{"sources":{"@chainlink/contracts/src/v0.8/Denominations.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nlibrary Denominations {\n address public constant ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;\n address public constant BTC = 0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB;\n\n // Fiat currencies follow https://en.wikipedia.org/wiki/ISO_4217\n address public constant USD = address(840);\n address public constant GBP = address(826);\n address public constant EUR = address(978);\n address public constant JPY = address(392);\n address public constant KRW = address(410);\n address public constant CNY = address(156);\n address public constant AUD = address(36);\n address public constant CAD = address(124);\n address public constant CHF = address(756);\n address public constant ARS = address(32);\n address public constant PHP = address(608);\n address public constant NZD = address(554);\n address public constant SGD = address(702);\n address public constant NGN = address(566);\n address public constant ZAR = address(710);\n address public constant RUB = address(643);\n address public constant INR = address(356);\n address public constant BRL = address(986);\n}\n"},"@chainlink/contracts/src/v0.8/interfaces/FeedRegistryInterface.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\npragma abicoder v2;\n\nimport {AggregatorV2V3Interface} from \"../shared/interfaces/AggregatorV2V3Interface.sol\";\n\n// solhint-disable-next-line interface-starts-with-i\ninterface FeedRegistryInterface {\n struct Phase {\n uint16 phaseId;\n uint80 startingAggregatorRoundId;\n uint80 endingAggregatorRoundId;\n }\n\n event FeedProposed(\n address indexed asset,\n address indexed denomination,\n address indexed proposedAggregator,\n address currentAggregator,\n address sender\n );\n event FeedConfirmed(\n address indexed asset,\n address indexed denomination,\n address indexed latestAggregator,\n address previousAggregator,\n uint16 nextPhaseId,\n address sender\n );\n\n // V3 AggregatorV3Interface\n\n function decimals(address base, address quote) external view returns (uint8);\n\n function description(address base, address quote) external view returns (string memory);\n\n function version(address base, address quote) external view returns (uint256);\n\n function latestRoundData(\n address base,\n address quote\n ) external view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\n\n function getRoundData(\n address base,\n address quote,\n uint80 _roundId\n ) external view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\n\n // V2 AggregatorInterface\n\n function latestAnswer(address base, address quote) external view returns (int256 answer);\n\n function latestTimestamp(address base, address quote) external view returns (uint256 timestamp);\n\n function latestRound(address base, address quote) external view returns (uint256 roundId);\n\n function getAnswer(address base, address quote, uint256 roundId) external view returns (int256 answer);\n\n function getTimestamp(address base, address quote, uint256 roundId) external view returns (uint256 timestamp);\n\n // Registry getters\n\n function getFeed(address base, address quote) external view returns (AggregatorV2V3Interface aggregator);\n\n function getPhaseFeed(\n address base,\n address quote,\n uint16 phaseId\n ) external view returns (AggregatorV2V3Interface aggregator);\n\n function isFeedEnabled(address aggregator) external view returns (bool);\n\n function getPhase(address base, address quote, uint16 phaseId) external view returns (Phase memory phase);\n\n // Round helpers\n\n function getRoundFeed(\n address base,\n address quote,\n uint80 roundId\n ) external view returns (AggregatorV2V3Interface aggregator);\n\n function getPhaseRange(\n address base,\n address quote,\n uint16 phaseId\n ) external view returns (uint80 startingRoundId, uint80 endingRoundId);\n\n function getPreviousRoundId(\n address base,\n address quote,\n uint80 roundId\n ) external view returns (uint80 previousRoundId);\n\n function getNextRoundId(address base, address quote, uint80 roundId) external view returns (uint80 nextRoundId);\n\n // Feed management\n\n function proposeFeed(address base, address quote, address aggregator) external;\n\n function confirmFeed(address base, address quote, address aggregator) external;\n\n // Proposed aggregator\n\n function getProposedFeed(\n address base,\n address quote\n ) external view returns (AggregatorV2V3Interface proposedAggregator);\n\n function proposedGetRoundData(\n address base,\n address quote,\n uint80 roundId\n ) external view returns (uint80 id, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\n\n function proposedLatestRoundData(\n address base,\n address quote\n ) external view returns (uint80 id, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\n\n // Phases\n function getCurrentPhaseId(address base, address quote) external view returns (uint16 currentPhaseId);\n}\n"},"@chainlink/contracts/src/v0.8/shared/interfaces/AggregatorInterface.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// solhint-disable-next-line interface-starts-with-i\ninterface AggregatorInterface {\n function latestAnswer() external view returns (int256);\n\n function latestTimestamp() external view returns (uint256);\n\n function latestRound() external view returns (uint256);\n\n function getAnswer(uint256 roundId) external view returns (int256);\n\n function getTimestamp(uint256 roundId) external view returns (uint256);\n\n event AnswerUpdated(int256 indexed current, uint256 indexed roundId, uint256 updatedAt);\n\n event NewRound(uint256 indexed roundId, address indexed startedBy, uint256 startedAt);\n}\n"},"@chainlink/contracts/src/v0.8/shared/interfaces/AggregatorV2V3Interface.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport {AggregatorInterface} from \"./AggregatorInterface.sol\";\nimport {AggregatorV3Interface} from \"./AggregatorV3Interface.sol\";\n\n// solhint-disable-next-line interface-starts-with-i\ninterface AggregatorV2V3Interface is AggregatorInterface, AggregatorV3Interface {}\n"},"@chainlink/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n// solhint-disable-next-line interface-starts-with-i\ninterface AggregatorV3Interface {\n function decimals() external view returns (uint8);\n\n function description() external view returns (string memory);\n\n function version() external view returns (uint256);\n\n function getRoundData(\n uint80 _roundId\n ) external view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\n\n function latestRoundData()\n external\n view\n returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\n}\n"},"@openzeppelin/contracts/access/AccessControl.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (access/AccessControl.sol)\n\npragma solidity ^0.8.20;\n\nimport {IAccessControl} from \"./IAccessControl.sol\";\nimport {Context} from \"../utils/Context.sol\";\nimport {ERC165} from \"../utils/introspection/ERC165.sol\";\n\n/**\n * @dev Contract module that allows children to implement role-based access\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\n * members except through off-chain means by accessing the contract event logs. Some\n * applications may benefit from on-chain enumerability, for those cases see\n * {AccessControlEnumerable}.\n *\n * Roles are referred to by their `bytes32` identifier. These should be exposed\n * in the external API and be unique. The best way to achieve this is by\n * using `public constant` hash digests:\n *\n * ```solidity\n * bytes32 public constant MY_ROLE = keccak256(\"MY_ROLE\");\n * ```\n *\n * Roles can be used to represent a set of permissions. To restrict access to a\n * function call, use {hasRole}:\n *\n * ```solidity\n * function foo() public {\n * require(hasRole(MY_ROLE, msg.sender));\n * ...\n * }\n * ```\n *\n * Roles can be granted and revoked dynamically via the {grantRole} and\n * {revokeRole} functions. Each role has an associated admin role, and only\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\n *\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\n * that only accounts with this role will be able to grant or revoke other\n * roles. More complex role relationships can be created by using\n * {_setRoleAdmin}.\n *\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\n * grant and revoke this role. Extra precautions should be taken to secure\n * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}\n * to enforce additional security measures for this role.\n */\nabstract contract AccessControl is Context, IAccessControl, ERC165 {\n struct RoleData {\n mapping(address account => bool) hasRole;\n bytes32 adminRole;\n }\n\n mapping(bytes32 role => RoleData) private _roles;\n\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\n\n /**\n * @dev Modifier that checks that an account has a specific role. Reverts\n * with an {AccessControlUnauthorizedAccount} error including the required role.\n */\n modifier onlyRole(bytes32 role) {\n _checkRole(role);\n _;\n }\n\n /**\n * @dev See {IERC165-supportsInterface}.\n */\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);\n }\n\n /**\n * @dev Returns `true` if `account` has been granted `role`.\n */\n function hasRole(bytes32 role, address account) public view virtual returns (bool) {\n return _roles[role].hasRole[account];\n }\n\n /**\n * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `_msgSender()`\n * is missing `role`. Overriding this function changes the behavior of the {onlyRole} modifier.\n */\n function _checkRole(bytes32 role) internal view virtual {\n _checkRole(role, _msgSender());\n }\n\n /**\n * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `account`\n * is missing `role`.\n */\n function _checkRole(bytes32 role, address account) internal view virtual {\n if (!hasRole(role, account)) {\n revert AccessControlUnauthorizedAccount(account, role);\n }\n }\n\n /**\n * @dev Returns the admin role that controls `role`. See {grantRole} and\n * {revokeRole}.\n *\n * To change a role's admin, use {_setRoleAdmin}.\n */\n function getRoleAdmin(bytes32 role) public view virtual returns (bytes32) {\n return _roles[role].adminRole;\n }\n\n /**\n * @dev Grants `role` to `account`.\n *\n * If `account` had not been already granted `role`, emits a {RoleGranted}\n * event.\n *\n * Requirements:\n *\n * - the caller must have ``role``'s admin role.\n *\n * May emit a {RoleGranted} event.\n */\n function grantRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {\n _grantRole(role, account);\n }\n\n /**\n * @dev Revokes `role` from `account`.\n *\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\n *\n * Requirements:\n *\n * - the caller must have ``role``'s admin role.\n *\n * May emit a {RoleRevoked} event.\n */\n function revokeRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {\n _revokeRole(role, account);\n }\n\n /**\n * @dev Revokes `role` from the calling account.\n *\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\n * purpose is to provide a mechanism for accounts to lose their privileges\n * if they are compromised (such as when a trusted device is misplaced).\n *\n * If the calling account had been revoked `role`, emits a {RoleRevoked}\n * event.\n *\n * Requirements:\n *\n * - the caller must be `callerConfirmation`.\n *\n * May emit a {RoleRevoked} event.\n */\n function renounceRole(bytes32 role, address callerConfirmation) public virtual {\n if (callerConfirmation != _msgSender()) {\n revert AccessControlBadConfirmation();\n }\n\n _revokeRole(role, callerConfirmation);\n }\n\n /**\n * @dev Sets `adminRole` as ``role``'s admin role.\n *\n * Emits a {RoleAdminChanged} event.\n */\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\n bytes32 previousAdminRole = getRoleAdmin(role);\n _roles[role].adminRole = adminRole;\n emit RoleAdminChanged(role, previousAdminRole, adminRole);\n }\n\n /**\n * @dev Attempts to grant `role` to `account` and returns a boolean indicating if `role` was granted.\n *\n * Internal function without access restriction.\n *\n * May emit a {RoleGranted} event.\n */\n function _grantRole(bytes32 role, address account) internal virtual returns (bool) {\n if (!hasRole(role, account)) {\n _roles[role].hasRole[account] = true;\n emit RoleGranted(role, account, _msgSender());\n return true;\n } else {\n return false;\n }\n }\n\n /**\n * @dev Attempts to revoke `role` to `account` and returns a boolean indicating if `role` was revoked.\n *\n * Internal function without access restriction.\n *\n * May emit a {RoleRevoked} event.\n */\n function _revokeRole(bytes32 role, address account) internal virtual returns (bool) {\n if (hasRole(role, account)) {\n _roles[role].hasRole[account] = false;\n emit RoleRevoked(role, account, _msgSender());\n return true;\n } else {\n return false;\n }\n }\n}\n"},"@openzeppelin/contracts/access/extensions/AccessControlDefaultAdminRules.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (access/extensions/AccessControlDefaultAdminRules.sol)\n\npragma solidity ^0.8.20;\n\nimport {IAccessControlDefaultAdminRules} from \"./IAccessControlDefaultAdminRules.sol\";\nimport {AccessControl, IAccessControl} from \"../AccessControl.sol\";\nimport {SafeCast} from \"../../utils/math/SafeCast.sol\";\nimport {Math} from \"../../utils/math/Math.sol\";\nimport {IERC5313} from \"../../interfaces/IERC5313.sol\";\n\n/**\n * @dev Extension of {AccessControl} that allows specifying special rules to manage\n * the `DEFAULT_ADMIN_ROLE` holder, which is a sensitive role with special permissions\n * over other roles that may potentially have privileged rights in the system.\n *\n * If a specific role doesn't have an admin role assigned, the holder of the\n * `DEFAULT_ADMIN_ROLE` will have the ability to grant it and revoke it.\n *\n * This contract implements the following risk mitigations on top of {AccessControl}:\n *\n * * Only one account holds the `DEFAULT_ADMIN_ROLE` since deployment until it's potentially renounced.\n * * Enforces a 2-step process to transfer the `DEFAULT_ADMIN_ROLE` to another account.\n * * Enforces a configurable delay between the two steps, with the ability to cancel before the transfer is accepted.\n * * The delay can be changed by scheduling, see {changeDefaultAdminDelay}.\n * * It is not possible to use another role to manage the `DEFAULT_ADMIN_ROLE`.\n *\n * Example usage:\n *\n * ```solidity\n * contract MyToken is AccessControlDefaultAdminRules {\n * constructor() AccessControlDefaultAdminRules(\n * 3 days,\n * msg.sender // Explicit initial `DEFAULT_ADMIN_ROLE` holder\n * ) {}\n * }\n * ```\n */\nabstract contract AccessControlDefaultAdminRules is IAccessControlDefaultAdminRules, IERC5313, AccessControl {\n // pending admin pair read/written together frequently\n address private _pendingDefaultAdmin;\n uint48 private _pendingDefaultAdminSchedule; // 0 == unset\n\n uint48 private _currentDelay;\n address private _currentDefaultAdmin;\n\n // pending delay pair read/written together frequently\n uint48 private _pendingDelay;\n uint48 private _pendingDelaySchedule; // 0 == unset\n\n /**\n * @dev Sets the initial values for {defaultAdminDelay} and {defaultAdmin} address.\n */\n constructor(uint48 initialDelay, address initialDefaultAdmin) {\n if (initialDefaultAdmin == address(0)) {\n revert AccessControlInvalidDefaultAdmin(address(0));\n }\n _currentDelay = initialDelay;\n _grantRole(DEFAULT_ADMIN_ROLE, initialDefaultAdmin);\n }\n\n /**\n * @dev See {IERC165-supportsInterface}.\n */\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n return interfaceId == type(IAccessControlDefaultAdminRules).interfaceId || super.supportsInterface(interfaceId);\n }\n\n /**\n * @dev See {IERC5313-owner}.\n */\n function owner() public view virtual returns (address) {\n return defaultAdmin();\n }\n\n ///\n /// Override AccessControl role management\n ///\n\n /**\n * @dev See {AccessControl-grantRole}. Reverts for `DEFAULT_ADMIN_ROLE`.\n */\n function grantRole(bytes32 role, address account) public virtual override(AccessControl, IAccessControl) {\n if (role == DEFAULT_ADMIN_ROLE) {\n revert AccessControlEnforcedDefaultAdminRules();\n }\n super.grantRole(role, account);\n }\n\n /**\n * @dev See {AccessControl-revokeRole}. Reverts for `DEFAULT_ADMIN_ROLE`.\n */\n function revokeRole(bytes32 role, address account) public virtual override(AccessControl, IAccessControl) {\n if (role == DEFAULT_ADMIN_ROLE) {\n revert AccessControlEnforcedDefaultAdminRules();\n }\n super.revokeRole(role, account);\n }\n\n /**\n * @dev See {AccessControl-renounceRole}.\n *\n * For the `DEFAULT_ADMIN_ROLE`, it only allows renouncing in two steps by first calling\n * {beginDefaultAdminTransfer} to the `address(0)`, so it's required that the {pendingDefaultAdmin} schedule\n * has also passed when calling this function.\n *\n * After its execution, it will not be possible to call `onlyRole(DEFAULT_ADMIN_ROLE)` functions.\n *\n * NOTE: Renouncing `DEFAULT_ADMIN_ROLE` will leave the contract without a {defaultAdmin},\n * thereby disabling any functionality that is only available for it, and the possibility of reassigning a\n * non-administrated role.\n */\n function renounceRole(bytes32 role, address account) public virtual override(AccessControl, IAccessControl) {\n if (role == DEFAULT_ADMIN_ROLE && account == defaultAdmin()) {\n (address newDefaultAdmin, uint48 schedule) = pendingDefaultAdmin();\n if (newDefaultAdmin != address(0) || !_isScheduleSet(schedule) || !_hasSchedulePassed(schedule)) {\n revert AccessControlEnforcedDefaultAdminDelay(schedule);\n }\n delete _pendingDefaultAdminSchedule;\n }\n super.renounceRole(role, account);\n }\n\n /**\n * @dev See {AccessControl-_grantRole}.\n *\n * For `DEFAULT_ADMIN_ROLE`, it only allows granting if there isn't already a {defaultAdmin} or if the\n * role has been previously renounced.\n *\n * NOTE: Exposing this function through another mechanism may make the `DEFAULT_ADMIN_ROLE`\n * assignable again. Make sure to guarantee this is the expected behavior in your implementation.\n */\n function _grantRole(bytes32 role, address account) internal virtual override returns (bool) {\n if (role == DEFAULT_ADMIN_ROLE) {\n if (defaultAdmin() != address(0)) {\n revert AccessControlEnforcedDefaultAdminRules();\n }\n _currentDefaultAdmin = account;\n }\n return super._grantRole(role, account);\n }\n\n /**\n * @dev See {AccessControl-_revokeRole}.\n */\n function _revokeRole(bytes32 role, address account) internal virtual override returns (bool) {\n if (role == DEFAULT_ADMIN_ROLE && account == defaultAdmin()) {\n delete _currentDefaultAdmin;\n }\n return super._revokeRole(role, account);\n }\n\n /**\n * @dev See {AccessControl-_setRoleAdmin}. Reverts for `DEFAULT_ADMIN_ROLE`.\n */\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual override {\n if (role == DEFAULT_ADMIN_ROLE) {\n revert AccessControlEnforcedDefaultAdminRules();\n }\n super._setRoleAdmin(role, adminRole);\n }\n\n ///\n /// AccessControlDefaultAdminRules accessors\n ///\n\n /**\n * @inheritdoc IAccessControlDefaultAdminRules\n */\n function defaultAdmin() public view virtual returns (address) {\n return _currentDefaultAdmin;\n }\n\n /**\n * @inheritdoc IAccessControlDefaultAdminRules\n */\n function pendingDefaultAdmin() public view virtual returns (address newAdmin, uint48 schedule) {\n return (_pendingDefaultAdmin, _pendingDefaultAdminSchedule);\n }\n\n /**\n * @inheritdoc IAccessControlDefaultAdminRules\n */\n function defaultAdminDelay() public view virtual returns (uint48) {\n uint48 schedule = _pendingDelaySchedule;\n return (_isScheduleSet(schedule) && _hasSchedulePassed(schedule)) ? _pendingDelay : _currentDelay;\n }\n\n /**\n * @inheritdoc IAccessControlDefaultAdminRules\n */\n function pendingDefaultAdminDelay() public view virtual returns (uint48 newDelay, uint48 schedule) {\n schedule = _pendingDelaySchedule;\n return (_isScheduleSet(schedule) && !_hasSchedulePassed(schedule)) ? (_pendingDelay, schedule) : (0, 0);\n }\n\n /**\n * @inheritdoc IAccessControlDefaultAdminRules\n */\n function defaultAdminDelayIncreaseWait() public view virtual returns (uint48) {\n return 5 days;\n }\n\n ///\n /// AccessControlDefaultAdminRules public and internal setters for defaultAdmin/pendingDefaultAdmin\n ///\n\n /**\n * @inheritdoc IAccessControlDefaultAdminRules\n */\n function beginDefaultAdminTransfer(address newAdmin) public virtual onlyRole(DEFAULT_ADMIN_ROLE) {\n _beginDefaultAdminTransfer(newAdmin);\n }\n\n /**\n * @dev See {beginDefaultAdminTransfer}.\n *\n * Internal function without access restriction.\n */\n function _beginDefaultAdminTransfer(address newAdmin) internal virtual {\n uint48 newSchedule = SafeCast.toUint48(block.timestamp) + defaultAdminDelay();\n _setPendingDefaultAdmin(newAdmin, newSchedule);\n emit DefaultAdminTransferScheduled(newAdmin, newSchedule);\n }\n\n /**\n * @inheritdoc IAccessControlDefaultAdminRules\n */\n function cancelDefaultAdminTransfer() public virtual onlyRole(DEFAULT_ADMIN_ROLE) {\n _cancelDefaultAdminTransfer();\n }\n\n /**\n * @dev See {cancelDefaultAdminTransfer}.\n *\n * Internal function without access restriction.\n */\n function _cancelDefaultAdminTransfer() internal virtual {\n _setPendingDefaultAdmin(address(0), 0);\n }\n\n /**\n * @inheritdoc IAccessControlDefaultAdminRules\n */\n function acceptDefaultAdminTransfer() public virtual {\n (address newDefaultAdmin, ) = pendingDefaultAdmin();\n if (_msgSender() != newDefaultAdmin) {\n // Enforce newDefaultAdmin explicit acceptance.\n revert AccessControlInvalidDefaultAdmin(_msgSender());\n }\n _acceptDefaultAdminTransfer();\n }\n\n /**\n * @dev See {acceptDefaultAdminTransfer}.\n *\n * Internal function without access restriction.\n */\n function _acceptDefaultAdminTransfer() internal virtual {\n (address newAdmin, uint48 schedule) = pendingDefaultAdmin();\n if (!_isScheduleSet(schedule) || !_hasSchedulePassed(schedule)) {\n revert AccessControlEnforcedDefaultAdminDelay(schedule);\n }\n _revokeRole(DEFAULT_ADMIN_ROLE, defaultAdmin());\n _grantRole(DEFAULT_ADMIN_ROLE, newAdmin);\n delete _pendingDefaultAdmin;\n delete _pendingDefaultAdminSchedule;\n }\n\n ///\n /// AccessControlDefaultAdminRules public and internal setters for defaultAdminDelay/pendingDefaultAdminDelay\n ///\n\n /**\n * @inheritdoc IAccessControlDefaultAdminRules\n */\n function changeDefaultAdminDelay(uint48 newDelay) public virtual onlyRole(DEFAULT_ADMIN_ROLE) {\n _changeDefaultAdminDelay(newDelay);\n }\n\n /**\n * @dev See {changeDefaultAdminDelay}.\n *\n * Internal function without access restriction.\n */\n function _changeDefaultAdminDelay(uint48 newDelay) internal virtual {\n uint48 newSchedule = SafeCast.toUint48(block.timestamp) + _delayChangeWait(newDelay);\n _setPendingDelay(newDelay, newSchedule);\n emit DefaultAdminDelayChangeScheduled(newDelay, newSchedule);\n }\n\n /**\n * @inheritdoc IAccessControlDefaultAdminRules\n */\n function rollbackDefaultAdminDelay() public virtual onlyRole(DEFAULT_ADMIN_ROLE) {\n _rollbackDefaultAdminDelay();\n }\n\n /**\n * @dev See {rollbackDefaultAdminDelay}.\n *\n * Internal function without access restriction.\n */\n function _rollbackDefaultAdminDelay() internal virtual {\n _setPendingDelay(0, 0);\n }\n\n /**\n * @dev Returns the amount of seconds to wait after the `newDelay` will\n * become the new {defaultAdminDelay}.\n *\n * The value returned guarantees that if the delay is reduced, it will go into effect\n * after a wait that honors the previously set delay.\n *\n * See {defaultAdminDelayIncreaseWait}.\n */\n function _delayChangeWait(uint48 newDelay) internal view virtual returns (uint48) {\n uint48 currentDelay = defaultAdminDelay();\n\n // When increasing the delay, we schedule the delay change to occur after a period of \"new delay\" has passed, up\n // to a maximum given by defaultAdminDelayIncreaseWait, by default 5 days. For example, if increasing from 1 day\n // to 3 days, the new delay will come into effect after 3 days. If increasing from 1 day to 10 days, the new\n // delay will come into effect after 5 days. The 5 day wait period is intended to be able to fix an error like\n // using milliseconds instead of seconds.\n //\n // When decreasing the delay, we wait the difference between \"current delay\" and \"new delay\". This guarantees\n // that an admin transfer cannot be made faster than \"current delay\" at the time the delay change is scheduled.\n // For example, if decreasing from 10 days to 3 days, the new delay will come into effect after 7 days.\n return\n newDelay > currentDelay\n ? uint48(Math.min(newDelay, defaultAdminDelayIncreaseWait())) // no need to safecast, both inputs are uint48\n : currentDelay - newDelay;\n }\n\n ///\n /// Private setters\n ///\n\n /**\n * @dev Setter of the tuple for pending admin and its schedule.\n *\n * May emit a DefaultAdminTransferCanceled event.\n */\n function _setPendingDefaultAdmin(address newAdmin, uint48 newSchedule) private {\n (, uint48 oldSchedule) = pendingDefaultAdmin();\n\n _pendingDefaultAdmin = newAdmin;\n _pendingDefaultAdminSchedule = newSchedule;\n\n // An `oldSchedule` from `pendingDefaultAdmin()` is only set if it hasn't been accepted.\n if (_isScheduleSet(oldSchedule)) {\n // Emit for implicit cancellations when another default admin was scheduled.\n emit DefaultAdminTransferCanceled();\n }\n }\n\n /**\n * @dev Setter of the tuple for pending delay and its schedule.\n *\n * May emit a DefaultAdminDelayChangeCanceled event.\n */\n function _setPendingDelay(uint48 newDelay, uint48 newSchedule) private {\n uint48 oldSchedule = _pendingDelaySchedule;\n\n if (_isScheduleSet(oldSchedule)) {\n if (_hasSchedulePassed(oldSchedule)) {\n // Materialize a virtual delay\n _currentDelay = _pendingDelay;\n } else {\n // Emit for implicit cancellations when another delay was scheduled.\n emit DefaultAdminDelayChangeCanceled();\n }\n }\n\n _pendingDelay = newDelay;\n _pendingDelaySchedule = newSchedule;\n }\n\n ///\n /// Private helpers\n ///\n\n /**\n * @dev Defines if an `schedule` is considered set. For consistency purposes.\n */\n function _isScheduleSet(uint48 schedule) private pure returns (bool) {\n return schedule != 0;\n }\n\n /**\n * @dev Defines if an `schedule` is considered passed. For consistency purposes.\n */\n function _hasSchedulePassed(uint48 schedule) private view returns (bool) {\n return schedule < block.timestamp;\n }\n}\n"},"@openzeppelin/contracts/access/extensions/IAccessControlDefaultAdminRules.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (access/extensions/IAccessControlDefaultAdminRules.sol)\n\npragma solidity ^0.8.20;\n\nimport {IAccessControl} from \"../IAccessControl.sol\";\n\n/**\n * @dev External interface of AccessControlDefaultAdminRules declared to support ERC165 detection.\n */\ninterface IAccessControlDefaultAdminRules is IAccessControl {\n /**\n * @dev The new default admin is not a valid default admin.\n */\n error AccessControlInvalidDefaultAdmin(address defaultAdmin);\n\n /**\n * @dev At least one of the following rules was violated:\n *\n * - The `DEFAULT_ADMIN_ROLE` must only be managed by itself.\n * - The `DEFAULT_ADMIN_ROLE` must only be held by one account at the time.\n * - Any `DEFAULT_ADMIN_ROLE` transfer must be in two delayed steps.\n */\n error AccessControlEnforcedDefaultAdminRules();\n\n /**\n * @dev The delay for transferring the default admin delay is enforced and\n * the operation must wait until `schedule`.\n *\n * NOTE: `schedule` can be 0 indicating there's no transfer scheduled.\n */\n error AccessControlEnforcedDefaultAdminDelay(uint48 schedule);\n\n /**\n * @dev Emitted when a {defaultAdmin} transfer is started, setting `newAdmin` as the next\n * address to become the {defaultAdmin} by calling {acceptDefaultAdminTransfer} only after `acceptSchedule`\n * passes.\n */\n event DefaultAdminTransferScheduled(address indexed newAdmin, uint48 acceptSchedule);\n\n /**\n * @dev Emitted when a {pendingDefaultAdmin} is reset if it was never accepted, regardless of its schedule.\n */\n event DefaultAdminTransferCanceled();\n\n /**\n * @dev Emitted when a {defaultAdminDelay} change is started, setting `newDelay` as the next\n * delay to be applied between default admin transfer after `effectSchedule` has passed.\n */\n event DefaultAdminDelayChangeScheduled(uint48 newDelay, uint48 effectSchedule);\n\n /**\n * @dev Emitted when a {pendingDefaultAdminDelay} is reset if its schedule didn't pass.\n */\n event DefaultAdminDelayChangeCanceled();\n\n /**\n * @dev Returns the address of the current `DEFAULT_ADMIN_ROLE` holder.\n */\n function defaultAdmin() external view returns (address);\n\n /**\n * @dev Returns a tuple of a `newAdmin` and an accept schedule.\n *\n * After the `schedule` passes, the `newAdmin` will be able to accept the {defaultAdmin} role\n * by calling {acceptDefaultAdminTransfer}, completing the role transfer.\n *\n * A zero value only in `acceptSchedule` indicates no pending admin transfer.\n *\n * NOTE: A zero address `newAdmin` means that {defaultAdmin} is being renounced.\n */\n function pendingDefaultAdmin() external view returns (address newAdmin, uint48 acceptSchedule);\n\n /**\n * @dev Returns the delay required to schedule the acceptance of a {defaultAdmin} transfer started.\n *\n * This delay will be added to the current timestamp when calling {beginDefaultAdminTransfer} to set\n * the acceptance schedule.\n *\n * NOTE: If a delay change has been scheduled, it will take effect as soon as the schedule passes, making this\n * function returns the new delay. See {changeDefaultAdminDelay}.\n */\n function defaultAdminDelay() external view returns (uint48);\n\n /**\n * @dev Returns a tuple of `newDelay` and an effect schedule.\n *\n * After the `schedule` passes, the `newDelay` will get into effect immediately for every\n * new {defaultAdmin} transfer started with {beginDefaultAdminTransfer}.\n *\n * A zero value only in `effectSchedule` indicates no pending delay change.\n *\n * NOTE: A zero value only for `newDelay` means that the next {defaultAdminDelay}\n * will be zero after the effect schedule.\n */\n function pendingDefaultAdminDelay() external view returns (uint48 newDelay, uint48 effectSchedule);\n\n /**\n * @dev Starts a {defaultAdmin} transfer by setting a {pendingDefaultAdmin} scheduled for acceptance\n * after the current timestamp plus a {defaultAdminDelay}.\n *\n * Requirements:\n *\n * - Only can be called by the current {defaultAdmin}.\n *\n * Emits a DefaultAdminRoleChangeStarted event.\n */\n function beginDefaultAdminTransfer(address newAdmin) external;\n\n /**\n * @dev Cancels a {defaultAdmin} transfer previously started with {beginDefaultAdminTransfer}.\n *\n * A {pendingDefaultAdmin} not yet accepted can also be cancelled with this function.\n *\n * Requirements:\n *\n * - Only can be called by the current {defaultAdmin}.\n *\n * May emit a DefaultAdminTransferCanceled event.\n */\n function cancelDefaultAdminTransfer() external;\n\n /**\n * @dev Completes a {defaultAdmin} transfer previously started with {beginDefaultAdminTransfer}.\n *\n * After calling the function:\n *\n * - `DEFAULT_ADMIN_ROLE` should be granted to the caller.\n * - `DEFAULT_ADMIN_ROLE` should be revoked from the previous holder.\n * - {pendingDefaultAdmin} should be reset to zero values.\n *\n * Requirements:\n *\n * - Only can be called by the {pendingDefaultAdmin}'s `newAdmin`.\n * - The {pendingDefaultAdmin}'s `acceptSchedule` should've passed.\n */\n function acceptDefaultAdminTransfer() external;\n\n /**\n * @dev Initiates a {defaultAdminDelay} update by setting a {pendingDefaultAdminDelay} scheduled for getting\n * into effect after the current timestamp plus a {defaultAdminDelay}.\n *\n * This function guarantees that any call to {beginDefaultAdminTransfer} done between the timestamp this\n * method is called and the {pendingDefaultAdminDelay} effect schedule will use the current {defaultAdminDelay}\n * set before calling.\n *\n * The {pendingDefaultAdminDelay}'s effect schedule is defined in a way that waiting until the schedule and then\n * calling {beginDefaultAdminTransfer} with the new delay will take at least the same as another {defaultAdmin}\n * complete transfer (including acceptance).\n *\n * The schedule is designed for two scenarios:\n *\n * - When the delay is changed for a larger one the schedule is `block.timestamp + newDelay` capped by\n * {defaultAdminDelayIncreaseWait}.\n * - When the delay is changed for a shorter one, the schedule is `block.timestamp + (current delay - new delay)`.\n *\n * A {pendingDefaultAdminDelay} that never got into effect will be canceled in favor of a new scheduled change.\n *\n * Requirements:\n *\n * - Only can be called by the current {defaultAdmin}.\n *\n * Emits a DefaultAdminDelayChangeScheduled event and may emit a DefaultAdminDelayChangeCanceled event.\n */\n function changeDefaultAdminDelay(uint48 newDelay) external;\n\n /**\n * @dev Cancels a scheduled {defaultAdminDelay} change.\n *\n * Requirements:\n *\n * - Only can be called by the current {defaultAdmin}.\n *\n * May emit a DefaultAdminDelayChangeCanceled event.\n */\n function rollbackDefaultAdminDelay() external;\n\n /**\n * @dev Maximum time in seconds for an increase to {defaultAdminDelay} (that is scheduled using {changeDefaultAdminDelay})\n * to take effect. Default to 5 days.\n *\n * When the {defaultAdminDelay} is scheduled to be increased, it goes into effect after the new delay has passed with\n * the purpose of giving enough time for reverting any accidental change (i.e. using milliseconds instead of seconds)\n * that may lock the contract. However, to avoid excessive schedules, the wait is capped by this function and it can\n * be overrode for a custom {defaultAdminDelay} increase scheduling.\n *\n * IMPORTANT: Make sure to add a reasonable amount of time while overriding this value, otherwise,\n * there's a risk of setting a high new delay that goes into effect almost immediately without the\n * possibility of human intervention in the case of an input error (eg. set milliseconds instead of seconds).\n */\n function defaultAdminDelayIncreaseWait() external view returns (uint48);\n}\n"},"@openzeppelin/contracts/access/IAccessControl.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (access/IAccessControl.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev External interface of AccessControl declared to support ERC165 detection.\n */\ninterface IAccessControl {\n /**\n * @dev The `account` is missing a role.\n */\n error AccessControlUnauthorizedAccount(address account, bytes32 neededRole);\n\n /**\n * @dev The caller of a function is not the expected one.\n *\n * NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.\n */\n error AccessControlBadConfirmation();\n\n /**\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\n *\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\n * {RoleAdminChanged} not being emitted signaling this.\n */\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\n\n /**\n * @dev Emitted when `account` is granted `role`.\n *\n * `sender` is the account that originated the contract call, an admin role\n * bearer except when using {AccessControl-_setupRole}.\n */\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\n\n /**\n * @dev Emitted when `account` is revoked `role`.\n *\n * `sender` is the account that originated the contract call:\n * - if using `revokeRole`, it is the admin role bearer\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\n */\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\n\n /**\n * @dev Returns `true` if `account` has been granted `role`.\n */\n function hasRole(bytes32 role, address account) external view returns (bool);\n\n /**\n * @dev Returns the admin role that controls `role`. See {grantRole} and\n * {revokeRole}.\n *\n * To change a role's admin, use {AccessControl-_setRoleAdmin}.\n */\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\n\n /**\n * @dev Grants `role` to `account`.\n *\n * If `account` had not been already granted `role`, emits a {RoleGranted}\n * event.\n *\n * Requirements:\n *\n * - the caller must have ``role``'s admin role.\n */\n function grantRole(bytes32 role, address account) external;\n\n /**\n * @dev Revokes `role` from `account`.\n *\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\n *\n * Requirements:\n *\n * - the caller must have ``role``'s admin role.\n */\n function revokeRole(bytes32 role, address account) external;\n\n /**\n * @dev Revokes `role` from the calling account.\n *\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\n * purpose is to provide a mechanism for accounts to lose their privileges\n * if they are compromised (such as when a trusted device is misplaced).\n *\n * If the calling account had been granted `role`, emits a {RoleRevoked}\n * event.\n *\n * Requirements:\n *\n * - the caller must be `callerConfirmation`.\n */\n function renounceRole(bytes32 role, address callerConfirmation) external;\n}\n"},"@openzeppelin/contracts/interfaces/IERC5313.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC5313.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface for the Light Contract Ownership Standard.\n *\n * A standardized minimal interface required to identify an account that controls a contract\n */\ninterface IERC5313 {\n /**\n * @dev Gets the address of the owner.\n */\n function owner() external view returns (address);\n}\n"},"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"../IERC20.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n */\ninterface IERC20Metadata is IERC20 {\n /**\n * @dev Returns the name of the token.\n */\n function name() external view returns (string memory);\n\n /**\n * @dev Returns the symbol of the token.\n */\n function symbol() external view returns (string memory);\n\n /**\n * @dev Returns the decimals places of the token.\n */\n function decimals() external view returns (uint8);\n}\n"},"@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)\n\npragma solidity ^0.8.20;\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"},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.20;\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 value of tokens in existence.\n */\n function totalSupply() external view returns (uint256);\n\n /**\n * @dev Returns the value of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n * @dev Moves a `value` amount of tokens from the caller's account to `to`.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transfer(address to, uint256 value) external returns (bool);\n\n /**\n * @dev Returns the remaining number of tokens that `spender` will be\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\n * zero by default.\n *\n * This value changes when {approve} or {transferFrom} are called.\n */\n function allowance(address owner, address spender) external view returns (uint256);\n\n /**\n * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n * caller's tokens.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\n * that someone may use both the old and the new allowance by unfortunate\n * transaction ordering. One possible solution to mitigate this race\n * condition is to first reduce the spender's allowance to 0 and set the\n * desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n *\n * Emits an {Approval} event.\n */\n function approve(address spender, uint256 value) external returns (bool);\n\n /**\n * @dev Moves a `value` amount of tokens from `from` to `to` using the\n * allowance mechanism. `value` is then deducted from the caller's\n * allowance.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(address from, address to, uint256 value) external returns (bool);\n}\n"},"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"../IERC20.sol\";\nimport {IERC20Permit} from \"../extensions/IERC20Permit.sol\";\nimport {Address} from \"../../../utils/Address.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20 {\n using Address for address;\n\n /**\n * @dev An operation with an ERC20 token failed.\n */\n error SafeERC20FailedOperation(address token);\n\n /**\n * @dev Indicates a failed `decreaseAllowance` request.\n */\n error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\n\n /**\n * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\n * non-reverting calls are assumed to be successful.\n */\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\n _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\n }\n\n /**\n * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\n * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\n */\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\n _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\n }\n\n /**\n * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\n * non-reverting calls are assumed to be successful.\n */\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n uint256 oldAllowance = token.allowance(address(this), spender);\n forceApprove(token, spender, oldAllowance + value);\n }\n\n /**\n * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\n * value, non-reverting calls are assumed to be successful.\n */\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\n unchecked {\n uint256 currentAllowance = token.allowance(address(this), spender);\n if (currentAllowance < requestedDecrease) {\n revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\n }\n forceApprove(token, spender, currentAllowance - requestedDecrease);\n }\n }\n\n /**\n * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\n * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\n * to be set to zero before setting it to a non-zero value, such as USDT.\n */\n function forceApprove(IERC20 token, address spender, uint256 value) internal {\n bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\n\n if (!_callOptionalReturnBool(token, approvalCall)) {\n _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\n _callOptionalReturn(token, approvalCall);\n }\n }\n\n /**\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n * on the return value: the return value is optional (but if data is returned, it must not be false).\n * @param token The token targeted by the call.\n * @param data The call data (encoded using abi.encode or one of its variants).\n */\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that\n // the target address contains contract code and also asserts for success in the low-level call.\n\n bytes memory returndata = address(token).functionCall(data);\n if (returndata.length != 0 && !abi.decode(returndata, (bool))) {\n revert SafeERC20FailedOperation(address(token));\n }\n }\n\n /**\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n * on the return value: the return value is optional (but if data is returned, it must not be false).\n * @param token The token targeted by the call.\n * @param data The call data (encoded using abi.encode or one of its variants).\n *\n * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.\n */\n function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false\n // and not revert is the subcall reverts.\n\n (bool success, bytes memory returndata) = address(token).call(data);\n return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;\n }\n}\n"},"@openzeppelin/contracts/utils/Address.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n /**\n * @dev The ETH balance of the account is not enough to perform the operation.\n */\n error AddressInsufficientBalance(address account);\n\n /**\n * @dev There's no code at `target` (it is not a contract).\n */\n error AddressEmptyCode(address target);\n\n /**\n * @dev A call to an address target failed. The target may have reverted.\n */\n error FailedInnerCall();\n\n /**\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n * `recipient`, forwarding all available gas and reverting on errors.\n *\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\n * imposed by `transfer`, making them unable to receive funds via\n * `transfer`. {sendValue} removes this limitation.\n *\n * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n *\n * IMPORTANT: because control is transferred to `recipient`, care must be\n * taken to not create reentrancy vulnerabilities. Consider using\n * {ReentrancyGuard} or the\n * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n */\n function sendValue(address payable recipient, uint256 amount) internal {\n if (address(this).balance < amount) {\n revert AddressInsufficientBalance(address(this));\n }\n\n (bool success, ) = recipient.call{value: amount}(\"\");\n if (!success) {\n revert FailedInnerCall();\n }\n }\n\n /**\n * @dev Performs a Solidity function call using a low level `call`. A\n * plain `call` is an unsafe replacement for a function call: use this\n * function instead.\n *\n * If `target` reverts with a revert reason or custom error, it is bubbled\n * up by this function (like regular Solidity function calls). However, if\n * the call reverted with no returned reason, this function reverts with a\n * {FailedInnerCall} error.\n *\n * Returns the raw returned data. To convert to the expected return value,\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n *\n * Requirements:\n *\n * - `target` must be a contract.\n * - calling `target` with `data` must not revert.\n */\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but also transferring `value` wei to `target`.\n *\n * Requirements:\n *\n * - the calling contract must have an ETH balance of at least `value`.\n * - the called Solidity function must be `payable`.\n */\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n if (address(this).balance < value) {\n revert AddressInsufficientBalance(address(this));\n }\n (bool success, bytes memory returndata) = target.call{value: value}(data);\n return verifyCallResultFromTarget(target, success, returndata);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a static call.\n */\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n (bool success, bytes memory returndata) = target.staticcall(data);\n return verifyCallResultFromTarget(target, success, returndata);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a delegate call.\n */\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n (bool success, bytes memory returndata) = target.delegatecall(data);\n return verifyCallResultFromTarget(target, success, returndata);\n }\n\n /**\n * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target\n * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an\n * unsuccessful call.\n */\n function verifyCallResultFromTarget(\n address target,\n bool success,\n bytes memory returndata\n ) internal view returns (bytes memory) {\n if (!success) {\n _revert(returndata);\n } else {\n // only check if target is a contract if the call was successful and the return data is empty\n // otherwise we already know that it was a contract\n if (returndata.length == 0 && target.code.length == 0) {\n revert AddressEmptyCode(target);\n }\n return returndata;\n }\n }\n\n /**\n * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the\n * revert reason or with a default {FailedInnerCall} error.\n */\n function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {\n if (!success) {\n _revert(returndata);\n } else {\n return returndata;\n }\n }\n\n /**\n * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.\n */\n function _revert(bytes memory returndata) private pure {\n // Look for revert reason and bubble it up if present\n if (returndata.length > 0) {\n // The easiest way to bubble the revert reason is using memory via assembly\n /// @solidity memory-safe-assembly\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert FailedInnerCall();\n }\n }\n}\n"},"@openzeppelin/contracts/utils/Context.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n function _msgSender() internal view virtual returns (address) {\n return msg.sender;\n }\n\n function _msgData() internal view virtual returns (bytes calldata) {\n return msg.data;\n }\n\n function _contextSuffixLength() internal view virtual returns (uint256) {\n return 0;\n }\n}\n"},"@openzeppelin/contracts/utils/cryptography/ECDSA.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/ECDSA.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\n *\n * These functions can be used to verify that a message was signed by the holder\n * of the private keys of a given address.\n */\nlibrary ECDSA {\n enum RecoverError {\n NoError,\n InvalidSignature,\n InvalidSignatureLength,\n InvalidSignatureS\n }\n\n /**\n * @dev The signature derives the `address(0)`.\n */\n error ECDSAInvalidSignature();\n\n /**\n * @dev The signature has an invalid length.\n */\n error ECDSAInvalidSignatureLength(uint256 length);\n\n /**\n * @dev The signature has an S value that is in the upper half order.\n */\n error ECDSAInvalidSignatureS(bytes32 s);\n\n /**\n * @dev Returns the address that signed a hashed message (`hash`) with `signature` or an error. This will not\n * return address(0) without also returning an error description. Errors are documented using an enum (error type)\n * and a bytes32 providing additional information about the error.\n *\n * If no error is returned, then the address can be used for verification purposes.\n *\n * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:\n * this function rejects them by requiring the `s` value to be in the lower\n * half order, and the `v` value to be either 27 or 28.\n *\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n * verification to be secure: it is possible to craft signatures that\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n * this is by receiving a hash of the original message (which may otherwise\n * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.\n *\n * Documentation for signature generation:\n * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]\n * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]\n */\n function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError, bytes32) {\n if (signature.length == 65) {\n bytes32 r;\n bytes32 s;\n uint8 v;\n // ecrecover takes the signature parameters, and the only way to get them\n // currently is to use assembly.\n /// @solidity memory-safe-assembly\n assembly {\n r := mload(add(signature, 0x20))\n s := mload(add(signature, 0x40))\n v := byte(0, mload(add(signature, 0x60)))\n }\n return tryRecover(hash, v, r, s);\n } else {\n return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));\n }\n }\n\n /**\n * @dev Returns the address that signed a hashed message (`hash`) with\n * `signature`. This address can then be used for verification purposes.\n *\n * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:\n * this function rejects them by requiring the `s` value to be in the lower\n * half order, and the `v` value to be either 27 or 28.\n *\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n * verification to be secure: it is possible to craft signatures that\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n * this is by receiving a hash of the original message (which may otherwise\n * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.\n */\n function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\n (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);\n _throwError(error, errorArg);\n return recovered;\n }\n\n /**\n * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.\n *\n * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]\n */\n function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError, bytes32) {\n unchecked {\n bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);\n // We do not check for an overflow here since the shift operation results in 0 or 1.\n uint8 v = uint8((uint256(vs) >> 255) + 27);\n return tryRecover(hash, v, r, s);\n }\n }\n\n /**\n * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.\n */\n function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {\n (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);\n _throwError(error, errorArg);\n return recovered;\n }\n\n /**\n * @dev Overload of {ECDSA-tryRecover} that receives the `v`,\n * `r` and `s` signature fields separately.\n */\n function tryRecover(\n bytes32 hash,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) internal pure returns (address, RecoverError, bytes32) {\n // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\n // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\n // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most\n // signatures from current libraries generate a unique signature with an s-value in the lower half order.\n //\n // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\n // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\n // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\n // these malleable signatures as well.\n if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {\n return (address(0), RecoverError.InvalidSignatureS, s);\n }\n\n // If the signature is valid (and not malleable), return the signer address\n address signer = ecrecover(hash, v, r, s);\n if (signer == address(0)) {\n return (address(0), RecoverError.InvalidSignature, bytes32(0));\n }\n\n return (signer, RecoverError.NoError, bytes32(0));\n }\n\n /**\n * @dev Overload of {ECDSA-recover} that receives the `v`,\n * `r` and `s` signature fields separately.\n */\n function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {\n (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s);\n _throwError(error, errorArg);\n return recovered;\n }\n\n /**\n * @dev Optionally reverts with the corresponding custom error according to the `error` argument provided.\n */\n function _throwError(RecoverError error, bytes32 errorArg) private pure {\n if (error == RecoverError.NoError) {\n return; // no error: do nothing\n } else if (error == RecoverError.InvalidSignature) {\n revert ECDSAInvalidSignature();\n } else if (error == RecoverError.InvalidSignatureLength) {\n revert ECDSAInvalidSignatureLength(uint256(errorArg));\n } else if (error == RecoverError.InvalidSignatureS) {\n revert ECDSAInvalidSignatureS(errorArg);\n }\n }\n}\n"},"@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/MessageHashUtils.sol)\n\npragma solidity ^0.8.20;\n\nimport {Strings} from \"../Strings.sol\";\n\n/**\n * @dev Signature message hash utilities for producing digests to be consumed by {ECDSA} recovery or signing.\n *\n * The library provides methods for generating a hash of a message that conforms to the\n * https://eips.ethereum.org/EIPS/eip-191[EIP 191] and https://eips.ethereum.org/EIPS/eip-712[EIP 712]\n * specifications.\n */\nlibrary MessageHashUtils {\n /**\n * @dev Returns the keccak256 digest of an EIP-191 signed data with version\n * `0x45` (`personal_sign` messages).\n *\n * The digest is calculated by prefixing a bytes32 `messageHash` with\n * `\"\\x19Ethereum Signed Message:\\n32\"` and hashing the result. It corresponds with the\n * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.\n *\n * NOTE: The `messageHash` parameter is intended to be the result of hashing a raw message with\n * keccak256, although any bytes32 value can be safely used because the final digest will\n * be re-hashed.\n *\n * See {ECDSA-recover}.\n */\n function toEthSignedMessageHash(bytes32 messageHash) internal pure returns (bytes32 digest) {\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, \"\\x19Ethereum Signed Message:\\n32\") // 32 is the bytes-length of messageHash\n mstore(0x1c, messageHash) // 0x1c (28) is the length of the prefix\n digest := keccak256(0x00, 0x3c) // 0x3c is the length of the prefix (0x1c) + messageHash (0x20)\n }\n }\n\n /**\n * @dev Returns the keccak256 digest of an EIP-191 signed data with version\n * `0x45` (`personal_sign` messages).\n *\n * The digest is calculated by prefixing an arbitrary `message` with\n * `\"\\x19Ethereum Signed Message:\\n\" + len(message)` and hashing the result. It corresponds with the\n * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.\n *\n * See {ECDSA-recover}.\n */\n function toEthSignedMessageHash(bytes memory message) internal pure returns (bytes32) {\n return\n keccak256(bytes.concat(\"\\x19Ethereum Signed Message:\\n\", bytes(Strings.toString(message.length)), message));\n }\n\n /**\n * @dev Returns the keccak256 digest of an EIP-191 signed data with version\n * `0x00` (data with intended validator).\n *\n * The digest is calculated by prefixing an arbitrary `data` with `\"\\x19\\x00\"` and the intended\n * `validator` address. Then hashing the result.\n *\n * See {ECDSA-recover}.\n */\n function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {\n return keccak256(abi.encodePacked(hex\"19_00\", validator, data));\n }\n\n /**\n * @dev Returns the keccak256 digest of an EIP-712 typed data (EIP-191 version `0x01`).\n *\n * The digest is calculated from a `domainSeparator` and a `structHash`, by prefixing them with\n * `\\x19\\x01` and hashing the result. It corresponds to the hash signed by the\n * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] JSON-RPC method as part of EIP-712.\n *\n * See {ECDSA-recover}.\n */\n function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 digest) {\n /// @solidity memory-safe-assembly\n assembly {\n let ptr := mload(0x40)\n mstore(ptr, hex\"19_01\")\n mstore(add(ptr, 0x02), domainSeparator)\n mstore(add(ptr, 0x22), structHash)\n digest := keccak256(ptr, 0x42)\n }\n }\n}\n"},"@openzeppelin/contracts/utils/introspection/ERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/ERC165.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC165} from \"./IERC165.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n */\nabstract contract ERC165 is IERC165 {\n /**\n * @dev See {IERC165-supportsInterface}.\n */\n function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {\n return interfaceId == type(IERC165).interfaceId;\n }\n}\n"},"@openzeppelin/contracts/utils/introspection/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n /**\n * @dev Returns true if this contract implements the interface defined by\n * `interfaceId`. See the corresponding\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\n * to learn more about how these ids are created.\n *\n * This function call must use less than 30 000 gas.\n */\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"},"@openzeppelin/contracts/utils/math/Math.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n /**\n * @dev Muldiv operation overflow.\n */\n error MathOverflowedMulDiv();\n\n enum Rounding {\n Floor, // Toward negative infinity\n Ceil, // Toward positive infinity\n Trunc, // Toward zero\n Expand // Away from zero\n }\n\n /**\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\n */\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n uint256 c = a + b;\n if (c < a) return (false, 0);\n return (true, c);\n }\n }\n\n /**\n * @dev Returns the subtraction of two unsigned integers, with an overflow flag.\n */\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n if (b > a) return (false, 0);\n return (true, a - b);\n }\n }\n\n /**\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\n */\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\n // benefit is lost if 'b' is also tested.\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n if (a == 0) return (true, 0);\n uint256 c = a * b;\n if (c / a != b) return (false, 0);\n return (true, c);\n }\n }\n\n /**\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\n */\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n if (b == 0) return (false, 0);\n return (true, a / b);\n }\n }\n\n /**\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\n */\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n unchecked {\n if (b == 0) return (false, 0);\n return (true, a % b);\n }\n }\n\n /**\n * @dev Returns the largest of two numbers.\n */\n function max(uint256 a, uint256 b) internal pure returns (uint256) {\n return a > b ? a : b;\n }\n\n /**\n * @dev Returns the smallest of two numbers.\n */\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\n return a < b ? a : b;\n }\n\n /**\n * @dev Returns the average of two numbers. The result is rounded towards\n * zero.\n */\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\n // (a + b) / 2 can overflow.\n return (a & b) + (a ^ b) / 2;\n }\n\n /**\n * @dev Returns the ceiling of the division of two numbers.\n *\n * This differs from standard division with `/` in that it rounds towards infinity instead\n * of rounding towards zero.\n */\n function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n if (b == 0) {\n // Guarantee the same behavior as in a regular Solidity division.\n return a / b;\n }\n\n // (a + b - 1) / b can overflow on addition, so we distribute.\n return a == 0 ? 0 : (a - 1) / b + 1;\n }\n\n /**\n * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\n * denominator == 0.\n * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\n * Uniswap Labs also under MIT license.\n */\n function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\n unchecked {\n // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\n // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\n // variables such that product = prod1 * 2^256 + prod0.\n uint256 prod0 = x * y; // Least significant 256 bits of the product\n uint256 prod1; // Most significant 256 bits of the product\n assembly {\n let mm := mulmod(x, y, not(0))\n prod1 := sub(sub(mm, prod0), lt(mm, prod0))\n }\n\n // Handle non-overflow cases, 256 by 256 division.\n if (prod1 == 0) {\n // Solidity will revert if denominator == 0, unlike the div opcode on its own.\n // The surrounding unchecked block does not change this fact.\n // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\n return prod0 / denominator;\n }\n\n // Make sure the result is less than 2^256. Also prevents denominator == 0.\n if (denominator <= prod1) {\n revert MathOverflowedMulDiv();\n }\n\n ///////////////////////////////////////////////\n // 512 by 256 division.\n ///////////////////////////////////////////////\n\n // Make division exact by subtracting the remainder from [prod1 prod0].\n uint256 remainder;\n assembly {\n // Compute remainder using mulmod.\n remainder := mulmod(x, y, denominator)\n\n // Subtract 256 bit number from 512 bit number.\n prod1 := sub(prod1, gt(remainder, prod0))\n prod0 := sub(prod0, remainder)\n }\n\n // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\n // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\n\n uint256 twos = denominator & (0 - denominator);\n assembly {\n // Divide denominator by twos.\n denominator := div(denominator, twos)\n\n // Divide [prod1 prod0] by twos.\n prod0 := div(prod0, twos)\n\n // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\n twos := add(div(sub(0, twos), twos), 1)\n }\n\n // Shift in bits from prod1 into prod0.\n prod0 |= prod1 * twos;\n\n // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\n // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\n // four bits. That is, denominator * inv = 1 mod 2^4.\n uint256 inverse = (3 * denominator) ^ 2;\n\n // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\n // works in modular arithmetic, doubling the correct bits in each step.\n inverse *= 2 - denominator * inverse; // inverse mod 2^8\n inverse *= 2 - denominator * inverse; // inverse mod 2^16\n inverse *= 2 - denominator * inverse; // inverse mod 2^32\n inverse *= 2 - denominator * inverse; // inverse mod 2^64\n inverse *= 2 - denominator * inverse; // inverse mod 2^128\n inverse *= 2 - denominator * inverse; // inverse mod 2^256\n\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\n // is no longer required.\n result = prod0 * inverse;\n return result;\n }\n }\n\n /**\n * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\n */\n function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\n uint256 result = mulDiv(x, y, denominator);\n if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {\n result += 1;\n }\n return result;\n }\n\n /**\n * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\n * towards zero.\n *\n * Inspired by Henry S. Warren, Jr.'s \"Hacker's Delight\" (Chapter 11).\n */\n function sqrt(uint256 a) internal pure returns (uint256) {\n if (a == 0) {\n return 0;\n }\n\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\n //\n // We know that the \"msb\" (most significant bit) of our target number `a` is a power of 2 such that we have\n // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\n //\n // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\n // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\n // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\n //\n // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\n uint256 result = 1 << (log2(a) >> 1);\n\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\n // into the expected uint128 result.\n unchecked {\n result = (result + a / result) >> 1;\n result = (result + a / result) >> 1;\n result = (result + a / result) >> 1;\n result = (result + a / result) >> 1;\n result = (result + a / result) >> 1;\n result = (result + a / result) >> 1;\n result = (result + a / result) >> 1;\n return min(result, a / result);\n }\n }\n\n /**\n * @notice Calculates sqrt(a), following the selected rounding direction.\n */\n function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\n unchecked {\n uint256 result = sqrt(a);\n return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);\n }\n }\n\n /**\n * @dev Return the log in base 2 of a positive value rounded towards zero.\n * Returns 0 if given 0.\n */\n function log2(uint256 value) internal pure returns (uint256) {\n uint256 result = 0;\n unchecked {\n if (value >> 128 > 0) {\n value >>= 128;\n result += 128;\n }\n if (value >> 64 > 0) {\n value >>= 64;\n result += 64;\n }\n if (value >> 32 > 0) {\n value >>= 32;\n result += 32;\n }\n if (value >> 16 > 0) {\n value >>= 16;\n result += 16;\n }\n if (value >> 8 > 0) {\n value >>= 8;\n result += 8;\n }\n if (value >> 4 > 0) {\n value >>= 4;\n result += 4;\n }\n if (value >> 2 > 0) {\n value >>= 2;\n result += 2;\n }\n if (value >> 1 > 0) {\n result += 1;\n }\n }\n return result;\n }\n\n /**\n * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\n * Returns 0 if given 0.\n */\n function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\n unchecked {\n uint256 result = log2(value);\n return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);\n }\n }\n\n /**\n * @dev Return the log in base 10 of a positive value rounded towards zero.\n * Returns 0 if given 0.\n */\n function log10(uint256 value) internal pure returns (uint256) {\n uint256 result = 0;\n unchecked {\n if (value >= 10 ** 64) {\n value /= 10 ** 64;\n result += 64;\n }\n if (value >= 10 ** 32) {\n value /= 10 ** 32;\n result += 32;\n }\n if (value >= 10 ** 16) {\n value /= 10 ** 16;\n result += 16;\n }\n if (value >= 10 ** 8) {\n value /= 10 ** 8;\n result += 8;\n }\n if (value >= 10 ** 4) {\n value /= 10 ** 4;\n result += 4;\n }\n if (value >= 10 ** 2) {\n value /= 10 ** 2;\n result += 2;\n }\n if (value >= 10 ** 1) {\n result += 1;\n }\n }\n return result;\n }\n\n /**\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n * Returns 0 if given 0.\n */\n function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n unchecked {\n uint256 result = log10(value);\n return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);\n }\n }\n\n /**\n * @dev Return the log in base 256 of a positive value rounded towards zero.\n * Returns 0 if given 0.\n *\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n */\n function log256(uint256 value) internal pure returns (uint256) {\n uint256 result = 0;\n unchecked {\n if (value >> 128 > 0) {\n value >>= 128;\n result += 16;\n }\n if (value >> 64 > 0) {\n value >>= 64;\n result += 8;\n }\n if (value >> 32 > 0) {\n value >>= 32;\n result += 4;\n }\n if (value >> 16 > 0) {\n value >>= 16;\n result += 2;\n }\n if (value >> 8 > 0) {\n result += 1;\n }\n }\n return result;\n }\n\n /**\n * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\n * Returns 0 if given 0.\n */\n function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n unchecked {\n uint256 result = log256(value);\n return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);\n }\n }\n\n /**\n * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\n */\n function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\n return uint8(rounding) % 2 == 1;\n }\n}\n"},"@openzeppelin/contracts/utils/math/SafeCast.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SafeCast.sol)\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\n * checks.\n *\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\n * easily result in undesired exploitation or bugs, since developers usually\n * assume that overflows raise errors. `SafeCast` restores this intuition by\n * reverting the transaction when such an operation overflows.\n *\n * Using this library instead of the unchecked operations eliminates an entire\n * class of bugs, so it's recommended to use it always.\n */\nlibrary SafeCast {\n /**\n * @dev Value doesn't fit in an uint of `bits` size.\n */\n error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\n\n /**\n * @dev An int value doesn't fit in an uint of `bits` size.\n */\n error SafeCastOverflowedIntToUint(int256 value);\n\n /**\n * @dev Value doesn't fit in an int of `bits` size.\n */\n error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\n\n /**\n * @dev An uint value doesn't fit in an int of `bits` size.\n */\n error SafeCastOverflowedUintToInt(uint256 value);\n\n /**\n * @dev Returns the downcasted uint248 from uint256, reverting on\n * overflow (when the input is greater than largest uint248).\n *\n * Counterpart to Solidity's `uint248` operator.\n *\n * Requirements:\n *\n * - input must fit into 248 bits\n */\n function toUint248(uint256 value) internal pure returns (uint248) {\n if (value > type(uint248).max) {\n revert SafeCastOverflowedUintDowncast(248, value);\n }\n return uint248(value);\n }\n\n /**\n * @dev Returns the downcasted uint240 from uint256, reverting on\n * overflow (when the input is greater than largest uint240).\n *\n * Counterpart to Solidity's `uint240` operator.\n *\n * Requirements:\n *\n * - input must fit into 240 bits\n */\n function toUint240(uint256 value) internal pure returns (uint240) {\n if (value > type(uint240).max) {\n revert SafeCastOverflowedUintDowncast(240, value);\n }\n return uint240(value);\n }\n\n /**\n * @dev Returns the downcasted uint232 from uint256, reverting on\n * overflow (when the input is greater than largest uint232).\n *\n * Counterpart to Solidity's `uint232` operator.\n *\n * Requirements:\n *\n * - input must fit into 232 bits\n */\n function toUint232(uint256 value) internal pure returns (uint232) {\n if (value > type(uint232).max) {\n revert SafeCastOverflowedUintDowncast(232, value);\n }\n return uint232(value);\n }\n\n /**\n * @dev Returns the downcasted uint224 from uint256, reverting on\n * overflow (when the input is greater than largest uint224).\n *\n * Counterpart to Solidity's `uint224` operator.\n *\n * Requirements:\n *\n * - input must fit into 224 bits\n */\n function toUint224(uint256 value) internal pure returns (uint224) {\n if (value > type(uint224).max) {\n revert SafeCastOverflowedUintDowncast(224, value);\n }\n return uint224(value);\n }\n\n /**\n * @dev Returns the downcasted uint216 from uint256, reverting on\n * overflow (when the input is greater than largest uint216).\n *\n * Counterpart to Solidity's `uint216` operator.\n *\n * Requirements:\n *\n * - input must fit into 216 bits\n */\n function toUint216(uint256 value) internal pure returns (uint216) {\n if (value > type(uint216).max) {\n revert SafeCastOverflowedUintDowncast(216, value);\n }\n return uint216(value);\n }\n\n /**\n * @dev Returns the downcasted uint208 from uint256, reverting on\n * overflow (when the input is greater than largest uint208).\n *\n * Counterpart to Solidity's `uint208` operator.\n *\n * Requirements:\n *\n * - input must fit into 208 bits\n */\n function toUint208(uint256 value) internal pure returns (uint208) {\n if (value > type(uint208).max) {\n revert SafeCastOverflowedUintDowncast(208, value);\n }\n return uint208(value);\n }\n\n /**\n * @dev Returns the downcasted uint200 from uint256, reverting on\n * overflow (when the input is greater than largest uint200).\n *\n * Counterpart to Solidity's `uint200` operator.\n *\n * Requirements:\n *\n * - input must fit into 200 bits\n */\n function toUint200(uint256 value) internal pure returns (uint200) {\n if (value > type(uint200).max) {\n revert SafeCastOverflowedUintDowncast(200, value);\n }\n return uint200(value);\n }\n\n /**\n * @dev Returns the downcasted uint192 from uint256, reverting on\n * overflow (when the input is greater than largest uint192).\n *\n * Counterpart to Solidity's `uint192` operator.\n *\n * Requirements:\n *\n * - input must fit into 192 bits\n */\n function toUint192(uint256 value) internal pure returns (uint192) {\n if (value > type(uint192).max) {\n revert SafeCastOverflowedUintDowncast(192, value);\n }\n return uint192(value);\n }\n\n /**\n * @dev Returns the downcasted uint184 from uint256, reverting on\n * overflow (when the input is greater than largest uint184).\n *\n * Counterpart to Solidity's `uint184` operator.\n *\n * Requirements:\n *\n * - input must fit into 184 bits\n */\n function toUint184(uint256 value) internal pure returns (uint184) {\n if (value > type(uint184).max) {\n revert SafeCastOverflowedUintDowncast(184, value);\n }\n return uint184(value);\n }\n\n /**\n * @dev Returns the downcasted uint176 from uint256, reverting on\n * overflow (when the input is greater than largest uint176).\n *\n * Counterpart to Solidity's `uint176` operator.\n *\n * Requirements:\n *\n * - input must fit into 176 bits\n */\n function toUint176(uint256 value) internal pure returns (uint176) {\n if (value > type(uint176).max) {\n revert SafeCastOverflowedUintDowncast(176, value);\n }\n return uint176(value);\n }\n\n /**\n * @dev Returns the downcasted uint168 from uint256, reverting on\n * overflow (when the input is greater than largest uint168).\n *\n * Counterpart to Solidity's `uint168` operator.\n *\n * Requirements:\n *\n * - input must fit into 168 bits\n */\n function toUint168(uint256 value) internal pure returns (uint168) {\n if (value > type(uint168).max) {\n revert SafeCastOverflowedUintDowncast(168, value);\n }\n return uint168(value);\n }\n\n /**\n * @dev Returns the downcasted uint160 from uint256, reverting on\n * overflow (when the input is greater than largest uint160).\n *\n * Counterpart to Solidity's `uint160` operator.\n *\n * Requirements:\n *\n * - input must fit into 160 bits\n */\n function toUint160(uint256 value) internal pure returns (uint160) {\n if (value > type(uint160).max) {\n revert SafeCastOverflowedUintDowncast(160, value);\n }\n return uint160(value);\n }\n\n /**\n * @dev Returns the downcasted uint152 from uint256, reverting on\n * overflow (when the input is greater than largest uint152).\n *\n * Counterpart to Solidity's `uint152` operator.\n *\n * Requirements:\n *\n * - input must fit into 152 bits\n */\n function toUint152(uint256 value) internal pure returns (uint152) {\n if (value > type(uint152).max) {\n revert SafeCastOverflowedUintDowncast(152, value);\n }\n return uint152(value);\n }\n\n /**\n * @dev Returns the downcasted uint144 from uint256, reverting on\n * overflow (when the input is greater than largest uint144).\n *\n * Counterpart to Solidity's `uint144` operator.\n *\n * Requirements:\n *\n * - input must fit into 144 bits\n */\n function toUint144(uint256 value) internal pure returns (uint144) {\n if (value > type(uint144).max) {\n revert SafeCastOverflowedUintDowncast(144, value);\n }\n return uint144(value);\n }\n\n /**\n * @dev Returns the downcasted uint136 from uint256, reverting on\n * overflow (when the input is greater than largest uint136).\n *\n * Counterpart to Solidity's `uint136` operator.\n *\n * Requirements:\n *\n * - input must fit into 136 bits\n */\n function toUint136(uint256 value) internal pure returns (uint136) {\n if (value > type(uint136).max) {\n revert SafeCastOverflowedUintDowncast(136, value);\n }\n return uint136(value);\n }\n\n /**\n * @dev Returns the downcasted uint128 from uint256, reverting on\n * overflow (when the input is greater than largest uint128).\n *\n * Counterpart to Solidity's `uint128` operator.\n *\n * Requirements:\n *\n * - input must fit into 128 bits\n */\n function toUint128(uint256 value) internal pure returns (uint128) {\n if (value > type(uint128).max) {\n revert SafeCastOverflowedUintDowncast(128, value);\n }\n return uint128(value);\n }\n\n /**\n * @dev Returns the downcasted uint120 from uint256, reverting on\n * overflow (when the input is greater than largest uint120).\n *\n * Counterpart to Solidity's `uint120` operator.\n *\n * Requirements:\n *\n * - input must fit into 120 bits\n */\n function toUint120(uint256 value) internal pure returns (uint120) {\n if (value > type(uint120).max) {\n revert SafeCastOverflowedUintDowncast(120, value);\n }\n return uint120(value);\n }\n\n /**\n * @dev Returns the downcasted uint112 from uint256, reverting on\n * overflow (when the input is greater than largest uint112).\n *\n * Counterpart to Solidity's `uint112` operator.\n *\n * Requirements:\n *\n * - input must fit into 112 bits\n */\n function toUint112(uint256 value) internal pure returns (uint112) {\n if (value > type(uint112).max) {\n revert SafeCastOverflowedUintDowncast(112, value);\n }\n return uint112(value);\n }\n\n /**\n * @dev Returns the downcasted uint104 from uint256, reverting on\n * overflow (when the input is greater than largest uint104).\n *\n * Counterpart to Solidity's `uint104` operator.\n *\n * Requirements:\n *\n * - input must fit into 104 bits\n */\n function toUint104(uint256 value) internal pure returns (uint104) {\n if (value > type(uint104).max) {\n revert SafeCastOverflowedUintDowncast(104, value);\n }\n return uint104(value);\n }\n\n /**\n * @dev Returns the downcasted uint96 from uint256, reverting on\n * overflow (when the input is greater than largest uint96).\n *\n * Counterpart to Solidity's `uint96` operator.\n *\n * Requirements:\n *\n * - input must fit into 96 bits\n */\n function toUint96(uint256 value) internal pure returns (uint96) {\n if (value > type(uint96).max) {\n revert SafeCastOverflowedUintDowncast(96, value);\n }\n return uint96(value);\n }\n\n /**\n * @dev Returns the downcasted uint88 from uint256, reverting on\n * overflow (when the input is greater than largest uint88).\n *\n * Counterpart to Solidity's `uint88` operator.\n *\n * Requirements:\n *\n * - input must fit into 88 bits\n */\n function toUint88(uint256 value) internal pure returns (uint88) {\n if (value > type(uint88).max) {\n revert SafeCastOverflowedUintDowncast(88, value);\n }\n return uint88(value);\n }\n\n /**\n * @dev Returns the downcasted uint80 from uint256, reverting on\n * overflow (when the input is greater than largest uint80).\n *\n * Counterpart to Solidity's `uint80` operator.\n *\n * Requirements:\n *\n * - input must fit into 80 bits\n */\n function toUint80(uint256 value) internal pure returns (uint80) {\n if (value > type(uint80).max) {\n revert SafeCastOverflowedUintDowncast(80, value);\n }\n return uint80(value);\n }\n\n /**\n * @dev Returns the downcasted uint72 from uint256, reverting on\n * overflow (when the input is greater than largest uint72).\n *\n * Counterpart to Solidity's `uint72` operator.\n *\n * Requirements:\n *\n * - input must fit into 72 bits\n */\n function toUint72(uint256 value) internal pure returns (uint72) {\n if (value > type(uint72).max) {\n revert SafeCastOverflowedUintDowncast(72, value);\n }\n return uint72(value);\n }\n\n /**\n * @dev Returns the downcasted uint64 from uint256, reverting on\n * overflow (when the input is greater than largest uint64).\n *\n * Counterpart to Solidity's `uint64` operator.\n *\n * Requirements:\n *\n * - input must fit into 64 bits\n */\n function toUint64(uint256 value) internal pure returns (uint64) {\n if (value > type(uint64).max) {\n revert SafeCastOverflowedUintDowncast(64, value);\n }\n return uint64(value);\n }\n\n /**\n * @dev Returns the downcasted uint56 from uint256, reverting on\n * overflow (when the input is greater than largest uint56).\n *\n * Counterpart to Solidity's `uint56` operator.\n *\n * Requirements:\n *\n * - input must fit into 56 bits\n */\n function toUint56(uint256 value) internal pure returns (uint56) {\n if (value > type(uint56).max) {\n revert SafeCastOverflowedUintDowncast(56, value);\n }\n return uint56(value);\n }\n\n /**\n * @dev Returns the downcasted uint48 from uint256, reverting on\n * overflow (when the input is greater than largest uint48).\n *\n * Counterpart to Solidity's `uint48` operator.\n *\n * Requirements:\n *\n * - input must fit into 48 bits\n */\n function toUint48(uint256 value) internal pure returns (uint48) {\n if (value > type(uint48).max) {\n revert SafeCastOverflowedUintDowncast(48, value);\n }\n return uint48(value);\n }\n\n /**\n * @dev Returns the downcasted uint40 from uint256, reverting on\n * overflow (when the input is greater than largest uint40).\n *\n * Counterpart to Solidity's `uint40` operator.\n *\n * Requirements:\n *\n * - input must fit into 40 bits\n */\n function toUint40(uint256 value) internal pure returns (uint40) {\n if (value > type(uint40).max) {\n revert SafeCastOverflowedUintDowncast(40, value);\n }\n return uint40(value);\n }\n\n /**\n * @dev Returns the downcasted uint32 from uint256, reverting on\n * overflow (when the input is greater than largest uint32).\n *\n * Counterpart to Solidity's `uint32` operator.\n *\n * Requirements:\n *\n * - input must fit into 32 bits\n */\n function toUint32(uint256 value) internal pure returns (uint32) {\n if (value > type(uint32).max) {\n revert SafeCastOverflowedUintDowncast(32, value);\n }\n return uint32(value);\n }\n\n /**\n * @dev Returns the downcasted uint24 from uint256, reverting on\n * overflow (when the input is greater than largest uint24).\n *\n * Counterpart to Solidity's `uint24` operator.\n *\n * Requirements:\n *\n * - input must fit into 24 bits\n */\n function toUint24(uint256 value) internal pure returns (uint24) {\n if (value > type(uint24).max) {\n revert SafeCastOverflowedUintDowncast(24, value);\n }\n return uint24(value);\n }\n\n /**\n * @dev Returns the downcasted uint16 from uint256, reverting on\n * overflow (when the input is greater than largest uint16).\n *\n * Counterpart to Solidity's `uint16` operator.\n *\n * Requirements:\n *\n * - input must fit into 16 bits\n */\n function toUint16(uint256 value) internal pure returns (uint16) {\n if (value > type(uint16).max) {\n revert SafeCastOverflowedUintDowncast(16, value);\n }\n return uint16(value);\n }\n\n /**\n * @dev Returns the downcasted uint8 from uint256, reverting on\n * overflow (when the input is greater than largest uint8).\n *\n * Counterpart to Solidity's `uint8` operator.\n *\n * Requirements:\n *\n * - input must fit into 8 bits\n */\n function toUint8(uint256 value) internal pure returns (uint8) {\n if (value > type(uint8).max) {\n revert SafeCastOverflowedUintDowncast(8, value);\n }\n return uint8(value);\n }\n\n /**\n * @dev Converts a signed int256 into an unsigned uint256.\n *\n * Requirements:\n *\n * - input must be greater than or equal to 0.\n */\n function toUint256(int256 value) internal pure returns (uint256) {\n if (value < 0) {\n revert SafeCastOverflowedIntToUint(value);\n }\n return uint256(value);\n }\n\n /**\n * @dev Returns the downcasted int248 from int256, reverting on\n * overflow (when the input is less than smallest int248 or\n * greater than largest int248).\n *\n * Counterpart to Solidity's `int248` operator.\n *\n * Requirements:\n *\n * - input must fit into 248 bits\n */\n function toInt248(int256 value) internal pure returns (int248 downcasted) {\n downcasted = int248(value);\n if (downcasted != value) {\n revert SafeCastOverflowedIntDowncast(248, value);\n }\n }\n\n /**\n * @dev Returns the downcasted int240 from int256, reverting on\n * overflow (when the input is less than smallest int240 or\n * greater than largest int240).\n *\n * Counterpart to Solidity's `int240` operator.\n *\n * Requirements:\n *\n * - input must fit into 240 bits\n */\n function toInt240(int256 value) internal pure returns (int240 downcasted) {\n downcasted = int240(value);\n if (downcasted != value) {\n revert SafeCastOverflowedIntDowncast(240, value);\n }\n }\n\n /**\n * @dev Returns the downcasted int232 from int256, reverting on\n * overflow (when the input is less than smallest int232 or\n * greater than largest int232).\n *\n * Counterpart to Solidity's `int232` operator.\n *\n * Requirements:\n *\n * - input must fit into 232 bits\n */\n function toInt232(int256 value) internal pure returns (int232 downcasted) {\n downcasted = int232(value);\n if (downcasted != value) {\n revert SafeCastOverflowedIntDowncast(232, value);\n }\n }\n\n /**\n * @dev Returns the downcasted int224 from int256, reverting on\n * overflow (when the input is less than smallest int224 or\n * greater than largest int224).\n *\n * Counterpart to Solidity's `int224` operator.\n *\n * Requirements:\n *\n * - input must fit into 224 bits\n */\n function toInt224(int256 value) internal pure returns (int224 downcasted) {\n downcasted = int224(value);\n if (downcasted != value) {\n revert SafeCastOverflowedIntDowncast(224, value);\n }\n }\n\n /**\n * @dev Returns the downcasted int216 from int256, reverting on\n * overflow (when the input is less than smallest int216 or\n * greater than largest int216).\n *\n * Counterpart to Solidity's `int216` operator.\n *\n * Requirements:\n *\n * - input must fit into 216 bits\n */\n function toInt216(int256 value) internal pure returns (int216 downcasted) {\n downcasted = int216(value);\n if (downcasted != value) {\n revert SafeCastOverflowedIntDowncast(216, value);\n }\n }\n\n /**\n * @dev Returns the downcasted int208 from int256, reverting on\n * overflow (when the input is less than smallest int208 or\n * greater than largest int208).\n *\n * Counterpart to Solidity's `int208` operator.\n *\n * Requirements:\n *\n * - input must fit into 208 bits\n */\n function toInt208(int256 value) internal pure returns (int208 downcasted) {\n downcasted = int208(value);\n if (downcasted != value) {\n revert SafeCastOverflowedIntDowncast(208, value);\n }\n }\n\n /**\n * @dev Returns the downcasted int200 from int256, reverting on\n * overflow (when the input is less than smallest int200 or\n * greater than largest int200).\n *\n * Counterpart to Solidity's `int200` operator.\n *\n * Requirements:\n *\n * - input must fit into 200 bits\n */\n function toInt200(int256 value) internal pure returns (int200 downcasted) {\n downcasted = int200(value);\n if (downcasted != value) {\n revert SafeCastOverflowedIntDowncast(200, value);\n }\n }\n\n /**\n * @dev Returns the downcasted int192 from int256, reverting on\n * overflow (when the input is less than smallest int192 or\n * greater than largest int192).\n *\n * Counterpart to Solidity's `int192` operator.\n *\n * Requirements:\n *\n * - input must fit into 192 bits\n */\n function toInt192(int256 value) internal pure returns (int192 downcasted) {\n downcasted = int192(value);\n if (downcasted != value) {\n revert SafeCastOverflowedIntDowncast(192, value);\n }\n }\n\n /**\n * @dev Returns the downcasted int184 from int256, reverting on\n * overflow (when the input is less than smallest int184 or\n * greater than largest int184).\n *\n * Counterpart to Solidity's `int184` operator.\n *\n * Requirements:\n *\n * - input must fit into 184 bits\n */\n function toInt184(int256 value) internal pure returns (int184 downcasted) {\n downcasted = int184(value);\n if (downcasted != value) {\n revert SafeCastOverflowedIntDowncast(184, value);\n }\n }\n\n /**\n * @dev Returns the downcasted int176 from int256, reverting on\n * overflow (when the input is less than smallest int176 or\n * greater than largest int176).\n *\n * Counterpart to Solidity's `int176` operator.\n *\n * Requirements:\n *\n * - input must fit into 176 bits\n */\n function toInt176(int256 value) internal pure returns (int176 downcasted) {\n downcasted = int176(value);\n if (downcasted != value) {\n revert SafeCastOverflowedIntDowncast(176, value);\n }\n }\n\n /**\n * @dev Returns the downcasted int168 from int256, reverting on\n * overflow (when the input is less than smallest int168 or\n * greater than largest int168).\n *\n * Counterpart to Solidity's `int168` operator.\n *\n * Requirements:\n *\n * - input must fit into 168 bits\n */\n function toInt168(int256 value) internal pure returns (int168 downcasted) {\n downcasted = int168(value);\n if (downcasted != value) {\n revert SafeCastOverflowedIntDowncast(168, value);\n }\n }\n\n /**\n * @dev Returns the downcasted int160 from int256, reverting on\n * overflow (when the input is less than smallest int160 or\n * greater than largest int160).\n *\n * Counterpart to Solidity's `int160` operator.\n *\n * Requirements:\n *\n * - input must fit into 160 bits\n */\n function toInt160(int256 value) internal pure returns (int160 downcasted) {\n downcasted = int160(value);\n if (downcasted != value) {\n revert SafeCastOverflowedIntDowncast(160, value);\n }\n }\n\n /**\n * @dev Returns the downcasted int152 from int256, reverting on\n * overflow (when the input is less than smallest int152 or\n * greater than largest int152).\n *\n * Counterpart to Solidity's `int152` operator.\n *\n * Requirements:\n *\n * - input must fit into 152 bits\n */\n function toInt152(int256 value) internal pure returns (int152 downcasted) {\n downcasted = int152(value);\n if (downcasted != value) {\n revert SafeCastOverflowedIntDowncast(152, value);\n }\n }\n\n /**\n * @dev Returns the downcasted int144 from int256, reverting on\n * overflow (when the input is less than smallest int144 or\n * greater than largest int144).\n *\n * Counterpart to Solidity's `int144` operator.\n *\n * Requirements:\n *\n * - input must fit into 144 bits\n */\n function toInt144(int256 value) internal pure returns (int144 downcasted) {\n downcasted = int144(value);\n if (downcasted != value) {\n revert SafeCastOverflowedIntDowncast(144, value);\n }\n }\n\n /**\n * @dev Returns the downcasted int136 from int256, reverting on\n * overflow (when the input is less than smallest int136 or\n * greater than largest int136).\n *\n * Counterpart to Solidity's `int136` operator.\n *\n * Requirements:\n *\n * - input must fit into 136 bits\n */\n function toInt136(int256 value) internal pure returns (int136 downcasted) {\n downcasted = int136(value);\n if (downcasted != value) {\n revert SafeCastOverflowedIntDowncast(136, value);\n }\n }\n\n /**\n * @dev Returns the downcasted int128 from int256, reverting on\n * overflow (when the input is less than smallest int128 or\n * greater than largest int128).\n *\n * Counterpart to Solidity's `int128` operator.\n *\n * Requirements:\n *\n * - input must fit into 128 bits\n */\n function toInt128(int256 value) internal pure returns (int128 downcasted) {\n downcasted = int128(value);\n if (downcasted != value) {\n revert SafeCastOverflowedIntDowncast(128, value);\n }\n }\n\n /**\n * @dev Returns the downcasted int120 from int256, reverting on\n * overflow (when the input is less than smallest int120 or\n * greater than largest int120).\n *\n * Counterpart to Solidity's `int120` operator.\n *\n * Requirements:\n *\n * - input must fit into 120 bits\n */\n function toInt120(int256 value) internal pure returns (int120 downcasted) {\n downcasted = int120(value);\n if (downcasted != value) {\n revert SafeCastOverflowedIntDowncast(120, value);\n }\n }\n\n /**\n * @dev Returns the downcasted int112 from int256, reverting on\n * overflow (when the input is less than smallest int112 or\n * greater than largest int112).\n *\n * Counterpart to Solidity's `int112` operator.\n *\n * Requirements:\n *\n * - input must fit into 112 bits\n */\n function toInt112(int256 value) internal pure returns (int112 downcasted) {\n downcasted = int112(value);\n if (downcasted != value) {\n revert SafeCastOverflowedIntDowncast(112, value);\n }\n }\n\n /**\n * @dev Returns the downcasted int104 from int256, reverting on\n * overflow (when the input is less than smallest int104 or\n * greater than largest int104).\n *\n * Counterpart to Solidity's `int104` operator.\n *\n * Requirements:\n *\n * - input must fit into 104 bits\n */\n function toInt104(int256 value) internal pure returns (int104 downcasted) {\n downcasted = int104(value);\n if (downcasted != value) {\n revert SafeCastOverflowedIntDowncast(104, value);\n }\n }\n\n /**\n * @dev Returns the downcasted int96 from int256, reverting on\n * overflow (when the input is less than smallest int96 or\n * greater than largest int96).\n *\n * Counterpart to Solidity's `int96` operator.\n *\n * Requirements:\n *\n * - input must fit into 96 bits\n */\n function toInt96(int256 value) internal pure returns (int96 downcasted) {\n downcasted = int96(value);\n if (downcasted != value) {\n revert SafeCastOverflowedIntDowncast(96, value);\n }\n }\n\n /**\n * @dev Returns the downcasted int88 from int256, reverting on\n * overflow (when the input is less than smallest int88 or\n * greater than largest int88).\n *\n * Counterpart to Solidity's `int88` operator.\n *\n * Requirements:\n *\n * - input must fit into 88 bits\n */\n function toInt88(int256 value) internal pure returns (int88 downcasted) {\n downcasted = int88(value);\n if (downcasted != value) {\n revert SafeCastOverflowedIntDowncast(88, value);\n }\n }\n\n /**\n * @dev Returns the downcasted int80 from int256, reverting on\n * overflow (when the input is less than smallest int80 or\n * greater than largest int80).\n *\n * Counterpart to Solidity's `int80` operator.\n *\n * Requirements:\n *\n * - input must fit into 80 bits\n */\n function toInt80(int256 value) internal pure returns (int80 downcasted) {\n downcasted = int80(value);\n if (downcasted != value) {\n revert SafeCastOverflowedIntDowncast(80, value);\n }\n }\n\n /**\n * @dev Returns the downcasted int72 from int256, reverting on\n * overflow (when the input is less than smallest int72 or\n * greater than largest int72).\n *\n * Counterpart to Solidity's `int72` operator.\n *\n * Requirements:\n *\n * - input must fit into 72 bits\n */\n function toInt72(int256 value) internal pure returns (int72 downcasted) {\n downcasted = int72(value);\n if (downcasted != value) {\n revert SafeCastOverflowedIntDowncast(72, value);\n }\n }\n\n /**\n * @dev Returns the downcasted int64 from int256, reverting on\n * overflow (when the input is less than smallest int64 or\n * greater than largest int64).\n *\n * Counterpart to Solidity's `int64` operator.\n *\n * Requirements:\n *\n * - input must fit into 64 bits\n */\n function toInt64(int256 value) internal pure returns (int64 downcasted) {\n downcasted = int64(value);\n if (downcasted != value) {\n revert SafeCastOverflowedIntDowncast(64, value);\n }\n }\n\n /**\n * @dev Returns the downcasted int56 from int256, reverting on\n * overflow (when the input is less than smallest int56 or\n * greater than largest int56).\n *\n * Counterpart to Solidity's `int56` operator.\n *\n * Requirements:\n *\n * - input must fit into 56 bits\n */\n function toInt56(int256 value) internal pure returns (int56 downcasted) {\n downcasted = int56(value);\n if (downcasted != value) {\n revert SafeCastOverflowedIntDowncast(56, value);\n }\n }\n\n /**\n * @dev Returns the downcasted int48 from int256, reverting on\n * overflow (when the input is less than smallest int48 or\n * greater than largest int48).\n *\n * Counterpart to Solidity's `int48` operator.\n *\n * Requirements:\n *\n * - input must fit into 48 bits\n */\n function toInt48(int256 value) internal pure returns (int48 downcasted) {\n downcasted = int48(value);\n if (downcasted != value) {\n revert SafeCastOverflowedIntDowncast(48, value);\n }\n }\n\n /**\n * @dev Returns the downcasted int40 from int256, reverting on\n * overflow (when the input is less than smallest int40 or\n * greater than largest int40).\n *\n * Counterpart to Solidity's `int40` operator.\n *\n * Requirements:\n *\n * - input must fit into 40 bits\n */\n function toInt40(int256 value) internal pure returns (int40 downcasted) {\n downcasted = int40(value);\n if (downcasted != value) {\n revert SafeCastOverflowedIntDowncast(40, value);\n }\n }\n\n /**\n * @dev Returns the downcasted int32 from int256, reverting on\n * overflow (when the input is less than smallest int32 or\n * greater than largest int32).\n *\n * Counterpart to Solidity's `int32` operator.\n *\n * Requirements:\n *\n * - input must fit into 32 bits\n */\n function toInt32(int256 value) internal pure returns (int32 downcasted) {\n downcasted = int32(value);\n if (downcasted != value) {\n revert SafeCastOverflowedIntDowncast(32, value);\n }\n }\n\n /**\n * @dev Returns the downcasted int24 from int256, reverting on\n * overflow (when the input is less than smallest int24 or\n * greater than largest int24).\n *\n * Counterpart to Solidity's `int24` operator.\n *\n * Requirements:\n *\n * - input must fit into 24 bits\n */\n function toInt24(int256 value) internal pure returns (int24 downcasted) {\n downcasted = int24(value);\n if (downcasted != value) {\n revert SafeCastOverflowedIntDowncast(24, value);\n }\n }\n\n /**\n * @dev Returns the downcasted int16 from int256, reverting on\n * overflow (when the input is less than smallest int16 or\n * greater than largest int16).\n *\n * Counterpart to Solidity's `int16` operator.\n *\n * Requirements:\n *\n * - input must fit into 16 bits\n */\n function toInt16(int256 value) internal pure returns (int16 downcasted) {\n downcasted = int16(value);\n if (downcasted != value) {\n revert SafeCastOverflowedIntDowncast(16, value);\n }\n }\n\n /**\n * @dev Returns the downcasted int8 from int256, reverting on\n * overflow (when the input is less than smallest int8 or\n * greater than largest int8).\n *\n * Counterpart to Solidity's `int8` operator.\n *\n * Requirements:\n *\n * - input must fit into 8 bits\n */\n function toInt8(int256 value) internal pure returns (int8 downcasted) {\n downcasted = int8(value);\n if (downcasted != value) {\n revert SafeCastOverflowedIntDowncast(8, value);\n }\n }\n\n /**\n * @dev Converts an unsigned uint256 into a signed int256.\n *\n * Requirements:\n *\n * - input must be less than or equal to maxInt256.\n */\n function toInt256(uint256 value) internal pure returns (int256) {\n // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\n if (value > uint256(type(int256).max)) {\n revert SafeCastOverflowedUintToInt(value);\n }\n return int256(value);\n }\n}\n"},"@openzeppelin/contracts/utils/math/SignedMath.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Standard signed math utilities missing in the Solidity language.\n */\nlibrary SignedMath {\n /**\n * @dev Returns the largest of two signed numbers.\n */\n function max(int256 a, int256 b) internal pure returns (int256) {\n return a > b ? a : b;\n }\n\n /**\n * @dev Returns the smallest of two signed numbers.\n */\n function min(int256 a, int256 b) internal pure returns (int256) {\n return a < b ? a : b;\n }\n\n /**\n * @dev Returns the average of two signed numbers without overflow.\n * The result is rounded towards zero.\n */\n function average(int256 a, int256 b) internal pure returns (int256) {\n // Formula from the book \"Hacker's Delight\"\n int256 x = (a & b) + ((a ^ b) >> 1);\n return x + (int256(uint256(x) >> 255) & (a ^ b));\n }\n\n /**\n * @dev Returns the absolute unsigned value of a signed value.\n */\n function abs(int256 n) internal pure returns (uint256) {\n unchecked {\n // must be unchecked in order to support `n = type(int256).min`\n return uint256(n >= 0 ? n : -n);\n }\n }\n}\n"},"@openzeppelin/contracts/utils/ReentrancyGuard.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/ReentrancyGuard.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Contract module that helps prevent reentrant calls to a function.\n *\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\n * available, which can be applied to functions to make sure there are no nested\n * (reentrant) calls to them.\n *\n * Note that because there is a single `nonReentrant` guard, functions marked as\n * `nonReentrant` may not call one another. This can be worked around by making\n * those functions `private`, and then adding `external` `nonReentrant` entry\n * points to them.\n *\n * TIP: If you would like to learn more about reentrancy and alternative ways\n * to protect against it, check out our blog post\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\n */\nabstract contract ReentrancyGuard {\n // Booleans are more expensive than uint256 or any type that takes up a full\n // word because each write operation emits an extra SLOAD to first read the\n // slot's contents, replace the bits taken up by the boolean, and then write\n // back. This is the compiler's defense against contract upgrades and\n // pointer aliasing, and it cannot be disabled.\n\n // The values being non-zero value makes deployment a bit more expensive,\n // but in exchange the refund on every call to nonReentrant will be lower in\n // amount. Since refunds are capped to a percentage of the total\n // transaction's gas, it is best to keep them low in cases like this one, to\n // increase the likelihood of the full refund coming into effect.\n uint256 private constant NOT_ENTERED = 1;\n uint256 private constant ENTERED = 2;\n\n uint256 private _status;\n\n /**\n * @dev Unauthorized reentrant call.\n */\n error ReentrancyGuardReentrantCall();\n\n constructor() {\n _status = NOT_ENTERED;\n }\n\n /**\n * @dev Prevents a contract from calling itself, directly or indirectly.\n * Calling a `nonReentrant` function from another `nonReentrant`\n * function is not supported. It is possible to prevent this from happening\n * by making the `nonReentrant` function external, and making it call a\n * `private` function that does the actual work.\n */\n modifier nonReentrant() {\n _nonReentrantBefore();\n _;\n _nonReentrantAfter();\n }\n\n function _nonReentrantBefore() private {\n // On the first call to nonReentrant, _status will be NOT_ENTERED\n if (_status == ENTERED) {\n revert ReentrancyGuardReentrantCall();\n }\n\n // Any calls to nonReentrant after this point will fail\n _status = ENTERED;\n }\n\n function _nonReentrantAfter() private {\n // By storing the original value once again, a refund is triggered (see\n // https://eips.ethereum.org/EIPS/eip-2200)\n _status = NOT_ENTERED;\n }\n\n /**\n * @dev Returns true if the reentrancy guard is currently set to \"entered\", which indicates there is a\n * `nonReentrant` function in the call stack.\n */\n function _reentrancyGuardEntered() internal view returns (bool) {\n return _status == ENTERED;\n }\n}\n"},"@openzeppelin/contracts/utils/Strings.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/Strings.sol)\n\npragma solidity ^0.8.20;\n\nimport {Math} from \"./math/Math.sol\";\nimport {SignedMath} from \"./math/SignedMath.sol\";\n\n/**\n * @dev String operations.\n */\nlibrary Strings {\n bytes16 private constant HEX_DIGITS = \"0123456789abcdef\";\n uint8 private constant ADDRESS_LENGTH = 20;\n\n /**\n * @dev The `value` string doesn't fit in the specified `length`.\n */\n error StringsInsufficientHexLength(uint256 value, uint256 length);\n\n /**\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n */\n function toString(uint256 value) internal pure returns (string memory) {\n unchecked {\n uint256 length = Math.log10(value) + 1;\n string memory buffer = new string(length);\n uint256 ptr;\n /// @solidity memory-safe-assembly\n assembly {\n ptr := add(buffer, add(32, length))\n }\n while (true) {\n ptr--;\n /// @solidity memory-safe-assembly\n assembly {\n mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))\n }\n value /= 10;\n if (value == 0) break;\n }\n return buffer;\n }\n }\n\n /**\n * @dev Converts a `int256` to its ASCII `string` decimal representation.\n */\n function toStringSigned(int256 value) internal pure returns (string memory) {\n return string.concat(value < 0 ? \"-\" : \"\", toString(SignedMath.abs(value)));\n }\n\n /**\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n */\n function toHexString(uint256 value) internal pure returns (string memory) {\n unchecked {\n return toHexString(value, Math.log256(value) + 1);\n }\n }\n\n /**\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n */\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n uint256 localValue = value;\n bytes memory buffer = new bytes(2 * length + 2);\n buffer[0] = \"0\";\n buffer[1] = \"x\";\n for (uint256 i = 2 * length + 1; i > 1; --i) {\n buffer[i] = HEX_DIGITS[localValue & 0xf];\n localValue >>= 4;\n }\n if (localValue != 0) {\n revert StringsInsufficientHexLength(value, length);\n }\n return string(buffer);\n }\n\n /**\n * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal\n * representation.\n */\n function toHexString(address addr) internal pure returns (string memory) {\n return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);\n }\n\n /**\n * @dev Returns true if the two strings are equal.\n */\n function equal(string memory a, string memory b) internal pure returns (bool) {\n return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));\n }\n}\n"},"@openzeppelin/contracts/utils/structs/EnumerableMap.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/structs/EnumerableMap.sol)\n// This file was procedurally generated from scripts/generate/templates/EnumerableMap.js.\n\npragma solidity ^0.8.20;\n\nimport {EnumerableSet} from \"./EnumerableSet.sol\";\n\n/**\n * @dev Library for managing an enumerable variant of Solidity's\n * https://solidity.readthedocs.io/en/latest/types.html#mapping-types[`mapping`]\n * type.\n *\n * Maps have the following properties:\n *\n * - Entries are added, removed, and checked for existence in constant time\n * (O(1)).\n * - Entries are enumerated in O(n). No guarantees are made on the ordering.\n *\n * ```solidity\n * contract Example {\n * // Add the library methods\n * using EnumerableMap for EnumerableMap.UintToAddressMap;\n *\n * // Declare a set state variable\n * EnumerableMap.UintToAddressMap private myMap;\n * }\n * ```\n *\n * The following map types are supported:\n *\n * - `uint256 -> address` (`UintToAddressMap`) since v3.0.0\n * - `address -> uint256` (`AddressToUintMap`) since v4.6.0\n * - `bytes32 -> bytes32` (`Bytes32ToBytes32Map`) since v4.6.0\n * - `uint256 -> uint256` (`UintToUintMap`) since v4.7.0\n * - `bytes32 -> uint256` (`Bytes32ToUintMap`) since v4.7.0\n *\n * [WARNING]\n * ====\n * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure\n * unusable.\n * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.\n *\n * In order to clean an EnumerableMap, you can either remove all elements one by one or create a fresh instance using an\n * array of EnumerableMap.\n * ====\n */\nlibrary EnumerableMap {\n using EnumerableSet for EnumerableSet.Bytes32Set;\n\n // To implement this library for multiple types with as little code repetition as possible, we write it in\n // terms of a generic Map type with bytes32 keys and values. The Map implementation uses private functions,\n // and user-facing implementations such as `UintToAddressMap` are just wrappers around the underlying Map.\n // This means that we can only create new EnumerableMaps for types that fit in bytes32.\n\n /**\n * @dev Query for a nonexistent map key.\n */\n error EnumerableMapNonexistentKey(bytes32 key);\n\n struct Bytes32ToBytes32Map {\n // Storage of keys\n EnumerableSet.Bytes32Set _keys;\n mapping(bytes32 key => bytes32) _values;\n }\n\n /**\n * @dev Adds a key-value pair to a map, or updates the value for an existing\n * key. O(1).\n *\n * Returns true if the key was added to the map, that is if it was not\n * already present.\n */\n function set(Bytes32ToBytes32Map storage map, bytes32 key, bytes32 value) internal returns (bool) {\n map._values[key] = value;\n return map._keys.add(key);\n }\n\n /**\n * @dev Removes a key-value pair from a map. O(1).\n *\n * Returns true if the key was removed from the map, that is if it was present.\n */\n function remove(Bytes32ToBytes32Map storage map, bytes32 key) internal returns (bool) {\n delete map._values[key];\n return map._keys.remove(key);\n }\n\n /**\n * @dev Returns true if the key is in the map. O(1).\n */\n function contains(Bytes32ToBytes32Map storage map, bytes32 key) internal view returns (bool) {\n return map._keys.contains(key);\n }\n\n /**\n * @dev Returns the number of key-value pairs in the map. O(1).\n */\n function length(Bytes32ToBytes32Map storage map) internal view returns (uint256) {\n return map._keys.length();\n }\n\n /**\n * @dev Returns the key-value pair stored at position `index` in the map. O(1).\n *\n * Note that there are no guarantees on the ordering of entries inside the\n * array, and it may change when more entries are added or removed.\n *\n * Requirements:\n *\n * - `index` must be strictly less than {length}.\n */\n function at(Bytes32ToBytes32Map storage map, uint256 index) internal view returns (bytes32, bytes32) {\n bytes32 key = map._keys.at(index);\n return (key, map._values[key]);\n }\n\n /**\n * @dev Tries to returns the value associated with `key`. O(1).\n * Does not revert if `key` is not in the map.\n */\n function tryGet(Bytes32ToBytes32Map storage map, bytes32 key) internal view returns (bool, bytes32) {\n bytes32 value = map._values[key];\n if (value == bytes32(0)) {\n return (contains(map, key), bytes32(0));\n } else {\n return (true, value);\n }\n }\n\n /**\n * @dev Returns the value associated with `key`. O(1).\n *\n * Requirements:\n *\n * - `key` must be in the map.\n */\n function get(Bytes32ToBytes32Map storage map, bytes32 key) internal view returns (bytes32) {\n bytes32 value = map._values[key];\n if (value == 0 && !contains(map, key)) {\n revert EnumerableMapNonexistentKey(key);\n }\n return value;\n }\n\n /**\n * @dev Return the an array containing all the keys\n *\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\n * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\n * uncallable if the map grows to a point where copying to memory consumes too much gas to fit in a block.\n */\n function keys(Bytes32ToBytes32Map storage map) internal view returns (bytes32[] memory) {\n return map._keys.values();\n }\n\n // UintToUintMap\n\n struct UintToUintMap {\n Bytes32ToBytes32Map _inner;\n }\n\n /**\n * @dev Adds a key-value pair to a map, or updates the value for an existing\n * key. O(1).\n *\n * Returns true if the key was added to the map, that is if it was not\n * already present.\n */\n function set(UintToUintMap storage map, uint256 key, uint256 value) internal returns (bool) {\n return set(map._inner, bytes32(key), bytes32(value));\n }\n\n /**\n * @dev Removes a value from a map. O(1).\n *\n * Returns true if the key was removed from the map, that is if it was present.\n */\n function remove(UintToUintMap storage map, uint256 key) internal returns (bool) {\n return remove(map._inner, bytes32(key));\n }\n\n /**\n * @dev Returns true if the key is in the map. O(1).\n */\n function contains(UintToUintMap storage map, uint256 key) internal view returns (bool) {\n return contains(map._inner, bytes32(key));\n }\n\n /**\n * @dev Returns the number of elements in the map. O(1).\n */\n function length(UintToUintMap storage map) internal view returns (uint256) {\n return length(map._inner);\n }\n\n /**\n * @dev Returns the element stored at position `index` in the map. O(1).\n * Note that there are no guarantees on the ordering of values inside the\n * array, and it may change when more values are added or removed.\n *\n * Requirements:\n *\n * - `index` must be strictly less than {length}.\n */\n function at(UintToUintMap storage map, uint256 index) internal view returns (uint256, uint256) {\n (bytes32 key, bytes32 value) = at(map._inner, index);\n return (uint256(key), uint256(value));\n }\n\n /**\n * @dev Tries to returns the value associated with `key`. O(1).\n * Does not revert if `key` is not in the map.\n */\n function tryGet(UintToUintMap storage map, uint256 key) internal view returns (bool, uint256) {\n (bool success, bytes32 value) = tryGet(map._inner, bytes32(key));\n return (success, uint256(value));\n }\n\n /**\n * @dev Returns the value associated with `key`. O(1).\n *\n * Requirements:\n *\n * - `key` must be in the map.\n */\n function get(UintToUintMap storage map, uint256 key) internal view returns (uint256) {\n return uint256(get(map._inner, bytes32(key)));\n }\n\n /**\n * @dev Return the an array containing all the keys\n *\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\n * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\n * uncallable if the map grows to a point where copying to memory consumes too much gas to fit in a block.\n */\n function keys(UintToUintMap storage map) internal view returns (uint256[] memory) {\n bytes32[] memory store = keys(map._inner);\n uint256[] memory result;\n\n /// @solidity memory-safe-assembly\n assembly {\n result := store\n }\n\n return result;\n }\n\n // UintToAddressMap\n\n struct UintToAddressMap {\n Bytes32ToBytes32Map _inner;\n }\n\n /**\n * @dev Adds a key-value pair to a map, or updates the value for an existing\n * key. O(1).\n *\n * Returns true if the key was added to the map, that is if it was not\n * already present.\n */\n function set(UintToAddressMap storage map, uint256 key, address value) internal returns (bool) {\n return set(map._inner, bytes32(key), bytes32(uint256(uint160(value))));\n }\n\n /**\n * @dev Removes a value from a map. O(1).\n *\n * Returns true if the key was removed from the map, that is if it was present.\n */\n function remove(UintToAddressMap storage map, uint256 key) internal returns (bool) {\n return remove(map._inner, bytes32(key));\n }\n\n /**\n * @dev Returns true if the key is in the map. O(1).\n */\n function contains(UintToAddressMap storage map, uint256 key) internal view returns (bool) {\n return contains(map._inner, bytes32(key));\n }\n\n /**\n * @dev Returns the number of elements in the map. O(1).\n */\n function length(UintToAddressMap storage map) internal view returns (uint256) {\n return length(map._inner);\n }\n\n /**\n * @dev Returns the element stored at position `index` in the map. O(1).\n * Note that there are no guarantees on the ordering of values inside the\n * array, and it may change when more values are added or removed.\n *\n * Requirements:\n *\n * - `index` must be strictly less than {length}.\n */\n function at(UintToAddressMap storage map, uint256 index) internal view returns (uint256, address) {\n (bytes32 key, bytes32 value) = at(map._inner, index);\n return (uint256(key), address(uint160(uint256(value))));\n }\n\n /**\n * @dev Tries to returns the value associated with `key`. O(1).\n * Does not revert if `key` is not in the map.\n */\n function tryGet(UintToAddressMap storage map, uint256 key) internal view returns (bool, address) {\n (bool success, bytes32 value) = tryGet(map._inner, bytes32(key));\n return (success, address(uint160(uint256(value))));\n }\n\n /**\n * @dev Returns the value associated with `key`. O(1).\n *\n * Requirements:\n *\n * - `key` must be in the map.\n */\n function get(UintToAddressMap storage map, uint256 key) internal view returns (address) {\n return address(uint160(uint256(get(map._inner, bytes32(key)))));\n }\n\n /**\n * @dev Return the an array containing all the keys\n *\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\n * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\n * uncallable if the map grows to a point where copying to memory consumes too much gas to fit in a block.\n */\n function keys(UintToAddressMap storage map) internal view returns (uint256[] memory) {\n bytes32[] memory store = keys(map._inner);\n uint256[] memory result;\n\n /// @solidity memory-safe-assembly\n assembly {\n result := store\n }\n\n return result;\n }\n\n // AddressToUintMap\n\n struct AddressToUintMap {\n Bytes32ToBytes32Map _inner;\n }\n\n /**\n * @dev Adds a key-value pair to a map, or updates the value for an existing\n * key. O(1).\n *\n * Returns true if the key was added to the map, that is if it was not\n * already present.\n */\n function set(AddressToUintMap storage map, address key, uint256 value) internal returns (bool) {\n return set(map._inner, bytes32(uint256(uint160(key))), bytes32(value));\n }\n\n /**\n * @dev Removes a value from a map. O(1).\n *\n * Returns true if the key was removed from the map, that is if it was present.\n */\n function remove(AddressToUintMap storage map, address key) internal returns (bool) {\n return remove(map._inner, bytes32(uint256(uint160(key))));\n }\n\n /**\n * @dev Returns true if the key is in the map. O(1).\n */\n function contains(AddressToUintMap storage map, address key) internal view returns (bool) {\n return contains(map._inner, bytes32(uint256(uint160(key))));\n }\n\n /**\n * @dev Returns the number of elements in the map. O(1).\n */\n function length(AddressToUintMap storage map) internal view returns (uint256) {\n return length(map._inner);\n }\n\n /**\n * @dev Returns the element stored at position `index` in the map. O(1).\n * Note that there are no guarantees on the ordering of values inside the\n * array, and it may change when more values are added or removed.\n *\n * Requirements:\n *\n * - `index` must be strictly less than {length}.\n */\n function at(AddressToUintMap storage map, uint256 index) internal view returns (address, uint256) {\n (bytes32 key, bytes32 value) = at(map._inner, index);\n return (address(uint160(uint256(key))), uint256(value));\n }\n\n /**\n * @dev Tries to returns the value associated with `key`. O(1).\n * Does not revert if `key` is not in the map.\n */\n function tryGet(AddressToUintMap storage map, address key) internal view returns (bool, uint256) {\n (bool success, bytes32 value) = tryGet(map._inner, bytes32(uint256(uint160(key))));\n return (success, uint256(value));\n }\n\n /**\n * @dev Returns the value associated with `key`. O(1).\n *\n * Requirements:\n *\n * - `key` must be in the map.\n */\n function get(AddressToUintMap storage map, address key) internal view returns (uint256) {\n return uint256(get(map._inner, bytes32(uint256(uint160(key)))));\n }\n\n /**\n * @dev Return the an array containing all the keys\n *\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\n * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\n * uncallable if the map grows to a point where copying to memory consumes too much gas to fit in a block.\n */\n function keys(AddressToUintMap storage map) internal view returns (address[] memory) {\n bytes32[] memory store = keys(map._inner);\n address[] memory result;\n\n /// @solidity memory-safe-assembly\n assembly {\n result := store\n }\n\n return result;\n }\n\n // Bytes32ToUintMap\n\n struct Bytes32ToUintMap {\n Bytes32ToBytes32Map _inner;\n }\n\n /**\n * @dev Adds a key-value pair to a map, or updates the value for an existing\n * key. O(1).\n *\n * Returns true if the key was added to the map, that is if it was not\n * already present.\n */\n function set(Bytes32ToUintMap storage map, bytes32 key, uint256 value) internal returns (bool) {\n return set(map._inner, key, bytes32(value));\n }\n\n /**\n * @dev Removes a value from a map. O(1).\n *\n * Returns true if the key was removed from the map, that is if it was present.\n */\n function remove(Bytes32ToUintMap storage map, bytes32 key) internal returns (bool) {\n return remove(map._inner, key);\n }\n\n /**\n * @dev Returns true if the key is in the map. O(1).\n */\n function contains(Bytes32ToUintMap storage map, bytes32 key) internal view returns (bool) {\n return contains(map._inner, key);\n }\n\n /**\n * @dev Returns the number of elements in the map. O(1).\n */\n function length(Bytes32ToUintMap storage map) internal view returns (uint256) {\n return length(map._inner);\n }\n\n /**\n * @dev Returns the element stored at position `index` in the map. O(1).\n * Note that there are no guarantees on the ordering of values inside the\n * array, and it may change when more values are added or removed.\n *\n * Requirements:\n *\n * - `index` must be strictly less than {length}.\n */\n function at(Bytes32ToUintMap storage map, uint256 index) internal view returns (bytes32, uint256) {\n (bytes32 key, bytes32 value) = at(map._inner, index);\n return (key, uint256(value));\n }\n\n /**\n * @dev Tries to returns the value associated with `key`. O(1).\n * Does not revert if `key` is not in the map.\n */\n function tryGet(Bytes32ToUintMap storage map, bytes32 key) internal view returns (bool, uint256) {\n (bool success, bytes32 value) = tryGet(map._inner, key);\n return (success, uint256(value));\n }\n\n /**\n * @dev Returns the value associated with `key`. O(1).\n *\n * Requirements:\n *\n * - `key` must be in the map.\n */\n function get(Bytes32ToUintMap storage map, bytes32 key) internal view returns (uint256) {\n return uint256(get(map._inner, key));\n }\n\n /**\n * @dev Return the an array containing all the keys\n *\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\n * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\n * uncallable if the map grows to a point where copying to memory consumes too much gas to fit in a block.\n */\n function keys(Bytes32ToUintMap storage map) internal view returns (bytes32[] memory) {\n bytes32[] memory store = keys(map._inner);\n bytes32[] memory result;\n\n /// @solidity memory-safe-assembly\n assembly {\n result := store\n }\n\n return result;\n }\n}\n"},"@openzeppelin/contracts/utils/structs/EnumerableSet.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/structs/EnumerableSet.sol)\n// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Library for managing\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\n * types.\n *\n * Sets have the following properties:\n *\n * - Elements are added, removed, and checked for existence in constant time\n * (O(1)).\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\n *\n * ```solidity\n * contract Example {\n * // Add the library methods\n * using EnumerableSet for EnumerableSet.AddressSet;\n *\n * // Declare a set state variable\n * EnumerableSet.AddressSet private mySet;\n * }\n * ```\n *\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\n * and `uint256` (`UintSet`) are supported.\n *\n * [WARNING]\n * ====\n * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure\n * unusable.\n * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.\n *\n * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an\n * array of EnumerableSet.\n * ====\n */\nlibrary EnumerableSet {\n // To implement this library for multiple types with as little code\n // repetition as possible, we write it in terms of a generic Set type with\n // bytes32 values.\n // The Set implementation uses private functions, and user-facing\n // implementations (such as AddressSet) are just wrappers around the\n // underlying Set.\n // This means that we can only create new EnumerableSets for types that fit\n // in bytes32.\n\n struct Set {\n // Storage of set values\n bytes32[] _values;\n // Position is the index of the value in the `values` array plus 1.\n // Position 0 is used to mean a value is not in the set.\n mapping(bytes32 value => uint256) _positions;\n }\n\n /**\n * @dev Add a value to a set. O(1).\n *\n * Returns true if the value was added to the set, that is if it was not\n * already present.\n */\n function _add(Set storage set, bytes32 value) private returns (bool) {\n if (!_contains(set, value)) {\n set._values.push(value);\n // The value is stored at length-1, but we add 1 to all indexes\n // and use 0 as a sentinel value\n set._positions[value] = set._values.length;\n return true;\n } else {\n return false;\n }\n }\n\n /**\n * @dev Removes a value from a set. O(1).\n *\n * Returns true if the value was removed from the set, that is if it was\n * present.\n */\n function _remove(Set storage set, bytes32 value) private returns (bool) {\n // We cache the value's position to prevent multiple reads from the same storage slot\n uint256 position = set._positions[value];\n\n if (position != 0) {\n // Equivalent to contains(set, value)\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\n // the array, and then remove the last element (sometimes called as 'swap and pop').\n // This modifies the order of the array, as noted in {at}.\n\n uint256 valueIndex = position - 1;\n uint256 lastIndex = set._values.length - 1;\n\n if (valueIndex != lastIndex) {\n bytes32 lastValue = set._values[lastIndex];\n\n // Move the lastValue to the index where the value to delete is\n set._values[valueIndex] = lastValue;\n // Update the tracked position of the lastValue (that was just moved)\n set._positions[lastValue] = position;\n }\n\n // Delete the slot where the moved value was stored\n set._values.pop();\n\n // Delete the tracked position for the deleted slot\n delete set._positions[value];\n\n return true;\n } else {\n return false;\n }\n }\n\n /**\n * @dev Returns true if the value is in the set. O(1).\n */\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\n return set._positions[value] != 0;\n }\n\n /**\n * @dev Returns the number of values on the set. O(1).\n */\n function _length(Set storage set) private view returns (uint256) {\n return set._values.length;\n }\n\n /**\n * @dev Returns the value stored at position `index` in the set. O(1).\n *\n * Note that there are no guarantees on the ordering of values inside the\n * array, and it may change when more values are added or removed.\n *\n * Requirements:\n *\n * - `index` must be strictly less than {length}.\n */\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\n return set._values[index];\n }\n\n /**\n * @dev Return the entire set in an array\n *\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\n * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\n * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\n */\n function _values(Set storage set) private view returns (bytes32[] memory) {\n return set._values;\n }\n\n // Bytes32Set\n\n struct Bytes32Set {\n Set _inner;\n }\n\n /**\n * @dev Add a value to a set. O(1).\n *\n * Returns true if the value was added to the set, that is if it was not\n * already present.\n */\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\n return _add(set._inner, value);\n }\n\n /**\n * @dev Removes a value from a set. O(1).\n *\n * Returns true if the value was removed from the set, that is if it was\n * present.\n */\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\n return _remove(set._inner, value);\n }\n\n /**\n * @dev Returns true if the value is in the set. O(1).\n */\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\n return _contains(set._inner, value);\n }\n\n /**\n * @dev Returns the number of values in the set. O(1).\n */\n function length(Bytes32Set storage set) internal view returns (uint256) {\n return _length(set._inner);\n }\n\n /**\n * @dev Returns the value stored at position `index` in the set. O(1).\n *\n * Note that there are no guarantees on the ordering of values inside the\n * array, and it may change when more values are added or removed.\n *\n * Requirements:\n *\n * - `index` must be strictly less than {length}.\n */\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\n return _at(set._inner, index);\n }\n\n /**\n * @dev Return the entire set in an array\n *\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\n * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\n * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\n */\n function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {\n bytes32[] memory store = _values(set._inner);\n bytes32[] memory result;\n\n /// @solidity memory-safe-assembly\n assembly {\n result := store\n }\n\n return result;\n }\n\n // AddressSet\n\n struct AddressSet {\n Set _inner;\n }\n\n /**\n * @dev Add a value to a set. O(1).\n *\n * Returns true if the value was added to the set, that is if it was not\n * already present.\n */\n function add(AddressSet storage set, address value) internal returns (bool) {\n return _add(set._inner, bytes32(uint256(uint160(value))));\n }\n\n /**\n * @dev Removes a value from a set. O(1).\n *\n * Returns true if the value was removed from the set, that is if it was\n * present.\n */\n function remove(AddressSet storage set, address value) internal returns (bool) {\n return _remove(set._inner, bytes32(uint256(uint160(value))));\n }\n\n /**\n * @dev Returns true if the value is in the set. O(1).\n */\n function contains(AddressSet storage set, address value) internal view returns (bool) {\n return _contains(set._inner, bytes32(uint256(uint160(value))));\n }\n\n /**\n * @dev Returns the number of values in the set. O(1).\n */\n function length(AddressSet storage set) internal view returns (uint256) {\n return _length(set._inner);\n }\n\n /**\n * @dev Returns the value stored at position `index` in the set. O(1).\n *\n * Note that there are no guarantees on the ordering of values inside the\n * array, and it may change when more values are added or removed.\n *\n * Requirements:\n *\n * - `index` must be strictly less than {length}.\n */\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\n return address(uint160(uint256(_at(set._inner, index))));\n }\n\n /**\n * @dev Return the entire set in an array\n *\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\n * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\n * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\n */\n function values(AddressSet storage set) internal view returns (address[] memory) {\n bytes32[] memory store = _values(set._inner);\n address[] memory result;\n\n /// @solidity memory-safe-assembly\n assembly {\n result := store\n }\n\n return result;\n }\n\n // UintSet\n\n struct UintSet {\n Set _inner;\n }\n\n /**\n * @dev Add a value to a set. O(1).\n *\n * Returns true if the value was added to the set, that is if it was not\n * already present.\n */\n function add(UintSet storage set, uint256 value) internal returns (bool) {\n return _add(set._inner, bytes32(value));\n }\n\n /**\n * @dev Removes a value from a set. O(1).\n *\n * Returns true if the value was removed from the set, that is if it was\n * present.\n */\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\n return _remove(set._inner, bytes32(value));\n }\n\n /**\n * @dev Returns true if the value is in the set. O(1).\n */\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\n return _contains(set._inner, bytes32(value));\n }\n\n /**\n * @dev Returns the number of values in the set. O(1).\n */\n function length(UintSet storage set) internal view returns (uint256) {\n return _length(set._inner);\n }\n\n /**\n * @dev Returns the value stored at position `index` in the set. O(1).\n *\n * Note that there are no guarantees on the ordering of values inside the\n * array, and it may change when more values are added or removed.\n *\n * Requirements:\n *\n * - `index` must be strictly less than {length}.\n */\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\n return uint256(_at(set._inner, index));\n }\n\n /**\n * @dev Return the entire set in an array\n *\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\n * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\n * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\n */\n function values(UintSet storage set) internal view returns (uint256[] memory) {\n bytes32[] memory store = _values(set._inner);\n uint256[] memory result;\n\n /// @solidity memory-safe-assembly\n assembly {\n result := store\n }\n\n return result;\n }\n}\n"},"contracts/AegisMinting.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.26;\n\nimport \"@openzeppelin/contracts/access/extensions/AccessControlDefaultAdminRules.sol\";\nimport \"@openzeppelin/contracts/utils/ReentrancyGuard.sol\";\nimport \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\nimport \"@openzeppelin/contracts/utils/structs/EnumerableMap.sol\";\nimport \"@openzeppelin/contracts/utils/math/Math.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport { IERC165 } from \"@openzeppelin/contracts/utils/introspection/ERC165.sol\";\n\nimport { FeedRegistryInterface } from \"@chainlink/contracts/src/v0.8/interfaces/FeedRegistryInterface.sol\";\nimport { Denominations } from \"@chainlink/contracts/src/v0.8/Denominations.sol\";\n\nimport { OrderLib } from \"./lib/OrderLib.sol\";\n\nimport { IAegisMintingEvents, IAegisMintingErrors } from \"./interfaces/IAegisMinting.sol\";\nimport { IAegisRewards } from \"./interfaces/IAegisRewards.sol\";\nimport { IAegisConfig } from \"./interfaces/IAegisConfig.sol\";\nimport { IAegisOracle } from \"./interfaces/IAegisOracle.sol\";\nimport { IYUSD } from \"./interfaces/IYUSD.sol\";\n\ncontract AegisMinting is IAegisMintingEvents, IAegisMintingErrors, AccessControlDefaultAdminRules, ReentrancyGuard {\n using EnumerableSet for EnumerableSet.AddressSet;\n using EnumerableMap for EnumerableMap.AddressToUintMap;\n using OrderLib for OrderLib.Order;\n using SafeERC20 for IERC20;\n using SafeERC20 for IYUSD;\n\n enum RedeemRequestStatus {\n PENDING,\n APPROVED,\n REJECTED,\n WITHDRAWN\n }\n\n struct RedeemRequest {\n RedeemRequestStatus status;\n OrderLib.Order order;\n uint256 timestamp;\n }\n\n struct MintRedeemLimit {\n uint32 periodDuration;\n uint32 currentPeriodStartTime;\n uint256 maxPeriodAmount;\n uint256 currentPeriodTotalAmount;\n }\n\n uint16 constant MAX_BPS = 10_000;\n\n /// @dev role enabling to update various settings\n bytes32 private constant SETTINGS_MANAGER_ROLE = keccak256(\"SETTINGS_MANAGER_ROLE\");\n\n /// @dev role enabling to deposit income/redeem and withdraw redeem\n bytes32 private constant FUNDS_MANAGER_ROLE = keccak256(\"FUNDS_MANAGER_ROLE\");\n\n /// @dev role enabling to transfer collateral to custody wallets\n bytes32 private constant COLLATERAL_MANAGER_ROLE = keccak256(\"COLLATERAL_MANAGER_ROLE\");\n\n /// @dev EIP712 domain\n bytes32 private constant EIP712_DOMAIN = keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\");\n\n /// @dev EIP712 name\n bytes32 private constant EIP712_NAME = keccak256(\"AegisMinting\");\n\n /// @dev holds EIP712 revision\n bytes32 private constant EIP712_REVISION = keccak256(\"1\");\n\n /// @dev YUSD stablecoin\n IYUSD public immutable yusd;\n\n /// @dev AegisRewards contract\n IAegisRewards public aegisRewards;\n\n /// @dev AegisConfig contract\n IAegisConfig public aegisConfig;\n\n /// @dev AegisOracle contract providing YUSD/USD price\n IAegisOracle public aegisOracle;\n\n /// @dev InsuranceFund address\n address public insuranceFundAddress;\n\n /// @dev Percent of YUSD rewards that will be transferred to InsuranceFund address. Default: 5%\n uint16 public incomeFeeBP = 500;\n\n /// @dev Mint pause state\n bool public mintPaused;\n\n /// @dev Redeem pause state\n bool public redeemPaused;\n\n /// @dev Cross-chain operations pause state\n bool public crossChainPaused;\n\n /// @dev Percent of YUSD that will be taken as a fee from mint amount\n uint16 public mintFeeBP;\n\n /// @dev Percent of YUSD that will be taken as a fee from redeem amount\n uint16 public redeemFeeBP;\n\n /// @dev Asset funds that were frozen and cannot be transfered to custody\n mapping(address => uint256) public assetFrozenFunds;\n\n /// @dev Mint limiting parameter\n MintRedeemLimit public mintLimit;\n\n /// @dev Redeem limiting parameters\n MintRedeemLimit public redeemLimit;\n\n /// @dev Tracks total amount of users locked YUSD for redeem requests\n uint256 public totalRedeemLockedYUSD;\n\n /// @dev Asset heartbeat of Chainlink feed in seconds\n mapping(address => uint32) public chainlinkAssetHeartbeat;\n\n /// @dev Chainlink FeedRegistry\n FeedRegistryInterface private _feedRegistry;\n\n /// @dev Supported assets\n EnumerableSet.AddressSet private _supportedAssets;\n\n /// @dev Custodian addresses\n EnumerableSet.AddressSet private _custodianAddresses;\n\n mapping(address => uint256) private _custodyTransferrableAssetFunds;\n\n /// @dev Map of redeem request id to RedeemRequest struct\n mapping(bytes32 => RedeemRequest) private _redeemRequests;\n\n /// @dev holds computable chain id\n uint256 private immutable _chainId;\n\n /// @dev holds computable domain separator\n bytes32 private immutable _domainSeparator;\n\n /// @dev user order deduplication\n mapping(address => mapping(uint256 => uint256)) private _orderBitmaps;\n\n /// @dev Single cross-chain operator address\n address private _crossChainOperatorAddress;\n\n modifier onlyWhitelisted(address sender) {\n if (address(aegisConfig) == address(0) || !aegisConfig.isWhitelisted(sender)) {\n revert NotWhitelisted();\n }\n _;\n }\n\n modifier onlySupportedAsset(address asset) {\n if (!_supportedAssets.contains(asset)) {\n revert InvalidAssetAddress(asset);\n }\n _;\n }\n\n modifier onlyCustodianAddress(address wallet) {\n if (!_custodianAddresses.contains(wallet)) {\n revert InvalidCustodianAddress(wallet);\n }\n _;\n }\n\n modifier whenRedeemUnpaused() {\n if (redeemPaused) {\n revert RedeemPaused();\n }\n _;\n }\n\n modifier onlyCrossChainOperator() {\n if (msg.sender != _crossChainOperatorAddress) {\n revert NotAuthorized();\n }\n _;\n }\n\n modifier whenCrossChainUnpaused() {\n if (crossChainPaused) {\n revert CrossChainPaused();\n }\n _;\n }\n\n constructor(\n IYUSD _yusd,\n IAegisConfig _aegisConfig,\n IAegisRewards _aegisRewards,\n IAegisOracle _aegisOracle,\n FeedRegistryInterface _fdRegistry,\n address _insuranceFundAddress,\n address[] memory _assets,\n uint32[] memory _chainlinkAssetHeartbeats,\n address[] memory _custodians,\n address _admin\n ) AccessControlDefaultAdminRules(3 days, _admin) {\n if (address(_yusd) == address(0)) revert ZeroAddress();\n if (address(_aegisRewards) == address(0)) revert ZeroAddress();\n if (address(_aegisConfig) == address(0)) revert ZeroAddress();\n if (_assets.length == 0) revert NotAssetsProvided();\n require(_assets.length == _chainlinkAssetHeartbeats.length);\n\n yusd = _yusd;\n mintLimit.currentPeriodStartTime = uint32(block.timestamp);\n redeemLimit.currentPeriodStartTime = uint32(block.timestamp);\n _setAegisRewardsAddress(_aegisRewards);\n _setAegisConfigAddress(_aegisConfig);\n _setFeedRegistryAddress(_fdRegistry);\n _setAegisOracleAddress(_aegisOracle);\n _setInsuranceFundAddress(_insuranceFundAddress);\n\n for (uint256 i = 0; i < _assets.length; i++) {\n _addSupportedAsset(_assets[i], _chainlinkAssetHeartbeats[i]);\n }\n\n for (uint256 i = 0; i < _custodians.length; i++) {\n _addCustodianAddress(_custodians[i]);\n }\n\n _chainId = block.chainid;\n _domainSeparator = _computeDomainSeparator();\n }\n\n /// @dev Returns custody transferrable asset funds minus durty funds\n function custodyAvailableAssetBalance(address asset) public view returns (uint256) {\n return _custodyAvailableAssetBalance(asset);\n }\n\n /// @dev Returns asset balance minus custody transferrable and durty funds\n function untrackedAvailableAssetBalance(address asset) public view returns (uint256) {\n return _untrackedAvailableAssetBalance(asset);\n }\n\n /// @dev Returns RedeemRequest by id\n function getRedeemRequest(string calldata requestId) public view returns (RedeemRequest memory) {\n return _redeemRequests[keccak256(abi.encode(requestId))];\n }\n\n /// @dev Retuns asset/USD price from Chainlink feed\n function assetChainlinkUSDPrice(address asset) public view returns (uint256) {\n (uint256 price, ) = _getAssetUSDPriceChainlink(asset);\n return price;\n }\n\n /// @dev Returns asset/YUSD price from AegisOracle\n function assetAegisOracleYUSDPrice(address asset) public view returns (uint256) {\n (uint256 price, ) = _getAssetYUSDPriceOracle(asset);\n return price;\n }\n\n /**\n * @dev Mints YUSD from assets\n * @param order Struct containing order details\n * @param signature Signature of trusted signer\n */\n function mint(\n OrderLib.Order calldata order,\n bytes calldata signature\n ) external nonReentrant onlyWhitelisted(order.userWallet) onlySupportedAsset(order.collateralAsset) {\n if (mintPaused) {\n revert MintPaused();\n }\n if (order.orderType != OrderLib.OrderType.MINT) {\n revert InvalidOrder();\n }\n\n _checkMintRedeemLimit(mintLimit, order.yusdAmount);\n order.verify(getDomainSeparator(), aegisConfig.trustedSigner(), signature);\n _deduplicateOrder(order.userWallet, order.nonce);\n\n uint256 balanceBefore = IERC20(order.collateralAsset).balanceOf(address(this));\n IERC20(order.collateralAsset).safeTransferFrom(order.userWallet, address(this), order.collateralAmount);\n uint256 balanceAfter = IERC20(order.collateralAsset).balanceOf(address(this));\n uint256 received = balanceAfter - balanceBefore;\n\n uint256 yusdAmount = _calculateMinYUSDAmount(order.collateralAsset, received, order.yusdAmount);\n if (yusdAmount < order.slippageAdjustedAmount) {\n revert PriceSlippage();\n }\n\n // Take a fee, if it's applicable\n (uint256 mintAmount, uint256 fee) = _calculateInsuranceFundFeeFromAmount(yusdAmount, mintFeeBP);\n if (fee > 0) {\n yusd.mint(insuranceFundAddress, fee);\n }\n\n yusd.mint(order.userWallet, mintAmount);\n _custodyTransferrableAssetFunds[order.collateralAsset] += received;\n\n emit Mint(_msgSender(), order.collateralAsset, received, mintAmount, fee);\n }\n\n /**\n * @dev Creates new RedeemRequest and locks user's YUSD tokens\n * @param order Struct containing order details\n * @param signature Signature of trusted signer\n */\n function requestRedeem(\n OrderLib.Order calldata order,\n bytes calldata signature\n ) external nonReentrant onlyWhitelisted(order.userWallet) whenRedeemUnpaused onlySupportedAsset(order.collateralAsset) {\n if (order.orderType != OrderLib.OrderType.REDEEM) {\n revert InvalidOrder();\n }\n\n _checkMintRedeemLimit(redeemLimit, order.yusdAmount);\n order.verify(getDomainSeparator(), aegisConfig.trustedSigner(), signature);\n\n uint256 collateralAmount = _calculateRedeemMinCollateralAmount(order.collateralAsset, order.collateralAmount, order.yusdAmount);\n // Revert transaction when smallest amount is less than order minAmount\n if (collateralAmount < order.slippageAdjustedAmount) {\n revert PriceSlippage();\n }\n\n string memory requestId = abi.decode(order.additionalData, (string));\n RedeemRequest memory request = _redeemRequests[keccak256(abi.encode(requestId))];\n if (request.timestamp != 0) {\n revert InvalidRedeemRequest();\n }\n\n _redeemRequests[keccak256(abi.encode(requestId))] = RedeemRequest(RedeemRequestStatus.PENDING, order, block.timestamp);\n\n // Lock YUSD\n yusd.safeTransferFrom(order.userWallet, address(this), order.yusdAmount);\n totalRedeemLockedYUSD += order.yusdAmount;\n\n emit CreateRedeemRequest(requestId, _msgSender(), order.collateralAsset, order.collateralAmount, order.yusdAmount);\n }\n\n /**\n * @dev Approves pending RedeemRequest.\n * @dev Burns locked YUSD and transfers collateral amount to request order benefactor\n * @param requestId Id of RedeemRequest to approve\n * @param amount Max collateral amount that will be transferred to user\n */\n function approveRedeemRequest(string calldata requestId, uint256 amount) external nonReentrant onlyRole(FUNDS_MANAGER_ROLE) whenRedeemUnpaused {\n RedeemRequest storage request = _redeemRequests[keccak256(abi.encode(requestId))];\n if (request.timestamp == 0 || request.status != RedeemRequestStatus.PENDING) {\n revert InvalidRedeemRequest();\n }\n if (amount == 0 || amount > request.order.collateralAmount) {\n revert InvalidAmount();\n }\n\n // Take a fee, if it's applicable\n (uint256 burnAmount, uint256 fee) = _calculateInsuranceFundFeeFromAmount(request.order.yusdAmount, redeemFeeBP);\n if (fee > 0) {\n yusd.safeTransfer(insuranceFundAddress, fee);\n }\n\n uint256 collateralAmount = _calculateRedeemMinCollateralAmount(request.order.collateralAsset, amount, burnAmount);\n\n /*\n * Reject if:\n * - asset is no longer supported\n * - smallest amount is less than order minAmount\n * - order expired\n */\n if (\n !_supportedAssets.contains(request.order.collateralAsset) ||\n collateralAmount < request.order.slippageAdjustedAmount ||\n request.order.expiry < block.timestamp\n ) {\n _rejectRedeemRequest(requestId, request);\n return;\n }\n\n uint256 availableAssetFunds = _untrackedAvailableAssetBalance(request.order.collateralAsset);\n if (availableAssetFunds < collateralAmount) {\n revert NotEnoughFunds();\n }\n\n request.status = RedeemRequestStatus.APPROVED;\n totalRedeemLockedYUSD -= request.order.yusdAmount;\n\n IERC20(request.order.collateralAsset).safeTransfer(request.order.userWallet, collateralAmount);\n yusd.burn(burnAmount);\n\n emit ApproveRedeemRequest(requestId, _msgSender(), request.order.userWallet, request.order.collateralAsset, collateralAmount, burnAmount, fee);\n }\n\n /**\n * @dev Rejects pending RedeemRequest and unlocks user's YUSD\n * @param requestId Id of RedeemRequest to reject\n */\n function rejectRedeemRequest(string calldata requestId) external nonReentrant onlyRole(FUNDS_MANAGER_ROLE) whenRedeemUnpaused {\n RedeemRequest storage request = _redeemRequests[keccak256(abi.encode(requestId))];\n if (request.timestamp == 0 || request.status != RedeemRequestStatus.PENDING) {\n revert InvalidRedeemRequest();\n }\n\n _rejectRedeemRequest(requestId, request);\n }\n\n /**\n * @dev Withdraws expired RedeemRequest locked YUSD funds to user\n * @param requestId Id of RedeemRequest to withdraw\n */\n function withdrawRedeemRequest(string calldata requestId) public nonReentrant whenRedeemUnpaused {\n RedeemRequest storage request = _redeemRequests[keccak256(abi.encode(requestId))];\n if (request.timestamp == 0 || request.status != RedeemRequestStatus.PENDING || request.order.expiry > block.timestamp) {\n revert InvalidRedeemRequest();\n }\n\n request.status = RedeemRequestStatus.WITHDRAWN;\n\n // Unlock YUSD\n totalRedeemLockedYUSD -= request.order.yusdAmount;\n yusd.safeTransfer(request.order.userWallet, request.order.yusdAmount);\n\n emit WithdrawRedeemRequest(requestId, request.order.userWallet, request.order.yusdAmount);\n }\n\n /**\n * @dev Mints YUSD for cross-chain transfer\n * @param to Address to mint YUSD to\n * @param amount Amount of YUSD to mint\n */\n function mintForCrossChain(address to, uint256 amount) \n external \n nonReentrant \n onlyCrossChainOperator \n whenCrossChainUnpaused \n {\n yusd.mint(to, amount);\n emit CrossChainMint(to, amount);\n }\n\n /**\n * @dev Burns YUSD for cross-chain transfer\n * @param from Address to burn YUSD from\n * @param amount Amount of YUSD to burn\n */\n function burnForCrossChain(address from, uint256 amount) \n external \n nonReentrant \n onlyCrossChainOperator \n whenCrossChainUnpaused \n {\n yusd.burnFrom(from, amount);\n emit CrossChainBurn(from, amount);\n }\n\n\n\n /**\n * @dev Mints YUSD rewards in exchange for collateral asset income\n * @param order Struct containing order details\n * @param signature Signature of trusted signer\n */\n function depositIncome(\n OrderLib.Order calldata order,\n bytes calldata signature\n ) external nonReentrant onlyRole(FUNDS_MANAGER_ROLE) onlySupportedAsset(order.collateralAsset) {\n if (order.orderType != OrderLib.OrderType.DEPOSIT_INCOME) {\n revert InvalidOrder();\n }\n order.verify(getDomainSeparator(), aegisConfig.trustedSigner(), signature);\n _deduplicateOrder(order.userWallet, order.nonce);\n\n uint256 availableAssetFunds = _untrackedAvailableAssetBalance(order.collateralAsset);\n if (availableAssetFunds < order.collateralAmount) {\n revert NotEnoughFunds();\n }\n\n uint256 yusdAmount = _calculateMinYUSDAmount(order.collateralAsset, order.collateralAmount, order.yusdAmount);\n\n _custodyTransferrableAssetFunds[order.collateralAsset] += order.collateralAmount;\n\n // Transfer percent of YUSD rewards to insurance fund\n (uint256 mintAmount, uint256 fee) = _calculateInsuranceFundFeeFromAmount(yusdAmount, incomeFeeBP);\n if (fee > 0) {\n yusd.mint(insuranceFundAddress, fee);\n }\n\n // Mint YUSD rewards to AegisRewards contract\n yusd.mint(address(aegisRewards), mintAmount);\n aegisRewards.depositRewards(order.additionalData, mintAmount);\n\n emit DepositIncome(\n abi.decode(order.additionalData, (string)),\n _msgSender(),\n order.collateralAsset,\n order.collateralAmount,\n mintAmount,\n fee,\n block.timestamp\n );\n }\n\n /**\n * @dev Transfers provided amount of asset to custodian wallet\n * @param wallet Custodian address\n * @param asset Asset address to transfer\n * @param amount Asset amount to transfer\n */\n function transferToCustody(\n address wallet,\n address asset,\n uint256 amount\n ) external nonReentrant onlyRole(COLLATERAL_MANAGER_ROLE) onlySupportedAsset(asset) onlyCustodianAddress(wallet) {\n uint256 availableBalance = _custodyAvailableAssetBalance(asset);\n if (availableBalance < amount) {\n revert NotEnoughFunds();\n }\n\n _custodyTransferrableAssetFunds[asset] -= amount;\n IERC20(asset).safeTransfer(wallet, amount);\n\n emit CustodyTransfer(wallet, asset, amount);\n }\n\n /**\n * @dev Forcefully transfers all asset funds except frozen\n * @param wallet Custodian address\n * @param asset Asset address to transfer\n */\n function forceTransferToCustody(\n address wallet,\n address asset\n ) external nonReentrant onlyRole(COLLATERAL_MANAGER_ROLE) onlySupportedAsset(asset) onlyCustodianAddress(wallet) {\n uint256 availableBalance = _custodyAvailableAssetBalance(asset);\n if (availableBalance == 0) {\n revert NotEnoughFunds();\n }\n\n _custodyTransferrableAssetFunds[asset] -= availableBalance;\n IERC20(asset).safeTransfer(wallet, availableBalance);\n\n emit ForceCustodyTransfer(wallet, asset, availableBalance);\n }\n\n /// @dev Sets new AegisRewards address\n function setAegisRewardsAddress(IAegisRewards _aegisRewards) external onlyRole(SETTINGS_MANAGER_ROLE) {\n if (address(_aegisRewards) == address(0)) {\n revert ZeroAddress();\n }\n _setAegisRewardsAddress(_aegisRewards);\n }\n\n /// @dev Sets new AegisConfig address\n function setAegisConfigAddress(IAegisConfig _config) external onlyRole(DEFAULT_ADMIN_ROLE) {\n _setAegisConfigAddress(_config);\n }\n\n /// @dev Sets new InsuranceFund address\n function setInsuranceFundAddress(address _insuranceFundAddress) external onlyRole(SETTINGS_MANAGER_ROLE) {\n if (_insuranceFundAddress == address(this)) {\n revert InvalidAddress();\n }\n _setInsuranceFundAddress(_insuranceFundAddress);\n }\n\n /// @dev Sets new FeedRegistry address\n function setFeedRegistryAddress(FeedRegistryInterface _registry) external onlyRole(SETTINGS_MANAGER_ROLE) {\n _setFeedRegistryAddress(_registry);\n }\n\n /// @dev Sets new AegisOracle address\n function setAegisOracleAddress(IAegisOracle _aegisOracle) external onlyRole(SETTINGS_MANAGER_ROLE) {\n _setAegisOracleAddress(_aegisOracle);\n }\n\n /// @dev Sets cross-chain operator address\n function setCrossChainOperator(address _operator) external onlyRole(DEFAULT_ADMIN_ROLE) {\n _setCrossChainOperator(_operator);\n }\n\n /// @dev Sets percent in basis points of YUSD that will be taken as a fee on depositIncome\n function setIncomeFeeBP(uint16 value) external onlyRole(SETTINGS_MANAGER_ROLE) {\n // No more than 50%\n if (value > MAX_BPS / 2) {\n revert InvalidPercentBP(value);\n }\n incomeFeeBP = value;\n emit SetIncomeFeeBP(value);\n }\n\n /// @dev Switches mint pause state\n function setMintPaused(bool paused) external onlyRole(SETTINGS_MANAGER_ROLE) {\n mintPaused = paused;\n emit MintPauseChanged(paused);\n }\n\n /// @dev Swtiches redeem pause state\n function setRedeemPaused(bool paused) external onlyRole(SETTINGS_MANAGER_ROLE) {\n redeemPaused = paused;\n emit RedeemPauseChanged(paused);\n }\n\n /// @dev Switches cross-chain operations pause state\n function setCrossChainPaused(bool paused) external onlyRole(SETTINGS_MANAGER_ROLE) {\n crossChainPaused = paused;\n emit CrossChainPauseChanged(paused);\n }\n\n /// @dev Sets percent in basis points of YUSD that will be taken as a fee on mint\n function setMintFeeBP(uint16 value) external onlyRole(SETTINGS_MANAGER_ROLE) {\n // No more than 50%\n if (value > MAX_BPS / 2) {\n revert InvalidPercentBP(value);\n }\n mintFeeBP = value;\n emit SetMintFeeBP(value);\n }\n\n /// @dev Sets percent in basis points of YUSD that will be taken as a fee on redeem\n function setRedeemFeeBP(uint16 value) external onlyRole(SETTINGS_MANAGER_ROLE) {\n // No more than 50%\n if (value > MAX_BPS / 2) {\n revert InvalidPercentBP(value);\n }\n redeemFeeBP = value;\n emit SetRedeemFeeBP(value);\n }\n\n /// @dev Sets mint limit period duration and maximum amount\n function setMintLimits(uint32 periodDuration, uint256 maxPeriodAmount) external onlyRole(SETTINGS_MANAGER_ROLE) {\n mintLimit.periodDuration = periodDuration;\n mintLimit.maxPeriodAmount = maxPeriodAmount;\n emit SetMintLimits(periodDuration, maxPeriodAmount);\n }\n\n /// @dev Sets redeem limit period duration and maximum amount\n function setRedeemLimits(uint32 periodDuration, uint256 maxPeriodAmount) external onlyRole(SETTINGS_MANAGER_ROLE) {\n redeemLimit.periodDuration = periodDuration;\n redeemLimit.maxPeriodAmount = maxPeriodAmount;\n emit SetRedeemLimits(periodDuration, maxPeriodAmount);\n }\n\n /// @dev Sets Chainlink feed heartbeat for asset\n function setChainlinkAssetHeartbeat(address asset, uint32 heartbeat) external onlyRole(SETTINGS_MANAGER_ROLE) onlySupportedAsset(asset) {\n chainlinkAssetHeartbeat[asset] = heartbeat;\n emit SetChainlinkAssetHeartbeat(asset, heartbeat);\n }\n\n /// @dev Adds an asset to supporetd assets list\n function addSupportedAsset(address asset, uint32 hearbeat) public onlyRole(DEFAULT_ADMIN_ROLE) {\n _addSupportedAsset(asset, hearbeat);\n }\n\n /// @dev Removes an asset from supported assets list\n function removeSupportedAsset(address asset) external onlyRole(DEFAULT_ADMIN_ROLE) {\n if (!_supportedAssets.remove(asset)) {\n revert InvalidAssetAddress(asset);\n }\n chainlinkAssetHeartbeat[asset] = 0;\n emit AssetRemoved(asset);\n }\n\n /// @dev Checks if an asset is supported\n function isSupportedAsset(address asset) public view returns (bool) {\n return _supportedAssets.contains(asset);\n }\n\n /// @dev Adds custodian to custodians address list\n function addCustodianAddress(address custodian) public onlyRole(DEFAULT_ADMIN_ROLE) {\n _addCustodianAddress(custodian);\n }\n\n /// @dev Removes custodian from custodians address list\n function removeCustodianAddress(address custodian) external onlyRole(DEFAULT_ADMIN_ROLE) {\n if (!_custodianAddresses.remove(custodian)) {\n revert InvalidCustodianAddress(custodian);\n }\n emit CustodianAddressRemoved(custodian);\n }\n\n\n\n /// @dev Freeze asset funds and prevent them from transferring to custodians or users\n function freezeFunds(address asset, uint256 amount) external onlyRole(FUNDS_MANAGER_ROLE) onlySupportedAsset(asset) {\n if (assetFrozenFunds[asset] + amount > IERC20(asset).balanceOf(address(this))) {\n revert InvalidAmount();\n }\n\n assetFrozenFunds[asset] += amount;\n\n emit FreezeFunds(asset, amount);\n }\n\n /// @dev Unfreeze asset funds and allow them for transferring to custodians or users\n function unfreezeFunds(address asset, uint256 amount) external onlyRole(FUNDS_MANAGER_ROLE) onlySupportedAsset(asset) {\n if (amount > assetFrozenFunds[asset]) {\n revert InvalidAmount();\n }\n\n assetFrozenFunds[asset] -= amount;\n\n emit UnfreezeFunds(asset, amount);\n }\n\n /// @dev Return cached value if chainId matches cache, otherwise recomputes separator\n /// @return The domain separator at current chain\n function getDomainSeparator() public view returns (bytes32) {\n if (block.chainid == _chainId) {\n return _domainSeparator;\n }\n return _computeDomainSeparator();\n }\n\n /// @dev verify validity of nonce by checking its presence\n function verifyNonce(address sender, uint256 nonce) public view returns (uint256, uint256, uint256) {\n if (nonce == 0) revert InvalidNonce();\n uint256 invalidatorSlot = uint64(nonce) >> 8;\n uint256 invalidatorBit = 1 << uint8(nonce);\n uint256 invalidator = _orderBitmaps[sender][invalidatorSlot];\n if (invalidator & invalidatorBit != 0) revert InvalidNonce();\n\n return (invalidatorSlot, invalidator, invalidatorBit);\n }\n\n /// @dev deduplication of user order\n function _deduplicateOrder(address sender, uint256 nonce) private {\n (uint256 invalidatorSlot, uint256 invalidator, uint256 invalidatorBit) = verifyNonce(sender, nonce);\n _orderBitmaps[sender][invalidatorSlot] = invalidator | invalidatorBit;\n }\n\n function _addSupportedAsset(address asset, uint32 heartbeat) internal {\n if (asset == address(0) || asset == address(yusd) || !_supportedAssets.add(asset)) {\n revert InvalidAssetAddress(asset);\n }\n chainlinkAssetHeartbeat[asset] = heartbeat;\n emit AssetAdded(asset, heartbeat);\n }\n\n function _addCustodianAddress(address custodian) internal {\n if (custodian == address(0) || custodian == address(yusd) || !_custodianAddresses.add(custodian)) {\n revert InvalidCustodianAddress(custodian);\n }\n emit CustodianAddressAdded(custodian);\n }\n\n function _setCrossChainOperator(address _operator) internal {\n _crossChainOperatorAddress = _operator;\n emit SetCrossChainOperator(_crossChainOperatorAddress);\n }\n\n function _setInsuranceFundAddress(address _insuranceFundAddress) internal {\n insuranceFundAddress = _insuranceFundAddress;\n emit SetInsuranceFundAddress(insuranceFundAddress);\n }\n\n function _setAegisRewardsAddress(IAegisRewards _aegisRewards) internal {\n aegisRewards = _aegisRewards;\n emit SetAegisRewardsAddress(address(aegisRewards));\n }\n\n function _setAegisOracleAddress(IAegisOracle _aegisOracle) internal {\n aegisOracle = _aegisOracle;\n emit SetAegisOracleAddress(address(aegisOracle));\n }\n\n function _setAegisConfigAddress(IAegisConfig _config) internal {\n if (address(_config) != address(0) && !IERC165(address(_config)).supportsInterface(type(IAegisConfig).interfaceId)) {\n revert InvalidAddress();\n }\n\n aegisConfig = _config;\n emit SetAegisConfigAddress(address(_config));\n }\n\n function _setFeedRegistryAddress(FeedRegistryInterface _registry) internal {\n _feedRegistry = _registry;\n emit SetFeedRegistryAddress(address(_registry));\n }\n\n function _rejectRedeemRequest(string calldata requestId, RedeemRequest storage request) internal {\n request.status = RedeemRequestStatus.REJECTED;\n\n // Unlock YUSD\n totalRedeemLockedYUSD -= request.order.yusdAmount;\n yusd.safeTransfer(request.order.userWallet, request.order.yusdAmount);\n\n emit RejectRedeemRequest(requestId, _msgSender(), request.order.userWallet, request.order.yusdAmount);\n }\n\n function _custodyAvailableAssetBalance(address _asset) internal view returns (uint256) {\n uint256 custodyTransferrableFunds = _custodyTransferrableAssetFunds[_asset];\n uint256 balance = IERC20(_asset).balanceOf(address(this));\n if (balance < custodyTransferrableFunds || custodyTransferrableFunds < assetFrozenFunds[_asset]) {\n return 0;\n }\n\n return custodyTransferrableFunds - assetFrozenFunds[_asset];\n }\n\n function _untrackedAvailableAssetBalance(address _asset) internal view returns (uint256) {\n uint256 balance = IERC20(_asset).balanceOf(address(this));\n if (balance < _custodyTransferrableAssetFunds[_asset] + assetFrozenFunds[_asset]) {\n return 0;\n }\n\n return balance - _custodyTransferrableAssetFunds[_asset] - assetFrozenFunds[_asset];\n }\n\n function _calculateInsuranceFundFeeFromAmount(uint256 amount, uint16 feeBP) internal view returns (uint256, uint256) {\n if (insuranceFundAddress == address(0) || feeBP == 0) {\n return (amount, 0);\n }\n\n uint256 fee = (amount * feeBP) / MAX_BPS;\n\n return (amount - fee, fee);\n }\n\n function _calculateMinYUSDAmount(address collateralAsset, uint256 collateralAmount, uint256 yusdAmount) internal view returns (uint256) {\n (uint256 chainlinkPrice, uint8 feedDecimals) = _getAssetUSDPriceChainlink(collateralAsset);\n if (chainlinkPrice == 0) {\n return yusdAmount;\n }\n\n uint256 chainlinkYUSDAmount = Math.mulDiv(\n collateralAmount * 10 ** (18 - IERC20Metadata(collateralAsset).decimals()),\n chainlinkPrice,\n 10 ** feedDecimals\n );\n\n // Return smallest amount\n return Math.min(yusdAmount, chainlinkYUSDAmount);\n }\n\n function _calculateRedeemMinCollateralAmount(\n address collateralAsset,\n uint256 collateralAmount,\n uint256 yusdAmount\n ) internal view returns (uint256) {\n // Calculate collateral amount for chainlink asset price.\n (uint256 chainlinkPrice, uint8 feedDecimals) = _getAssetUSDPriceChainlink(collateralAsset);\n if (chainlinkPrice > 0) {\n uint256 chainlinkCollateralAmount = Math.mulDiv(\n yusdAmount,\n 10 ** feedDecimals,\n chainlinkPrice * 10 ** (18 - IERC20Metadata(collateralAsset).decimals())\n );\n\n // Get smallest amount\n collateralAmount = Math.min(collateralAmount, chainlinkCollateralAmount);\n }\n\n // Calculate collateral amount for aegisOracle asset/YUSD price.\n (uint256 oraclePrice, uint8 oracleDecimals) = _getAssetYUSDPriceOracle(collateralAsset);\n if (oraclePrice > 0) {\n uint256 oracleCollateralAmount = Math.mulDiv(\n yusdAmount,\n 10 ** oracleDecimals,\n oraclePrice * 10 ** (18 - IERC20Metadata(collateralAsset).decimals())\n );\n\n // Get smallest amount\n collateralAmount = Math.min(collateralAmount, oracleCollateralAmount);\n }\n\n return collateralAmount;\n }\n\n function _checkMintRedeemLimit(MintRedeemLimit storage limits, uint256 yusdAmount) internal {\n if (limits.periodDuration == 0 || limits.maxPeriodAmount == 0) {\n return;\n }\n uint256 currentPeriodEndTime = limits.currentPeriodStartTime + limits.periodDuration;\n if (\n (currentPeriodEndTime >= block.timestamp && limits.currentPeriodTotalAmount + yusdAmount > limits.maxPeriodAmount) ||\n (currentPeriodEndTime < block.timestamp && yusdAmount > limits.maxPeriodAmount)\n ) {\n revert LimitReached();\n }\n // Start new mint period\n if (currentPeriodEndTime <= block.timestamp) {\n limits.currentPeriodStartTime = uint32(block.timestamp);\n limits.currentPeriodTotalAmount = 0;\n }\n\n limits.currentPeriodTotalAmount += yusdAmount;\n }\n\n function _getAssetUSDPriceChainlink(address asset) internal view returns (uint256, uint8) {\n if (address(_feedRegistry) == address(0)) {\n return (0, 0);\n }\n\n (, int256 answer, , uint256 updatedAt, ) = _feedRegistry.latestRoundData(asset, Denominations.USD);\n require(answer > 0, \"Invalid price\");\n require(updatedAt >= block.timestamp - chainlinkAssetHeartbeat[asset], \"Stale price\");\n\n return (uint256(answer), _feedRegistry.decimals(asset, Denominations.USD));\n }\n\n function _getAssetYUSDPriceOracle(address asset) internal view returns (uint256, uint8) {\n if (address(aegisOracle) == address(0)) {\n return (0, 0);\n }\n\n int256 yusdUSDPrice = aegisOracle.yusdUSDPrice();\n if (yusdUSDPrice <= 0) {\n return (0, 0);\n }\n uint8 yusdUSDPriceDecimals = aegisOracle.decimals();\n (uint256 assetUSDPrice, ) = _getAssetUSDPriceChainlink(asset);\n\n return ((assetUSDPrice * 10 ** yusdUSDPriceDecimals) / uint256(yusdUSDPrice), yusdUSDPriceDecimals);\n }\n\n function _computeDomainSeparator() internal view returns (bytes32) {\n return keccak256(abi.encode(EIP712_DOMAIN, EIP712_NAME, EIP712_REVISION, block.chainid, address(this)));\n }\n}\n"},"contracts/interfaces/IAegisConfig.sol":{"content":"// SPDX-License-Identifier: UNLICENSED\npragma solidity ^0.8.26;\n\ninterface IAegisConfig {\n function trustedSigner() external view returns (address);\n\n function isWhitelisted(address addr) external view returns (bool);\n}\n\ninterface IAegisConfigEvents {\n /// @dev Event emitted when one address whitelist status is changed\n event WhitelistAddress(address addr, bool whitelisted);\n\n /// @dev Event emitted when multiple address whitelist statuses are changed\n event WhitelistAddressBatch(address[] addrs, bool[] whitelisted);\n\n /// @dev Event emitted when a trusted signer is changed\n event SetTrustedSigner(address indexed signer);\n\n /// @dev Event emitted when whitelist functionality is enabled\n event WhitelistEnabled();\n\n /// @dev Event emitted when whitelist functionality is disabled\n event WhitelistDisabled();\n\n /// @dev Event emitted when operator is set/unset\n event SetOperator(address indexed operator, bool allowed);\n}\n\ninterface IAegisConfigErrors {\n error InvalidArguments();\n error ZeroAddress();\n error AccessForbidden();\n}\n"},"contracts/interfaces/IAegisMinting.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.26;\n\ninterface IAegisMintingEvents {\n /// @dev Event emitted when YUSD is minted\n event Mint(address indexed userWallet, address collateralAsset, uint256 collateralAmount, uint256 yusdAmount, uint256 fee);\n\n /// @dev Event emitted when new RedeemRequest is created\n event CreateRedeemRequest(string requestId, address indexed userWallet, address collateralAsset, uint256 collateralAmount, uint256 yusdAmount);\n\n /// @dev Event emitted when RedeemRequest is approved and executed by funds manager\n event ApproveRedeemRequest(\n string requestId,\n address indexed manager,\n address indexed userWallet,\n address collateralAsset,\n uint256 collateralAmount,\n uint256 yusdAmount,\n uint256 fee\n );\n\n /// @dev Event emitted when RedeemRequest is rejected\n event RejectRedeemRequest(string requestId, address manager, address userWallet, uint256 yusdAmount);\n\n /// @dev Event emitted when expired redeem request is withdrawn by user\n event WithdrawRedeemRequest(string requestId, address userWallet, uint256 yusdAmount);\n\n /// @dev Event emitted when collateral asset income is deposited\n event DepositIncome(\n string snapshotId,\n address indexed manager,\n address collateralAsset,\n uint256 collateralAmount,\n uint256 yusdAmount,\n uint256 fee,\n uint256 timestamp\n );\n\n /// @dev Event emitted when collateral asset is transferred to custodian wallet\n event CustodyTransfer(address indexed wallet, address indexed asset, uint256 amount);\n\n /// @dev Event emitted when all collateral assets forcefully transferred to custodian wallet\n event ForceCustodyTransfer(address indexed wallet, address indexed asset, uint256 amount);\n\n /// @dev Event emitted when a supported asset is added\n event AssetAdded(address indexed asset, uint32 chainlinkHeartbeat);\n\n /// @dev Event emitted when a supported asset is removed\n event AssetRemoved(address indexed asset);\n\n /// @dev Event emitted when a custodian address is added\n event CustodianAddressAdded(address indexed custodian);\n\n /// @dev Event emitted when a custodian address is removed\n event CustodianAddressRemoved(address indexed custodian);\n\n /// @dev Event emitted when a AegisRewards contract address is changed\n event SetAegisRewardsAddress(address indexed rewards);\n\n /// @dev Event emitted when a AegisConfig contract address is changed\n event SetAegisConfigAddress(address indexed config);\n\n /// @dev Event emitted when a InsuranceFund address is changed\n event SetInsuranceFundAddress(address indexed insuranceFund);\n\n /// @dev Event emitted when a AegisOracle address is changed\n event SetAegisOracleAddress(address indexed oracle);\n\n /// @dev Event emitted when cross-chain operator address is changed\n event SetCrossChainOperator(address indexed operator);\n\n /// @dev Event emitted when a fee percent of income minted YUSD is changed\n event SetIncomeFeeBP(uint16 percentPB);\n\n /// @dev Event emitted when mint is paused/unpaused\n event MintPauseChanged(bool paused);\n\n /// @dev Event emitted when redeem is paused/unpaused\n event RedeemPauseChanged(bool paused);\n\n /// @dev Event emitted when a fee percent of minted YUSD is changed\n event SetMintFeeBP(uint16 val);\n\n /// @dev Event emitted when a fee percent of redeemed YUSD is changed\n event SetRedeemFeeBP(uint16 val);\n\n /// @dev Event emitted when asset amount is frozen\n event FreezeFunds(address indexed asset, uint256 amount);\n\n /// @dev Event emitted when asset amount is unfrozen\n event UnfreezeFunds(address indexed asset, uint256 amount);\n\n /// @dev Event emitted when mint limit parameters are changed\n event SetMintLimits(uint32 periodDuration, uint256 maxPeriodAmount);\n\n /// @dev Event emitted when redeem limit parameters are changed\n event SetRedeemLimits(uint32 periodDuration, uint256 maxPeriodAmount);\n\n /// @dev Event emitted when Chainlink FeedRegistry address is changed\n event SetFeedRegistryAddress(address registry);\n\n /// @dev Event emitted when Chainlink asset feed heartbeat is changed\n event SetChainlinkAssetHeartbeat(address indexed asset, uint32 chainlinkHeartbeat);\n\n /// @dev Event emitted when YUSD is minted for cross-chain transfer\n event CrossChainMint(address indexed to, uint256 amount);\n\n /// @dev Event emitted when YUSD is burned for cross-chain transfer\n event CrossChainBurn(address indexed from, uint256 amount);\n\n /// @dev Event emitted when cross-chain operations are paused/unpaused\n event CrossChainPauseChanged(bool paused);\n}\n\ninterface IAegisMintingErrors {\n error ZeroAddress();\n error InvalidAddress();\n error InvalidAssetAddress(address asset);\n error InvalidCustodianAddress(address custodian);\n error InvalidOrder();\n error NotEnoughFunds();\n error InvalidPercentBP(uint256 value);\n error InvalidRedeemRequest();\n error NotAssetsProvided();\n error MintPaused();\n error RedeemPaused();\n error InvalidAmount();\n error LimitReached();\n error NotWhitelisted();\n error PriceSlippage();\n error InvalidNonce();\n error NotAuthorized();\n error CrossChainPaused();\n}\n"},"contracts/interfaces/IAegisOracle.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.26;\n\ninterface IAegisOracle {\n function decimals() external pure returns (uint8);\n\n function yusdUSDPrice() external view returns (int256);\n\n function lastUpdateTimestamp() external view returns (uint32);\n}\n"},"contracts/interfaces/IAegisRewards.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.26;\n\ninterface IAegisRewards {\n function claimRewards(bytes32[] memory ids, uint256[] memory amounts, bytes memory signature) external;\n\n function depositRewards(bytes calldata requestId, uint256 amount) external;\n}\n\ninterface IAegisRewardsEvents {\n /// @dev Event emitted when YUSD rewards is deposited to the contract\n event DepositRewards(bytes32 id, uint256 amount, uint256 timestamp);\n\n /// @dev Event emitted when rewards with id are finalized\n event FinalizeRewards(bytes32 id, uint256 expiry);\n\n /// @dev Event emitted when expired rewards withdrawn\n event WithdrawExpiredRewards(bytes32 id, address to, uint256 amount);\n\n /// @dev Event emitted when user claims rewards\n event ClaimRewards(address indexed wallet, bytes32[] ids, uint256 totalAmount);\n\n /// @dev Event emitted when AegisConfig contract address is changed\n event SetAegisConfigAddress(address indexed config);\n\n /// @dev Event emitted when AegisMinting contract address is changed\n event SetAegisMintingAddress(address indexed minting);\n}\n\ninterface IAegisRewardsErrors {\n error ZeroAddress();\n error InvalidAddress();\n error ZeroRewards();\n error UnknownRewards();\n}\n"},"contracts/interfaces/IYUSD.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.26;\n\nimport \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol\";\n\ninterface IYUSD is IERC20Permit, IERC20Metadata {\n function mint(address account, uint256 value) external;\n\n function mint(address account, uint256 value, bytes calldata data) external;\n\n function burn(uint256 _amount) external;\n\n function burnFrom(address account, uint256 amount) external;\n\n function setMinter(address newMinter) external;\n}\n\ninterface IYUSDErrors {\n error ZeroAddress();\n error OnlyMinter();\n error Blacklisted(address _user);\n}\n"},"contracts/lib/OrderLib.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.26;\n\nimport \"@openzeppelin/contracts/utils/cryptography/ECDSA.sol\";\nimport \"@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol\";\n\nlibrary OrderLib {\n enum OrderType {\n MINT,\n REDEEM,\n DEPOSIT_INCOME\n }\n\n struct Order {\n OrderType orderType;\n address userWallet;\n address collateralAsset;\n uint256 collateralAmount;\n uint256 yusdAmount;\n uint256 slippageAdjustedAmount;\n uint256 expiry;\n uint256 nonce;\n bytes additionalData;\n }\n\n /// @dev Order type hash\n bytes32 private constant ORDER_TYPE =\n keccak256(\n \"Order(uint8 orderType,address userWallet,address collateralAsset,uint256 collateralAmount,uint256 yusdAmount,uint256 slippageAdjustedAmount,uint256 expiry,uint256 nonce,bytes additionalData)\"\n );\n\n error InvalidSignature();\n error InvalidAmount();\n error InvalidSender();\n error SignatureExpired();\n\n /// @dev Hashes order struct\n function hashOrder(Order calldata order, bytes32 domainSeparator) internal pure returns (bytes32) {\n return MessageHashUtils.toTypedDataHash(domainSeparator, keccak256(encodeOrder(order)));\n }\n\n function encodeOrder(Order calldata order) internal pure returns (bytes memory) {\n return\n abi.encode(\n ORDER_TYPE,\n order.orderType,\n order.userWallet,\n order.collateralAsset,\n order.collateralAmount,\n order.yusdAmount,\n order.slippageAdjustedAmount,\n order.expiry,\n order.nonce,\n keccak256(order.additionalData)\n );\n }\n\n /// @dev Verifies validity of signed order\n function verify(\n Order calldata self,\n bytes32 domainSeparator,\n address expectedSigner,\n bytes calldata signature\n ) internal view returns (bytes32 orderHash) {\n orderHash = hashOrder(self, domainSeparator);\n address signer = ECDSA.recover(orderHash, signature);\n\n if (self.userWallet != msg.sender) revert InvalidSender();\n if (signer != expectedSigner) revert InvalidSignature();\n if (self.collateralAmount == 0) revert InvalidAmount();\n if (self.yusdAmount == 0) revert InvalidAmount();\n if (block.timestamp > self.expiry) revert SignatureExpired();\n }\n}\n"}},"matchId":"8764193","creationMatch":"match","runtimeMatch":"match","verifiedAt":"2025-08-11T13:32:58Z","match":"match","chainId":"1","address":"0xC4Df68e592245cA5202fE8b7C438d2b799820fc2"}