{"abi":[{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"name":"AccessControlBadConfirmation","type":"error","inputs":[]},{"name":"AccessControlUnauthorizedAccount","type":"error","inputs":[{"name":"account","type":"address","internalType":"address"},{"name":"neededRole","type":"bytes32","internalType":"bytes32"}]},{"name":"AddressEmptyCode","type":"error","inputs":[{"name":"target","type":"address","internalType":"address"}]},{"name":"AmountOutOfRange","type":"error","inputs":[]},{"name":"AssetIsBadCollateral","type":"error","inputs":[{"name":"asset","type":"address","internalType":"address"}]},{"name":"AssetIsNotBadCollateral","type":"error","inputs":[{"name":"asset","type":"address","internalType":"address"}]},{"name":"AssetNotRegistered","type":"error","inputs":[{"name":"asset","type":"address","internalType":"address"}]},{"name":"BlacklistedWallet","type":"error","inputs":[]},{"name":"CapCanCauseDenialOfService","type":"error","inputs":[]},{"name":"ERC1967InvalidImplementation","type":"error","inputs":[{"name":"implementation","type":"address","internalType":"address"}]},{"name":"ERC1967NonPayable","type":"error","inputs":[]},{"name":"EnforcedPause","type":"error","inputs":[]},{"name":"ExceedGlobalCap","type":"error","inputs":[]},{"name":"ExceedRelativeCap","type":"error","inputs":[]},{"name":"ExpectedPause","type":"error","inputs":[]},{"name":"FailedCall","type":"error","inputs":[]},{"name":"InsufficientAssets","type":"error","inputs":[{"name":"assets","type":"uint256","internalType":"uint256"},{"name":"shares","type":"uint256","internalType":"uint256"}]},{"name":"InsufficientBalanceToPayPythFee","type":"error","inputs":[]},{"name":"InsufficientRecapitalizeAmount","type":"error","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"}]},{"name":"InvalidCustodyInfoInput","type":"error","inputs":[]},{"name":"InvalidInitialization","type":"error","inputs":[]},{"name":"LiquidationDisabled","type":"error","inputs":[]},{"name":"LiquidationWithReferenceCollateral","type":"error","inputs":[]},{"name":"MismatchedOwner","type":"error","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"expectedOwner","type":"address","internalType":"address"}]},{"name":"NotFactory","type":"error","inputs":[]},{"name":"NotInitializing","type":"error","inputs":[]},{"name":"NotPegged","type":"error","inputs":[{"name":"asset","type":"address","internalType":"address"}]},{"name":"OverOneHundredPercentRate","type":"error","inputs":[{"name":"rate","type":"uint256","internalType":"uint256"}]},{"name":"RecapitalizeNotNeeded","type":"error","inputs":[{"name":"asset","type":"address","internalType":"address"}]},{"name":"UUPSUnauthorizedCallContext","type":"error","inputs":[]},{"name":"UUPSUnsupportedProxiableUUID","type":"error","inputs":[{"name":"slot","type":"bytes32","internalType":"bytes32"}]},{"name":"UnauthorizedCaller","type":"error","inputs":[{"name":"caller","type":"address","internalType":"address"},{"name":"expectedCaller","type":"address","internalType":"address"}]},{"name":"UnderNinetyEightPercentRate","type":"error","inputs":[{"name":"rate","type":"uint256","internalType":"uint256"}]},{"name":"UnexpectedBasketModeStatus","type":"error","inputs":[]},{"name":"VaultAlreadyRegistered","type":"error","inputs":[{"name":"asset","type":"address","internalType":"address"}]},{"name":"VaultPaused","type":"error","inputs":[]},{"name":"ZeroAddress","type":"error","inputs":[]},{"name":"ZeroAmount","type":"error","inputs":[]},{"name":"ZeroWeight","type":"error","inputs":[{"name":"asset","type":"address","internalType":"address"}]},{"name":"BasketModeForced","type":"event","inputs":[{"name":"forced","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"CollateralAssetStatusSet","type":"event","inputs":[{"name":"asset","type":"address","indexed":true,"internalType":"address"},{"name":"isBadCollateral","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"CollectedFeeWithdrawn","type":"event","inputs":[{"name":"asset","type":"address","indexed":true,"internalType":"address"},{"name":"receiver","type":"address","indexed":true,"internalType":"address"},{"name":"shares","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"assets","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"DepegOffsetsSet","type":"event","inputs":[{"name":"asset","type":"address","indexed":false,"internalType":"address"},{"name":"lower","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"upper","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"FeeReceiverSet","type":"event","inputs":[{"name":"feeReceiver","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"GlobalCapSet","type":"event","inputs":[{"name":"globalCap","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"HoneyMinted","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"asset","type":"address","indexed":true,"internalType":"address"},{"name":"assetAmount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"mintAmount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"HoneyRedeemed","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"asset","type":"address","indexed":true,"internalType":"address"},{"name":"assetAmount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"redeemAmount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Initialized","type":"event","inputs":[{"name":"version","type":"uint64","indexed":false,"internalType":"uint64"}],"anonymous":false},{"name":"Liquidated","type":"event","inputs":[{"name":"badAsset","type":"address","indexed":false,"internalType":"address"},{"name":"goodAsset","type":"address","indexed":false,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"sender","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"LiquidationRateSet","type":"event","inputs":[{"name":"asset","type":"address","indexed":false,"internalType":"address"},{"name":"rate","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"LiquidationStatusSet","type":"event","inputs":[{"name":"enabled","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"MaxFeedDelaySet","type":"event","inputs":[{"name":"maxFeedDelay","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"MinSharesToRecapitalizeSet","type":"event","inputs":[{"name":"minShareAmount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"MintRateSet","type":"event","inputs":[{"name":"asset","type":"address","indexed":true,"internalType":"address"},{"name":"rate","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"POLFeeCollectorFeeRateSet","type":"event","inputs":[{"name":"rate","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"POLFeeCollectorSet","type":"event","inputs":[{"name":"polFeeCollector","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"Paused","type":"event","inputs":[{"name":"account","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"PriceFeedChanged","type":"event","inputs":[{"name":"asset","type":"address","indexed":true,"internalType":"address"},{"name":"id","type":"bytes32","indexed":false,"internalType":"bytes32"}],"anonymous":false},{"name":"PriceOracleSet","type":"event","inputs":[{"name":"oracle","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"RecapitalizeBalanceThresholdSet","type":"event","inputs":[{"name":"asset","type":"address","indexed":false,"internalType":"address"},{"name":"target","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Recapitalized","type":"event","inputs":[{"name":"asset","type":"address","indexed":false,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"sender","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"RedeemRateSet","type":"event","inputs":[{"name":"asset","type":"address","indexed":true,"internalType":"address"},{"name":"rate","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"ReferenceCollateralSet","type":"event","inputs":[{"name":"old","type":"address","indexed":false,"internalType":"address"},{"name":"asset","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"RelativeCapSet","type":"event","inputs":[{"name":"asset","type":"address","indexed":false,"internalType":"address"},{"name":"relativeCap","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"RoleAdminChanged","type":"event","inputs":[{"name":"role","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"previousAdminRole","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"newAdminRole","type":"bytes32","indexed":true,"internalType":"bytes32"}],"anonymous":false},{"name":"RoleGranted","type":"event","inputs":[{"name":"role","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"account","type":"address","indexed":true,"internalType":"address"},{"name":"sender","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"RoleRevoked","type":"event","inputs":[{"name":"role","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"account","type":"address","indexed":true,"internalType":"address"},{"name":"sender","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"Unpaused","type":"event","inputs":[{"name":"account","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"Upgraded","type":"event","inputs":[{"name":"implementation","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"VaultCreated","type":"event","inputs":[{"name":"vault","type":"address","indexed":true,"internalType":"address"},{"name":"asset","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"DEFAULT_ADMIN_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"MANAGER_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"PAUSER_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"UPGRADE_INTERFACE_VERSION","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"beacon","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"collectedAssetFees","type":"function","inputs":[{"name":"asset","type":"address","internalType":"address"}],"outputs":[{"name":"collectedFee","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"collectedFees","type":"function","inputs":[{"name":"receiver","type":"address","internalType":"address"},{"name":"asset","type":"address","internalType":"address"}],"outputs":[{"name":"collectedFee","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"createVault","type":"function","inputs":[{"name":"asset","type":"address","internalType":"address"}],"outputs":[{"name":"vault","type":"address","internalType":"contract ERC4626"}],"stateMutability":"nonpayable"},{"name":"feeReceiver","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"forcedBasketMode","type":"function","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"getRoleAdmin","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"getWeights","type":"function","inputs":[],"outputs":[{"name":"w","type":"uint256[]","internalType":"uint256[]"}],"stateMutability":"view"},{"name":"globalCap","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"grantRole","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"},{"name":"account","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"hasRole","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"},{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"honey","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract Honey"}],"stateMutability":"view"},{"name":"initialize","type":"function","inputs":[{"name":"_governance","type":"address","internalType":"address"},{"name":"_honey","type":"address","internalType":"address"},{"name":"_polFeeCollector","type":"address","internalType":"address"},{"name":"_feeReceiver","type":"address","internalType":"address"},{"name":"_priceOracle","type":"address","internalType":"address"},{"name":"_beacon","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"isBadCollateralAsset","type":"function","inputs":[{"name":"asset","type":"address","internalType":"address"}],"outputs":[{"name":"badCollateral","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"isBasketModeEnabled","type":"function","inputs":[{"name":"isMint","type":"bool","internalType":"bool"}],"outputs":[{"name":"basketMode","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"isPegged","type":"function","inputs":[{"name":"asset","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"liquidate","type":"function","inputs":[{"name":"badCollateral","type":"address","internalType":"address"},{"name":"goodCollateral","type":"address","internalType":"address"},{"name":"goodAmount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"badAmount","type":"uint256","internalType":"uint256"}],"stateMutability":"nonpayable"},{"name":"liquidationEnabled","type":"function","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"lowerPegOffsets","type":"function","inputs":[{"name":"asset","type":"address","internalType":"address"}],"outputs":[{"name":"lowerPegOffset","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"minSharesToRecapitalize","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"mint","type":"function","inputs":[{"name":"asset","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"receiver","type":"address","internalType":"address"},{"name":"expectBasketMode","type":"bool","internalType":"bool"}],"outputs":[{"name":"honeyToMint","type":"uint256","internalType":"uint256"}],"stateMutability":"nonpayable"},{"name":"mintRates","type":"function","inputs":[{"name":"asset","type":"address","internalType":"address"}],"outputs":[{"name":"rate","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"numRegisteredAssets","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"pause","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"pauseVault","type":"function","inputs":[{"name":"asset","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"paused","type":"function","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"polFeeCollector","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"polFeeCollectorFeeRate","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"priceOracle","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IPriceOracle"}],"stateMutability":"view"},{"name":"proxiableUUID","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"recapitalize","type":"function","inputs":[{"name":"asset","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"recapitalizeBalanceThreshold","type":"function","inputs":[{"name":"asset","type":"address","internalType":"address"}],"outputs":[{"name":"targetBalance","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"redeem","type":"function","inputs":[{"name":"asset","type":"address","internalType":"address"},{"name":"honeyAmount","type":"uint256","internalType":"uint256"},{"name":"receiver","type":"address","internalType":"address"},{"name":"expectBasketMode","type":"bool","internalType":"bool"}],"outputs":[{"name":"redeemed","type":"uint256[]","internalType":"uint256[]"}],"stateMutability":"nonpayable"},{"name":"redeemRates","type":"function","inputs":[{"name":"asset","type":"address","internalType":"address"}],"outputs":[{"name":"rate","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"referenceCollateral","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"registeredAssets","type":"function","inputs":[{"name":"","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"relativeCap","type":"function","inputs":[{"name":"asset","type":"address","internalType":"address"}],"outputs":[{"name":"limit","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"renounceRole","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"},{"name":"callerConfirmation","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"revokeRole","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"},{"name":"account","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setCollateralAssetStatus","type":"function","inputs":[{"name":"asset","type":"address","internalType":"address"},{"name":"_isBadCollateral","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setCustodyInfo","type":"function","inputs":[{"name":"asset","type":"address","internalType":"address"},{"name":"isCustodyVault","type":"bool","internalType":"bool"},{"name":"custodyAddress","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setDepegOffsets","type":"function","inputs":[{"name":"asset","type":"address","internalType":"address"},{"name":"lowerOffset","type":"uint256","internalType":"uint256"},{"name":"upperOffset","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setFeeReceiver","type":"function","inputs":[{"name":"_feeReceiver","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setForcedBasketMode","type":"function","inputs":[{"name":"forced","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setGlobalCap","type":"function","inputs":[{"name":"limit","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setLiquidationEnabled","type":"function","inputs":[{"name":"enabled","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setLiquidationRate","type":"function","inputs":[{"name":"asset","type":"address","internalType":"address"},{"name":"extraRate","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setMinSharesToRecapitalize","type":"function","inputs":[{"name":"minSharesAmount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setMintRate","type":"function","inputs":[{"name":"asset","type":"address","internalType":"address"},{"name":"mintRate","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setPOLFeeCollector","type":"function","inputs":[{"name":"_polFeeCollector","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setPOLFeeCollectorFeeRate","type":"function","inputs":[{"name":"_polFeeCollectorFeeRate","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setPriceOracle","type":"function","inputs":[{"name":"priceOracle_","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setRecapitalizeBalanceThreshold","type":"function","inputs":[{"name":"asset","type":"address","internalType":"address"},{"name":"target","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setRedeemRate","type":"function","inputs":[{"name":"asset","type":"address","internalType":"address"},{"name":"redeemRate","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setReferenceCollateral","type":"function","inputs":[{"name":"asset","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setRelativeCap","type":"function","inputs":[{"name":"asset","type":"address","internalType":"address"},{"name":"limit","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"supportsInterface","type":"function","inputs":[{"name":"interfaceId","type":"bytes4","internalType":"bytes4"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"unpause","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"unpauseVault","type":"function","inputs":[{"name":"asset","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"upgradeToAndCall","type":"function","inputs":[{"name":"newImplementation","type":"address","internalType":"address"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"payable"},{"name":"upperPegOffsets","type":"function","inputs":[{"name":"asset","type":"address","internalType":"address"}],"outputs":[{"name":"upperPegOffset","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"vaults","type":"function","inputs":[{"name":"asset","type":"address","internalType":"address"}],"outputs":[{"name":"vault","type":"address","internalType":"contract CollateralVault"}],"stateMutability":"view"},{"name":"withdrawAllFees","type":"function","inputs":[{"name":"receiver","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"withdrawFee","type":"function","inputs":[{"name":"asset","type":"address","internalType":"address"},{"name":"receiver","type":"address","internalType":"address"}],"outputs":[{"name":"assets","type":"uint256","internalType":"uint256"}],"stateMutability":"nonpayable"}],"sources":{"lib/solady/src/tokens/ERC20.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Simple ERC20 + EIP-2612 implementation.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/tokens/ERC20.sol)\n/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC20.sol)\n/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol)\n///\n/// @dev Note:\n/// - The ERC20 standard allows minting and transferring to and from the zero address,\n/// minting and transferring zero tokens, as well as self-approvals.\n/// For performance, this implementation WILL NOT revert for such actions.\n/// Please add any checks with overrides if desired.\n/// - The `permit` function uses the ecrecover precompile (0x1).\n///\n/// If you are overriding:\n/// - NEVER violate the ERC20 invariant:\n/// the total sum of all balances must be equal to `totalSupply()`.\n/// - Check that the overridden function is actually used in the function you want to\n/// change the behavior of. Much of the code has been manually inlined for performance.\nabstract contract ERC20 {\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* CUSTOM ERRORS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev The total supply has overflowed.\n error TotalSupplyOverflow();\n\n /// @dev The allowance has overflowed.\n error AllowanceOverflow();\n\n /// @dev The allowance has underflowed.\n error AllowanceUnderflow();\n\n /// @dev Insufficient balance.\n error InsufficientBalance();\n\n /// @dev Insufficient allowance.\n error InsufficientAllowance();\n\n /// @dev The permit is invalid.\n error InvalidPermit();\n\n /// @dev The permit has expired.\n error PermitExpired();\n\n /// @dev The allowance of Permit2 is fixed at infinity.\n error Permit2AllowanceIsFixedAtInfinity();\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* EVENTS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Emitted when `amount` tokens is transferred from `from` to `to`.\n event Transfer(address indexed from, address indexed to, uint256 amount);\n\n /// @dev Emitted when `amount` tokens is approved by `owner` to be used by `spender`.\n event Approval(address indexed owner, address indexed spender, uint256 amount);\n\n /// @dev `keccak256(bytes(\"Transfer(address,address,uint256)\"))`.\n uint256 private constant _TRANSFER_EVENT_SIGNATURE =\n 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;\n\n /// @dev `keccak256(bytes(\"Approval(address,address,uint256)\"))`.\n uint256 private constant _APPROVAL_EVENT_SIGNATURE =\n 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925;\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* STORAGE */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev The storage slot for the total supply.\n uint256 private constant _TOTAL_SUPPLY_SLOT = 0x05345cdf77eb68f44c;\n\n /// @dev The balance slot of `owner` is given by:\n /// ```\n /// mstore(0x0c, _BALANCE_SLOT_SEED)\n /// mstore(0x00, owner)\n /// let balanceSlot := keccak256(0x0c, 0x20)\n /// ```\n uint256 private constant _BALANCE_SLOT_SEED = 0x87a211a2;\n\n /// @dev The allowance slot of (`owner`, `spender`) is given by:\n /// ```\n /// mstore(0x20, spender)\n /// mstore(0x0c, _ALLOWANCE_SLOT_SEED)\n /// mstore(0x00, owner)\n /// let allowanceSlot := keccak256(0x0c, 0x34)\n /// ```\n uint256 private constant _ALLOWANCE_SLOT_SEED = 0x7f5e9f20;\n\n /// @dev The nonce slot of `owner` is given by:\n /// ```\n /// mstore(0x0c, _NONCES_SLOT_SEED)\n /// mstore(0x00, owner)\n /// let nonceSlot := keccak256(0x0c, 0x20)\n /// ```\n uint256 private constant _NONCES_SLOT_SEED = 0x38377508;\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* CONSTANTS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev `(_NONCES_SLOT_SEED << 16) | 0x1901`.\n uint256 private constant _NONCES_SLOT_SEED_WITH_SIGNATURE_PREFIX = 0x383775081901;\n\n /// @dev `keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\")`.\n bytes32 private constant _DOMAIN_TYPEHASH =\n 0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f;\n\n /// @dev `keccak256(\"1\")`.\n /// If you need to use a different version, override `_versionHash`.\n bytes32 private constant _DEFAULT_VERSION_HASH =\n 0xc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc6;\n\n /// @dev `keccak256(\"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\")`.\n bytes32 private constant _PERMIT_TYPEHASH =\n 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;\n\n /// @dev The canonical Permit2 address.\n /// For signature-based allowance granting for single transaction ERC20 `transferFrom`.\n /// To enable, override `_givePermit2InfiniteAllowance()`.\n /// [Github](https://github.com/Uniswap/permit2)\n /// [Etherscan](https://etherscan.io/address/0x000000000022D473030F116dDEE9F6B43aC78BA3)\n address internal constant _PERMIT2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* ERC20 METADATA */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Returns the name of the token.\n function name() public view virtual returns (string memory);\n\n /// @dev Returns the symbol of the token.\n function symbol() public view virtual returns (string memory);\n\n /// @dev Returns the decimals places of the token.\n function decimals() public view virtual returns (uint8) {\n return 18;\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* ERC20 */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Returns the amount of tokens in existence.\n function totalSupply() public view virtual returns (uint256 result) {\n /// @solidity memory-safe-assembly\n assembly {\n result := sload(_TOTAL_SUPPLY_SLOT)\n }\n }\n\n /// @dev Returns the amount of tokens owned by `owner`.\n function balanceOf(address owner) public view virtual returns (uint256 result) {\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x0c, _BALANCE_SLOT_SEED)\n mstore(0x00, owner)\n result := sload(keccak256(0x0c, 0x20))\n }\n }\n\n /// @dev Returns the amount of tokens that `spender` can spend on behalf of `owner`.\n function allowance(address owner, address spender)\n public\n view\n virtual\n returns (uint256 result)\n {\n if (_givePermit2InfiniteAllowance()) {\n if (spender == _PERMIT2) return type(uint256).max;\n }\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x20, spender)\n mstore(0x0c, _ALLOWANCE_SLOT_SEED)\n mstore(0x00, owner)\n result := sload(keccak256(0x0c, 0x34))\n }\n }\n\n /// @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n ///\n /// Emits a {Approval} event.\n function approve(address spender, uint256 amount) public virtual returns (bool) {\n if (_givePermit2InfiniteAllowance()) {\n /// @solidity memory-safe-assembly\n assembly {\n // If `spender == _PERMIT2 && amount != type(uint256).max`.\n if iszero(or(xor(shr(96, shl(96, spender)), _PERMIT2), iszero(not(amount)))) {\n mstore(0x00, 0x3f68539a) // `Permit2AllowanceIsFixedAtInfinity()`.\n revert(0x1c, 0x04)\n }\n }\n }\n /// @solidity memory-safe-assembly\n assembly {\n // Compute the allowance slot and store the amount.\n mstore(0x20, spender)\n mstore(0x0c, _ALLOWANCE_SLOT_SEED)\n mstore(0x00, caller())\n sstore(keccak256(0x0c, 0x34), amount)\n // Emit the {Approval} event.\n mstore(0x00, amount)\n log3(0x00, 0x20, _APPROVAL_EVENT_SIGNATURE, caller(), shr(96, mload(0x2c)))\n }\n return true;\n }\n\n /// @dev Transfer `amount` tokens from the caller to `to`.\n ///\n /// Requirements:\n /// - `from` must at least have `amount`.\n ///\n /// Emits a {Transfer} event.\n function transfer(address to, uint256 amount) public virtual returns (bool) {\n _beforeTokenTransfer(msg.sender, to, amount);\n /// @solidity memory-safe-assembly\n assembly {\n // Compute the balance slot and load its value.\n mstore(0x0c, _BALANCE_SLOT_SEED)\n mstore(0x00, caller())\n let fromBalanceSlot := keccak256(0x0c, 0x20)\n let fromBalance := sload(fromBalanceSlot)\n // Revert if insufficient balance.\n if gt(amount, fromBalance) {\n mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.\n revert(0x1c, 0x04)\n }\n // Subtract and store the updated balance.\n sstore(fromBalanceSlot, sub(fromBalance, amount))\n // Compute the balance slot of `to`.\n mstore(0x00, to)\n let toBalanceSlot := keccak256(0x0c, 0x20)\n // Add and store the updated balance of `to`.\n // Will not overflow because the sum of all user balances\n // cannot exceed the maximum uint256 value.\n sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))\n // Emit the {Transfer} event.\n mstore(0x20, amount)\n log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, caller(), shr(96, mload(0x0c)))\n }\n _afterTokenTransfer(msg.sender, to, amount);\n return true;\n }\n\n /// @dev Transfers `amount` tokens from `from` to `to`.\n ///\n /// Note: Does not update the allowance if it is the maximum uint256 value.\n ///\n /// Requirements:\n /// - `from` must at least have `amount`.\n /// - The caller must have at least `amount` of allowance to transfer the tokens of `from`.\n ///\n /// Emits a {Transfer} event.\n function transferFrom(address from, address to, uint256 amount) public virtual returns (bool) {\n _beforeTokenTransfer(from, to, amount);\n // Code duplication is for zero-cost abstraction if possible.\n if (_givePermit2InfiniteAllowance()) {\n /// @solidity memory-safe-assembly\n assembly {\n let from_ := shl(96, from)\n if iszero(eq(caller(), _PERMIT2)) {\n // Compute the allowance slot and load its value.\n mstore(0x20, caller())\n mstore(0x0c, or(from_, _ALLOWANCE_SLOT_SEED))\n let allowanceSlot := keccak256(0x0c, 0x34)\n let allowance_ := sload(allowanceSlot)\n // If the allowance is not the maximum uint256 value.\n if not(allowance_) {\n // Revert if the amount to be transferred exceeds the allowance.\n if gt(amount, allowance_) {\n mstore(0x00, 0x13be252b) // `InsufficientAllowance()`.\n revert(0x1c, 0x04)\n }\n // Subtract and store the updated allowance.\n sstore(allowanceSlot, sub(allowance_, amount))\n }\n }\n // Compute the balance slot and load its value.\n mstore(0x0c, or(from_, _BALANCE_SLOT_SEED))\n let fromBalanceSlot := keccak256(0x0c, 0x20)\n let fromBalance := sload(fromBalanceSlot)\n // Revert if insufficient balance.\n if gt(amount, fromBalance) {\n mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.\n revert(0x1c, 0x04)\n }\n // Subtract and store the updated balance.\n sstore(fromBalanceSlot, sub(fromBalance, amount))\n // Compute the balance slot of `to`.\n mstore(0x00, to)\n let toBalanceSlot := keccak256(0x0c, 0x20)\n // Add and store the updated balance of `to`.\n // Will not overflow because the sum of all user balances\n // cannot exceed the maximum uint256 value.\n sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))\n // Emit the {Transfer} event.\n mstore(0x20, amount)\n log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, from_), shr(96, mload(0x0c)))\n }\n } else {\n /// @solidity memory-safe-assembly\n assembly {\n let from_ := shl(96, from)\n // Compute the allowance slot and load its value.\n mstore(0x20, caller())\n mstore(0x0c, or(from_, _ALLOWANCE_SLOT_SEED))\n let allowanceSlot := keccak256(0x0c, 0x34)\n let allowance_ := sload(allowanceSlot)\n // If the allowance is not the maximum uint256 value.\n if not(allowance_) {\n // Revert if the amount to be transferred exceeds the allowance.\n if gt(amount, allowance_) {\n mstore(0x00, 0x13be252b) // `InsufficientAllowance()`.\n revert(0x1c, 0x04)\n }\n // Subtract and store the updated allowance.\n sstore(allowanceSlot, sub(allowance_, amount))\n }\n // Compute the balance slot and load its value.\n mstore(0x0c, or(from_, _BALANCE_SLOT_SEED))\n let fromBalanceSlot := keccak256(0x0c, 0x20)\n let fromBalance := sload(fromBalanceSlot)\n // Revert if insufficient balance.\n if gt(amount, fromBalance) {\n mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.\n revert(0x1c, 0x04)\n }\n // Subtract and store the updated balance.\n sstore(fromBalanceSlot, sub(fromBalance, amount))\n // Compute the balance slot of `to`.\n mstore(0x00, to)\n let toBalanceSlot := keccak256(0x0c, 0x20)\n // Add and store the updated balance of `to`.\n // Will not overflow because the sum of all user balances\n // cannot exceed the maximum uint256 value.\n sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))\n // Emit the {Transfer} event.\n mstore(0x20, amount)\n log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, from_), shr(96, mload(0x0c)))\n }\n }\n _afterTokenTransfer(from, to, amount);\n return true;\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* EIP-2612 */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev For more performance, override to return the constant value\n /// of `keccak256(bytes(name()))` if `name()` will never change.\n function _constantNameHash() internal view virtual returns (bytes32 result) {}\n\n /// @dev If you need a different value, override this function.\n function _versionHash() internal view virtual returns (bytes32 result) {\n result = _DEFAULT_VERSION_HASH;\n }\n\n /// @dev For inheriting contracts to increment the nonce.\n function _incrementNonce(address owner) internal virtual {\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x0c, _NONCES_SLOT_SEED)\n mstore(0x00, owner)\n let nonceSlot := keccak256(0x0c, 0x20)\n sstore(nonceSlot, add(1, sload(nonceSlot)))\n }\n }\n\n /// @dev Returns the current nonce for `owner`.\n /// This value is used to compute the signature for EIP-2612 permit.\n function nonces(address owner) public view virtual returns (uint256 result) {\n /// @solidity memory-safe-assembly\n assembly {\n // Compute the nonce slot and load its value.\n mstore(0x0c, _NONCES_SLOT_SEED)\n mstore(0x00, owner)\n result := sload(keccak256(0x0c, 0x20))\n }\n }\n\n /// @dev Sets `value` as the allowance of `spender` over the tokens of `owner`,\n /// authorized by a signed approval by `owner`.\n ///\n /// Emits a {Approval} event.\n function permit(\n address owner,\n address spender,\n uint256 value,\n uint256 deadline,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) public virtual {\n if (_givePermit2InfiniteAllowance()) {\n /// @solidity memory-safe-assembly\n assembly {\n // If `spender == _PERMIT2 && value != type(uint256).max`.\n if iszero(or(xor(shr(96, shl(96, spender)), _PERMIT2), iszero(not(value)))) {\n mstore(0x00, 0x3f68539a) // `Permit2AllowanceIsFixedAtInfinity()`.\n revert(0x1c, 0x04)\n }\n }\n }\n bytes32 nameHash = _constantNameHash();\n // We simply calculate it on-the-fly to allow for cases where the `name` may change.\n if (nameHash == bytes32(0)) nameHash = keccak256(bytes(name()));\n bytes32 versionHash = _versionHash();\n /// @solidity memory-safe-assembly\n assembly {\n // Revert if the block timestamp is greater than `deadline`.\n if gt(timestamp(), deadline) {\n mstore(0x00, 0x1a15a3cc) // `PermitExpired()`.\n revert(0x1c, 0x04)\n }\n let m := mload(0x40) // Grab the free memory pointer.\n // Clean the upper 96 bits.\n owner := shr(96, shl(96, owner))\n spender := shr(96, shl(96, spender))\n // Compute the nonce slot and load its value.\n mstore(0x0e, _NONCES_SLOT_SEED_WITH_SIGNATURE_PREFIX)\n mstore(0x00, owner)\n let nonceSlot := keccak256(0x0c, 0x20)\n let nonceValue := sload(nonceSlot)\n // Prepare the domain separator.\n mstore(m, _DOMAIN_TYPEHASH)\n mstore(add(m, 0x20), nameHash)\n mstore(add(m, 0x40), versionHash)\n mstore(add(m, 0x60), chainid())\n mstore(add(m, 0x80), address())\n mstore(0x2e, keccak256(m, 0xa0))\n // Prepare the struct hash.\n mstore(m, _PERMIT_TYPEHASH)\n mstore(add(m, 0x20), owner)\n mstore(add(m, 0x40), spender)\n mstore(add(m, 0x60), value)\n mstore(add(m, 0x80), nonceValue)\n mstore(add(m, 0xa0), deadline)\n mstore(0x4e, keccak256(m, 0xc0))\n // Prepare the ecrecover calldata.\n mstore(0x00, keccak256(0x2c, 0x42))\n mstore(0x20, and(0xff, v))\n mstore(0x40, r)\n mstore(0x60, s)\n let t := staticcall(gas(), 1, 0x00, 0x80, 0x20, 0x20)\n // If the ecrecover fails, the returndatasize will be 0x00,\n // `owner` will be checked if it equals the hash at 0x00,\n // which evaluates to false (i.e. 0), and we will revert.\n // If the ecrecover succeeds, the returndatasize will be 0x20,\n // `owner` will be compared against the returned address at 0x20.\n if iszero(eq(mload(returndatasize()), owner)) {\n mstore(0x00, 0xddafbaef) // `InvalidPermit()`.\n revert(0x1c, 0x04)\n }\n // Increment and store the updated nonce.\n sstore(nonceSlot, add(nonceValue, t)) // `t` is 1 if ecrecover succeeds.\n // Compute the allowance slot and store the value.\n // The `owner` is already at slot 0x20.\n mstore(0x40, or(shl(160, _ALLOWANCE_SLOT_SEED), spender))\n sstore(keccak256(0x2c, 0x34), value)\n // Emit the {Approval} event.\n log3(add(m, 0x60), 0x20, _APPROVAL_EVENT_SIGNATURE, owner, spender)\n mstore(0x40, m) // Restore the free memory pointer.\n mstore(0x60, 0) // Restore the zero pointer.\n }\n }\n\n /// @dev Returns the EIP-712 domain separator for the EIP-2612 permit.\n function DOMAIN_SEPARATOR() public view virtual returns (bytes32 result) {\n bytes32 nameHash = _constantNameHash();\n // We simply calculate it on-the-fly to allow for cases where the `name` may change.\n if (nameHash == bytes32(0)) nameHash = keccak256(bytes(name()));\n bytes32 versionHash = _versionHash();\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40) // Grab the free memory pointer.\n mstore(m, _DOMAIN_TYPEHASH)\n mstore(add(m, 0x20), nameHash)\n mstore(add(m, 0x40), versionHash)\n mstore(add(m, 0x60), chainid())\n mstore(add(m, 0x80), address())\n result := keccak256(m, 0xa0)\n }\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* INTERNAL MINT FUNCTIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Mints `amount` tokens to `to`, increasing the total supply.\n ///\n /// Emits a {Transfer} event.\n function _mint(address to, uint256 amount) internal virtual {\n _beforeTokenTransfer(address(0), to, amount);\n /// @solidity memory-safe-assembly\n assembly {\n let totalSupplyBefore := sload(_TOTAL_SUPPLY_SLOT)\n let totalSupplyAfter := add(totalSupplyBefore, amount)\n // Revert if the total supply overflows.\n if lt(totalSupplyAfter, totalSupplyBefore) {\n mstore(0x00, 0xe5cfe957) // `TotalSupplyOverflow()`.\n revert(0x1c, 0x04)\n }\n // Store the updated total supply.\n sstore(_TOTAL_SUPPLY_SLOT, totalSupplyAfter)\n // Compute the balance slot and load its value.\n mstore(0x0c, _BALANCE_SLOT_SEED)\n mstore(0x00, to)\n let toBalanceSlot := keccak256(0x0c, 0x20)\n // Add and store the updated balance.\n sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))\n // Emit the {Transfer} event.\n mstore(0x20, amount)\n log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, 0, shr(96, mload(0x0c)))\n }\n _afterTokenTransfer(address(0), to, amount);\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* INTERNAL BURN FUNCTIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Burns `amount` tokens from `from`, reducing the total supply.\n ///\n /// Emits a {Transfer} event.\n function _burn(address from, uint256 amount) internal virtual {\n _beforeTokenTransfer(from, address(0), amount);\n /// @solidity memory-safe-assembly\n assembly {\n // Compute the balance slot and load its value.\n mstore(0x0c, _BALANCE_SLOT_SEED)\n mstore(0x00, from)\n let fromBalanceSlot := keccak256(0x0c, 0x20)\n let fromBalance := sload(fromBalanceSlot)\n // Revert if insufficient balance.\n if gt(amount, fromBalance) {\n mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.\n revert(0x1c, 0x04)\n }\n // Subtract and store the updated balance.\n sstore(fromBalanceSlot, sub(fromBalance, amount))\n // Subtract and store the updated total supply.\n sstore(_TOTAL_SUPPLY_SLOT, sub(sload(_TOTAL_SUPPLY_SLOT), amount))\n // Emit the {Transfer} event.\n mstore(0x00, amount)\n log3(0x00, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, shl(96, from)), 0)\n }\n _afterTokenTransfer(from, address(0), amount);\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* INTERNAL TRANSFER FUNCTIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Moves `amount` of tokens from `from` to `to`.\n function _transfer(address from, address to, uint256 amount) internal virtual {\n _beforeTokenTransfer(from, to, amount);\n /// @solidity memory-safe-assembly\n assembly {\n let from_ := shl(96, from)\n // Compute the balance slot and load its value.\n mstore(0x0c, or(from_, _BALANCE_SLOT_SEED))\n let fromBalanceSlot := keccak256(0x0c, 0x20)\n let fromBalance := sload(fromBalanceSlot)\n // Revert if insufficient balance.\n if gt(amount, fromBalance) {\n mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.\n revert(0x1c, 0x04)\n }\n // Subtract and store the updated balance.\n sstore(fromBalanceSlot, sub(fromBalance, amount))\n // Compute the balance slot of `to`.\n mstore(0x00, to)\n let toBalanceSlot := keccak256(0x0c, 0x20)\n // Add and store the updated balance of `to`.\n // Will not overflow because the sum of all user balances\n // cannot exceed the maximum uint256 value.\n sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))\n // Emit the {Transfer} event.\n mstore(0x20, amount)\n log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, from_), shr(96, mload(0x0c)))\n }\n _afterTokenTransfer(from, to, amount);\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* INTERNAL ALLOWANCE FUNCTIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Updates the allowance of `owner` for `spender` based on spent `amount`.\n function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {\n if (_givePermit2InfiniteAllowance()) {\n if (spender == _PERMIT2) return; // Do nothing, as allowance is infinite.\n }\n /// @solidity memory-safe-assembly\n assembly {\n // Compute the allowance slot and load its value.\n mstore(0x20, spender)\n mstore(0x0c, _ALLOWANCE_SLOT_SEED)\n mstore(0x00, owner)\n let allowanceSlot := keccak256(0x0c, 0x34)\n let allowance_ := sload(allowanceSlot)\n // If the allowance is not the maximum uint256 value.\n if not(allowance_) {\n // Revert if the amount to be transferred exceeds the allowance.\n if gt(amount, allowance_) {\n mstore(0x00, 0x13be252b) // `InsufficientAllowance()`.\n revert(0x1c, 0x04)\n }\n // Subtract and store the updated allowance.\n sstore(allowanceSlot, sub(allowance_, amount))\n }\n }\n }\n\n /// @dev Sets `amount` as the allowance of `spender` over the tokens of `owner`.\n ///\n /// Emits a {Approval} event.\n function _approve(address owner, address spender, uint256 amount) internal virtual {\n if (_givePermit2InfiniteAllowance()) {\n /// @solidity memory-safe-assembly\n assembly {\n // If `spender == _PERMIT2 && amount != type(uint256).max`.\n if iszero(or(xor(shr(96, shl(96, spender)), _PERMIT2), iszero(not(amount)))) {\n mstore(0x00, 0x3f68539a) // `Permit2AllowanceIsFixedAtInfinity()`.\n revert(0x1c, 0x04)\n }\n }\n }\n /// @solidity memory-safe-assembly\n assembly {\n let owner_ := shl(96, owner)\n // Compute the allowance slot and store the amount.\n mstore(0x20, spender)\n mstore(0x0c, or(owner_, _ALLOWANCE_SLOT_SEED))\n sstore(keccak256(0x0c, 0x34), amount)\n // Emit the {Approval} event.\n mstore(0x00, amount)\n log3(0x00, 0x20, _APPROVAL_EVENT_SIGNATURE, shr(96, owner_), shr(96, mload(0x2c)))\n }\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* HOOKS TO OVERRIDE */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Hook that is called before any transfer of tokens.\n /// This includes minting and burning.\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n\n /// @dev Hook that is called after any transfer of tokens.\n /// This includes minting and burning.\n function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* PERMIT2 */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Returns whether to fix the Permit2 contract's allowance at infinity.\n ///\n /// This value should be kept constant after contract initialization,\n /// or else the actual allowance values may not match with the {Approval} events.\n /// For best performance, return a compile-time constant for zero-cost abstraction.\n function _givePermit2InfiniteAllowance() internal view virtual returns (bool) {\n return false;\n }\n}\n"},"lib/solady/src/tokens/ERC4626.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\nimport {ERC20} from \"./ERC20.sol\";\nimport {FixedPointMathLib} from \"../utils/FixedPointMathLib.sol\";\nimport {SafeTransferLib} from \"../utils/SafeTransferLib.sol\";\n\n/// @notice Simple ERC4626 tokenized Vault implementation.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/tokens/ERC4626.sol)\n/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/mixins/ERC4626.sol)\n/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/extensions/ERC4626.sol)\nabstract contract ERC4626 is ERC20 {\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* CONSTANTS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev The default underlying decimals.\n uint8 internal constant _DEFAULT_UNDERLYING_DECIMALS = 18;\n\n /// @dev The default decimals offset.\n uint8 internal constant _DEFAULT_DECIMALS_OFFSET = 0;\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* CUSTOM ERRORS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Cannot deposit more than the max limit.\n error DepositMoreThanMax();\n\n /// @dev Cannot mint more than the max limit.\n error MintMoreThanMax();\n\n /// @dev Cannot withdraw more than the max limit.\n error WithdrawMoreThanMax();\n\n /// @dev Cannot redeem more than the max limit.\n error RedeemMoreThanMax();\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* EVENTS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Emitted during a mint call or deposit call.\n event Deposit(address indexed by, address indexed owner, uint256 assets, uint256 shares);\n\n /// @dev Emitted during a withdraw call or redeem call.\n event Withdraw(\n address indexed by,\n address indexed to,\n address indexed owner,\n uint256 assets,\n uint256 shares\n );\n\n /// @dev `keccak256(bytes(\"Deposit(address,address,uint256,uint256)\"))`.\n uint256 private constant _DEPOSIT_EVENT_SIGNATURE =\n 0xdcbc1c05240f31ff3ad067ef1ee35ce4997762752e3a095284754544f4c709d7;\n\n /// @dev `keccak256(bytes(\"Withdraw(address,address,address,uint256,uint256)\"))`.\n uint256 private constant _WITHDRAW_EVENT_SIGNATURE =\n 0xfbde797d201c681b91056529119e0b02407c7bb96a4a2c75c01fc9667232c8db;\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* ERC4626 CONSTANTS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev To be overridden to return the address of the underlying asset.\n ///\n /// - MUST be an ERC20 token contract.\n /// - MUST NOT revert.\n function asset() public view virtual returns (address);\n\n /// @dev To be overridden to return the number of decimals of the underlying asset.\n /// Default: 18.\n ///\n /// - MUST NOT revert.\n function _underlyingDecimals() internal view virtual returns (uint8) {\n return _DEFAULT_UNDERLYING_DECIMALS;\n }\n\n /// @dev Override to return a non-zero value to make the inflation attack even more unfeasible.\n /// Only used when {_useVirtualShares} returns true.\n /// Default: 0.\n ///\n /// - MUST NOT revert.\n function _decimalsOffset() internal view virtual returns (uint8) {\n return _DEFAULT_DECIMALS_OFFSET;\n }\n\n /// @dev Returns whether virtual shares will be used to mitigate the inflation attack.\n /// See: https://github.com/OpenZeppelin/openzeppelin-contracts/issues/3706\n /// Override to return true or false.\n /// Default: true.\n ///\n /// - MUST NOT revert.\n function _useVirtualShares() internal view virtual returns (bool) {\n return true;\n }\n\n /// @dev Returns the decimals places of the token.\n ///\n /// - MUST NOT revert.\n function decimals() public view virtual override(ERC20) returns (uint8) {\n if (!_useVirtualShares()) return _underlyingDecimals();\n return _underlyingDecimals() + _decimalsOffset();\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* ASSET DECIMALS GETTER HELPER */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Helper function to get the decimals of the underlying asset.\n /// Useful for setting the return value of `_underlyingDecimals` during initialization.\n /// If the retrieval succeeds, `success` will be true, and `result` will hold the result.\n /// Otherwise, `success` will be false, and `result` will be zero.\n ///\n /// Example usage:\n /// ```\n /// (bool success, uint8 result) = _tryGetAssetDecimals(underlying);\n /// _decimals = success ? result : _DEFAULT_UNDERLYING_DECIMALS;\n /// ```\n function _tryGetAssetDecimals(address underlying)\n internal\n view\n returns (bool success, uint8 result)\n {\n /// @solidity memory-safe-assembly\n assembly {\n // Store the function selector of `decimals()`.\n mstore(0x00, 0x313ce567)\n // Arguments are evaluated last to first.\n success :=\n and(\n // Returned value is less than 256, at left-padded to 32 bytes.\n and(lt(mload(0x00), 0x100), gt(returndatasize(), 0x1f)),\n // The staticcall succeeds.\n staticcall(gas(), underlying, 0x1c, 0x04, 0x00, 0x20)\n )\n result := mul(mload(0x00), success)\n }\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* ACCOUNTING LOGIC */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Returns the total amount of the underlying asset managed by the Vault.\n ///\n /// - SHOULD include any compounding that occurs from the yield.\n /// - MUST be inclusive of any fees that are charged against assets in the Vault.\n /// - MUST NOT revert.\n function totalAssets() public view virtual returns (uint256 assets) {\n assets = SafeTransferLib.balanceOf(asset(), address(this));\n }\n\n /// @dev Returns the amount of shares that the Vault will exchange for the amount of\n /// assets provided, in an ideal scenario where all 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, during the actual exchange.\n /// - MUST NOT revert.\n ///\n /// Note: This calculation MAY NOT reflect the \"per-user\" price-per-share, and instead\n /// should reflect the \"average-user's\" price-per-share, i.e. what the average user should\n /// expect to see when exchanging to and from.\n function convertToShares(uint256 assets) public view virtual returns (uint256 shares) {\n if (!_useVirtualShares()) {\n uint256 supply = totalSupply();\n return _eitherIsZero(assets, supply)\n ? _initialConvertToShares(assets)\n : FixedPointMathLib.fullMulDiv(assets, supply, totalAssets());\n }\n uint256 o = _decimalsOffset();\n if (o == uint256(0)) {\n return FixedPointMathLib.fullMulDiv(assets, totalSupply() + 1, _inc(totalAssets()));\n }\n return FixedPointMathLib.fullMulDiv(assets, totalSupply() + 10 ** o, _inc(totalAssets()));\n }\n\n /// @dev Returns the amount of assets that the Vault will exchange for the amount of\n /// shares provided, in an ideal scenario where all 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, during the actual exchange.\n /// - MUST NOT revert.\n ///\n /// Note: This calculation MAY NOT reflect the \"per-user\" price-per-share, and instead\n /// should reflect the \"average-user's\" price-per-share, i.e. what the average user should\n /// expect to see when exchanging to and from.\n function convertToAssets(uint256 shares) public view virtual returns (uint256 assets) {\n if (!_useVirtualShares()) {\n uint256 supply = totalSupply();\n return supply == uint256(0)\n ? _initialConvertToAssets(shares)\n : FixedPointMathLib.fullMulDiv(shares, totalAssets(), supply);\n }\n uint256 o = _decimalsOffset();\n if (o == uint256(0)) {\n return FixedPointMathLib.fullMulDiv(shares, totalAssets() + 1, _inc(totalSupply()));\n }\n return FixedPointMathLib.fullMulDiv(shares, totalAssets() + 1, totalSupply() + 10 ** o);\n }\n\n /// @dev Allows an on-chain or off-chain user to simulate the effects of their deposit\n /// at the current block, given current on-chain conditions.\n ///\n /// - MUST return as close to and no more than the exact amount of Vault shares that\n /// will be minted in a deposit call in the same transaction, i.e. deposit should\n /// return the same or more shares as `previewDeposit` if call in the same transaction.\n /// - MUST NOT account for deposit limits like those returned from `maxDeposit` and should\n /// always act as if the deposit will be accepted, regardless of approvals, etc.\n /// - MUST be inclusive of deposit fees. Integrators should be aware of this.\n /// - MUST not revert.\n ///\n /// Note: Any unfavorable discrepancy between `convertToShares` and `previewDeposit` SHOULD\n /// be considered slippage in share price or some other type of condition, meaning\n /// the depositor will lose assets by depositing.\n function previewDeposit(uint256 assets) public view virtual returns (uint256 shares) {\n shares = convertToShares(assets);\n }\n\n /// @dev Allows an on-chain or off-chain user to simulate the effects of their mint\n /// at the current block, given current on-chain conditions.\n ///\n /// - MUST return as close to and no fewer than the exact amount of assets that\n /// will be deposited in a mint call in the same transaction, i.e. mint should\n /// return the same or fewer assets as `previewMint` if called in the same transaction.\n /// - MUST NOT account for mint limits like those returned from `maxMint` and should\n /// always act as if the mint will be accepted, regardless of approvals, etc.\n /// - MUST be inclusive of deposit fees. Integrators should be aware of this.\n /// - MUST not revert.\n ///\n /// Note: Any unfavorable discrepancy between `convertToAssets` and `previewMint` SHOULD\n /// be considered slippage in share price or some other type of condition,\n /// meaning the depositor will lose assets by minting.\n function previewMint(uint256 shares) public view virtual returns (uint256 assets) {\n if (!_useVirtualShares()) {\n uint256 supply = totalSupply();\n return supply == uint256(0)\n ? _initialConvertToAssets(shares)\n : FixedPointMathLib.fullMulDivUp(shares, totalAssets(), supply);\n }\n uint256 o = _decimalsOffset();\n if (o == uint256(0)) {\n return FixedPointMathLib.fullMulDivUp(shares, totalAssets() + 1, _inc(totalSupply()));\n }\n return FixedPointMathLib.fullMulDivUp(shares, totalAssets() + 1, totalSupply() + 10 ** o);\n }\n\n /// @dev Allows an on-chain or off-chain user to simulate the effects of their withdrawal\n /// at the current block, given the current on-chain conditions.\n ///\n /// - MUST return as close to and no fewer than the exact amount of Vault shares that\n /// will be burned in a withdraw call in the same transaction, i.e. withdraw should\n /// return the same or fewer shares as `previewWithdraw` if call in the same transaction.\n /// - MUST NOT account for withdrawal limits like those returned from `maxWithdraw` and should\n /// always act as if the withdrawal will be accepted, regardless of share balance, etc.\n /// - MUST be inclusive of withdrawal fees. Integrators should be aware of this.\n /// - MUST not revert.\n ///\n /// Note: Any unfavorable discrepancy between `convertToShares` and `previewWithdraw` SHOULD\n /// be considered slippage in share price or some other type of condition,\n /// meaning the depositor will lose assets by depositing.\n function previewWithdraw(uint256 assets) public view virtual returns (uint256 shares) {\n if (!_useVirtualShares()) {\n uint256 supply = totalSupply();\n return _eitherIsZero(assets, supply)\n ? _initialConvertToShares(assets)\n : FixedPointMathLib.fullMulDivUp(assets, supply, totalAssets());\n }\n uint256 o = _decimalsOffset();\n if (o == uint256(0)) {\n return FixedPointMathLib.fullMulDivUp(assets, totalSupply() + 1, _inc(totalAssets()));\n }\n return FixedPointMathLib.fullMulDivUp(assets, totalSupply() + 10 ** o, _inc(totalAssets()));\n }\n\n /// @dev Allows an on-chain or off-chain user to simulate the effects of their redemption\n /// at the current block, given current on-chain conditions.\n ///\n /// - MUST return as close to and no more than the exact amount of assets that\n /// will be withdrawn in a redeem call in the same transaction, i.e. redeem should\n /// return the same or more assets as `previewRedeem` if called in the same transaction.\n /// - MUST NOT account for redemption limits like those returned from `maxRedeem` and should\n /// always act as if the redemption will be accepted, regardless of approvals, etc.\n /// - MUST be inclusive of withdrawal fees. Integrators should be aware of this.\n /// - MUST NOT revert.\n ///\n /// Note: Any unfavorable discrepancy between `convertToAssets` and `previewRedeem` SHOULD\n /// be considered slippage in share price or some other type of condition,\n /// meaning the depositor will lose assets by depositing.\n function previewRedeem(uint256 shares) public view virtual returns (uint256 assets) {\n assets = convertToAssets(shares);\n }\n\n /// @dev Private helper to return if either value is zero.\n function _eitherIsZero(uint256 a, uint256 b) private pure returns (bool result) {\n /// @solidity memory-safe-assembly\n assembly {\n result := or(iszero(a), iszero(b))\n }\n }\n\n /// @dev Private helper to return `x + 1` without the overflow check.\n /// Used for computing the denominator input to `FixedPointMathLib.fullMulDiv(a, b, x + 1)`.\n /// When `x == type(uint256).max`, we get `x + 1 == 0` (mod 2**256 - 1),\n /// and `FixedPointMathLib.fullMulDiv` will revert as the denominator is zero.\n function _inc(uint256 x) private pure returns (uint256) {\n unchecked {\n return x + 1;\n }\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* DEPOSIT / WITHDRAWAL LIMIT LOGIC */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Returns the maximum amount of the underlying asset that can be deposited\n /// into the Vault for `to`, via a deposit call.\n ///\n /// - MUST return a limited value if `to` is subject to some deposit limit.\n /// - MUST return `2**256-1` if there is no maximum limit.\n /// - MUST NOT revert.\n function maxDeposit(address to) public view virtual returns (uint256 maxAssets) {\n to = to; // Silence unused variable warning.\n maxAssets = type(uint256).max;\n }\n\n /// @dev Returns the maximum amount of the Vault shares that can be minter for `to`,\n /// via a mint call.\n ///\n /// - MUST return a limited value if `to` is subject to some mint limit.\n /// - MUST return `2**256-1` if there is no maximum limit.\n /// - MUST NOT revert.\n function maxMint(address to) public view virtual returns (uint256 maxShares) {\n to = to; // Silence unused variable warning.\n maxShares = type(uint256).max;\n }\n\n /// @dev Returns the maximum amount of the underlying asset that can be withdrawn\n /// from the `owner`'s balance in the Vault, via 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 function maxWithdraw(address owner) public view virtual returns (uint256 maxAssets) {\n maxAssets = convertToAssets(balanceOf(owner));\n }\n\n /// @dev Returns the maximum amount of Vault shares that can be redeemed\n /// from the `owner`'s balance in the Vault, via 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)` otherwise.\n /// - MUST NOT revert.\n function maxRedeem(address owner) public view virtual returns (uint256 maxShares) {\n maxShares = balanceOf(owner);\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* DEPOSIT / WITHDRAWAL LOGIC */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Mints `shares` Vault shares to `to` by depositing exactly `assets`\n /// 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\n /// contract before the deposit execution, and are accounted for during deposit.\n /// - MUST revert if all of `assets` cannot be deposited, such as due to deposit limit,\n /// slippage, insufficient approval, etc.\n ///\n /// Note: Most implementations will require pre-approval of the Vault with the\n /// Vault's underlying `asset` token.\n function deposit(uint256 assets, address to) public virtual returns (uint256 shares) {\n if (assets > maxDeposit(to)) _revert(0xb3c61a83); // `DepositMoreThanMax()`.\n shares = previewDeposit(assets);\n _deposit(msg.sender, to, assets, shares);\n }\n\n /// @dev Mints exactly `shares` Vault shares to `to` by depositing `assets`\n /// 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\n /// contract before the mint execution, and are accounted for during mint.\n /// - MUST revert if all of `shares` cannot be deposited, such as due to deposit limit,\n /// slippage, insufficient approval, etc.\n ///\n /// Note: Most implementations will require pre-approval of the Vault with the\n /// Vault's underlying `asset` token.\n function mint(uint256 shares, address to) public virtual returns (uint256 assets) {\n if (shares > maxMint(to)) _revert(0x6a695959); // `MintMoreThanMax()`.\n assets = previewMint(shares);\n _deposit(msg.sender, to, assets, shares);\n }\n\n /// @dev Burns `shares` from `owner` and sends exactly `assets` of underlying tokens to `to`.\n ///\n /// - MUST emit the {Withdraw} event.\n /// - MAY support an additional flow in which the underlying tokens are owned by the Vault\n /// contract before the withdraw execution, and are accounted for during withdraw.\n /// - MUST revert if all of `assets` cannot be withdrawn, such as due to withdrawal limit,\n /// slippage, insufficient balance, etc.\n ///\n /// Note: Some implementations will require pre-requesting to the Vault before a withdrawal\n /// may be performed. Those methods should be performed separately.\n function withdraw(uint256 assets, address to, address owner)\n public\n virtual\n returns (uint256 shares)\n {\n if (assets > maxWithdraw(owner)) _revert(0x936941fc); // `WithdrawMoreThanMax()`.\n shares = previewWithdraw(assets);\n _withdraw(msg.sender, to, owner, assets, shares);\n }\n\n /// @dev Burns exactly `shares` from `owner` and sends `assets` of underlying tokens to `to`.\n ///\n /// - MUST emit the {Withdraw} event.\n /// - MAY support an additional flow in which the underlying tokens are owned by the Vault\n /// contract before the redeem execution, and are accounted for during redeem.\n /// - MUST revert if all of shares cannot be redeemed, such as due to withdrawal limit,\n /// slippage, insufficient balance, etc.\n ///\n /// Note: Some implementations will require pre-requesting to the Vault before a redeem\n /// may be performed. Those methods should be performed separately.\n function redeem(uint256 shares, address to, address owner)\n public\n virtual\n returns (uint256 assets)\n {\n if (shares > maxRedeem(owner)) _revert(0x4656425a); // `RedeemMoreThanMax()`.\n assets = previewRedeem(shares);\n _withdraw(msg.sender, to, owner, assets, shares);\n }\n\n /// @dev Internal helper for reverting efficiently.\n function _revert(uint256 s) private pure {\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, s)\n revert(0x1c, 0x04)\n }\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* INTERNAL HELPERS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev For deposits and mints.\n ///\n /// Emits a {Deposit} event.\n function _deposit(address by, address to, uint256 assets, uint256 shares) internal virtual {\n SafeTransferLib.safeTransferFrom(asset(), by, address(this), assets);\n _mint(to, shares);\n /// @solidity memory-safe-assembly\n assembly {\n // Emit the {Deposit} event.\n mstore(0x00, assets)\n mstore(0x20, shares)\n let m := shr(96, not(0))\n log3(0x00, 0x40, _DEPOSIT_EVENT_SIGNATURE, and(m, by), and(m, to))\n }\n _afterDeposit(assets, shares);\n }\n\n /// @dev For withdrawals and redemptions.\n ///\n /// Emits a {Withdraw} event.\n function _withdraw(address by, address to, address owner, uint256 assets, uint256 shares)\n internal\n virtual\n {\n if (by != owner) _spendAllowance(owner, by, shares);\n _beforeWithdraw(assets, shares);\n _burn(owner, shares);\n SafeTransferLib.safeTransfer(asset(), to, assets);\n /// @solidity memory-safe-assembly\n assembly {\n // Emit the {Withdraw} event.\n mstore(0x00, assets)\n mstore(0x20, shares)\n let m := shr(96, not(0))\n log4(0x00, 0x40, _WITHDRAW_EVENT_SIGNATURE, and(m, by), and(m, to), and(m, owner))\n }\n }\n\n /// @dev Internal conversion function (from assets to shares) to apply when the Vault is empty.\n /// Only used when {_useVirtualShares} returns false.\n ///\n /// Note: Make sure to keep this function consistent with {_initialConvertToAssets}\n /// when overriding it.\n function _initialConvertToShares(uint256 assets)\n internal\n view\n virtual\n returns (uint256 shares)\n {\n shares = assets;\n }\n\n /// @dev Internal conversion function (from shares to assets) to apply when the Vault is empty.\n /// Only used when {_useVirtualShares} returns false.\n ///\n /// Note: Make sure to keep this function consistent with {_initialConvertToShares}\n /// when overriding it.\n function _initialConvertToAssets(uint256 shares)\n internal\n view\n virtual\n returns (uint256 assets)\n {\n assets = shares;\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* HOOKS TO OVERRIDE */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Hook that is called before any withdrawal or redemption.\n function _beforeWithdraw(uint256 assets, uint256 shares) internal virtual {}\n\n /// @dev Hook that is called after any deposit or mint.\n function _afterDeposit(uint256 assets, uint256 shares) internal virtual {}\n}\n"},"lib/solady/src/utils/FixedPointMathLib.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Arithmetic library with operations for fixed-point numbers.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/FixedPointMathLib.sol)\n/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/FixedPointMathLib.sol)\nlibrary FixedPointMathLib {\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* CUSTOM ERRORS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev The operation failed, as the output exceeds the maximum value of uint256.\n error ExpOverflow();\n\n /// @dev The operation failed, as the output exceeds the maximum value of uint256.\n error FactorialOverflow();\n\n /// @dev The operation failed, due to an overflow.\n error RPowOverflow();\n\n /// @dev The mantissa is too big to fit.\n error MantissaOverflow();\n\n /// @dev The operation failed, due to an multiplication overflow.\n error MulWadFailed();\n\n /// @dev The operation failed, due to an multiplication overflow.\n error SMulWadFailed();\n\n /// @dev The operation failed, either due to a multiplication overflow, or a division by a zero.\n error DivWadFailed();\n\n /// @dev The operation failed, either due to a multiplication overflow, or a division by a zero.\n error SDivWadFailed();\n\n /// @dev The operation failed, either due to a multiplication overflow, or a division by a zero.\n error MulDivFailed();\n\n /// @dev The division failed, as the denominator is zero.\n error DivFailed();\n\n /// @dev The full precision multiply-divide operation failed, either due\n /// to the result being larger than 256 bits, or a division by a zero.\n error FullMulDivFailed();\n\n /// @dev The output is undefined, as the input is less-than-or-equal to zero.\n error LnWadUndefined();\n\n /// @dev The input outside the acceptable domain.\n error OutOfDomain();\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* CONSTANTS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev The scalar of ETH and most ERC20s.\n uint256 internal constant WAD = 1e18;\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* SIMPLIFIED FIXED POINT OPERATIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Equivalent to `(x * y) / WAD` rounded down.\n function mulWad(uint256 x, uint256 y) internal pure returns (uint256 z) {\n /// @solidity memory-safe-assembly\n assembly {\n // Equivalent to `require(y == 0 || x <= type(uint256).max / y)`.\n if gt(x, div(not(0), y)) {\n if y {\n mstore(0x00, 0xbac65e5b) // `MulWadFailed()`.\n revert(0x1c, 0x04)\n }\n }\n z := div(mul(x, y), WAD)\n }\n }\n\n /// @dev Equivalent to `(x * y) / WAD` rounded down.\n function sMulWad(int256 x, int256 y) internal pure returns (int256 z) {\n /// @solidity memory-safe-assembly\n assembly {\n z := mul(x, y)\n // Equivalent to `require((x == 0 || z / x == y) && !(x == -1 && y == type(int256).min))`.\n if iszero(gt(or(iszero(x), eq(sdiv(z, x), y)), lt(not(x), eq(y, shl(255, 1))))) {\n mstore(0x00, 0xedcd4dd4) // `SMulWadFailed()`.\n revert(0x1c, 0x04)\n }\n z := sdiv(z, WAD)\n }\n }\n\n /// @dev Equivalent to `(x * y) / WAD` rounded down, but without overflow checks.\n function rawMulWad(uint256 x, uint256 y) internal pure returns (uint256 z) {\n /// @solidity memory-safe-assembly\n assembly {\n z := div(mul(x, y), WAD)\n }\n }\n\n /// @dev Equivalent to `(x * y) / WAD` rounded down, but without overflow checks.\n function rawSMulWad(int256 x, int256 y) internal pure returns (int256 z) {\n /// @solidity memory-safe-assembly\n assembly {\n z := sdiv(mul(x, y), WAD)\n }\n }\n\n /// @dev Equivalent to `(x * y) / WAD` rounded up.\n function mulWadUp(uint256 x, uint256 y) internal pure returns (uint256 z) {\n /// @solidity memory-safe-assembly\n assembly {\n z := mul(x, y)\n // Equivalent to `require(y == 0 || x <= type(uint256).max / y)`.\n if iszero(eq(div(z, y), x)) {\n if y {\n mstore(0x00, 0xbac65e5b) // `MulWadFailed()`.\n revert(0x1c, 0x04)\n }\n }\n z := add(iszero(iszero(mod(z, WAD))), div(z, WAD))\n }\n }\n\n /// @dev Equivalent to `(x * y) / WAD` rounded up, but without overflow checks.\n function rawMulWadUp(uint256 x, uint256 y) internal pure returns (uint256 z) {\n /// @solidity memory-safe-assembly\n assembly {\n z := add(iszero(iszero(mod(mul(x, y), WAD))), div(mul(x, y), WAD))\n }\n }\n\n /// @dev Equivalent to `(x * WAD) / y` rounded down.\n function divWad(uint256 x, uint256 y) internal pure returns (uint256 z) {\n /// @solidity memory-safe-assembly\n assembly {\n // Equivalent to `require(y != 0 && x <= type(uint256).max / WAD)`.\n if iszero(mul(y, lt(x, add(1, div(not(0), WAD))))) {\n mstore(0x00, 0x7c5f487d) // `DivWadFailed()`.\n revert(0x1c, 0x04)\n }\n z := div(mul(x, WAD), y)\n }\n }\n\n /// @dev Equivalent to `(x * WAD) / y` rounded down.\n function sDivWad(int256 x, int256 y) internal pure returns (int256 z) {\n /// @solidity memory-safe-assembly\n assembly {\n z := mul(x, WAD)\n // Equivalent to `require(y != 0 && ((x * WAD) / WAD == x))`.\n if iszero(mul(y, eq(sdiv(z, WAD), x))) {\n mstore(0x00, 0x5c43740d) // `SDivWadFailed()`.\n revert(0x1c, 0x04)\n }\n z := sdiv(z, y)\n }\n }\n\n /// @dev Equivalent to `(x * WAD) / y` rounded down, but without overflow and divide by zero checks.\n function rawDivWad(uint256 x, uint256 y) internal pure returns (uint256 z) {\n /// @solidity memory-safe-assembly\n assembly {\n z := div(mul(x, WAD), y)\n }\n }\n\n /// @dev Equivalent to `(x * WAD) / y` rounded down, but without overflow and divide by zero checks.\n function rawSDivWad(int256 x, int256 y) internal pure returns (int256 z) {\n /// @solidity memory-safe-assembly\n assembly {\n z := sdiv(mul(x, WAD), y)\n }\n }\n\n /// @dev Equivalent to `(x * WAD) / y` rounded up.\n function divWadUp(uint256 x, uint256 y) internal pure returns (uint256 z) {\n /// @solidity memory-safe-assembly\n assembly {\n // Equivalent to `require(y != 0 && x <= type(uint256).max / WAD)`.\n if iszero(mul(y, lt(x, add(1, div(not(0), WAD))))) {\n mstore(0x00, 0x7c5f487d) // `DivWadFailed()`.\n revert(0x1c, 0x04)\n }\n z := add(iszero(iszero(mod(mul(x, WAD), y))), div(mul(x, WAD), y))\n }\n }\n\n /// @dev Equivalent to `(x * WAD) / y` rounded up, but without overflow and divide by zero checks.\n function rawDivWadUp(uint256 x, uint256 y) internal pure returns (uint256 z) {\n /// @solidity memory-safe-assembly\n assembly {\n z := add(iszero(iszero(mod(mul(x, WAD), y))), div(mul(x, WAD), y))\n }\n }\n\n /// @dev Equivalent to `x` to the power of `y`.\n /// because `x ** y = (e ** ln(x)) ** y = e ** (ln(x) * y)`.\n /// Note: This function is an approximation.\n function powWad(int256 x, int256 y) internal pure returns (int256) {\n // Using `ln(x)` means `x` must be greater than 0.\n return expWad((lnWad(x) * y) / int256(WAD));\n }\n\n /// @dev Returns `exp(x)`, denominated in `WAD`.\n /// Credit to Remco Bloemen under MIT license: https://2π.com/22/exp-ln\n /// Note: This function is an approximation. Monotonically increasing.\n function expWad(int256 x) internal pure returns (int256 r) {\n unchecked {\n // When the result is less than 0.5 we return zero.\n // This happens when `x <= (log(1e-18) * 1e18) ~ -4.15e19`.\n if (x <= -41446531673892822313) return r;\n\n /// @solidity memory-safe-assembly\n assembly {\n // When the result is greater than `(2**255 - 1) / 1e18` we can not represent it as\n // an int. This happens when `x >= floor(log((2**255 - 1) / 1e18) * 1e18) ≈ 135`.\n if iszero(slt(x, 135305999368893231589)) {\n mstore(0x00, 0xa37bfec9) // `ExpOverflow()`.\n revert(0x1c, 0x04)\n }\n }\n\n // `x` is now in the range `(-42, 136) * 1e18`. Convert to `(-42, 136) * 2**96`\n // for more intermediate precision and a binary basis. This base conversion\n // is a multiplication by 1e18 / 2**96 = 5**18 / 2**78.\n x = (x << 78) / 5 ** 18;\n\n // Reduce range of x to (-½ ln 2, ½ ln 2) * 2**96 by factoring out powers\n // of two such that exp(x) = exp(x') * 2**k, where k is an integer.\n // Solving this gives k = round(x / log(2)) and x' = x - k * log(2).\n int256 k = ((x << 96) / 54916777467707473351141471128 + 2 ** 95) >> 96;\n x = x - k * 54916777467707473351141471128;\n\n // `k` is in the range `[-61, 195]`.\n\n // Evaluate using a (6, 7)-term rational approximation.\n // `p` is made monic, we'll multiply by a scale factor later.\n int256 y = x + 1346386616545796478920950773328;\n y = ((y * x) >> 96) + 57155421227552351082224309758442;\n int256 p = y + x - 94201549194550492254356042504812;\n p = ((p * y) >> 96) + 28719021644029726153956944680412240;\n p = p * x + (4385272521454847904659076985693276 << 96);\n\n // We leave `p` in `2**192` basis so we don't need to scale it back up for the division.\n int256 q = x - 2855989394907223263936484059900;\n q = ((q * x) >> 96) + 50020603652535783019961831881945;\n q = ((q * x) >> 96) - 533845033583426703283633433725380;\n q = ((q * x) >> 96) + 3604857256930695427073651918091429;\n q = ((q * x) >> 96) - 14423608567350463180887372962807573;\n q = ((q * x) >> 96) + 26449188498355588339934803723976023;\n\n /// @solidity memory-safe-assembly\n assembly {\n // Div in assembly because solidity adds a zero check despite the unchecked.\n // The q polynomial won't have zeros in the domain as all its roots are complex.\n // No scaling is necessary because p is already `2**96` too large.\n r := sdiv(p, q)\n }\n\n // r should be in the range `(0.09, 0.25) * 2**96`.\n\n // We now need to multiply r by:\n // - The scale factor `s ≈ 6.031367120`.\n // - The `2**k` factor from the range reduction.\n // - The `1e18 / 2**96` factor for base conversion.\n // We do this all at once, with an intermediate result in `2**213`\n // basis, so the final right shift is always by a positive amount.\n r = int256(\n (uint256(r) * 3822833074963236453042738258902158003155416615667) >> uint256(195 - k)\n );\n }\n }\n\n /// @dev Returns `ln(x)`, denominated in `WAD`.\n /// Credit to Remco Bloemen under MIT license: https://2π.com/22/exp-ln\n /// Note: This function is an approximation. Monotonically increasing.\n function lnWad(int256 x) internal pure returns (int256 r) {\n /// @solidity memory-safe-assembly\n assembly {\n // We want to convert `x` from `10**18` fixed point to `2**96` fixed point.\n // We do this by multiplying by `2**96 / 10**18`. But since\n // `ln(x * C) = ln(x) + ln(C)`, we can simply do nothing here\n // and add `ln(2**96 / 10**18)` at the end.\n\n // Compute `k = log2(x) - 96`, `r = 159 - k = 255 - log2(x) = 255 ^ log2(x)`.\n r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))\n r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))\n r := or(r, shl(5, lt(0xffffffff, shr(r, x))))\n r := or(r, shl(4, lt(0xffff, shr(r, x))))\n r := or(r, shl(3, lt(0xff, shr(r, x))))\n // We place the check here for more optimal stack operations.\n if iszero(sgt(x, 0)) {\n mstore(0x00, 0x1615e638) // `LnWadUndefined()`.\n revert(0x1c, 0x04)\n }\n // forgefmt: disable-next-item\n r := xor(r, byte(and(0x1f, shr(shr(r, x), 0x8421084210842108cc6318c6db6d54be)),\n 0xf8f9f9faf9fdfafbf9fdfcfdfafbfcfef9fafdfafcfcfbfefafafcfbffffffff))\n\n // Reduce range of x to (1, 2) * 2**96\n // ln(2^k * x) = k * ln(2) + ln(x)\n x := shr(159, shl(r, x))\n\n // Evaluate using a (8, 8)-term rational approximation.\n // `p` is made monic, we will multiply by a scale factor later.\n // forgefmt: disable-next-item\n let p := sub( // This heavily nested expression is to avoid stack-too-deep for via-ir.\n sar(96, mul(add(43456485725739037958740375743393,\n sar(96, mul(add(24828157081833163892658089445524,\n sar(96, mul(add(3273285459638523848632254066296,\n x), x))), x))), x)), 11111509109440967052023855526967)\n p := sub(sar(96, mul(p, x)), 45023709667254063763336534515857)\n p := sub(sar(96, mul(p, x)), 14706773417378608786704636184526)\n p := sub(mul(p, x), shl(96, 795164235651350426258249787498))\n // We leave `p` in `2**192` basis so we don't need to scale it back up for the division.\n\n // `q` is monic by convention.\n let q := add(5573035233440673466300451813936, x)\n q := add(71694874799317883764090561454958, sar(96, mul(x, q)))\n q := add(283447036172924575727196451306956, sar(96, mul(x, q)))\n q := add(401686690394027663651624208769553, sar(96, mul(x, q)))\n q := add(204048457590392012362485061816622, sar(96, mul(x, q)))\n q := add(31853899698501571402653359427138, sar(96, mul(x, q)))\n q := add(909429971244387300277376558375, sar(96, mul(x, q)))\n\n // `p / q` is in the range `(0, 0.125) * 2**96`.\n\n // Finalization, we need to:\n // - Multiply by the scale factor `s = 5.549…`.\n // - Add `ln(2**96 / 10**18)`.\n // - Add `k * ln(2)`.\n // - Multiply by `10**18 / 2**96 = 5**18 >> 78`.\n\n // The q polynomial is known not to have zeros in the domain.\n // No scaling required because p is already `2**96` too large.\n p := sdiv(p, q)\n // Multiply by the scaling factor: `s * 5**18 * 2**96`, base is now `5**18 * 2**192`.\n p := mul(1677202110996718588342820967067443963516166, p)\n // Add `ln(2) * k * 5**18 * 2**192`.\n // forgefmt: disable-next-item\n p := add(mul(16597577552685614221487285958193947469193820559219878177908093499208371, sub(159, r)), p)\n // Add `ln(2**96 / 10**18) * 5**18 * 2**192`.\n p := add(600920179829731861736702779321621459595472258049074101567377883020018308, p)\n // Base conversion: mul `2**18 / 2**192`.\n r := sar(174, p)\n }\n }\n\n /// @dev Returns `W_0(x)`, denominated in `WAD`.\n /// See: https://en.wikipedia.org/wiki/Lambert_W_function\n /// a.k.a. Product log function. This is an approximation of the principal branch.\n /// Note: This function is an approximation. Monotonically increasing.\n function lambertW0Wad(int256 x) internal pure returns (int256 w) {\n // forgefmt: disable-next-item\n unchecked {\n if ((w = x) <= -367879441171442322) revert OutOfDomain(); // `x` less than `-1/e`.\n (int256 wad, int256 p) = (int256(WAD), x);\n uint256 c; // Whether we need to avoid catastrophic cancellation.\n uint256 i = 4; // Number of iterations.\n if (w <= 0x1ffffffffffff) {\n if (-0x4000000000000 <= w) {\n i = 1; // Inputs near zero only take one step to converge.\n } else if (w <= -0x3ffffffffffffff) {\n i = 32; // Inputs near `-1/e` take very long to converge.\n }\n } else if (uint256(w >> 63) == uint256(0)) {\n /// @solidity memory-safe-assembly\n assembly {\n // Inline log2 for more performance, since the range is small.\n let v := shr(49, w)\n let l := shl(3, lt(0xff, v))\n l := add(or(l, byte(and(0x1f, shr(shr(l, v), 0x8421084210842108cc6318c6db6d54be)),\n 0x0706060506020504060203020504030106050205030304010505030400000000)), 49)\n w := sdiv(shl(l, 7), byte(sub(l, 31), 0x0303030303030303040506080c13))\n c := gt(l, 60)\n i := add(2, add(gt(l, 53), c))\n }\n } else {\n int256 ll = lnWad(w = lnWad(w));\n /// @solidity memory-safe-assembly\n assembly {\n // `w = ln(x) - ln(ln(x)) + b * ln(ln(x)) / ln(x)`.\n w := add(sdiv(mul(ll, 1023715080943847266), w), sub(w, ll))\n i := add(3, iszero(shr(68, x)))\n c := iszero(shr(143, x))\n }\n if (c == uint256(0)) {\n do { // If `x` is big, use Newton's so that intermediate values won't overflow.\n int256 e = expWad(w);\n /// @solidity memory-safe-assembly\n assembly {\n let t := mul(w, div(e, wad))\n w := sub(w, sdiv(sub(t, x), div(add(e, t), wad)))\n }\n if (p <= w) break;\n p = w;\n } while (--i != uint256(0));\n /// @solidity memory-safe-assembly\n assembly {\n w := sub(w, sgt(w, 2))\n }\n return w;\n }\n }\n do { // Otherwise, use Halley's for faster convergence.\n int256 e = expWad(w);\n /// @solidity memory-safe-assembly\n assembly {\n let t := add(w, wad)\n let s := sub(mul(w, e), mul(x, wad))\n w := sub(w, sdiv(mul(s, wad), sub(mul(e, t), sdiv(mul(add(t, wad), s), add(t, t)))))\n }\n if (p <= w) break;\n p = w;\n } while (--i != c);\n /// @solidity memory-safe-assembly\n assembly {\n w := sub(w, sgt(w, 2))\n }\n // For certain ranges of `x`, we'll use the quadratic-rate recursive formula of\n // R. Iacono and J.P. Boyd for the last iteration, to avoid catastrophic cancellation.\n if (c == uint256(0)) return w;\n int256 t = w | 1;\n /// @solidity memory-safe-assembly\n assembly {\n x := sdiv(mul(x, wad), t)\n }\n x = (t * (wad + lnWad(x)));\n /// @solidity memory-safe-assembly\n assembly {\n w := sdiv(x, add(wad, t))\n }\n }\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* GENERAL NUMBER UTILITIES */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Calculates `floor(x * y / d)` with full precision.\n /// Throws if result overflows a uint256 or when `d` is zero.\n /// Credit to Remco Bloemen under MIT license: https://2π.com/21/muldiv\n function fullMulDiv(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 result) {\n /// @solidity memory-safe-assembly\n assembly {\n // 512-bit multiply `[p1 p0] = x * y`.\n // Compute the product mod `2**256` and mod `2**256 - 1`\n // then use the Chinese Remainder Theorem to reconstruct\n // the 512 bit result. The result is stored in two 256\n // variables such that `product = p1 * 2**256 + p0`.\n\n // Temporarily use `result` as `p0` to save gas.\n result := mul(x, y) // Lower 256 bits of `x * y`.\n for {} 1 {} {\n // If overflows.\n if iszero(mul(or(iszero(x), eq(div(result, x), y)), d)) {\n let mm := mulmod(x, y, not(0))\n let p1 := sub(mm, add(result, lt(mm, result))) // Upper 256 bits of `x * y`.\n\n /*------------------- 512 by 256 division --------------------*/\n\n // Make division exact by subtracting the remainder from `[p1 p0]`.\n let r := mulmod(x, y, d) // Compute remainder using mulmod.\n let t := and(d, sub(0, d)) // The least significant bit of `d`. `t >= 1`.\n // Make sure the result is less than `2**256`. Also prevents `d == 0`.\n // Placing the check here seems to give more optimal stack operations.\n if iszero(gt(d, p1)) {\n mstore(0x00, 0xae47f702) // `FullMulDivFailed()`.\n revert(0x1c, 0x04)\n }\n d := div(d, t) // Divide `d` by `t`, which is a power of two.\n // Invert `d mod 2**256`\n // Now that `d` is an odd number, it has an inverse\n // modulo `2**256` such that `d * inv = 1 mod 2**256`.\n // Compute the inverse by starting with a seed that is correct\n // correct for four bits. That is, `d * inv = 1 mod 2**4`.\n let inv := xor(2, mul(3, d))\n // Now use Newton-Raphson iteration to improve the precision.\n // Thanks to Hensel's lifting lemma, this also works in modular\n // arithmetic, doubling the correct bits in each step.\n inv := mul(inv, sub(2, mul(d, inv))) // inverse mod 2**8\n inv := mul(inv, sub(2, mul(d, inv))) // inverse mod 2**16\n inv := mul(inv, sub(2, mul(d, inv))) // inverse mod 2**32\n inv := mul(inv, sub(2, mul(d, inv))) // inverse mod 2**64\n inv := mul(inv, sub(2, mul(d, inv))) // inverse mod 2**128\n result :=\n mul(\n // Divide [p1 p0] by the factors of two.\n // Shift in bits from `p1` into `p0`. For this we need\n // to flip `t` such that it is `2**256 / t`.\n or(\n mul(sub(p1, gt(r, result)), add(div(sub(0, t), t), 1)),\n div(sub(result, r), t)\n ),\n mul(sub(2, mul(d, inv)), inv) // inverse mod 2**256\n )\n break\n }\n result := div(result, d)\n break\n }\n }\n }\n\n /// @dev Calculates `floor(x * y / d)` with full precision.\n /// Behavior is undefined if `d` is zero or the final result cannot fit in 256 bits.\n /// Performs the full 512 bit calculation regardless.\n function fullMulDivUnchecked(uint256 x, uint256 y, uint256 d)\n internal\n pure\n returns (uint256 result)\n {\n /// @solidity memory-safe-assembly\n assembly {\n result := mul(x, y)\n let mm := mulmod(x, y, not(0))\n let p1 := sub(mm, add(result, lt(mm, result)))\n let t := and(d, sub(0, d))\n let r := mulmod(x, y, d)\n d := div(d, t)\n let inv := xor(2, mul(3, d))\n inv := mul(inv, sub(2, mul(d, inv)))\n inv := mul(inv, sub(2, mul(d, inv)))\n inv := mul(inv, sub(2, mul(d, inv)))\n inv := mul(inv, sub(2, mul(d, inv)))\n inv := mul(inv, sub(2, mul(d, inv)))\n result :=\n mul(\n or(mul(sub(p1, gt(r, result)), add(div(sub(0, t), t), 1)), div(sub(result, r), t)),\n mul(sub(2, mul(d, inv)), inv)\n )\n }\n }\n\n /// @dev Calculates `floor(x * y / d)` with full precision, rounded up.\n /// Throws if result overflows a uint256 or when `d` is zero.\n /// Credit to Uniswap-v3-core under MIT license:\n /// https://github.com/Uniswap/v3-core/blob/main/contracts/libraries/FullMath.sol\n function fullMulDivUp(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 result) {\n result = fullMulDiv(x, y, d);\n /// @solidity memory-safe-assembly\n assembly {\n if mulmod(x, y, d) {\n result := add(result, 1)\n if iszero(result) {\n mstore(0x00, 0xae47f702) // `FullMulDivFailed()`.\n revert(0x1c, 0x04)\n }\n }\n }\n }\n\n /// @dev Returns `floor(x * y / d)`.\n /// Reverts if `x * y` overflows, or `d` is zero.\n function mulDiv(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 z) {\n /// @solidity memory-safe-assembly\n assembly {\n z := mul(x, y)\n // Equivalent to `require(d != 0 && (y == 0 || x <= type(uint256).max / y))`.\n if iszero(mul(or(iszero(x), eq(div(z, x), y)), d)) {\n mstore(0x00, 0xad251c27) // `MulDivFailed()`.\n revert(0x1c, 0x04)\n }\n z := div(z, d)\n }\n }\n\n /// @dev Returns `ceil(x * y / d)`.\n /// Reverts if `x * y` overflows, or `d` is zero.\n function mulDivUp(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 z) {\n /// @solidity memory-safe-assembly\n assembly {\n z := mul(x, y)\n // Equivalent to `require(d != 0 && (y == 0 || x <= type(uint256).max / y))`.\n if iszero(mul(or(iszero(x), eq(div(z, x), y)), d)) {\n mstore(0x00, 0xad251c27) // `MulDivFailed()`.\n revert(0x1c, 0x04)\n }\n z := add(iszero(iszero(mod(z, d))), div(z, d))\n }\n }\n\n /// @dev Returns `ceil(x / d)`.\n /// Reverts if `d` is zero.\n function divUp(uint256 x, uint256 d) internal pure returns (uint256 z) {\n /// @solidity memory-safe-assembly\n assembly {\n if iszero(d) {\n mstore(0x00, 0x65244e4e) // `DivFailed()`.\n revert(0x1c, 0x04)\n }\n z := add(iszero(iszero(mod(x, d))), div(x, d))\n }\n }\n\n /// @dev Returns `max(0, x - y)`.\n function zeroFloorSub(uint256 x, uint256 y) internal pure returns (uint256 z) {\n /// @solidity memory-safe-assembly\n assembly {\n z := mul(gt(x, y), sub(x, y))\n }\n }\n\n /// @dev Returns `condition ? x : y`, without branching.\n function ternary(bool condition, uint256 x, uint256 y) internal pure returns (uint256 result) {\n /// @solidity memory-safe-assembly\n assembly {\n result := xor(x, mul(xor(x, y), iszero(condition)))\n }\n }\n\n /// @dev Exponentiate `x` to `y` by squaring, denominated in base `b`.\n /// Reverts if the computation overflows.\n function rpow(uint256 x, uint256 y, uint256 b) internal pure returns (uint256 z) {\n /// @solidity memory-safe-assembly\n assembly {\n z := mul(b, iszero(y)) // `0 ** 0 = 1`. Otherwise, `0 ** n = 0`.\n if x {\n z := xor(b, mul(xor(b, x), and(y, 1))) // `z = isEven(y) ? scale : x`\n let half := shr(1, b) // Divide `b` by 2.\n // Divide `y` by 2 every iteration.\n for { y := shr(1, y) } y { y := shr(1, y) } {\n let xx := mul(x, x) // Store x squared.\n let xxRound := add(xx, half) // Round to the nearest number.\n // Revert if `xx + half` overflowed, or if `x ** 2` overflows.\n if or(lt(xxRound, xx), shr(128, x)) {\n mstore(0x00, 0x49f7642b) // `RPowOverflow()`.\n revert(0x1c, 0x04)\n }\n x := div(xxRound, b) // Set `x` to scaled `xxRound`.\n // If `y` is odd:\n if and(y, 1) {\n let zx := mul(z, x) // Compute `z * x`.\n let zxRound := add(zx, half) // Round to the nearest number.\n // If `z * x` overflowed or `zx + half` overflowed:\n if or(xor(div(zx, x), z), lt(zxRound, zx)) {\n // Revert if `x` is non-zero.\n if x {\n mstore(0x00, 0x49f7642b) // `RPowOverflow()`.\n revert(0x1c, 0x04)\n }\n }\n z := div(zxRound, b) // Return properly scaled `zxRound`.\n }\n }\n }\n }\n }\n\n /// @dev Returns the square root of `x`, rounded down.\n function sqrt(uint256 x) internal pure returns (uint256 z) {\n /// @solidity memory-safe-assembly\n assembly {\n // `floor(sqrt(2**15)) = 181`. `sqrt(2**15) - 181 = 2.84`.\n z := 181 // The \"correct\" value is 1, but this saves a multiplication later.\n\n // This segment is to get a reasonable initial estimate for the Babylonian method. With a bad\n // start, the correct # of bits increases ~linearly each iteration instead of ~quadratically.\n\n // Let `y = x / 2**r`. We check `y >= 2**(k + 8)`\n // but shift right by `k` bits to ensure that if `x >= 256`, then `y >= 256`.\n let r := shl(7, lt(0xffffffffffffffffffffffffffffffffff, x))\n r := or(r, shl(6, lt(0xffffffffffffffffff, shr(r, x))))\n r := or(r, shl(5, lt(0xffffffffff, shr(r, x))))\n r := or(r, shl(4, lt(0xffffff, shr(r, x))))\n z := shl(shr(1, r), z)\n\n // Goal was to get `z*z*y` within a small factor of `x`. More iterations could\n // get y in a tighter range. Currently, we will have y in `[256, 256*(2**16))`.\n // We ensured `y >= 256` so that the relative difference between `y` and `y+1` is small.\n // That's not possible if `x < 256` but we can just verify those cases exhaustively.\n\n // Now, `z*z*y <= x < z*z*(y+1)`, and `y <= 2**(16+8)`, and either `y >= 256`, or `x < 256`.\n // Correctness can be checked exhaustively for `x < 256`, so we assume `y >= 256`.\n // Then `z*sqrt(y)` is within `sqrt(257)/sqrt(256)` of `sqrt(x)`, or about 20bps.\n\n // For `s` in the range `[1/256, 256]`, the estimate `f(s) = (181/1024) * (s+1)`\n // is in the range `(1/2.84 * sqrt(s), 2.84 * sqrt(s))`,\n // with largest error when `s = 1` and when `s = 256` or `1/256`.\n\n // Since `y` is in `[256, 256*(2**16))`, let `a = y/65536`, so that `a` is in `[1/256, 256)`.\n // Then we can estimate `sqrt(y)` using\n // `sqrt(65536) * 181/1024 * (a + 1) = 181/4 * (y + 65536)/65536 = 181 * (y + 65536)/2**18`.\n\n // There is no overflow risk here since `y < 2**136` after the first branch above.\n z := shr(18, mul(z, add(shr(r, x), 65536))) // A `mul()` is saved from starting `z` at 181.\n\n // Given the worst case multiplicative error of 2.84 above, 7 iterations should be enough.\n z := shr(1, add(z, div(x, z)))\n z := shr(1, add(z, div(x, z)))\n z := shr(1, add(z, div(x, z)))\n z := shr(1, add(z, div(x, z)))\n z := shr(1, add(z, div(x, z)))\n z := shr(1, add(z, div(x, z)))\n z := shr(1, add(z, div(x, z)))\n\n // If `x+1` is a perfect square, the Babylonian method cycles between\n // `floor(sqrt(x))` and `ceil(sqrt(x))`. This statement ensures we return floor.\n // See: https://en.wikipedia.org/wiki/Integer_square_root#Using_only_integer_division\n z := sub(z, lt(div(x, z), z))\n }\n }\n\n /// @dev Returns the cube root of `x`, rounded down.\n /// Credit to bout3fiddy and pcaversaccio under AGPLv3 license:\n /// https://github.com/pcaversaccio/snekmate/blob/main/src/utils/Math.vy\n /// Formally verified by xuwinnie:\n /// https://github.com/vectorized/solady/blob/main/audits/xuwinnie-solady-cbrt-proof.pdf\n function cbrt(uint256 x) internal pure returns (uint256 z) {\n /// @solidity memory-safe-assembly\n assembly {\n let r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))\n r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))\n r := or(r, shl(5, lt(0xffffffff, shr(r, x))))\n r := or(r, shl(4, lt(0xffff, shr(r, x))))\n r := or(r, shl(3, lt(0xff, shr(r, x))))\n // Makeshift lookup table to nudge the approximate log2 result.\n z := div(shl(div(r, 3), shl(lt(0xf, shr(r, x)), 0xf)), xor(7, mod(r, 3)))\n // Newton-Raphson's.\n z := div(add(add(div(x, mul(z, z)), z), z), 3)\n z := div(add(add(div(x, mul(z, z)), z), z), 3)\n z := div(add(add(div(x, mul(z, z)), z), z), 3)\n z := div(add(add(div(x, mul(z, z)), z), z), 3)\n z := div(add(add(div(x, mul(z, z)), z), z), 3)\n z := div(add(add(div(x, mul(z, z)), z), z), 3)\n z := div(add(add(div(x, mul(z, z)), z), z), 3)\n // Round down.\n z := sub(z, lt(div(x, mul(z, z)), z))\n }\n }\n\n /// @dev Returns the square root of `x`, denominated in `WAD`, rounded down.\n function sqrtWad(uint256 x) internal pure returns (uint256 z) {\n unchecked {\n if (x <= type(uint256).max / 10 ** 18) return sqrt(x * 10 ** 18);\n z = (1 + sqrt(x)) * 10 ** 9;\n z = (fullMulDivUnchecked(x, 10 ** 18, z) + z) >> 1;\n }\n /// @solidity memory-safe-assembly\n assembly {\n z := sub(z, gt(999999999999999999, sub(mulmod(z, z, x), 1))) // Round down.\n }\n }\n\n /// @dev Returns the cube root of `x`, denominated in `WAD`, rounded down.\n /// Formally verified by xuwinnie:\n /// https://github.com/vectorized/solady/blob/main/audits/xuwinnie-solady-cbrt-proof.pdf\n function cbrtWad(uint256 x) internal pure returns (uint256 z) {\n unchecked {\n if (x <= type(uint256).max / 10 ** 36) return cbrt(x * 10 ** 36);\n z = (1 + cbrt(x)) * 10 ** 12;\n z = (fullMulDivUnchecked(x, 10 ** 36, z * z) + z + z) / 3;\n }\n /// @solidity memory-safe-assembly\n assembly {\n let p := x\n for {} 1 {} {\n if iszero(shr(229, p)) {\n if iszero(shr(199, p)) {\n p := mul(p, 100000000000000000) // 10 ** 17.\n break\n }\n p := mul(p, 100000000) // 10 ** 8.\n break\n }\n if iszero(shr(249, p)) { p := mul(p, 100) }\n break\n }\n let t := mulmod(mul(z, z), z, p)\n z := sub(z, gt(lt(t, shr(1, p)), iszero(t))) // Round down.\n }\n }\n\n /// @dev Returns the factorial of `x`.\n function factorial(uint256 x) internal pure returns (uint256 result) {\n /// @solidity memory-safe-assembly\n assembly {\n result := 1\n if iszero(lt(x, 58)) {\n mstore(0x00, 0xaba0f2a2) // `FactorialOverflow()`.\n revert(0x1c, 0x04)\n }\n for {} x { x := sub(x, 1) } { result := mul(result, x) }\n }\n }\n\n /// @dev Returns the log2 of `x`.\n /// Equivalent to computing the index of the most significant bit (MSB) of `x`.\n /// Returns 0 if `x` is zero.\n function log2(uint256 x) internal pure returns (uint256 r) {\n /// @solidity memory-safe-assembly\n assembly {\n r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))\n r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))\n r := or(r, shl(5, lt(0xffffffff, shr(r, x))))\n r := or(r, shl(4, lt(0xffff, shr(r, x))))\n r := or(r, shl(3, lt(0xff, shr(r, x))))\n // forgefmt: disable-next-item\n r := or(r, byte(and(0x1f, shr(shr(r, x), 0x8421084210842108cc6318c6db6d54be)),\n 0x0706060506020504060203020504030106050205030304010505030400000000))\n }\n }\n\n /// @dev Returns the log2 of `x`, rounded up.\n /// Returns 0 if `x` is zero.\n function log2Up(uint256 x) internal pure returns (uint256 r) {\n r = log2(x);\n /// @solidity memory-safe-assembly\n assembly {\n r := add(r, lt(shl(r, 1), x))\n }\n }\n\n /// @dev Returns the log10 of `x`.\n /// Returns 0 if `x` is zero.\n function log10(uint256 x) internal pure returns (uint256 r) {\n /// @solidity memory-safe-assembly\n assembly {\n if iszero(lt(x, 100000000000000000000000000000000000000)) {\n x := div(x, 100000000000000000000000000000000000000)\n r := 38\n }\n if iszero(lt(x, 100000000000000000000)) {\n x := div(x, 100000000000000000000)\n r := add(r, 20)\n }\n if iszero(lt(x, 10000000000)) {\n x := div(x, 10000000000)\n r := add(r, 10)\n }\n if iszero(lt(x, 100000)) {\n x := div(x, 100000)\n r := add(r, 5)\n }\n r := add(r, add(gt(x, 9), add(gt(x, 99), add(gt(x, 999), gt(x, 9999)))))\n }\n }\n\n /// @dev Returns the log10 of `x`, rounded up.\n /// Returns 0 if `x` is zero.\n function log10Up(uint256 x) internal pure returns (uint256 r) {\n r = log10(x);\n /// @solidity memory-safe-assembly\n assembly {\n r := add(r, lt(exp(10, r), x))\n }\n }\n\n /// @dev Returns the log256 of `x`.\n /// Returns 0 if `x` is zero.\n function log256(uint256 x) internal pure returns (uint256 r) {\n /// @solidity memory-safe-assembly\n assembly {\n r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))\n r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))\n r := or(r, shl(5, lt(0xffffffff, shr(r, x))))\n r := or(r, shl(4, lt(0xffff, shr(r, x))))\n r := or(shr(3, r), lt(0xff, shr(r, x)))\n }\n }\n\n /// @dev Returns the log256 of `x`, rounded up.\n /// Returns 0 if `x` is zero.\n function log256Up(uint256 x) internal pure returns (uint256 r) {\n r = log256(x);\n /// @solidity memory-safe-assembly\n assembly {\n r := add(r, lt(shl(shl(3, r), 1), x))\n }\n }\n\n /// @dev Returns the scientific notation format `mantissa * 10 ** exponent` of `x`.\n /// Useful for compressing prices (e.g. using 25 bit mantissa and 7 bit exponent).\n function sci(uint256 x) internal pure returns (uint256 mantissa, uint256 exponent) {\n /// @solidity memory-safe-assembly\n assembly {\n mantissa := x\n if mantissa {\n if iszero(mod(mantissa, 1000000000000000000000000000000000)) {\n mantissa := div(mantissa, 1000000000000000000000000000000000)\n exponent := 33\n }\n if iszero(mod(mantissa, 10000000000000000000)) {\n mantissa := div(mantissa, 10000000000000000000)\n exponent := add(exponent, 19)\n }\n if iszero(mod(mantissa, 1000000000000)) {\n mantissa := div(mantissa, 1000000000000)\n exponent := add(exponent, 12)\n }\n if iszero(mod(mantissa, 1000000)) {\n mantissa := div(mantissa, 1000000)\n exponent := add(exponent, 6)\n }\n if iszero(mod(mantissa, 10000)) {\n mantissa := div(mantissa, 10000)\n exponent := add(exponent, 4)\n }\n if iszero(mod(mantissa, 100)) {\n mantissa := div(mantissa, 100)\n exponent := add(exponent, 2)\n }\n if iszero(mod(mantissa, 10)) {\n mantissa := div(mantissa, 10)\n exponent := add(exponent, 1)\n }\n }\n }\n }\n\n /// @dev Convenience function for packing `x` into a smaller number using `sci`.\n /// The `mantissa` will be in bits [7..255] (the upper 249 bits).\n /// The `exponent` will be in bits [0..6] (the lower 7 bits).\n /// Use `SafeCastLib` to safely ensure that the `packed` number is small\n /// enough to fit in the desired unsigned integer type:\n /// ```\n /// uint32 packed = SafeCastLib.toUint32(FixedPointMathLib.packSci(777 ether));\n /// ```\n function packSci(uint256 x) internal pure returns (uint256 packed) {\n (x, packed) = sci(x); // Reuse for `mantissa` and `exponent`.\n /// @solidity memory-safe-assembly\n assembly {\n if shr(249, x) {\n mstore(0x00, 0xce30380c) // `MantissaOverflow()`.\n revert(0x1c, 0x04)\n }\n packed := or(shl(7, x), packed)\n }\n }\n\n /// @dev Convenience function for unpacking a packed number from `packSci`.\n function unpackSci(uint256 packed) internal pure returns (uint256 unpacked) {\n unchecked {\n unpacked = (packed >> 7) * 10 ** (packed & 0x7f);\n }\n }\n\n /// @dev Returns the average of `x` and `y`. Rounds towards zero.\n function avg(uint256 x, uint256 y) internal pure returns (uint256 z) {\n unchecked {\n z = (x & y) + ((x ^ y) >> 1);\n }\n }\n\n /// @dev Returns the average of `x` and `y`. Rounds towards negative infinity.\n function avg(int256 x, int256 y) internal pure returns (int256 z) {\n unchecked {\n z = (x >> 1) + (y >> 1) + (x & y & 1);\n }\n }\n\n /// @dev Returns the absolute value of `x`.\n function abs(int256 x) internal pure returns (uint256 z) {\n unchecked {\n z = (uint256(x) + uint256(x >> 255)) ^ uint256(x >> 255);\n }\n }\n\n /// @dev Returns the absolute distance between `x` and `y`.\n function dist(uint256 x, uint256 y) internal pure returns (uint256 z) {\n /// @solidity memory-safe-assembly\n assembly {\n z := add(xor(sub(0, gt(x, y)), sub(y, x)), gt(x, y))\n }\n }\n\n /// @dev Returns the absolute distance between `x` and `y`.\n function dist(int256 x, int256 y) internal pure returns (uint256 z) {\n /// @solidity memory-safe-assembly\n assembly {\n z := add(xor(sub(0, sgt(x, y)), sub(y, x)), sgt(x, y))\n }\n }\n\n /// @dev Returns the minimum of `x` and `y`.\n function min(uint256 x, uint256 y) internal pure returns (uint256 z) {\n /// @solidity memory-safe-assembly\n assembly {\n z := xor(x, mul(xor(x, y), lt(y, x)))\n }\n }\n\n /// @dev Returns the minimum of `x` and `y`.\n function min(int256 x, int256 y) internal pure returns (int256 z) {\n /// @solidity memory-safe-assembly\n assembly {\n z := xor(x, mul(xor(x, y), slt(y, x)))\n }\n }\n\n /// @dev Returns the maximum of `x` and `y`.\n function max(uint256 x, uint256 y) internal pure returns (uint256 z) {\n /// @solidity memory-safe-assembly\n assembly {\n z := xor(x, mul(xor(x, y), gt(y, x)))\n }\n }\n\n /// @dev Returns the maximum of `x` and `y`.\n function max(int256 x, int256 y) internal pure returns (int256 z) {\n /// @solidity memory-safe-assembly\n assembly {\n z := xor(x, mul(xor(x, y), sgt(y, x)))\n }\n }\n\n /// @dev Returns `x`, bounded to `minValue` and `maxValue`.\n function clamp(uint256 x, uint256 minValue, uint256 maxValue)\n internal\n pure\n returns (uint256 z)\n {\n /// @solidity memory-safe-assembly\n assembly {\n z := xor(x, mul(xor(x, minValue), gt(minValue, x)))\n z := xor(z, mul(xor(z, maxValue), lt(maxValue, z)))\n }\n }\n\n /// @dev Returns `x`, bounded to `minValue` and `maxValue`.\n function clamp(int256 x, int256 minValue, int256 maxValue) internal pure returns (int256 z) {\n /// @solidity memory-safe-assembly\n assembly {\n z := xor(x, mul(xor(x, minValue), sgt(minValue, x)))\n z := xor(z, mul(xor(z, maxValue), slt(maxValue, z)))\n }\n }\n\n /// @dev Returns greatest common divisor of `x` and `y`.\n function gcd(uint256 x, uint256 y) internal pure returns (uint256 z) {\n /// @solidity memory-safe-assembly\n assembly {\n for { z := x } y {} {\n let t := y\n y := mod(z, y)\n z := t\n }\n }\n }\n\n /// @dev Returns `a + (b - a) * (t - begin) / (end - begin)`,\n /// with `t` clamped between `begin` and `end` (inclusive).\n /// Agnostic to the order of (`a`, `b`) and (`end`, `begin`).\n /// If `begins == end`, returns `t <= begin ? a : b`.\n function lerp(uint256 a, uint256 b, uint256 t, uint256 begin, uint256 end)\n internal\n pure\n returns (uint256)\n {\n if (begin > end) (t, begin, end) = (~t, ~begin, ~end);\n if (t <= begin) return a;\n if (t >= end) return b;\n unchecked {\n if (b >= a) return a + fullMulDiv(b - a, t - begin, end - begin);\n return a - fullMulDiv(a - b, t - begin, end - begin);\n }\n }\n\n /// @dev Returns `a + (b - a) * (t - begin) / (end - begin)`.\n /// with `t` clamped between `begin` and `end` (inclusive).\n /// Agnostic to the order of (`a`, `b`) and (`end`, `begin`).\n /// If `begins == end`, returns `t <= begin ? a : b`.\n function lerp(int256 a, int256 b, int256 t, int256 begin, int256 end)\n internal\n pure\n returns (int256)\n {\n if (begin > end) (t, begin, end) = (~t, ~begin, ~end);\n if (t <= begin) return a;\n if (t >= end) return b;\n // forgefmt: disable-next-item\n unchecked {\n if (b >= a) return int256(uint256(a) + fullMulDiv(uint256(b - a),\n uint256(t - begin), uint256(end - begin)));\n return int256(uint256(a) - fullMulDiv(uint256(a - b),\n uint256(t - begin), uint256(end - begin)));\n }\n }\n\n /// @dev Returns if `x` is an even number. Some people may need this.\n function isEven(uint256 x) internal pure returns (bool) {\n return x & uint256(1) == uint256(0);\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* RAW NUMBER OPERATIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Returns `x + y`, without checking for overflow.\n function rawAdd(uint256 x, uint256 y) internal pure returns (uint256 z) {\n unchecked {\n z = x + y;\n }\n }\n\n /// @dev Returns `x + y`, without checking for overflow.\n function rawAdd(int256 x, int256 y) internal pure returns (int256 z) {\n unchecked {\n z = x + y;\n }\n }\n\n /// @dev Returns `x - y`, without checking for underflow.\n function rawSub(uint256 x, uint256 y) internal pure returns (uint256 z) {\n unchecked {\n z = x - y;\n }\n }\n\n /// @dev Returns `x - y`, without checking for underflow.\n function rawSub(int256 x, int256 y) internal pure returns (int256 z) {\n unchecked {\n z = x - y;\n }\n }\n\n /// @dev Returns `x * y`, without checking for overflow.\n function rawMul(uint256 x, uint256 y) internal pure returns (uint256 z) {\n unchecked {\n z = x * y;\n }\n }\n\n /// @dev Returns `x * y`, without checking for overflow.\n function rawMul(int256 x, int256 y) internal pure returns (int256 z) {\n unchecked {\n z = x * y;\n }\n }\n\n /// @dev Returns `x / y`, returning 0 if `y` is zero.\n function rawDiv(uint256 x, uint256 y) internal pure returns (uint256 z) {\n /// @solidity memory-safe-assembly\n assembly {\n z := div(x, y)\n }\n }\n\n /// @dev Returns `x / y`, returning 0 if `y` is zero.\n function rawSDiv(int256 x, int256 y) internal pure returns (int256 z) {\n /// @solidity memory-safe-assembly\n assembly {\n z := sdiv(x, y)\n }\n }\n\n /// @dev Returns `x % y`, returning 0 if `y` is zero.\n function rawMod(uint256 x, uint256 y) internal pure returns (uint256 z) {\n /// @solidity memory-safe-assembly\n assembly {\n z := mod(x, y)\n }\n }\n\n /// @dev Returns `x % y`, returning 0 if `y` is zero.\n function rawSMod(int256 x, int256 y) internal pure returns (int256 z) {\n /// @solidity memory-safe-assembly\n assembly {\n z := smod(x, y)\n }\n }\n\n /// @dev Returns `(x + y) % d`, return 0 if `d` if zero.\n function rawAddMod(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 z) {\n /// @solidity memory-safe-assembly\n assembly {\n z := addmod(x, y, d)\n }\n }\n\n /// @dev Returns `(x * y) % d`, return 0 if `d` if zero.\n function rawMulMod(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 z) {\n /// @solidity memory-safe-assembly\n assembly {\n z := mulmod(x, y, d)\n }\n }\n}\n"},"lib/solady/src/utils/LibClone.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Minimal proxy library.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibClone.sol)\n/// @author Minimal proxy by 0age (https://github.com/0age)\n/// @author Clones with immutable args by wighawag, zefram.eth, Saw-mon & Natalie\n/// (https://github.com/Saw-mon-and-Natalie/clones-with-immutable-args)\n/// @author Minimal ERC1967 proxy by jtriley-eth (https://github.com/jtriley-eth/minimum-viable-proxy)\n///\n/// @dev Minimal proxy:\n/// Although the sw0nt pattern saves 5 gas over the ERC1167 pattern during runtime,\n/// it is not supported out-of-the-box on Etherscan. Hence, we choose to use the 0age pattern,\n/// which saves 4 gas over the ERC1167 pattern during runtime, and has the smallest bytecode.\n/// - Automatically verified on Etherscan.\n///\n/// @dev Minimal proxy (PUSH0 variant):\n/// This is a new minimal proxy that uses the PUSH0 opcode introduced during Shanghai.\n/// It is optimized first for minimal runtime gas, then for minimal bytecode.\n/// The PUSH0 clone functions are intentionally postfixed with a jarring \"_PUSH0\" as\n/// many EVM chains may not support the PUSH0 opcode in the early months after Shanghai.\n/// Please use with caution.\n/// - Automatically verified on Etherscan.\n///\n/// @dev Clones with immutable args (CWIA):\n/// The implementation of CWIA here is does NOT append the immutable args into the calldata\n/// passed into delegatecall. It is simply an ERC1167 minimal proxy with the immutable arguments\n/// appended to the back of the runtime bytecode.\n/// - Uses the identity precompile (0x4) to copy args during deployment.\n///\n/// @dev Minimal ERC1967 proxy:\n/// An minimal ERC1967 proxy, intended to be upgraded with UUPS.\n/// This is NOT the same as ERC1967Factory's transparent proxy, which includes admin logic.\n/// - Automatically verified on Etherscan.\n///\n/// @dev Minimal ERC1967 proxy with immutable args:\n/// - Uses the identity precompile (0x4) to copy args during deployment.\n/// - Automatically verified on Etherscan.\n///\n/// @dev ERC1967I proxy:\n/// An variant of the minimal ERC1967 proxy, with a special code path that activates\n/// if `calldatasize() == 1`. This code path skips the delegatecall and directly returns the\n/// `implementation` address. The returned implementation is guaranteed to be valid if the\n/// keccak256 of the proxy's code is equal to `ERC1967I_CODE_HASH`.\n///\n/// @dev ERC1967I proxy with immutable args:\n/// An variant of the minimal ERC1967 proxy, with a special code path that activates\n/// if `calldatasize() == 1`. This code path skips the delegatecall and directly returns the\n/// - Uses the identity precompile (0x4) to copy args during deployment.\n///\n/// @dev Minimal ERC1967 beacon proxy:\n/// A minimal beacon proxy, intended to be upgraded with an upgradable beacon.\n/// - Automatically verified on Etherscan.\n///\n/// @dev Minimal ERC1967 beacon proxy with immutable args:\n/// - Uses the identity precompile (0x4) to copy args during deployment.\n/// - Automatically verified on Etherscan.\n///\n/// @dev ERC1967I beacon proxy:\n/// An variant of the minimal ERC1967 beacon proxy, with a special code path that activates\n/// if `calldatasize() == 1`. This code path skips the delegatecall and directly returns the\n/// `implementation` address. The returned implementation is guaranteed to be valid if the\n/// keccak256 of the proxy's code is equal to `ERC1967I_CODE_HASH`.\n///\n/// @dev ERC1967I proxy with immutable args:\n/// An variant of the minimal ERC1967 beacon proxy, with a special code path that activates\n/// if `calldatasize() == 1`. This code path skips the delegatecall and directly returns the\n/// - Uses the identity precompile (0x4) to copy args during deployment.\nlibrary LibClone {\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* CONSTANTS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev The keccak256 of deployed code for the clone proxy,\n /// with the implementation set to `address(0)`.\n bytes32 internal constant CLONE_CODE_HASH =\n 0x48db2cfdb2853fce0b464f1f93a1996469459df3ab6c812106074c4106a1eb1f;\n\n /// @dev The keccak256 of deployed code for the PUSH0 proxy,\n /// with the implementation set to `address(0)`.\n bytes32 internal constant PUSH0_CLONE_CODE_HASH =\n 0x67bc6bde1b84d66e267c718ba44cf3928a615d29885537955cb43d44b3e789dc;\n\n /// @dev The keccak256 of deployed code for the ERC-1167 CWIA proxy,\n /// with the implementation set to `address(0)`.\n bytes32 internal constant CWIA_CODE_HASH =\n 0x3cf92464268225a4513da40a34d967354684c32cd0edd67b5f668dfe3550e940;\n\n /// @dev The keccak256 of the deployed code for the ERC1967 proxy.\n bytes32 internal constant ERC1967_CODE_HASH =\n 0xaaa52c8cc8a0e3fd27ce756cc6b4e70c51423e9b597b11f32d3e49f8b1fc890d;\n\n /// @dev The keccak256 of the deployed code for the ERC1967I proxy.\n bytes32 internal constant ERC1967I_CODE_HASH =\n 0xce700223c0d4cea4583409accfc45adac4a093b3519998a9cbbe1504dadba6f7;\n\n /// @dev The keccak256 of the deployed code for the ERC1967 beacon proxy.\n bytes32 internal constant ERC1967_BEACON_PROXY_CODE_HASH =\n 0x14044459af17bc4f0f5aa2f658cb692add77d1302c29fe2aebab005eea9d1162;\n\n /// @dev The keccak256 of the deployed code for the ERC1967 beacon proxy.\n bytes32 internal constant ERC1967I_BEACON_PROXY_CODE_HASH =\n 0xf8c46d2793d5aa984eb827aeaba4b63aedcab80119212fce827309788735519a;\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* CUSTOM ERRORS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Unable to deploy the clone.\n error DeploymentFailed();\n\n /// @dev The salt must start with either the zero address or `by`.\n error SaltDoesNotStartWith();\n\n /// @dev The ETH transfer has failed.\n error ETHTransferFailed();\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* MINIMAL PROXY OPERATIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Deploys a clone of `implementation`.\n function clone(address implementation) internal returns (address instance) {\n instance = clone(0, implementation);\n }\n\n /// @dev Deploys a clone of `implementation`.\n /// Deposits `value` ETH during deployment.\n function clone(uint256 value, address implementation) internal returns (address instance) {\n /// @solidity memory-safe-assembly\n assembly {\n /**\n * --------------------------------------------------------------------------+\n * CREATION (9 bytes) |\n * --------------------------------------------------------------------------|\n * Opcode | Mnemonic | Stack | Memory |\n * --------------------------------------------------------------------------|\n * 60 runSize | PUSH1 runSize | r | |\n * 3d | RETURNDATASIZE | 0 r | |\n * 81 | DUP2 | r 0 r | |\n * 60 offset | PUSH1 offset | o r 0 r | |\n * 3d | RETURNDATASIZE | 0 o r 0 r | |\n * 39 | CODECOPY | 0 r | [0..runSize): runtime code |\n * f3 | RETURN | | [0..runSize): runtime code |\n * --------------------------------------------------------------------------|\n * RUNTIME (44 bytes) |\n * --------------------------------------------------------------------------|\n * Opcode | Mnemonic | Stack | Memory |\n * --------------------------------------------------------------------------|\n * |\n * ::: keep some values in stack ::::::::::::::::::::::::::::::::::::::::::: |\n * 3d | RETURNDATASIZE | 0 | |\n * 3d | RETURNDATASIZE | 0 0 | |\n * 3d | RETURNDATASIZE | 0 0 0 | |\n * 3d | RETURNDATASIZE | 0 0 0 0 | |\n * |\n * ::: copy calldata to memory ::::::::::::::::::::::::::::::::::::::::::::: |\n * 36 | CALLDATASIZE | cds 0 0 0 0 | |\n * 3d | RETURNDATASIZE | 0 cds 0 0 0 0 | |\n * 3d | RETURNDATASIZE | 0 0 cds 0 0 0 0 | |\n * 37 | CALLDATACOPY | 0 0 0 0 | [0..cds): calldata |\n * |\n * ::: delegate call to the implementation contract :::::::::::::::::::::::: |\n * 36 | CALLDATASIZE | cds 0 0 0 0 | [0..cds): calldata |\n * 3d | RETURNDATASIZE | 0 cds 0 0 0 0 | [0..cds): calldata |\n * 73 addr | PUSH20 addr | addr 0 cds 0 0 0 0 | [0..cds): calldata |\n * 5a | GAS | gas addr 0 cds 0 0 0 0 | [0..cds): calldata |\n * f4 | DELEGATECALL | success 0 0 | [0..cds): calldata |\n * |\n * ::: copy return data to memory :::::::::::::::::::::::::::::::::::::::::: |\n * 3d | RETURNDATASIZE | rds success 0 0 | [0..cds): calldata |\n * 3d | RETURNDATASIZE | rds rds success 0 0 | [0..cds): calldata |\n * 93 | SWAP4 | 0 rds success 0 rds | [0..cds): calldata |\n * 80 | DUP1 | 0 0 rds success 0 rds | [0..cds): calldata |\n * 3e | RETURNDATACOPY | success 0 rds | [0..rds): returndata |\n * |\n * 60 0x2a | PUSH1 0x2a | 0x2a success 0 rds | [0..rds): returndata |\n * 57 | JUMPI | 0 rds | [0..rds): returndata |\n * |\n * ::: revert :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: |\n * fd | REVERT | | [0..rds): returndata |\n * |\n * ::: return :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: |\n * 5b | JUMPDEST | 0 rds | [0..rds): returndata |\n * f3 | RETURN | | [0..rds): returndata |\n * --------------------------------------------------------------------------+\n */\n mstore(0x21, 0x5af43d3d93803e602a57fd5bf3)\n mstore(0x14, implementation)\n mstore(0x00, 0x602c3d8160093d39f33d3d3d3d363d3d37363d73)\n instance := create(value, 0x0c, 0x35)\n if iszero(instance) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n mstore(0x21, 0) // Restore the overwritten part of the free memory pointer.\n }\n }\n\n /// @dev Deploys a deterministic clone of `implementation` with `salt`.\n function cloneDeterministic(address implementation, bytes32 salt)\n internal\n returns (address instance)\n {\n instance = cloneDeterministic(0, implementation, salt);\n }\n\n /// @dev Deploys a deterministic clone of `implementation` with `salt`.\n /// Deposits `value` ETH during deployment.\n function cloneDeterministic(uint256 value, address implementation, bytes32 salt)\n internal\n returns (address instance)\n {\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x21, 0x5af43d3d93803e602a57fd5bf3)\n mstore(0x14, implementation)\n mstore(0x00, 0x602c3d8160093d39f33d3d3d3d363d3d37363d73)\n instance := create2(value, 0x0c, 0x35, salt)\n if iszero(instance) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n mstore(0x21, 0) // Restore the overwritten part of the free memory pointer.\n }\n }\n\n /// @dev Returns the initialization code of the clone of `implementation`.\n function initCode(address implementation) internal pure returns (bytes memory c) {\n /// @solidity memory-safe-assembly\n assembly {\n c := mload(0x40)\n mstore(add(c, 0x40), 0x5af43d3d93803e602a57fd5bf30000000000000000000000)\n mstore(add(c, 0x28), implementation)\n mstore(add(c, 0x14), 0x602c3d8160093d39f33d3d3d3d363d3d37363d73)\n mstore(c, 0x35) // Store the length.\n mstore(0x40, add(c, 0x60)) // Allocate memory.\n }\n }\n\n /// @dev Returns the initialization code hash of the clone of `implementation`.\n function initCodeHash(address implementation) internal pure returns (bytes32 hash) {\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x21, 0x5af43d3d93803e602a57fd5bf3)\n mstore(0x14, implementation)\n mstore(0x00, 0x602c3d8160093d39f33d3d3d3d363d3d37363d73)\n hash := keccak256(0x0c, 0x35)\n mstore(0x21, 0) // Restore the overwritten part of the free memory pointer.\n }\n }\n\n /// @dev Returns the address of the clone of `implementation`, with `salt` by `deployer`.\n /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n function predictDeterministicAddress(address implementation, bytes32 salt, address deployer)\n internal\n pure\n returns (address predicted)\n {\n bytes32 hash = initCodeHash(implementation);\n predicted = predictDeterministicAddress(hash, salt, deployer);\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* MINIMAL PROXY OPERATIONS (PUSH0 VARIANT) */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Deploys a PUSH0 clone of `implementation`.\n function clone_PUSH0(address implementation) internal returns (address instance) {\n instance = clone_PUSH0(0, implementation);\n }\n\n /// @dev Deploys a PUSH0 clone of `implementation`.\n /// Deposits `value` ETH during deployment.\n function clone_PUSH0(uint256 value, address implementation)\n internal\n returns (address instance)\n {\n /// @solidity memory-safe-assembly\n assembly {\n /**\n * --------------------------------------------------------------------------+\n * CREATION (9 bytes) |\n * --------------------------------------------------------------------------|\n * Opcode | Mnemonic | Stack | Memory |\n * --------------------------------------------------------------------------|\n * 60 runSize | PUSH1 runSize | r | |\n * 5f | PUSH0 | 0 r | |\n * 81 | DUP2 | r 0 r | |\n * 60 offset | PUSH1 offset | o r 0 r | |\n * 5f | PUSH0 | 0 o r 0 r | |\n * 39 | CODECOPY | 0 r | [0..runSize): runtime code |\n * f3 | RETURN | | [0..runSize): runtime code |\n * --------------------------------------------------------------------------|\n * RUNTIME (45 bytes) |\n * --------------------------------------------------------------------------|\n * Opcode | Mnemonic | Stack | Memory |\n * --------------------------------------------------------------------------|\n * |\n * ::: keep some values in stack ::::::::::::::::::::::::::::::::::::::::::: |\n * 5f | PUSH0 | 0 | |\n * 5f | PUSH0 | 0 0 | |\n * |\n * ::: copy calldata to memory ::::::::::::::::::::::::::::::::::::::::::::: |\n * 36 | CALLDATASIZE | cds 0 0 | |\n * 5f | PUSH0 | 0 cds 0 0 | |\n * 5f | PUSH0 | 0 0 cds 0 0 | |\n * 37 | CALLDATACOPY | 0 0 | [0..cds): calldata |\n * |\n * ::: delegate call to the implementation contract :::::::::::::::::::::::: |\n * 36 | CALLDATASIZE | cds 0 0 | [0..cds): calldata |\n * 5f | PUSH0 | 0 cds 0 0 | [0..cds): calldata |\n * 73 addr | PUSH20 addr | addr 0 cds 0 0 | [0..cds): calldata |\n * 5a | GAS | gas addr 0 cds 0 0 | [0..cds): calldata |\n * f4 | DELEGATECALL | success | [0..cds): calldata |\n * |\n * ::: copy return data to memory :::::::::::::::::::::::::::::::::::::::::: |\n * 3d | RETURNDATASIZE | rds success | [0..cds): calldata |\n * 5f | PUSH0 | 0 rds success | [0..cds): calldata |\n * 5f | PUSH0 | 0 0 rds success | [0..cds): calldata |\n * 3e | RETURNDATACOPY | success | [0..rds): returndata |\n * |\n * 60 0x29 | PUSH1 0x29 | 0x29 success | [0..rds): returndata |\n * 57 | JUMPI | | [0..rds): returndata |\n * |\n * ::: revert :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: |\n * 3d | RETURNDATASIZE | rds | [0..rds): returndata |\n * 5f | PUSH0 | 0 rds | [0..rds): returndata |\n * fd | REVERT | | [0..rds): returndata |\n * |\n * ::: return :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: |\n * 5b | JUMPDEST | | [0..rds): returndata |\n * 3d | RETURNDATASIZE | rds | [0..rds): returndata |\n * 5f | PUSH0 | 0 rds | [0..rds): returndata |\n * f3 | RETURN | | [0..rds): returndata |\n * --------------------------------------------------------------------------+\n */\n mstore(0x24, 0x5af43d5f5f3e6029573d5ffd5b3d5ff3) // 16\n mstore(0x14, implementation) // 20\n mstore(0x00, 0x602d5f8160095f39f35f5f365f5f37365f73) // 9 + 9\n instance := create(value, 0x0e, 0x36)\n if iszero(instance) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n mstore(0x24, 0) // Restore the overwritten part of the free memory pointer.\n }\n }\n\n /// @dev Deploys a deterministic PUSH0 clone of `implementation` with `salt`.\n function cloneDeterministic_PUSH0(address implementation, bytes32 salt)\n internal\n returns (address instance)\n {\n instance = cloneDeterministic_PUSH0(0, implementation, salt);\n }\n\n /// @dev Deploys a deterministic PUSH0 clone of `implementation` with `salt`.\n /// Deposits `value` ETH during deployment.\n function cloneDeterministic_PUSH0(uint256 value, address implementation, bytes32 salt)\n internal\n returns (address instance)\n {\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x24, 0x5af43d5f5f3e6029573d5ffd5b3d5ff3) // 16\n mstore(0x14, implementation) // 20\n mstore(0x00, 0x602d5f8160095f39f35f5f365f5f37365f73) // 9 + 9\n instance := create2(value, 0x0e, 0x36, salt)\n if iszero(instance) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n mstore(0x24, 0) // Restore the overwritten part of the free memory pointer.\n }\n }\n\n /// @dev Returns the initialization code of the PUSH0 clone of `implementation`.\n function initCode_PUSH0(address implementation) internal pure returns (bytes memory c) {\n /// @solidity memory-safe-assembly\n assembly {\n c := mload(0x40)\n mstore(add(c, 0x40), 0x5af43d5f5f3e6029573d5ffd5b3d5ff300000000000000000000) // 16\n mstore(add(c, 0x26), implementation) // 20\n mstore(add(c, 0x12), 0x602d5f8160095f39f35f5f365f5f37365f73) // 9 + 9\n mstore(c, 0x36) // Store the length.\n mstore(0x40, add(c, 0x60)) // Allocate memory.\n }\n }\n\n /// @dev Returns the initialization code hash of the PUSH0 clone of `implementation`.\n function initCodeHash_PUSH0(address implementation) internal pure returns (bytes32 hash) {\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x24, 0x5af43d5f5f3e6029573d5ffd5b3d5ff3) // 16\n mstore(0x14, implementation) // 20\n mstore(0x00, 0x602d5f8160095f39f35f5f365f5f37365f73) // 9 + 9\n hash := keccak256(0x0e, 0x36)\n mstore(0x24, 0) // Restore the overwritten part of the free memory pointer.\n }\n }\n\n /// @dev Returns the address of the PUSH0 clone of `implementation`, with `salt` by `deployer`.\n /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n function predictDeterministicAddress_PUSH0(\n address implementation,\n bytes32 salt,\n address deployer\n ) internal pure returns (address predicted) {\n bytes32 hash = initCodeHash_PUSH0(implementation);\n predicted = predictDeterministicAddress(hash, salt, deployer);\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* CLONES WITH IMMUTABLE ARGS OPERATIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Deploys a clone of `implementation` with immutable arguments encoded in `args`.\n function clone(address implementation, bytes memory args) internal returns (address instance) {\n instance = clone(0, implementation, args);\n }\n\n /// @dev Deploys a clone of `implementation` with immutable arguments encoded in `args`.\n /// Deposits `value` ETH during deployment.\n function clone(uint256 value, address implementation, bytes memory args)\n internal\n returns (address instance)\n {\n /// @solidity memory-safe-assembly\n assembly {\n /**\n * ---------------------------------------------------------------------------+\n * CREATION (10 bytes) |\n * ---------------------------------------------------------------------------|\n * Opcode | Mnemonic | Stack | Memory |\n * ---------------------------------------------------------------------------|\n * 61 runSize | PUSH2 runSize | r | |\n * 3d | RETURNDATASIZE | 0 r | |\n * 81 | DUP2 | r 0 r | |\n * 60 offset | PUSH1 offset | o r 0 r | |\n * 3d | RETURNDATASIZE | 0 o r 0 r | |\n * 39 | CODECOPY | 0 r | [0..runSize): runtime code |\n * f3 | RETURN | | [0..runSize): runtime code |\n * ---------------------------------------------------------------------------|\n * RUNTIME (45 bytes + extraLength) |\n * ---------------------------------------------------------------------------|\n * Opcode | Mnemonic | Stack | Memory |\n * ---------------------------------------------------------------------------|\n * |\n * ::: copy calldata to memory :::::::::::::::::::::::::::::::::::::::::::::: |\n * 36 | CALLDATASIZE | cds | |\n * 3d | RETURNDATASIZE | 0 cds | |\n * 3d | RETURNDATASIZE | 0 0 cds | |\n * 37 | CALLDATACOPY | | [0..cds): calldata |\n * |\n * ::: delegate call to the implementation contract ::::::::::::::::::::::::: |\n * 3d | RETURNDATASIZE | 0 | [0..cds): calldata |\n * 3d | RETURNDATASIZE | 0 0 | [0..cds): calldata |\n * 3d | RETURNDATASIZE | 0 0 0 | [0..cds): calldata |\n * 36 | CALLDATASIZE | cds 0 0 0 | [0..cds): calldata |\n * 3d | RETURNDATASIZE | 0 cds 0 0 0 0 | [0..cds): calldata |\n * 73 addr | PUSH20 addr | addr 0 cds 0 0 0 0 | [0..cds): calldata |\n * 5a | GAS | gas addr 0 cds 0 0 0 0 | [0..cds): calldata |\n * f4 | DELEGATECALL | success 0 0 | [0..cds): calldata |\n * |\n * ::: copy return data to memory ::::::::::::::::::::::::::::::::::::::::::: |\n * 3d | RETURNDATASIZE | rds success 0 | [0..cds): calldata |\n * 82 | DUP3 | 0 rds success 0 | [0..cds): calldata |\n * 80 | DUP1 | 0 0 rds success 0 | [0..cds): calldata |\n * 3e | RETURNDATACOPY | success 0 | [0..rds): returndata |\n * 90 | SWAP1 | 0 success | [0..rds): returndata |\n * 3d | RETURNDATASIZE | rds 0 success | [0..rds): returndata |\n * 91 | SWAP2 | success 0 rds | [0..rds): returndata |\n * |\n * 60 0x2b | PUSH1 0x2b | 0x2b success 0 rds | [0..rds): returndata |\n * 57 | JUMPI | 0 rds | [0..rds): returndata |\n * |\n * ::: revert ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: |\n * fd | REVERT | | [0..rds): returndata |\n * |\n * ::: return ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: |\n * 5b | JUMPDEST | 0 rds | [0..rds): returndata |\n * f3 | RETURN | | [0..rds): returndata |\n * ---------------------------------------------------------------------------+\n */\n let m := mload(0x40)\n let n := mload(args)\n pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x43), n))\n mstore(add(m, 0x23), 0x5af43d82803e903d91602b57fd5bf3)\n mstore(add(m, 0x14), implementation)\n mstore(m, add(0xfe61002d3d81600a3d39f3363d3d373d3d3d363d73, shl(136, n)))\n // Do a out-of-gas revert if `n` is greater than `0xffff - 0x2d = 0xffd2`.\n instance := create(value, add(m, add(0x0b, lt(n, 0xffd3))), add(n, 0x37))\n if iszero(instance) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n }\n }\n\n /// @dev Deploys a deterministic clone of `implementation`\n /// with immutable arguments encoded in `args` and `salt`.\n function cloneDeterministic(address implementation, bytes memory args, bytes32 salt)\n internal\n returns (address instance)\n {\n instance = cloneDeterministic(0, implementation, args, salt);\n }\n\n /// @dev Deploys a deterministic clone of `implementation`\n /// with immutable arguments encoded in `args` and `salt`.\n function cloneDeterministic(\n uint256 value,\n address implementation,\n bytes memory args,\n bytes32 salt\n ) internal returns (address instance) {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40)\n let n := mload(args)\n pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x43), n))\n mstore(add(m, 0x23), 0x5af43d82803e903d91602b57fd5bf3)\n mstore(add(m, 0x14), implementation)\n mstore(m, add(0xfe61002d3d81600a3d39f3363d3d373d3d3d363d73, shl(136, n)))\n // Do a out-of-gas revert if `n` is greater than `0xffff - 0x2d = 0xffd2`.\n instance := create2(value, add(m, add(0x0b, lt(n, 0xffd3))), add(n, 0x37), salt)\n if iszero(instance) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n }\n }\n\n /// @dev Deploys a deterministic clone of `implementation`\n /// with immutable arguments encoded in `args` and `salt`.\n /// This method does not revert if the clone has already been deployed.\n function createDeterministicClone(address implementation, bytes memory args, bytes32 salt)\n internal\n returns (bool alreadyDeployed, address instance)\n {\n return createDeterministicClone(0, implementation, args, salt);\n }\n\n /// @dev Deploys a deterministic clone of `implementation`\n /// with immutable arguments encoded in `args` and `salt`.\n /// This method does not revert if the clone has already been deployed.\n function createDeterministicClone(\n uint256 value,\n address implementation,\n bytes memory args,\n bytes32 salt\n ) internal returns (bool alreadyDeployed, address instance) {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40)\n let n := mload(args)\n pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x43), n))\n mstore(add(m, 0x23), 0x5af43d82803e903d91602b57fd5bf3)\n mstore(add(m, 0x14), implementation)\n // Do a out-of-gas revert if `n` is greater than `0xffff - 0x2d = 0xffd2`.\n // forgefmt: disable-next-item\n mstore(add(m, gt(n, 0xffd2)), add(0xfe61002d3d81600a3d39f3363d3d373d3d3d363d73, shl(136, n)))\n // Compute and store the bytecode hash.\n mstore8(0x00, 0xff) // Write the prefix.\n mstore(0x35, keccak256(add(m, 0x0c), add(n, 0x37)))\n mstore(0x01, shl(96, address()))\n mstore(0x15, salt)\n instance := keccak256(0x00, 0x55)\n for {} 1 {} {\n if iszero(extcodesize(instance)) {\n instance := create2(value, add(m, 0x0c), add(n, 0x37), salt)\n if iszero(instance) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n break\n }\n alreadyDeployed := 1\n if iszero(value) { break }\n if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {\n mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n revert(0x1c, 0x04)\n }\n break\n }\n mstore(0x35, 0) // Restore the overwritten part of the free memory pointer.\n }\n }\n\n /// @dev Returns the initialization code hash of the clone of `implementation`\n /// using immutable arguments encoded in `args`.\n function initCode(address implementation, bytes memory args)\n internal\n pure\n returns (bytes memory c)\n {\n /// @solidity memory-safe-assembly\n assembly {\n c := mload(0x40)\n let n := mload(args)\n // Do a out-of-gas revert if `n` is greater than `0xffff - 0x2d = 0xffd2`.\n returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffd2))\n for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {\n mstore(add(add(c, 0x57), i), mload(add(add(args, 0x20), i)))\n }\n mstore(add(c, 0x37), 0x5af43d82803e903d91602b57fd5bf3)\n mstore(add(c, 0x28), implementation)\n mstore(add(c, 0x14), add(0x61002d3d81600a3d39f3363d3d373d3d3d363d73, shl(136, n)))\n mstore(c, add(0x37, n)) // Store the length.\n mstore(add(c, add(n, 0x57)), 0) // Zeroize the slot after the bytes.\n mstore(0x40, add(c, add(n, 0x77))) // Allocate memory.\n }\n }\n\n /// @dev Returns the initialization code hash of the clone of `implementation`\n /// using immutable arguments encoded in `args`.\n function initCodeHash(address implementation, bytes memory args)\n internal\n pure\n returns (bytes32 hash)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40)\n let n := mload(args)\n // Do a out-of-gas revert if `n` is greater than `0xffff - 0x2d = 0xffd2`.\n returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffd2))\n for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {\n mstore(add(add(m, 0x43), i), mload(add(add(args, 0x20), i)))\n }\n mstore(add(m, 0x23), 0x5af43d82803e903d91602b57fd5bf3)\n mstore(add(m, 0x14), implementation)\n mstore(m, add(0x61002d3d81600a3d39f3363d3d373d3d3d363d73, shl(136, n)))\n hash := keccak256(add(m, 0x0c), add(n, 0x37))\n }\n }\n\n /// @dev Returns the address of the clone of\n /// `implementation` using immutable arguments encoded in `args`, with `salt`, by `deployer`.\n /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n function predictDeterministicAddress(\n address implementation,\n bytes memory data,\n bytes32 salt,\n address deployer\n ) internal pure returns (address predicted) {\n bytes32 hash = initCodeHash(implementation, data);\n predicted = predictDeterministicAddress(hash, salt, deployer);\n }\n\n /// @dev Equivalent to `argsOnClone(instance, 0, 2 ** 256 - 1)`.\n function argsOnClone(address instance) internal view returns (bytes memory args) {\n /// @solidity memory-safe-assembly\n assembly {\n args := mload(0x40)\n mstore(args, and(0xffffffffff, sub(extcodesize(instance), 0x2d))) // Store the length.\n extcodecopy(instance, add(args, 0x20), 0x2d, add(mload(args), 0x20))\n mstore(0x40, add(mload(args), add(args, 0x40))) // Allocate memory.\n }\n }\n\n /// @dev Equivalent to `argsOnClone(instance, start, 2 ** 256 - 1)`.\n function argsOnClone(address instance, uint256 start)\n internal\n view\n returns (bytes memory args)\n {\n /// @solidity memory-safe-assembly\n assembly {\n args := mload(0x40)\n let n := and(0xffffffffff, sub(extcodesize(instance), 0x2d))\n extcodecopy(instance, add(args, 0x20), add(start, 0x2d), add(n, 0x20))\n mstore(args, mul(sub(n, start), lt(start, n))) // Store the length.\n mstore(0x40, add(args, add(0x40, mload(args)))) // Allocate memory.\n }\n }\n\n /// @dev Returns a slice of the immutable arguments on `instance` from `start` to `end`.\n /// `start` and `end` will be clamped to the range `[0, args.length]`.\n /// The `instance` MUST be deployed via the clone with immutable args functions.\n /// Otherwise, the behavior is undefined.\n /// Out-of-gas reverts if `instance` does not have any code.\n function argsOnClone(address instance, uint256 start, uint256 end)\n internal\n view\n returns (bytes memory args)\n {\n /// @solidity memory-safe-assembly\n assembly {\n args := mload(0x40)\n if iszero(lt(end, 0xffff)) { end := 0xffff }\n let d := mul(sub(end, start), lt(start, end))\n extcodecopy(instance, args, add(start, 0x0d), add(d, 0x20))\n if iszero(and(0xff, mload(add(args, d)))) {\n let n := sub(extcodesize(instance), 0x2d)\n returndatacopy(returndatasize(), returndatasize(), shr(40, n))\n d := mul(gt(n, start), sub(d, mul(gt(end, n), sub(end, n))))\n }\n mstore(args, d) // Store the length.\n mstore(add(add(args, 0x20), d), 0) // Zeroize the slot after the bytes.\n mstore(0x40, add(add(args, 0x40), d)) // Allocate memory.\n }\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* MINIMAL ERC1967 PROXY OPERATIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n // Note: The ERC1967 proxy here is intended to be upgraded with UUPS.\n // This is NOT the same as ERC1967Factory's transparent proxy, which includes admin logic.\n\n /// @dev Deploys a minimal ERC1967 proxy with `implementation`.\n function deployERC1967(address implementation) internal returns (address instance) {\n instance = deployERC1967(0, implementation);\n }\n\n /// @dev Deploys a minimal ERC1967 proxy with `implementation`.\n /// Deposits `value` ETH during deployment.\n function deployERC1967(uint256 value, address implementation)\n internal\n returns (address instance)\n {\n /// @solidity memory-safe-assembly\n assembly {\n /**\n * ---------------------------------------------------------------------------------+\n * CREATION (34 bytes) |\n * ---------------------------------------------------------------------------------|\n * Opcode | Mnemonic | Stack | Memory |\n * ---------------------------------------------------------------------------------|\n * 60 runSize | PUSH1 runSize | r | |\n * 3d | RETURNDATASIZE | 0 r | |\n * 81 | DUP2 | r 0 r | |\n * 60 offset | PUSH1 offset | o r 0 r | |\n * 3d | RETURNDATASIZE | 0 o r 0 r | |\n * 39 | CODECOPY | 0 r | [0..runSize): runtime code |\n * 73 impl | PUSH20 impl | impl 0 r | [0..runSize): runtime code |\n * 60 slotPos | PUSH1 slotPos | slotPos impl 0 r | [0..runSize): runtime code |\n * 51 | MLOAD | slot impl 0 r | [0..runSize): runtime code |\n * 55 | SSTORE | 0 r | [0..runSize): runtime code |\n * f3 | RETURN | | [0..runSize): runtime code |\n * ---------------------------------------------------------------------------------|\n * RUNTIME (61 bytes) |\n * ---------------------------------------------------------------------------------|\n * Opcode | Mnemonic | Stack | Memory |\n * ---------------------------------------------------------------------------------|\n * |\n * ::: copy calldata to memory :::::::::::::::::::::::::::::::::::::::::::::::::::: |\n * 36 | CALLDATASIZE | cds | |\n * 3d | RETURNDATASIZE | 0 cds | |\n * 3d | RETURNDATASIZE | 0 0 cds | |\n * 37 | CALLDATACOPY | | [0..calldatasize): calldata |\n * |\n * ::: delegatecall to implementation ::::::::::::::::::::::::::::::::::::::::::::: |\n * 3d | RETURNDATASIZE | 0 | |\n * 3d | RETURNDATASIZE | 0 0 | |\n * 36 | CALLDATASIZE | cds 0 0 | [0..calldatasize): calldata |\n * 3d | RETURNDATASIZE | 0 cds 0 0 | [0..calldatasize): calldata |\n * 7f slot | PUSH32 slot | s 0 cds 0 0 | [0..calldatasize): calldata |\n * 54 | SLOAD | i 0 cds 0 0 | [0..calldatasize): calldata |\n * 5a | GAS | g i 0 cds 0 0 | [0..calldatasize): calldata |\n * f4 | DELEGATECALL | succ | [0..calldatasize): calldata |\n * |\n * ::: copy returndata to memory :::::::::::::::::::::::::::::::::::::::::::::::::: |\n * 3d | RETURNDATASIZE | rds succ | [0..calldatasize): calldata |\n * 60 0x00 | PUSH1 0x00 | 0 rds succ | [0..calldatasize): calldata |\n * 80 | DUP1 | 0 0 rds succ | [0..calldatasize): calldata |\n * 3e | RETURNDATACOPY | succ | [0..returndatasize): returndata |\n * |\n * ::: branch on delegatecall status :::::::::::::::::::::::::::::::::::::::::::::: |\n * 60 0x38 | PUSH1 0x38 | dest succ | [0..returndatasize): returndata |\n * 57 | JUMPI | | [0..returndatasize): returndata |\n * |\n * ::: delegatecall failed, revert :::::::::::::::::::::::::::::::::::::::::::::::: |\n * 3d | RETURNDATASIZE | rds | [0..returndatasize): returndata |\n * 60 0x00 | PUSH1 0x00 | 0 rds | [0..returndatasize): returndata |\n * fd | REVERT | | [0..returndatasize): returndata |\n * |\n * ::: delegatecall succeeded, return ::::::::::::::::::::::::::::::::::::::::::::: |\n * 5b | JUMPDEST | | [0..returndatasize): returndata |\n * 3d | RETURNDATASIZE | rds | [0..returndatasize): returndata |\n * 60 0x00 | PUSH1 0x00 | 0 rds | [0..returndatasize): returndata |\n * f3 | RETURN | | [0..returndatasize): returndata |\n * ---------------------------------------------------------------------------------+\n */\n let m := mload(0x40) // Cache the free memory pointer.\n mstore(0x60, 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)\n mstore(0x40, 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)\n mstore(0x20, 0x6009)\n mstore(0x1e, implementation)\n mstore(0x0a, 0x603d3d8160223d3973)\n instance := create(value, 0x21, 0x5f)\n if iszero(instance) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n mstore(0x40, m) // Restore the free memory pointer.\n mstore(0x60, 0) // Restore the zero slot.\n }\n }\n\n /// @dev Deploys a deterministic minimal ERC1967 proxy with `implementation` and `salt`.\n function deployDeterministicERC1967(address implementation, bytes32 salt)\n internal\n returns (address instance)\n {\n instance = deployDeterministicERC1967(0, implementation, salt);\n }\n\n /// @dev Deploys a deterministic minimal ERC1967 proxy with `implementation` and `salt`.\n /// Deposits `value` ETH during deployment.\n function deployDeterministicERC1967(uint256 value, address implementation, bytes32 salt)\n internal\n returns (address instance)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40) // Cache the free memory pointer.\n mstore(0x60, 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)\n mstore(0x40, 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)\n mstore(0x20, 0x6009)\n mstore(0x1e, implementation)\n mstore(0x0a, 0x603d3d8160223d3973)\n instance := create2(value, 0x21, 0x5f, salt)\n if iszero(instance) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n mstore(0x40, m) // Restore the free memory pointer.\n mstore(0x60, 0) // Restore the zero slot.\n }\n }\n\n /// @dev Creates a deterministic minimal ERC1967 proxy with `implementation` and `salt`.\n /// Note: This method is intended for use in ERC4337 factories,\n /// which are expected to NOT revert if the proxy is already deployed.\n function createDeterministicERC1967(address implementation, bytes32 salt)\n internal\n returns (bool alreadyDeployed, address instance)\n {\n return createDeterministicERC1967(0, implementation, salt);\n }\n\n /// @dev Creates a deterministic minimal ERC1967 proxy with `implementation` and `salt`.\n /// Deposits `value` ETH during deployment.\n /// Note: This method is intended for use in ERC4337 factories,\n /// which are expected to NOT revert if the proxy is already deployed.\n function createDeterministicERC1967(uint256 value, address implementation, bytes32 salt)\n internal\n returns (bool alreadyDeployed, address instance)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40) // Cache the free memory pointer.\n mstore(0x60, 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)\n mstore(0x40, 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)\n mstore(0x20, 0x6009)\n mstore(0x1e, implementation)\n mstore(0x0a, 0x603d3d8160223d3973)\n // Compute and store the bytecode hash.\n mstore(add(m, 0x35), keccak256(0x21, 0x5f))\n mstore(m, shl(88, address()))\n mstore8(m, 0xff) // Write the prefix.\n mstore(add(m, 0x15), salt)\n instance := keccak256(m, 0x55)\n for {} 1 {} {\n if iszero(extcodesize(instance)) {\n instance := create2(value, 0x21, 0x5f, salt)\n if iszero(instance) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n break\n }\n alreadyDeployed := 1\n if iszero(value) { break }\n if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {\n mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n revert(0x1c, 0x04)\n }\n break\n }\n mstore(0x40, m) // Restore the free memory pointer.\n mstore(0x60, 0) // Restore the zero slot.\n }\n }\n\n /// @dev Returns the initialization code of the minimal ERC1967 proxy of `implementation`.\n function initCodeERC1967(address implementation) internal pure returns (bytes memory c) {\n /// @solidity memory-safe-assembly\n assembly {\n c := mload(0x40)\n mstore(add(c, 0x60), 0x3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f300)\n mstore(add(c, 0x40), 0x55f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076cc)\n mstore(add(c, 0x20), or(shl(24, implementation), 0x600951))\n mstore(add(c, 0x09), 0x603d3d8160223d3973)\n mstore(c, 0x5f) // Store the length.\n mstore(0x40, add(c, 0x80)) // Allocate memory.\n }\n }\n\n /// @dev Returns the initialization code hash of the minimal ERC1967 proxy of `implementation`.\n function initCodeHashERC1967(address implementation) internal pure returns (bytes32 hash) {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40) // Cache the free memory pointer.\n mstore(0x60, 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)\n mstore(0x40, 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)\n mstore(0x20, 0x6009)\n mstore(0x1e, implementation)\n mstore(0x0a, 0x603d3d8160223d3973)\n hash := keccak256(0x21, 0x5f)\n mstore(0x40, m) // Restore the free memory pointer.\n mstore(0x60, 0) // Restore the zero slot.\n }\n }\n\n /// @dev Returns the address of the ERC1967 proxy of `implementation`, with `salt` by `deployer`.\n /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n function predictDeterministicAddressERC1967(\n address implementation,\n bytes32 salt,\n address deployer\n ) internal pure returns (address predicted) {\n bytes32 hash = initCodeHashERC1967(implementation);\n predicted = predictDeterministicAddress(hash, salt, deployer);\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* MINIMAL ERC1967 PROXY WITH IMMUTABLE ARGS OPERATIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Deploys a minimal ERC1967 proxy with `implementation` and `args`.\n function deployERC1967(address implementation, bytes memory args)\n internal\n returns (address instance)\n {\n instance = deployERC1967(0, implementation, args);\n }\n\n /// @dev Deploys a minimal ERC1967 proxy with `implementation` and `args`.\n /// Deposits `value` ETH during deployment.\n function deployERC1967(uint256 value, address implementation, bytes memory args)\n internal\n returns (address instance)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40)\n let n := mload(args)\n pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x60), n))\n mstore(add(m, 0x40), 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)\n mstore(add(m, 0x20), 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)\n mstore(0x16, 0x6009)\n mstore(0x14, implementation)\n // Do a out-of-gas revert if `n` is greater than `0xffff - 0x3d = 0xffc2`.\n mstore(gt(n, 0xffc2), add(0xfe61003d3d8160233d3973, shl(56, n)))\n mstore(m, mload(0x16))\n instance := create(value, m, add(n, 0x60))\n if iszero(instance) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n }\n }\n\n /// @dev Deploys a deterministic minimal ERC1967 proxy with `implementation`, `args` and `salt`.\n function deployDeterministicERC1967(address implementation, bytes memory args, bytes32 salt)\n internal\n returns (address instance)\n {\n instance = deployDeterministicERC1967(0, implementation, args, salt);\n }\n\n /// @dev Deploys a deterministic minimal ERC1967 proxy with `implementation`, `args` and `salt`.\n /// Deposits `value` ETH during deployment.\n function deployDeterministicERC1967(\n uint256 value,\n address implementation,\n bytes memory args,\n bytes32 salt\n ) internal returns (address instance) {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40)\n let n := mload(args)\n pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x60), n))\n mstore(add(m, 0x40), 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)\n mstore(add(m, 0x20), 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)\n mstore(0x16, 0x6009)\n mstore(0x14, implementation)\n // Do a out-of-gas revert if `n` is greater than `0xffff - 0x3d = 0xffc2`.\n mstore(gt(n, 0xffc2), add(0xfe61003d3d8160233d3973, shl(56, n)))\n mstore(m, mload(0x16))\n instance := create2(value, m, add(n, 0x60), salt)\n if iszero(instance) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n }\n }\n\n /// @dev Creates a deterministic minimal ERC1967 proxy with `implementation`, `args` and `salt`.\n /// Note: This method is intended for use in ERC4337 factories,\n /// which are expected to NOT revert if the proxy is already deployed.\n function createDeterministicERC1967(address implementation, bytes memory args, bytes32 salt)\n internal\n returns (bool alreadyDeployed, address instance)\n {\n return createDeterministicERC1967(0, implementation, args, salt);\n }\n\n /// @dev Creates a deterministic minimal ERC1967 proxy with `implementation`, `args` and `salt`.\n /// Deposits `value` ETH during deployment.\n /// Note: This method is intended for use in ERC4337 factories,\n /// which are expected to NOT revert if the proxy is already deployed.\n function createDeterministicERC1967(\n uint256 value,\n address implementation,\n bytes memory args,\n bytes32 salt\n ) internal returns (bool alreadyDeployed, address instance) {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40)\n let n := mload(args)\n pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x60), n))\n mstore(add(m, 0x40), 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)\n mstore(add(m, 0x20), 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)\n mstore(0x16, 0x6009)\n mstore(0x14, implementation)\n // Do a out-of-gas revert if `n` is greater than `0xffff - 0x3d = 0xffc2`.\n mstore(gt(n, 0xffc2), add(0xfe61003d3d8160233d3973, shl(56, n)))\n mstore(m, mload(0x16))\n // Compute and store the bytecode hash.\n mstore8(0x00, 0xff) // Write the prefix.\n mstore(0x35, keccak256(m, add(n, 0x60)))\n mstore(0x01, shl(96, address()))\n mstore(0x15, salt)\n instance := keccak256(0x00, 0x55)\n for {} 1 {} {\n if iszero(extcodesize(instance)) {\n instance := create2(value, m, add(n, 0x60), salt)\n if iszero(instance) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n break\n }\n alreadyDeployed := 1\n if iszero(value) { break }\n if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {\n mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n revert(0x1c, 0x04)\n }\n break\n }\n mstore(0x35, 0) // Restore the overwritten part of the free memory pointer.\n }\n }\n\n /// @dev Returns the initialization code of the minimal ERC1967 proxy of `implementation` and `args`.\n function initCodeERC1967(address implementation, bytes memory args)\n internal\n pure\n returns (bytes memory c)\n {\n /// @solidity memory-safe-assembly\n assembly {\n c := mload(0x40)\n let n := mload(args)\n // Do a out-of-gas revert if `n` is greater than `0xffff - 0x3d = 0xffc2`.\n returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffc2))\n for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {\n mstore(add(add(c, 0x80), i), mload(add(add(args, 0x20), i)))\n }\n mstore(add(c, 0x60), 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)\n mstore(add(c, 0x40), 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)\n mstore(add(c, 0x20), 0x6009)\n mstore(add(c, 0x1e), implementation)\n mstore(add(c, 0x0a), add(0x61003d3d8160233d3973, shl(56, n)))\n mstore(c, add(n, 0x60)) // Store the length.\n mstore(add(c, add(n, 0x80)), 0) // Zeroize the slot after the bytes.\n mstore(0x40, add(c, add(n, 0xa0))) // Allocate memory.\n }\n }\n\n /// @dev Returns the initialization code hash of the minimal ERC1967 proxy of `implementation` and `args`.\n function initCodeHashERC1967(address implementation, bytes memory args)\n internal\n pure\n returns (bytes32 hash)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40)\n let n := mload(args)\n // Do a out-of-gas revert if `n` is greater than `0xffff - 0x3d = 0xffc2`.\n returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffc2))\n for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {\n mstore(add(add(m, 0x60), i), mload(add(add(args, 0x20), i)))\n }\n mstore(add(m, 0x40), 0xcc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3)\n mstore(add(m, 0x20), 0x5155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076)\n mstore(0x16, 0x6009)\n mstore(0x14, implementation)\n mstore(0x00, add(0x61003d3d8160233d3973, shl(56, n)))\n mstore(m, mload(0x16))\n hash := keccak256(m, add(n, 0x60))\n }\n }\n\n /// @dev Returns the address of the ERC1967 proxy of `implementation`, `args`, with `salt` by `deployer`.\n /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n function predictDeterministicAddressERC1967(\n address implementation,\n bytes memory args,\n bytes32 salt,\n address deployer\n ) internal pure returns (address predicted) {\n bytes32 hash = initCodeHashERC1967(implementation, args);\n predicted = predictDeterministicAddress(hash, salt, deployer);\n }\n\n /// @dev Equivalent to `argsOnERC1967(instance, start, 2 ** 256 - 1)`.\n function argsOnERC1967(address instance) internal view returns (bytes memory args) {\n /// @solidity memory-safe-assembly\n assembly {\n args := mload(0x40)\n mstore(args, and(0xffffffffff, sub(extcodesize(instance), 0x3d))) // Store the length.\n extcodecopy(instance, add(args, 0x20), 0x3d, add(mload(args), 0x20))\n mstore(0x40, add(mload(args), add(args, 0x40))) // Allocate memory.\n }\n }\n\n /// @dev Equivalent to `argsOnERC1967(instance, start, 2 ** 256 - 1)`.\n function argsOnERC1967(address instance, uint256 start)\n internal\n view\n returns (bytes memory args)\n {\n /// @solidity memory-safe-assembly\n assembly {\n args := mload(0x40)\n let n := and(0xffffffffff, sub(extcodesize(instance), 0x3d))\n extcodecopy(instance, add(args, 0x20), add(start, 0x3d), add(n, 0x20))\n mstore(args, mul(sub(n, start), lt(start, n))) // Store the length.\n mstore(0x40, add(args, add(0x40, mload(args)))) // Allocate memory.\n }\n }\n\n /// @dev Returns a slice of the immutable arguments on `instance` from `start` to `end`.\n /// `start` and `end` will be clamped to the range `[0, args.length]`.\n /// The `instance` MUST be deployed via the ERC1967 with immutable args functions.\n /// Otherwise, the behavior is undefined.\n /// Out-of-gas reverts if `instance` does not have any code.\n function argsOnERC1967(address instance, uint256 start, uint256 end)\n internal\n view\n returns (bytes memory args)\n {\n /// @solidity memory-safe-assembly\n assembly {\n args := mload(0x40)\n if iszero(lt(end, 0xffff)) { end := 0xffff }\n let d := mul(sub(end, start), lt(start, end))\n extcodecopy(instance, args, add(start, 0x1d), add(d, 0x20))\n if iszero(and(0xff, mload(add(args, d)))) {\n let n := sub(extcodesize(instance), 0x3d)\n returndatacopy(returndatasize(), returndatasize(), shr(40, n))\n d := mul(gt(n, start), sub(d, mul(gt(end, n), sub(end, n))))\n }\n mstore(args, d) // Store the length.\n mstore(add(add(args, 0x20), d), 0) // Zeroize the slot after the bytes.\n mstore(0x40, add(add(args, 0x40), d)) // Allocate memory.\n }\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* ERC1967I PROXY OPERATIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n // Note: This proxy has a special code path that activates if `calldatasize() == 1`.\n // This code path skips the delegatecall and directly returns the `implementation` address.\n // The returned implementation is guaranteed to be valid if the keccak256 of the\n // proxy's code is equal to `ERC1967I_CODE_HASH`.\n\n /// @dev Deploys a ERC1967I proxy with `implementation`.\n function deployERC1967I(address implementation) internal returns (address instance) {\n instance = deployERC1967I(0, implementation);\n }\n\n /// @dev Deploys a ERC1967I proxy with `implementation`.\n /// Deposits `value` ETH during deployment.\n function deployERC1967I(uint256 value, address implementation)\n internal\n returns (address instance)\n {\n /// @solidity memory-safe-assembly\n assembly {\n /**\n * ---------------------------------------------------------------------------------+\n * CREATION (34 bytes) |\n * ---------------------------------------------------------------------------------|\n * Opcode | Mnemonic | Stack | Memory |\n * ---------------------------------------------------------------------------------|\n * 60 runSize | PUSH1 runSize | r | |\n * 3d | RETURNDATASIZE | 0 r | |\n * 81 | DUP2 | r 0 r | |\n * 60 offset | PUSH1 offset | o r 0 r | |\n * 3d | RETURNDATASIZE | 0 o r 0 r | |\n * 39 | CODECOPY | 0 r | [0..runSize): runtime code |\n * 73 impl | PUSH20 impl | impl 0 r | [0..runSize): runtime code |\n * 60 slotPos | PUSH1 slotPos | slotPos impl 0 r | [0..runSize): runtime code |\n * 51 | MLOAD | slot impl 0 r | [0..runSize): runtime code |\n * 55 | SSTORE | 0 r | [0..runSize): runtime code |\n * f3 | RETURN | | [0..runSize): runtime code |\n * ---------------------------------------------------------------------------------|\n * RUNTIME (82 bytes) |\n * ---------------------------------------------------------------------------------|\n * Opcode | Mnemonic | Stack | Memory |\n * ---------------------------------------------------------------------------------|\n * |\n * ::: check calldatasize ::::::::::::::::::::::::::::::::::::::::::::::::::::::::: |\n * 36 | CALLDATASIZE | cds | |\n * 58 | PC | 1 cds | |\n * 14 | EQ | eqs | |\n * 60 0x43 | PUSH1 0x43 | dest eqs | |\n * 57 | JUMPI | | |\n * |\n * ::: copy calldata to memory :::::::::::::::::::::::::::::::::::::::::::::::::::: |\n * 36 | CALLDATASIZE | cds | |\n * 3d | RETURNDATASIZE | 0 cds | |\n * 3d | RETURNDATASIZE | 0 0 cds | |\n * 37 | CALLDATACOPY | | [0..calldatasize): calldata |\n * |\n * ::: delegatecall to implementation ::::::::::::::::::::::::::::::::::::::::::::: |\n * 3d | RETURNDATASIZE | 0 | |\n * 3d | RETURNDATASIZE | 0 0 | |\n * 36 | CALLDATASIZE | cds 0 0 | [0..calldatasize): calldata |\n * 3d | RETURNDATASIZE | 0 cds 0 0 | [0..calldatasize): calldata |\n * 7f slot | PUSH32 slot | s 0 cds 0 0 | [0..calldatasize): calldata |\n * 54 | SLOAD | i 0 cds 0 0 | [0..calldatasize): calldata |\n * 5a | GAS | g i 0 cds 0 0 | [0..calldatasize): calldata |\n * f4 | DELEGATECALL | succ | [0..calldatasize): calldata |\n * |\n * ::: copy returndata to memory :::::::::::::::::::::::::::::::::::::::::::::::::: |\n * 3d | RETURNDATASIZE | rds succ | [0..calldatasize): calldata |\n * 60 0x00 | PUSH1 0x00 | 0 rds succ | [0..calldatasize): calldata |\n * 80 | DUP1 | 0 0 rds succ | [0..calldatasize): calldata |\n * 3e | RETURNDATACOPY | succ | [0..returndatasize): returndata |\n * |\n * ::: branch on delegatecall status :::::::::::::::::::::::::::::::::::::::::::::: |\n * 60 0x3E | PUSH1 0x3E | dest succ | [0..returndatasize): returndata |\n * 57 | JUMPI | | [0..returndatasize): returndata |\n * |\n * ::: delegatecall failed, revert :::::::::::::::::::::::::::::::::::::::::::::::: |\n * 3d | RETURNDATASIZE | rds | [0..returndatasize): returndata |\n * 60 0x00 | PUSH1 0x00 | 0 rds | [0..returndatasize): returndata |\n * fd | REVERT | | [0..returndatasize): returndata |\n * |\n * ::: delegatecall succeeded, return ::::::::::::::::::::::::::::::::::::::::::::: |\n * 5b | JUMPDEST | | [0..returndatasize): returndata |\n * 3d | RETURNDATASIZE | rds | [0..returndatasize): returndata |\n * 60 0x00 | PUSH1 0x00 | 0 rds | [0..returndatasize): returndata |\n * f3 | RETURN | | [0..returndatasize): returndata |\n * |\n * ::: implementation , return :::::::::::::::::::::::::::::::::::::::::::::::::::: |\n * 5b | JUMPDEST | | |\n * 60 0x20 | PUSH1 0x20 | 32 | |\n * 60 0x0F | PUSH1 0x0F | o 32 | |\n * 3d | RETURNDATASIZE | 0 o 32 | |\n * 39 | CODECOPY | | [0..32): implementation slot |\n * 3d | RETURNDATASIZE | 0 | [0..32): implementation slot |\n * 51 | MLOAD | slot | [0..32): implementation slot |\n * 54 | SLOAD | impl | [0..32): implementation slot |\n * 3d | RETURNDATASIZE | 0 impl | [0..32): implementation slot |\n * 52 | MSTORE | | [0..32): implementation address |\n * 59 | MSIZE | 32 | [0..32): implementation address |\n * 3d | RETURNDATASIZE | 0 32 | [0..32): implementation address |\n * f3 | RETURN | | [0..32): implementation address |\n * ---------------------------------------------------------------------------------+\n */\n let m := mload(0x40) // Cache the free memory pointer.\n mstore(0x60, 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)\n mstore(0x40, 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)\n mstore(0x20, 0x600f5155f3365814604357363d3d373d3d363d7f360894)\n mstore(0x09, or(shl(160, 0x60523d8160223d3973), shr(96, shl(96, implementation))))\n instance := create(value, 0x0c, 0x74)\n if iszero(instance) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n mstore(0x40, m) // Restore the free memory pointer.\n mstore(0x60, 0) // Restore the zero slot.\n }\n }\n\n /// @dev Deploys a deterministic ERC1967I proxy with `implementation` and `salt`.\n function deployDeterministicERC1967I(address implementation, bytes32 salt)\n internal\n returns (address instance)\n {\n instance = deployDeterministicERC1967I(0, implementation, salt);\n }\n\n /// @dev Deploys a deterministic ERC1967I proxy with `implementation` and `salt`.\n /// Deposits `value` ETH during deployment.\n function deployDeterministicERC1967I(uint256 value, address implementation, bytes32 salt)\n internal\n returns (address instance)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40) // Cache the free memory pointer.\n mstore(0x60, 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)\n mstore(0x40, 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)\n mstore(0x20, 0x600f5155f3365814604357363d3d373d3d363d7f360894)\n mstore(0x09, or(shl(160, 0x60523d8160223d3973), shr(96, shl(96, implementation))))\n instance := create2(value, 0x0c, 0x74, salt)\n if iszero(instance) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n mstore(0x40, m) // Restore the free memory pointer.\n mstore(0x60, 0) // Restore the zero slot.\n }\n }\n\n /// @dev Creates a deterministic ERC1967I proxy with `implementation` and `salt`.\n /// Note: This method is intended for use in ERC4337 factories,\n /// which are expected to NOT revert if the proxy is already deployed.\n function createDeterministicERC1967I(address implementation, bytes32 salt)\n internal\n returns (bool alreadyDeployed, address instance)\n {\n return createDeterministicERC1967I(0, implementation, salt);\n }\n\n /// @dev Creates a deterministic ERC1967I proxy with `implementation` and `salt`.\n /// Deposits `value` ETH during deployment.\n /// Note: This method is intended for use in ERC4337 factories,\n /// which are expected to NOT revert if the proxy is already deployed.\n function createDeterministicERC1967I(uint256 value, address implementation, bytes32 salt)\n internal\n returns (bool alreadyDeployed, address instance)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40) // Cache the free memory pointer.\n mstore(0x60, 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)\n mstore(0x40, 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)\n mstore(0x20, 0x600f5155f3365814604357363d3d373d3d363d7f360894)\n mstore(0x09, or(shl(160, 0x60523d8160223d3973), shr(96, shl(96, implementation))))\n // Compute and store the bytecode hash.\n mstore(add(m, 0x35), keccak256(0x0c, 0x74))\n mstore(m, shl(88, address()))\n mstore8(m, 0xff) // Write the prefix.\n mstore(add(m, 0x15), salt)\n instance := keccak256(m, 0x55)\n for {} 1 {} {\n if iszero(extcodesize(instance)) {\n instance := create2(value, 0x0c, 0x74, salt)\n if iszero(instance) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n break\n }\n alreadyDeployed := 1\n if iszero(value) { break }\n if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {\n mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n revert(0x1c, 0x04)\n }\n break\n }\n mstore(0x40, m) // Restore the free memory pointer.\n mstore(0x60, 0) // Restore the zero slot.\n }\n }\n\n /// @dev Returns the initialization code of the ERC1967I proxy of `implementation`.\n function initCodeERC1967I(address implementation) internal pure returns (bytes memory c) {\n /// @solidity memory-safe-assembly\n assembly {\n c := mload(0x40)\n mstore(add(c, 0x74), 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)\n mstore(add(c, 0x54), 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)\n mstore(add(c, 0x34), 0x600f5155f3365814604357363d3d373d3d363d7f360894)\n mstore(add(c, 0x1d), implementation)\n mstore(add(c, 0x09), 0x60523d8160223d3973)\n mstore(add(c, 0x94), 0)\n mstore(c, 0x74) // Store the length.\n mstore(0x40, add(c, 0xa0)) // Allocate memory.\n }\n }\n\n /// @dev Returns the initialization code hash of the ERC1967I proxy of `implementation`.\n function initCodeHashERC1967I(address implementation) internal pure returns (bytes32 hash) {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40) // Cache the free memory pointer.\n mstore(0x60, 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)\n mstore(0x40, 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)\n mstore(0x20, 0x600f5155f3365814604357363d3d373d3d363d7f360894)\n mstore(0x09, or(shl(160, 0x60523d8160223d3973), shr(96, shl(96, implementation))))\n hash := keccak256(0x0c, 0x74)\n mstore(0x40, m) // Restore the free memory pointer.\n mstore(0x60, 0) // Restore the zero slot.\n }\n }\n\n /// @dev Returns the address of the ERC1967I proxy of `implementation`, with `salt` by `deployer`.\n /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n function predictDeterministicAddressERC1967I(\n address implementation,\n bytes32 salt,\n address deployer\n ) internal pure returns (address predicted) {\n bytes32 hash = initCodeHashERC1967I(implementation);\n predicted = predictDeterministicAddress(hash, salt, deployer);\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* ERC1967I PROXY WITH IMMUTABLE ARGS OPERATIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Deploys a minimal ERC1967I proxy with `implementation` and `args`.\n function deployERC1967I(address implementation, bytes memory args) internal returns (address) {\n return deployERC1967I(0, implementation, args);\n }\n\n /// @dev Deploys a minimal ERC1967I proxy with `implementation` and `args`.\n /// Deposits `value` ETH during deployment.\n function deployERC1967I(uint256 value, address implementation, bytes memory args)\n internal\n returns (address instance)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40)\n let n := mload(args)\n pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x8b), n))\n\n mstore(add(m, 0x6b), 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)\n mstore(add(m, 0x4b), 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)\n mstore(add(m, 0x2b), 0x600f5155f3365814604357363d3d373d3d363d7f360894)\n mstore(add(m, 0x14), implementation)\n mstore(m, add(0xfe6100523d8160233d3973, shl(56, n)))\n\n // Do a out-of-gas revert if `n` is greater than `0xffff - 0x52 = 0xffad`.\n instance := create(value, add(m, add(0x15, lt(n, 0xffae))), add(0x75, n))\n if iszero(instance) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n }\n }\n\n /// @dev Deploys a deterministic ERC1967I proxy with `implementation`, `args`, and `salt`.\n function deployDeterministicERC1967I(address implementation, bytes memory args, bytes32 salt)\n internal\n returns (address instance)\n {\n instance = deployDeterministicERC1967I(0, implementation, args, salt);\n }\n\n /// @dev Deploys a deterministic ERC1967I proxy with `implementation`,`args`, and `salt`.\n /// Deposits `value` ETH during deployment.\n function deployDeterministicERC1967I(\n uint256 value,\n address implementation,\n bytes memory args,\n bytes32 salt\n ) internal returns (address instance) {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40)\n let n := mload(args)\n pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x8b), n))\n\n mstore(add(m, 0x6b), 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)\n mstore(add(m, 0x4b), 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)\n mstore(add(m, 0x2b), 0x600f5155f3365814604357363d3d373d3d363d7f360894)\n mstore(add(m, 0x14), implementation)\n mstore(m, add(0xfe6100523d8160233d3973, shl(56, n)))\n\n // Do a out-of-gas revert if `n` is greater than `0xffff - 0x52 = 0xffad`.\n instance := create2(value, add(m, add(0x15, lt(n, 0xffae))), add(0x75, n), salt)\n if iszero(instance) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n }\n }\n\n /// @dev Creates a deterministic ERC1967I proxy with `implementation`, `args` and `salt`.\n /// Note: This method is intended for use in ERC4337 factories,\n /// which are expected to NOT revert if the proxy is already deployed.\n function createDeterministicERC1967I(address implementation, bytes memory args, bytes32 salt)\n internal\n returns (bool alreadyDeployed, address instance)\n {\n return createDeterministicERC1967I(0, implementation, args, salt);\n }\n\n /// @dev Creates a deterministic ERC1967I proxy with `implementation`,`args` and `salt`.\n /// Deposits `value` ETH during deployment.\n /// Note: This method is intended for use in ERC4337 factories,\n /// which are expected to NOT revert if the proxy is already deployed.\n function createDeterministicERC1967I(\n uint256 value,\n address implementation,\n bytes memory args,\n bytes32 salt\n ) internal returns (bool alreadyDeployed, address instance) {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40)\n let n := mload(args)\n pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x75), n))\n mstore(add(m, 0x55), 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)\n mstore(add(m, 0x35), 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)\n mstore(add(m, 0x15), 0x5155f3365814604357363d3d373d3d363d7f360894)\n mstore(0x16, 0x600f)\n mstore(0x14, implementation)\n // Do a out-of-gas revert if `n` is greater than `0xffff - 0x52 = 0xffad`.\n mstore(gt(n, 0xffad), add(0xfe6100523d8160233d3973, shl(56, n)))\n mstore(m, mload(0x16))\n // Compute and store the bytecode hash.\n mstore8(0x00, 0xff) // Write the prefix.\n mstore(0x35, keccak256(m, add(n, 0x75)))\n mstore(0x01, shl(96, address()))\n mstore(0x15, salt)\n instance := keccak256(0x00, 0x55)\n for {} 1 {} {\n if iszero(extcodesize(instance)) {\n instance := create2(value, m, add(0x75, n), salt)\n if iszero(instance) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n break\n }\n alreadyDeployed := 1\n if iszero(value) { break }\n if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {\n mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n revert(0x1c, 0x04)\n }\n break\n }\n mstore(0x35, 0) // Restore the overwritten part of the free memory pointer.\n }\n }\n\n /// @dev Returns the initialization code of the ERC1967I proxy of `implementation`and `args`.\n function initCodeERC1967I(address implementation, bytes memory args)\n internal\n pure\n returns (bytes memory c)\n {\n /// @solidity memory-safe-assembly\n assembly {\n c := mload(0x40)\n let n := mload(args)\n // Do a out-of-gas revert if `n` is greater than `0xffff - 0x52 = 0xffad`.\n returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffad))\n for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {\n mstore(add(add(c, 0x95), i), mload(add(add(args, 0x20), i)))\n }\n\n mstore(add(c, 0x75), 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)\n mstore(add(c, 0x55), 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)\n mstore(add(c, 0x35), 0x600f5155f3365814604357363d3d373d3d363d7f360894)\n mstore(add(c, 0x1e), implementation)\n mstore(add(c, 0x0a), add(0x6100523d8160233d3973, shl(56, n)))\n mstore(add(c, add(n, 0x95)), 0)\n mstore(c, add(0x75, n)) // Store the length.\n mstore(0x40, add(c, add(n, 0xb5))) // Allocate memory.\n }\n }\n\n /// @dev Returns the initialization code hash of the ERC1967I proxy of `implementation` and `args.\n function initCodeHashERC1967I(address implementation, bytes memory args)\n internal\n pure\n returns (bytes32 hash)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40) // Cache the free memory pointer.\n let n := mload(args)\n // Do a out-of-gas revert if `n` is greater than `0xffff - 0x52 = 0xffad`.\n returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffad))\n\n for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {\n mstore(add(add(m, 0x75), i), mload(add(add(args, 0x20), i)))\n }\n\n mstore(add(m, 0x55), 0x3d6000803e603e573d6000fd5b3d6000f35b6020600f3d393d51543d52593df3)\n mstore(add(m, 0x35), 0xa13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af4)\n mstore(add(m, 0x15), 0x5155f3365814604357363d3d373d3d363d7f360894)\n mstore(0x16, 0x600f)\n mstore(0x14, implementation)\n mstore(0x00, add(0x6100523d8160233d3973, shl(56, n)))\n mstore(m, mload(0x16))\n hash := keccak256(m, add(0x75, n))\n }\n }\n\n /// @dev Returns the address of the ERC1967I proxy of `implementation`, 'args` with `salt` by `deployer`.\n /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n function predictDeterministicAddressERC1967I(\n address implementation,\n bytes memory args,\n bytes32 salt,\n address deployer\n ) internal pure returns (address predicted) {\n bytes32 hash = initCodeHashERC1967I(implementation, args);\n predicted = predictDeterministicAddress(hash, salt, deployer);\n }\n\n /// @dev Equivalent to `argsOnERC1967I(instance, start, 2 ** 256 - 1)`.\n function argsOnERC1967I(address instance) internal view returns (bytes memory args) {\n /// @solidity memory-safe-assembly\n assembly {\n args := mload(0x40)\n mstore(args, and(0xffffffffff, sub(extcodesize(instance), 0x52))) // Store the length.\n extcodecopy(instance, add(args, 0x20), 0x52, add(mload(args), 0x20))\n mstore(0x40, add(mload(args), add(args, 0x40))) // Allocate memory.\n }\n }\n\n /// @dev Equivalent to `argsOnERC1967I(instance, start, 2 ** 256 - 1)`.\n function argsOnERC1967I(address instance, uint256 start)\n internal\n view\n returns (bytes memory args)\n {\n /// @solidity memory-safe-assembly\n assembly {\n args := mload(0x40)\n let n := and(0xffffffffff, sub(extcodesize(instance), 0x52))\n extcodecopy(instance, add(args, 0x20), add(start, 0x52), add(n, 0x20))\n mstore(args, mul(sub(n, start), lt(start, n))) // Store the length.\n mstore(0x40, add(mload(args), add(args, 0x40))) // Allocate memory.\n }\n }\n\n /// @dev Returns a slice of the immutable arguments on `instance` from `start` to `end`.\n /// `start` and `end` will be clamped to the range `[0, args.length]`.\n /// The `instance` MUST be deployed via the ERC1967 with immutable args functions.\n /// Otherwise, the behavior is undefined.\n /// Out-of-gas reverts if `instance` does not have any code.\n function argsOnERC1967I(address instance, uint256 start, uint256 end)\n internal\n view\n returns (bytes memory args)\n {\n /// @solidity memory-safe-assembly\n assembly {\n args := mload(0x40)\n if iszero(lt(end, 0xffff)) { end := 0xffff }\n let d := mul(sub(end, start), lt(start, end))\n extcodecopy(instance, args, add(start, 0x32), add(d, 0x20))\n if iszero(and(0xff, mload(add(args, d)))) {\n let n := sub(extcodesize(instance), 0x52)\n returndatacopy(returndatasize(), returndatasize(), shr(40, n))\n d := mul(gt(n, start), sub(d, mul(gt(end, n), sub(end, n))))\n }\n mstore(args, d) // Store the length.\n mstore(add(add(args, 0x20), d), 0) // Zeroize the slot after the bytes.\n mstore(0x40, add(add(args, 0x40), d)) // Allocate memory.\n }\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* ERC1967 BOOTSTRAP OPERATIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n // A bootstrap is a minimal UUPS implementation that allows an ERC1967 proxy\n // pointing to it to be upgraded. The ERC1967 proxy can then be deployed to a\n // deterministic address independent of the implementation:\n // ```\n // address bootstrap = LibClone.erc1967Bootstrap();\n // address instance = LibClone.deployDeterministicERC1967(0, bootstrap, salt);\n // LibClone.bootstrapERC1967(bootstrap, implementation);\n // ```\n\n /// @dev Deploys the ERC1967 bootstrap if it has not been deployed.\n function erc1967Bootstrap() internal returns (address) {\n return erc1967Bootstrap(address(this));\n }\n\n /// @dev Deploys the ERC1967 bootstrap if it has not been deployed.\n function erc1967Bootstrap(address authorizedUpgrader) internal returns (address bootstrap) {\n bytes memory c = initCodeERC1967Bootstrap(authorizedUpgrader);\n bootstrap = predictDeterministicAddress(keccak256(c), bytes32(0), address(this));\n /// @solidity memory-safe-assembly\n assembly {\n if iszero(extcodesize(bootstrap)) {\n if iszero(create2(0, add(c, 0x20), mload(c), 0)) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n }\n }\n }\n\n /// @dev Replaces the implementation at `instance`.\n function bootstrapERC1967(address instance, address implementation) internal {\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, implementation)\n if iszero(call(gas(), instance, 0, 0x0c, 0x14, codesize(), 0x00)) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n }\n }\n\n /// @dev Replaces the implementation at `instance`, and then call it with `data`.\n function bootstrapERC1967AndCall(address instance, address implementation, bytes memory data)\n internal\n {\n /// @solidity memory-safe-assembly\n assembly {\n let n := mload(data)\n mstore(data, implementation)\n if iszero(call(gas(), instance, 0, add(data, 0x0c), add(n, 0x14), codesize(), 0x00)) {\n if iszero(returndatasize()) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n returndatacopy(mload(0x40), 0x00, returndatasize())\n revert(mload(0x40), returndatasize())\n }\n mstore(data, n) // Restore the length of `data`.\n }\n }\n\n /// @dev Returns the implementation address of the ERC1967 bootstrap for this contract.\n function predictDeterministicAddressERC1967Bootstrap() internal view returns (address) {\n return predictDeterministicAddressERC1967Bootstrap(address(this), address(this));\n }\n\n /// @dev Returns the implementation address of the ERC1967 bootstrap for this contract.\n function predictDeterministicAddressERC1967Bootstrap(\n address authorizedUpgrader,\n address deployer\n ) internal pure returns (address) {\n bytes32 hash = initCodeHashERC1967Bootstrap(authorizedUpgrader);\n return predictDeterministicAddress(hash, bytes32(0), deployer);\n }\n\n /// @dev Returns the initialization code of the ERC1967 bootstrap.\n function initCodeERC1967Bootstrap(address authorizedUpgrader)\n internal\n pure\n returns (bytes memory c)\n {\n /// @solidity memory-safe-assembly\n assembly {\n c := mload(0x40)\n mstore(add(c, 0x80), 0x3d3560601c5af46047573d6000383e3d38fd0000000000000000000000000000)\n mstore(add(c, 0x60), 0xa920a3ca505d382bbc55601436116049575b005b363d3d373d3d601436036014)\n mstore(add(c, 0x40), 0x0338573d3560601c7f360894a13ba1a3210667c828492db98dca3e2076cc3735)\n mstore(add(c, 0x20), authorizedUpgrader)\n mstore(add(c, 0x0c), 0x606880600a3d393df3fe3373)\n mstore(c, 0x72)\n mstore(0x40, add(c, 0xa0))\n }\n }\n\n /// @dev Returns the initialization code hash of the ERC1967 bootstrap.\n function initCodeHashERC1967Bootstrap(address authorizedUpgrader)\n internal\n pure\n returns (bytes32)\n {\n return keccak256(initCodeERC1967Bootstrap(authorizedUpgrader));\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* MINIMAL ERC1967 BEACON PROXY OPERATIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n // Note: If you use this proxy, you MUST make sure that the beacon is a\n // valid ERC1967 beacon. This means that the beacon must always return a valid\n // address upon a staticcall to `implementation()`, given sufficient gas.\n // For performance, the deployment operations and the proxy assumes that the\n // beacon is always valid and will NOT validate it.\n\n /// @dev Deploys a minimal ERC1967 beacon proxy.\n function deployERC1967BeaconProxy(address beacon) internal returns (address instance) {\n instance = deployERC1967BeaconProxy(0, beacon);\n }\n\n /// @dev Deploys a minimal ERC1967 beacon proxy.\n /// Deposits `value` ETH during deployment.\n function deployERC1967BeaconProxy(uint256 value, address beacon)\n internal\n returns (address instance)\n {\n /// @solidity memory-safe-assembly\n assembly {\n /**\n * ---------------------------------------------------------------------------------+\n * CREATION (34 bytes) |\n * ---------------------------------------------------------------------------------|\n * Opcode | Mnemonic | Stack | Memory |\n * ---------------------------------------------------------------------------------|\n * 60 runSize | PUSH1 runSize | r | |\n * 3d | RETURNDATASIZE | 0 r | |\n * 81 | DUP2 | r 0 r | |\n * 60 offset | PUSH1 offset | o r 0 r | |\n * 3d | RETURNDATASIZE | 0 o r 0 r | |\n * 39 | CODECOPY | 0 r | [0..runSize): runtime code |\n * 73 beac | PUSH20 beac | beac 0 r | [0..runSize): runtime code |\n * 60 slotPos | PUSH1 slotPos | slotPos beac 0 r | [0..runSize): runtime code |\n * 51 | MLOAD | slot beac 0 r | [0..runSize): runtime code |\n * 55 | SSTORE | 0 r | [0..runSize): runtime code |\n * f3 | RETURN | | [0..runSize): runtime code |\n * ---------------------------------------------------------------------------------|\n * RUNTIME (82 bytes) |\n * ---------------------------------------------------------------------------------|\n * Opcode | Mnemonic | Stack | Memory |\n * ---------------------------------------------------------------------------------|\n * |\n * ::: copy calldata to memory :::::::::::::::::::::::::::::::::::::::::::::::::::: |\n * 36 | CALLDATASIZE | cds | |\n * 3d | RETURNDATASIZE | 0 cds | |\n * 3d | RETURNDATASIZE | 0 0 cds | |\n * 37 | CALLDATACOPY | | [0..calldatasize): calldata |\n * |\n * ::: delegatecall to implementation ::::::::::::::::::::::::::::::::::::::::::::: |\n * 3d | RETURNDATASIZE | 0 | |\n * 3d | RETURNDATASIZE | 0 0 | |\n * 36 | CALLDATASIZE | cds 0 0 | [0..calldatasize): calldata |\n * 3d | RETURNDATASIZE | 0 cds 0 0 | [0..calldatasize): calldata |\n * |\n * ~~~~~~~ beacon staticcall sub procedure ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |\n * 60 0x20 | PUSH1 0x20 | 32 | |\n * 36 | CALLDATASIZE | cds 32 | |\n * 60 0x04 | PUSH1 0x04 | 4 cds 32 | |\n * 36 | CALLDATASIZE | cds 4 cds 32 | |\n * 63 0x5c60da1b | PUSH4 0x5c60da1b | 0x5c60da1b cds 4 cds 32 | |\n * 60 0xe0 | PUSH1 0xe0 | 224 0x5c60da1b cds 4 cds 32 | |\n * 1b | SHL | sel cds 4 cds 32 | |\n * 36 | CALLDATASIZE | cds sel cds 4 cds 32 | |\n * 52 | MSTORE | cds 4 cds 32 | sel |\n * 7f slot | PUSH32 slot | s cds 4 cds 32 | sel |\n * 54 | SLOAD | beac cds 4 cds 32 | sel |\n * 5a | GAS | g beac cds 4 cds 32 | sel |\n * fa | STATICCALL | succ | impl |\n * 50 | POP | | impl |\n * 36 | CALLDATASIZE | cds | impl |\n * 51 | MLOAD | impl | impl |\n * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |\n * 5a | GAS | g impl 0 cds 0 0 | [0..calldatasize): calldata |\n * f4 | DELEGATECALL | succ | [0..calldatasize): calldata |\n * |\n * ::: copy returndata to memory :::::::::::::::::::::::::::::::::::::::::::::::::: |\n * 3d | RETURNDATASIZE | rds succ | [0..calldatasize): calldata |\n * 60 0x00 | PUSH1 0x00 | 0 rds succ | [0..calldatasize): calldata |\n * 80 | DUP1 | 0 0 rds succ | [0..calldatasize): calldata |\n * 3e | RETURNDATACOPY | succ | [0..returndatasize): returndata |\n * |\n * ::: branch on delegatecall status :::::::::::::::::::::::::::::::::::::::::::::: |\n * 60 0x4d | PUSH1 0x4d | dest succ | [0..returndatasize): returndata |\n * 57 | JUMPI | | [0..returndatasize): returndata |\n * |\n * ::: delegatecall failed, revert :::::::::::::::::::::::::::::::::::::::::::::::: |\n * 3d | RETURNDATASIZE | rds | [0..returndatasize): returndata |\n * 60 0x00 | PUSH1 0x00 | 0 rds | [0..returndatasize): returndata |\n * fd | REVERT | | [0..returndatasize): returndata |\n * |\n * ::: delegatecall succeeded, return ::::::::::::::::::::::::::::::::::::::::::::: |\n * 5b | JUMPDEST | | [0..returndatasize): returndata |\n * 3d | RETURNDATASIZE | rds | [0..returndatasize): returndata |\n * 60 0x00 | PUSH1 0x00 | 0 rds | [0..returndatasize): returndata |\n * f3 | RETURN | | [0..returndatasize): returndata |\n * ---------------------------------------------------------------------------------+\n */\n let m := mload(0x40) // Cache the free memory pointer.\n mstore(0x60, 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)\n mstore(0x40, 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)\n mstore(0x20, 0x60195155f3363d3d373d3d363d602036600436635c60da)\n mstore(0x09, or(shl(160, 0x60523d8160223d3973), shr(96, shl(96, beacon))))\n instance := create(value, 0x0c, 0x74)\n if iszero(instance) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n mstore(0x40, m) // Restore the free memory pointer.\n mstore(0x60, 0) // Restore the zero slot.\n }\n }\n\n /// @dev Deploys a deterministic minimal ERC1967 beacon proxy with `salt`.\n function deployDeterministicERC1967BeaconProxy(address beacon, bytes32 salt)\n internal\n returns (address instance)\n {\n instance = deployDeterministicERC1967BeaconProxy(0, beacon, salt);\n }\n\n /// @dev Deploys a deterministic minimal ERC1967 beacon proxy with `salt`.\n /// Deposits `value` ETH during deployment.\n function deployDeterministicERC1967BeaconProxy(uint256 value, address beacon, bytes32 salt)\n internal\n returns (address instance)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40) // Cache the free memory pointer.\n mstore(0x60, 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)\n mstore(0x40, 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)\n mstore(0x20, 0x60195155f3363d3d373d3d363d602036600436635c60da)\n mstore(0x09, or(shl(160, 0x60523d8160223d3973), shr(96, shl(96, beacon))))\n instance := create2(value, 0x0c, 0x74, salt)\n if iszero(instance) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n mstore(0x40, m) // Restore the free memory pointer.\n mstore(0x60, 0) // Restore the zero slot.\n }\n }\n\n /// @dev Creates a deterministic minimal ERC1967 beacon proxy with `salt`.\n /// Note: This method is intended for use in ERC4337 factories,\n /// which are expected to NOT revert if the proxy is already deployed.\n function createDeterministicERC1967BeaconProxy(address beacon, bytes32 salt)\n internal\n returns (bool alreadyDeployed, address instance)\n {\n return createDeterministicERC1967BeaconProxy(0, beacon, salt);\n }\n\n /// @dev Creates a deterministic minimal ERC1967 beacon proxy with `salt`.\n /// Deposits `value` ETH during deployment.\n /// Note: This method is intended for use in ERC4337 factories,\n /// which are expected to NOT revert if the proxy is already deployed.\n function createDeterministicERC1967BeaconProxy(uint256 value, address beacon, bytes32 salt)\n internal\n returns (bool alreadyDeployed, address instance)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40) // Cache the free memory pointer.\n mstore(0x60, 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)\n mstore(0x40, 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)\n mstore(0x20, 0x60195155f3363d3d373d3d363d602036600436635c60da)\n mstore(0x09, or(shl(160, 0x60523d8160223d3973), shr(96, shl(96, beacon))))\n // Compute and store the bytecode hash.\n mstore(add(m, 0x35), keccak256(0x0c, 0x74))\n mstore(m, shl(88, address()))\n mstore8(m, 0xff) // Write the prefix.\n mstore(add(m, 0x15), salt)\n instance := keccak256(m, 0x55)\n for {} 1 {} {\n if iszero(extcodesize(instance)) {\n instance := create2(value, 0x0c, 0x74, salt)\n if iszero(instance) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n break\n }\n alreadyDeployed := 1\n if iszero(value) { break }\n if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {\n mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n revert(0x1c, 0x04)\n }\n break\n }\n mstore(0x40, m) // Restore the free memory pointer.\n mstore(0x60, 0) // Restore the zero slot.\n }\n }\n\n /// @dev Returns the initialization code of the minimal ERC1967 beacon proxy.\n function initCodeERC1967BeaconProxy(address beacon) internal pure returns (bytes memory c) {\n /// @solidity memory-safe-assembly\n assembly {\n c := mload(0x40)\n mstore(add(c, 0x74), 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)\n mstore(add(c, 0x54), 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)\n mstore(add(c, 0x34), 0x60195155f3363d3d373d3d363d602036600436635c60da)\n mstore(add(c, 0x1d), beacon)\n mstore(add(c, 0x09), 0x60523d8160223d3973)\n mstore(add(c, 0x94), 0)\n mstore(c, 0x74) // Store the length.\n mstore(0x40, add(c, 0xa0)) // Allocate memory.\n }\n }\n\n /// @dev Returns the initialization code hash of the minimal ERC1967 beacon proxy.\n function initCodeHashERC1967BeaconProxy(address beacon) internal pure returns (bytes32 hash) {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40) // Cache the free memory pointer.\n mstore(0x60, 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)\n mstore(0x40, 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)\n mstore(0x20, 0x60195155f3363d3d373d3d363d602036600436635c60da)\n mstore(0x09, or(shl(160, 0x60523d8160223d3973), shr(96, shl(96, beacon))))\n hash := keccak256(0x0c, 0x74)\n mstore(0x40, m) // Restore the free memory pointer.\n mstore(0x60, 0) // Restore the zero slot.\n }\n }\n\n /// @dev Returns the address of the ERC1967 beacon proxy, with `salt` by `deployer`.\n /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n function predictDeterministicAddressERC1967BeaconProxy(\n address beacon,\n bytes32 salt,\n address deployer\n ) internal pure returns (address predicted) {\n bytes32 hash = initCodeHashERC1967BeaconProxy(beacon);\n predicted = predictDeterministicAddress(hash, salt, deployer);\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* ERC1967 BEACON PROXY WITH IMMUTABLE ARGS OPERATIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Deploys a minimal ERC1967 beacon proxy with `args`.\n function deployERC1967BeaconProxy(address beacon, bytes memory args)\n internal\n returns (address instance)\n {\n instance = deployERC1967BeaconProxy(0, beacon, args);\n }\n\n /// @dev Deploys a minimal ERC1967 beacon proxy with `args`.\n /// Deposits `value` ETH during deployment.\n function deployERC1967BeaconProxy(uint256 value, address beacon, bytes memory args)\n internal\n returns (address instance)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40)\n let n := mload(args)\n pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x8b), n))\n mstore(add(m, 0x6b), 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)\n mstore(add(m, 0x4b), 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)\n mstore(add(m, 0x2b), 0x60195155f3363d3d373d3d363d602036600436635c60da)\n mstore(add(m, 0x14), beacon)\n // Do a out-of-gas revert if `n` is greater than `0xffff - 0x52 = 0xffad`.\n mstore(add(m, gt(n, 0xffad)), add(0xfe6100523d8160233d3973, shl(56, n)))\n instance := create(value, add(m, 0x16), add(n, 0x75))\n if iszero(instance) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n }\n }\n\n /// @dev Deploys a deterministic minimal ERC1967 beacon proxy with `args` and `salt`.\n function deployDeterministicERC1967BeaconProxy(address beacon, bytes memory args, bytes32 salt)\n internal\n returns (address instance)\n {\n instance = deployDeterministicERC1967BeaconProxy(0, beacon, args, salt);\n }\n\n /// @dev Deploys a deterministic minimal ERC1967 beacon proxy with `args` and `salt`.\n /// Deposits `value` ETH during deployment.\n function deployDeterministicERC1967BeaconProxy(\n uint256 value,\n address beacon,\n bytes memory args,\n bytes32 salt\n ) internal returns (address instance) {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40)\n let n := mload(args)\n pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x8b), n))\n mstore(add(m, 0x6b), 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)\n mstore(add(m, 0x4b), 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)\n mstore(add(m, 0x2b), 0x60195155f3363d3d373d3d363d602036600436635c60da)\n mstore(add(m, 0x14), beacon)\n // Do a out-of-gas revert if `n` is greater than `0xffff - 0x52 = 0xffad`.\n mstore(add(m, gt(n, 0xffad)), add(0xfe6100523d8160233d3973, shl(56, n)))\n instance := create2(value, add(m, 0x16), add(n, 0x75), salt)\n if iszero(instance) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n }\n }\n\n /// @dev Creates a deterministic minimal ERC1967 beacon proxy with `args` and `salt`.\n /// Note: This method is intended for use in ERC4337 factories,\n /// which are expected to NOT revert if the proxy is already deployed.\n function createDeterministicERC1967BeaconProxy(address beacon, bytes memory args, bytes32 salt)\n internal\n returns (bool alreadyDeployed, address instance)\n {\n return createDeterministicERC1967BeaconProxy(0, beacon, args, salt);\n }\n\n /// @dev Creates a deterministic minimal ERC1967 beacon proxy with `args` and `salt`.\n /// Deposits `value` ETH during deployment.\n /// Note: This method is intended for use in ERC4337 factories,\n /// which are expected to NOT revert if the proxy is already deployed.\n function createDeterministicERC1967BeaconProxy(\n uint256 value,\n address beacon,\n bytes memory args,\n bytes32 salt\n ) internal returns (bool alreadyDeployed, address instance) {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40)\n let n := mload(args)\n pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x8b), n))\n mstore(add(m, 0x6b), 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)\n mstore(add(m, 0x4b), 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)\n mstore(add(m, 0x2b), 0x60195155f3363d3d373d3d363d602036600436635c60da)\n mstore(add(m, 0x14), beacon)\n // Do a out-of-gas revert if `n` is greater than `0xffff - 0x52 = 0xffad`.\n mstore(add(m, gt(n, 0xffad)), add(0xfe6100523d8160233d3973, shl(56, n)))\n // Compute and store the bytecode hash.\n mstore8(0x00, 0xff) // Write the prefix.\n mstore(0x35, keccak256(add(m, 0x16), add(n, 0x75)))\n mstore(0x01, shl(96, address()))\n mstore(0x15, salt)\n instance := keccak256(0x00, 0x55)\n for {} 1 {} {\n if iszero(extcodesize(instance)) {\n instance := create2(value, add(m, 0x16), add(n, 0x75), salt)\n if iszero(instance) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n break\n }\n alreadyDeployed := 1\n if iszero(value) { break }\n if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {\n mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n revert(0x1c, 0x04)\n }\n break\n }\n mstore(0x35, 0) // Restore the overwritten part of the free memory pointer.\n }\n }\n\n /// @dev Returns the initialization code of the minimal ERC1967 beacon proxy.\n function initCodeERC1967BeaconProxy(address beacon, bytes memory args)\n internal\n pure\n returns (bytes memory c)\n {\n /// @solidity memory-safe-assembly\n assembly {\n c := mload(0x40)\n let n := mload(args)\n // Do a out-of-gas revert if `n` is greater than `0xffff - 0x52 = 0xffad`.\n returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffad))\n for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {\n mstore(add(add(c, 0x95), i), mload(add(add(args, 0x20), i)))\n }\n mstore(add(c, 0x75), 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)\n mstore(add(c, 0x55), 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)\n mstore(add(c, 0x35), 0x60195155f3363d3d373d3d363d602036600436635c60da)\n mstore(add(c, 0x1e), beacon)\n mstore(add(c, 0x0a), add(0x6100523d8160233d3973, shl(56, n)))\n mstore(c, add(n, 0x75)) // Store the length.\n mstore(add(c, add(n, 0x95)), 0) // Zeroize the slot after the bytes.\n mstore(0x40, add(c, add(n, 0xb5))) // Allocate memory.\n }\n }\n\n /// @dev Returns the initialization code hash of the minimal ERC1967 beacon proxy with `args`.\n function initCodeHashERC1967BeaconProxy(address beacon, bytes memory args)\n internal\n pure\n returns (bytes32 hash)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40)\n let n := mload(args)\n // Do a out-of-gas revert if `n` is greater than `0xffff - 0x52 = 0xffad`.\n returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffad))\n for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {\n mstore(add(add(m, 0x8b), i), mload(add(add(args, 0x20), i)))\n }\n mstore(add(m, 0x6b), 0xb3582b35133d50545afa5036515af43d6000803e604d573d6000fd5b3d6000f3)\n mstore(add(m, 0x4b), 0x1b60e01b36527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6c)\n mstore(add(m, 0x2b), 0x60195155f3363d3d373d3d363d602036600436635c60da)\n mstore(add(m, 0x14), beacon)\n mstore(m, add(0x6100523d8160233d3973, shl(56, n)))\n hash := keccak256(add(m, 0x16), add(n, 0x75))\n }\n }\n\n /// @dev Returns the address of the ERC1967 beacon proxy with `args`, with `salt` by `deployer`.\n /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n function predictDeterministicAddressERC1967BeaconProxy(\n address beacon,\n bytes memory args,\n bytes32 salt,\n address deployer\n ) internal pure returns (address predicted) {\n bytes32 hash = initCodeHashERC1967BeaconProxy(beacon, args);\n predicted = predictDeterministicAddress(hash, salt, deployer);\n }\n\n /// @dev Equivalent to `argsOnERC1967BeaconProxy(instance, start, 2 ** 256 - 1)`.\n function argsOnERC1967BeaconProxy(address instance) internal view returns (bytes memory args) {\n /// @solidity memory-safe-assembly\n assembly {\n args := mload(0x40)\n mstore(args, and(0xffffffffff, sub(extcodesize(instance), 0x52))) // Store the length.\n extcodecopy(instance, add(args, 0x20), 0x52, add(mload(args), 0x20))\n mstore(0x40, add(mload(args), add(args, 0x40))) // Allocate memory.\n }\n }\n\n /// @dev Equivalent to `argsOnERC1967BeaconProxy(instance, start, 2 ** 256 - 1)`.\n function argsOnERC1967BeaconProxy(address instance, uint256 start)\n internal\n view\n returns (bytes memory args)\n {\n /// @solidity memory-safe-assembly\n assembly {\n args := mload(0x40)\n let n := and(0xffffffffff, sub(extcodesize(instance), 0x52))\n extcodecopy(instance, add(args, 0x20), add(start, 0x52), add(n, 0x20))\n mstore(args, mul(sub(n, start), lt(start, n))) // Store the length.\n mstore(0x40, add(args, add(0x40, mload(args)))) // Allocate memory.\n }\n }\n\n /// @dev Returns a slice of the immutable arguments on `instance` from `start` to `end`.\n /// `start` and `end` will be clamped to the range `[0, args.length]`.\n /// The `instance` MUST be deployed via the ERC1967 beacon proxy with immutable args functions.\n /// Otherwise, the behavior is undefined.\n /// Out-of-gas reverts if `instance` does not have any code.\n function argsOnERC1967BeaconProxy(address instance, uint256 start, uint256 end)\n internal\n view\n returns (bytes memory args)\n {\n /// @solidity memory-safe-assembly\n assembly {\n args := mload(0x40)\n if iszero(lt(end, 0xffff)) { end := 0xffff }\n let d := mul(sub(end, start), lt(start, end))\n extcodecopy(instance, args, add(start, 0x32), add(d, 0x20))\n if iszero(and(0xff, mload(add(args, d)))) {\n let n := sub(extcodesize(instance), 0x52)\n returndatacopy(returndatasize(), returndatasize(), shr(40, n))\n d := mul(gt(n, start), sub(d, mul(gt(end, n), sub(end, n))))\n }\n mstore(args, d) // Store the length.\n mstore(add(add(args, 0x20), d), 0) // Zeroize the slot after the bytes.\n mstore(0x40, add(add(args, 0x40), d)) // Allocate memory.\n }\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* ERC1967I BEACON PROXY OPERATIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n // Note: This proxy has a special code path that activates if `calldatasize() == 1`.\n // This code path skips the delegatecall and directly returns the `implementation` address.\n // The returned implementation is guaranteed to be valid if the keccak256 of the\n // proxy's code is equal to `ERC1967_BEACON_PROXY_CODE_HASH`.\n //\n // If you use this proxy, you MUST make sure that the beacon is a\n // valid ERC1967 beacon. This means that the beacon must always return a valid\n // address upon a staticcall to `implementation()`, given sufficient gas.\n // For performance, the deployment operations and the proxy assumes that the\n // beacon is always valid and will NOT validate it.\n\n /// @dev Deploys a ERC1967I beacon proxy.\n function deployERC1967IBeaconProxy(address beacon) internal returns (address instance) {\n instance = deployERC1967IBeaconProxy(0, beacon);\n }\n\n /// @dev Deploys a ERC1967I beacon proxy.\n /// Deposits `value` ETH during deployment.\n function deployERC1967IBeaconProxy(uint256 value, address beacon)\n internal\n returns (address instance)\n {\n /// @solidity memory-safe-assembly\n assembly {\n /**\n * ---------------------------------------------------------------------------------+\n * CREATION (34 bytes) |\n * ---------------------------------------------------------------------------------|\n * Opcode | Mnemonic | Stack | Memory |\n * ---------------------------------------------------------------------------------|\n * 60 runSize | PUSH1 runSize | r | |\n * 3d | RETURNDATASIZE | 0 r | |\n * 81 | DUP2 | r 0 r | |\n * 60 offset | PUSH1 offset | o r 0 r | |\n * 3d | RETURNDATASIZE | 0 o r 0 r | |\n * 39 | CODECOPY | 0 r | [0..runSize): runtime code |\n * 73 beac | PUSH20 beac | beac 0 r | [0..runSize): runtime code |\n * 60 slotPos | PUSH1 slotPos | slotPos beac 0 r | [0..runSize): runtime code |\n * 51 | MLOAD | slot beac 0 r | [0..runSize): runtime code |\n * 55 | SSTORE | 0 r | [0..runSize): runtime code |\n * f3 | RETURN | | [0..runSize): runtime code |\n * ---------------------------------------------------------------------------------|\n * RUNTIME (87 bytes) |\n * ---------------------------------------------------------------------------------|\n * Opcode | Mnemonic | Stack | Memory |\n * ---------------------------------------------------------------------------------|\n * |\n * ::: copy calldata to memory :::::::::::::::::::::::::::::::::::::::::::::::::::: |\n * 36 | CALLDATASIZE | cds | |\n * 3d | RETURNDATASIZE | 0 cds | |\n * 3d | RETURNDATASIZE | 0 0 cds | |\n * 37 | CALLDATACOPY | | [0..calldatasize): calldata |\n * |\n * ::: delegatecall to implementation ::::::::::::::::::::::::::::::::::::::::::::: |\n * 3d | RETURNDATASIZE | 0 | |\n * 3d | RETURNDATASIZE | 0 0 | |\n * 36 | CALLDATASIZE | cds 0 0 | [0..calldatasize): calldata |\n * 3d | RETURNDATASIZE | 0 cds 0 0 | [0..calldatasize): calldata |\n * |\n * ~~~~~~~ beacon staticcall sub procedure ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |\n * 60 0x20 | PUSH1 0x20 | 32 | |\n * 36 | CALLDATASIZE | cds 32 | |\n * 60 0x04 | PUSH1 0x04 | 4 cds 32 | |\n * 36 | CALLDATASIZE | cds 4 cds 32 | |\n * 63 0x5c60da1b | PUSH4 0x5c60da1b | 0x5c60da1b cds 4 cds 32 | |\n * 60 0xe0 | PUSH1 0xe0 | 224 0x5c60da1b cds 4 cds 32 | |\n * 1b | SHL | sel cds 4 cds 32 | |\n * 36 | CALLDATASIZE | cds sel cds 4 cds 32 | |\n * 52 | MSTORE | cds 4 cds 32 | sel |\n * 7f slot | PUSH32 slot | s cds 4 cds 32 | sel |\n * 54 | SLOAD | beac cds 4 cds 32 | sel |\n * 5a | GAS | g beac cds 4 cds 32 | sel |\n * fa | STATICCALL | succ | impl |\n * ~~~~~~ check calldatasize ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |\n * 36 | CALLDATASIZE | cds succ | |\n * 14 | EQ | | impl |\n * 60 0x52 | PUSH1 0x52 | | impl |\n * 57 | JUMPI | | impl |\n * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |\n * 36 | CALLDATASIZE | cds | impl |\n * 51 | MLOAD | impl | impl |\n * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |\n * 5a | GAS | g impl 0 cds 0 0 | [0..calldatasize): calldata |\n * f4 | DELEGATECALL | succ | [0..calldatasize): calldata |\n * |\n * ::: copy returndata to memory :::::::::::::::::::::::::::::::::::::::::::::::::: |\n * 3d | RETURNDATASIZE | rds succ | [0..calldatasize): calldata |\n * 60 0x00 | PUSH1 0x00 | 0 rds succ | [0..calldatasize): calldata |\n * 60 0x01 | PUSH1 0x01 | 1 0 rds succ | [0..calldatasize): calldata |\n * 3e | RETURNDATACOPY | succ | [1..returndatasize): returndata |\n * |\n * ::: branch on delegatecall status :::::::::::::::::::::::::::::::::::::::::::::: |\n * 60 0x52 | PUSH1 0x52 | dest succ | [1..returndatasize): returndata |\n * 57 | JUMPI | | [1..returndatasize): returndata |\n * |\n * ::: delegatecall failed, revert :::::::::::::::::::::::::::::::::::::::::::::::: |\n * 3d | RETURNDATASIZE | rds | [1..returndatasize): returndata |\n * 60 0x01 | PUSH1 0x01 | 1 rds | [1..returndatasize): returndata |\n * fd | REVERT | | [1..returndatasize): returndata |\n * |\n * ::: delegatecall succeeded, return ::::::::::::::::::::::::::::::::::::::::::::: |\n * 5b | JUMPDEST | | [1..returndatasize): returndata |\n * 3d | RETURNDATASIZE | rds | [1..returndatasize): returndata |\n * 60 0x01 | PUSH1 0x01 | 1 rds | [1..returndatasize): returndata |\n * f3 | RETURN | | [1..returndatasize): returndata |\n * ---------------------------------------------------------------------------------+\n */\n let m := mload(0x40) // Cache the free memory pointer.\n mstore(0x60, 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)\n mstore(0x40, 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)\n mstore(0x20, 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)\n mstore(0x04, or(shl(160, 0x60573d8160223d3973), shr(96, shl(96, beacon))))\n instance := create(value, 0x07, 0x79)\n if iszero(instance) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n mstore(0x40, m) // Restore the free memory pointer.\n mstore(0x60, 0) // Restore the zero slot.\n }\n }\n\n /// @dev Deploys a deterministic ERC1967I beacon proxy with `salt`.\n function deployDeterministicERC1967IBeaconProxy(address beacon, bytes32 salt)\n internal\n returns (address instance)\n {\n instance = deployDeterministicERC1967IBeaconProxy(0, beacon, salt);\n }\n\n /// @dev Deploys a deterministic ERC1967I beacon proxy with `salt`.\n /// Deposits `value` ETH during deployment.\n function deployDeterministicERC1967IBeaconProxy(uint256 value, address beacon, bytes32 salt)\n internal\n returns (address instance)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40) // Cache the free memory pointer.\n mstore(0x60, 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)\n mstore(0x40, 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)\n mstore(0x20, 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)\n mstore(0x04, or(shl(160, 0x60573d8160223d3973), shr(96, shl(96, beacon))))\n instance := create2(value, 0x07, 0x79, salt)\n if iszero(instance) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n mstore(0x40, m) // Restore the free memory pointer.\n mstore(0x60, 0) // Restore the zero slot.\n }\n }\n\n /// @dev Creates a deterministic ERC1967I beacon proxy with `salt`.\n /// Note: This method is intended for use in ERC4337 factories,\n /// which are expected to NOT revert if the proxy is already deployed.\n function createDeterministicERC1967IBeaconProxy(address beacon, bytes32 salt)\n internal\n returns (bool alreadyDeployed, address instance)\n {\n return createDeterministicERC1967IBeaconProxy(0, beacon, salt);\n }\n\n /// @dev Creates a deterministic ERC1967I beacon proxy with `salt`.\n /// Deposits `value` ETH during deployment.\n /// Note: This method is intended for use in ERC4337 factories,\n /// which are expected to NOT revert if the proxy is already deployed.\n function createDeterministicERC1967IBeaconProxy(uint256 value, address beacon, bytes32 salt)\n internal\n returns (bool alreadyDeployed, address instance)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40) // Cache the free memory pointer.\n mstore(0x60, 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)\n mstore(0x40, 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)\n mstore(0x20, 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)\n mstore(0x04, or(shl(160, 0x60573d8160223d3973), shr(96, shl(96, beacon))))\n // Compute and store the bytecode hash.\n mstore(add(m, 0x35), keccak256(0x07, 0x79))\n mstore(m, shl(88, address()))\n mstore8(m, 0xff) // Write the prefix.\n mstore(add(m, 0x15), salt)\n instance := keccak256(m, 0x55)\n for {} 1 {} {\n if iszero(extcodesize(instance)) {\n instance := create2(value, 0x07, 0x79, salt)\n if iszero(instance) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n break\n }\n alreadyDeployed := 1\n if iszero(value) { break }\n if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {\n mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n revert(0x1c, 0x04)\n }\n break\n }\n mstore(0x40, m) // Restore the free memory pointer.\n mstore(0x60, 0) // Restore the zero slot.\n }\n }\n\n /// @dev Returns the initialization code of the ERC1967I beacon proxy.\n function initCodeERC1967IBeaconProxy(address beacon) internal pure returns (bytes memory c) {\n /// @solidity memory-safe-assembly\n assembly {\n c := mload(0x40)\n mstore(add(c, 0x79), 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)\n mstore(add(c, 0x59), 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)\n mstore(add(c, 0x39), 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)\n mstore(add(c, 0x1d), beacon)\n mstore(add(c, 0x09), 0x60573d8160223d3973)\n mstore(add(c, 0x99), 0)\n mstore(c, 0x79) // Store the length.\n mstore(0x40, add(c, 0xa0)) // Allocate memory.\n }\n }\n\n /// @dev Returns the initialization code hash of the ERC1967I beacon proxy.\n function initCodeHashERC1967IBeaconProxy(address beacon) internal pure returns (bytes32 hash) {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40) // Cache the free memory pointer.\n mstore(0x60, 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)\n mstore(0x40, 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)\n mstore(0x20, 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)\n mstore(0x04, or(shl(160, 0x60573d8160223d3973), shr(96, shl(96, beacon))))\n hash := keccak256(0x07, 0x79)\n mstore(0x40, m) // Restore the free memory pointer.\n mstore(0x60, 0) // Restore the zero slot.\n }\n }\n\n /// @dev Returns the address of the ERC1967I beacon proxy, with `salt` by `deployer`.\n /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n function predictDeterministicAddressERC1967IBeaconProxy(\n address beacon,\n bytes32 salt,\n address deployer\n ) internal pure returns (address predicted) {\n bytes32 hash = initCodeHashERC1967IBeaconProxy(beacon);\n predicted = predictDeterministicAddress(hash, salt, deployer);\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* ERC1967I BEACON PROXY WITH IMMUTABLE ARGS OPERATIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Deploys a ERC1967I beacon proxy with `args.\n function deployERC1967IBeaconProxy(address beacon, bytes memory args)\n internal\n returns (address instance)\n {\n instance = deployERC1967IBeaconProxy(0, beacon, args);\n }\n\n /// @dev Deploys a ERC1967I beacon proxy with `args.\n /// Deposits `value` ETH during deployment.\n function deployERC1967IBeaconProxy(uint256 value, address beacon, bytes memory args)\n internal\n returns (address instance)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40) // Cache the free memory pointer.\n let n := mload(args)\n pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x90), n))\n mstore(add(m, 0x70), 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)\n mstore(add(m, 0x50), 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)\n mstore(add(m, 0x30), 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)\n mstore(add(m, 0x14), beacon)\n // Do a out-of-gas revert if `n` is greater than `0xffff - 0x57 = 0xffa8`.\n mstore(add(m, gt(n, 0xffa8)), add(0xfe6100573d8160233d3973, shl(56, n)))\n instance := create(value, add(m, 0x16), add(n, 0x7a))\n if iszero(instance) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n }\n }\n\n /// @dev Deploys a deterministic ERC1967I beacon proxy with `args` and `salt`.\n function deployDeterministicERC1967IBeaconProxy(address beacon, bytes memory args, bytes32 salt)\n internal\n returns (address instance)\n {\n instance = deployDeterministicERC1967IBeaconProxy(0, beacon, args, salt);\n }\n\n /// @dev Deploys a deterministic ERC1967I beacon proxy with `args` and `salt`.\n /// Deposits `value` ETH during deployment.\n function deployDeterministicERC1967IBeaconProxy(\n uint256 value,\n address beacon,\n bytes memory args,\n bytes32 salt\n ) internal returns (address instance) {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40) // Cache the free memory pointer.\n let n := mload(args)\n pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x90), n))\n mstore(add(m, 0x70), 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)\n mstore(add(m, 0x50), 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)\n mstore(add(m, 0x30), 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)\n mstore(add(m, 0x14), beacon)\n // Do a out-of-gas revert if `n` is greater than `0xffff - 0x57 = 0xffa8`.\n mstore(add(m, gt(n, 0xffa8)), add(0xfe6100573d8160233d3973, shl(56, n)))\n instance := create2(value, add(m, 0x16), add(n, 0x7a), salt)\n if iszero(instance) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n }\n }\n\n /// @dev Creates a deterministic ERC1967I beacon proxy with `args` and `salt`.\n /// Note: This method is intended for use in ERC4337 factories,\n /// which are expected to NOT revert if the proxy is already deployed.\n function createDeterministicERC1967IBeaconProxy(address beacon, bytes memory args, bytes32 salt)\n internal\n returns (bool alreadyDeployed, address instance)\n {\n return createDeterministicERC1967IBeaconProxy(0, beacon, args, salt);\n }\n\n /// @dev Creates a deterministic ERC1967I beacon proxy with `args` and `salt`.\n /// Deposits `value` ETH during deployment.\n /// Note: This method is intended for use in ERC4337 factories,\n /// which are expected to NOT revert if the proxy is already deployed.\n function createDeterministicERC1967IBeaconProxy(\n uint256 value,\n address beacon,\n bytes memory args,\n bytes32 salt\n ) internal returns (bool alreadyDeployed, address instance) {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40)\n let n := mload(args)\n pop(staticcall(gas(), 4, add(args, 0x20), n, add(m, 0x90), n))\n mstore(add(m, 0x70), 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)\n mstore(add(m, 0x50), 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)\n mstore(add(m, 0x30), 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)\n mstore(add(m, 0x14), beacon)\n // Do a out-of-gas revert if `n` is greater than `0xffff - 0x57 = 0xffa8`.\n mstore(add(m, gt(n, 0xffa8)), add(0xfe6100573d8160233d3973, shl(56, n)))\n // Compute and store the bytecode hash.\n mstore8(0x00, 0xff) // Write the prefix.\n mstore(0x35, keccak256(add(m, 0x16), add(n, 0x7a)))\n mstore(0x01, shl(96, address()))\n mstore(0x15, salt)\n instance := keccak256(0x00, 0x55)\n for {} 1 {} {\n if iszero(extcodesize(instance)) {\n instance := create2(value, add(m, 0x16), add(n, 0x7a), salt)\n if iszero(instance) {\n mstore(0x00, 0x30116425) // `DeploymentFailed()`.\n revert(0x1c, 0x04)\n }\n break\n }\n alreadyDeployed := 1\n if iszero(value) { break }\n if iszero(call(gas(), instance, value, codesize(), 0x00, codesize(), 0x00)) {\n mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n revert(0x1c, 0x04)\n }\n break\n }\n mstore(0x35, 0) // Restore the overwritten part of the free memory pointer.\n }\n }\n\n /// @dev Returns the initialization code of the ERC1967I beacon proxy with `args`.\n function initCodeERC1967IBeaconProxy(address beacon, bytes memory args)\n internal\n pure\n returns (bytes memory c)\n {\n /// @solidity memory-safe-assembly\n assembly {\n c := mload(0x40)\n let n := mload(args)\n // Do a out-of-gas revert if `n` is greater than `0xffff - 0x57 = 0xffa8`.\n returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffa8))\n for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {\n mstore(add(add(c, 0x9a), i), mload(add(add(args, 0x20), i)))\n }\n mstore(add(c, 0x7a), 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)\n mstore(add(c, 0x5a), 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)\n mstore(add(c, 0x3a), 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)\n mstore(add(c, 0x1e), beacon)\n mstore(add(c, 0x0a), add(0x6100573d8160233d3973, shl(56, n)))\n mstore(add(c, add(n, 0x9a)), 0)\n mstore(c, add(n, 0x7a)) // Store the length.\n mstore(0x40, add(c, add(n, 0xba))) // Allocate memory.\n }\n }\n\n /// @dev Returns the initialization code hash of the ERC1967I beacon proxy with `args`.\n function initCodeHashERC1967IBeaconProxy(address beacon, bytes memory args)\n internal\n pure\n returns (bytes32 hash)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let c := mload(0x40) // Cache the free memory pointer.\n let n := mload(args)\n // Do a out-of-gas revert if `n` is greater than `0xffff - 0x57 = 0xffa8`.\n returndatacopy(returndatasize(), returndatasize(), gt(n, 0xffa8))\n for { let i := 0 } lt(i, n) { i := add(i, 0x20) } {\n mstore(add(add(c, 0x90), i), mload(add(add(args, 0x20), i)))\n }\n mstore(add(c, 0x70), 0x3d50545afa361460525736515af43d600060013e6052573d6001fd5b3d6001f3)\n mstore(add(c, 0x50), 0x527fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b3513)\n mstore(add(c, 0x30), 0x60195155f3363d3d373d3d363d602036600436635c60da1b60e01b36)\n mstore(add(c, 0x14), beacon)\n mstore(c, add(0x6100573d8160233d3973, shl(56, n)))\n hash := keccak256(add(c, 0x16), add(n, 0x7a))\n }\n }\n\n /// @dev Returns the address of the ERC1967I beacon proxy, with `args` and salt` by `deployer`.\n /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n function predictDeterministicAddressERC1967IBeaconProxy(\n address beacon,\n bytes memory args,\n bytes32 salt,\n address deployer\n ) internal pure returns (address predicted) {\n bytes32 hash = initCodeHashERC1967IBeaconProxy(beacon, args);\n predicted = predictDeterministicAddress(hash, salt, deployer);\n }\n\n /// @dev Equivalent to `argsOnERC1967IBeaconProxy(instance, start, 2 ** 256 - 1)`.\n function argsOnERC1967IBeaconProxy(address instance)\n internal\n view\n returns (bytes memory args)\n {\n /// @solidity memory-safe-assembly\n assembly {\n args := mload(0x40)\n mstore(args, and(0xffffffffff, sub(extcodesize(instance), 0x57))) // Store the length.\n extcodecopy(instance, add(args, 0x20), 0x57, add(mload(args), 0x20))\n mstore(0x40, add(mload(args), add(args, 0x40))) // Allocate memory.\n }\n }\n\n /// @dev Equivalent to `argsOnERC1967IBeaconProxy(instance, start, 2 ** 256 - 1)`.\n function argsOnERC1967IBeaconProxy(address instance, uint256 start)\n internal\n view\n returns (bytes memory args)\n {\n /// @solidity memory-safe-assembly\n assembly {\n args := mload(0x40)\n let n := and(0xffffffffff, sub(extcodesize(instance), 0x57))\n extcodecopy(instance, add(args, 0x20), add(start, 0x57), add(n, 0x20))\n mstore(args, mul(sub(n, start), lt(start, n))) // Store the length.\n mstore(0x40, add(args, add(0x40, mload(args)))) // Allocate memory.\n }\n }\n\n /// @dev Returns a slice of the immutable arguments on `instance` from `start` to `end`.\n /// `start` and `end` will be clamped to the range `[0, args.length]`.\n /// The `instance` MUST be deployed via the ERC1967I beacon proxy with immutable args functions.\n /// Otherwise, the behavior is undefined.\n /// Out-of-gas reverts if `instance` does not have any code.\n function argsOnERC1967IBeaconProxy(address instance, uint256 start, uint256 end)\n internal\n view\n returns (bytes memory args)\n {\n /// @solidity memory-safe-assembly\n assembly {\n args := mload(0x40)\n if iszero(lt(end, 0xffff)) { end := 0xffff }\n let d := mul(sub(end, start), lt(start, end))\n extcodecopy(instance, args, add(start, 0x37), add(d, 0x20))\n if iszero(and(0xff, mload(add(args, d)))) {\n let n := sub(extcodesize(instance), 0x57)\n returndatacopy(returndatasize(), returndatasize(), shr(40, n))\n d := mul(gt(n, start), sub(d, mul(gt(end, n), sub(end, n))))\n }\n mstore(args, d) // Store the length.\n mstore(add(add(args, 0x20), d), 0) // Zeroize the slot after the bytes.\n mstore(0x40, add(add(args, 0x40), d)) // Allocate memory.\n }\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* OTHER OPERATIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Returns `address(0)` if the implementation address cannot be determined.\n function implementationOf(address instance) internal view returns (address result) {\n /// @solidity memory-safe-assembly\n assembly {\n for { extcodecopy(instance, 0x00, 0x00, 0x57) } 1 {} {\n if mload(0x2d) {\n // ERC1967I and ERC1967IBeaconProxy detection.\n if or(\n eq(keccak256(0x00, 0x52), ERC1967I_CODE_HASH),\n eq(keccak256(0x00, 0x57), ERC1967I_BEACON_PROXY_CODE_HASH)\n ) {\n pop(staticcall(gas(), instance, 0x00, 0x01, 0x00, 0x20))\n result := mload(0x0c)\n break\n }\n }\n // 0age clone detection.\n result := mload(0x0b)\n codecopy(0x0b, codesize(), 0x14) // Zeroize the 20 bytes for the address.\n if iszero(xor(keccak256(0x00, 0x2c), CLONE_CODE_HASH)) { break }\n mstore(0x0b, result) // Restore the zeroized memory.\n // CWIA detection.\n result := mload(0x0a)\n codecopy(0x0a, codesize(), 0x14) // Zeroize the 20 bytes for the address.\n if iszero(xor(keccak256(0x00, 0x2d), CWIA_CODE_HASH)) { break }\n mstore(0x0a, result) // Restore the zeroized memory.\n // PUSH0 clone detection.\n result := mload(0x09)\n codecopy(0x09, codesize(), 0x14) // Zeroize the 20 bytes for the address.\n result := shr(xor(keccak256(0x00, 0x2d), PUSH0_CLONE_CODE_HASH), result)\n break\n }\n result := shr(96, result)\n mstore(0x37, 0) // Restore the overwritten part of the free memory pointer.\n }\n }\n\n /// @dev Returns the address when a contract with initialization code hash,\n /// `hash`, is deployed with `salt`, by `deployer`.\n /// Note: The returned result has dirty upper 96 bits. Please clean if used in assembly.\n function predictDeterministicAddress(bytes32 hash, bytes32 salt, address deployer)\n internal\n pure\n returns (address predicted)\n {\n /// @solidity memory-safe-assembly\n assembly {\n // Compute and store the bytecode hash.\n mstore8(0x00, 0xff) // Write the prefix.\n mstore(0x35, hash)\n mstore(0x01, shl(96, deployer))\n mstore(0x15, salt)\n predicted := keccak256(0x00, 0x55)\n mstore(0x35, 0) // Restore the overwritten part of the free memory pointer.\n }\n }\n\n /// @dev Requires that `salt` starts with either the zero address or `by`.\n function checkStartsWith(bytes32 salt, address by) internal pure {\n /// @solidity memory-safe-assembly\n assembly {\n // If the salt does not start with the zero address or `by`.\n if iszero(or(iszero(shr(96, salt)), eq(shr(96, shl(96, by)), shr(96, salt)))) {\n mstore(0x00, 0x0c4549ef) // `SaltDoesNotStartWith()`.\n revert(0x1c, 0x04)\n }\n }\n }\n\n /// @dev Returns the `bytes32` at `offset` in `args`, without any bounds checks.\n /// To load an address, you can use `address(bytes20(argLoad(args, offset)))`.\n function argLoad(bytes memory args, uint256 offset) internal pure returns (bytes32 result) {\n /// @solidity memory-safe-assembly\n assembly {\n result := mload(add(add(args, 0x20), offset))\n }\n }\n}\n"},"lib/solady/src/utils/SafeTransferLib.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/SafeTransferLib.sol)\n/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SafeTransferLib.sol)\n/// @author Permit2 operations from (https://github.com/Uniswap/permit2/blob/main/src/libraries/Permit2Lib.sol)\n///\n/// @dev Note:\n/// - For ETH transfers, please use `forceSafeTransferETH` for DoS protection.\nlibrary SafeTransferLib {\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* CUSTOM ERRORS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev The ETH transfer has failed.\n error ETHTransferFailed();\n\n /// @dev The ERC20 `transferFrom` has failed.\n error TransferFromFailed();\n\n /// @dev The ERC20 `transfer` has failed.\n error TransferFailed();\n\n /// @dev The ERC20 `approve` has failed.\n error ApproveFailed();\n\n /// @dev The Permit2 operation has failed.\n error Permit2Failed();\n\n /// @dev The Permit2 amount must be less than `2**160 - 1`.\n error Permit2AmountOverflow();\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* CONSTANTS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Suggested gas stipend for contract receiving ETH that disallows any storage writes.\n uint256 internal constant GAS_STIPEND_NO_STORAGE_WRITES = 2300;\n\n /// @dev Suggested gas stipend for contract receiving ETH to perform a few\n /// storage reads and writes, but low enough to prevent griefing.\n uint256 internal constant GAS_STIPEND_NO_GRIEF = 100000;\n\n /// @dev The unique EIP-712 domain domain separator for the DAI token contract.\n bytes32 internal constant DAI_DOMAIN_SEPARATOR =\n 0xdbb8cf42e1ecb028be3f3dbc922e1d878b963f411dc388ced501601c60f7c6f7;\n\n /// @dev The address for the WETH9 contract on Ethereum mainnet.\n address internal constant WETH9 = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;\n\n /// @dev The canonical Permit2 address.\n /// [Github](https://github.com/Uniswap/permit2)\n /// [Etherscan](https://etherscan.io/address/0x000000000022D473030F116dDEE9F6B43aC78BA3)\n address internal constant PERMIT2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* ETH OPERATIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n // If the ETH transfer MUST succeed with a reasonable gas budget, use the force variants.\n //\n // The regular variants:\n // - Forwards all remaining gas to the target.\n // - Reverts if the target reverts.\n // - Reverts if the current contract has insufficient balance.\n //\n // The force variants:\n // - Forwards with an optional gas stipend\n // (defaults to `GAS_STIPEND_NO_GRIEF`, which is sufficient for most cases).\n // - If the target reverts, or if the gas stipend is exhausted,\n // creates a temporary contract to force send the ETH via `SELFDESTRUCT`.\n // Future compatible with `SENDALL`: https://eips.ethereum.org/EIPS/eip-4758.\n // - Reverts if the current contract has insufficient balance.\n //\n // The try variants:\n // - Forwards with a mandatory gas stipend.\n // - Instead of reverting, returns whether the transfer succeeded.\n\n /// @dev Sends `amount` (in wei) ETH to `to`.\n function safeTransferETH(address to, uint256 amount) internal {\n /// @solidity memory-safe-assembly\n assembly {\n if iszero(call(gas(), to, amount, codesize(), 0x00, codesize(), 0x00)) {\n mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n revert(0x1c, 0x04)\n }\n }\n }\n\n /// @dev Sends all the ETH in the current contract to `to`.\n function safeTransferAllETH(address to) internal {\n /// @solidity memory-safe-assembly\n assembly {\n // Transfer all the ETH and check if it succeeded or not.\n if iszero(call(gas(), to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {\n mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n revert(0x1c, 0x04)\n }\n }\n }\n\n /// @dev Force sends `amount` (in wei) ETH to `to`, with a `gasStipend`.\n function forceSafeTransferETH(address to, uint256 amount, uint256 gasStipend) internal {\n /// @solidity memory-safe-assembly\n assembly {\n if lt(selfbalance(), amount) {\n mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n revert(0x1c, 0x04)\n }\n if iszero(call(gasStipend, to, amount, codesize(), 0x00, codesize(), 0x00)) {\n mstore(0x00, to) // Store the address in scratch space.\n mstore8(0x0b, 0x73) // Opcode `PUSH20`.\n mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.\n if iszero(create(amount, 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.\n }\n }\n }\n\n /// @dev Force sends all the ETH in the current contract to `to`, with a `gasStipend`.\n function forceSafeTransferAllETH(address to, uint256 gasStipend) internal {\n /// @solidity memory-safe-assembly\n assembly {\n if iszero(call(gasStipend, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {\n mstore(0x00, to) // Store the address in scratch space.\n mstore8(0x0b, 0x73) // Opcode `PUSH20`.\n mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.\n if iszero(create(selfbalance(), 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.\n }\n }\n }\n\n /// @dev Force sends `amount` (in wei) ETH to `to`, with `GAS_STIPEND_NO_GRIEF`.\n function forceSafeTransferETH(address to, uint256 amount) internal {\n /// @solidity memory-safe-assembly\n assembly {\n if lt(selfbalance(), amount) {\n mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n revert(0x1c, 0x04)\n }\n if iszero(call(GAS_STIPEND_NO_GRIEF, to, amount, codesize(), 0x00, codesize(), 0x00)) {\n mstore(0x00, to) // Store the address in scratch space.\n mstore8(0x0b, 0x73) // Opcode `PUSH20`.\n mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.\n if iszero(create(amount, 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.\n }\n }\n }\n\n /// @dev Force sends all the ETH in the current contract to `to`, with `GAS_STIPEND_NO_GRIEF`.\n function forceSafeTransferAllETH(address to) internal {\n /// @solidity memory-safe-assembly\n assembly {\n // forgefmt: disable-next-item\n if iszero(call(GAS_STIPEND_NO_GRIEF, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {\n mstore(0x00, to) // Store the address in scratch space.\n mstore8(0x0b, 0x73) // Opcode `PUSH20`.\n mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.\n if iszero(create(selfbalance(), 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.\n }\n }\n }\n\n /// @dev Sends `amount` (in wei) ETH to `to`, with a `gasStipend`.\n function trySafeTransferETH(address to, uint256 amount, uint256 gasStipend)\n internal\n returns (bool success)\n {\n /// @solidity memory-safe-assembly\n assembly {\n success := call(gasStipend, to, amount, codesize(), 0x00, codesize(), 0x00)\n }\n }\n\n /// @dev Sends all the ETH in the current contract to `to`, with a `gasStipend`.\n function trySafeTransferAllETH(address to, uint256 gasStipend)\n internal\n returns (bool success)\n {\n /// @solidity memory-safe-assembly\n assembly {\n success := call(gasStipend, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)\n }\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* ERC20 OPERATIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Sends `amount` of ERC20 `token` from `from` to `to`.\n /// Reverts upon failure.\n ///\n /// The `from` account must have at least `amount` approved for\n /// the current contract to manage.\n function safeTransferFrom(address token, address from, address to, uint256 amount) internal {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40) // Cache the free memory pointer.\n mstore(0x60, amount) // Store the `amount` argument.\n mstore(0x40, to) // Store the `to` argument.\n mstore(0x2c, shl(96, from)) // Store the `from` argument.\n mstore(0x0c, 0x23b872dd000000000000000000000000) // `transferFrom(address,address,uint256)`.\n let success := call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)\n if iszero(and(eq(mload(0x00), 1), success)) {\n if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\n mstore(0x00, 0x7939f424) // `TransferFromFailed()`.\n revert(0x1c, 0x04)\n }\n }\n mstore(0x60, 0) // Restore the zero slot to zero.\n mstore(0x40, m) // Restore the free memory pointer.\n }\n }\n\n /// @dev Sends `amount` of ERC20 `token` from `from` to `to`.\n ///\n /// The `from` account must have at least `amount` approved for the current contract to manage.\n function trySafeTransferFrom(address token, address from, address to, uint256 amount)\n internal\n returns (bool success)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40) // Cache the free memory pointer.\n mstore(0x60, amount) // Store the `amount` argument.\n mstore(0x40, to) // Store the `to` argument.\n mstore(0x2c, shl(96, from)) // Store the `from` argument.\n mstore(0x0c, 0x23b872dd000000000000000000000000) // `transferFrom(address,address,uint256)`.\n success := call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)\n if iszero(and(eq(mload(0x00), 1), success)) {\n success := lt(or(iszero(extcodesize(token)), returndatasize()), success)\n }\n mstore(0x60, 0) // Restore the zero slot to zero.\n mstore(0x40, m) // Restore the free memory pointer.\n }\n }\n\n /// @dev Sends all of ERC20 `token` from `from` to `to`.\n /// Reverts upon failure.\n ///\n /// The `from` account must have their entire balance approved for the current contract to manage.\n function safeTransferAllFrom(address token, address from, address to)\n internal\n returns (uint256 amount)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40) // Cache the free memory pointer.\n mstore(0x40, to) // Store the `to` argument.\n mstore(0x2c, shl(96, from)) // Store the `from` argument.\n mstore(0x0c, 0x70a08231000000000000000000000000) // `balanceOf(address)`.\n // Read the balance, reverting upon failure.\n if iszero(\n and( // The arguments of `and` are evaluated from right to left.\n gt(returndatasize(), 0x1f), // At least 32 bytes returned.\n staticcall(gas(), token, 0x1c, 0x24, 0x60, 0x20)\n )\n ) {\n mstore(0x00, 0x7939f424) // `TransferFromFailed()`.\n revert(0x1c, 0x04)\n }\n mstore(0x00, 0x23b872dd) // `transferFrom(address,address,uint256)`.\n amount := mload(0x60) // The `amount` is already at 0x60. We'll need to return it.\n // Perform the transfer, reverting upon failure.\n let success := call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)\n if iszero(and(eq(mload(0x00), 1), success)) {\n if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\n mstore(0x00, 0x7939f424) // `TransferFromFailed()`.\n revert(0x1c, 0x04)\n }\n }\n mstore(0x60, 0) // Restore the zero slot to zero.\n mstore(0x40, m) // Restore the free memory pointer.\n }\n }\n\n /// @dev Sends `amount` of ERC20 `token` from the current contract to `to`.\n /// Reverts upon failure.\n function safeTransfer(address token, address to, uint256 amount) internal {\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x14, to) // Store the `to` argument.\n mstore(0x34, amount) // Store the `amount` argument.\n mstore(0x00, 0xa9059cbb000000000000000000000000) // `transfer(address,uint256)`.\n // Perform the transfer, reverting upon failure.\n let success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n if iszero(and(eq(mload(0x00), 1), success)) {\n if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\n mstore(0x00, 0x90b8ec18) // `TransferFailed()`.\n revert(0x1c, 0x04)\n }\n }\n mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.\n }\n }\n\n /// @dev Sends all of ERC20 `token` from the current contract to `to`.\n /// Reverts upon failure.\n function safeTransferAll(address token, address to) internal returns (uint256 amount) {\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, 0x70a08231) // Store the function selector of `balanceOf(address)`.\n mstore(0x20, address()) // Store the address of the current contract.\n // Read the balance, reverting upon failure.\n if iszero(\n and( // The arguments of `and` are evaluated from right to left.\n gt(returndatasize(), 0x1f), // At least 32 bytes returned.\n staticcall(gas(), token, 0x1c, 0x24, 0x34, 0x20)\n )\n ) {\n mstore(0x00, 0x90b8ec18) // `TransferFailed()`.\n revert(0x1c, 0x04)\n }\n mstore(0x14, to) // Store the `to` argument.\n amount := mload(0x34) // The `amount` is already at 0x34. We'll need to return it.\n mstore(0x00, 0xa9059cbb000000000000000000000000) // `transfer(address,uint256)`.\n // Perform the transfer, reverting upon failure.\n let success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n if iszero(and(eq(mload(0x00), 1), success)) {\n if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\n mstore(0x00, 0x90b8ec18) // `TransferFailed()`.\n revert(0x1c, 0x04)\n }\n }\n mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.\n }\n }\n\n /// @dev Sets `amount` of ERC20 `token` for `to` to manage on behalf of the current contract.\n /// Reverts upon failure.\n function safeApprove(address token, address to, uint256 amount) internal {\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x14, to) // Store the `to` argument.\n mstore(0x34, amount) // Store the `amount` argument.\n mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.\n let success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n if iszero(and(eq(mload(0x00), 1), success)) {\n if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\n mstore(0x00, 0x3e3f8f73) // `ApproveFailed()`.\n revert(0x1c, 0x04)\n }\n }\n mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.\n }\n }\n\n /// @dev Sets `amount` of ERC20 `token` for `to` to manage on behalf of the current contract.\n /// If the initial attempt to approve fails, attempts to reset the approved amount to zero,\n /// then retries the approval again (some tokens, e.g. USDT, requires this).\n /// Reverts upon failure.\n function safeApproveWithRetry(address token, address to, uint256 amount) internal {\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x14, to) // Store the `to` argument.\n mstore(0x34, amount) // Store the `amount` argument.\n mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.\n // Perform the approval, retrying upon failure.\n let success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n if iszero(and(eq(mload(0x00), 1), success)) {\n if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\n mstore(0x34, 0) // Store 0 for the `amount`.\n mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.\n pop(call(gas(), token, 0, 0x10, 0x44, codesize(), 0x00)) // Reset the approval.\n mstore(0x34, amount) // Store back the original `amount`.\n // Retry the approval, reverting upon failure.\n success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n if iszero(and(eq(mload(0x00), 1), success)) {\n // Check the `extcodesize` again just in case the token selfdestructs lol.\n if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\n mstore(0x00, 0x3e3f8f73) // `ApproveFailed()`.\n revert(0x1c, 0x04)\n }\n }\n }\n }\n mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.\n }\n }\n\n /// @dev Returns the amount of ERC20 `token` owned by `account`.\n /// Returns zero if the `token` does not exist.\n function balanceOf(address token, address account) internal view returns (uint256 amount) {\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x14, account) // Store the `account` argument.\n mstore(0x00, 0x70a08231000000000000000000000000) // `balanceOf(address)`.\n amount :=\n mul( // The arguments of `mul` are evaluated from right to left.\n mload(0x20),\n and( // The arguments of `and` are evaluated from right to left.\n gt(returndatasize(), 0x1f), // At least 32 bytes returned.\n staticcall(gas(), token, 0x10, 0x24, 0x20, 0x20)\n )\n )\n }\n }\n\n /// @dev Sends `amount` of ERC20 `token` from `from` to `to`.\n /// If the initial attempt fails, try to use Permit2 to transfer the token.\n /// Reverts upon failure.\n ///\n /// The `from` account must have at least `amount` approved for the current contract to manage.\n function safeTransferFrom2(address token, address from, address to, uint256 amount) internal {\n if (!trySafeTransferFrom(token, from, to, amount)) {\n permit2TransferFrom(token, from, to, amount);\n }\n }\n\n /// @dev Sends `amount` of ERC20 `token` from `from` to `to` via Permit2.\n /// Reverts upon failure.\n function permit2TransferFrom(address token, address from, address to, uint256 amount)\n internal\n {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40)\n mstore(add(m, 0x74), shr(96, shl(96, token)))\n mstore(add(m, 0x54), amount)\n mstore(add(m, 0x34), to)\n mstore(add(m, 0x20), shl(96, from))\n // `transferFrom(address,address,uint160,address)`.\n mstore(m, 0x36c78516000000000000000000000000)\n let p := PERMIT2\n let exists := eq(chainid(), 1)\n if iszero(exists) { exists := iszero(iszero(extcodesize(p))) }\n if iszero(\n and(\n call(gas(), p, 0, add(m, 0x10), 0x84, codesize(), 0x00),\n lt(iszero(extcodesize(token)), exists) // Token has code and Permit2 exists.\n )\n ) {\n mstore(0x00, 0x7939f4248757f0fd) // `TransferFromFailed()` or `Permit2AmountOverflow()`.\n revert(add(0x18, shl(2, iszero(iszero(shr(160, amount))))), 0x04)\n }\n }\n }\n\n /// @dev Permit a user to spend a given amount of\n /// another user's tokens via native EIP-2612 permit if possible, falling\n /// back to Permit2 if native permit fails or is not implemented on the token.\n function permit2(\n address token,\n address owner,\n address spender,\n uint256 amount,\n uint256 deadline,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) internal {\n bool success;\n /// @solidity memory-safe-assembly\n assembly {\n for {} shl(96, xor(token, WETH9)) {} {\n mstore(0x00, 0x3644e515) // `DOMAIN_SEPARATOR()`.\n if iszero(\n and( // The arguments of `and` are evaluated from right to left.\n lt(iszero(mload(0x00)), eq(returndatasize(), 0x20)), // Returns 1 non-zero word.\n // Gas stipend to limit gas burn for tokens that don't refund gas when\n // an non-existing function is called. 5K should be enough for a SLOAD.\n staticcall(5000, token, 0x1c, 0x04, 0x00, 0x20)\n )\n ) { break }\n // After here, we can be sure that token is a contract.\n let m := mload(0x40)\n mstore(add(m, 0x34), spender)\n mstore(add(m, 0x20), shl(96, owner))\n mstore(add(m, 0x74), deadline)\n if eq(mload(0x00), DAI_DOMAIN_SEPARATOR) {\n mstore(0x14, owner)\n mstore(0x00, 0x7ecebe00000000000000000000000000) // `nonces(address)`.\n mstore(add(m, 0x94), staticcall(gas(), token, 0x10, 0x24, add(m, 0x54), 0x20))\n mstore(m, 0x8fcbaf0c000000000000000000000000) // `IDAIPermit.permit`.\n // `nonces` is already at `add(m, 0x54)`.\n // `1` is already stored at `add(m, 0x94)`.\n mstore(add(m, 0xb4), and(0xff, v))\n mstore(add(m, 0xd4), r)\n mstore(add(m, 0xf4), s)\n success := call(gas(), token, 0, add(m, 0x10), 0x104, codesize(), 0x00)\n break\n }\n mstore(m, 0xd505accf000000000000000000000000) // `IERC20Permit.permit`.\n mstore(add(m, 0x54), amount)\n mstore(add(m, 0x94), and(0xff, v))\n mstore(add(m, 0xb4), r)\n mstore(add(m, 0xd4), s)\n success := call(gas(), token, 0, add(m, 0x10), 0xe4, codesize(), 0x00)\n break\n }\n }\n if (!success) simplePermit2(token, owner, spender, amount, deadline, v, r, s);\n }\n\n /// @dev Simple permit on the Permit2 contract.\n function simplePermit2(\n address token,\n address owner,\n address spender,\n uint256 amount,\n uint256 deadline,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) internal {\n /// @solidity memory-safe-assembly\n assembly {\n let m := mload(0x40)\n mstore(m, 0x927da105) // `allowance(address,address,address)`.\n {\n let addressMask := shr(96, not(0))\n mstore(add(m, 0x20), and(addressMask, owner))\n mstore(add(m, 0x40), and(addressMask, token))\n mstore(add(m, 0x60), and(addressMask, spender))\n mstore(add(m, 0xc0), and(addressMask, spender))\n }\n let p := mul(PERMIT2, iszero(shr(160, amount)))\n if iszero(\n and( // The arguments of `and` are evaluated from right to left.\n gt(returndatasize(), 0x5f), // Returns 3 words: `amount`, `expiration`, `nonce`.\n staticcall(gas(), p, add(m, 0x1c), 0x64, add(m, 0x60), 0x60)\n )\n ) {\n mstore(0x00, 0x6b836e6b8757f0fd) // `Permit2Failed()` or `Permit2AmountOverflow()`.\n revert(add(0x18, shl(2, iszero(p))), 0x04)\n }\n mstore(m, 0x2b67b570) // `Permit2.permit` (PermitSingle variant).\n // `owner` is already `add(m, 0x20)`.\n // `token` is already at `add(m, 0x40)`.\n mstore(add(m, 0x60), amount)\n mstore(add(m, 0x80), 0xffffffffffff) // `expiration = type(uint48).max`.\n // `nonce` is already at `add(m, 0xa0)`.\n // `spender` is already at `add(m, 0xc0)`.\n mstore(add(m, 0xe0), deadline)\n mstore(add(m, 0x100), 0x100) // `signature` offset.\n mstore(add(m, 0x120), 0x41) // `signature` length.\n mstore(add(m, 0x140), r)\n mstore(add(m, 0x160), s)\n mstore(add(m, 0x180), shl(248, v))\n if iszero( // Revert if token does not have code, or if the call fails.\n mul(extcodesize(token), call(gas(), p, 0, add(m, 0x1c), 0x184, codesize(), 0x00))) {\n mstore(0x00, 0x6b836e6b) // `Permit2Failed()`.\n revert(0x1c, 0x04)\n }\n }\n }\n}\n"},"node_modules/@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (access/AccessControl.sol)\n\npragma solidity ^0.8.20;\n\nimport {IAccessControl} from \"@openzeppelin/contracts/access/IAccessControl.sol\";\nimport {ContextUpgradeable} from \"../utils/ContextUpgradeable.sol\";\nimport {ERC165Upgradeable} from \"../utils/introspection/ERC165Upgradeable.sol\";\nimport {Initializable} from \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module that allows children to implement role-based access\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\n * members except through off-chain means by accessing the contract event logs. Some\n * applications may benefit from on-chain enumerability, for those cases see\n * {AccessControlEnumerable}.\n *\n * Roles are referred to by their `bytes32` identifier. These should be exposed\n * in the external API and be unique. The best way to achieve this is by\n * using `public constant` hash digests:\n *\n * ```solidity\n * bytes32 public constant MY_ROLE = keccak256(\"MY_ROLE\");\n * ```\n *\n * Roles can be used to represent a set of permissions. To restrict access to a\n * function call, use {hasRole}:\n *\n * ```solidity\n * function foo() public {\n * require(hasRole(MY_ROLE, msg.sender));\n * ...\n * }\n * ```\n *\n * Roles can be granted and revoked dynamically via the {grantRole} and\n * {revokeRole} functions. Each role has an associated admin role, and only\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\n *\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\n * that only accounts with this role will be able to grant or revoke other\n * roles. More complex role relationships can be created by using\n * {_setRoleAdmin}.\n *\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\n * grant and revoke this role. Extra precautions should be taken to secure\n * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}\n * to enforce additional security measures for this role.\n */\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControl, ERC165Upgradeable {\n struct RoleData {\n mapping(address account => bool) hasRole;\n bytes32 adminRole;\n }\n\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\n\n\n /// @custom:storage-location erc7201:openzeppelin.storage.AccessControl\n struct AccessControlStorage {\n mapping(bytes32 role => RoleData) _roles;\n }\n\n // keccak256(abi.encode(uint256(keccak256(\"openzeppelin.storage.AccessControl\")) - 1)) & ~bytes32(uint256(0xff))\n bytes32 private constant AccessControlStorageLocation = 0x02dd7bc7dec4dceedda775e58dd541e08a116c6c53815c0bd028192f7b626800;\n\n function _getAccessControlStorage() private pure returns (AccessControlStorage storage $) {\n assembly {\n $.slot := AccessControlStorageLocation\n }\n }\n\n /**\n * @dev Modifier that checks that an account has a specific role. Reverts\n * with an {AccessControlUnauthorizedAccount} error including the required role.\n */\n modifier onlyRole(bytes32 role) {\n _checkRole(role);\n _;\n }\n\n function __AccessControl_init() internal onlyInitializing {\n }\n\n function __AccessControl_init_unchained() internal onlyInitializing {\n }\n /**\n * @dev See {IERC165-supportsInterface}.\n */\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);\n }\n\n /**\n * @dev Returns `true` if `account` has been granted `role`.\n */\n function hasRole(bytes32 role, address account) public view virtual returns (bool) {\n AccessControlStorage storage $ = _getAccessControlStorage();\n return $._roles[role].hasRole[account];\n }\n\n /**\n * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `_msgSender()`\n * is missing `role`. Overriding this function changes the behavior of the {onlyRole} modifier.\n */\n function _checkRole(bytes32 role) internal view virtual {\n _checkRole(role, _msgSender());\n }\n\n /**\n * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `account`\n * is missing `role`.\n */\n function _checkRole(bytes32 role, address account) internal view virtual {\n if (!hasRole(role, account)) {\n revert AccessControlUnauthorizedAccount(account, role);\n }\n }\n\n /**\n * @dev Returns the admin role that controls `role`. See {grantRole} and\n * {revokeRole}.\n *\n * To change a role's admin, use {_setRoleAdmin}.\n */\n function getRoleAdmin(bytes32 role) public view virtual returns (bytes32) {\n AccessControlStorage storage $ = _getAccessControlStorage();\n return $._roles[role].adminRole;\n }\n\n /**\n * @dev Grants `role` to `account`.\n *\n * If `account` had not been already granted `role`, emits a {RoleGranted}\n * event.\n *\n * Requirements:\n *\n * - the caller must have ``role``'s admin role.\n *\n * May emit a {RoleGranted} event.\n */\n function grantRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {\n _grantRole(role, account);\n }\n\n /**\n * @dev Revokes `role` from `account`.\n *\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\n *\n * Requirements:\n *\n * - the caller must have ``role``'s admin role.\n *\n * May emit a {RoleRevoked} event.\n */\n function revokeRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {\n _revokeRole(role, account);\n }\n\n /**\n * @dev Revokes `role` from the calling account.\n *\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\n * purpose is to provide a mechanism for accounts to lose their privileges\n * if they are compromised (such as when a trusted device is misplaced).\n *\n * If the calling account had been revoked `role`, emits a {RoleRevoked}\n * event.\n *\n * Requirements:\n *\n * - the caller must be `callerConfirmation`.\n *\n * May emit a {RoleRevoked} event.\n */\n function renounceRole(bytes32 role, address callerConfirmation) public virtual {\n if (callerConfirmation != _msgSender()) {\n revert AccessControlBadConfirmation();\n }\n\n _revokeRole(role, callerConfirmation);\n }\n\n /**\n * @dev Sets `adminRole` as ``role``'s admin role.\n *\n * Emits a {RoleAdminChanged} event.\n */\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\n AccessControlStorage storage $ = _getAccessControlStorage();\n bytes32 previousAdminRole = getRoleAdmin(role);\n $._roles[role].adminRole = adminRole;\n emit RoleAdminChanged(role, previousAdminRole, adminRole);\n }\n\n /**\n * @dev Attempts to grant `role` to `account` and returns a boolean indicating if `role` was granted.\n *\n * Internal function without access restriction.\n *\n * May emit a {RoleGranted} event.\n */\n function _grantRole(bytes32 role, address account) internal virtual returns (bool) {\n AccessControlStorage storage $ = _getAccessControlStorage();\n if (!hasRole(role, account)) {\n $._roles[role].hasRole[account] = true;\n emit RoleGranted(role, account, _msgSender());\n return true;\n } else {\n return false;\n }\n }\n\n /**\n * @dev Attempts to revoke `role` to `account` and returns a boolean indicating if `role` was revoked.\n *\n * Internal function without access restriction.\n *\n * May emit a {RoleRevoked} event.\n */\n function _revokeRole(bytes32 role, address account) internal virtual returns (bool) {\n AccessControlStorage storage $ = _getAccessControlStorage();\n if (hasRole(role, account)) {\n $._roles[role].hasRole[account] = false;\n emit RoleRevoked(role, account, _msgSender());\n return true;\n } else {\n return false;\n }\n }\n}\n"},"node_modules/@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/Initializable.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\n *\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\n * reused. This mechanism prevents re-execution of each \"step\" but allows the creation of new initialization steps in\n * case an upgrade adds a module that needs to be initialized.\n *\n * For example:\n *\n * [.hljs-theme-light.nopadding]\n * ```solidity\n * contract MyToken is ERC20Upgradeable {\n * function initialize() initializer public {\n * __ERC20_init(\"MyToken\", \"MTK\");\n * }\n * }\n *\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\n * function initializeV2() reinitializer(2) public {\n * __ERC20Permit_init(\"MyToken\");\n * }\n * }\n * ```\n *\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\n *\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\n *\n * [CAUTION]\n * ====\n * Avoid leaving a contract uninitialized.\n *\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * /// @custom:oz-upgrades-unsafe-allow constructor\n * constructor() {\n * _disableInitializers();\n * }\n * ```\n * ====\n */\nabstract contract Initializable {\n /**\n * @dev Storage of the initializable contract.\n *\n * It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions\n * when using with upgradeable contracts.\n *\n * @custom:storage-location erc7201:openzeppelin.storage.Initializable\n */\n struct InitializableStorage {\n /**\n * @dev Indicates that the contract has been initialized.\n */\n uint64 _initialized;\n /**\n * @dev Indicates that the contract is in the process of being initialized.\n */\n bool _initializing;\n }\n\n // keccak256(abi.encode(uint256(keccak256(\"openzeppelin.storage.Initializable\")) - 1)) & ~bytes32(uint256(0xff))\n bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00;\n\n /**\n * @dev The contract is already initialized.\n */\n error InvalidInitialization();\n\n /**\n * @dev The contract is not initializing.\n */\n error NotInitializing();\n\n /**\n * @dev Triggered when the contract has been initialized or reinitialized.\n */\n event Initialized(uint64 version);\n\n /**\n * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\n * `onlyInitializing` functions can be used to initialize parent contracts.\n *\n * Similar to `reinitializer(1)`, except that in the context of a constructor an `initializer` may be invoked any\n * number of times. This behavior in the constructor can be useful during testing and is not expected to be used in\n * production.\n *\n * Emits an {Initialized} event.\n */\n modifier initializer() {\n // solhint-disable-next-line var-name-mixedcase\n InitializableStorage storage $ = _getInitializableStorage();\n\n // Cache values to avoid duplicated sloads\n bool isTopLevelCall = !$._initializing;\n uint64 initialized = $._initialized;\n\n // Allowed calls:\n // - initialSetup: the contract is not in the initializing state and no previous version was\n // initialized\n // - construction: the contract is initialized at version 1 (no reininitialization) and the\n // current contract is just being deployed\n bool initialSetup = initialized == 0 && isTopLevelCall;\n bool construction = initialized == 1 && address(this).code.length == 0;\n\n if (!initialSetup && !construction) {\n revert InvalidInitialization();\n }\n $._initialized = 1;\n if (isTopLevelCall) {\n $._initializing = true;\n }\n _;\n if (isTopLevelCall) {\n $._initializing = false;\n emit Initialized(1);\n }\n }\n\n /**\n * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\n * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\n * used to initialize parent contracts.\n *\n * A reinitializer may be used after the original initialization step. This is essential to configure modules that\n * are added through upgrades and that require initialization.\n *\n * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\n * cannot be nested. If one is invoked in the context of another, execution will revert.\n *\n * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\n * a contract, executing them in the right order is up to the developer or operator.\n *\n * WARNING: Setting the version to 2**64 - 1 will prevent any future reinitialization.\n *\n * Emits an {Initialized} event.\n */\n modifier reinitializer(uint64 version) {\n // solhint-disable-next-line var-name-mixedcase\n InitializableStorage storage $ = _getInitializableStorage();\n\n if ($._initializing || $._initialized >= version) {\n revert InvalidInitialization();\n }\n $._initialized = version;\n $._initializing = true;\n _;\n $._initializing = false;\n emit Initialized(version);\n }\n\n /**\n * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\n * {initializer} and {reinitializer} modifiers, directly or indirectly.\n */\n modifier onlyInitializing() {\n _checkInitializing();\n _;\n }\n\n /**\n * @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}.\n */\n function _checkInitializing() internal view virtual {\n if (!_isInitializing()) {\n revert NotInitializing();\n }\n }\n\n /**\n * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\n * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\n * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\n * through proxies.\n *\n * Emits an {Initialized} event the first time it is successfully executed.\n */\n function _disableInitializers() internal virtual {\n // solhint-disable-next-line var-name-mixedcase\n InitializableStorage storage $ = _getInitializableStorage();\n\n if ($._initializing) {\n revert InvalidInitialization();\n }\n if ($._initialized != type(uint64).max) {\n $._initialized = type(uint64).max;\n emit Initialized(type(uint64).max);\n }\n }\n\n /**\n * @dev Returns the highest version that has been initialized. See {reinitializer}.\n */\n function _getInitializedVersion() internal view returns (uint64) {\n return _getInitializableStorage()._initialized;\n }\n\n /**\n * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.\n */\n function _isInitializing() internal view returns (bool) {\n return _getInitializableStorage()._initializing;\n }\n\n /**\n * @dev Returns a pointer to the storage namespace.\n */\n // solhint-disable-next-line var-name-mixedcase\n function _getInitializableStorage() private pure returns (InitializableStorage storage $) {\n assembly {\n $.slot := INITIALIZABLE_STORAGE\n }\n }\n}\n"},"node_modules/@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (proxy/utils/UUPSUpgradeable.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC1822Proxiable} from \"@openzeppelin/contracts/interfaces/draft-IERC1822.sol\";\nimport {ERC1967Utils} from \"@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol\";\nimport {Initializable} from \"./Initializable.sol\";\n\n/**\n * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an\n * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.\n *\n * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is\n * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing\n * `UUPSUpgradeable` with a custom implementation of upgrades.\n *\n * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.\n */\nabstract contract UUPSUpgradeable is Initializable, IERC1822Proxiable {\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\n address private immutable __self = address(this);\n\n /**\n * @dev The version of the upgrade interface of the contract. If this getter is missing, both `upgradeTo(address)`\n * and `upgradeToAndCall(address,bytes)` are present, and `upgradeTo` must be used if no function should be called,\n * while `upgradeToAndCall` will invoke the `receive` function if the second argument is the empty byte string.\n * If the getter returns `\"5.0.0\"`, only `upgradeToAndCall(address,bytes)` is present, and the second argument must\n * be the empty byte string if no function should be called, making it impossible to invoke the `receive` function\n * during an upgrade.\n */\n string public constant UPGRADE_INTERFACE_VERSION = \"5.0.0\";\n\n /**\n * @dev The call is from an unauthorized context.\n */\n error UUPSUnauthorizedCallContext();\n\n /**\n * @dev The storage `slot` is unsupported as a UUID.\n */\n error UUPSUnsupportedProxiableUUID(bytes32 slot);\n\n /**\n * @dev Check that the execution is being performed through a delegatecall call and that the execution context is\n * a proxy contract with an implementation (as defined in ERC-1967) pointing to self. This should only be the case\n * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a\n * function through ERC-1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to\n * fail.\n */\n modifier onlyProxy() {\n _checkProxy();\n _;\n }\n\n /**\n * @dev Check that the execution is not being performed through a delegate call. This allows a function to be\n * callable on the implementing contract but not through proxies.\n */\n modifier notDelegated() {\n _checkNotDelegated();\n _;\n }\n\n function __UUPSUpgradeable_init() internal onlyInitializing {\n }\n\n function __UUPSUpgradeable_init_unchained() internal onlyInitializing {\n }\n /**\n * @dev Implementation of the ERC-1822 {proxiableUUID} function. This returns the storage slot used by the\n * implementation. It is used to validate the implementation's compatibility when performing an upgrade.\n *\n * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\n * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\n * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.\n */\n function proxiableUUID() external view virtual notDelegated returns (bytes32) {\n return ERC1967Utils.IMPLEMENTATION_SLOT;\n }\n\n /**\n * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call\n * encoded in `data`.\n *\n * Calls {_authorizeUpgrade}.\n *\n * Emits an {Upgraded} event.\n *\n * @custom:oz-upgrades-unsafe-allow-reachable delegatecall\n */\n function upgradeToAndCall(address newImplementation, bytes memory data) public payable virtual onlyProxy {\n _authorizeUpgrade(newImplementation);\n _upgradeToAndCallUUPS(newImplementation, data);\n }\n\n /**\n * @dev Reverts if the execution is not performed via delegatecall or the execution\n * context is not of a proxy with an ERC-1967 compliant implementation pointing to self.\n * See {_onlyProxy}.\n */\n function _checkProxy() internal view virtual {\n if (\n address(this) == __self || // Must be called through delegatecall\n ERC1967Utils.getImplementation() != __self // Must be called through an active proxy\n ) {\n revert UUPSUnauthorizedCallContext();\n }\n }\n\n /**\n * @dev Reverts if the execution is performed via delegatecall.\n * See {notDelegated}.\n */\n function _checkNotDelegated() internal view virtual {\n if (address(this) != __self) {\n // Must not be called through delegatecall\n revert UUPSUnauthorizedCallContext();\n }\n }\n\n /**\n * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by\n * {upgradeToAndCall}.\n *\n * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.\n *\n * ```solidity\n * function _authorizeUpgrade(address) internal onlyOwner {}\n * ```\n */\n function _authorizeUpgrade(address newImplementation) internal virtual;\n\n /**\n * @dev Performs an implementation upgrade with a security check for UUPS proxies, and additional setup call.\n *\n * As a security check, {proxiableUUID} is invoked in the new implementation, and the return value\n * is expected to be the implementation slot in ERC-1967.\n *\n * Emits an {IERC1967-Upgraded} event.\n */\n function _upgradeToAndCallUUPS(address newImplementation, bytes memory data) private {\n try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {\n if (slot != ERC1967Utils.IMPLEMENTATION_SLOT) {\n revert UUPSUnsupportedProxiableUUID(slot);\n }\n ERC1967Utils.upgradeToAndCall(newImplementation, data);\n } catch {\n // The implementation is not UUPS\n revert ERC1967Utils.ERC1967InvalidImplementation(newImplementation);\n }\n }\n}\n"},"node_modules/@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\n\npragma solidity ^0.8.20;\nimport {Initializable} from \"../proxy/utils/Initializable.sol\";\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 ContextUpgradeable is Initializable {\n function __Context_init() internal onlyInitializing {\n }\n\n function __Context_init_unchained() internal onlyInitializing {\n }\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"},"node_modules/@openzeppelin/contracts-upgradeable/utils/PausableUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/Pausable.sol)\n\npragma solidity ^0.8.20;\n\nimport {ContextUpgradeable} from \"../utils/ContextUpgradeable.sol\";\nimport {Initializable} from \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module which allows children to implement an emergency stop\n * mechanism that can be triggered by an authorized account.\n *\n * This module is used through inheritance. It will make available the\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\n * the functions of your contract. Note that they will not be pausable by\n * simply including this module, only once the modifiers are put in place.\n */\nabstract contract PausableUpgradeable is Initializable, ContextUpgradeable {\n /// @custom:storage-location erc7201:openzeppelin.storage.Pausable\n struct PausableStorage {\n bool _paused;\n }\n\n // keccak256(abi.encode(uint256(keccak256(\"openzeppelin.storage.Pausable\")) - 1)) & ~bytes32(uint256(0xff))\n bytes32 private constant PausableStorageLocation = 0xcd5ed15c6e187e77e9aee88184c21f4f2182ab5827cb3b7e07fbedcd63f03300;\n\n function _getPausableStorage() private pure returns (PausableStorage storage $) {\n assembly {\n $.slot := PausableStorageLocation\n }\n }\n\n /**\n * @dev Emitted when the pause is triggered by `account`.\n */\n event Paused(address account);\n\n /**\n * @dev Emitted when the pause is lifted by `account`.\n */\n event Unpaused(address account);\n\n /**\n * @dev The operation failed because the contract is paused.\n */\n error EnforcedPause();\n\n /**\n * @dev The operation failed because the contract is not paused.\n */\n error ExpectedPause();\n\n /**\n * @dev Initializes the contract in unpaused state.\n */\n function __Pausable_init() internal onlyInitializing {\n __Pausable_init_unchained();\n }\n\n function __Pausable_init_unchained() internal onlyInitializing {\n PausableStorage storage $ = _getPausableStorage();\n $._paused = false;\n }\n\n /**\n * @dev Modifier to make a function callable only when the contract is not paused.\n *\n * Requirements:\n *\n * - The contract must not be paused.\n */\n modifier whenNotPaused() {\n _requireNotPaused();\n _;\n }\n\n /**\n * @dev Modifier to make a function callable only when the contract is paused.\n *\n * Requirements:\n *\n * - The contract must be paused.\n */\n modifier whenPaused() {\n _requirePaused();\n _;\n }\n\n /**\n * @dev Returns true if the contract is paused, and false otherwise.\n */\n function paused() public view virtual returns (bool) {\n PausableStorage storage $ = _getPausableStorage();\n return $._paused;\n }\n\n /**\n * @dev Throws if the contract is paused.\n */\n function _requireNotPaused() internal view virtual {\n if (paused()) {\n revert EnforcedPause();\n }\n }\n\n /**\n * @dev Throws if the contract is not paused.\n */\n function _requirePaused() internal view virtual {\n if (!paused()) {\n revert ExpectedPause();\n }\n }\n\n /**\n * @dev Triggers stopped state.\n *\n * Requirements:\n *\n * - The contract must not be paused.\n */\n function _pause() internal virtual whenNotPaused {\n PausableStorage storage $ = _getPausableStorage();\n $._paused = true;\n emit Paused(_msgSender());\n }\n\n /**\n * @dev Returns to normal state.\n *\n * Requirements:\n *\n * - The contract must be paused.\n */\n function _unpause() internal virtual whenPaused {\n PausableStorage storage $ = _getPausableStorage();\n $._paused = false;\n emit Unpaused(_msgSender());\n }\n}\n"},"node_modules/@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/ERC165.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC165} from \"@openzeppelin/contracts/utils/introspection/IERC165.sol\";\nimport {Initializable} from \"../../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC-165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n */\nabstract contract ERC165Upgradeable is Initializable, IERC165 {\n function __ERC165_init() internal onlyInitializing {\n }\n\n function __ERC165_init_unchained() internal onlyInitializing {\n }\n /**\n * @dev See {IERC165-supportsInterface}.\n */\n function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {\n return interfaceId == type(IERC165).interfaceId;\n }\n}\n"},"node_modules/@openzeppelin/contracts/access/IAccessControl.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (access/IAccessControl.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev External interface of AccessControl declared to support ERC-165 detection.\n */\ninterface IAccessControl {\n /**\n * @dev The `account` is missing a role.\n */\n error AccessControlUnauthorizedAccount(address account, bytes32 neededRole);\n\n /**\n * @dev The caller of a function is not the expected one.\n *\n * NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.\n */\n error AccessControlBadConfirmation();\n\n /**\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\n *\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\n * {RoleAdminChanged} not being emitted signaling this.\n */\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\n\n /**\n * @dev Emitted when `account` is granted `role`.\n *\n * `sender` is the account that originated the contract call. This account bears the admin role (for the granted role).\n * Expected in cases where the role was granted using the internal {AccessControl-_grantRole}.\n */\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\n\n /**\n * @dev Emitted when `account` is revoked `role`.\n *\n * `sender` is the account that originated the contract call:\n * - if using `revokeRole`, it is the admin role bearer\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\n */\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\n\n /**\n * @dev Returns `true` if `account` has been granted `role`.\n */\n function hasRole(bytes32 role, address account) external view returns (bool);\n\n /**\n * @dev Returns the admin role that controls `role`. See {grantRole} and\n * {revokeRole}.\n *\n * To change a role's admin, use {AccessControl-_setRoleAdmin}.\n */\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\n\n /**\n * @dev Grants `role` to `account`.\n *\n * If `account` had not been already granted `role`, emits a {RoleGranted}\n * event.\n *\n * Requirements:\n *\n * - the caller must have ``role``'s admin role.\n */\n function grantRole(bytes32 role, address account) external;\n\n /**\n * @dev Revokes `role` from `account`.\n *\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\n *\n * Requirements:\n *\n * - the caller must have ``role``'s admin role.\n */\n function revokeRole(bytes32 role, address account) external;\n\n /**\n * @dev Revokes `role` from the calling account.\n *\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\n * purpose is to provide a mechanism for accounts to lose their privileges\n * if they are compromised (such as when a trusted device is misplaced).\n *\n * If the calling account had been granted `role`, emits a {RoleRevoked}\n * event.\n *\n * Requirements:\n *\n * - the caller must be `callerConfirmation`.\n */\n function renounceRole(bytes32 role, address callerConfirmation) external;\n}\n"},"node_modules/@openzeppelin/contracts/interfaces/IERC1271.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC1271.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC-1271 standard signature validation method for\n * contracts as defined in https://eips.ethereum.org/EIPS/eip-1271[ERC-1271].\n */\ninterface IERC1271 {\n /**\n * @dev Should return whether the signature provided is valid for the provided data\n * @param hash Hash of the data to be signed\n * @param signature Signature byte array associated with _data\n */\n function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue);\n}\n"},"node_modules/@openzeppelin/contracts/interfaces/IERC1967.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC1967.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev ERC-1967: Proxy Storage Slots. This interface contains the events defined in the ERC.\n */\ninterface IERC1967 {\n /**\n * @dev Emitted when the implementation is upgraded.\n */\n event Upgraded(address indexed implementation);\n\n /**\n * @dev Emitted when the admin account has changed.\n */\n event AdminChanged(address previousAdmin, address newAdmin);\n\n /**\n * @dev Emitted when the beacon is changed.\n */\n event BeaconUpgraded(address indexed beacon);\n}\n"},"node_modules/@openzeppelin/contracts/interfaces/draft-IERC1822.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/draft-IERC1822.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev ERC-1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified\n * proxy whose upgrades are fully controlled by the current implementation.\n */\ninterface IERC1822Proxiable {\n /**\n * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation\n * address.\n *\n * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\n * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\n * function revert if invoked through a proxy.\n */\n function proxiableUUID() external view returns (bytes32);\n}\n"},"node_modules/@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (proxy/ERC1967/ERC1967Utils.sol)\n\npragma solidity ^0.8.21;\n\nimport {IBeacon} from \"../beacon/IBeacon.sol\";\nimport {IERC1967} from \"../../interfaces/IERC1967.sol\";\nimport {Address} from \"../../utils/Address.sol\";\nimport {StorageSlot} from \"../../utils/StorageSlot.sol\";\n\n/**\n * @dev This library provides getters and event emitting update functions for\n * https://eips.ethereum.org/EIPS/eip-1967[ERC-1967] slots.\n */\nlibrary ERC1967Utils {\n /**\n * @dev Storage slot with the address of the current implementation.\n * This is the keccak-256 hash of \"eip1967.proxy.implementation\" subtracted by 1.\n */\n // solhint-disable-next-line private-vars-leading-underscore\n bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n\n /**\n * @dev The `implementation` of the proxy is invalid.\n */\n error ERC1967InvalidImplementation(address implementation);\n\n /**\n * @dev The `admin` of the proxy is invalid.\n */\n error ERC1967InvalidAdmin(address admin);\n\n /**\n * @dev The `beacon` of the proxy is invalid.\n */\n error ERC1967InvalidBeacon(address beacon);\n\n /**\n * @dev An upgrade function sees `msg.value > 0` that may be lost.\n */\n error ERC1967NonPayable();\n\n /**\n * @dev Returns the current implementation address.\n */\n function getImplementation() internal view returns (address) {\n return StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value;\n }\n\n /**\n * @dev Stores a new address in the ERC-1967 implementation slot.\n */\n function _setImplementation(address newImplementation) private {\n if (newImplementation.code.length == 0) {\n revert ERC1967InvalidImplementation(newImplementation);\n }\n StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value = newImplementation;\n }\n\n /**\n * @dev Performs implementation upgrade with additional setup call if data is nonempty.\n * This function is payable only if the setup call is performed, otherwise `msg.value` is rejected\n * to avoid stuck value in the contract.\n *\n * Emits an {IERC1967-Upgraded} event.\n */\n function upgradeToAndCall(address newImplementation, bytes memory data) internal {\n _setImplementation(newImplementation);\n emit IERC1967.Upgraded(newImplementation);\n\n if (data.length > 0) {\n Address.functionDelegateCall(newImplementation, data);\n } else {\n _checkNonPayable();\n }\n }\n\n /**\n * @dev Storage slot with the admin of the contract.\n * This is the keccak-256 hash of \"eip1967.proxy.admin\" subtracted by 1.\n */\n // solhint-disable-next-line private-vars-leading-underscore\n bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\n\n /**\n * @dev Returns the current admin.\n *\n * TIP: To get this value clients can read directly from the storage slot shown below (specified by ERC-1967) using\n * the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.\n * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`\n */\n function getAdmin() internal view returns (address) {\n return StorageSlot.getAddressSlot(ADMIN_SLOT).value;\n }\n\n /**\n * @dev Stores a new address in the ERC-1967 admin slot.\n */\n function _setAdmin(address newAdmin) private {\n if (newAdmin == address(0)) {\n revert ERC1967InvalidAdmin(address(0));\n }\n StorageSlot.getAddressSlot(ADMIN_SLOT).value = newAdmin;\n }\n\n /**\n * @dev Changes the admin of the proxy.\n *\n * Emits an {IERC1967-AdminChanged} event.\n */\n function changeAdmin(address newAdmin) internal {\n emit IERC1967.AdminChanged(getAdmin(), newAdmin);\n _setAdmin(newAdmin);\n }\n\n /**\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\n * This is the keccak-256 hash of \"eip1967.proxy.beacon\" subtracted by 1.\n */\n // solhint-disable-next-line private-vars-leading-underscore\n bytes32 internal constant BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\n\n /**\n * @dev Returns the current beacon.\n */\n function getBeacon() internal view returns (address) {\n return StorageSlot.getAddressSlot(BEACON_SLOT).value;\n }\n\n /**\n * @dev Stores a new beacon in the ERC-1967 beacon slot.\n */\n function _setBeacon(address newBeacon) private {\n if (newBeacon.code.length == 0) {\n revert ERC1967InvalidBeacon(newBeacon);\n }\n\n StorageSlot.getAddressSlot(BEACON_SLOT).value = newBeacon;\n\n address beaconImplementation = IBeacon(newBeacon).implementation();\n if (beaconImplementation.code.length == 0) {\n revert ERC1967InvalidImplementation(beaconImplementation);\n }\n }\n\n /**\n * @dev Change the beacon and trigger a setup call if data is nonempty.\n * This function is payable only if the setup call is performed, otherwise `msg.value` is rejected\n * to avoid stuck value in the contract.\n *\n * Emits an {IERC1967-BeaconUpgraded} event.\n *\n * CAUTION: Invoking this function has no effect on an instance of {BeaconProxy} since v5, since\n * it uses an immutable beacon without looking at the value of the ERC-1967 beacon slot for\n * efficiency.\n */\n function upgradeBeaconToAndCall(address newBeacon, bytes memory data) internal {\n _setBeacon(newBeacon);\n emit IERC1967.BeaconUpgraded(newBeacon);\n\n if (data.length > 0) {\n Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);\n } else {\n _checkNonPayable();\n }\n }\n\n /**\n * @dev Reverts if `msg.value` is not zero. It can be used to avoid `msg.value` stuck in the contract\n * if an upgrade doesn't perform an initialization call.\n */\n function _checkNonPayable() private {\n if (msg.value > 0) {\n revert ERC1967NonPayable();\n }\n }\n}\n"},"node_modules/@openzeppelin/contracts/proxy/beacon/IBeacon.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (proxy/beacon/IBeacon.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\n */\ninterface IBeacon {\n /**\n * @dev Must return an address that can be used as a delegate call target.\n *\n * {UpgradeableBeacon} will check that this address is a contract.\n */\n function implementation() external view returns (address);\n}\n"},"node_modules/@openzeppelin/contracts/utils/Address.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Address.sol)\n\npragma solidity ^0.8.20;\n\nimport {Errors} from \"./Errors.sol\";\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n /**\n * @dev There's no code at `target` (it is not a contract).\n */\n error AddressEmptyCode(address target);\n\n /**\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n * `recipient`, forwarding all available gas and reverting on errors.\n *\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\n * imposed by `transfer`, making them unable to receive funds via\n * `transfer`. {sendValue} removes this limitation.\n *\n * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n *\n * IMPORTANT: because control is transferred to `recipient`, care must be\n * taken to not create reentrancy vulnerabilities. Consider using\n * {ReentrancyGuard} or the\n * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n */\n function sendValue(address payable recipient, uint256 amount) internal {\n if (address(this).balance < amount) {\n revert Errors.InsufficientBalance(address(this).balance, amount);\n }\n\n (bool success, ) = recipient.call{value: amount}(\"\");\n if (!success) {\n revert Errors.FailedCall();\n }\n }\n\n /**\n * @dev Performs a Solidity function call using a low level `call`. A\n * plain `call` is an unsafe replacement for a function call: use this\n * function instead.\n *\n * If `target` reverts with a revert reason or custom error, it is bubbled\n * up by this function (like regular Solidity function calls). However, if\n * the call reverted with no returned reason, this function reverts with a\n * {Errors.FailedCall} error.\n *\n * Returns the raw returned data. To convert to the expected return value,\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n *\n * Requirements:\n *\n * - `target` must be a contract.\n * - calling `target` with `data` must not revert.\n */\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but also transferring `value` wei to `target`.\n *\n * Requirements:\n *\n * - the calling contract must have an ETH balance of at least `value`.\n * - the called Solidity function must be `payable`.\n */\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n if (address(this).balance < value) {\n revert Errors.InsufficientBalance(address(this).balance, value);\n }\n (bool success, bytes memory returndata) = target.call{value: value}(data);\n return verifyCallResultFromTarget(target, success, returndata);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a static call.\n */\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n (bool success, bytes memory returndata) = target.staticcall(data);\n return verifyCallResultFromTarget(target, success, returndata);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a delegate call.\n */\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n (bool success, bytes memory returndata) = target.delegatecall(data);\n return verifyCallResultFromTarget(target, success, returndata);\n }\n\n /**\n * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target\n * was not a contract or bubbling up the revert reason (falling back to {Errors.FailedCall}) in case\n * of an unsuccessful call.\n */\n function verifyCallResultFromTarget(\n address target,\n bool success,\n bytes memory returndata\n ) internal view returns (bytes memory) {\n if (!success) {\n _revert(returndata);\n } else {\n // only check if target is a contract if the call was successful and the return data is empty\n // otherwise we already know that it was a contract\n if (returndata.length == 0 && target.code.length == 0) {\n revert AddressEmptyCode(target);\n }\n return returndata;\n }\n }\n\n /**\n * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the\n * revert reason or with a default {Errors.FailedCall} error.\n */\n function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {\n if (!success) {\n _revert(returndata);\n } else {\n return returndata;\n }\n }\n\n /**\n * @dev Reverts with returndata if present. Otherwise reverts with {Errors.FailedCall}.\n */\n function _revert(bytes memory returndata) private pure {\n // Look for revert reason and bubble it up if present\n if (returndata.length > 0) {\n // The easiest way to bubble the revert reason is using memory via assembly\n assembly (\"memory-safe\") {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert Errors.FailedCall();\n }\n }\n}\n"},"node_modules/@openzeppelin/contracts/utils/Errors.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Errors.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Collection of common custom errors used in multiple contracts\n *\n * IMPORTANT: Backwards compatibility is not guaranteed in future versions of the library.\n * It is recommended to avoid relying on the error API for critical functionality.\n *\n * _Available since v5.1._\n */\nlibrary Errors {\n /**\n * @dev The ETH balance of the account is not enough to perform the operation.\n */\n error InsufficientBalance(uint256 balance, uint256 needed);\n\n /**\n * @dev A call to an address target failed. The target may have reverted.\n */\n error FailedCall();\n\n /**\n * @dev The deployment failed.\n */\n error FailedDeployment();\n\n /**\n * @dev A necessary precompile is missing.\n */\n error MissingPrecompile(address);\n}\n"},"node_modules/@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"},"node_modules/@openzeppelin/contracts/utils/StorageSlot.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/StorageSlot.sol)\n// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Library for reading and writing primitive types to specific storage slots.\n *\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\n * This library helps with reading and writing to such slots without the need for inline assembly.\n *\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\n *\n * Example usage to set ERC-1967 implementation slot:\n * ```solidity\n * contract ERC1967 {\n * // Define the slot. Alternatively, use the SlotDerivation library to derive the slot.\n * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n *\n * function _getImplementation() internal view returns (address) {\n * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n * }\n *\n * function _setImplementation(address newImplementation) internal {\n * require(newImplementation.code.length > 0);\n * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n * }\n * }\n * ```\n *\n * TIP: Consider using this library along with {SlotDerivation}.\n */\nlibrary StorageSlot {\n struct AddressSlot {\n address value;\n }\n\n struct BooleanSlot {\n bool value;\n }\n\n struct Bytes32Slot {\n bytes32 value;\n }\n\n struct Uint256Slot {\n uint256 value;\n }\n\n struct Int256Slot {\n int256 value;\n }\n\n struct StringSlot {\n string value;\n }\n\n struct BytesSlot {\n bytes value;\n }\n\n /**\n * @dev Returns an `AddressSlot` with member `value` located at `slot`.\n */\n function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\n assembly (\"memory-safe\") {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns a `BooleanSlot` with member `value` located at `slot`.\n */\n function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\n assembly (\"memory-safe\") {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns a `Bytes32Slot` with member `value` located at `slot`.\n */\n function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\n assembly (\"memory-safe\") {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns a `Uint256Slot` with member `value` located at `slot`.\n */\n function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\n assembly (\"memory-safe\") {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns a `Int256Slot` with member `value` located at `slot`.\n */\n function getInt256Slot(bytes32 slot) internal pure returns (Int256Slot storage r) {\n assembly (\"memory-safe\") {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns a `StringSlot` with member `value` located at `slot`.\n */\n function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {\n assembly (\"memory-safe\") {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `StringSlot` representation of the string storage pointer `store`.\n */\n function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {\n assembly (\"memory-safe\") {\n r.slot := store.slot\n }\n }\n\n /**\n * @dev Returns a `BytesSlot` with member `value` located at `slot`.\n */\n function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {\n assembly (\"memory-safe\") {\n r.slot := slot\n }\n }\n\n /**\n * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.\n */\n function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {\n assembly (\"memory-safe\") {\n r.slot := store.slot\n }\n }\n}\n"},"node_modules/@openzeppelin/contracts/utils/Strings.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Strings.sol)\n\npragma solidity ^0.8.20;\n\nimport {Math} from \"./math/Math.sol\";\nimport {SignedMath} from \"./math/SignedMath.sol\";\n\n/**\n * @dev String operations.\n */\nlibrary Strings {\n bytes16 private constant HEX_DIGITS = \"0123456789abcdef\";\n uint8 private constant ADDRESS_LENGTH = 20;\n\n /**\n * @dev The `value` string doesn't fit in the specified `length`.\n */\n error StringsInsufficientHexLength(uint256 value, uint256 length);\n\n /**\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n */\n function toString(uint256 value) internal pure returns (string memory) {\n unchecked {\n uint256 length = Math.log10(value) + 1;\n string memory buffer = new string(length);\n uint256 ptr;\n assembly (\"memory-safe\") {\n ptr := add(buffer, add(32, length))\n }\n while (true) {\n ptr--;\n assembly (\"memory-safe\") {\n mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))\n }\n value /= 10;\n if (value == 0) break;\n }\n return buffer;\n }\n }\n\n /**\n * @dev Converts a `int256` to its ASCII `string` decimal representation.\n */\n function toStringSigned(int256 value) internal pure returns (string memory) {\n return string.concat(value < 0 ? \"-\" : \"\", toString(SignedMath.abs(value)));\n }\n\n /**\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n */\n function toHexString(uint256 value) internal pure returns (string memory) {\n unchecked {\n return toHexString(value, Math.log256(value) + 1);\n }\n }\n\n /**\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n */\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n uint256 localValue = value;\n bytes memory buffer = new bytes(2 * length + 2);\n buffer[0] = \"0\";\n buffer[1] = \"x\";\n for (uint256 i = 2 * length + 1; i > 1; --i) {\n buffer[i] = HEX_DIGITS[localValue & 0xf];\n localValue >>= 4;\n }\n if (localValue != 0) {\n revert StringsInsufficientHexLength(value, length);\n }\n return string(buffer);\n }\n\n /**\n * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal\n * representation.\n */\n function toHexString(address addr) internal pure returns (string memory) {\n return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);\n }\n\n /**\n * @dev Converts an `address` with fixed length of 20 bytes to its checksummed ASCII `string` hexadecimal\n * representation, according to EIP-55.\n */\n function toChecksumHexString(address addr) internal pure returns (string memory) {\n bytes memory buffer = bytes(toHexString(addr));\n\n // hash the hex part of buffer (skip length + 2 bytes, length 40)\n uint256 hashValue;\n assembly (\"memory-safe\") {\n hashValue := shr(96, keccak256(add(buffer, 0x22), 40))\n }\n\n for (uint256 i = 41; i > 1; --i) {\n // possible values for buffer[i] are 48 (0) to 57 (9) and 97 (a) to 102 (f)\n if (hashValue & 0xf > 7 && uint8(buffer[i]) > 96) {\n // case shift by xoring with 0x20\n buffer[i] ^= 0x20;\n }\n hashValue >>= 4;\n }\n return string(buffer);\n }\n\n /**\n * @dev Returns true if the two strings are equal.\n */\n function equal(string memory a, string memory b) internal pure returns (bool) {\n return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));\n }\n}\n"},"node_modules/@openzeppelin/contracts/utils/cryptography/ECDSA.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/cryptography/ECDSA.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\n *\n * These functions can be used to verify that a message was signed by the holder\n * of the private keys of a given address.\n */\nlibrary ECDSA {\n enum RecoverError {\n NoError,\n InvalidSignature,\n InvalidSignatureLength,\n InvalidSignatureS\n }\n\n /**\n * @dev The signature derives the `address(0)`.\n */\n error ECDSAInvalidSignature();\n\n /**\n * @dev The signature has an invalid length.\n */\n error ECDSAInvalidSignatureLength(uint256 length);\n\n /**\n * @dev The signature has an S value that is in the upper half order.\n */\n error ECDSAInvalidSignatureS(bytes32 s);\n\n /**\n * @dev Returns the address that signed a hashed message (`hash`) with `signature` or an error. This will not\n * return address(0) without also returning an error description. Errors are documented using an enum (error type)\n * and a bytes32 providing additional information about the error.\n *\n * If no error is returned, then the address can be used for verification purposes.\n *\n * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:\n * this function rejects them by requiring the `s` value to be in the lower\n * half order, and the `v` value to be either 27 or 28.\n *\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n * verification to be secure: it is possible to craft signatures that\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n * this is by receiving a hash of the original message (which may otherwise\n * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.\n *\n * Documentation for signature generation:\n * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]\n * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]\n */\n function tryRecover(\n bytes32 hash,\n bytes memory signature\n ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n if (signature.length == 65) {\n bytes32 r;\n bytes32 s;\n uint8 v;\n // ecrecover takes the signature parameters, and the only way to get them\n // currently is to use assembly.\n assembly (\"memory-safe\") {\n r := mload(add(signature, 0x20))\n s := mload(add(signature, 0x40))\n v := byte(0, mload(add(signature, 0x60)))\n }\n return tryRecover(hash, v, r, s);\n } else {\n return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));\n }\n }\n\n /**\n * @dev Returns the address that signed a hashed message (`hash`) with\n * `signature`. This address can then be used for verification purposes.\n *\n * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:\n * this function rejects them by requiring the `s` value to be in the lower\n * half order, and the `v` value to be either 27 or 28.\n *\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n * verification to be secure: it is possible to craft signatures that\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n * this is by receiving a hash of the original message (which may otherwise\n * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.\n */\n function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\n (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);\n _throwError(error, errorArg);\n return recovered;\n }\n\n /**\n * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.\n *\n * See https://eips.ethereum.org/EIPS/eip-2098[ERC-2098 short signatures]\n */\n function tryRecover(\n bytes32 hash,\n bytes32 r,\n bytes32 vs\n ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n unchecked {\n bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);\n // We do not check for an overflow here since the shift operation results in 0 or 1.\n uint8 v = uint8((uint256(vs) >> 255) + 27);\n return tryRecover(hash, v, r, s);\n }\n }\n\n /**\n * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.\n */\n function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {\n (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);\n _throwError(error, errorArg);\n return recovered;\n }\n\n /**\n * @dev Overload of {ECDSA-tryRecover} that receives the `v`,\n * `r` and `s` signature fields separately.\n */\n function tryRecover(\n bytes32 hash,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\n // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\n // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most\n // signatures from current libraries generate a unique signature with an s-value in the lower half order.\n //\n // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\n // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\n // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\n // these malleable signatures as well.\n if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {\n return (address(0), RecoverError.InvalidSignatureS, s);\n }\n\n // If the signature is valid (and not malleable), return the signer address\n address signer = ecrecover(hash, v, r, s);\n if (signer == address(0)) {\n return (address(0), RecoverError.InvalidSignature, bytes32(0));\n }\n\n return (signer, RecoverError.NoError, bytes32(0));\n }\n\n /**\n * @dev Overload of {ECDSA-recover} that receives the `v`,\n * `r` and `s` signature fields separately.\n */\n function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {\n (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s);\n _throwError(error, errorArg);\n return recovered;\n }\n\n /**\n * @dev Optionally reverts with the corresponding custom error according to the `error` argument provided.\n */\n function _throwError(RecoverError error, bytes32 errorArg) private pure {\n if (error == RecoverError.NoError) {\n return; // no error: do nothing\n } else if (error == RecoverError.InvalidSignature) {\n revert ECDSAInvalidSignature();\n } else if (error == RecoverError.InvalidSignatureLength) {\n revert ECDSAInvalidSignatureLength(uint256(errorArg));\n } else if (error == RecoverError.InvalidSignatureS) {\n revert ECDSAInvalidSignatureS(errorArg);\n }\n }\n}\n"},"node_modules/@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/cryptography/MessageHashUtils.sol)\n\npragma solidity ^0.8.20;\n\nimport {Strings} from \"../Strings.sol\";\n\n/**\n * @dev Signature message hash utilities for producing digests to be consumed by {ECDSA} recovery or signing.\n *\n * The library provides methods for generating a hash of a message that conforms to the\n * https://eips.ethereum.org/EIPS/eip-191[ERC-191] and https://eips.ethereum.org/EIPS/eip-712[EIP 712]\n * specifications.\n */\nlibrary MessageHashUtils {\n /**\n * @dev Returns the keccak256 digest of an ERC-191 signed data with version\n * `0x45` (`personal_sign` messages).\n *\n * The digest is calculated by prefixing a bytes32 `messageHash` with\n * `\"\\x19Ethereum Signed Message:\\n32\"` and hashing the result. It corresponds with the\n * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.\n *\n * NOTE: The `messageHash` parameter is intended to be the result of hashing a raw message with\n * keccak256, although any bytes32 value can be safely used because the final digest will\n * be re-hashed.\n *\n * See {ECDSA-recover}.\n */\n function toEthSignedMessageHash(bytes32 messageHash) internal pure returns (bytes32 digest) {\n assembly (\"memory-safe\") {\n mstore(0x00, \"\\x19Ethereum Signed Message:\\n32\") // 32 is the bytes-length of messageHash\n mstore(0x1c, messageHash) // 0x1c (28) is the length of the prefix\n digest := keccak256(0x00, 0x3c) // 0x3c is the length of the prefix (0x1c) + messageHash (0x20)\n }\n }\n\n /**\n * @dev Returns the keccak256 digest of an ERC-191 signed data with version\n * `0x45` (`personal_sign` messages).\n *\n * The digest is calculated by prefixing an arbitrary `message` with\n * `\"\\x19Ethereum Signed Message:\\n\" + len(message)` and hashing the result. It corresponds with the\n * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.\n *\n * See {ECDSA-recover}.\n */\n function toEthSignedMessageHash(bytes memory message) internal pure returns (bytes32) {\n return\n keccak256(bytes.concat(\"\\x19Ethereum Signed Message:\\n\", bytes(Strings.toString(message.length)), message));\n }\n\n /**\n * @dev Returns the keccak256 digest of an ERC-191 signed data with version\n * `0x00` (data with intended validator).\n *\n * The digest is calculated by prefixing an arbitrary `data` with `\"\\x19\\x00\"` and the intended\n * `validator` address. Then hashing the result.\n *\n * See {ECDSA-recover}.\n */\n function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {\n return keccak256(abi.encodePacked(hex\"19_00\", validator, data));\n }\n\n /**\n * @dev Returns the keccak256 digest of an EIP-712 typed data (ERC-191 version `0x01`).\n *\n * The digest is calculated from a `domainSeparator` and a `structHash`, by prefixing them with\n * `\\x19\\x01` and hashing the result. It corresponds to the hash signed by the\n * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] JSON-RPC method as part of EIP-712.\n *\n * See {ECDSA-recover}.\n */\n function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 digest) {\n assembly (\"memory-safe\") {\n let ptr := mload(0x40)\n mstore(ptr, hex\"19_01\")\n mstore(add(ptr, 0x02), domainSeparator)\n mstore(add(ptr, 0x22), structHash)\n digest := keccak256(ptr, 0x42)\n }\n }\n}\n"},"node_modules/@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/cryptography/SignatureChecker.sol)\n\npragma solidity ^0.8.20;\n\nimport {ECDSA} from \"./ECDSA.sol\";\nimport {IERC1271} from \"../../interfaces/IERC1271.sol\";\n\n/**\n * @dev Signature verification helper that can be used instead of `ECDSA.recover` to seamlessly support both ECDSA\n * signatures from externally owned accounts (EOAs) as well as ERC-1271 signatures from smart contract wallets like\n * Argent and Safe Wallet (previously Gnosis Safe).\n */\nlibrary SignatureChecker {\n /**\n * @dev Checks if a signature is valid for a given signer and data hash. If the signer is a smart contract, the\n * signature is validated against that smart contract using ERC-1271, otherwise it's validated using `ECDSA.recover`.\n *\n * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus\n * change through time. It could return true at block N and false at block N+1 (or the opposite).\n */\n function isValidSignatureNow(address signer, bytes32 hash, bytes memory signature) internal view returns (bool) {\n if (signer.code.length == 0) {\n (address recovered, ECDSA.RecoverError err, ) = ECDSA.tryRecover(hash, signature);\n return err == ECDSA.RecoverError.NoError && recovered == signer;\n } else {\n return isValidERC1271SignatureNow(signer, hash, signature);\n }\n }\n\n /**\n * @dev Checks if a signature is valid for a given signer and data hash. The signature is validated\n * against the signer smart contract using ERC-1271.\n *\n * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus\n * change through time. It could return true at block N and false at block N+1 (or the opposite).\n */\n function isValidERC1271SignatureNow(\n address signer,\n bytes32 hash,\n bytes memory signature\n ) internal view returns (bool) {\n (bool success, bytes memory result) = signer.staticcall(\n abi.encodeCall(IERC1271.isValidSignature, (hash, signature))\n );\n return (success &&\n result.length >= 32 &&\n abi.decode(result, (bytes32)) == bytes32(IERC1271.isValidSignature.selector));\n }\n}\n"},"node_modules/@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"},"node_modules/@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²⁵⁶ and mod 2²⁵⁶ - 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²⁵⁶ + 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²⁵⁶. 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²⁵⁶ / 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²⁵⁶. Now that denominator is an odd number, it has an inverse modulo 2²⁵⁶ such\n // that denominator * inv ≡ 1 mod 2²⁵⁶. Compute the inverse by starting with a seed that is correct for\n // four bits. That is, denominator * inv ≡ 1 mod 2⁴.\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⁸\n inverse *= 2 - denominator * inverse; // inverse mod 2¹⁶\n inverse *= 2 - denominator * inverse; // inverse mod 2³²\n inverse *= 2 - denominator * inverse; // inverse mod 2⁶⁴\n inverse *= 2 - denominator * inverse; // inverse mod 2¹²⁸\n inverse *= 2 - denominator * inverse; // inverse mod 2²⁵⁶\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²⁵⁶. Since the preconditions guarantee that the outcome is\n // less than 2²⁵⁶, 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 ≡ 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) ≡ 1 mod p`. As a consequence, we have `a * a**(p-2) ≡ 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² - 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 `ε_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) ≤ sqrt(a) < 2**e`). We know that `e ≤ 128` because `(2¹²⁸)² = 2²⁵⁶` is\n // bigger than any uint256.\n //\n // By noticing that\n // `2**(e-1) ≤ sqrt(a) < 2**e → (2**(e-1))² ≤ a < (2**e)² → 2**(2*e-2) ≤ 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) ≤ sqrt(a) < 2**e = 2 * x_n`. This implies ε_n ≤ 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 ε_n ≤ 2**(e-2).\n // This is going to be our x_0 (and ε_0)\n xn = (3 * xn) >> 1; // ε_0 := | x_0 - sqrt(a) | ≤ 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}² - a = ((x_n + a / x_n) / 2)² - a\n // = ((x_n² + a) / (2 * x_n))² - a\n // = (x_n⁴ + 2 * a * x_n² + a²) / (4 * x_n²) - a\n // = (x_n⁴ + 2 * a * x_n² + a² - 4 * a * x_n²) / (4 * x_n²)\n // = (x_n⁴ - 2 * a * x_n² + a²) / (4 * x_n²)\n // = (x_n² - a)² / (2 * x_n)²\n // = ((x_n² - a) / (2 * x_n))²\n // ≥ 0\n // Which proves that for all n ≥ 1, sqrt(a) ≤ x_n\n //\n // This gives us the proof of quadratic convergence of the sequence:\n // ε_{n+1} = | x_{n+1} - sqrt(a) |\n // = | (x_n + a / x_n) / 2 - sqrt(a) |\n // = | (x_n² + a - 2*x_n*sqrt(a)) / (2 * x_n) |\n // = | (x_n - sqrt(a))² / (2 * x_n) |\n // = | ε_n² / (2 * x_n) |\n // = ε_n² / | (2 * x_n) |\n //\n // For the first iteration, we have a special case where x_0 is known:\n // ε_1 = ε_0² / | (2 * x_0) |\n // ≤ (2**(e-2))² / (2 * (2**(e-1) + 2**(e-2)))\n // ≤ 2**(2*e-4) / (3 * 2**(e-1))\n // ≤ 2**(e-3) / 3\n // ≤ 2**(e-3-log2(3))\n // ≤ 2**(e-4.5)\n //\n // For the following iterations, we use the fact that, 2**(e-1) ≤ sqrt(a) ≤ x_n:\n // ε_{n+1} = ε_n² / | (2 * x_n) |\n // ≤ (2**(e-k))² / (2 * 2**(e-1))\n // ≤ 2**(2*e-2*k) / 2**e\n // ≤ 2**(e-2*k)\n xn = (xn + a / xn) >> 1; // ε_1 := | x_1 - sqrt(a) | ≤ 2**(e-4.5) -- special case, see above\n xn = (xn + a / xn) >> 1; // ε_2 := | x_2 - sqrt(a) | ≤ 2**(e-9) -- general case with k = 4.5\n xn = (xn + a / xn) >> 1; // ε_3 := | x_3 - sqrt(a) | ≤ 2**(e-18) -- general case with k = 9\n xn = (xn + a / xn) >> 1; // ε_4 := | x_4 - sqrt(a) | ≤ 2**(e-36) -- general case with k = 18\n xn = (xn + a / xn) >> 1; // ε_5 := | x_5 - sqrt(a) | ≤ 2**(e-72) -- general case with k = 36\n xn = (xn + a / xn) >> 1; // ε_6 := | x_6 - sqrt(a) | ≤ 2**(e-144) -- general case with k = 72\n\n // Because e ≤ 128 (as discussed during the first estimation phase), we know have reached a precision\n // ε_6 ≤ 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"},"node_modules/@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"},"node_modules/@openzeppelin/contracts/utils/math/SignedMath.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SignedMath.sol)\n\npragma solidity ^0.8.20;\n\nimport {SafeCast} from \"./SafeCast.sol\";\n\n/**\n * @dev Standard signed math utilities missing in the Solidity language.\n */\nlibrary SignedMath {\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, int256 a, int256 b) internal pure returns (int256) {\n unchecked {\n // branchless ternary works because:\n // b ^ (a ^ b) == a\n // b ^ 0 == b\n return b ^ ((a ^ b) * int256(SafeCast.toUint(condition)));\n }\n }\n\n /**\n * @dev Returns the largest of two signed numbers.\n */\n function max(int256 a, int256 b) internal pure returns (int256) {\n return ternary(a > b, a, b);\n }\n\n /**\n * @dev Returns the smallest of two signed numbers.\n */\n function min(int256 a, int256 b) internal pure returns (int256) {\n return ternary(a < b, a, b);\n }\n\n /**\n * @dev Returns the average of two signed numbers without overflow.\n * The result is rounded towards zero.\n */\n function average(int256 a, int256 b) internal pure returns (int256) {\n // Formula from the book \"Hacker's Delight\"\n int256 x = (a & b) + ((a ^ b) >> 1);\n return x + (int256(uint256(x) >> 255) & (a ^ b));\n }\n\n /**\n * @dev Returns the absolute unsigned value of a signed value.\n */\n function abs(int256 n) internal pure returns (uint256) {\n unchecked {\n // Formula from the \"Bit Twiddling Hacks\" by Sean Eron Anderson.\n // Since `n` is a signed integer, the generated bytecode will use the SAR opcode to perform the right shift,\n // taking advantage of the most significant (or \"sign\" bit) in two's complement representation.\n // This opcode adds new most significant bits set to the value of the previous most significant bit. As a result,\n // the mask will either be `bytes32(0)` (if n is positive) or `~bytes32(0)` (if n is negative).\n int256 mask = n >> 255;\n\n // A `bytes32(0)` mask leaves the input unchanged, while a `~bytes32(0)` mask complements it.\n return uint256((n + mask) ^ mask);\n }\n }\n}\n"},"src/base/EIP2612.sol":{"content":"/**\n * SPDX-License-Identifier: Apache-2.0\n *\n * Copyright (c) 2023, Circle Internet Financial, LLC.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n * ---------------------------------------------------------------------\n *\n * Adapted and modified by Berachain for greater flexibility and reusability\n */\npragma solidity 0.8.26;\n\nimport { ERC20 } from \"solady/src/tokens/ERC20.sol\";\nimport { SignatureChecker } from \"@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol\";\nimport { MessageHashUtils } from \"@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol\";\n\n/**\n * @title EIP-2612\n * @notice Provide implementation for gas-abstracted approvals with smart account support\n * @dev Extends ERC20 to use its EIP712 logic and EIP2612 nonce management.\n */\nabstract contract EIP2612 is ERC20 {\n // keccak256(\"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\")\n bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;\n\n /**\n * @notice Verify a signed approval permit and execute if valid\n * @dev Overrides Solady's permit to support smart account (EIP-1271) signatures.\n * @param owner Token owner's address (Authorizer)\n * @param spender Spender's address\n * @param value Amount of allowance\n * @param deadline The time at which the signature expires (unix time), or max uint256 value to signal no\n * expiration\n * @param v v of the signature\n * @param r r of the signature\n * @param s s of the signature\n */\n function permit(\n address owner,\n address spender,\n uint256 value,\n uint256 deadline,\n uint8 v,\n bytes32 r,\n bytes32 s\n )\n public\n virtual\n override\n {\n _permit(owner, spender, value, deadline, abi.encodePacked(r, s, v));\n }\n\n /**\n * @notice Verify a signed approval permit and execute if valid (bytes signature version)\n * @dev EOA wallet signatures should be packed in the order of r, s, v.\n * @param owner Token owner's address (Authorizer)\n * @param spender Spender's address\n * @param value Amount of allowance\n * @param deadline The time at which the signature expires (unix time), or max uint256 value to signal no\n * expiration\n * @param signature Signature byte array signed by an EOA wallet or a contract wallet\n */\n function permit(\n address owner,\n address spender,\n uint256 value,\n uint256 deadline,\n bytes memory signature\n )\n public\n virtual\n {\n _permit(owner, spender, value, deadline, signature);\n }\n\n /**\n * @notice Internal permit implementation with bytes signature\n * @param owner Token owner's address (Authorizer)\n * @param spender Spender's address\n * @param value Amount of allowance\n * @param deadline The time at which the signature expires (unix time), or max uint256 value to signal no\n * expiration\n * @param signature Signature byte array signed by an EOA wallet or a contract wallet\n */\n function _permit(\n address owner,\n address spender,\n uint256 value,\n uint256 deadline,\n bytes memory signature\n )\n internal\n {\n if (deadline < block.timestamp) {\n revert PermitExpired();\n }\n\n bytes32 typedDataHash = MessageHashUtils.toTypedDataHash(\n DOMAIN_SEPARATOR(), keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonces(owner), deadline))\n );\n _incrementNonce(owner);\n if (!SignatureChecker.isValidSignatureNow(owner, typedDataHash, signature)) {\n revert InvalidPermit();\n }\n\n _approve(owner, spender, value);\n }\n}\n"},"src/base/EIP3009.sol":{"content":"/**\n * SPDX-License-Identifier: Apache-2.0\n *\n * Copyright (c) 2023, Circle Internet Financial, LLC.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n * ---------------------------------------------------------------------\n *\n * Adapted by Berachain for greater flexibility and reusability\n */\npragma solidity 0.8.26;\n\nimport { ERC20 } from \"solady/src/tokens/ERC20.sol\";\nimport { SignatureChecker } from \"@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol\";\nimport { MessageHashUtils } from \"@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol\";\n\n/**\n * @title EIP-3009\n * @notice Provide implementation for gas-abstracted transfers\n * @dev Contracts that inherit from this should override these\n * functions by adding appropriate modifiers where necessary.\n */\nabstract contract EIP3009 is ERC20 {\n /// @custom:storage-location erc7201:berachain.storage.EIP3009\n struct EIP3009Storage {\n mapping(address authorizer => mapping(bytes32 nonce => bool used)) _authorizationStates;\n }\n\n // keccak256(abi.encode(uint256(keccak256(\"berachain.storage.EIP3009\")) - 1)) & ~bytes32(uint256(0xff))\n bytes32 private constant EIP3009StorageLocation =\n 0xfbda9a20cf04639da2e56edbca47d40f931e601dac0a5ca2778816e5742b9200;\n\n bytes32 public constant TRANSFER_WITH_AUTHORIZATION_TYPEHASH = keccak256(\n \"TransferWithAuthorization(address from,address to,uint256 value,uint256 validAfter,uint256 validBefore,bytes32 nonce)\"\n );\n\n bytes32 public constant RECEIVE_WITH_AUTHORIZATION_TYPEHASH = keccak256(\n \"ReceiveWithAuthorization(address from,address to,uint256 value,uint256 validAfter,uint256 validBefore,bytes32 nonce)\"\n );\n\n bytes32 public constant CANCEL_AUTHORIZATION_TYPEHASH =\n keccak256(\"CancelAuthorization(address authorizer,bytes32 nonce)\");\n\n event AuthorizationUsed(address indexed authorizer, bytes32 indexed nonce);\n event AuthorizationCanceled(address indexed authorizer, bytes32 indexed nonce);\n\n function _getEIP3009Storage() private pure returns (EIP3009Storage storage $) {\n assembly {\n $.slot := EIP3009StorageLocation\n }\n }\n\n /**\n * @notice Returns the state of an authorization\n * @dev Nonces are randomly generated 32-byte data unique to the\n * authorizer's address\n * @param authorizer Authorizer's address\n * @param nonce Nonce of the authorization\n * @return True if the nonce is used\n */\n function authorizationState(address authorizer, bytes32 nonce) external view returns (bool) {\n EIP3009Storage storage $ = _getEIP3009Storage();\n return $._authorizationStates[authorizer][nonce];\n }\n\n /**\n * @notice Execute a transfer with a signed authorization\n * @dev Override this function in derived contracts to add custom validation.\n * @param from Payer's address (Authorizer)\n * @param to Payee's address\n * @param value 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 Unique nonce\n * @param v v of the signature\n * @param r r of the signature\n * @param s s of the signature\n */\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 public\n virtual\n {\n _transferWithAuthorization(from, to, value, validAfter, validBefore, nonce, abi.encodePacked(r, s, v));\n }\n\n /**\n * @notice Execute a transfer with a signed authorization\n * @dev Override this function in derived contracts to add custom validation.\n * @dev EOA wallet signatures should be packed in the order of r, s, v.\n * @param from Payer's address (Authorizer)\n * @param to Payee's address\n * @param value 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 Unique nonce\n * @param signature Signature bytes signed by an EOA wallet or a contract wallet\n */\n function transferWithAuthorization(\n address from,\n address to,\n uint256 value,\n uint256 validAfter,\n uint256 validBefore,\n bytes32 nonce,\n bytes memory signature\n )\n public\n virtual\n {\n _transferWithAuthorization(from, to, value, validAfter, validBefore, nonce, signature);\n }\n\n /**\n * @notice Receive a transfer with a signed authorization from the payer\n * @dev Override this function in derived contracts to add custom validation.\n * @dev This has an additional check to ensure that the payee's address\n * matches the caller of this function to prevent front-running attacks.\n * @param from Payer's address (Authorizer)\n * @param to Payee's address\n * @param value 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 Unique nonce\n * @param v v of the signature\n * @param r r of the signature\n * @param s s of the signature\n */\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 public\n virtual\n {\n _receiveWithAuthorization(from, to, value, validAfter, validBefore, nonce, abi.encodePacked(r, s, v));\n }\n\n /**\n * @notice Receive a transfer with a signed authorization from the payer\n * @dev Override this function in derived contracts to add custom validation.\n * @dev This has an additional check to ensure that the payee's address\n * matches the caller of this function to prevent front-running attacks.\n * EOA wallet signatures should be packed in the order of r, s, v.\n * @param from Payer's address (Authorizer)\n * @param to Payee's address\n * @param value 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 Unique nonce\n * @param signature Signature bytes signed by an EOA wallet or a contract wallet\n */\n function receiveWithAuthorization(\n address from,\n address to,\n uint256 value,\n uint256 validAfter,\n uint256 validBefore,\n bytes32 nonce,\n bytes memory signature\n )\n public\n virtual\n {\n _receiveWithAuthorization(from, to, value, validAfter, validBefore, nonce, signature);\n }\n\n /**\n * @notice Attempt to cancel an authorization\n * @dev Override this function in derived contracts to add custom validation.\n * @param authorizer Authorizer's address\n * @param nonce Nonce of the authorization\n * @param v v of the signature\n * @param r r of the signature\n * @param s s of the signature\n */\n function cancelAuthorization(address authorizer, bytes32 nonce, uint8 v, bytes32 r, bytes32 s) public virtual {\n _cancelAuthorization(authorizer, nonce, abi.encodePacked(r, s, v));\n }\n\n /**\n * @notice Attempt to cancel an authorization\n * @dev Override this function in derived contracts to add custom validation.\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 signature Signature bytes signed by an EOA wallet or a contract wallet\n */\n function cancelAuthorization(address authorizer, bytes32 nonce, bytes memory signature) public virtual {\n _cancelAuthorization(authorizer, nonce, signature);\n }\n\n /**\n * @notice Execute a transfer with a signed authorization\n * @param from Payer's address (Authorizer)\n * @param to Payee's address\n * @param value 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 Unique nonce\n * @param signature signature in bytes\n */\n function _transferWithAuthorization(\n address from,\n address to,\n uint256 value,\n uint256 validAfter,\n uint256 validBefore,\n bytes32 nonce,\n bytes memory signature\n )\n internal\n {\n _requireValidAuthorization(from, nonce, validAfter, validBefore);\n _requireValidSignature(\n from,\n keccak256(\n abi.encode(TRANSFER_WITH_AUTHORIZATION_TYPEHASH, from, to, value, validAfter, validBefore, nonce)\n ),\n signature\n );\n\n _markAuthorizationAsUsed(from, nonce);\n _transfer(from, to, value);\n }\n\n /**\n * @notice Receive a transfer with a signed authorization from the payer\n * @dev This has an additional check to ensure that the payee's address\n * matches the caller of this function to prevent front-running attacks.\n * @param from Payer's address (Authorizer)\n * @param to Payee's address\n * @param value 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 Unique nonce\n * @param signature signature in bytes\n */\n function _receiveWithAuthorization(\n address from,\n address to,\n uint256 value,\n uint256 validAfter,\n uint256 validBefore,\n bytes32 nonce,\n bytes memory signature\n )\n internal\n {\n require(to == msg.sender, \"EIP3009: to != msg.sender\");\n _requireValidAuthorization(from, nonce, validAfter, validBefore);\n _requireValidSignature(\n from,\n keccak256(\n abi.encode(RECEIVE_WITH_AUTHORIZATION_TYPEHASH, from, to, value, validAfter, validBefore, nonce)\n ),\n signature\n );\n\n _markAuthorizationAsUsed(from, nonce);\n _transfer(from, to, value);\n }\n\n function _cancelAuthorization(address authorizer, bytes32 nonce, bytes memory signature) internal {\n _requireUnusedAuthorization(authorizer, nonce);\n _requireValidSignature(\n authorizer, keccak256(abi.encode(CANCEL_AUTHORIZATION_TYPEHASH, authorizer, nonce)), signature\n );\n\n EIP3009Storage storage $ = _getEIP3009Storage();\n $._authorizationStates[authorizer][nonce] = true;\n emit AuthorizationCanceled(authorizer, nonce);\n }\n\n /**\n * @notice Validates that signature against input data struct\n * @param signer Signer's address\n * @param dataHash Hash of encoded data struct\n * @param signature signature in bytes\n */\n function _requireValidSignature(address signer, bytes32 dataHash, bytes memory signature) private view {\n require(\n SignatureChecker.isValidSignatureNow(\n signer, MessageHashUtils.toTypedDataHash(DOMAIN_SEPARATOR(), dataHash), signature\n ),\n \"EIP3009: invalid signature\"\n );\n }\n\n /**\n * @notice Check that an authorization is unused\n * @param authorizer Authorizer's address\n * @param nonce Nonce of the authorization\n */\n function _requireUnusedAuthorization(address authorizer, bytes32 nonce) private view {\n EIP3009Storage storage $ = _getEIP3009Storage();\n require(!$._authorizationStates[authorizer][nonce], \"EIP3009: auth invalid\");\n }\n\n /**\n * @notice Check that authorization is valid\n * @param authorizer Authorizer's address\n * @param nonce Nonce of the authorization\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 */\n function _requireValidAuthorization(\n address authorizer,\n bytes32 nonce,\n uint256 validAfter,\n uint256 validBefore\n )\n private\n view\n {\n require(block.timestamp > validAfter, \"EIP3009: auth early\");\n require(block.timestamp < validBefore, \"EIP3009: auth expired\");\n _requireUnusedAuthorization(authorizer, nonce);\n }\n\n /**\n * @notice Mark an authorization as used\n * @param authorizer Authorizer's address\n * @param nonce Nonce of the authorization\n */\n function _markAuthorizationAsUsed(address authorizer, bytes32 nonce) private {\n EIP3009Storage storage $ = _getEIP3009Storage();\n $._authorizationStates[authorizer][nonce] = true;\n emit AuthorizationUsed(authorizer, nonce);\n }\n}\n"},"src/extras/IPriceOracle.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity ^0.8.26;\n\n/// @title Provide asset prices in USD with WAD precision\n/// @dev Generic interface that wraps the Pyth oracle and redstone price oracle\ninterface IPriceOracle {\n /// @dev TBD whether to also return a confidence interval.\n struct Data {\n // Price with WAD precision\n uint256 price;\n // Unix timestamp describing when the price was published\n uint256 publishTime;\n }\n\n // Signature: 0xd92e233d\n error ZeroAddress();\n error UnavailableData(address asset);\n\n /// @notice Returns the price in USD.\n /// @dev Reverts if the price has not been recently updated (implementation defined).\n /// @param asset The asset of which to fetch the price.\n /// @return data\n function getPrice(address asset) external view returns (Data memory data);\n\n /// @notice Returns the price without any sanity checks.\n /// @dev This function returns the most recent price update in this contract without any recency checks.\n /// This function is unsafe as the returned price update may be arbitrarily far in the past.\n ///\n /// Users of this function should check the `publishTime` to ensure that the returned price is\n /// sufficiently recent for their application. If you are considering using this function, it may be\n /// safer / easier to use either `getPrice` or `getPriceNoOlderThan`.\n /// @return data\n function getPriceUnsafe(address asset) external view returns (Data memory data);\n\n /// @notice Returns the price that is no older than `age` seconds of the current time.\n /// @dev This function is a sanity-checked version of `getPriceUnsafe` which is useful in\n /// applications that require a sufficiently-recent price. Reverts if the price wasn't updated sufficiently\n /// recently.\n /// @return data\n function getPriceNoOlderThan(address asset, uint256 age) external view returns (Data memory data);\n\n /// @notice Returns whether a price is available or not.\n function priceAvailable(address asset) external view returns (bool);\n}\n"},"src/honey/CollateralVault.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity 0.8.26;\n\nimport { PausableUpgradeable } from \"@openzeppelin/contracts-upgradeable/utils/PausableUpgradeable.sol\";\nimport { ERC20 } from \"solady/src/tokens/ERC20.sol\";\nimport { ERC4626 } from \"solady/src/tokens/ERC4626.sol\";\nimport { SafeTransferLib } from \"solady/src/utils/SafeTransferLib.sol\";\n\nimport { Utils } from \"../libraries/Utils.sol\";\nimport { IHoneyErrors } from \"./IHoneyErrors.sol\";\n\n/// @notice This is the ERC4626 vault for the collateral assets to mint Honey.\n/// @author Berachain Team\ncontract CollateralVault is ERC4626, PausableUpgradeable, IHoneyErrors {\n using Utils for bytes4;\n\n event CustodyInfoSet(bool indexed isCustodyVault, address indexed custodyAddress);\n\n ERC20 private _vaultAsset;\n string private _name;\n string private _symbol;\n /// @notice The address of the honey factory that created this vault.\n address public factory;\n\n /// @notice The custody info for the vault.\n CustodyInfo public custodyInfo;\n\n /// @notice The custody info struct.\n /// @param isCustodyVault Whether the vault is a custody vault.\n /// @param custodyAddress The address of the custody. 0 in case of no custody.\n struct CustodyInfo {\n bool isCustodyVault;\n address custodyAddress;\n }\n\n /// @custom:oz-upgrades-unsafe-allow constructor\n constructor() {\n _disableInitializers();\n }\n\n function initialize(address asset_, address _factory) external initializer {\n __CollateralVault_init(asset_, _factory);\n }\n\n function __CollateralVault_init(address asset_, address _factory) internal onlyInitializing {\n __Pausable_init();\n // Check for zero addresses.\n // No need to check for zero asset address,\n // _asset.name(), _asset.symbol() will revert with `EvmError` if asset is zero address.\n if (_factory == address(0)) ZeroAddress.selector.revertWith();\n factory = _factory;\n ERC20 _asset = ERC20(asset_);\n _vaultAsset = _asset;\n _name = string.concat(_asset.name(), \"Vault\");\n _symbol = string.concat(_asset.symbol(), \"Vault\");\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* MODIFIERS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Throws if called by any account other than the factory.\n modifier onlyFactory() {\n _checkFactory();\n _;\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* ADMIN FUNCTIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @notice Pauses the vault.\n /// @dev Only the factory can call this function.\n function pause() external onlyFactory {\n _pause();\n }\n\n /// @notice Unpauses the vault.\n /// @dev Only the factory can call this function.\n function unpause() external onlyFactory {\n _unpause();\n }\n\n /**\n * @dev A wrapper to ERC4626.deposit that only VaultAdmin can call.\n * @dev It is a protection against inflation attacks,\n * @dev in which only VaultAdmin can mint/burn shares.\n * @param assets The assets to deposit into the vault to receive shares.\n * @param receiver The address that will receive the shares.\n * @return shares The shares minted to deposit the assets.\n */\n function deposit(uint256 assets, address receiver) public override onlyFactory whenNotPaused returns (uint256) {\n return super.deposit(assets, receiver);\n }\n\n /**\n * @dev A wrapper to ERC4626.mint that only VaultAdmin can call.\n * @dev It is a protection against inflation attacks,\n * @dev in which only VaultAdmin can mint/burn shares.\n * @param shares The exact shares to mint by depositing the assets.\n * @param receiver The address that will receive the shares.\n * @return assets The assets required to mint the shares.\n */\n function mint(uint256 shares, address receiver) public override onlyFactory whenNotPaused returns (uint256) {\n return super.mint(shares, receiver);\n }\n\n /**\n * @notice Set the custody info for the vault.\n * @dev Only the factory can call this function.\n * @dev To change the custody vault, the factory must first remove the existing custody vault.\n * @param _isCustodyVault Whether the vault is a custody vault.\n * @param _custodyAddress The address of the custody.\n */\n function setCustodyInfo(bool _isCustodyVault, address _custodyAddress) external onlyFactory {\n if (_isCustodyVault && _custodyAddress == address(0)) ZeroAddress.selector.revertWith();\n CustodyInfo memory _custodyInfo = custodyInfo;\n\n // set custody info for new custody vault\n if (_isCustodyVault && _custodyInfo.custodyAddress == address(0)) {\n SafeTransferLib.safeTransfer(asset(), _custodyAddress, ERC20(asset()).balanceOf(address(this)));\n custodyInfo = CustodyInfo(_isCustodyVault, _custodyAddress);\n emit CustodyInfoSet(_isCustodyVault, _custodyAddress);\n return;\n }\n\n // allow to remove custody feature for existing custody vault\n if (!_isCustodyVault && _custodyInfo.custodyAddress == _custodyAddress) {\n SafeTransferLib.safeTransferFrom(\n asset(), _custodyAddress, address(this), ERC20(asset()).balanceOf(_custodyAddress)\n );\n custodyInfo = CustodyInfo(_isCustodyVault, address(0));\n emit CustodyInfoSet(_isCustodyVault, address(0));\n return;\n }\n // revert if any other combination of inputs\n else {\n InvalidCustodyInfoInput.selector.revertWith();\n }\n }\n\n /**\n * @dev A wrapper to ERC4626.withdraw that only VaultAdmin can call.\n * @dev It is a protection against inflation attacks,\n * @dev in which only VaultAdmin can mint/burn shares.\n * @param assets The exact assets to withdraw from the vault.\n * @param receiver The address that will receive the assets.\n * @param owner The address that will burn the shares.\n * @return shares The shares burned to withdraw the assets.\n */\n function withdraw(\n uint256 assets,\n address receiver,\n address owner\n )\n public\n override\n onlyFactory\n whenNotPaused\n returns (uint256)\n {\n return super.withdraw(assets, receiver, owner);\n }\n\n /**\n * @dev A wrapper to ERC4626.redeem that only VaultAdmin can call.\n * @dev It is a protection against inflation attacks,\n * @dev in which only VaultAdmin can mint/burn shares.\n * @param shares The shares to redeem for the assets.\n * @param receiver The address that will receive the assets.\n * @param owner The address that will burn the shares.\n * @return assets The assets redeemed from the vault.\n */\n function redeem(\n uint256 shares,\n address receiver,\n address owner\n )\n public\n override\n onlyFactory\n whenNotPaused\n returns (uint256)\n {\n return super.redeem(shares, receiver, owner);\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* GETTERS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n function name() public view override returns (string memory) {\n return _name;\n }\n\n function symbol() public view override returns (string memory) {\n return _symbol;\n }\n\n function asset() public view virtual override returns (address) {\n return address(_vaultAsset);\n }\n\n function convertToAssets(uint256 shares) public view override returns (uint256) {\n return _convertToAssets(shares);\n }\n\n function convertToShares(uint256 assets) public view override returns (uint256) {\n return _convertToShares(assets);\n }\n\n /**\n * @dev An implementation of ERC4626.totalAssets to avoid inflation attacks,\n * @dev which returns the total assets that VaultAdmin transferred to the vault.\n */\n function totalAssets() public view override returns (uint256) {\n // This is another layer of protection against inflation attacks.\n // ERC4626 uses this function to calculate the exchange rate.\n // Because only VaultAdmin can mint/burn shares via deposit/mint,\n // the total assets transferred by VaultAdmin into this vault\n // must be always equal to the total supply of the shares.\n // Therefore, the assets/shares exchange rate is always 1.\n // Attackers or users can transfer assets directly into this vault\n // (thus the total assets is always greater than or equal the total supply),\n // but that will not change the total assets returned by this\n // function, thus the exchange rate is not changed.\n //\n // We also need to consider the difference in decimals\n // between the vault and the asset to ensure that\n // 10^assetDecimals asset_wei ~ 10^vaultDecimals vault_wei.\n // asset_wei_totalAssets ~ vault_wei_totalSupply / 10**(vaultDecimals - assetDecimals)\n return _convertToAssets(totalSupply());\n }\n\n /// @inheritdoc ERC4626\n function previewWithdraw(uint256 assets) public view override returns (uint256 shares) {\n return _convertToShares(assets);\n }\n\n /// @inheritdoc ERC4626\n function previewMint(uint256 shares) public view override returns (uint256 assets) {\n return _convertToAssets(shares);\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* INTERNAL FUNCTIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @inheritdoc ERC4626\n function _initialConvertToShares(uint256 assets) internal view override returns (uint256 shares) {\n return _convertToShares(assets);\n }\n\n /// @inheritdoc ERC4626\n function _initialConvertToAssets(uint256 shares) internal view override returns (uint256 assets) {\n return _convertToAssets(shares);\n }\n\n /**\n * @dev Convert the assets to shares with decimals in consideration,\n * but out of the ERC4626's logic to enforce the fixed exchange rate\n * between Honey, shares, and assets.\n * @param assets The assets to convert to shares.\n * @return shares The shares converted from the assets.\n */\n function _convertToShares(uint256 assets) private view returns (uint256 shares) {\n uint8 vaultDecimals = decimals();\n uint8 assetDecimals = _vaultAsset.decimals();\n uint256 exponent;\n if (vaultDecimals >= assetDecimals) {\n unchecked {\n exponent = vaultDecimals - assetDecimals;\n }\n return assets * (10 ** exponent);\n }\n unchecked {\n exponent = assetDecimals - vaultDecimals;\n }\n return assets / (10 ** exponent);\n }\n\n /**\n * @dev Convert the assets to shares with decimals in consideration,\n * but out of the ERC4626's logic to enforce the fixed exchange rate\n * between Honey, shares, and assets.\n * @param shares The shares to convert to assets.\n * @return assets The assets converted from the shares.\n */\n function _convertToAssets(uint256 shares) private view returns (uint256 assets) {\n uint8 vaultDecimals = decimals();\n uint8 assetDecimals = _vaultAsset.decimals();\n uint256 exponent;\n if (vaultDecimals >= assetDecimals) {\n unchecked {\n exponent = vaultDecimals - assetDecimals;\n }\n return shares / (10 ** exponent);\n }\n unchecked {\n exponent = assetDecimals - vaultDecimals;\n }\n return shares * (10 ** exponent);\n }\n\n /// @inheritdoc ERC4626\n function _useVirtualShares() internal pure override returns (bool) {\n return false;\n }\n\n /// @inheritdoc PausableUpgradeable\n function _requireNotPaused() internal view override {\n if (paused()) VaultPaused.selector.revertWith(asset());\n }\n\n function _checkFactory() internal view {\n if (msg.sender != factory) {\n NotFactory.selector.revertWith();\n }\n }\n\n /// @dev This function is called after the deposit is made.\n /// @dev If the vault is a custody vault, it will transfer the assets to the custody.\n function _afterDeposit(uint256 assets, uint256) internal override {\n if (custodyInfo.isCustodyVault) {\n SafeTransferLib.safeTransfer(asset(), custodyInfo.custodyAddress, assets);\n }\n }\n\n /// @dev This function is called before the withdraw is made.\n /// @dev If the vault is a custody vault, it will pull the assets from the custody.\n function _beforeWithdraw(uint256 assets, uint256) internal override {\n if (custodyInfo.isCustodyVault) {\n SafeTransferLib.safeTransferFrom(asset(), custodyInfo.custodyAddress, address(this), assets);\n }\n }\n}\n"},"src/honey/Honey.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity 0.8.26;\n\nimport { ERC20 } from \"solady/src/tokens/ERC20.sol\";\nimport { AccessControlUpgradeable } from \"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\";\nimport { PausableUpgradeable } from \"@openzeppelin/contracts-upgradeable/utils/PausableUpgradeable.sol\";\nimport { UUPSUpgradeable } from \"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\";\n\nimport { Utils } from \"../libraries/Utils.sol\";\nimport { IHoneyErrors } from \"./IHoneyErrors.sol\";\nimport { EIP2612 } from \"../base/EIP2612.sol\";\nimport { EIP3009 } from \"../base/EIP3009.sol\";\n\n/// @notice This is the ERC20 token representation of Berachain's native stablecoin, Honey.\n/// @author Berachain Team\n/// @dev Uses diamond inheritance for EIP3009 and EIP2612 (both extend ERC20).\ncontract Honey is EIP3009, EIP2612, PausableUpgradeable, AccessControlUpgradeable, UUPSUpgradeable, IHoneyErrors {\n using Utils for bytes4;\n\n string private constant NAME = \"Honey\";\n string private constant SYMBOL = \"HONEY\";\n\n /// @notice The factory contract that mints and burns Honey.\n address public factory;\n\n /// @notice Whether or not a wallet has been blacklisted (e.g. due to stolen funds).\n mapping(address wallet => bool blacklisted) public isBlacklistedWallet;\n\n /// @notice Emitted when the fee receiver address is set.\n event BlacklistedStatusChanged(address wallet, bool status);\n\n /// @custom:oz-upgrades-unsafe-allow constructor\n constructor() {\n _disableInitializers();\n }\n\n function initialize(address _governance, address _factory) external initializer {\n __Pausable_init();\n __AccessControl_init();\n __UUPSUpgradeable_init();\n\n // Check for zero addresses.\n if (_factory == address(0)) ZeroAddress.selector.revertWith();\n if (_governance == address(0)) ZeroAddress.selector.revertWith();\n factory = _factory;\n _grantRole(DEFAULT_ADMIN_ROLE, _governance);\n }\n\n /// @custom:oz-upgrades-validate-as-initializer\n function initializeV1Update() external reinitializer(2) {\n __Pausable_init();\n }\n\n function _authorizeUpgrade(address) internal override onlyRole(DEFAULT_ADMIN_ROLE) { }\n\n modifier onlyFactory() {\n if (msg.sender != factory) NotFactory.selector.revertWith();\n _;\n }\n\n /// @notice Mint Honey to the receiver.\n /// @dev Only the factory can call this function.\n /// @param to The receiver address.\n /// @param amount The amount of Honey to mint.\n function mint(address to, uint256 amount) external onlyFactory {\n _mint(to, amount);\n }\n\n /// @notice Burn Honey from an account.\n /// @dev Only the factory can call this function.\n /// @param from The account to burn Honey from.\n /// @param amount The amount of Honey to burn.\n function burn(address from, uint256 amount) external onlyFactory {\n _burn(from, amount);\n }\n\n function name() public pure override returns (string memory) {\n return NAME;\n }\n\n function symbol() public pure override returns (string memory) {\n return SYMBOL;\n }\n\n /// @notice Version string for the EIP712 domain separator\n /// @return Version string\n function version() public pure returns (string memory) {\n return \"1\";\n }\n\n /// @dev Override to use the version function in case it changes to keep the EIP712 domain separator consistent.\n function _versionHash() internal pure override returns (bytes32) {\n return keccak256(abi.encodePacked(version()));\n }\n\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal view override {\n amount;\n _requireNotPaused();\n\n if (isBlacklistedWallet[from] || isBlacklistedWallet[to]) {\n revert BlacklistedWallet();\n }\n }\n\n /// @notice Allows to pause transfer of Honey for a specific wallet\n function setBlacklisted(address wallet, bool status) external {\n _checkRole(DEFAULT_ADMIN_ROLE);\n isBlacklistedWallet[wallet] = status;\n\n emit BlacklistedStatusChanged(wallet, status);\n }\n\n /// @notice Allows to pause transfer of Honey\n function setPaused(bool pause) external {\n _checkRole(DEFAULT_ADMIN_ROLE);\n\n bool isPaused = paused();\n if (pause && !isPaused) {\n _pause();\n }\n if (!pause && isPaused) {\n _unpause();\n }\n }\n\n /// @inheritdoc EIP2612\n /// @dev Override to add whenNotPaused check.\n function permit(\n address owner,\n address spender,\n uint256 value,\n uint256 deadline,\n uint8 v,\n bytes32 r,\n bytes32 s\n )\n public\n override(EIP2612, ERC20)\n whenNotPaused\n {\n super.permit(owner, spender, value, deadline, v, r, s);\n }\n\n /// @inheritdoc EIP2612\n /// @dev Override to add whenNotPaused check.\n function permit(\n address owner,\n address spender,\n uint256 value,\n uint256 deadline,\n bytes memory signature\n )\n public\n override\n whenNotPaused\n {\n super.permit(owner, spender, value, deadline, signature);\n }\n\n /// @inheritdoc EIP3009\n /// @dev Override to add whenNotPaused check.\n function cancelAuthorization(\n address authorizer,\n bytes32 nonce,\n uint8 v,\n bytes32 r,\n bytes32 s\n )\n public\n override\n whenNotPaused\n {\n super.cancelAuthorization(authorizer, nonce, v, r, s);\n }\n\n /// @inheritdoc EIP3009\n /// @dev Override to add whenNotPaused check.\n function cancelAuthorization(\n address authorizer,\n bytes32 nonce,\n bytes memory signature\n )\n public\n override\n whenNotPaused\n {\n super.cancelAuthorization(authorizer, nonce, signature);\n }\n}\n"},"src/honey/HoneyFactory.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity 0.8.26;\n\nimport { ERC20 } from \"solady/src/tokens/ERC20.sol\";\nimport { ERC4626 } from \"solady/src/tokens/ERC4626.sol\";\nimport { SafeTransferLib } from \"solady/src/utils/SafeTransferLib.sol\";\n\nimport { IPriceOracle } from \"../extras/IPriceOracle.sol\";\nimport { IHoneyFactory } from \"./IHoneyFactory.sol\";\nimport { Utils } from \"../libraries/Utils.sol\";\nimport { Honey } from \"./Honey.sol\";\nimport { VaultAdmin, CollateralVault } from \"./VaultAdmin.sol\";\n\n/// @notice This is the factory contract for minting and redeeming Honey.\n/// @author Berachain Team\ncontract HoneyFactory is IHoneyFactory, VaultAdmin {\n using Utils for bytes4;\n\n /// @dev The constant representing 100% of mint/redeem rate.\n uint256 private constant ONE_HUNDRED_PERCENT_RATE = 1e18;\n\n /// @dev The constant representing 98% of mint/redeem rate.\n uint256 private constant NINETY_EIGHT_PERCENT_RATE = 98e16;\n\n /// @dev The constant representing the default symmetrical offset for USD peg.\n uint256 private constant DEFAULT_PEG_OFFSET = 0.002e18;\n\n /// @dev The constant representing the default mint/redeem rate.\n uint256 private constant DEFAULT_MINT_REDEEM_RATE = 0.9995e18;\n\n /// @notice The constant representing the default minimum amount of shares to recapitalize.\n /// @dev It's set to 1 share.\n uint256 private constant DEFAULT_MIN_SHARES_TO_RECAPITALIZE = 1e18;\n\n /// @notice The constant representing the max peg offset allowed.\n /// @dev It's set to 2 cents.\n uint256 private constant MAX_PEG_OFFSET = 0.02e18;\n\n /// @notice The Honey token contract.\n Honey public honey;\n\n /// @notice The rate of POLFeeCollector fees, 60.18-decimal fixed-point number representation\n /// @dev 1e18 will imply all the fees are collected by the POLFeeCollector\n /// @dev 0 will imply all fees goes to the feeReceiver\n uint256 public polFeeCollectorFeeRate;\n\n /// @notice Mint rate of Honey for each asset, 60.18-decimal fixed-point number representation\n mapping(address asset => uint256 rate) public mintRates;\n /// @notice Redemption rate of Honey for each asset, 60.18-decimal fixed-point number representation\n mapping(address asset => uint256 rate) public redeemRates;\n\n /// @notice WAD offset from 1e18 for USD peg\n mapping(address asset => uint256 lowerPegOffset) public lowerPegOffsets;\n mapping(address asset => uint256 upperPegOffset) public upperPegOffsets;\n\n /// @notice Premium rate applied upon liquidation\n mapping(address asset => uint256 rate) internal liquidationRates;\n\n /// @notice Whether the basket mode is forced regardless of the price oracle\n bool public forcedBasketMode;\n\n /// @notice Whether the liquidation is enabled\n bool public liquidationEnabled;\n\n /// @notice The price oracle\n IPriceOracle public priceOracle;\n\n /// @notice The max number of seconds of tolerated staleness\n /// @dev It's involved into deeming a collateral asset pegged or not\n /// @dev Deprecated, not used anymore.\n uint256 private _priceFeedMaxDelay;\n\n address public referenceCollateral;\n mapping(address asset => uint256 limit) public relativeCap;\n uint256 public globalCap;\n\n /// @notice The target balance for recapitalization of each asset\n mapping(address asset => uint256 targetBalance) public recapitalizeBalanceThreshold;\n\n /// @notice The minimum amount of shares that the user have to mint to recapitalize\n uint256 public minSharesToRecapitalize;\n\n /// @custom:oz-upgrades-unsafe-allow constructor\n constructor() {\n _disableInitializers();\n }\n\n function initialize(\n address _governance,\n address _honey,\n address _polFeeCollector,\n address _feeReceiver,\n address _priceOracle,\n address _beacon\n )\n external\n initializer\n {\n __VaultAdmin_init(_governance, _polFeeCollector, _feeReceiver, _beacon);\n\n if (_honey == address(0)) ZeroAddress.selector.revertWith();\n if (_priceOracle == address(0)) ZeroAddress.selector.revertWith();\n\n honey = Honey(_honey);\n\n // initialize with 100% of the mint/redeem fee to the polFeeCollector\n polFeeCollectorFeeRate = ONE_HUNDRED_PERCENT_RATE;\n\n // NOTE: based on the average block time of ~2 seconds.\n _priceFeedMaxDelay = 10 seconds;\n minSharesToRecapitalize = DEFAULT_MIN_SHARES_TO_RECAPITALIZE;\n priceOracle = IPriceOracle(_priceOracle);\n globalCap = ONE_HUNDRED_PERCENT_RATE;\n liquidationEnabled = false;\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* MANAGER FUNCTIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @notice Set the mint rate of Honey for an asset.\n function setMintRate(address asset, uint256 mintRate) external {\n _checkRole(MANAGER_ROLE);\n // Revert if the mint rate is over 100%\n if (mintRate > ONE_HUNDRED_PERCENT_RATE) {\n OverOneHundredPercentRate.selector.revertWith(mintRate);\n }\n // Ensure manager cannot set the mint rate below 98%\n if (mintRate < NINETY_EIGHT_PERCENT_RATE) {\n UnderNinetyEightPercentRate.selector.revertWith(mintRate);\n }\n mintRates[asset] = mintRate;\n emit MintRateSet(asset, mintRate);\n }\n\n /// @notice Set the redemption rate of Honey for an asset.\n function setRedeemRate(address asset, uint256 redeemRate) external {\n _checkRole(MANAGER_ROLE);\n // Revert if the redeem rate is over 100%\n if (redeemRate > ONE_HUNDRED_PERCENT_RATE) {\n OverOneHundredPercentRate.selector.revertWith(redeemRate);\n }\n // Ensure manager cannot set the redeem rate below 98%\n if (redeemRate < NINETY_EIGHT_PERCENT_RATE) {\n UnderNinetyEightPercentRate.selector.revertWith(redeemRate);\n }\n redeemRates[asset] = redeemRate;\n emit RedeemRateSet(asset, redeemRate);\n }\n\n /// @notice Set the forced basket mode status.\n /// @dev Only Manager role can call this function.\n function setForcedBasketMode(bool forced) external {\n _checkRole(MANAGER_ROLE);\n forcedBasketMode = forced;\n emit BasketModeForced(forced);\n }\n\n /// @notice Set lower and upper depeg offset for an asset.\n /// @dev Only Manager role can call this function.\n function setDepegOffsets(address asset, uint256 lowerOffset, uint256 upperOffset) external {\n _checkRole(MANAGER_ROLE);\n _checkRegisteredAsset(asset);\n\n if (lowerOffset > MAX_PEG_OFFSET || upperOffset > MAX_PEG_OFFSET) {\n AmountOutOfRange.selector.revertWith();\n }\n lowerPegOffsets[asset] = lowerOffset;\n upperPegOffsets[asset] = upperOffset;\n emit DepegOffsetsSet(asset, lowerOffset, upperOffset);\n }\n\n /// @notice Set the reference collateral for cap limits.\n function setReferenceCollateral(address asset) external {\n _checkRole(MANAGER_ROLE);\n _checkRegisteredAsset(asset);\n\n address old = referenceCollateral;\n referenceCollateral = asset;\n emit ReferenceCollateralSet(old, asset);\n }\n\n /// @notice Set the global cap limit.\n function setGlobalCap(uint256 limit) external {\n _checkRole(MANAGER_ROLE);\n\n // A change in the weights distribution that frontruns this transaction\n // may cause a DoS in the redeem of Honey\n uint256[] memory weights = _getWeights(true, false);\n uint256 max = 0;\n for (uint256 i = 0; i < registeredAssets.length; i++) {\n if (weights[i] > max) {\n max = weights[i];\n }\n }\n if (limit < max) {\n CapCanCauseDenialOfService.selector.revertWith();\n }\n\n globalCap = limit;\n emit GlobalCapSet(limit);\n }\n\n /// @notice Set the relative cap limit.\n function setRelativeCap(address asset, uint256 limit) external {\n _checkRole(MANAGER_ROLE);\n relativeCap[asset] = limit;\n emit RelativeCapSet(asset, limit);\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* ADMIN FUNCTIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @notice Set the POLFeeCollector fee rate.\n function setPOLFeeCollectorFeeRate(uint256 _polFeeCollectorFeeRate) external {\n _checkRole(DEFAULT_ADMIN_ROLE);\n // Revert if the POLFeeCollector fee rate is over 100%\n if (_polFeeCollectorFeeRate > ONE_HUNDRED_PERCENT_RATE) {\n OverOneHundredPercentRate.selector.revertWith(_polFeeCollectorFeeRate);\n }\n polFeeCollectorFeeRate = _polFeeCollectorFeeRate;\n emit POLFeeCollectorFeeRateSet(_polFeeCollectorFeeRate);\n }\n\n /// @notice Set whether the liquidation is enabled or not.\n function setLiquidationEnabled(bool enabled) external {\n _checkRole(DEFAULT_ADMIN_ROLE);\n liquidationEnabled = enabled;\n emit LiquidationStatusSet(enabled);\n }\n\n /// @notice Set the liquidation rate for an asset\n /// @dev The `extraRate` is a premium, hence a 0.25 rate means a 1.25 premium factor.\n function setLiquidationRate(address asset, uint256 extraRate) external {\n _checkRole(DEFAULT_ADMIN_ROLE);\n _checkRegisteredAsset(asset);\n\n liquidationRates[asset] = extraRate;\n emit LiquidationRateSet(asset, extraRate);\n }\n\n /// @notice Set the minimum amount of shares that the user have to mint to recapitalize\n function setMinSharesToRecapitalize(uint256 minSharesAmount) external {\n _checkRole(DEFAULT_ADMIN_ROLE);\n if (minSharesAmount < DEFAULT_MIN_SHARES_TO_RECAPITALIZE) {\n AmountOutOfRange.selector.revertWith(minSharesAmount);\n }\n minSharesToRecapitalize = minSharesAmount;\n emit MinSharesToRecapitalizeSet(minSharesAmount);\n }\n\n /// @notice Set the target balance for recapitalization.\n /// @param asset The collateral asset to which the target applies.\n /// @param target The target amount with the token's decimals.\n function setRecapitalizeBalanceThreshold(address asset, uint256 target) external {\n _checkRole(DEFAULT_ADMIN_ROLE);\n recapitalizeBalanceThreshold[asset] = target;\n emit RecapitalizeBalanceThresholdSet(asset, target);\n }\n\n /// @notice Replace the price oracle.\n /// @param priceOracle_ The new price oracle to use.\n function setPriceOracle(address priceOracle_) external {\n _checkRole(DEFAULT_ADMIN_ROLE);\n if (priceOracle_ == address(0)) ZeroAddress.selector.revertWith();\n priceOracle = IPriceOracle(priceOracle_);\n emit PriceOracleSet(priceOracle_);\n }\n\n /// @dev Create a new ERC4626 vault for a pair of asset - Honey and register it with VaultAdmin.\n /// @dev Reverts if the vault for the given asset is already registered.\n /// @dev Reverts if the asset is zero address during `vault.initialize`.\n /// @param asset The asset to create a vault for.\n /// @return vault The newly created vault.\n function createVault(address asset) external returns (ERC4626 vault) {\n if (numRegisteredAssets() == 0) {\n referenceCollateral = asset;\n }\n\n vault = _createVault(asset);\n\n relativeCap[asset] = ONE_HUNDRED_PERCENT_RATE;\n mintRates[asset] = DEFAULT_MINT_REDEEM_RATE;\n redeemRates[asset] = DEFAULT_MINT_REDEEM_RATE;\n\n // Check if oracle has the needed data and the asset is a stable one:\n lowerPegOffsets[asset] = MAX_PEG_OFFSET;\n upperPegOffsets[asset] = MAX_PEG_OFFSET;\n if (!isPegged(asset)) {\n NotPegged.selector.revertWith(asset);\n }\n // Restore the default value:\n lowerPegOffsets[asset] = DEFAULT_PEG_OFFSET;\n upperPegOffsets[asset] = DEFAULT_PEG_OFFSET;\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* USER FUNCTIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @inheritdoc IHoneyFactory\n function mint(\n address asset,\n uint256 amount,\n address receiver,\n bool expectBasketMode\n )\n external\n whenNotPaused\n returns (uint256 honeyToMint)\n {\n _checkRegisteredAsset(asset);\n\n bool basketMode = isBasketModeEnabled(true);\n if (basketMode != expectBasketMode) {\n UnexpectedBasketModeStatus.selector.revertWith();\n }\n\n if (!basketMode) {\n // Check if the asset is not market as bad collateral and if it is pegged.\n _checkGoodCollateralAsset(asset);\n if (!isPegged(asset)) {\n NotPegged.selector.revertWith(asset);\n }\n\n honeyToMint = _mint(asset, amount, receiver, false);\n if (!_isCappedGlobal(true, asset)) {\n ExceedGlobalCap.selector.revertWith();\n }\n } else {\n uint256[] memory weights = _getWeights(false, true);\n // Here the assumption is that the callers knows about the basket mode and\n // has already approved all the needed (and previewed) amounts.\n // As we cannot trust the caller to have provided the right asset/amount tuples\n // without changing their distribution or without tricking it (e.g. by repeating some assets),\n // we take one of those amount as reference and compute the others accordingly.\n uint256 refAssetWeight = weights[_lookupRegistrationIndex(asset)];\n if (refAssetWeight == 0) {\n ZeroWeight.selector.revertWith(asset);\n }\n uint8 decimals = ERC20(asset).decimals();\n uint256 refAmount = Utils.changeDecimals(amount, decimals, 18);\n refAmount = refAmount * 1e18 / refAssetWeight;\n for (uint256 i = 0; i < registeredAssets.length; i++) {\n amount = refAmount * weights[i] / 1e18;\n amount = vaults[registeredAssets[i]].convertToAssets(amount);\n\n honeyToMint += _mint(registeredAssets[i], amount, receiver, true);\n }\n }\n }\n\n /// @inheritdoc IHoneyFactory\n function redeem(\n address asset,\n uint256 honeyAmount,\n address receiver,\n bool expectBasketMode\n )\n external\n whenNotPaused\n returns (uint256[] memory redeemed)\n {\n _checkRegisteredAsset(asset);\n\n bool basketMode = isBasketModeEnabled(false);\n if (basketMode != expectBasketMode) {\n UnexpectedBasketModeStatus.selector.revertWith();\n }\n\n if (!basketMode) {\n redeemed = new uint256[](registeredAssets.length);\n uint256 index = _lookupRegistrationIndex(asset);\n redeemed[index] = _redeem(asset, honeyAmount, receiver);\n\n // When the redeemed asset is the reference collateral\n // it might block other assets on mint due to its usage in the computation of the relative cap limits.\n // Because of this, we need to check the relative cap limits for all the other assets.\n if (asset == referenceCollateral) {\n for (uint256 i = 0; i < registeredAssets.length; i++) {\n if (registeredAssets[i] == asset) {\n continue;\n }\n if (!_isCappedRelative(registeredAssets[i])) {\n ExceedRelativeCap.selector.revertWith();\n }\n }\n }\n\n if (!_isCappedGlobal(false, asset)) {\n ExceedGlobalCap.selector.revertWith();\n }\n\n return redeemed;\n }\n\n uint256[] memory weights = _getWeights(false, true);\n redeemed = new uint256[](registeredAssets.length);\n for (uint256 i = 0; i < registeredAssets.length; i++) {\n uint256 amount = honeyAmount * weights[i] / 1e18;\n\n redeemed[i] = _redeem(registeredAssets[i], amount, receiver);\n }\n }\n\n /// @inheritdoc IHoneyFactory\n function liquidate(\n address badCollateral,\n address goodCollateral,\n uint256 goodAmount\n )\n external\n whenNotPaused\n returns (uint256 badAmount)\n {\n _checkRegisteredAsset(badCollateral);\n _checkRegisteredAsset(goodCollateral);\n _checkGoodCollateralAsset(goodCollateral);\n\n if (!liquidationEnabled) {\n LiquidationDisabled.selector.revertWith();\n }\n if (!isBadCollateralAsset[badCollateral]) {\n AssetIsNotBadCollateral.selector.revertWith();\n }\n // If the bad collateral is the reference one, a liquidation may block other assets on mint\n // due to its usage in the computation of the relative cap limits.\n // As a conseguence, the reference asset must first be replaced.\n if (badCollateral == referenceCollateral) {\n LiquidationWithReferenceCollateral.selector.revertWith();\n }\n\n uint256 goodShares = _approveAndDeposit(goodCollateral, goodAmount);\n\n uint256 priceBad = _getPrice(badCollateral);\n uint256 priceGood = _getPrice(goodCollateral);\n badAmount = (goodShares * priceGood / priceBad) * (1e18 + liquidationRates[badCollateral]) / 1e18;\n\n uint256 badShares = _getSharesWithoutFees(badCollateral);\n if (badAmount > badShares) {\n // x = bs / (pg / pb) * (1 + r)\n // optimized (for gas and rounding issues) as:\n // x = bs * (pb / pg) / (1 + r)\n uint256 goodSharesAdjusted =\n (badShares * priceBad / priceGood) * 1e18 / (1e18 + liquidationRates[badCollateral]);\n _redeemShares(goodCollateral, goodShares - goodSharesAdjusted, msg.sender);\n badAmount = badShares;\n }\n\n if (!_isCappedRelative(goodCollateral)) {\n ExceedRelativeCap.selector.revertWith();\n }\n if (!_isCappedGlobal(false, badCollateral)) {\n ExceedGlobalCap.selector.revertWith();\n }\n\n badAmount = _redeemShares(badCollateral, badAmount, msg.sender);\n\n if (badAmount == 0) {\n ZeroAmount.selector.revertWith();\n }\n\n _checkInvariants(badCollateral);\n _checkInvariants(goodCollateral);\n emit Liquidated(badCollateral, goodCollateral, goodAmount, msg.sender);\n }\n\n /// @inheritdoc IHoneyFactory\n function recapitalize(address asset, uint256 amount) external whenNotPaused {\n _checkRegisteredAsset(asset);\n _checkGoodCollateralAsset(asset);\n uint256 targetBalance = recapitalizeBalanceThreshold[asset];\n uint256 feeAssetBalance = vaults[asset].convertToAssets(collectedAssetFees[asset]);\n uint256 currentBalance = vaults[asset].totalAssets() - feeAssetBalance;\n\n if (currentBalance >= targetBalance) {\n RecapitalizeNotNeeded.selector.revertWith(asset);\n }\n\n if (!isPegged(asset)) {\n NotPegged.selector.revertWith(asset);\n }\n\n if (currentBalance + amount > targetBalance) {\n amount = targetBalance - currentBalance;\n }\n\n // Convert the amount to shares to avoid the need of decimals handling.\n uint256 shares = vaults[asset].convertToShares(amount);\n\n if (shares < minSharesToRecapitalize) {\n InsufficientRecapitalizeAmount.selector.revertWith(amount);\n }\n\n // Calculate the a posteriori missing balance:\n uint256 remainingToTarget = targetBalance - (currentBalance + amount);\n // If the a posteriori missing balance is less than the minimum required to recapitalize,\n // reduce the amount so that another recapitalize is still doable.\n uint256 minAssetsForRecap = vaults[asset].convertToAssets(minSharesToRecapitalize);\n if (remainingToTarget > 0 && remainingToTarget < minAssetsForRecap) {\n uint256 excessAmount = minAssetsForRecap - remainingToTarget;\n amount -= excessAmount;\n }\n\n _approveAndDeposit(asset, amount);\n\n if (!_isCappedRelative(asset)) {\n ExceedRelativeCap.selector.revertWith();\n }\n if (!_isCappedGlobal(true, asset)) {\n ExceedGlobalCap.selector.revertWith();\n }\n _checkInvariants(asset);\n emit Recapitalized(asset, amount, msg.sender);\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* GETTERS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @notice Get the status of the basket mode.\n /// @dev On mint, basket mode is enabled if all collaterals are either depegged or bad.\n /// @dev On redeem, basket mode is enabled if at least one asset is deppegged\n /// except for the collateral assets that have been fully liquidated.\n function isBasketModeEnabled(bool isMint) public view returns (bool basketMode) {\n if (forcedBasketMode) {\n return true;\n }\n\n for (uint256 i = 0; i < registeredAssets.length; i++) {\n bool isPegged_ = isPegged(registeredAssets[i]);\n\n if (isMint) {\n if (isPegged_ && !isBadCollateralAsset[registeredAssets[i]]) {\n // Basket mode should be disabled. It means there is a good collateral.\n return false;\n }\n } else if (!isPegged_) {\n // If the not pegged asset is a bad collateral and its vault doesn't have shares\n // we can ignore it because it means it has been fully liquidated.\n bool usedAsCollateral = _getSharesWithoutFees(registeredAssets[i]) > 0;\n\n if (!usedAsCollateral) {\n continue;\n }\n return true;\n }\n }\n\n // When is mint and there is no asset that disable basket mode, return true.\n // When is redeem and there is no asset that enable basket mode, return false.\n return isMint ? true : false;\n }\n\n /// @notice Get weights of all the registered assets except for the paused ones.\n /// @return w weights of all the registered assets.\n function getWeights() external view returns (uint256[] memory w) {\n w = _getWeights(false, true);\n }\n\n /// @notice Get if an asset is pegged or not.\n /// @param asset The asset to check.\n /// @return true if the asset is pegged.\n function isPegged(address asset) public view returns (bool) {\n if (!priceOracle.priceAvailable(asset)) {\n return false;\n }\n // Staleness of the feed is monitored offchain and is not considered here.\n IPriceOracle.Data memory data = priceOracle.getPriceUnsafe(asset);\n return (1e18 - lowerPegOffsets[asset] <= data.price) && (data.price <= 1e18 + upperPegOffsets[asset]);\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* INTERNAL FUNCTIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n function _mint(address asset, uint256 amount, address receiver, bool basketMode) internal returns (uint256) {\n if (amount == 0) {\n return 0;\n }\n\n uint256 shares = _approveAndDeposit(asset, amount);\n\n // The factory mints the corresponding amount of Honey to the receiver\n // with the consideration of the static mint fee.\n (uint256 honeyToMint, uint256 feeReceiverFeeShares, uint256 polFeeCollectorFeeShares) =\n _getHoneyMintedFromShares(asset, shares);\n\n // Updates the fee accounts for the minted shares.\n _handleFees(asset, polFeeCollectorFeeShares, feeReceiverFeeShares);\n if (!basketMode && !_isCappedRelative(asset)) {\n ExceedRelativeCap.selector.revertWith();\n }\n honey.mint(receiver, honeyToMint);\n\n _checkInvariants(asset);\n emit HoneyMinted(msg.sender, receiver, asset, amount, honeyToMint);\n return honeyToMint;\n }\n\n function _redeem(address asset, uint256 honeyAmount, address receiver) internal returns (uint256 redeemedAssets) {\n // The function reverts if the sender does not have enough Honey to burn or\n // the vault does not have enough assets to redeem.\n // The factory burns the corresponding amount of Honey of the sender\n // to get the shares and redeem them for assets from the vault.\n if (honeyAmount == 0) {\n return 0;\n }\n\n {\n (uint256 sharesForRedeem, uint256 feeReceiverFeeShares, uint256 polFeeCollectorFeeShares) =\n _getSharesRedeemedFromHoney(asset, honeyAmount);\n honey.burn(msg.sender, honeyAmount);\n // Updates the fee accounts for the redeemed shares.\n _handleFees(asset, polFeeCollectorFeeShares, feeReceiverFeeShares);\n // The factory redeems the corresponding amount of assets from Vault\n // and transfer the assets to the receiver.\n redeemedAssets = _redeemShares(asset, sharesForRedeem, receiver);\n }\n _checkInvariants(asset);\n\n emit HoneyRedeemed(msg.sender, receiver, asset, redeemedAssets, honeyAmount);\n }\n\n function _getHoneyMintedFromShares(\n address asset,\n uint256 shares\n )\n internal\n view\n returns (uint256 honeyAmount, uint256 feeReceiverFeeShares, uint256 polFeeCollectorFeeShares)\n {\n uint256 mintRate = mintRates[asset];\n honeyAmount = shares * mintRate / 1e18;\n uint256 feeShares = shares - honeyAmount;\n polFeeCollectorFeeShares = feeShares * polFeeCollectorFeeRate / 1e18;\n feeReceiverFeeShares = feeShares - polFeeCollectorFeeShares;\n }\n\n function _getSharesRedeemedFromHoney(\n address asset,\n uint256 honeyAmount\n )\n internal\n view\n returns (uint256 shares, uint256 feeReceiverFeeShares, uint256 polFeeCollectorFeeShares)\n {\n uint256 redeemRate = redeemRates[asset];\n shares = honeyAmount * redeemRate / 1e18;\n uint256 feeShares = honeyAmount - shares;\n // Distribute the fee to the polFeeCollector based on the polFeeCollectorFeeRate.\n polFeeCollectorFeeShares = feeShares * polFeeCollectorFeeRate / 1e18;\n // The remaining fee is distributed to the feeReceiver.\n feeReceiverFeeShares = feeShares - polFeeCollectorFeeShares;\n }\n\n function _getWeights(\n bool filterBadCollaterals,\n bool filterPausedCollateral\n )\n internal\n view\n returns (uint256[] memory weights)\n {\n weights = new uint256[](registeredAssets.length);\n uint256 sum = 0;\n for (uint256 i = 0; i < registeredAssets.length; i++) {\n if (filterBadCollaterals && isBadCollateralAsset[registeredAssets[i]]) {\n continue;\n }\n // If vault is paused, the weight of the asset is 0.\n if (filterPausedCollateral && vaults[registeredAssets[i]].paused()) {\n continue;\n }\n // NOTE: vault shares are always in WAD, regardless of the asset's decimals\n weights[i] = _getSharesWithoutFees(registeredAssets[i]);\n sum += weights[i];\n }\n\n if (sum == 0) {\n return weights;\n }\n for (uint256 i = 0; i < registeredAssets.length; i++) {\n weights[i] = weights[i] * 1e18 / sum;\n }\n }\n\n function _isCappedRelative(address asset) internal view returns (bool) {\n if (asset == referenceCollateral) {\n return true;\n }\n\n uint256 balance = _getSharesWithoutFees(asset);\n uint256 refBalance = _getSharesWithoutFees(referenceCollateral);\n\n if (refBalance == 0) {\n // If the balance of the asset is 0, it means that is capped\n // because the refence asset has also 0 balance.\n return (balance == 0) ? true : false;\n }\n uint256 weight = balance * 1e18 / refBalance;\n\n return weight <= relativeCap[asset];\n }\n\n function _isCappedGlobal(bool isMint, address collateralAsset) internal view returns (bool) {\n uint256[] memory weights = _getWeights(true, false);\n for (uint256 i = 0; i < registeredAssets.length; i++) {\n // Upon mint, we don't care about the other collaterals, as their weight can\n // only decrease; also, shall we check them all, it's enough to have at least\n // one of them that exceeds their weight to prevent the current mint.\n if (isMint && registeredAssets[i] != collateralAsset) {\n continue;\n }\n // Upon redeem, we always allows the weight of the asset to be reduced, even if\n // its current weight is already over the globalCap (due to a lowered value),\n // as long as it doesn't cause the other collateral to exceeds the limit.\n if (!isMint && registeredAssets[i] == collateralAsset) {\n continue;\n }\n if (weights[i] > globalCap) {\n return false;\n }\n }\n return true;\n }\n\n function _getPrice(address asset) internal view returns (uint256) {\n IPriceOracle.Data memory data = priceOracle.getPrice(asset);\n return data.price;\n }\n\n /// @dev Returns the amount of the shares of the factory for the given asset excluding the fees.\n function _getSharesWithoutFees(address asset) internal view returns (uint256) {\n return vaults[asset].balanceOf(address(this)) - collectedAssetFees[asset];\n }\n\n function _approveAndDeposit(address asset, uint256 amount) internal returns (uint256 shares) {\n SafeTransferLib.safeTransferFrom(asset, msg.sender, address(this), amount);\n SafeTransferLib.safeApprove(asset, address(vaults[asset]), amount);\n shares = vaults[asset].deposit(amount, address(this));\n }\n\n function _redeemShares(address asset, uint256 shares, address receiver) internal returns (uint256) {\n return vaults[asset].redeem(shares, receiver, address(this));\n }\n\n /// @notice Handles the fee to distribute for a given asset to the PoL fee collector and the fee receiver.\n function _handleFees(address asset, uint256 polFeeCollectorFeeShares, uint256 feeReceiverFeeShares) internal {\n // The PoL fee collector's fee, if any, are transferred right away:\n // NOTE: There might be some dust loss if asset value of polFeeCollectorFeeShares is 0.\n if (polFeeCollectorFeeShares > 0) {\n _redeemShares(asset, polFeeCollectorFeeShares, polFeeCollector);\n }\n // The fee receiver's fee (shares), if any, are held until they are redeemed:\n if (feeReceiverFeeShares > 0) {\n collectedFees[feeReceiver][asset] += feeReceiverFeeShares;\n collectedAssetFees[asset] += feeReceiverFeeShares;\n }\n }\n\n /// @dev Check the invariant of the vault to ensure that assets are always sufficient to redeem.\n function _checkInvariants(address asset) internal view {\n ERC4626 vault = vaults[asset];\n uint256 totalShares = vault.totalSupply();\n (bool isCustodyVault, address custodyAddress) = CollateralVault(address(vault)).custodyInfo();\n uint256 totalAssets =\n isCustodyVault ? ERC20(asset).balanceOf(custodyAddress) : ERC20(asset).balanceOf(address(vault));\n if (vault.convertToAssets(totalShares) > totalAssets) {\n InsufficientAssets.selector.revertWith(totalAssets, totalShares);\n }\n\n // A user cannot redeem also the collected fees\n uint256 vaultShares = vault.balanceOf(address(this));\n if (vaultShares < collectedAssetFees[asset]) {\n uint256 vaultAssets = vault.convertToAssets(vaultShares);\n InsufficientAssets.selector.revertWith(vaultAssets, vaultShares);\n }\n }\n}\n"},"src/honey/IHoneyErrors.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity ^0.8.26;\n\n/// @notice Interface of Honey errors\ninterface IHoneyErrors {\n // Signature: 0xd92e233d\n error ZeroAddress();\n // Signature: 0x14799671\n error MismatchedOwner(address owner, address expectedOwner);\n // Signature: 0x38bfcc16\n error VaultAlreadyRegistered(address asset);\n // Signature: 0x1a2a9e87\n error AssetNotRegistered(address asset);\n // Signature: 0x536dd9ef\n error UnauthorizedCaller(address caller, address expectedCaller);\n // Signature: 0xada46d16\n error OverOneHundredPercentRate(uint256 rate);\n // Signature: 0x71fba9d0\n error UnderNinetyEightPercentRate(uint256 rate);\n // Signature: 0x32cc7236\n error NotFactory();\n // Signature: 0xb97fded1\n error InsufficientAssets(uint256 assets, uint256 shares);\n // Signature: 0xb0f29513\n error InsufficientBalanceToPayPythFee();\n // Signature: 0x6ba2e418\n error AssetIsBadCollateral(address asset);\n // Signature: 0x2595dbe7\n error ExceedRelativeCap();\n // Signature: 0x6dabf61e\n error ExceedGlobalCap();\n // Signature: 0x07091331\n error LiquidationDisabled();\n // Signature: 0x867344a8\n error AssetIsNotBadCollateral(address asset);\n // Signature: 0x0dc86ad3\n error LiquidationWithReferenceCollateral();\n // Signature: 0xda9f8b34\n error VaultPaused();\n // Signature: 0x168cecf7\n error ZeroWeight(address asset);\n // Signature: 0x10e4809e\n error RecapitalizeNotNeeded(address asset);\n // Signature: 0x2dd78c7e\n error InsufficientRecapitalizeAmount(uint256 amount);\n // Signature: 0xc64200e9\n error AmountOutOfRange();\n // Signature: 0x2201a6c3\n error NotPegged(address asset);\n // Signature: 0x1f2a2005\n error ZeroAmount();\n // Signature: 0x6ce14a8b\n error UnexpectedBasketModeStatus();\n // Signature: 0x5419864a\n error CapCanCauseDenialOfService();\n // Signature: 0xcd09f603\n error InvalidCustodyInfoInput();\n // Signature: 0x265693b4\n error BlacklistedWallet();\n}\n"},"src/honey/IHoneyFactory.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity ^0.8.26;\n\nimport { Honey } from \"./Honey.sol\";\n\n/// @notice This is the interface of HoneyFactory.\n/// @author Berachain Team\ninterface IHoneyFactory {\n /// @notice Emitted when a mint rate is set for an asset.\n event MintRateSet(address indexed asset, uint256 rate);\n\n /// @notice Emitted when a redemption rate is set for an asset.\n event RedeemRateSet(address indexed asset, uint256 rate);\n\n /// @notice Emitted when the POLFeeCollector fee rate is set.\n event POLFeeCollectorFeeRateSet(uint256 rate);\n\n /// @notice Emitted when honey is minted\n /// @param from The account that supplied assets for the minted honey.\n /// @param to The account that received the honey.\n /// @param asset The asset used to mint the honey.\n /// @param assetAmount The amount of assets supplied for minting the honey.\n /// @param mintAmount The amount of honey that was minted.\n event HoneyMinted(\n address indexed from, address indexed to, address indexed asset, uint256 assetAmount, uint256 mintAmount\n );\n\n /// @notice Emitted when honey is redeemed\n /// @param from The account that redeemed the honey.\n /// @param to The account that received the assets.\n /// @param asset The asset for redeeming the honey.\n /// @param assetAmount The amount of assets received for redeeming the honey.\n /// @param redeemAmount The amount of honey that was redeemed.\n event HoneyRedeemed(\n address indexed from, address indexed to, address indexed asset, uint256 assetAmount, uint256 redeemAmount\n );\n\n /// @notice Emitted when the basked mode is forced.\n /// @param forced The flag that represent the forced basket mode.\n event BasketModeForced(bool forced);\n\n /// @notice Emitted when the depeg offsets are changed.\n /// @param asset The asset that the depeg offsets are changed.\n /// @param lower The lower depeg offset.\n /// @param upper The upper depeg offset.\n event DepegOffsetsSet(address asset, uint256 lower, uint256 upper);\n\n /// @notice Emitted when the liquidation is enabled or disabled.\n /// @param enabled The flag that represent the liquidation status.\n event LiquidationStatusSet(bool enabled);\n\n /// @notice Emitted when the reference collateral is set.\n /// @param old The old reference collateral.\n /// @param asset The new reference collateral.\n event ReferenceCollateralSet(address old, address asset);\n\n /// @notice Emitted when the recapitalize balance threshold is set.\n /// @param asset The asset that the recapitalize balance threshold is set.\n /// @param target The target balance threshold.\n event RecapitalizeBalanceThresholdSet(address asset, uint256 target);\n\n /// @notice Emitted when the min shares to recapitalize is set.\n /// @param minShareAmount The min shares to recapitalize.\n event MinSharesToRecapitalizeSet(uint256 minShareAmount);\n\n /// @notice Emitted when the max feed delay is set.\n /// @param maxFeedDelay The max feed delay.\n event MaxFeedDelaySet(uint256 maxFeedDelay);\n\n /// @notice Emitted when the liquidation rate is set.\n /// @param asset The asset that the liquidation rate is set.\n /// @param rate The liquidation rate.\n event LiquidationRateSet(address asset, uint256 rate);\n\n /// @notice Emitted when the global cap is set.\n /// @param globalCap The global cap.\n event GlobalCapSet(uint256 globalCap);\n\n /// @notice Emitted when the relative cap is set.\n /// @param asset The asset that the relative cap is set.\n /// @param relativeCap The relative cap.\n event RelativeCapSet(address asset, uint256 relativeCap);\n\n /// @notice Emitted when the price oracle is replaced.\n /// @param oracle The address of the new price oracle.\n event PriceOracleSet(address oracle);\n\n /// @notice Emitted when the liquidate is performed.\n /// @param badAsset The bad asset that is liquidated.\n /// @param goodAsset The good asset that is provided.\n /// @param amount The amount of good asset provided.\n /// @param sender The account that performed the liquidation.\n event Liquidated(address badAsset, address goodAsset, uint256 amount, address sender);\n\n /// @notice Emitted when the collateral vault is recapitalized.\n /// @param asset The asset that is recapitalized.\n /// @param amount The amount of asset provided.\n /// @param sender The account that performed the recapitalization.\n event Recapitalized(address asset, uint256 amount, address sender);\n\n /// @notice Returns the address of the Honey token contract.\n /// @return honey_ Address of Honey.\n function honey() external view returns (Honey honey_);\n\n /// @notice Returns the flag to tell if factory is forced to basket mode.\n /// @return forcedBasketMode_ True if forced to basket mode.\n function forcedBasketMode() external view returns (bool forcedBasketMode_);\n\n /// @notice Returns the lower offset of the peg range for a given asset.\n /// @param asset The address of the asset to check lower peg offset.\n /// @return lowerPegOffset The lower peg offset.\n function lowerPegOffsets(address asset) external view returns (uint256 lowerPegOffset);\n\n /// @notice Returns the upper offset of the peg range for a given asset.\n /// @param asset The address of the asset to check upper peg offset.\n /// @return upperPegOffset The upper peg offset.\n function upperPegOffsets(address asset) external view returns (uint256 upperPegOffset);\n\n /// @notice Mint Honey by sending ERC20 to this contract.\n /// @dev Assest must be registered and must be a good collateral.\n /// @param amount The amount of ERC20 to mint with.\n /// @param receiver The address that will receive Honey.\n /// @param expectBasketMode The flag with which the client communicates its expectation of the basket mode\n /// status.\n /// @return The amount of Honey minted.\n /// @dev The expectBasketMode flag avoid behavioral issues that may happen when the basket mode status changes\n /// after the client signed its transaction.\n function mint(address asset, uint256 amount, address receiver, bool expectBasketMode) external returns (uint256);\n\n /// @notice Redeem assets by sending Honey in to burn.\n /// @param honeyAmount The amount of Honey to redeem.\n /// @param receiver The address that will receive assets.\n /// @param expectBasketMode The flag with which the client communicates its expectation of the basket mode\n /// status.\n /// @return The amount of assets redeemed.\n /// @dev The expectBasketMode flag avoid behavioral issues that may happen when the basket mode status changes\n /// after the client signed its transaction.\n function redeem(\n address asset,\n uint256 honeyAmount,\n address receiver,\n bool expectBasketMode\n )\n external\n returns (uint256[] memory);\n\n /// @notice Liquidate a bad collateral asset.\n /// @param badCollateral The ERC20 asset to liquidate.\n /// @param goodCollateral The ERC20 asset to provide in place.\n /// @param goodAmount The amount provided.\n /// @return badAmount The amount obtained.\n function liquidate(\n address badCollateral,\n address goodCollateral,\n uint256 goodAmount\n )\n external\n returns (uint256 badAmount);\n\n /// @notice Recapitalize a collateral vault.\n /// @param asset The ERC20 asset to recapitalize.\n /// @param amount The amount provided.\n function recapitalize(address asset, uint256 amount) external;\n}\n"},"src/honey/VaultAdmin.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\n// To support named parameters in mapping types and custom operators for user-defined value types.\npragma solidity 0.8.26;\n\nimport { AccessControlUpgradeable } from \"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\";\nimport { PausableUpgradeable } from \"@openzeppelin/contracts-upgradeable/utils/PausableUpgradeable.sol\";\nimport { UUPSUpgradeable } from \"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\";\nimport { LibClone } from \"solady/src/utils/LibClone.sol\";\n\nimport { IHoneyErrors } from \"./IHoneyErrors.sol\";\nimport { Utils } from \"../libraries/Utils.sol\";\nimport { CollateralVault } from \"./CollateralVault.sol\";\n\n/// @notice This is the admin contract that manages the vaults and fees.\n/// @author Berachain Team\nabstract contract VaultAdmin is AccessControlUpgradeable, PausableUpgradeable, UUPSUpgradeable, IHoneyErrors {\n using Utils for bytes4;\n\n /// @notice Emitted when the fee receiver address is set.\n event FeeReceiverSet(address indexed feeReceiver);\n\n /// @notice Emitted when the POL Fee Collector address is set.\n event POLFeeCollectorSet(address indexed polFeeCollector);\n\n /// @notice Emitted when a new vault is created.\n event VaultCreated(address indexed vault, address indexed asset);\n\n /// @notice Emitted when collateral asset status is set.\n event CollateralAssetStatusSet(address indexed asset, bool isBadCollateral);\n\n /// @notice Emitted when a collected fee is withdrawn.\n event CollectedFeeWithdrawn(address indexed asset, address indexed receiver, uint256 shares, uint256 assets);\n\n /// @notice Emitted when a price feed is changed.\n event PriceFeedChanged(address indexed asset, bytes32 id);\n\n /// @notice The MANAGER role.\n bytes32 public constant MANAGER_ROLE = keccak256(\"MANAGER_ROLE\");\n\n /// @notice The PAUSER role.\n /// @dev This role is used to only pause the factory and vaults.\n bytes32 public constant PAUSER_ROLE = keccak256(\"PAUSER_ROLE\");\n\n /// @notice The beacon address.\n address public beacon;\n\n /// @notice The address of the fee receiver.\n address public feeReceiver;\n\n /// @notice The address of the POL Fee Collector.\n address public polFeeCollector;\n\n /// @notice Array of registered assets.\n address[] public registeredAssets;\n\n /// @notice Mapping of assets to their corresponding vaults.\n mapping(address asset => CollateralVault vault) public vaults;\n\n /// @notice Mapping of bad collateral assets.\n mapping(address asset => bool badCollateral) public isBadCollateralAsset;\n\n /// @notice Mapping of receiver to asset to collected fee.\n /// @dev Stores the shares of fees corresponding to the receiver that are not yet redeemed.\n mapping(address receiver => mapping(address asset => uint256 collectedFee)) public collectedFees;\n\n /// @dev Stores the shares of fees for each asset that are not yet redeemed.\n mapping(address asset => uint256 collectedFee) public collectedAssetFees;\n\n /// @dev This gap is used to prevent storage collisions.\n uint256[49] private __gap;\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* INITIALIZER */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Must be called by the initializer of the inheriting contract.\n /// @param _governance The address of the governance.\n /// @param _feeReceiver The address of the fee receiver.\n /// @param _polFeeCollector The address of the POL Fee Collector.\n function __VaultAdmin_init(\n address _governance,\n address _polFeeCollector,\n address _feeReceiver,\n address _beacon\n )\n internal\n onlyInitializing\n {\n __AccessControl_init();\n __Pausable_init();\n __UUPSUpgradeable_init();\n\n __VaultAdmin_init_unchained(_governance, _polFeeCollector, _feeReceiver, _beacon);\n // Allow the MANAGER role to manage the PAUSER role.\n // MANAGER role can grant and revoke access for the PAUSER role.\n _setRoleAdmin(PAUSER_ROLE, MANAGER_ROLE);\n }\n\n function __VaultAdmin_init_unchained(\n address _governance,\n address _polFeeCollector,\n address _feeReceiver,\n address _beacon\n )\n internal\n onlyInitializing\n {\n if (_governance == address(0)) ZeroAddress.selector.revertWith();\n if (_polFeeCollector == address(0)) ZeroAddress.selector.revertWith();\n if (_feeReceiver == address(0)) ZeroAddress.selector.revertWith();\n if (_beacon == address(0)) ZeroAddress.selector.revertWith();\n\n beacon = _beacon;\n _grantRole(DEFAULT_ADMIN_ROLE, _governance);\n\n feeReceiver = _feeReceiver;\n polFeeCollector = _polFeeCollector;\n emit FeeReceiverSet(_feeReceiver);\n emit POLFeeCollectorSet(_polFeeCollector);\n }\n\n /// @notice Check if the asset is registered.\n function _checkRegisteredAsset(address asset) internal view {\n if (address(vaults[asset]) == address(0)) {\n AssetNotRegistered.selector.revertWith(asset);\n }\n }\n\n /// @notice Check if the asset is not a bad collateral.\n function _checkGoodCollateralAsset(address asset) internal view {\n if (isBadCollateralAsset[asset]) {\n AssetIsBadCollateral.selector.revertWith(asset);\n }\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* ADMIN FUNCTIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n function _authorizeUpgrade(address newImplementation) internal virtual override {\n // Silent warning\n newImplementation;\n _checkRole(DEFAULT_ADMIN_ROLE);\n }\n\n /// @notice Pause the contract.\n /// @dev Only the PAUSER role can call this function.\n function pause() external {\n _checkRole(PAUSER_ROLE);\n _pause();\n }\n\n /// @notice Unpause the contract.\n /// @dev only the MANAGER role can call this function.\n function unpause() external {\n _checkRole(MANAGER_ROLE);\n _unpause();\n }\n\n /// @notice Pause the vault for a given asset.\n /// @dev Only the PAUSER role can call this function.\n /// @dev Only registered assets can be paused.\n /// @param asset The address of the asset.\n function pauseVault(address asset) external {\n _checkRole(PAUSER_ROLE);\n _checkRegisteredAsset(asset);\n CollateralVault(address(vaults[asset])).pause();\n }\n\n /// @notice Unpause the vault for a given asset.\n /// @dev Only the MANAGER role can call this function.\n /// @dev Only registered assets can be unpaused.\n /// @param asset The address of the asset.\n function unpauseVault(address asset) external {\n _checkRole(MANAGER_ROLE);\n _checkRegisteredAsset(asset);\n CollateralVault(address(vaults[asset])).unpause();\n }\n\n /// @notice Set the custody info for the vault.\n /// @dev Only the default admin role can call this function.\n /// @dev Only registered assets can be set as custody vault.\n /// @dev Checks on zero address and input are done in the vault.\n /// @param asset The address of the asset.\n /// @param isCustodyVault Whether the vault is a custody vault.\n /// @param custodyAddress The address of the custody.\n function setCustodyInfo(address asset, bool isCustodyVault, address custodyAddress) external {\n _checkRole(DEFAULT_ADMIN_ROLE);\n _checkRegisteredAsset(asset);\n vaults[asset].setCustodyInfo(isCustodyVault, custodyAddress);\n }\n\n function _createVault(address asset) internal returns (CollateralVault) {\n _checkRole(DEFAULT_ADMIN_ROLE);\n // Revert if the vault for the given asset is already registered.\n if (address(vaults[asset]) != address(0)) {\n VaultAlreadyRegistered.selector.revertWith(asset);\n }\n // Register the asset.\n registeredAssets.push(asset);\n\n // Use solady library to deploy deterministic beacon proxy.\n // NOTE: bits not part of the encoding of the address type cannot be assumed to be zero\n bytes32 salt;\n assembly (\"memory-safe\") {\n mstore(0, shr(96, shl(96, asset)))\n salt := keccak256(0, 0x20)\n }\n CollateralVault vault = CollateralVault(LibClone.deployDeterministicERC1967BeaconProxy(beacon, salt));\n vault.initialize(asset, address(this));\n\n vaults[asset] = vault;\n emit VaultCreated(address(vault), address(asset));\n return vault;\n }\n\n /// @notice Set the fee receiver address.\n /// @dev Only the default admin role can call this function.\n /// @dev Reverts if the fee receiver address is zero address.\n /// @dev Migrate any outstanding collected fee shares to the new receiver.\n /// @param _feeReceiver The address of the fee receiver.\n function setFeeReceiver(address _feeReceiver) external {\n _checkRole(DEFAULT_ADMIN_ROLE);\n if (_feeReceiver == address(0)) ZeroAddress.selector.revertWith();\n address oldFeeReceiver = feeReceiver;\n feeReceiver = _feeReceiver;\n emit FeeReceiverSet(_feeReceiver);\n\n // Migrate any outstanding fee shares to the new receiver to avoid stranding dust.\n // NOTE: Limited number of registered assets is assumed.\n for (uint256 i = 0; i < registeredAssets.length;) {\n address asset = registeredAssets[i];\n uint256 collectedFee = collectedFees[oldFeeReceiver][asset];\n\n if (collectedFee > 0) {\n collectedFees[oldFeeReceiver][asset] = 0;\n collectedFees[_feeReceiver][asset] += collectedFee;\n }\n unchecked {\n ++i;\n }\n }\n }\n\n /// @notice Set the POL Fee Collector address.\n /// @dev Only the default admin role can call this function.\n /// @dev Reverts if the POL Fee Collector address is zero address.\n /// @param _polFeeCollector The address of the POL Fee Collector.\n function setPOLFeeCollector(address _polFeeCollector) external {\n _checkRole(DEFAULT_ADMIN_ROLE);\n if (_polFeeCollector == address(0)) ZeroAddress.selector.revertWith();\n polFeeCollector = _polFeeCollector;\n emit POLFeeCollectorSet(_polFeeCollector);\n }\n\n /// @notice Set the bad collateral status of an asset.\n /// @dev Only the manager role can call this function.\n /// @dev Only registered assets can be set as bad collateral.\n /// @dev If set to true, minting will be disabled for the asset.\n /// @param asset The address of the asset.\n /// @param _isBadCollateral The status of the asset.\n function setCollateralAssetStatus(address asset, bool _isBadCollateral) external {\n _checkRole(MANAGER_ROLE);\n _checkRegisteredAsset(asset);\n\n isBadCollateralAsset[asset] = _isBadCollateral;\n emit CollateralAssetStatusSet(asset, _isBadCollateral);\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* FEE RELATED */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @notice Withdraw all the collected fees for a `receiver`.\n /// @dev It loops over all the registered assets and withdraws the collected fees.\n /// @dev Skips the assets whose vault is paused. If all the vaults are paused, transaction will do nothing.\n /// Caller is responsible for doing its own due diligence about the collaterals being paused.\n /// @param receiver The address of the receiver.\n function withdrawAllFees(address receiver) external {\n uint256 numAssets = numRegisteredAssets();\n for (uint256 i; i < numAssets;) {\n address asset = registeredAssets[i];\n // If the vault is paused, skip the asset.\n if (!vaults[asset].paused()) {\n _withdrawCollectedFee(asset, receiver);\n }\n unchecked {\n ++i;\n }\n }\n }\n\n /// @notice Withdraw the collected fees for a `receiver` for a specific `asset`.\n function withdrawFee(address asset, address receiver) external returns (uint256 assets) {\n _checkRegisteredAsset(asset);\n assets = _withdrawCollectedFee(asset, receiver);\n }\n\n /// @notice Internal function to withdraw the collected fees.\n /// @dev Redeems the shares from the vault and transfers the assets to the receiver.\n /// @param asset The address of the asset.\n /// @param receiver The address of the receiver.\n /// @return assets The amount of assets redeemed.\n function _withdrawCollectedFee(address asset, address receiver) internal returns (uint256 assets) {\n uint256 shares = collectedFees[receiver][asset];\n\n if (vaults[asset].convertToAssets(shares) == 0) {\n return 0;\n }\n\n collectedFees[receiver][asset] = 0;\n // All the shares refer to the receiver and the assets are transferred to the receiver.\n // This subtraction is safe because of they are counted in the same function.\n collectedAssetFees[asset] -= shares;\n\n assets = vaults[asset].redeem(shares, receiver, address(this));\n emit CollectedFeeWithdrawn(asset, receiver, shares, assets);\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* GETTERS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @notice Get the length of `registeredAssets` array.\n function numRegisteredAssets() public view returns (uint256) {\n return registeredAssets.length;\n }\n\n function _lookupRegistrationIndex(address asset) internal view returns (uint256 index) {\n for (uint256 i = 0; i < registeredAssets.length; i++) {\n if (registeredAssets[i] == asset) {\n return i;\n }\n }\n }\n}\n"},"src/libraries/Utils.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\n// solhint-disable-next-line compiler-version\npragma solidity 0.8.26;\n\nimport { SafeTransferLib } from \"solady/src/utils/SafeTransferLib.sol\";\n\nlibrary Utils {\n using SafeTransferLib for address;\n\n /// @notice The gas limit for a transfer, used to prevent malicious token griefing.\n uint32 constant TRANSFER_GAS_LIMIT = 500_000;\n\n /// @notice Error for overflow when increasing allowance\n error IncreaseAllowanceOverflow();\n\n /// @dev Reverts with the selector of a custom error in the scratch space.\n function revertWith(bytes4 selector) internal pure {\n assembly (\"memory-safe\") {\n mstore(0, selector)\n revert(0, 0x04)\n }\n }\n\n /// @dev Reverts for the reason encoding a silent revert, Error(string), or a custom error.\n function revertFor(bytes memory reason) internal pure {\n assembly (\"memory-safe\") {\n revert(add(reason, 0x20), mload(reason))\n }\n }\n\n function revertWith(bytes4 selector, address addr) internal pure {\n assembly (\"memory-safe\") {\n mstore(0, selector)\n mstore(0x04, addr)\n revert(0, 0x24) // 4 (selector) + 32 (addr)\n }\n }\n\n function revertWith(bytes4 selector, uint256 amount) internal pure {\n assembly (\"memory-safe\") {\n mstore(0, selector)\n mstore(0x04, amount)\n revert(0, 0x24) // 4 (selector) + 32 (amount)\n }\n }\n\n function revertWith(bytes4 selector, uint256 amount1, uint256 amount2) internal pure {\n assembly (\"memory-safe\") {\n mstore(0, selector)\n mstore(0x04, amount1)\n mstore(0x24, amount2)\n revert(0, 0x44) // 4 (selector) + 32 (amount1) + 32 (amount2)\n }\n }\n\n function revertWith(bytes4 selector, address addr1, address addr2) internal pure {\n assembly (\"memory-safe\") {\n mstore(0, selector)\n mstore(0x04, addr1)\n mstore(0x24, addr2)\n revert(0, 0x44) // 4 (selector) + 32 (addr1) + 32 (addr2)\n }\n }\n\n /// @dev Increase the calling contract's allowance toward `spender` by `amount`.\n /// @dev Does not check if token exists.\n function safeIncreaseAllowance(address token, address spender, uint256 amount) internal {\n unchecked {\n uint256 oldAllowance = allowance(token, address(this), spender);\n uint256 newAllowance = oldAllowance + amount;\n if (newAllowance < oldAllowance) revertWith(IncreaseAllowanceOverflow.selector);\n token.safeApprove(spender, newAllowance);\n }\n }\n\n /// @dev Returns the amount of ERC20 `token` that `owner` has allowed `spender` to use.\n /// Returns zero if the `token` does not exist.\n function allowance(address token, address owner, address spender) internal view returns (uint256 amount) {\n assembly (\"memory-safe\") {\n mstore(0, 0xdd62ed3e00000000000000000000000000000000000000000000000000000000) // Store function selector of\n // `allowance(address,address)`.\n mstore(0x04, owner) // Store the `owner` argument.\n mstore(0x24, spender) // Store the `spender` argument.\n amount := mul( // The arguments of `mul` are evaluated from right to left.\n mload(0),\n and( // The arguments of `and` are evaluated from right to left.\n gt(returndatasize(), 0x1f), // At least 32 bytes returned.\n staticcall(gas(), token, 0, 0x44, 0, 0x20)\n )\n )\n mstore(0x24, 0) // clear the upper bits of free memory pointer.\n }\n }\n\n /// @dev Sends `amount` of ERC20 `token` from the current contract to `to`.\n /// Doesn't revert upon failure.\n function trySafeTransfer(address token, address to, uint256 amount) internal returns (bool success) {\n assembly (\"memory-safe\") {\n mstore(0x14, to) // Store the `to` argument.\n mstore(0x34, amount) // Store the `amount` argument.\n mstore(0x00, 0xa9059cbb000000000000000000000000) // `transfer(address,uint256)` function selector.\n\n // Perform the transfer, returning success status.\n success := and(\n or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.\n call(TRANSFER_GAS_LIMIT, token, 0, 0x10, 0x44, 0x00, 0x20)\n )\n\n mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.\n }\n }\n\n function changeDecimals(uint256 amount, uint8 from, uint8 to) internal pure returns (uint256) {\n if (from == to) {\n return amount;\n }\n if (from > to) {\n return amount / (10 ** (from - to));\n } else {\n return amount * (10 ** (to - from));\n }\n }\n}\n"}},"matchId":"43389024","creationMatch":"match","runtimeMatch":"match","verifiedAt":"2026-08-07T17:52:56Z","match":"match","chainId":"80094","address":"0xB587F98c81c37432067060196aC1DdAEC106ED8D"}