{"compiler":{"version":"0.8.23+commit.f704f362"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address","name":"addressProvider_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"caller","type":"address"}],"name":"CallerIsNotMarketConfiguratorException","type":"error"},{"inputs":[{"internalType":"bytes4","name":"selector","type":"bytes4"}],"name":"ForbiddenConfigurationCallException","type":"error"},{"inputs":[{"internalType":"bytes4","name":"selector","type":"bytes4"}],"name":"ForbiddenEmergencyConfigurationCallException","type":"error"},{"inputs":[],"name":"InvalidConstructorParamsException","type":"error"},{"inputs":[],"name":"addressProvider","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bytecodeRepository","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pool","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"}],"name":"configure","outputs":[{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct Call[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"contractType","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pool","type":"address"},{"components":[{"internalType":"bytes32","name":"postfix","type":"bytes32"},{"internalType":"bytes32","name":"salt","type":"bytes32"},{"internalType":"bytes","name":"constructorParams","type":"bytes"}],"internalType":"struct DeployParams","name":"params","type":"tuple"}],"name":"deployRateKeeper","outputs":[{"components":[{"internalType":"address","name":"newContract","type":"address"},{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct Call[]","name":"onInstallOps","type":"tuple[]"}],"internalType":"struct DeployResult","name":"","type":"tuple"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"}],"name":"emergencyConfigure","outputs":[{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct Call[]","name":"","type":"tuple[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"gearStaking","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"marketConfiguratorFactory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pool","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"onAddToken","outputs":[{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct Call[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"onCreateCreditSuite","outputs":[{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct Call[]","name":"","type":"tuple[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"rateKeeper","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"onCreateMarket","outputs":[{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct Call[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"onShutdownCreditSuite","outputs":[{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct Call[]","name":"","type":"tuple[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"pool","type":"address"}],"name":"onShutdownMarket","outputs":[{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct Call[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"onUpdateInterestRateModel","outputs":[{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct Call[]","name":"","type":"tuple[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"onUpdateLossPolicy","outputs":[{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct Call[]","name":"","type":"tuple[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"onUpdatePriceOracle","outputs":[{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct Call[]","name":"","type":"tuple[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"pool","type":"address"},{"internalType":"address","name":"newRateKeeper","type":"address"},{"internalType":"address","name":"oldRateKeeper","type":"address"}],"name":"onUpdateRateKeeper","outputs":[{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct Call[]","name":"calls","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"version","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{"contractType()":{"notice":"Contract type"},"version()":{"notice":"Contract version"}},"version":1}},"settings":{"compilationTarget":{"contracts/factories/RateKeeperFactory.sol":"RateKeeperFactory"},"evmVersion":"shanghai","libraries":{},"metadata":{"bytecodeHash":"none","useLiteralContent":true},"optimizer":{"enabled":true,"runs":1000},"remappings":[":@1inch/=lib/@1inch/",":@gearbox-protocol/=lib/@gearbox-protocol/",":@openzeppelin/=lib/@openzeppelin/",":@redstone-finance/=node_modules/@redstone-finance/",":@solady/=lib/@solady/src/",":ds-test/=lib/forge-std/lib/ds-test/src/",":erc4626-tests/=lib/@openzeppelin/lib/erc4626-tests/",":forge-std/=lib/forge-std/src/",":openzeppelin/=lib/@openzeppelin/contracts/"]},"sources":{"contracts/factories/AbstractFactory.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2025.\npragma solidity ^0.8.23;\n\nimport {IFactory} from \"../interfaces/factories/IFactory.sol\";\nimport {IMarketConfigurator} from \"../interfaces/IMarketConfigurator.sol\";\nimport {IMarketConfiguratorFactory} from \"../interfaces/IMarketConfiguratorFactory.sol\";\nimport {Call} from \"../interfaces/Types.sol\";\n\nimport {AP_MARKET_CONFIGURATOR_FACTORY, NO_VERSION_CONTROL} from \"../libraries/ContractLiterals.sol\";\n\nimport {DeployerTrait} from \"../traits/DeployerTrait.sol\";\n\nabstract contract AbstractFactory is DeployerTrait, IFactory {\n address public immutable override marketConfiguratorFactory;\n\n modifier onlyMarketConfigurators() {\n _ensureCallerIsMarketConfigurator();\n _;\n }\n\n constructor(address addressProvider_) DeployerTrait(addressProvider_) {\n marketConfiguratorFactory = _getAddressOrRevert(AP_MARKET_CONFIGURATOR_FACTORY, NO_VERSION_CONTROL);\n }\n\n // ------------- //\n // CONFIGURATION //\n // ------------- //\n\n function configure(address, bytes calldata callData) external virtual override returns (Call[] memory) {\n revert ForbiddenConfigurationCallException(bytes4(callData));\n }\n\n function emergencyConfigure(address, bytes calldata callData) external virtual override returns (Call[] memory) {\n revert ForbiddenEmergencyConfigurationCallException(bytes4(callData));\n }\n\n // --------- //\n // INTERNALS //\n // --------- //\n\n function _ensureCallerIsMarketConfigurator() internal view {\n if (!IMarketConfiguratorFactory(marketConfiguratorFactory).isMarketConfigurator(msg.sender)) {\n revert CallerIsNotMarketConfiguratorException(msg.sender);\n }\n }\n\n function _authorizeFactory(address marketConfigurator, address suite, address target)\n internal\n view\n returns (Call memory)\n {\n return Call({\n target: marketConfigurator,\n callData: abi.encodeCall(IMarketConfigurator.authorizeFactory, (address(this), suite, target))\n });\n }\n\n function _unauthorizeFactory(address marketConfigurator, address suite, address target)\n internal\n view\n returns (Call memory)\n {\n return Call({\n target: marketConfigurator,\n callData: abi.encodeCall(IMarketConfigurator.unauthorizeFactory, (address(this), suite, target))\n });\n }\n}\n","keccak256":"0x5c46e9dc6a4c94c66cde4f2c0068c57373b7cff56166acfc3a0eb8d73a70f3b7","license":"BUSL-1.1"},"contracts/factories/AbstractMarketFactory.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2025.\npragma solidity ^0.8.23;\n\nimport {Ownable} from \"@openzeppelin/contracts/access/Ownable.sol\";\nimport {IPoolQuotaKeeperV3} from \"@gearbox-protocol/core-v3/contracts/interfaces/IPoolQuotaKeeperV3.sol\";\nimport {IPoolV3} from \"@gearbox-protocol/core-v3/contracts/interfaces/IPoolV3.sol\";\nimport {IMarketFactory} from \"../interfaces/factories/IMarketFactory.sol\";\nimport {IContractsRegister} from \"../interfaces/IContractsRegister.sol\";\nimport {IMarketConfigurator} from \"../interfaces/IMarketConfigurator.sol\";\nimport {Call} from \"../interfaces/Types.sol\";\nimport {AbstractFactory} from \"./AbstractFactory.sol\";\n\nabstract contract AbstractMarketFactory is AbstractFactory, IMarketFactory {\n // ------------ //\n // MARKET HOOKS //\n // ------------ //\n\n function onCreateMarket(address, address, address, address, address, address)\n external\n virtual\n override\n returns (Call[] memory)\n {}\n\n function onShutdownMarket(address) external virtual override returns (Call[] memory) {}\n\n function onCreateCreditSuite(address) external virtual override returns (Call[] memory) {}\n\n function onShutdownCreditSuite(address) external virtual override returns (Call[] memory) {}\n\n function onUpdatePriceOracle(address, address, address) external virtual override returns (Call[] memory) {}\n\n function onUpdateInterestRateModel(address, address, address) external virtual override returns (Call[] memory) {}\n\n function onUpdateRateKeeper(address, address, address) external virtual override returns (Call[] memory) {}\n\n function onUpdateLossPolicy(address, address, address) external virtual override returns (Call[] memory) {}\n\n function onAddToken(address, address, address) external virtual override returns (Call[] memory) {}\n\n // --------- //\n // INTERNALS //\n // --------- //\n\n function _validateDefaultConstructorParams(address pool, bytes calldata constructorParams) internal view {\n (address decodedPool, address decodedAddressProvider) = abi.decode(constructorParams[:64], (address, address));\n if (decodedPool != pool || decodedAddressProvider != addressProvider) {\n revert InvalidConstructorParamsException();\n }\n }\n\n function _marketConfigurator(address pool) internal view returns (address) {\n return Ownable(IPoolV3(pool).acl()).owner();\n }\n\n function _contractsRegister(address pool) internal view returns (address) {\n return IMarketConfigurator(_marketConfigurator(pool)).contractsRegister();\n }\n\n function _underlying(address pool) internal view returns (address) {\n return IPoolV3(pool).asset();\n }\n\n function _quotaKeeper(address pool) internal view returns (address) {\n return IPoolV3(pool).poolQuotaKeeper();\n }\n\n function _interestRateModel(address pool) internal view returns (address) {\n return IPoolV3(pool).interestRateModel();\n }\n\n function _priceOracle(address pool) internal view returns (address) {\n return IContractsRegister(_contractsRegister(pool)).getPriceOracle(pool);\n }\n\n function _lossPolicy(address pool) internal view returns (address) {\n return IContractsRegister(_contractsRegister(pool)).getLossPolicy(pool);\n }\n\n function _rateKeeper(address quotaKeeper) internal view returns (address) {\n return IPoolQuotaKeeperV3(quotaKeeper).gauge();\n }\n\n function _quotedTokens(address quotaKeeper) internal view returns (address[] memory) {\n return IPoolQuotaKeeperV3(quotaKeeper).quotedTokens();\n }\n\n function _isQuotedToken(address quotaKeeper, address token) internal view returns (bool) {\n return IPoolQuotaKeeperV3(quotaKeeper).isQuotedToken(token);\n }\n\n function _quota(address quotaKeeper, address token) internal view returns (uint96 quota) {\n (,,, quota,,) = IPoolQuotaKeeperV3(quotaKeeper).getTokenQuotaParams(token);\n }\n}\n","keccak256":"0xdee1d0494be57e74e282c5164854cda52fb03bb45a593ef287fd4c6622591f60","license":"BUSL-1.1"},"contracts/factories/RateKeeperFactory.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2025.\npragma solidity ^0.8.23;\n\nimport {IRateKeeper} from \"@gearbox-protocol/core-v3/contracts/interfaces/base/IRateKeeper.sol\";\nimport {IGaugeV3} from \"@gearbox-protocol/core-v3/contracts/interfaces/IGaugeV3.sol\";\n\nimport {IFactory} from \"../interfaces/factories/IFactory.sol\";\nimport {IMarketFactory} from \"../interfaces/factories/IMarketFactory.sol\";\nimport {IRateKeeperFactory} from \"../interfaces/factories/IRateKeeperFactory.sol\";\nimport {Call, DeployParams, DeployResult} from \"../interfaces/Types.sol\";\n\nimport {CallBuilder} from \"../libraries/CallBuilder.sol\";\nimport {\n DOMAIN_RATE_KEEPER,\n AP_RATE_KEEPER_FACTORY,\n NO_VERSION_CONTROL,\n AP_GEAR_STAKING\n} from \"../libraries/ContractLiterals.sol\";\n\nimport {AbstractFactory} from \"./AbstractFactory.sol\";\nimport {AbstractMarketFactory} from \"./AbstractMarketFactory.sol\";\n\ncontract RateKeeperFactory is AbstractMarketFactory, IRateKeeperFactory {\n using CallBuilder for Call[];\n\n uint256 public constant override version = 3_11;\n bytes32 public constant override contractType = AP_RATE_KEEPER_FACTORY;\n\n address public immutable gearStaking;\n\n constructor(address addressProvider_) AbstractFactory(addressProvider_) {\n gearStaking = _getAddressOrRevert(AP_GEAR_STAKING, NO_VERSION_CONTROL);\n }\n\n // ---------- //\n // DEPLOYMENT //\n // ---------- //\n\n function deployRateKeeper(address pool, DeployParams calldata params)\n external\n override\n onlyMarketConfigurators\n returns (DeployResult memory)\n {\n if (params.postfix == \"GAUGE\") {\n (address decodedPool, address decodedGearStaking) = abi.decode(params.constructorParams, (address, address));\n if (decodedPool != pool || decodedGearStaking != gearStaking) revert InvalidConstructorParamsException();\n } else if (params.postfix == \"TUMBLER\") {\n (address decodedPool,) = abi.decode(params.constructorParams, (address, uint256));\n if (decodedPool != pool) revert InvalidConstructorParamsException();\n } else {\n _validateDefaultConstructorParams(pool, params.constructorParams);\n }\n\n bytes32 contractType_ = _getContractType(DOMAIN_RATE_KEEPER, params.postfix);\n address rateKeeper = _deployLatestPatch({\n contractType: contractType_,\n minorVersion: version,\n constructorParams: params.constructorParams,\n salt: keccak256(abi.encode(params.salt, msg.sender))\n });\n\n address[] memory tokens = _quotedTokens(_quotaKeeper(pool));\n uint256 numTokens = tokens.length;\n Call[] memory onInstallOps = new Call[](1 + numTokens);\n onInstallOps[0] = _authorizeFactory(msg.sender, pool, rateKeeper);\n for (uint256 i; i < numTokens; ++i) {\n onInstallOps[i + 1] = _addToken(rateKeeper, tokens[i], contractType_);\n }\n\n return DeployResult({newContract: rateKeeper, onInstallOps: onInstallOps});\n }\n\n // ------------ //\n // MARKET HOOKS //\n // ------------ //\n\n function onCreateMarket(address, address, address, address rateKeeper, address, address)\n external\n view\n override(AbstractMarketFactory, IMarketFactory)\n returns (Call[] memory)\n {\n if (_getRateKeeperType(rateKeeper) == \"RATE_KEEPER::GAUGE\") {\n return CallBuilder.build(_setFrozenEpoch(rateKeeper, false));\n }\n return CallBuilder.build();\n }\n\n function onShutdownMarket(address pool)\n external\n view\n override(AbstractMarketFactory, IMarketFactory)\n returns (Call[] memory)\n {\n address rateKeeper = _rateKeeper(_quotaKeeper(pool));\n if (_getRateKeeperType(rateKeeper) == \"RATE_KEEPER::GAUGE\") {\n return CallBuilder.build(_setFrozenEpoch(rateKeeper, true));\n }\n return CallBuilder.build();\n }\n\n function onUpdateRateKeeper(address pool, address newRateKeeper, address oldRateKeeper)\n external\n view\n override(AbstractMarketFactory, IMarketFactory)\n returns (Call[] memory calls)\n {\n if (_getRateKeeperType(oldRateKeeper) == \"RATE_KEEPER::GAUGE\") {\n calls = calls.append(_setFrozenEpoch(oldRateKeeper, true));\n }\n if (_getRateKeeperType(newRateKeeper) == \"RATE_KEEPER::GAUGE\") {\n calls = calls.append(_setFrozenEpoch(newRateKeeper, false));\n }\n calls = calls.append(_unauthorizeFactory(msg.sender, pool, oldRateKeeper));\n }\n\n function onAddToken(address pool, address token, address)\n external\n view\n override(AbstractMarketFactory, IMarketFactory)\n returns (Call[] memory)\n {\n address rateKeeper = _rateKeeper(_quotaKeeper(pool));\n return CallBuilder.build(_addToken(rateKeeper, token, _getRateKeeperType(rateKeeper)));\n }\n\n // ------------- //\n // CONFIGURATION //\n // ------------- //\n\n function configure(address pool, bytes calldata callData)\n external\n view\n override(AbstractFactory, IFactory)\n returns (Call[] memory)\n {\n address rateKeeper = _rateKeeper(_quotaKeeper(pool));\n bytes4 selector = bytes4(callData);\n if (_isForbiddenConfigurationCall(rateKeeper, selector)) revert ForbiddenConfigurationCallException(selector);\n return CallBuilder.build(Call(rateKeeper, callData));\n }\n\n // --------- //\n // INTERNALS //\n // --------- //\n\n function _getRateKeeperType(address rateKeeper) internal view returns (bytes32) {\n try IRateKeeper(rateKeeper).contractType() returns (bytes32 type_) {\n return type_;\n } catch {\n return \"RATE_KEEPER::GAUGE\";\n }\n }\n\n function _isForbiddenConfigurationCall(address rateKeeper, bytes4 selector) internal view returns (bool) {\n if (_getRateKeeperType(rateKeeper) == \"RATE_KEEPER::GAUGE\") {\n return selector == IRateKeeper.addToken.selector || selector == IGaugeV3.addQuotaToken.selector\n || selector == IGaugeV3.setFrozenEpoch.selector || selector == bytes4(keccak256(\"setController(address)\"));\n }\n return selector == IRateKeeper.addToken.selector;\n }\n\n function _addToken(address rateKeeper, address token, bytes32 type_) internal pure returns (Call memory) {\n return Call(\n rateKeeper,\n type_ == \"RATE_KEEPER::GAUGE\"\n ? abi.encodeCall(IGaugeV3.addQuotaToken, (token, 1, 1))\n : abi.encodeCall(IRateKeeper.addToken, token)\n );\n }\n\n function _setFrozenEpoch(address gauge, bool status) internal pure returns (Call memory) {\n return Call(gauge, abi.encodeCall(IGaugeV3.setFrozenEpoch, status));\n }\n}\n","keccak256":"0x5eccae70dd473cc9c92442a2edcecdfc595ce454b651d7ccbe2116d1a50fbdfc","license":"BUSL-1.1"},"contracts/interfaces/IAddressProvider.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2025.\npragma solidity ^0.8.23;\n\nimport {IAddressProvider as IAddressProviderBase} from\n \"@gearbox-protocol/core-v3/contracts/interfaces/base/IAddressProvider.sol\";\nimport {IVersion} from \"@gearbox-protocol/core-v3/contracts/interfaces/base/IVersion.sol\";\nimport {IImmutableOwnableTrait} from \"./base/IImmutableOwnableTrait.sol\";\nimport {AddressProviderEntry} from \"./Types.sol\";\n\n/// @title Address provider interface\ninterface IAddressProvider is IAddressProviderBase, IVersion, IImmutableOwnableTrait {\n // ------ //\n // EVENTS //\n // ------ //\n\n event SetAddress(bytes32 indexed key, uint256 indexed ver, address indexed value);\n\n // ------ //\n // ERRORS //\n // ------ //\n\n error AddressNotFoundException(bytes32 key, uint256 ver);\n error InvalidVersionException(bytes32 key, uint256 ver);\n error VersionNotFoundException(bytes32 key);\n error ZeroAddressException(bytes32 key);\n\n // ------- //\n // GETTERS //\n // ------- //\n\n function getAddress(bytes32 key, uint256 ver) external view returns (address);\n function getAddressOrRevert(bytes32 key, uint256 ver) external view override returns (address);\n function getKeys() external view returns (bytes32[] memory);\n function getVersions(bytes32 key) external view returns (uint256[] memory);\n function getAllEntries() external view returns (AddressProviderEntry[] memory);\n function getLatestVersion(bytes32 key) external view returns (uint256);\n function getLatestMinorVersion(bytes32 key, uint256 majorVersion) external view returns (uint256);\n function getLatestPatchVersion(bytes32 key, uint256 minorVersion) external view returns (uint256);\n\n // ------------- //\n // CONFIGURATION //\n // ------------- //\n\n function setAddress(bytes32 key, address value, bool saveVersion) external;\n}\n","keccak256":"0x725f19bfff37ca840f5bb995040b70cabb6034b4cc86401c6aca1c04056acacc","license":"MIT"},"contracts/interfaces/IBytecodeRepository.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2025.\npragma solidity ^0.8.23;\n\nimport {IVersion} from \"@gearbox-protocol/core-v3/contracts/interfaces/base/IVersion.sol\";\nimport {IImmutableOwnableTrait} from \"./base/IImmutableOwnableTrait.sol\";\nimport {AuditReport, Bytecode} from \"./Types.sol\";\n\n/// @title Bytecode repository interface\ninterface IBytecodeRepository is IVersion, IImmutableOwnableTrait {\n // ------ //\n // EVENTS //\n // ------ //\n\n event AddAuditor(address indexed auditor, string name);\n event AddPublicDomain(bytes32 indexed domain);\n event AddSystemDomain(bytes32 indexed domain);\n event AllowContract(bytes32 indexed bytecodeHash, bytes32 indexed contractType, uint256 indexed version);\n event AuditBytecode(bytes32 indexed bytecodeHash, address indexed auditor, string reportUrl, bytes signature);\n event DeployContract(\n bytes32 indexed bytecodeHash,\n bytes32 indexed contractType,\n uint256 indexed version,\n address contractAddress,\n bytes constructorParams\n );\n event ForbidContract(bytes32 indexed bytecodeHash, bytes32 indexed contractType, uint256 indexed version);\n event ForbidInitCode(bytes32 indexed initCodeHash);\n event RemoveAuditor(address indexed auditor);\n event RemoveContractTypeOwner(bytes32 indexed contractType);\n event SetContractTypeOwner(bytes32 indexed contractType, address indexed owner);\n event SetTokenSpecificPostfix(address indexed token, bytes32 indexed postfix);\n event UploadBytecode(\n bytes32 indexed bytecodeHash,\n bytes32 indexed contractType,\n uint256 indexed version,\n address author,\n string source,\n bytes signature\n );\n\n // ------ //\n // ERRORS //\n // ------ //\n\n error AuditorIsNotApprovedException(address auditor);\n error AuthorIsNotContractTypeOwnerException(bytes32 contractType, address author);\n error BytecodeIsAlreadyAllowedException(bytes32 contractType, uint256 version);\n error BytecodeIsAlreadySignedByAuditorException(bytes32 bytecodeHash, address auditor);\n error BytecodeIsNotAllowedException(bytes32 contractType, uint256 version);\n error BytecodeIsNotAuditedException(bytes32 bytecodeHash);\n error BytecodeIsNotUploadedException(bytes32 bytecodeHash);\n error CallerIsNotBytecodeAuthorException(address caller);\n error ContractIsAlreadyDeployedException(address deployedContract);\n error ContractTypeIsNotInPublicDomainException(bytes32 contractType);\n error DomainIsAlreadyMarkedAsPublicException(bytes32 domain);\n error DomainIsAlreadyMarkedAsSystemException(bytes32 domain);\n error InitCodeIsEmptyException();\n error InitCodeIsForbiddenException(bytes32 initCodeHash);\n error InvalidAuditorSignatureException(address auditor);\n error InvalidAuthorSignatureException(address author);\n error InvalidBytecodeException(bytes32 bytecodeHash);\n error InvalidContractTypeException(bytes32 contractType);\n error InvalidDomainException(bytes32 domain);\n error InvalidPostfixException(bytes32 postfix);\n error InvalidVersionException(bytes32 contractType, uint256 version);\n error VersionNotFoundException(bytes32 contractType);\n\n // --------------- //\n // EIP-712 GETTERS //\n // --------------- //\n\n function BYTECODE_TYPEHASH() external view returns (bytes32);\n function AUDIT_REPORT_TYPEHASH() external view returns (bytes32);\n function domainSeparatorV4() external view returns (bytes32);\n function computeBytecodeHash(Bytecode calldata bytecode) external view returns (bytes32);\n function computeAuditReportHash(bytes32 bytecodeHash, AuditReport calldata report)\n external\n view\n returns (bytes32);\n\n // ------------------- //\n // DEPLOYING CONTRACTS //\n // ------------------- //\n\n function isDeployedFromRepository(address deployedContract) external view returns (bool);\n function getDeployedContractBytecodeHash(address deployedContract) external view returns (bytes32);\n function computeAddress(\n bytes32 contractType,\n uint256 version,\n bytes calldata constructorParams,\n bytes32 salt,\n address deployer\n ) external view returns (address);\n function deploy(bytes32 contractType, uint256 version, bytes calldata constructorParams, bytes32 salt)\n external\n returns (address);\n\n // ------------------ //\n // UPLOADING BYTECODE //\n // ------------------ //\n\n function getBytecode(bytes32 bytecodeHash) external view returns (Bytecode memory);\n function isBytecodeUploaded(bytes32 bytecodeHash) external view returns (bool);\n function uploadBytecode(Bytecode calldata bytecode) external;\n\n // ----------------- //\n // AUDITING BYTECODE //\n // ----------------- //\n\n function isBytecodeAudited(bytes32 bytecodeHash) external view returns (bool);\n function getAuditReports(bytes32 bytecodeHash) external view returns (AuditReport[] memory);\n function getAuditReport(bytes32 bytecodeHash, uint256 index) external view returns (AuditReport memory);\n function getNumAuditReports(bytes32 bytecodeHash) external view returns (uint256);\n function submitAuditReport(bytes32 bytecodeHash, AuditReport calldata auditReport) external;\n\n // ----------------- //\n // ALLOWING BYTECODE //\n // ----------------- //\n\n function getAllowedBytecodeHash(bytes32 contractType, uint256 version) external view returns (bytes32);\n function getContractTypeOwner(bytes32 contractType) external view returns (address);\n function allowSystemContract(bytes32 bytecodeHash) external;\n function allowPublicContract(bytes32 bytecodeHash) external;\n function removePublicContractType(bytes32 contractType) external;\n\n // ------------------ //\n // DOMAINS MANAGEMENT //\n // ------------------ //\n\n function isSystemDomain(bytes32 domain) external view returns (bool);\n function getSystemDomains() external view returns (bytes32[] memory);\n function isPublicDomain(bytes32 domain) external view returns (bool);\n function getPublicDomains() external view returns (bytes32[] memory);\n function addPublicDomain(bytes32 domain) external;\n\n // ------------------- //\n // AUDITORS MANAGEMENT //\n // ------------------- //\n\n function isAuditor(address auditor) external view returns (bool);\n function getAuditors() external view returns (address[] memory);\n function getAuditorName(address auditor) external view returns (string memory);\n function addAuditor(address auditor, string calldata name) external;\n function removeAuditor(address auditor) external;\n\n // -------------------- //\n // FORBIDDING INIT CODE //\n // -------------------- //\n\n function isInitCodeForbidden(bytes32 initCodeHash) external view returns (bool);\n function forbidInitCode(bytes32 initCodeHash) external;\n\n // ------------------------ //\n // TOKENS WITH CUSTOM LOGIC //\n // ------------------------ //\n\n function getTokenSpecificPostfix(address token) external view returns (bytes32);\n function setTokenSpecificPostfix(address token, bytes32 postfix) external;\n\n // --------------- //\n // VERSION CONTROL //\n // --------------- //\n\n function getVersions(bytes32 contractType) external view returns (uint256[] memory);\n function getLatestVersion(bytes32 contractType) external view returns (uint256);\n function getLatestMinorVersion(bytes32 contractType, uint256 majorVersion) external view returns (uint256);\n function getLatestPatchVersion(bytes32 contractType, uint256 minorVersion) external view returns (uint256);\n}\n","keccak256":"0xad0bb39553e832d0f8e75f6a8140e9581b311078a968695e6e70988f65f4d03b","license":"MIT"},"contracts/interfaces/IContractsRegister.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2025.\npragma solidity ^0.8.23;\n\nimport {IACLTrait} from \"@gearbox-protocol/core-v3/contracts/interfaces/base/IACLTrait.sol\";\nimport {IContractsRegister as IContractsRegisterBase} from\n \"@gearbox-protocol/core-v3/contracts/interfaces/base/IContractsRegister.sol\";\nimport {IVersion} from \"@gearbox-protocol/core-v3/contracts/interfaces/base/IVersion.sol\";\n\ninterface IContractsRegister is IContractsRegisterBase, IVersion, IACLTrait {\n // ------ //\n // EVENTS //\n // ------ //\n\n event RegisterMarket(address indexed pool, address indexed priceOracle, address indexed lossPolicy);\n event ShutdownMarket(address indexed pool);\n event RegisterCreditSuite(address indexed pool, address indexed creditManager);\n event ShutdownCreditSuite(address indexed pool, address indexed creditManager);\n event SetPriceOracle(address indexed pool, address indexed priceOracle);\n event SetLossPolicy(address indexed pool, address indexed lossPolicy);\n\n // ------ //\n // ERRORS //\n // ------ //\n\n error MarketNotRegisteredException(address pool);\n error MarketShutDownException(address pool);\n error MarketNotEmptyException(address pool);\n error CreditSuiteNotRegisteredException(address creditManager);\n error CreditSuiteShutDownException(address creditManager);\n\n // ------- //\n // MARKETS //\n // ------- //\n\n function getShutdownPools() external view returns (address[] memory);\n function getPriceOracle(address pool) external view returns (address);\n function getLossPolicy(address pool) external view returns (address);\n\n function registerMarket(address pool, address priceOracle, address lossPolicy) external;\n function shutdownMarket(address pool) external;\n function setPriceOracle(address pool, address priceOracle) external;\n function setLossPolicy(address pool, address lossPolicy) external;\n\n // ------------- //\n // CREDIT SUITES //\n // ------------- //\n\n function getCreditManagers(address pool) external view returns (address[] memory);\n function getShutdownCreditManagers() external view returns (address[] memory);\n function getShutdownCreditManagers(address pool) external view returns (address[] memory);\n\n function registerCreditSuite(address creditManager) external;\n function shutdownCreditSuite(address creditManager) external;\n}\n","keccak256":"0xc8f2c626169e54517e2912a528c0d560c865e938db718995af483fae31cb82b2","license":"MIT"},"contracts/interfaces/IMarketConfigurator.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2025.\npragma solidity ^0.8.23;\n\nimport {IVersion} from \"@gearbox-protocol/core-v3/contracts/interfaces/base/IVersion.sol\";\nimport {IDeployerTrait} from \"./base/IDeployerTrait.sol\";\nimport {Call, DeployParams, MarketFactories} from \"./Types.sol\";\n\ninterface IMarketConfigurator is IVersion, IDeployerTrait {\n // ------ //\n // EVENTS //\n // ------ //\n\n event SetEmergencyAdmin(address indexed newEmergencyAdmin);\n\n event GrantRole(bytes32 indexed role, address indexed account);\n\n event RevokeRole(bytes32 indexed role, address indexed account);\n\n event EmergencyRevokeRole(bytes32 indexed role, address indexed account);\n\n event CreateMarket(\n address indexed pool,\n address priceOracle,\n address interestRateModel,\n address rateKeeper,\n address lossPolicy,\n MarketFactories factories\n );\n\n event ShutdownMarket(address indexed pool);\n\n event AddToken(address indexed pool, address indexed token);\n\n event ConfigurePool(address indexed pool, bytes data);\n\n event EmergencyConfigurePool(address indexed pool, bytes data);\n\n event CreateCreditSuite(address indexed creditManager, address factory);\n\n event ShutdownCreditSuite(address indexed creditManager);\n\n event ConfigureCreditSuite(address indexed creditManager, bytes data);\n\n event EmergencyConfigureCreditSuite(address indexed creditManager, bytes data);\n\n event UpdatePriceOracle(address indexed pool, address priceOracle);\n\n event ConfigurePriceOracle(address indexed pool, bytes data);\n\n event EmergencyConfigurePriceOracle(address indexed pool, bytes data);\n\n event UpdateInterestRateModel(address indexed pool, address interestRateModel);\n\n event ConfigureInterestRateModel(address indexed pool, bytes data);\n\n event EmergencyConfigureInterestRateModel(address indexed pool, bytes data);\n\n event UpdateRateKeeper(address indexed pool, address rateKeeper);\n\n event ConfigureRateKeeper(address indexed pool, bytes data);\n\n event EmergencyConfigureRateKeeper(address indexed pool, bytes data);\n\n event UpdateLossPolicy(address indexed pool, address lossPolicy);\n\n event ConfigureLossPolicy(address indexed pool, bytes data);\n\n event EmergencyConfigureLossPolicy(address indexed pool, bytes data);\n\n event AddPeripheryContract(bytes32 indexed domain, address indexed peripheryContract);\n\n event RemovePeripheryContract(bytes32 indexed domain, address indexed peripheryContract);\n\n event AuthorizeFactory(address indexed factory, address indexed suite, address indexed target);\n\n event UnauthorizeFactory(address indexed factory, address indexed suite, address indexed target);\n\n event UpgradePoolFactory(address indexed pool, address factory);\n\n event UpgradePriceOracleFactory(address indexed pool, address factory);\n\n event UpgradeInterestRateModelFactory(address indexed pool, address factory);\n\n event UpgradeRateKeeperFactory(address indexed pool, address factory);\n\n event UpgradeLossPolicyFactory(address indexed pool, address factory);\n\n event UpgradeCreditFactory(address indexed creditManager, address factory);\n\n event ExecuteHook(address indexed target, bytes callData);\n\n // ------ //\n // ERRORS //\n // ------ //\n\n error CallerIsNotAdminException(address caller);\n\n error CallerIsNotEmergencyAdminException(address caller);\n\n error CallerIsNotSelfException(address caller);\n\n error CreditSuiteNotRegisteredException(address creditManager);\n\n error IncorrectMinorVersionException(uint256 version);\n\n error IncorrectPeripheryContractException(address peripheryContract);\n\n error MarketNotRegisteredException(address pool);\n\n error UnauthorizedFactoryException(address factory, address target);\n\n // --------------- //\n // STATE VARIABLES //\n // --------------- //\n\n function admin() external view returns (address);\n function emergencyAdmin() external view returns (address);\n function curatorName() external view returns (string memory);\n\n function acl() external view returns (address);\n function contractsRegister() external view returns (address);\n function treasury() external view returns (address);\n\n // ---------------- //\n // ROLES MANAGEMENT //\n // ---------------- //\n\n function setEmergencyAdmin(address newEmergencyAdmin) external;\n\n function grantRole(bytes32 role, address account) external;\n\n function revokeRole(bytes32 role, address account) external;\n\n function emergencyRevokeRole(bytes32 role, address account) external;\n\n // ----------------- //\n // MARKET MANAGEMENT //\n // ----------------- //\n\n function previewCreateMarket(uint256 minorVersion, address underlying, string calldata name, string calldata symbol)\n external\n view\n returns (address pool);\n\n function createMarket(\n uint256 minorVersion,\n address underlying,\n string calldata name,\n string calldata symbol,\n DeployParams calldata interestRateModelParams,\n DeployParams calldata rateKeeperParams,\n DeployParams calldata lossPolicyParams,\n address underlyingPriceFeed\n ) external returns (address pool);\n\n function shutdownMarket(address pool) external;\n\n function addToken(address pool, address token, address priceFeed) external;\n\n function configurePool(address pool, bytes calldata data) external;\n\n function emergencyConfigurePool(address pool, bytes calldata data) external;\n\n // ----------------------- //\n // CREDIT SUITE MANAGEMENT //\n // ----------------------- //\n\n function previewCreateCreditSuite(uint256 minorVersion, address pool, bytes calldata encodedParams)\n external\n view\n returns (address creditManager);\n\n function previewCreateCreditSuite(\n uint256 marketMinorVersion,\n uint256 creditSuiteMinorVersion,\n address underlying,\n string calldata name,\n string calldata symbol,\n bytes calldata encodedParams\n ) external view returns (address creditManager);\n\n function createCreditSuite(uint256 minorVersion, address pool, bytes calldata encdodedParams)\n external\n returns (address creditManager);\n\n function shutdownCreditSuite(address creditManager) external;\n\n function configureCreditSuite(address creditManager, bytes calldata data) external;\n\n function emergencyConfigureCreditSuite(address creditManager, bytes calldata data) external;\n\n // ----------------------- //\n // PRICE ORACLE MANAGEMENT //\n // ----------------------- //\n\n function updatePriceOracle(address pool) external returns (address priceOracle);\n\n function configurePriceOracle(address pool, bytes calldata data) external;\n\n function emergencyConfigurePriceOracle(address pool, bytes calldata data) external;\n\n // -------------- //\n // IRM MANAGEMENT //\n // -------------- //\n\n function updateInterestRateModel(address pool, DeployParams calldata params) external returns (address irm);\n\n function configureInterestRateModel(address pool, bytes calldata data) external;\n\n function emergencyConfigureInterestRateModel(address pool, bytes calldata data) external;\n\n // ---------------------- //\n // RATE KEEPER MANAGEMENT //\n // ---------------------- //\n\n function updateRateKeeper(address pool, DeployParams calldata params) external returns (address rateKeeper);\n\n function configureRateKeeper(address pool, bytes calldata data) external;\n\n function emergencyConfigureRateKeeper(address pool, bytes calldata data) external;\n\n // -\u2013-------------------- //\n // LOSS POLICY MANAGEMENT //\n // -\u2013-------------------- //\n\n function updateLossPolicy(address pool, DeployParams calldata params) external returns (address lossPolicy);\n\n function configureLossPolicy(address pool, bytes calldata data) external;\n\n function emergencyConfigureLossPolicy(address pool, bytes calldata data) external;\n\n // --------- //\n // PERIPHERY //\n // --------- //\n\n function getPeripheryContracts(bytes32 domain) external view returns (address[] memory);\n\n function isPeripheryContract(bytes32 domain, address peripheryContract) external view returns (bool);\n\n function addPeripheryContract(address peripheryContract) external;\n\n function removePeripheryContract(address peripheryContract) external;\n\n // --------- //\n // FACTORIES //\n // --------- //\n\n function getMarketFactories(address pool) external view returns (MarketFactories memory);\n\n function getCreditFactory(address creditManager) external view returns (address);\n\n function getAuthorizedFactory(address target) external view returns (address);\n\n function getFactoryTargets(address factory, address suite) external view returns (address[] memory);\n\n function authorizeFactory(address factory, address suite, address target) external;\n\n function unauthorizeFactory(address factory, address suite, address target) external;\n\n function upgradePoolFactory(address pool) external;\n\n function upgradePriceOracleFactory(address pool) external;\n\n function upgradeInterestRateModelFactory(address pool) external;\n\n function upgradeRateKeeperFactory(address pool) external;\n\n function upgradeLossPolicyFactory(address pool) external;\n\n function upgradeCreditFactory(address creditManager) external;\n}\n","keccak256":"0x7f5f689da9baa93c6cca8b2e3ca40ce2c255299952454834c54dd055ba7dc3c4","license":"MIT"},"contracts/interfaces/IMarketConfiguratorFactory.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2025.\npragma solidity ^0.8.23;\n\nimport {IVersion} from \"@gearbox-protocol/core-v3/contracts/interfaces/base/IVersion.sol\";\nimport {IDeployerTrait} from \"./base/IDeployerTrait.sol\";\n\n/// @title Market configurator factory interface\ninterface IMarketConfiguratorFactory is IVersion, IDeployerTrait {\n // ------ //\n // EVENTS //\n // ------ //\n\n event CreateMarketConfigurator(address indexed marketConfigurator, string name);\n event ShutdownMarketConfigurator(address indexed marketConfigurator);\n\n // ------ //\n // ERRORS //\n // ------ //\n\n error CallerIsNotCrossChainGovernanceException(address caller);\n error CallerIsNotMarketConfiguratorAdminException(address caller);\n error CantShutdownMarketConfiguratorException(address marketConfigurator);\n error MarketConfiguratorIsAlreadyAddedException(address marketConfigurator);\n error MarketConfiguratorIsAlreadyShutdownException(address marketConfigruator);\n error MarketConfiguratorIsNotRegisteredException(address marketConfigurator);\n\n // ------- //\n // GETTERS //\n // ------- //\n\n function isMarketConfigurator(address account) external view returns (bool);\n function getMarketConfigurators() external view returns (address[] memory);\n function getMarketConfigurator(uint256 index) external view returns (address);\n function getNumMarketConfigurators() external view returns (uint256);\n function getShutdownMarketConfigurators() external view returns (address[] memory);\n\n // ------------- //\n // CONFIGURATION //\n // ------------- //\n\n function createMarketConfigurator(\n address emergencyAdmin,\n address adminFeeTreasury,\n string calldata curatorName,\n bool deployGovernor\n ) external returns (address marketConfigurator);\n function shutdownMarketConfigurator(address marketConfigurator) external;\n function addMarketConfigurator(address marketConfigurator) external;\n}\n","keccak256":"0x6e90ccc696301d5b75e7ae1f545e8ed1fc801e3e28769760e9e713276b6aad17","license":"MIT"},"contracts/interfaces/Types.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2025.\npragma solidity ^0.8.23;\n\nstruct AddressProviderEntry {\n bytes32 key;\n uint256 ver;\n address value;\n}\n\nstruct AuditReport {\n address auditor;\n string reportUrl;\n bytes signature;\n}\n\nstruct Bytecode {\n bytes32 contractType;\n uint256 version;\n bytes initCode;\n address author;\n string source;\n bytes authorSignature;\n}\n\nstruct BytecodePointer {\n bytes32 contractType;\n uint256 version;\n address[] initCodePointers;\n address author;\n string source;\n bytes authorSignature;\n}\n\nstruct Call {\n address target;\n bytes callData;\n}\n\nstruct ConnectedPriceFeed {\n address token;\n address[] priceFeeds;\n}\n\nstruct CrossChainCall {\n uint256 chainId; // 0 means to be executed on all chains\n address target;\n bytes callData;\n}\n\nstruct DeployParams {\n bytes32 postfix;\n bytes32 salt;\n bytes constructorParams;\n}\n\nstruct DeployResult {\n address newContract;\n Call[] onInstallOps;\n}\n\nstruct MarketFactories {\n address poolFactory;\n address priceOracleFactory;\n address interestRateModelFactory;\n address rateKeeperFactory;\n address lossPolicyFactory;\n}\n\nstruct PriceFeedInfo {\n string name;\n uint32 stalenessPeriod;\n bytes32 priceFeedType;\n uint256 version;\n}\n\nstruct SignedBatch {\n string name;\n bytes32 prevHash;\n CrossChainCall[] calls;\n bytes[] signatures;\n}\n\nstruct SignedRecoveryModeMessage {\n uint256 chainId;\n bytes32 startingBatchHash;\n bytes[] signatures;\n}\n\nstruct Split {\n bool initialized;\n address[] receivers;\n uint16[] proportions;\n}\n\nstruct TwoAdminProposal {\n bytes callData;\n bool confirmedByAdmin;\n bool confirmedByTreasuryProxy;\n}\n","keccak256":"0x6ac5744449d420d240bf0e9e61d61179258f96fab460d37baace204c4c065c84","license":"MIT"},"contracts/interfaces/base/IDeployerTrait.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2025.\npragma solidity ^0.8.23;\n\n/// @title Deployer trait interface\ninterface IDeployerTrait {\n function addressProvider() external view returns (address);\n\n function bytecodeRepository() external view returns (address);\n}\n","keccak256":"0xef8f1291807bb65f6f5a622040e5fd293a01b8497e577957ab7ed913ed011273","license":"MIT"},"contracts/interfaces/base/IImmutableOwnableTrait.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2025.\npragma solidity ^0.8.23;\n\n/// @title Immutable ownable trait interface\n/// @notice Interface for contracts with immutable owner functionality\ninterface IImmutableOwnableTrait {\n error CallerIsNotOwnerException(address caller);\n\n /// @notice Returns the immutable owner address\n function owner() external view returns (address);\n}\n","keccak256":"0xee7a0104fc96765e4a5cfb0a5c54a7a87e67d6471322b1b395220c7fa03c1669","license":"MIT"},"contracts/interfaces/factories/IFactory.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2025.\npragma solidity ^0.8.23;\n\nimport {IVersion} from \"@gearbox-protocol/core-v3/contracts/interfaces/base/IVersion.sol\";\nimport {IDeployerTrait} from \"../base/IDeployerTrait.sol\";\nimport {Call} from \"../Types.sol\";\n\ninterface IFactory is IVersion, IDeployerTrait {\n // ------ //\n // ERRORS //\n // ------ //\n\n error CallerIsNotMarketConfiguratorException(address caller);\n error ForbiddenConfigurationCallException(bytes4 selector);\n error ForbiddenEmergencyConfigurationCallException(bytes4 selector);\n error InvalidConstructorParamsException();\n\n // --------------- //\n // STATE VARIABLES //\n // --------------- //\n\n function marketConfiguratorFactory() external view returns (address);\n\n // ------------- //\n // CONFIGURATION //\n // ------------- //\n\n function configure(address target, bytes calldata callData) external returns (Call[] memory calls);\n\n function emergencyConfigure(address target, bytes calldata callData) external returns (Call[] memory calls);\n}\n","keccak256":"0x023309eeb433eaabb21ff262087f2f341b5defd3ad9a446583eedc21a5806791","license":"MIT"},"contracts/interfaces/factories/IMarketFactory.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2025.\npragma solidity ^0.8.23;\n\nimport {Call} from \"../Types.sol\";\nimport {IFactory} from \"./IFactory.sol\";\n\ninterface IMarketFactory is IFactory {\n // ------------ //\n // MARKET HOOKS //\n // ------------ //\n\n function onCreateMarket(\n address pool,\n address priceOracle,\n address interestRateModel,\n address rateKeeper,\n address lossPolicy,\n address underlyingPriceFeed\n ) external returns (Call[] memory calls);\n\n function onShutdownMarket(address pool) external returns (Call[] memory calls);\n\n function onCreateCreditSuite(address creditManager) external returns (Call[] memory calls);\n\n function onShutdownCreditSuite(address creditManager) external returns (Call[] memory calls);\n\n function onUpdatePriceOracle(address pool, address newPriceOracle, address oldPriceOracle)\n external\n returns (Call[] memory calls);\n\n function onUpdateInterestRateModel(address pool, address newInterestRateModel, address oldInterestRateModel)\n external\n returns (Call[] memory calls);\n\n function onUpdateRateKeeper(address pool, address newRateKeeper, address oldRateKeeper)\n external\n returns (Call[] memory calls);\n\n function onUpdateLossPolicy(address pool, address newLossPolicy, address oldLossPolicy)\n external\n returns (Call[] memory calls);\n\n function onAddToken(address pool, address token, address priceFeed) external returns (Call[] memory calls);\n}\n","keccak256":"0x20b3c85c3f3d6c78943bffe2ad3a8ce88636e95c57dbc23da859793f1ada46e0","license":"MIT"},"contracts/interfaces/factories/IRateKeeperFactory.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2025.\npragma solidity ^0.8.23;\n\nimport {DeployParams, DeployResult} from \"../Types.sol\";\nimport {IMarketFactory} from \"./IMarketFactory.sol\";\n\ninterface IRateKeeperFactory is IMarketFactory {\n function deployRateKeeper(address pool, DeployParams calldata params) external returns (DeployResult memory);\n}\n","keccak256":"0xa9f61a25ccb859ce296f65bcd5c9117e32d633033c30d0523ca36352460935b2","license":"MIT"},"contracts/libraries/CallBuilder.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2025.\npragma solidity ^0.8.23;\n\nimport {Call} from \"../interfaces/Types.sol\";\n\nlibrary CallBuilder {\n function build() internal pure returns (Call[] memory calls) {}\n\n function build(Call memory call1) internal pure returns (Call[] memory calls) {\n calls = new Call[](1);\n calls[0] = call1;\n }\n\n function build(Call memory call1, Call memory call2) internal pure returns (Call[] memory calls) {\n calls = new Call[](2);\n calls[0] = call1;\n calls[1] = call2;\n }\n\n function build(Call memory call1, Call memory call2, Call memory call3)\n internal\n pure\n returns (Call[] memory calls)\n {\n calls = new Call[](3);\n calls[0] = call1;\n calls[1] = call2;\n calls[2] = call3;\n }\n\n function build(Call memory call1, Call memory call2, Call memory call3, Call memory call4)\n internal\n pure\n returns (Call[] memory calls)\n {\n calls = new Call[](4);\n calls[0] = call1;\n calls[1] = call2;\n calls[2] = call3;\n calls[3] = call4;\n }\n\n function build(Call memory call1, Call memory call2, Call memory call3, Call memory call4, Call memory call5)\n internal\n pure\n returns (Call[] memory calls)\n {\n calls = new Call[](5);\n calls[0] = call1;\n calls[1] = call2;\n calls[2] = call3;\n calls[3] = call4;\n calls[4] = call5;\n }\n\n function build(\n Call memory call1,\n Call memory call2,\n Call memory call3,\n Call memory call4,\n Call memory call5,\n Call memory call6\n ) internal pure returns (Call[] memory calls) {\n calls = new Call[](6);\n calls[0] = call1;\n calls[1] = call2;\n calls[2] = call3;\n calls[3] = call4;\n calls[4] = call5;\n calls[5] = call6;\n }\n\n function append(Call[] memory calls, Call memory call) internal pure returns (Call[] memory newCalls) {\n uint256 numCalls = calls.length;\n newCalls = new Call[](numCalls + 1);\n for (uint256 i; i < numCalls; ++i) {\n newCalls[i] = calls[i];\n }\n newCalls[numCalls] = call;\n }\n\n function extend(Call[] memory calls1, Call[] memory calls2) internal pure returns (Call[] memory newCalls) {\n uint256 num1 = calls1.length;\n uint256 num2 = calls2.length;\n newCalls = new Call[](num1 + num2);\n for (uint256 i; i < num1; ++i) {\n newCalls[i] = calls1[i];\n }\n for (uint256 i; i < num2; ++i) {\n newCalls[num1 + i] = calls2[i];\n }\n }\n}\n","keccak256":"0xb35f26f9ddc7b8cb2230bafe2f5615417c87a0a9c89e7485696607d0112a4e58","license":"BUSL-1.1"},"contracts/libraries/ContractLiterals.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2025.\npragma solidity ^0.8.23;\n\nuint256 constant NO_VERSION_CONTROL = 0;\n\n// Contract types and prefixes\nbytes32 constant AP_ACCOUNT_FACTORY_DEFAULT = \"ACCOUNT_FACTORY::DEFAULT\";\nbytes32 constant AP_ACL = \"ACL\";\nbytes32 constant AP_ADDRESS_PROVIDER = \"ADDRESS_PROVIDER\";\nbytes32 constant AP_BOT_LIST = \"BOT_LIST\";\nbytes32 constant AP_BYTECODE_REPOSITORY = \"BYTECODE_REPOSITORY\";\nbytes32 constant AP_CONTRACTS_REGISTER = \"CONTRACTS_REGISTER\";\nbytes32 constant AP_CREDIT_CONFIGURATOR = \"CREDIT_CONFIGURATOR\";\nbytes32 constant AP_CREDIT_FACADE = \"CREDIT_FACADE\";\nbytes32 constant AP_CREDIT_FACTORY = \"CREDIT_FACTORY\";\nbytes32 constant AP_CREDIT_MANAGER = \"CREDIT_MANAGER\";\nbytes32 constant AP_CROSS_CHAIN_GOVERNANCE = \"CROSS_CHAIN_GOVERNANCE\";\nbytes32 constant AP_CROSS_CHAIN_GOVERNANCE_PROXY = \"CROSS_CHAIN_GOVERNANCE_PROXY\";\nbytes32 constant AP_CROSS_CHAIN_MULTISIG = \"CROSS_CHAIN_MULTISIG\";\nbytes32 constant AP_GEAR_STAKING = \"GEAR_STAKING\";\nbytes32 constant AP_GEAR_TOKEN = \"GLOBAL::GEAR_TOKEN\";\nbytes32 constant AP_GOVERNOR = \"GOVERNOR\";\nbytes32 constant AP_INSTANCE_MANAGER = \"INSTANCE_MANAGER\";\nbytes32 constant AP_INSTANCE_MANAGER_PROXY = \"INSTANCE_MANAGER_PROXY\";\nbytes32 constant AP_INTEREST_RATE_MODEL_DEFAULT = \"IRM::DEFAULT\";\nbytes32 constant AP_INTEREST_RATE_MODEL_FACTORY = \"INTEREST_RATE_MODEL_FACTORY\";\nbytes32 constant AP_INTEREST_RATE_MODEL_LINEAR = \"IRM::LINEAR\";\nbytes32 constant AP_LOSS_POLICY_ALIASED = \"LOSS_POLICY::ALIASED\";\nbytes32 constant AP_LOSS_POLICY_DEFAULT = \"LOSS_POLICY::DEFAULT\";\nbytes32 constant AP_LOSS_POLICY_FACTORY = \"LOSS_POLICY_FACTORY\";\nbytes32 constant AP_MARKET_CONFIGURATOR = \"MARKET_CONFIGURATOR\";\nbytes32 constant AP_MARKET_CONFIGURATOR_FACTORY = \"MARKET_CONFIGURATOR_FACTORY\";\nbytes32 constant AP_MARKET_CONFIGURATOR_LEGACY = \"MARKET_CONFIGURATOR::LEGACY\";\nbytes32 constant AP_POOL = \"POOL\";\nbytes32 constant AP_POOL_FACTORY = \"POOL_FACTORY\";\nbytes32 constant AP_POOL_QUOTA_KEEPER = \"POOL_QUOTA_KEEPER\";\nbytes32 constant AP_PRICE_FEED_STORE = \"PRICE_FEED_STORE\";\nbytes32 constant AP_PRICE_ORACLE = \"PRICE_ORACLE\";\nbytes32 constant AP_PRICE_ORACLE_FACTORY = \"PRICE_ORACLE_FACTORY\";\nbytes32 constant AP_RATE_KEEPER_FACTORY = \"RATE_KEEPER_FACTORY\";\nbytes32 constant AP_RATE_KEEPER_GAUGE = \"RATE_KEEPER::GAUGE\";\nbytes32 constant AP_RATE_KEEPER_TUMBLER = \"RATE_KEEPER::TUMBLER\";\nbytes32 constant AP_TREASURY = \"TREASURY\";\nbytes32 constant AP_TREASURY_PROXY = \"TREASURY_PROXY\";\nbytes32 constant AP_TREASURY_SPLITTER = \"TREASURY_SPLITTER\";\nbytes32 constant AP_WETH_TOKEN = \"WETH_TOKEN\";\nbytes32 constant AP_ZERO_PRICE_FEED = \"PRICE_FEED::ZERO\";\n\n// Common domains\nbytes32 constant DOMAIN_ACCOUNT_FACTORY = \"ACCOUNT_FACTORY\";\nbytes32 constant DOMAIN_ADAPTER = \"ADAPTER\";\nbytes32 constant DOMAIN_BOT = \"BOT\";\nbytes32 constant DOMAIN_CREDIT_MANAGER = \"CREDIT_MANAGER\";\nbytes32 constant DOMAIN_DEGEN_NFT = \"DEGEN_NFT\";\nbytes32 constant DOMAIN_IRM = \"IRM\";\nbytes32 constant DOMAIN_LOSS_POLICY = \"LOSS_POLICY\";\nbytes32 constant DOMAIN_POOL = \"POOL\";\nbytes32 constant DOMAIN_PRICE_FEED = \"PRICE_FEED\";\nbytes32 constant DOMAIN_RATE_KEEPER = \"RATE_KEEPER\";\nbytes32 constant DOMAIN_ZAPPER = \"ZAPPER\";\n\n// Roles\nbytes32 constant ROLE_EMERGENCY_LIQUIDATOR = \"EMERGENCY_LIQUIDATOR\";\nbytes32 constant ROLE_PAUSABLE_ADMIN = \"PAUSABLE_ADMIN\";\nbytes32 constant ROLE_UNPAUSABLE_ADMIN = \"UNPAUSABLE_ADMIN\";\n","keccak256":"0xffe54c43efd836075c3885a53aced2c406b3c569ed6605ed3fd2b18c7f5bb036","license":"BUSL-1.1"},"contracts/libraries/Domain.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2025.\npragma solidity ^0.8.23;\n\nimport {LibString} from \"@solady/utils/LibString.sol\";\n\nlibrary Domain {\n using LibString for string;\n using LibString for bytes32;\n\n uint128 internal constant UNDERSCORE = 1 << 95;\n\n function getContractType(bytes32 domain, bytes32 postfix) internal pure returns (bytes32) {\n if (postfix == 0) return domain;\n return string.concat(domain.fromSmallString(), \"::\", postfix.fromSmallString()).toSmallString();\n }\n\n function extractDomain(bytes32 contractType) internal pure returns (bytes32) {\n string memory str = contractType.fromSmallString();\n uint256 separatorIndex = str.indexOf(\"::\");\n\n // If no separator found, treat the whole type as domain\n if (separatorIndex == LibString.NOT_FOUND) return str.toSmallString();\n\n return str.slice(0, separatorIndex).toSmallString();\n }\n\n function extractPostfix(bytes32 contractType) internal pure returns (bytes32) {\n string memory str = contractType.fromSmallString();\n uint256 separatorIndex = str.indexOf(\"::\");\n\n // if no separator found, return empty postfix\n if (separatorIndex == LibString.NOT_FOUND) return bytes32(0);\n\n return str.slice(separatorIndex + 2).toSmallString();\n }\n\n function isValidContractType(bytes32 contractType) internal pure returns (bool) {\n bytes32 domain = extractDomain(contractType);\n if (!isValidDomain(domain)) return false;\n\n bytes32 postfix = extractPostfix(contractType);\n if (!isValidPostfix(postfix)) return false;\n\n // avoid the \"DOMAIN::\" case\n return contractType == getContractType(domain, postfix);\n }\n\n function isValidDomain(bytes32 domain) internal pure returns (bool) {\n return domain != 0 && _isValidString(domain.fromSmallString());\n }\n\n function isValidPostfix(bytes32 postfix) internal pure returns (bool) {\n return _isValidString(postfix.fromSmallString());\n }\n\n function _isValidString(string memory str) internal pure returns (bool) {\n return str.is7BitASCII(LibString.ALPHANUMERIC_7_BIT_ASCII | UNDERSCORE);\n }\n}\n","keccak256":"0x75a6c3b2f79458a41d8dd7048f8e16960f8fac9b52523ef2305d4720419a45c7","license":"BUSL-1.1"},"contracts/traits/DeployerTrait.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2025.\npragma solidity ^0.8.23;\n\nimport {LibString} from \"@solady/utils/LibString.sol\";\n\nimport {IAddressProvider} from \"../interfaces/IAddressProvider.sol\";\nimport {IBytecodeRepository} from \"../interfaces/IBytecodeRepository.sol\";\nimport {IDeployerTrait} from \"../interfaces/base/IDeployerTrait.sol\";\n\nimport {AP_BYTECODE_REPOSITORY, NO_VERSION_CONTROL} from \"../libraries/ContractLiterals.sol\";\nimport {Domain} from \"../libraries/Domain.sol\";\n\nabstract contract DeployerTrait is IDeployerTrait {\n using LibString for string;\n using LibString for bytes32;\n\n address public immutable override addressProvider;\n address public immutable override bytecodeRepository;\n\n constructor(address addressProvider_) {\n addressProvider = addressProvider_;\n bytecodeRepository = _getAddressOrRevert(AP_BYTECODE_REPOSITORY, NO_VERSION_CONTROL);\n }\n\n function _getAddress(bytes32 key, uint256 version) internal view returns (address) {\n return IAddressProvider(addressProvider).getAddress(key, version);\n }\n\n function _getAddressOrRevert(bytes32 key, uint256 version) internal view returns (address) {\n return IAddressProvider(addressProvider).getAddressOrRevert(key, version);\n }\n\n function _getContractType(bytes32 domain, bytes32 postfix) internal pure returns (bytes32) {\n return Domain.getContractType(domain, postfix);\n }\n\n function _deploy(bytes32 contractType, uint256 version, bytes memory constructorParams, bytes32 salt)\n internal\n returns (address)\n {\n return IBytecodeRepository(bytecodeRepository).deploy(contractType, version, constructorParams, salt);\n }\n\n function _computeAddress(\n bytes32 contractType,\n uint256 version,\n bytes memory constructorParams,\n bytes32 salt,\n address deployer\n ) internal view returns (address) {\n return IBytecodeRepository(bytecodeRepository).computeAddress(\n contractType, version, constructorParams, salt, deployer\n );\n }\n\n function _deployLatestPatch(\n bytes32 contractType,\n uint256 minorVersion,\n bytes memory constructorParams,\n bytes32 salt\n ) internal returns (address) {\n // NOTE: it's best to add a check that deployed contract's version matches the expected one in the governor\n return _deploy(contractType, _getLatestPatchVersion(contractType, minorVersion), constructorParams, salt);\n }\n\n function _computeAddressLatestPatch(\n bytes32 contractType,\n uint256 minorVersion,\n bytes memory constructorParams,\n bytes32 salt,\n address deployer\n ) internal view returns (address) {\n return _computeAddress(\n contractType, _getLatestPatchVersion(contractType, minorVersion), constructorParams, salt, deployer\n );\n }\n\n function _getLatestPatchVersion(bytes32 contractType, uint256 minorVersion) internal view returns (uint256) {\n return IBytecodeRepository(bytecodeRepository).getLatestPatchVersion(contractType, minorVersion);\n }\n\n function _getTokenSpecificPostfix(address token) internal view returns (bytes32) {\n return IBytecodeRepository(bytecodeRepository).getTokenSpecificPostfix(token);\n }\n}\n","keccak256":"0x3bfdf2bdbd8040a3621fb28488643daefdd348f3a3cca3bb0452d9e0b2dcd272","license":"BUSL-1.1"},"lib/@gearbox-protocol/core-v3/contracts/interfaces/IGaugeV3.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2024.\npragma solidity ^0.8.17;\n\nimport {IACLTrait} from \"./base/IACLTrait.sol\";\nimport {IRateKeeper} from \"./base/IRateKeeper.sol\";\nimport {IVotingContract} from \"./base/IVotingContract.sol\";\n\nstruct QuotaRateParams {\n uint16 minRate;\n uint16 maxRate;\n uint96 totalVotesLpSide;\n uint96 totalVotesCaSide;\n}\n\nstruct UserVotes {\n uint96 votesLpSide;\n uint96 votesCaSide;\n}\n\ninterface IGaugeV3Events {\n /// @notice Emitted when epoch is updated\n event UpdateEpoch(uint16 epochNow);\n\n /// @notice Emitted when a user submits a vote\n event Vote(address indexed user, address indexed token, uint96 votes, bool lpSide);\n\n /// @notice Emitted when a user removes a vote\n event Unvote(address indexed user, address indexed token, uint96 votes, bool lpSide);\n\n /// @notice Emitted when a new quota token is added in the PoolQuotaKeeper\n event AddQuotaToken(address indexed token, uint16 minRate, uint16 maxRate);\n\n /// @notice Emitted when quota interest rate parameters are changed\n event SetQuotaTokenParams(address indexed token, uint16 minRate, uint16 maxRate);\n\n /// @notice Emitted when the frozen epoch status changes\n event SetFrozenEpoch(bool status);\n}\n\n/// @title Gauge V3 interface\ninterface IGaugeV3 is IVotingContract, IRateKeeper, IACLTrait, IGaugeV3Events {\n function updateEpoch() external;\n\n function epochLastUpdate() external view returns (uint16);\n\n function getRates(address[] calldata tokens) external view override returns (uint16[] memory);\n\n function vote(address user, uint96 votes, bytes calldata extraData) external override;\n\n function unvote(address user, uint96 votes, bytes calldata extraData) external override;\n\n function userTokenVotes(address user, address token)\n external\n view\n returns (uint96 votesLpSide, uint96 votesCaSide);\n\n function quotaRateParams(address token)\n external\n view\n returns (uint16 minRate, uint16 maxRate, uint96 totalVotesLpSide, uint96 totalVotesCaSide);\n\n // ------------- //\n // CONFIGURATION //\n // ------------- //\n\n function epochFrozen() external view returns (bool);\n\n function setFrozenEpoch(bool status) external;\n\n function addQuotaToken(address token, uint16 minRate, uint16 maxRate) external;\n\n function changeQuotaMinRate(address token, uint16 minRate) external;\n\n function changeQuotaMaxRate(address token, uint16 maxRate) external;\n}\n","keccak256":"0x351036710f0230b06a6d9562e5f3896ee0dc15000dd9d14ed2c65c8cea70e1de","license":"MIT"},"lib/@gearbox-protocol/core-v3/contracts/interfaces/IPoolQuotaKeeperV3.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2024.\npragma solidity ^0.8.17;\n\nimport {IACLTrait} from \"./base/IACLTrait.sol\";\nimport {IContractsRegisterTrait} from \"./base/IContractsRegisterTrait.sol\";\nimport {IVersion} from \"./base/IVersion.sol\";\n\nstruct TokenQuotaParams {\n uint16 rate;\n uint192 cumulativeIndexLU;\n uint16 quotaIncreaseFee;\n uint96 totalQuoted;\n uint96 limit;\n}\n\nstruct AccountQuota {\n uint96 quota;\n uint192 cumulativeIndexLU;\n}\n\ninterface IPoolQuotaKeeperV3Events {\n /// @notice Emitted when account's quota for a token is updated\n event UpdateQuota(address indexed creditAccount, address indexed token, int96 quotaChange);\n\n /// @notice Emitted when token's quota rate is updated\n event UpdateTokenQuotaRate(address indexed token, uint16 rate);\n\n /// @notice Emitted when the gauge is updated\n event SetGauge(address indexed newGauge);\n\n /// @notice Emitted when a new credit manager is allowed\n event AddCreditManager(address indexed creditManager);\n\n /// @notice Emitted when a new token is added as quoted\n event AddQuotaToken(address indexed token);\n\n /// @notice Emitted when a new total quota limit is set for a token\n event SetTokenLimit(address indexed token, uint96 limit);\n\n /// @notice Emitted when a new one-time quota increase fee is set for a token\n event SetQuotaIncreaseFee(address indexed token, uint16 fee);\n}\n\n/// @title Pool quota keeper V3 interface\ninterface IPoolQuotaKeeperV3 is IPoolQuotaKeeperV3Events, IVersion, IACLTrait, IContractsRegisterTrait {\n function pool() external view returns (address);\n\n function underlying() external view returns (address);\n\n // ----------------- //\n // QUOTAS MANAGEMENT //\n // ----------------- //\n\n function updateQuota(address creditAccount, address token, int96 requestedChange, uint96 minQuota, uint96 maxQuota)\n external\n returns (uint128 caQuotaInterestChange, uint128 fees, bool enableToken, bool disableToken);\n\n function removeQuotas(address creditAccount, address[] calldata tokens, bool setLimitsToZero) external;\n\n function accrueQuotaInterest(address creditAccount, address[] calldata tokens) external;\n\n function getQuotaRate(address) external view returns (uint16);\n\n function cumulativeIndex(address token) external view returns (uint192);\n\n function isQuotedToken(address token) external view returns (bool);\n\n function getQuota(address creditAccount, address token)\n external\n view\n returns (uint96 quota, uint192 cumulativeIndexLU);\n\n function getTokenQuotaParams(address token)\n external\n view\n returns (\n uint16 rate,\n uint192 cumulativeIndexLU,\n uint16 quotaIncreaseFee,\n uint96 totalQuoted,\n uint96 limit,\n bool isActive\n );\n\n function getQuotaAndOutstandingInterest(address creditAccount, address token)\n external\n view\n returns (uint96 quoted, uint128 outstandingInterest);\n\n function poolQuotaRevenue() external view returns (uint256);\n\n function lastQuotaRateUpdate() external view returns (uint40);\n\n // ------------- //\n // CONFIGURATION //\n // ------------- //\n\n function gauge() external view returns (address);\n\n function setGauge(address _gauge) external;\n\n function creditManagers() external view returns (address[] memory);\n\n function addCreditManager(address _creditManager) external;\n\n function quotedTokens() external view returns (address[] memory);\n\n function addQuotaToken(address token) external;\n\n function updateRates() external;\n\n function setTokenLimit(address token, uint96 limit) external;\n\n function setTokenQuotaIncreaseFee(address token, uint16 fee) external;\n}\n","keccak256":"0x03b3362b0a792a28c724fa32097ada8ea6f1541a52d34ba1e4b7c9a96409e832","license":"MIT"},"lib/@gearbox-protocol/core-v3/contracts/interfaces/IPoolV3.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2024.\npragma solidity ^0.8.17;\npragma abicoder v1;\n\nimport {IERC4626} from \"@openzeppelin/contracts/interfaces/IERC4626.sol\";\nimport {IERC20Permit} from \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol\";\nimport {IACLTrait} from \"./base/IACLTrait.sol\";\nimport {IContractsRegisterTrait} from \"./base/IContractsRegisterTrait.sol\";\nimport {IVersion} from \"./base/IVersion.sol\";\n\ninterface IPoolV3Events {\n /// @notice Emitted when depositing liquidity with referral code\n event Refer(address indexed onBehalfOf, uint256 indexed referralCode, uint256 amount);\n\n /// @notice Emitted when credit account borrows funds from the pool\n event Borrow(address indexed creditManager, address indexed creditAccount, uint256 amount);\n\n /// @notice Emitted when credit account's debt is repaid to the pool\n event Repay(address indexed creditManager, uint256 borrowedAmount, uint256 profit, uint256 loss);\n\n /// @notice Emitted when incurred loss can't be fully covered by burning treasury's shares\n event IncurUncoveredLoss(address indexed creditManager, uint256 loss);\n\n /// @notice Emitted when new interest rate model contract is set\n event SetInterestRateModel(address indexed newInterestRateModel);\n\n /// @notice Emitted when new pool quota keeper contract is set\n event SetPoolQuotaKeeper(address indexed newPoolQuotaKeeper);\n\n /// @notice Emitted when new total debt limit is set\n event SetTotalDebtLimit(uint256 limit);\n\n /// @notice Emitted when new credit manager is connected to the pool\n event AddCreditManager(address indexed creditManager);\n\n /// @notice Emitted when new debt limit is set for a credit manager\n event SetCreditManagerDebtLimit(address indexed creditManager, uint256 newLimit);\n\n /// @notice Emitted when new withdrawal fee is set\n event SetWithdrawFee(uint256 fee);\n}\n\n/// @title Pool V3 interface\ninterface IPoolV3 is IVersion, IACLTrait, IContractsRegisterTrait, IPoolV3Events, IERC4626, IERC20Permit {\n function underlyingToken() external view returns (address);\n\n function treasury() external view returns (address);\n\n function withdrawFee() external view returns (uint16);\n\n function creditManagers() external view returns (address[] memory);\n\n function availableLiquidity() external view returns (uint256);\n\n function expectedLiquidity() external view returns (uint256);\n\n function expectedLiquidityLU() external view returns (uint256);\n\n // ---------------- //\n // ERC-4626 LENDING //\n // ---------------- //\n\n function depositWithReferral(uint256 assets, address receiver, uint256 referralCode)\n external\n returns (uint256 shares);\n\n function mintWithReferral(uint256 shares, address receiver, uint256 referralCode)\n external\n returns (uint256 assets);\n\n // --------- //\n // BORROWING //\n // --------- //\n\n function totalBorrowed() external view returns (uint256);\n\n function totalDebtLimit() external view returns (uint256);\n\n function creditManagerBorrowed(address creditManager) external view returns (uint256);\n\n function creditManagerDebtLimit(address creditManager) external view returns (uint256);\n\n function creditManagerBorrowable(address creditManager) external view returns (uint256 borrowable);\n\n function lendCreditAccount(uint256 borrowedAmount, address creditAccount) external;\n\n function repayCreditAccount(uint256 repaidAmount, uint256 profit, uint256 loss) external;\n\n // ------------- //\n // INTEREST RATE //\n // ------------- //\n\n function interestRateModel() external view returns (address);\n\n function baseInterestRate() external view returns (uint256);\n\n function supplyRate() external view returns (uint256);\n\n function baseInterestIndex() external view returns (uint256);\n\n function baseInterestIndexLU() external view returns (uint256);\n\n function lastBaseInterestUpdate() external view returns (uint40);\n\n // ------ //\n // QUOTAS //\n // ------ //\n\n function poolQuotaKeeper() external view returns (address);\n\n function quotaRevenue() external view returns (uint256);\n\n function lastQuotaRevenueUpdate() external view returns (uint40);\n\n function updateQuotaRevenue(int256 quotaRevenueDelta) external;\n\n function setQuotaRevenue(uint256 newQuotaRevenue) external;\n\n // ------------- //\n // CONFIGURATION //\n // ------------- //\n\n function setInterestRateModel(address newInterestRateModel) external;\n\n function setPoolQuotaKeeper(address newPoolQuotaKeeper) external;\n\n function setTotalDebtLimit(uint256 newLimit) external;\n\n function setCreditManagerDebtLimit(address creditManager, uint256 newLimit) external;\n\n function setWithdrawFee(uint256 newWithdrawFee) external;\n\n function pause() external;\n\n function unpause() external;\n}\n","keccak256":"0xcb981a10b3472a3a8f5ec8d8f124d727d5d5095658ddf395d99e8158bed9c6ff","license":"MIT"},"lib/@gearbox-protocol/core-v3/contracts/interfaces/base/IACLTrait.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2024.\npragma solidity ^0.8.17;\n\ninterface IACLTrait {\n function acl() external view returns (address);\n}\n","keccak256":"0xa921b085fe58d074492944ec373dcf9e6f33b4a1e13b5d03f3eb37b64a23fd95","license":"MIT"},"lib/@gearbox-protocol/core-v3/contracts/interfaces/base/IAddressProvider.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2024.\npragma solidity ^0.8.17;\n\ninterface IAddressProvider {\n function getAddressOrRevert(bytes32 key, uint256 version) external view returns (address);\n}\n","keccak256":"0x17654636800bae760f9f771471c093008b191bdbeb082167076111eee002ddc0","license":"MIT"},"lib/@gearbox-protocol/core-v3/contracts/interfaces/base/IContractsRegister.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2024.\npragma solidity ^0.8.17;\n\ninterface IContractsRegister {\n function isPool(address) external view returns (bool);\n function getPools() external view returns (address[] memory);\n function isCreditManager(address) external view returns (bool);\n function getCreditManagers() external view returns (address[] memory);\n}\n","keccak256":"0xbfea2a5497975edec84670da12d09f3a87711faae3edeb1af5cb5a3325b50924","license":"MIT"},"lib/@gearbox-protocol/core-v3/contracts/interfaces/base/IContractsRegisterTrait.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2024.\npragma solidity ^0.8.17;\n\ninterface IContractsRegisterTrait {\n function contractsRegister() external view returns (address);\n}\n","keccak256":"0x080b6b51cf516ec206938b1a6a1ee7bbc54023c7fbd28a83cdd2e4da53f63337","license":"MIT"},"lib/@gearbox-protocol/core-v3/contracts/interfaces/base/IRateKeeper.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2024.\npragma solidity ^0.8.17;\n\nimport {IStateSerializer} from \"./IStateSerializer.sol\";\nimport {IVersion} from \"./IVersion.sol\";\n\n/// @title Rate keeper interface\n/// @notice Generic interface for a contract that can provide rates to the quota keeper\n/// @dev Bots must have type `RATE_KEEPER::{POSTFIX}`\ninterface IRateKeeper is IVersion, IStateSerializer {\n /// @notice Pool rates are provided for\n function pool() external view returns (address);\n\n /// @notice Adds token to the rate keeper\n /// @dev Must add token to the quota keeper in case it's not already there\n function addToken(address token) external;\n\n /// @notice Whether token is added to the rate keeper\n function isTokenAdded(address token) external view returns (bool);\n\n /// @notice Returns quota rates for a list of tokens, must return non-zero rates for added tokens\n /// and revert if some tokens are not recognized\n function getRates(address[] calldata tokens) external view returns (uint16[] memory);\n}\n","keccak256":"0xb403ab7852efb090a4fbe1eefccb4095ea18cc21b985029fc4d2e09865b37def","license":"MIT"},"lib/@gearbox-protocol/core-v3/contracts/interfaces/base/IStateSerializer.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2024.\npragma solidity ^0.8.17;\n\n/// @title State serializer interface\n/// @notice Generic interface for a contract that can serialize its state into a bytes array\ninterface IStateSerializer {\n /// @notice Serializes the state of the contract into a bytes array `serializedData`\n function serialize() external view returns (bytes memory serializedData);\n}\n","keccak256":"0x23cfd28910d54c94b3da44825d182e7f5d0a174ef2904fdf1cc65e6c82157b85","license":"MIT"},"lib/@gearbox-protocol/core-v3/contracts/interfaces/base/IVersion.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2024.\npragma solidity ^0.8.17;\n\n/// @title Version interface\n/// @notice Defines contract version and type\ninterface IVersion {\n /// @notice Contract version\n function version() external view returns (uint256);\n\n /// @notice Contract type\n function contractType() external view returns (bytes32);\n}\n","keccak256":"0x985c0de4e24e431747820560798af3492989dba02e654e8cf4b006f2eedfc42c","license":"MIT"},"lib/@gearbox-protocol/core-v3/contracts/interfaces/base/IVotingContract.sol":{"content":"// SPDX-License-Identifier: MIT\n// Gearbox Protocol. Generalized leverage for DeFi protocols\n// (c) Gearbox Foundation, 2024.\npragma solidity ^0.8.17;\n\n/// @title Voting contract interface\n/// @notice Generic interface for a contract that can be voted for in `GearStakingV3` contract\n/// @dev `vote` and `unvote` must implement votes accounting since it's not performed on the staking contract side\ninterface IVotingContract {\n function voter() external view returns (address);\n function vote(address user, uint96 votes, bytes calldata extraData) external;\n function unvote(address user, uint96 votes, bytes calldata extraData) external;\n}\n","keccak256":"0xcb4b8bd23df4b71297a5f88c7112087629b9828b117d1267a8056c107b67ffb4","license":"MIT"},"lib/@openzeppelin/contracts/access/Ownable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n address private _owner;\n\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n /**\n * @dev Initializes the contract setting the deployer as the initial owner.\n */\n constructor() {\n _transferOwnership(_msgSender());\n }\n\n /**\n * @dev Throws if called by any account other than the owner.\n */\n modifier onlyOwner() {\n _checkOwner();\n _;\n }\n\n /**\n * @dev Returns the address of the current owner.\n */\n function owner() public view virtual returns (address) {\n return _owner;\n }\n\n /**\n * @dev Throws if the sender is not the owner.\n */\n function _checkOwner() internal view virtual {\n require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n }\n\n /**\n * @dev Leaves the contract without owner. It will not be possible to call\n * `onlyOwner` functions. Can only be called by the current owner.\n *\n * NOTE: Renouncing ownership will leave the contract without an owner,\n * thereby disabling any functionality that is only available to the owner.\n */\n function renounceOwnership() public virtual onlyOwner {\n _transferOwnership(address(0));\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\n * Can only be called by the current owner.\n */\n function transferOwnership(address newOwner) public virtual onlyOwner {\n require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n _transferOwnership(newOwner);\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\n * Internal function without access restriction.\n */\n function _transferOwnership(address newOwner) internal virtual {\n address oldOwner = _owner;\n _owner = newOwner;\n emit OwnershipTransferred(oldOwner, newOwner);\n }\n}\n","keccak256":"0xba43b97fba0d32eb4254f6a5a297b39a19a247082a02d6e69349e071e2946218","license":"MIT"},"lib/@openzeppelin/contracts/interfaces/IERC4626.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC4626.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../token/ERC20/IERC20.sol\";\nimport \"../token/ERC20/extensions/IERC20Metadata.sol\";\n\n/**\n * @dev Interface of the ERC4626 \"Tokenized Vault Standard\", as defined in\n * https://eips.ethereum.org/EIPS/eip-4626[ERC-4626].\n *\n * _Available since v4.7._\n */\ninterface IERC4626 is IERC20, IERC20Metadata {\n event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares);\n\n event Withdraw(\n address indexed sender,\n address indexed receiver,\n address indexed owner,\n uint256 assets,\n uint256 shares\n );\n\n /**\n * @dev Returns the address of the underlying token used for the Vault for accounting, depositing, and withdrawing.\n *\n * - MUST be an ERC-20 token contract.\n * - MUST NOT revert.\n */\n function asset() external view returns (address assetTokenAddress);\n\n /**\n * @dev Returns the total amount of the underlying asset that is \u201cmanaged\u201d by Vault.\n *\n * - SHOULD include any compounding that occurs from yield.\n * - MUST be inclusive of any fees that are charged against assets in the Vault.\n * - MUST NOT revert.\n */\n function totalAssets() external view returns (uint256 totalManagedAssets);\n\n /**\n * @dev Returns the amount of shares that the Vault would exchange for the amount of assets provided, in an ideal\n * scenario where all the conditions are met.\n *\n * - MUST NOT be inclusive of any fees that are charged against assets in the Vault.\n * - MUST NOT show any variations depending on the caller.\n * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.\n * - MUST NOT revert.\n *\n * NOTE: This calculation MAY NOT reflect the \u201cper-user\u201d price-per-share, and instead should reflect the\n * \u201caverage-user\u2019s\u201d price-per-share, meaning what the average user should expect to see when exchanging to and\n * from.\n */\n function convertToShares(uint256 assets) external view returns (uint256 shares);\n\n /**\n * @dev Returns the amount of assets that the Vault would exchange for the amount of shares provided, in an ideal\n * scenario where all the conditions are met.\n *\n * - MUST NOT be inclusive of any fees that are charged against assets in the Vault.\n * - MUST NOT show any variations depending on the caller.\n * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.\n * - MUST NOT revert.\n *\n * NOTE: This calculation MAY NOT reflect the \u201cper-user\u201d price-per-share, and instead should reflect the\n * \u201caverage-user\u2019s\u201d price-per-share, meaning what the average user should expect to see when exchanging to and\n * from.\n */\n function convertToAssets(uint256 shares) external view returns (uint256 assets);\n\n /**\n * @dev Returns the maximum amount of the underlying asset that can be deposited into the Vault for the receiver,\n * through a deposit call.\n *\n * - MUST return a limited value if receiver is subject to some deposit limit.\n * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of assets that may be deposited.\n * - MUST NOT revert.\n */\n function maxDeposit(address receiver) external view returns (uint256 maxAssets);\n\n /**\n * @dev Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given\n * current on-chain conditions.\n *\n * - MUST return as close to and no more than the exact amount of Vault shares that would be minted in a deposit\n * call in the same transaction. I.e. deposit should return the same or more shares as previewDeposit if called\n * in the same transaction.\n * - MUST NOT account for deposit limits like those returned from maxDeposit and should always act as though the\n * deposit would be accepted, regardless if the user has enough tokens approved, etc.\n * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.\n * - MUST NOT revert.\n *\n * NOTE: any unfavorable discrepancy between convertToShares and previewDeposit SHOULD be considered slippage in\n * share price or some other type of condition, meaning the depositor will lose assets by depositing.\n */\n function previewDeposit(uint256 assets) external view returns (uint256 shares);\n\n /**\n * @dev Mints shares Vault shares to receiver by depositing exactly amount of underlying tokens.\n *\n * - MUST emit the Deposit event.\n * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\n * deposit execution, and are accounted for during deposit.\n * - MUST revert if all of assets cannot be deposited (due to deposit limit being reached, slippage, the user not\n * approving enough underlying tokens to the Vault contract, etc).\n *\n * NOTE: most implementations will require pre-approval of the Vault with the Vault\u2019s underlying asset token.\n */\n function deposit(uint256 assets, address receiver) external returns (uint256 shares);\n\n /**\n * @dev Returns the maximum amount of the Vault shares that can be minted for the receiver, through a mint call.\n * - MUST return a limited value if receiver is subject to some mint limit.\n * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of shares that may be minted.\n * - MUST NOT revert.\n */\n function maxMint(address receiver) external view returns (uint256 maxShares);\n\n /**\n * @dev Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given\n * current on-chain conditions.\n *\n * - MUST return as close to and no fewer than the exact amount of assets that would be deposited in a mint call\n * in the same transaction. I.e. mint should return the same or fewer assets as previewMint if called in the\n * same transaction.\n * - MUST NOT account for mint limits like those returned from maxMint and should always act as though the mint\n * would be accepted, regardless if the user has enough tokens approved, etc.\n * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.\n * - MUST NOT revert.\n *\n * NOTE: any unfavorable discrepancy between convertToAssets and previewMint SHOULD be considered slippage in\n * share price or some other type of condition, meaning the depositor will lose assets by minting.\n */\n function previewMint(uint256 shares) external view returns (uint256 assets);\n\n /**\n * @dev Mints exactly shares Vault shares to receiver by depositing amount of underlying tokens.\n *\n * - MUST emit the Deposit event.\n * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the mint\n * execution, and are accounted for during mint.\n * - MUST revert if all of shares cannot be minted (due to deposit limit being reached, slippage, the user not\n * approving enough underlying tokens to the Vault contract, etc).\n *\n * NOTE: most implementations will require pre-approval of the Vault with the Vault\u2019s underlying asset token.\n */\n function mint(uint256 shares, address receiver) external returns (uint256 assets);\n\n /**\n * @dev Returns the maximum amount of the underlying asset that can be withdrawn from the owner balance in the\n * Vault, through a withdraw call.\n *\n * - MUST return a limited value if owner is subject to some withdrawal limit or timelock.\n * - MUST NOT revert.\n */\n function maxWithdraw(address owner) external view returns (uint256 maxAssets);\n\n /**\n * @dev Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block,\n * given current on-chain conditions.\n *\n * - MUST return as close to and no fewer than the exact amount of Vault shares that would be burned in a withdraw\n * call in the same transaction. I.e. withdraw should return the same or fewer shares as previewWithdraw if\n * called\n * in the same transaction.\n * - MUST NOT account for withdrawal limits like those returned from maxWithdraw and should always act as though\n * the withdrawal would be accepted, regardless if the user has enough shares, etc.\n * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.\n * - MUST NOT revert.\n *\n * NOTE: any unfavorable discrepancy between convertToShares and previewWithdraw SHOULD be considered slippage in\n * share price or some other type of condition, meaning the depositor will lose assets by depositing.\n */\n function previewWithdraw(uint256 assets) external view returns (uint256 shares);\n\n /**\n * @dev Burns shares from owner and sends exactly assets of underlying tokens to receiver.\n *\n * - MUST emit the Withdraw event.\n * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\n * withdraw execution, and are accounted for during withdraw.\n * - MUST revert if all of assets cannot be withdrawn (due to withdrawal limit being reached, slippage, the owner\n * not having enough shares, etc).\n *\n * Note that some implementations will require pre-requesting to the Vault before a withdrawal may be performed.\n * Those methods should be performed separately.\n */\n function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);\n\n /**\n * @dev Returns the maximum amount of Vault shares that can be redeemed from the owner balance in the Vault,\n * through a redeem call.\n *\n * - MUST return a limited value if owner is subject to some withdrawal limit or timelock.\n * - MUST return balanceOf(owner) if owner is not subject to any withdrawal limit or timelock.\n * - MUST NOT revert.\n */\n function maxRedeem(address owner) external view returns (uint256 maxShares);\n\n /**\n * @dev Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block,\n * given current on-chain conditions.\n *\n * - MUST return as close to and no more than the exact amount of assets that would be withdrawn in a redeem call\n * in the same transaction. I.e. redeem should return the same or more assets as previewRedeem if called in the\n * same transaction.\n * - MUST NOT account for redemption limits like those returned from maxRedeem and should always act as though the\n * redemption would be accepted, regardless if the user has enough shares, etc.\n * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.\n * - MUST NOT revert.\n *\n * NOTE: any unfavorable discrepancy between convertToAssets and previewRedeem SHOULD be considered slippage in\n * share price or some other type of condition, meaning the depositor will lose assets by redeeming.\n */\n function previewRedeem(uint256 shares) external view returns (uint256 assets);\n\n /**\n * @dev Burns exactly shares from owner and sends assets of underlying tokens to receiver.\n *\n * - MUST emit the Withdraw event.\n * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\n * redeem execution, and are accounted for during redeem.\n * - MUST revert if all of shares cannot be redeemed (due to withdrawal limit being reached, slippage, the owner\n * not having enough shares, etc).\n *\n * NOTE: some implementations will require pre-requesting to the Vault before a withdrawal may be performed.\n * Those methods should be performed separately.\n */\n function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);\n}\n","keccak256":"0x5a173dcd1c1f0074e4df6a9cdab3257e17f2e64f7b8f30ca9e17a8c5ea250e1c","license":"MIT"},"lib/@openzeppelin/contracts/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n /**\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\n * another (`to`).\n *\n * Note that `value` may be zero.\n */\n event Transfer(address indexed from, address indexed to, uint256 value);\n\n /**\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n * a call to {approve}. `value` is the new allowance.\n */\n event Approval(address indexed owner, address indexed spender, uint256 value);\n\n /**\n * @dev Returns the amount of tokens in existence.\n */\n function totalSupply() external view returns (uint256);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n * @dev Moves `amount` tokens from the caller's account to `to`.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transfer(address to, uint256 amount) external returns (bool);\n\n /**\n * @dev Returns the remaining number of tokens that `spender` will be\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\n * zero by default.\n *\n * This value changes when {approve} or {transferFrom} are called.\n */\n function allowance(address owner, address spender) external view returns (uint256);\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\n * that someone may use both the old and the new allowance by unfortunate\n * transaction ordering. One possible solution to mitigate this race\n * condition is to first reduce the spender's allowance to 0 and set the\n * desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n *\n * Emits an {Approval} event.\n */\n function approve(address spender, uint256 amount) external returns (bool);\n\n /**\n * @dev Moves `amount` tokens from `from` to `to` using the\n * allowance mechanism. `amount` is then deducted from the caller's\n * allowance.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(address from, address to, uint256 amount) external returns (bool);\n}\n","keccak256":"0x287b55befed2961a7eabd7d7b1b2839cbca8a5b80ef8dcbb25ed3d4c2002c305","license":"MIT"},"lib/@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n *\n * _Available since v4.1._\n */\ninterface IERC20Metadata is IERC20 {\n /**\n * @dev Returns the name of the token.\n */\n function name() external view returns (string memory);\n\n /**\n * @dev Returns the symbol of the token.\n */\n function symbol() external view returns (string memory);\n\n /**\n * @dev Returns the decimals places of the token.\n */\n function decimals() external view returns (uint8);\n}\n","keccak256":"0x8de418a5503946cabe331f35fe242d3201a73f67f77aaeb7110acb1f30423aca","license":"MIT"},"lib/@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.4) (token/ERC20/extensions/IERC20Permit.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n *\n * ==== Security Considerations\n *\n * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature\n * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be\n * considered as an intention to spend the allowance in any specific way. The second is that because permits have\n * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should\n * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be\n * generally recommended is:\n *\n * ```solidity\n * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {\n * try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}\n * doThing(..., value);\n * }\n *\n * function doThing(..., uint256 value) public {\n * token.safeTransferFrom(msg.sender, address(this), value);\n * ...\n * }\n * ```\n *\n * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of\n * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also\n * {SafeERC20-safeTransferFrom}).\n *\n * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so\n * contracts should have entry points that don't rely on permit.\n */\ninterface IERC20Permit {\n /**\n * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\n * given ``owner``'s signed approval.\n *\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\n * ordering also apply here.\n *\n * Emits an {Approval} event.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n * - `deadline` must be a timestamp in the future.\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\n * over the EIP712-formatted function arguments.\n * - the signature must use ``owner``'s current nonce (see {nonces}).\n *\n * For more information on the signature format, see the\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\n * section].\n *\n * CAUTION: See Security Considerations above.\n */\n function permit(\n address owner,\n address spender,\n uint256 value,\n uint256 deadline,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) external;\n\n /**\n * @dev Returns the current nonce for `owner`. This value must be\n * included whenever a signature is generated for {permit}.\n *\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\n * prevents a signature from being used multiple times.\n */\n function nonces(address owner) external view returns (uint256);\n\n /**\n * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\n */\n // solhint-disable-next-line func-name-mixedcase\n function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n","keccak256":"0xb264c03a3442eb37a68ad620cefd1182766b58bee6cec40343480392d6b14d69","license":"MIT"},"lib/@openzeppelin/contracts/utils/Context.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.4) (utils/Context.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n function _msgSender() internal view virtual returns (address) {\n return msg.sender;\n }\n\n function _msgData() internal view virtual returns (bytes calldata) {\n return msg.data;\n }\n\n function _contextSuffixLength() internal view virtual returns (uint256) {\n return 0;\n }\n}\n","keccak256":"0xa92e4fa126feb6907daa0513ddd816b2eb91f30a808de54f63c17d0e162c3439","license":"MIT"},"lib/@solady/src/utils/LibString.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Library for converting numbers into strings and other string operations.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibString.sol)\n/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/LibString.sol)\n///\n/// @dev Note:\n/// For performance and bytecode compactness, most of the string operations are restricted to\n/// byte strings (7-bit ASCII), except where otherwise specified.\n/// Usage of byte string operations on charsets with runes spanning two or more bytes\n/// can lead to undefined behavior.\nlibrary LibString {\n /*\u00b4:\u00b0\u2022.\u00b0+.*\u2022\u00b4.*:\u02da.\u00b0*.\u02da\u2022\u00b4.\u00b0:\u00b0\u2022.\u00b0\u2022.*\u2022\u00b4.*:\u02da.\u00b0*.\u02da\u2022\u00b4.\u00b0:\u00b0\u2022.\u00b0+.*\u2022\u00b4.*:*/\n /* CUSTOM ERRORS */\n /*.\u2022\u00b0:\u00b0.\u00b4+\u02da.*\u00b0.\u02da:*.\u00b4\u2022*.+\u00b0.\u2022\u00b0:\u00b4*.\u00b4\u2022*.\u2022\u00b0.\u2022\u00b0:\u00b0.\u00b4:\u2022\u02da\u00b0.*\u00b0.\u02da:*.\u00b4+\u00b0.\u2022*/\n\n /// @dev The length of the output is too small to contain all the hex digits.\n error HexLengthInsufficient();\n\n /// @dev The length of the string is more than 32 bytes.\n error TooBigForSmallString();\n\n /// @dev The input string must be a 7-bit ASCII.\n error StringNot7BitASCII();\n\n /*\u00b4:\u00b0\u2022.\u00b0+.*\u2022\u00b4.*:\u02da.\u00b0*.\u02da\u2022\u00b4.\u00b0:\u00b0\u2022.\u00b0\u2022.*\u2022\u00b4.*:\u02da.\u00b0*.\u02da\u2022\u00b4.\u00b0:\u00b0\u2022.\u00b0+.*\u2022\u00b4.*:*/\n /* CONSTANTS */\n /*.\u2022\u00b0:\u00b0.\u00b4+\u02da.*\u00b0.\u02da:*.\u00b4\u2022*.+\u00b0.\u2022\u00b0:\u00b4*.\u00b4\u2022*.\u2022\u00b0.\u2022\u00b0:\u00b0.\u00b4:\u2022\u02da\u00b0.*\u00b0.\u02da:*.\u00b4+\u00b0.\u2022*/\n\n /// @dev The constant returned when the `search` is not found in the string.\n uint256 internal constant NOT_FOUND = type(uint256).max;\n\n /// @dev Lookup for '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'.\n uint128 internal constant ALPHANUMERIC_7_BIT_ASCII = 0x7fffffe07fffffe03ff000000000000;\n\n /// @dev Lookup for 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'.\n uint128 internal constant LETTERS_7_BIT_ASCII = 0x7fffffe07fffffe0000000000000000;\n\n /// @dev Lookup for 'abcdefghijklmnopqrstuvwxyz'.\n uint128 internal constant LOWERCASE_7_BIT_ASCII = 0x7fffffe000000000000000000000000;\n\n /// @dev Lookup for 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.\n uint128 internal constant UPPERCASE_7_BIT_ASCII = 0x7fffffe0000000000000000;\n\n /// @dev Lookup for '0123456789'.\n uint128 internal constant DIGITS_7_BIT_ASCII = 0x3ff000000000000;\n\n /// @dev Lookup for '0123456789abcdefABCDEF'.\n uint128 internal constant HEXDIGITS_7_BIT_ASCII = 0x7e0000007e03ff000000000000;\n\n /// @dev Lookup for '01234567'.\n uint128 internal constant OCTDIGITS_7_BIT_ASCII = 0xff000000000000;\n\n /// @dev Lookup for '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!\"#$%&\\'()*+,-./:;<=>?@[\\\\]^_`{|}~ \\t\\n\\r\\x0b\\x0c'.\n uint128 internal constant PRINTABLE_7_BIT_ASCII = 0x7fffffffffffffffffffffff00003e00;\n\n /// @dev Lookup for '!\"#$%&\\'()*+,-./:;<=>?@[\\\\]^_`{|}~'.\n uint128 internal constant PUNCTUATION_7_BIT_ASCII = 0x78000001f8000001fc00fffe00000000;\n\n /// @dev Lookup for ' \\t\\n\\r\\x0b\\x0c'.\n uint128 internal constant WHITESPACE_7_BIT_ASCII = 0x100003e00;\n\n /*\u00b4:\u00b0\u2022.\u00b0+.*\u2022\u00b4.*:\u02da.\u00b0*.\u02da\u2022\u00b4.\u00b0:\u00b0\u2022.\u00b0\u2022.*\u2022\u00b4.*:\u02da.\u00b0*.\u02da\u2022\u00b4.\u00b0:\u00b0\u2022.\u00b0+.*\u2022\u00b4.*:*/\n /* DECIMAL OPERATIONS */\n /*.\u2022\u00b0:\u00b0.\u00b4+\u02da.*\u00b0.\u02da:*.\u00b4\u2022*.+\u00b0.\u2022\u00b0:\u00b4*.\u00b4\u2022*.\u2022\u00b0.\u2022\u00b0:\u00b0.\u00b4:\u2022\u02da\u00b0.*\u00b0.\u02da:*.\u00b4+\u00b0.\u2022*/\n\n /// @dev Returns the base 10 decimal representation of `value`.\n function toString(uint256 value) internal pure returns (string memory str) {\n /// @solidity memory-safe-assembly\n assembly {\n // The maximum value of a uint256 contains 78 digits (1 byte per digit), but\n // we allocate 0xa0 bytes to keep the free memory pointer 32-byte word aligned.\n // We will need 1 word for the trailing zeros padding, 1 word for the length,\n // and 3 words for a maximum of 78 digits.\n str := add(mload(0x40), 0x80)\n // Update the free memory pointer to allocate.\n mstore(0x40, add(str, 0x20))\n // Zeroize the slot after the string.\n mstore(str, 0)\n\n // Cache the end of the memory to calculate the length later.\n let end := str\n\n let w := not(0) // Tsk.\n // We write the string from rightmost digit to leftmost digit.\n // The following is essentially a do-while loop that also handles the zero case.\n for { let temp := value } 1 {} {\n str := add(str, w) // `sub(str, 1)`.\n // Write the character to the pointer.\n // The ASCII index of the '0' character is 48.\n mstore8(str, add(48, mod(temp, 10)))\n // Keep dividing `temp` until zero.\n temp := div(temp, 10)\n if iszero(temp) { break }\n }\n\n let length := sub(end, str)\n // Move the pointer 32 bytes leftwards to make room for the length.\n str := sub(str, 0x20)\n // Store the length.\n mstore(str, length)\n }\n }\n\n /// @dev Returns the base 10 decimal representation of `value`.\n function toString(int256 value) internal pure returns (string memory str) {\n if (value >= 0) {\n return toString(uint256(value));\n }\n unchecked {\n str = toString(~uint256(value) + 1);\n }\n /// @solidity memory-safe-assembly\n assembly {\n // We still have some spare memory space on the left,\n // as we have allocated 3 words (96 bytes) for up to 78 digits.\n let length := mload(str) // Load the string length.\n mstore(str, 0x2d) // Store the '-' character.\n str := sub(str, 1) // Move back the string pointer by a byte.\n mstore(str, add(length, 1)) // Update the string length.\n }\n }\n\n /*\u00b4:\u00b0\u2022.\u00b0+.*\u2022\u00b4.*:\u02da.\u00b0*.\u02da\u2022\u00b4.\u00b0:\u00b0\u2022.\u00b0\u2022.*\u2022\u00b4.*:\u02da.\u00b0*.\u02da\u2022\u00b4.\u00b0:\u00b0\u2022.\u00b0+.*\u2022\u00b4.*:*/\n /* HEXADECIMAL OPERATIONS */\n /*.\u2022\u00b0:\u00b0.\u00b4+\u02da.*\u00b0.\u02da:*.\u00b4\u2022*.+\u00b0.\u2022\u00b0:\u00b4*.\u00b4\u2022*.\u2022\u00b0.\u2022\u00b0:\u00b0.\u00b4:\u2022\u02da\u00b0.*\u00b0.\u02da:*.\u00b4+\u00b0.\u2022*/\n\n /// @dev Returns the hexadecimal representation of `value`,\n /// left-padded to an input length of `length` bytes.\n /// The output is prefixed with \"0x\" encoded using 2 hexadecimal digits per byte,\n /// giving a total length of `length * 2 + 2` bytes.\n /// Reverts if `length` is too small for the output to contain all the digits.\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory str) {\n str = toHexStringNoPrefix(value, length);\n /// @solidity memory-safe-assembly\n assembly {\n let strLength := add(mload(str), 2) // Compute the length.\n mstore(str, 0x3078) // Write the \"0x\" prefix.\n str := sub(str, 2) // Move the pointer.\n mstore(str, strLength) // Write the length.\n }\n }\n\n /// @dev Returns the hexadecimal representation of `value`,\n /// left-padded to an input length of `length` bytes.\n /// The output is prefixed with \"0x\" encoded using 2 hexadecimal digits per byte,\n /// giving a total length of `length * 2` bytes.\n /// Reverts if `length` is too small for the output to contain all the digits.\n function toHexStringNoPrefix(uint256 value, uint256 length)\n internal\n pure\n returns (string memory str)\n {\n /// @solidity memory-safe-assembly\n assembly {\n // We need 0x20 bytes for the trailing zeros padding, `length * 2` bytes\n // for the digits, 0x02 bytes for the prefix, and 0x20 bytes for the length.\n // We add 0x20 to the total and round down to a multiple of 0x20.\n // (0x20 + 0x20 + 0x02 + 0x20) = 0x62.\n str := add(mload(0x40), and(add(shl(1, length), 0x42), not(0x1f)))\n // Allocate the memory.\n mstore(0x40, add(str, 0x20))\n // Zeroize the slot after the string.\n mstore(str, 0)\n\n // Cache the end to calculate the length later.\n let end := str\n // Store \"0123456789abcdef\" in scratch space.\n mstore(0x0f, 0x30313233343536373839616263646566)\n\n let start := sub(str, add(length, length))\n let w := not(1) // Tsk.\n let temp := value\n // We write the string from rightmost digit to leftmost digit.\n // The following is essentially a do-while loop that also handles the zero case.\n for {} 1 {} {\n str := add(str, w) // `sub(str, 2)`.\n mstore8(add(str, 1), mload(and(temp, 15)))\n mstore8(str, mload(and(shr(4, temp), 15)))\n temp := shr(8, temp)\n if iszero(xor(str, start)) { break }\n }\n\n if temp {\n mstore(0x00, 0x2194895a) // `HexLengthInsufficient()`.\n revert(0x1c, 0x04)\n }\n\n // Compute the string's length.\n let strLength := sub(end, str)\n // Move the pointer and write the length.\n str := sub(str, 0x20)\n mstore(str, strLength)\n }\n }\n\n /// @dev Returns the hexadecimal representation of `value`.\n /// The output is prefixed with \"0x\" and encoded using 2 hexadecimal digits per byte.\n /// As address are 20 bytes long, the output will left-padded to have\n /// a length of `20 * 2 + 2` bytes.\n function toHexString(uint256 value) internal pure returns (string memory str) {\n str = toHexStringNoPrefix(value);\n /// @solidity memory-safe-assembly\n assembly {\n let strLength := add(mload(str), 2) // Compute the length.\n mstore(str, 0x3078) // Write the \"0x\" prefix.\n str := sub(str, 2) // Move the pointer.\n mstore(str, strLength) // Write the length.\n }\n }\n\n /// @dev Returns the hexadecimal representation of `value`.\n /// The output is prefixed with \"0x\".\n /// The output excludes leading \"0\" from the `toHexString` output.\n /// `0x00: \"0x0\", 0x01: \"0x1\", 0x12: \"0x12\", 0x123: \"0x123\"`.\n function toMinimalHexString(uint256 value) internal pure returns (string memory str) {\n str = toHexStringNoPrefix(value);\n /// @solidity memory-safe-assembly\n assembly {\n let o := eq(byte(0, mload(add(str, 0x20))), 0x30) // Whether leading zero is present.\n let strLength := add(mload(str), 2) // Compute the length.\n mstore(add(str, o), 0x3078) // Write the \"0x\" prefix, accounting for leading zero.\n str := sub(add(str, o), 2) // Move the pointer, accounting for leading zero.\n mstore(str, sub(strLength, o)) // Write the length, accounting for leading zero.\n }\n }\n\n /// @dev Returns the hexadecimal representation of `value`.\n /// The output excludes leading \"0\" from the `toHexStringNoPrefix` output.\n /// `0x00: \"0\", 0x01: \"1\", 0x12: \"12\", 0x123: \"123\"`.\n function toMinimalHexStringNoPrefix(uint256 value) internal pure returns (string memory str) {\n str = toHexStringNoPrefix(value);\n /// @solidity memory-safe-assembly\n assembly {\n let o := eq(byte(0, mload(add(str, 0x20))), 0x30) // Whether leading zero is present.\n let strLength := mload(str) // Get the length.\n str := add(str, o) // Move the pointer, accounting for leading zero.\n mstore(str, sub(strLength, o)) // Write the length, accounting for leading zero.\n }\n }\n\n /// @dev Returns the hexadecimal representation of `value`.\n /// The output is encoded using 2 hexadecimal digits per byte.\n /// As address are 20 bytes long, the output will left-padded to have\n /// a length of `20 * 2` bytes.\n function toHexStringNoPrefix(uint256 value) internal pure returns (string memory str) {\n /// @solidity memory-safe-assembly\n assembly {\n // We need 0x20 bytes for the trailing zeros padding, 0x20 bytes for the length,\n // 0x02 bytes for the prefix, and 0x40 bytes for the digits.\n // The next multiple of 0x20 above (0x20 + 0x20 + 0x02 + 0x40) is 0xa0.\n str := add(mload(0x40), 0x80)\n // Allocate the memory.\n mstore(0x40, add(str, 0x20))\n // Zeroize the slot after the string.\n mstore(str, 0)\n\n // Cache the end to calculate the length later.\n let end := str\n // Store \"0123456789abcdef\" in scratch space.\n mstore(0x0f, 0x30313233343536373839616263646566)\n\n let w := not(1) // Tsk.\n // We write the string from rightmost digit to leftmost digit.\n // The following is essentially a do-while loop that also handles the zero case.\n for { let temp := value } 1 {} {\n str := add(str, w) // `sub(str, 2)`.\n mstore8(add(str, 1), mload(and(temp, 15)))\n mstore8(str, mload(and(shr(4, temp), 15)))\n temp := shr(8, temp)\n if iszero(temp) { break }\n }\n\n // Compute the string's length.\n let strLength := sub(end, str)\n // Move the pointer and write the length.\n str := sub(str, 0x20)\n mstore(str, strLength)\n }\n }\n\n /// @dev Returns the hexadecimal representation of `value`.\n /// The output is prefixed with \"0x\", encoded using 2 hexadecimal digits per byte,\n /// and the alphabets are capitalized conditionally according to\n /// https://eips.ethereum.org/EIPS/eip-55\n function toHexStringChecksummed(address value) internal pure returns (string memory str) {\n str = toHexString(value);\n /// @solidity memory-safe-assembly\n assembly {\n let mask := shl(6, div(not(0), 255)) // `0b010000000100000000 ...`\n let o := add(str, 0x22)\n let hashed := and(keccak256(o, 40), mul(34, mask)) // `0b10001000 ... `\n let t := shl(240, 136) // `0b10001000 << 240`\n for { let i := 0 } 1 {} {\n mstore(add(i, i), mul(t, byte(i, hashed)))\n i := add(i, 1)\n if eq(i, 20) { break }\n }\n mstore(o, xor(mload(o), shr(1, and(mload(0x00), and(mload(o), mask)))))\n o := add(o, 0x20)\n mstore(o, xor(mload(o), shr(1, and(mload(0x20), and(mload(o), mask)))))\n }\n }\n\n /// @dev Returns the hexadecimal representation of `value`.\n /// The output is prefixed with \"0x\" and encoded using 2 hexadecimal digits per byte.\n function toHexString(address value) internal pure returns (string memory str) {\n str = toHexStringNoPrefix(value);\n /// @solidity memory-safe-assembly\n assembly {\n let strLength := add(mload(str), 2) // Compute the length.\n mstore(str, 0x3078) // Write the \"0x\" prefix.\n str := sub(str, 2) // Move the pointer.\n mstore(str, strLength) // Write the length.\n }\n }\n\n /// @dev Returns the hexadecimal representation of `value`.\n /// The output is encoded using 2 hexadecimal digits per byte.\n function toHexStringNoPrefix(address value) internal pure returns (string memory str) {\n /// @solidity memory-safe-assembly\n assembly {\n str := mload(0x40)\n\n // Allocate the memory.\n // We need 0x20 bytes for the trailing zeros padding, 0x20 bytes for the length,\n // 0x02 bytes for the prefix, and 0x28 bytes for the digits.\n // The next multiple of 0x20 above (0x20 + 0x20 + 0x02 + 0x28) is 0x80.\n mstore(0x40, add(str, 0x80))\n\n // Store \"0123456789abcdef\" in scratch space.\n mstore(0x0f, 0x30313233343536373839616263646566)\n\n str := add(str, 2)\n mstore(str, 40)\n\n let o := add(str, 0x20)\n mstore(add(o, 40), 0)\n\n value := shl(96, value)\n\n // We write the string from rightmost digit to leftmost digit.\n // The following is essentially a do-while loop that also handles the zero case.\n for { let i := 0 } 1 {} {\n let p := add(o, add(i, i))\n let temp := byte(i, value)\n mstore8(add(p, 1), mload(and(temp, 15)))\n mstore8(p, mload(shr(4, temp)))\n i := add(i, 1)\n if eq(i, 20) { break }\n }\n }\n }\n\n /// @dev Returns the hex encoded string from the raw bytes.\n /// The output is encoded using 2 hexadecimal digits per byte.\n function toHexString(bytes memory raw) internal pure returns (string memory str) {\n str = toHexStringNoPrefix(raw);\n /// @solidity memory-safe-assembly\n assembly {\n let strLength := add(mload(str), 2) // Compute the length.\n mstore(str, 0x3078) // Write the \"0x\" prefix.\n str := sub(str, 2) // Move the pointer.\n mstore(str, strLength) // Write the length.\n }\n }\n\n /// @dev Returns the hex encoded string from the raw bytes.\n /// The output is encoded using 2 hexadecimal digits per byte.\n function toHexStringNoPrefix(bytes memory raw) internal pure returns (string memory str) {\n /// @solidity memory-safe-assembly\n assembly {\n let length := mload(raw)\n str := add(mload(0x40), 2) // Skip 2 bytes for the optional prefix.\n mstore(str, add(length, length)) // Store the length of the output.\n\n // Store \"0123456789abcdef\" in scratch space.\n mstore(0x0f, 0x30313233343536373839616263646566)\n\n let o := add(str, 0x20)\n let end := add(raw, length)\n\n for {} iszero(eq(raw, end)) {} {\n raw := add(raw, 1)\n mstore8(add(o, 1), mload(and(mload(raw), 15)))\n mstore8(o, mload(and(shr(4, mload(raw)), 15)))\n o := add(o, 2)\n }\n mstore(o, 0) // Zeroize the slot after the string.\n mstore(0x40, add(o, 0x20)) // Allocate the memory.\n }\n }\n\n /*\u00b4:\u00b0\u2022.\u00b0+.*\u2022\u00b4.*:\u02da.\u00b0*.\u02da\u2022\u00b4.\u00b0:\u00b0\u2022.\u00b0\u2022.*\u2022\u00b4.*:\u02da.\u00b0*.\u02da\u2022\u00b4.\u00b0:\u00b0\u2022.\u00b0+.*\u2022\u00b4.*:*/\n /* RUNE STRING OPERATIONS */\n /*.\u2022\u00b0:\u00b0.\u00b4+\u02da.*\u00b0.\u02da:*.\u00b4\u2022*.+\u00b0.\u2022\u00b0:\u00b4*.\u00b4\u2022*.\u2022\u00b0.\u2022\u00b0:\u00b0.\u00b4:\u2022\u02da\u00b0.*\u00b0.\u02da:*.\u00b4+\u00b0.\u2022*/\n\n /// @dev Returns the number of UTF characters in the string.\n function runeCount(string memory s) internal pure returns (uint256 result) {\n /// @solidity memory-safe-assembly\n assembly {\n if mload(s) {\n mstore(0x00, div(not(0), 255))\n mstore(0x20, 0x0202020202020202020202020202020202020202020202020303030304040506)\n let o := add(s, 0x20)\n let end := add(o, mload(s))\n for { result := 1 } 1 { result := add(result, 1) } {\n o := add(o, byte(0, mload(shr(250, mload(o)))))\n if iszero(lt(o, end)) { break }\n }\n }\n }\n }\n\n /// @dev Returns if this string is a 7-bit ASCII string.\n /// (i.e. all characters codes are in [0..127])\n function is7BitASCII(string memory s) internal pure returns (bool result) {\n /// @solidity memory-safe-assembly\n assembly {\n let mask := shl(7, div(not(0), 255))\n result := 1\n let n := mload(s)\n if n {\n let o := add(s, 0x20)\n let end := add(o, n)\n let last := mload(end)\n mstore(end, 0)\n for {} 1 {} {\n if and(mask, mload(o)) {\n result := 0\n break\n }\n o := add(o, 0x20)\n if iszero(lt(o, end)) { break }\n }\n mstore(end, last)\n }\n }\n }\n\n /// @dev Returns if this string is a 7-bit ASCII string,\n /// AND all characters are in the `allowed` lookup.\n /// Note: If `s` is empty, returns true regardless of `allowed`.\n function is7BitASCII(string memory s, uint128 allowed) internal pure returns (bool result) {\n /// @solidity memory-safe-assembly\n assembly {\n result := 1\n if mload(s) {\n let allowed_ := shr(128, shl(128, allowed))\n let o := add(s, 0x20)\n let end := add(o, mload(s))\n for {} 1 {} {\n result := and(result, shr(byte(0, mload(o)), allowed_))\n o := add(o, 1)\n if iszero(and(result, lt(o, end))) { break }\n }\n }\n }\n }\n\n /// @dev Converts the bytes in the 7-bit ASCII string `s` to\n /// an allowed lookup for use in `is7BitASCII(s, allowed)`.\n /// To save runtime gas, you can cache the result in an immutable variable.\n function to7BitASCIIAllowedLookup(string memory s) internal pure returns (uint128 result) {\n /// @solidity memory-safe-assembly\n assembly {\n if mload(s) {\n let o := add(s, 0x20)\n let end := add(o, mload(s))\n for {} 1 {} {\n result := or(result, shl(byte(0, mload(o)), 1))\n o := add(o, 1)\n if iszero(lt(o, end)) { break }\n }\n if shr(128, result) {\n mstore(0x00, 0xc9807e0d) // `StringNot7BitASCII()`.\n revert(0x1c, 0x04)\n }\n }\n }\n }\n\n /*\u00b4:\u00b0\u2022.\u00b0+.*\u2022\u00b4.*:\u02da.\u00b0*.\u02da\u2022\u00b4.\u00b0:\u00b0\u2022.\u00b0\u2022.*\u2022\u00b4.*:\u02da.\u00b0*.\u02da\u2022\u00b4.\u00b0:\u00b0\u2022.\u00b0+.*\u2022\u00b4.*:*/\n /* BYTE STRING OPERATIONS */\n /*.\u2022\u00b0:\u00b0.\u00b4+\u02da.*\u00b0.\u02da:*.\u00b4\u2022*.+\u00b0.\u2022\u00b0:\u00b4*.\u00b4\u2022*.\u2022\u00b0.\u2022\u00b0:\u00b0.\u00b4:\u2022\u02da\u00b0.*\u00b0.\u02da:*.\u00b4+\u00b0.\u2022*/\n\n // For performance and bytecode compactness, byte string operations are restricted\n // to 7-bit ASCII strings. All offsets are byte offsets, not UTF character offsets.\n // Usage of byte string operations on charsets with runes spanning two or more bytes\n // can lead to undefined behavior.\n\n /// @dev Returns `subject` all occurrences of `search` replaced with `replacement`.\n function replace(string memory subject, string memory search, string memory replacement)\n internal\n pure\n returns (string memory result)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let subjectLength := mload(subject)\n let searchLength := mload(search)\n let replacementLength := mload(replacement)\n\n subject := add(subject, 0x20)\n search := add(search, 0x20)\n replacement := add(replacement, 0x20)\n result := add(mload(0x40), 0x20)\n\n let subjectEnd := add(subject, subjectLength)\n if iszero(gt(searchLength, subjectLength)) {\n let subjectSearchEnd := add(sub(subjectEnd, searchLength), 1)\n let h := 0\n if iszero(lt(searchLength, 0x20)) { h := keccak256(search, searchLength) }\n let m := shl(3, sub(0x20, and(searchLength, 0x1f)))\n let s := mload(search)\n for {} 1 {} {\n let t := mload(subject)\n // Whether the first `searchLength % 32` bytes of\n // `subject` and `search` matches.\n if iszero(shr(m, xor(t, s))) {\n if h {\n if iszero(eq(keccak256(subject, searchLength), h)) {\n mstore(result, t)\n result := add(result, 1)\n subject := add(subject, 1)\n if iszero(lt(subject, subjectSearchEnd)) { break }\n continue\n }\n }\n // Copy the `replacement` one word at a time.\n for { let o := 0 } 1 {} {\n mstore(add(result, o), mload(add(replacement, o)))\n o := add(o, 0x20)\n if iszero(lt(o, replacementLength)) { break }\n }\n result := add(result, replacementLength)\n subject := add(subject, searchLength)\n if searchLength {\n if iszero(lt(subject, subjectSearchEnd)) { break }\n continue\n }\n }\n mstore(result, t)\n result := add(result, 1)\n subject := add(subject, 1)\n if iszero(lt(subject, subjectSearchEnd)) { break }\n }\n }\n\n let resultRemainder := result\n result := add(mload(0x40), 0x20)\n let k := add(sub(resultRemainder, result), sub(subjectEnd, subject))\n // Copy the rest of the string one word at a time.\n for {} lt(subject, subjectEnd) {} {\n mstore(resultRemainder, mload(subject))\n resultRemainder := add(resultRemainder, 0x20)\n subject := add(subject, 0x20)\n }\n result := sub(result, 0x20)\n let last := add(add(result, 0x20), k) // Zeroize the slot after the string.\n mstore(last, 0)\n mstore(0x40, add(last, 0x20)) // Allocate the memory.\n mstore(result, k) // Store the length.\n }\n }\n\n /// @dev Returns the byte index of the first location of `search` in `subject`,\n /// searching from left to right, starting from `from`.\n /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found.\n function indexOf(string memory subject, string memory search, uint256 from)\n internal\n pure\n returns (uint256 result)\n {\n /// @solidity memory-safe-assembly\n assembly {\n for { let subjectLength := mload(subject) } 1 {} {\n if iszero(mload(search)) {\n if iszero(gt(from, subjectLength)) {\n result := from\n break\n }\n result := subjectLength\n break\n }\n let searchLength := mload(search)\n let subjectStart := add(subject, 0x20)\n\n result := not(0) // Initialize to `NOT_FOUND`.\n\n subject := add(subjectStart, from)\n let end := add(sub(add(subjectStart, subjectLength), searchLength), 1)\n\n let m := shl(3, sub(0x20, and(searchLength, 0x1f)))\n let s := mload(add(search, 0x20))\n\n if iszero(and(lt(subject, end), lt(from, subjectLength))) { break }\n\n if iszero(lt(searchLength, 0x20)) {\n for { let h := keccak256(add(search, 0x20), searchLength) } 1 {} {\n if iszero(shr(m, xor(mload(subject), s))) {\n if eq(keccak256(subject, searchLength), h) {\n result := sub(subject, subjectStart)\n break\n }\n }\n subject := add(subject, 1)\n if iszero(lt(subject, end)) { break }\n }\n break\n }\n for {} 1 {} {\n if iszero(shr(m, xor(mload(subject), s))) {\n result := sub(subject, subjectStart)\n break\n }\n subject := add(subject, 1)\n if iszero(lt(subject, end)) { break }\n }\n break\n }\n }\n }\n\n /// @dev Returns the byte index of the first location of `search` in `subject`,\n /// searching from left to right.\n /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found.\n function indexOf(string memory subject, string memory search)\n internal\n pure\n returns (uint256 result)\n {\n result = indexOf(subject, search, 0);\n }\n\n /// @dev Returns the byte index of the first location of `search` in `subject`,\n /// searching from right to left, starting from `from`.\n /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found.\n function lastIndexOf(string memory subject, string memory search, uint256 from)\n internal\n pure\n returns (uint256 result)\n {\n /// @solidity memory-safe-assembly\n assembly {\n for {} 1 {} {\n result := not(0) // Initialize to `NOT_FOUND`.\n let searchLength := mload(search)\n if gt(searchLength, mload(subject)) { break }\n let w := result\n\n let fromMax := sub(mload(subject), searchLength)\n if iszero(gt(fromMax, from)) { from := fromMax }\n\n let end := add(add(subject, 0x20), w)\n subject := add(add(subject, 0x20), from)\n if iszero(gt(subject, end)) { break }\n // As this function is not too often used,\n // we shall simply use keccak256 for smaller bytecode size.\n for { let h := keccak256(add(search, 0x20), searchLength) } 1 {} {\n if eq(keccak256(subject, searchLength), h) {\n result := sub(subject, add(end, 1))\n break\n }\n subject := add(subject, w) // `sub(subject, 1)`.\n if iszero(gt(subject, end)) { break }\n }\n break\n }\n }\n }\n\n /// @dev Returns the byte index of the first location of `search` in `subject`,\n /// searching from right to left.\n /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found.\n function lastIndexOf(string memory subject, string memory search)\n internal\n pure\n returns (uint256 result)\n {\n result = lastIndexOf(subject, search, uint256(int256(-1)));\n }\n\n /// @dev Returns true if `search` is found in `subject`, false otherwise.\n function contains(string memory subject, string memory search) internal pure returns (bool) {\n return indexOf(subject, search) != NOT_FOUND;\n }\n\n /// @dev Returns whether `subject` starts with `search`.\n function startsWith(string memory subject, string memory search)\n internal\n pure\n returns (bool result)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let searchLength := mload(search)\n // Just using keccak256 directly is actually cheaper.\n // forgefmt: disable-next-item\n result := and(\n iszero(gt(searchLength, mload(subject))),\n eq(\n keccak256(add(subject, 0x20), searchLength),\n keccak256(add(search, 0x20), searchLength)\n )\n )\n }\n }\n\n /// @dev Returns whether `subject` ends with `search`.\n function endsWith(string memory subject, string memory search)\n internal\n pure\n returns (bool result)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let searchLength := mload(search)\n let subjectLength := mload(subject)\n // Whether `search` is not longer than `subject`.\n let withinRange := iszero(gt(searchLength, subjectLength))\n // Just using keccak256 directly is actually cheaper.\n // forgefmt: disable-next-item\n result := and(\n withinRange,\n eq(\n keccak256(\n // `subject + 0x20 + max(subjectLength - searchLength, 0)`.\n add(add(subject, 0x20), mul(withinRange, sub(subjectLength, searchLength))),\n searchLength\n ),\n keccak256(add(search, 0x20), searchLength)\n )\n )\n }\n }\n\n /// @dev Returns `subject` repeated `times`.\n function repeat(string memory subject, uint256 times)\n internal\n pure\n returns (string memory result)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let subjectLength := mload(subject)\n if iszero(or(iszero(times), iszero(subjectLength))) {\n subject := add(subject, 0x20)\n result := mload(0x40)\n let output := add(result, 0x20)\n for {} 1 {} {\n // Copy the `subject` one word at a time.\n for { let o := 0 } 1 {} {\n mstore(add(output, o), mload(add(subject, o)))\n o := add(o, 0x20)\n if iszero(lt(o, subjectLength)) { break }\n }\n output := add(output, subjectLength)\n times := sub(times, 1)\n if iszero(times) { break }\n }\n mstore(output, 0) // Zeroize the slot after the string.\n let resultLength := sub(output, add(result, 0x20))\n mstore(result, resultLength) // Store the length.\n // Allocate the memory.\n mstore(0x40, add(result, add(resultLength, 0x20)))\n }\n }\n }\n\n /// @dev Returns a copy of `subject` sliced from `start` to `end` (exclusive).\n /// `start` and `end` are byte offsets.\n function slice(string memory subject, uint256 start, uint256 end)\n internal\n pure\n returns (string memory result)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let subjectLength := mload(subject)\n if iszero(gt(subjectLength, end)) { end := subjectLength }\n if iszero(gt(subjectLength, start)) { start := subjectLength }\n if lt(start, end) {\n result := mload(0x40)\n let resultLength := sub(end, start)\n mstore(result, resultLength)\n subject := add(subject, start)\n let w := not(0x1f)\n // Copy the `subject` one word at a time, backwards.\n for { let o := and(add(resultLength, 0x1f), w) } 1 {} {\n mstore(add(result, o), mload(add(subject, o)))\n o := add(o, w) // `sub(o, 0x20)`.\n if iszero(o) { break }\n }\n // Zeroize the slot after the string.\n mstore(add(add(result, 0x20), resultLength), 0)\n // Allocate memory for the length and the bytes,\n // rounded up to a multiple of 32.\n mstore(0x40, add(result, and(add(resultLength, 0x3f), w)))\n }\n }\n }\n\n /// @dev Returns a copy of `subject` sliced from `start` to the end of the string.\n /// `start` is a byte offset.\n function slice(string memory subject, uint256 start)\n internal\n pure\n returns (string memory result)\n {\n result = slice(subject, start, uint256(int256(-1)));\n }\n\n /// @dev Returns all the indices of `search` in `subject`.\n /// The indices are byte offsets.\n function indicesOf(string memory subject, string memory search)\n internal\n pure\n returns (uint256[] memory result)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let subjectLength := mload(subject)\n let searchLength := mload(search)\n\n if iszero(gt(searchLength, subjectLength)) {\n subject := add(subject, 0x20)\n search := add(search, 0x20)\n result := add(mload(0x40), 0x20)\n\n let subjectStart := subject\n let subjectSearchEnd := add(sub(add(subject, subjectLength), searchLength), 1)\n let h := 0\n if iszero(lt(searchLength, 0x20)) { h := keccak256(search, searchLength) }\n let m := shl(3, sub(0x20, and(searchLength, 0x1f)))\n let s := mload(search)\n for {} 1 {} {\n let t := mload(subject)\n // Whether the first `searchLength % 32` bytes of\n // `subject` and `search` matches.\n if iszero(shr(m, xor(t, s))) {\n if h {\n if iszero(eq(keccak256(subject, searchLength), h)) {\n subject := add(subject, 1)\n if iszero(lt(subject, subjectSearchEnd)) { break }\n continue\n }\n }\n // Append to `result`.\n mstore(result, sub(subject, subjectStart))\n result := add(result, 0x20)\n // Advance `subject` by `searchLength`.\n subject := add(subject, searchLength)\n if searchLength {\n if iszero(lt(subject, subjectSearchEnd)) { break }\n continue\n }\n }\n subject := add(subject, 1)\n if iszero(lt(subject, subjectSearchEnd)) { break }\n }\n let resultEnd := result\n // Assign `result` to the free memory pointer.\n result := mload(0x40)\n // Store the length of `result`.\n mstore(result, shr(5, sub(resultEnd, add(result, 0x20))))\n // Allocate memory for result.\n // We allocate one more word, so this array can be recycled for {split}.\n mstore(0x40, add(resultEnd, 0x20))\n }\n }\n }\n\n /// @dev Returns a arrays of strings based on the `delimiter` inside of the `subject` string.\n function split(string memory subject, string memory delimiter)\n internal\n pure\n returns (string[] memory result)\n {\n uint256[] memory indices = indicesOf(subject, delimiter);\n /// @solidity memory-safe-assembly\n assembly {\n let w := not(0x1f)\n let indexPtr := add(indices, 0x20)\n let indicesEnd := add(indexPtr, shl(5, add(mload(indices), 1)))\n mstore(add(indicesEnd, w), mload(subject))\n mstore(indices, add(mload(indices), 1))\n let prevIndex := 0\n for {} 1 {} {\n let index := mload(indexPtr)\n mstore(indexPtr, 0x60)\n if iszero(eq(index, prevIndex)) {\n let element := mload(0x40)\n let elementLength := sub(index, prevIndex)\n mstore(element, elementLength)\n // Copy the `subject` one word at a time, backwards.\n for { let o := and(add(elementLength, 0x1f), w) } 1 {} {\n mstore(add(element, o), mload(add(add(subject, prevIndex), o)))\n o := add(o, w) // `sub(o, 0x20)`.\n if iszero(o) { break }\n }\n // Zeroize the slot after the string.\n mstore(add(add(element, 0x20), elementLength), 0)\n // Allocate memory for the length and the bytes,\n // rounded up to a multiple of 32.\n mstore(0x40, add(element, and(add(elementLength, 0x3f), w)))\n // Store the `element` into the array.\n mstore(indexPtr, element)\n }\n prevIndex := add(index, mload(delimiter))\n indexPtr := add(indexPtr, 0x20)\n if iszero(lt(indexPtr, indicesEnd)) { break }\n }\n result := indices\n if iszero(mload(delimiter)) {\n result := add(indices, 0x20)\n mstore(result, sub(mload(indices), 2))\n }\n }\n }\n\n /// @dev Returns a concatenated string of `a` and `b`.\n /// Cheaper than `string.concat()` and does not de-align the free memory pointer.\n function concat(string memory a, string memory b)\n internal\n pure\n returns (string memory result)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let w := not(0x1f)\n result := mload(0x40)\n let aLength := mload(a)\n // Copy `a` one word at a time, backwards.\n for { let o := and(add(aLength, 0x20), w) } 1 {} {\n mstore(add(result, o), mload(add(a, o)))\n o := add(o, w) // `sub(o, 0x20)`.\n if iszero(o) { break }\n }\n let bLength := mload(b)\n let output := add(result, aLength)\n // Copy `b` one word at a time, backwards.\n for { let o := and(add(bLength, 0x20), w) } 1 {} {\n mstore(add(output, o), mload(add(b, o)))\n o := add(o, w) // `sub(o, 0x20)`.\n if iszero(o) { break }\n }\n let totalLength := add(aLength, bLength)\n let last := add(add(result, 0x20), totalLength)\n // Zeroize the slot after the string.\n mstore(last, 0)\n // Stores the length.\n mstore(result, totalLength)\n // Allocate memory for the length and the bytes,\n // rounded up to a multiple of 32.\n mstore(0x40, and(add(last, 0x1f), w))\n }\n }\n\n /// @dev Returns a copy of the string in either lowercase or UPPERCASE.\n /// WARNING! This function is only compatible with 7-bit ASCII strings.\n function toCase(string memory subject, bool toUpper)\n internal\n pure\n returns (string memory result)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let length := mload(subject)\n if length {\n result := add(mload(0x40), 0x20)\n subject := add(subject, 1)\n let flags := shl(add(70, shl(5, toUpper)), 0x3ffffff)\n let w := not(0)\n for { let o := length } 1 {} {\n o := add(o, w)\n let b := and(0xff, mload(add(subject, o)))\n mstore8(add(result, o), xor(b, and(shr(b, flags), 0x20)))\n if iszero(o) { break }\n }\n result := mload(0x40)\n mstore(result, length) // Store the length.\n let last := add(add(result, 0x20), length)\n mstore(last, 0) // Zeroize the slot after the string.\n mstore(0x40, add(last, 0x20)) // Allocate the memory.\n }\n }\n }\n\n /// @dev Returns a string from a small bytes32 string.\n /// `s` must be null-terminated, or behavior will be undefined.\n function fromSmallString(bytes32 s) internal pure returns (string memory result) {\n /// @solidity memory-safe-assembly\n assembly {\n result := mload(0x40)\n let n := 0\n for {} byte(n, s) { n := add(n, 1) } {} // Scan for '\\0'.\n mstore(result, n)\n let o := add(result, 0x20)\n mstore(o, s)\n mstore(add(o, n), 0)\n mstore(0x40, add(result, 0x40))\n }\n }\n\n /// @dev Returns the small string, with all bytes after the first null byte zeroized.\n function normalizeSmallString(bytes32 s) internal pure returns (bytes32 result) {\n /// @solidity memory-safe-assembly\n assembly {\n for {} byte(result, s) { result := add(result, 1) } {} // Scan for '\\0'.\n mstore(0x00, s)\n mstore(result, 0x00)\n result := mload(0x00)\n }\n }\n\n /// @dev Returns the string as a normalized null-terminated small string.\n function toSmallString(string memory s) internal pure returns (bytes32 result) {\n /// @solidity memory-safe-assembly\n assembly {\n result := mload(s)\n if iszero(lt(result, 33)) {\n mstore(0x00, 0xec92f9a3) // `TooBigForSmallString()`.\n revert(0x1c, 0x04)\n }\n result := shl(shl(3, sub(32, result)), mload(add(s, result)))\n }\n }\n\n /// @dev Returns a lowercased copy of the string.\n /// WARNING! This function is only compatible with 7-bit ASCII strings.\n function lower(string memory subject) internal pure returns (string memory result) {\n result = toCase(subject, false);\n }\n\n /// @dev Returns an UPPERCASED copy of the string.\n /// WARNING! This function is only compatible with 7-bit ASCII strings.\n function upper(string memory subject) internal pure returns (string memory result) {\n result = toCase(subject, true);\n }\n\n /// @dev Escapes the string to be used within HTML tags.\n function escapeHTML(string memory s) internal pure returns (string memory result) {\n /// @solidity memory-safe-assembly\n assembly {\n let end := add(s, mload(s))\n result := add(mload(0x40), 0x20)\n // Store the bytes of the packed offsets and strides into the scratch space.\n // `packed = (stride << 5) | offset`. Max offset is 20. Max stride is 6.\n mstore(0x1f, 0x900094)\n mstore(0x08, 0xc0000000a6ab)\n // Store \""&'<>\" into the scratch space.\n mstore(0x00, shl(64, 0x2671756f743b26616d703b262333393b266c743b2667743b))\n for {} iszero(eq(s, end)) {} {\n s := add(s, 1)\n let c := and(mload(s), 0xff)\n // Not in `[\"\\\"\",\"'\",\"&\",\"<\",\">\"]`.\n if iszero(and(shl(c, 1), 0x500000c400000000)) {\n mstore8(result, c)\n result := add(result, 1)\n continue\n }\n let t := shr(248, mload(c))\n mstore(result, mload(and(t, 0x1f)))\n result := add(result, shr(5, t))\n }\n let last := result\n mstore(last, 0) // Zeroize the slot after the string.\n result := mload(0x40)\n mstore(result, sub(last, add(result, 0x20))) // Store the length.\n mstore(0x40, add(last, 0x20)) // Allocate the memory.\n }\n }\n\n /// @dev Escapes the string to be used within double-quotes in a JSON.\n /// If `addDoubleQuotes` is true, the result will be enclosed in double-quotes.\n function escapeJSON(string memory s, bool addDoubleQuotes)\n internal\n pure\n returns (string memory result)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let end := add(s, mload(s))\n result := add(mload(0x40), 0x20)\n if addDoubleQuotes {\n mstore8(result, 34)\n result := add(1, result)\n }\n // Store \"\\\\u0000\" in scratch space.\n // Store \"0123456789abcdef\" in scratch space.\n // Also, store `{0x08:\"b\", 0x09:\"t\", 0x0a:\"n\", 0x0c:\"f\", 0x0d:\"r\"}`.\n // into the scratch space.\n mstore(0x15, 0x5c75303030303031323334353637383961626364656662746e006672)\n // Bitmask for detecting `[\"\\\"\",\"\\\\\"]`.\n let e := or(shl(0x22, 1), shl(0x5c, 1))\n for {} iszero(eq(s, end)) {} {\n s := add(s, 1)\n let c := and(mload(s), 0xff)\n if iszero(lt(c, 0x20)) {\n if iszero(and(shl(c, 1), e)) {\n // Not in `[\"\\\"\",\"\\\\\"]`.\n mstore8(result, c)\n result := add(result, 1)\n continue\n }\n mstore8(result, 0x5c) // \"\\\\\".\n mstore8(add(result, 1), c)\n result := add(result, 2)\n continue\n }\n if iszero(and(shl(c, 1), 0x3700)) {\n // Not in `[\"\\b\",\"\\t\",\"\\n\",\"\\f\",\"\\d\"]`.\n mstore8(0x1d, mload(shr(4, c))) // Hex value.\n mstore8(0x1e, mload(and(c, 15))) // Hex value.\n mstore(result, mload(0x19)) // \"\\\\u00XX\".\n result := add(result, 6)\n continue\n }\n mstore8(result, 0x5c) // \"\\\\\".\n mstore8(add(result, 1), mload(add(c, 8)))\n result := add(result, 2)\n }\n if addDoubleQuotes {\n mstore8(result, 34)\n result := add(1, result)\n }\n let last := result\n mstore(last, 0) // Zeroize the slot after the string.\n result := mload(0x40)\n mstore(result, sub(last, add(result, 0x20))) // Store the length.\n mstore(0x40, add(last, 0x20)) // Allocate the memory.\n }\n }\n\n /// @dev Escapes the string to be used within double-quotes in a JSON.\n function escapeJSON(string memory s) internal pure returns (string memory result) {\n result = escapeJSON(s, false);\n }\n\n /// @dev Returns whether `a` equals `b`.\n function eq(string memory a, string memory b) internal pure returns (bool result) {\n /// @solidity memory-safe-assembly\n assembly {\n result := eq(keccak256(add(a, 0x20), mload(a)), keccak256(add(b, 0x20), mload(b)))\n }\n }\n\n /// @dev Returns whether `a` equals `b`, where `b` is a null-terminated small string.\n function eqs(string memory a, bytes32 b) internal pure returns (bool result) {\n /// @solidity memory-safe-assembly\n assembly {\n // These should be evaluated on compile time, as far as possible.\n let m := not(shl(7, div(not(iszero(b)), 255))) // `0x7f7f ...`.\n let x := not(or(m, or(b, add(m, and(b, m)))))\n let r := shl(7, iszero(iszero(shr(128, x))))\n r := or(r, shl(6, iszero(iszero(shr(64, 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 result := gt(eq(mload(a), add(iszero(x), xor(31, shr(3, r)))),\n xor(shr(add(8, r), b), shr(add(8, r), mload(add(a, 0x20)))))\n }\n }\n\n /// @dev Packs a single string with its length into a single word.\n /// Returns `bytes32(0)` if the length is zero or greater than 31.\n function packOne(string memory a) internal pure returns (bytes32 result) {\n /// @solidity memory-safe-assembly\n assembly {\n // We don't need to zero right pad the string,\n // since this is our own custom non-standard packing scheme.\n result :=\n mul(\n // Load the length and the bytes.\n mload(add(a, 0x1f)),\n // `length != 0 && length < 32`. Abuses underflow.\n // Assumes that the length is valid and within the block gas limit.\n lt(sub(mload(a), 1), 0x1f)\n )\n }\n }\n\n /// @dev Unpacks a string packed using {packOne}.\n /// Returns the empty string if `packed` is `bytes32(0)`.\n /// If `packed` is not an output of {packOne}, the output behavior is undefined.\n function unpackOne(bytes32 packed) internal pure returns (string memory result) {\n /// @solidity memory-safe-assembly\n assembly {\n // Grab the free memory pointer.\n result := mload(0x40)\n // Allocate 2 words (1 for the length, 1 for the bytes).\n mstore(0x40, add(result, 0x40))\n // Zeroize the length slot.\n mstore(result, 0)\n // Store the length and bytes.\n mstore(add(result, 0x1f), packed)\n // Right pad with zeroes.\n mstore(add(add(result, 0x20), mload(result)), 0)\n }\n }\n\n /// @dev Packs two strings with their lengths into a single word.\n /// Returns `bytes32(0)` if combined length is zero or greater than 30.\n function packTwo(string memory a, string memory b) internal pure returns (bytes32 result) {\n /// @solidity memory-safe-assembly\n assembly {\n let aLength := mload(a)\n // We don't need to zero right pad the strings,\n // since this is our own custom non-standard packing scheme.\n result :=\n mul(\n // Load the length and the bytes of `a` and `b`.\n or(\n shl(shl(3, sub(0x1f, aLength)), mload(add(a, aLength))),\n mload(sub(add(b, 0x1e), aLength))\n ),\n // `totalLength != 0 && totalLength < 31`. Abuses underflow.\n // Assumes that the lengths are valid and within the block gas limit.\n lt(sub(add(aLength, mload(b)), 1), 0x1e)\n )\n }\n }\n\n /// @dev Unpacks strings packed using {packTwo}.\n /// Returns the empty strings if `packed` is `bytes32(0)`.\n /// If `packed` is not an output of {packTwo}, the output behavior is undefined.\n function unpackTwo(bytes32 packed)\n internal\n pure\n returns (string memory resultA, string memory resultB)\n {\n /// @solidity memory-safe-assembly\n assembly {\n // Grab the free memory pointer.\n resultA := mload(0x40)\n resultB := add(resultA, 0x40)\n // Allocate 2 words for each string (1 for the length, 1 for the byte). Total 4 words.\n mstore(0x40, add(resultB, 0x40))\n // Zeroize the length slots.\n mstore(resultA, 0)\n mstore(resultB, 0)\n // Store the lengths and bytes.\n mstore(add(resultA, 0x1f), packed)\n mstore(add(resultB, 0x1f), mload(add(add(resultA, 0x20), mload(resultA))))\n // Right pad with zeroes.\n mstore(add(add(resultA, 0x20), mload(resultA)), 0)\n mstore(add(add(resultB, 0x20), mload(resultB)), 0)\n }\n }\n\n /// @dev Directly returns `a` without copying.\n function directReturn(string memory a) internal pure {\n assembly {\n // Assumes that the string does not start from the scratch space.\n let retStart := sub(a, 0x20)\n let retUnpaddedSize := add(mload(a), 0x40)\n // Right pad with zeroes. Just in case the string is produced\n // by a method that doesn't zero right pad.\n mstore(add(retStart, retUnpaddedSize), 0)\n // Store the return offset.\n mstore(retStart, 0x20)\n // End the transaction, returning the string.\n return(retStart, and(not(0x1f), add(0x1f, retUnpaddedSize)))\n }\n }\n}\n","keccak256":"0x8839b641d7a1ada8c41b16c576e61c56ba4e41f40656ed5e4b6a049fe0e87749","license":"MIT"}},"version":1}