{"file_path":"project/contracts/parallelizer/facets/DiamondCut.sol","creation_status":"success","source_code":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.28;\n\nimport { IDiamondCut } from \"contracts/interfaces/IDiamondCut.sol\";\n\nimport { LibDiamond } from \"../libraries/LibDiamond.sol\";\n\nimport { AccessManagedModifiers } from \"./AccessManagedModifiers.sol\";\nimport \"../Storage.sol\";\n\n/// @title DiamondCut\n/// @author Cooper Labs\n/// @custom:contact security@cooperlabs.xyz\n/// @dev Reference: EIP-2535 Diamonds\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/facets/DiamondCutFacet.sol by mudgen\ncontract DiamondCut is IDiamondCut, AccessManagedModifiers {\n  /// @inheritdoc IDiamondCut\n  function diamondCut(FacetCut[] calldata _diamondCut, address _init, bytes calldata _calldata) external restricted {\n    LibDiamond.diamondCut(_diamondCut, _init, _calldata);\n  }\n}\n","deployed_bytecode":"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","optimization_enabled":true,"verified_twin_address_hash":null,"is_verified":true,"compiler_settings":{"evmVersion":"cancun","libraries":{},"metadata":{"bytecodeHash":"ipfs","useLiteralContent":true},"optimizer":{"enabled":true,"runs":1000},"outputSelection":{"*":{"":["*"],"*":["*"]}},"remappings":["npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/","project/:@helpers/=project/libs/helpers/","project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/","project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/","project/:contracts/=project/contracts/"]},"optimization_runs":1000,"sourcify_repo_url":null,"decoded_constructor_args":null,"compiler_version":"v0.8.28+commit.7893614a","is_verified_via_verifier_alliance":false,"verified_at":"2026-07-28T13:52:27.736612Z","implementations":[],"proxy_type":null,"external_libraries":[],"creation_bytecode":"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","name":"DiamondCut","is_blueprint":false,"license_type":"none","is_fully_verified":true,"is_verified_via_eth_bytecode_db":false,"language":"solidity","evm_version":"cancun","can_be_visualized_via_sol2uml":true,"is_verified_via_sourcify":false,"additional_sources":[{"file_path":"npm/@openzeppelin/contracts@5.4.0/access/manager/AuthorityUtils.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.3.0) (access/manager/AuthorityUtils.sol)\n\npragma solidity ^0.8.20;\n\nimport {IAuthority} from \"./IAuthority.sol\";\n\nlibrary AuthorityUtils {\n    /**\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\n     */\n    function canCallWithDelay(\n        address authority,\n        address caller,\n        address target,\n        bytes4 selector\n    ) internal view returns (bool immediate, uint32 delay) {\n        bytes memory data = abi.encodeCall(IAuthority.canCall, (caller, target, selector));\n\n        assembly (\"memory-safe\") {\n            mstore(0x00, 0x00)\n            mstore(0x20, 0x00)\n\n            if staticcall(gas(), authority, add(data, 0x20), mload(data), 0x00, 0x40) {\n                immediate := mload(0x00)\n                delay := mload(0x20)\n\n                // If delay does not fit in a uint32, return 0 (no delay)\n                // equivalent to: if gt(delay, 0xFFFFFFFF) { delay := 0 }\n                delay := mul(delay, iszero(shr(32, delay)))\n            }\n        }\n    }\n}\n"},{"file_path":"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\n\npragma solidity >=0.8.4;\n\ninterface IAccessManager {\n    /**\n     * @dev A delayed operation was scheduled.\n     */\n    event OperationScheduled(\n        bytes32 indexed operationId,\n        uint32 indexed nonce,\n        uint48 schedule,\n        address caller,\n        address target,\n        bytes data\n    );\n\n    /**\n     * @dev A scheduled operation was executed.\n     */\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\n\n    /**\n     * @dev A scheduled operation was canceled.\n     */\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\n\n    /**\n     * @dev Informational labelling for a roleId.\n     */\n    event RoleLabel(uint64 indexed roleId, string label);\n\n    /**\n     * @dev Emitted when `account` is granted `roleId`.\n     *\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\n     * otherwise it indicates the execution delay for this account and roleId is updated.\n     */\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\n\n    /**\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\n     */\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\n\n    /**\n     * @dev Role acting as admin over a given `roleId` is updated.\n     */\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\n\n    /**\n     * @dev Role acting as guardian over a given `roleId` is updated.\n     */\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\n\n    /**\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\n     */\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\n\n    /**\n     * @dev Target mode is updated (true = closed, false = open).\n     */\n    event TargetClosed(address indexed target, bool closed);\n\n    /**\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\n     */\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\n\n    /**\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\n     */\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\n\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\n    error AccessManagerNotScheduled(bytes32 operationId);\n    error AccessManagerNotReady(bytes32 operationId);\n    error AccessManagerExpired(bytes32 operationId);\n    error AccessManagerLockedRole(uint64 roleId);\n    error AccessManagerBadConfirmation();\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\n    error AccessManagerUnauthorizedConsume(address target);\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\n\n    /**\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\n     * & {execute} workflow.\n     *\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\n     * for future execution.\n     *\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\n     * the operation can be executed if and only if delay is greater than 0.\n     *\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\n     *\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\n     * {AccessManager} documentation.\n     */\n    function canCall(\n        address caller,\n        address target,\n        bytes4 selector\n    ) external view returns (bool allowed, uint32 delay);\n\n    /**\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\n     *\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\n     * disabling any scheduling usage.\n     */\n    function expiration() external view returns (uint32);\n\n    /**\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\n     * accidental increase). Defaults to 5 days.\n     */\n    function minSetback() external view returns (uint32);\n\n    /**\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\n     *\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\n     */\n    function isTargetClosed(address target) external view returns (bool);\n\n    /**\n     * @dev Get the role required to call a function.\n     */\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\n\n    /**\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\n     */\n    function getTargetAdminDelay(address target) external view returns (uint32);\n\n    /**\n     * @dev Get the id of the role that acts as an admin for the given role.\n     *\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\n     * an operation that is restricted to this role.\n     */\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\n\n    /**\n     * @dev Get the role that acts as a guardian for a given role.\n     *\n     * The guardian permission allows canceling operations that have been scheduled under the role.\n     */\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\n\n    /**\n     * @dev Get the role current grant delay.\n     *\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\n     */\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\n\n    /**\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\n     * level.\n     *\n     * Returns:\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\n     * [1] Current execution delay for the account.\n     * [2] Pending execution delay for the account.\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\n     */\n    function getAccess(\n        uint64 roleId,\n        address account\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\n\n    /**\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\n     */\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\n\n    /**\n     * @dev Give a label to a role, for improved role discoverability by UIs.\n     *\n     * Requirements:\n     *\n     * - the caller must be a global admin\n     *\n     * Emits a {RoleLabel} event.\n     */\n    function labelRole(uint64 roleId, string calldata label) external;\n\n    /**\n     * @dev Add `account` to `roleId`, or change its execution delay.\n     *\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\n     *\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\n     *\n     * Requirements:\n     *\n     * - the caller must be an admin for the role (see {getRoleAdmin})\n     * - granted role must not be the `PUBLIC_ROLE`\n     *\n     * Emits a {RoleGranted} event.\n     */\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\n\n    /**\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\n     * no effect.\n     *\n     * Requirements:\n     *\n     * - the caller must be an admin for the role (see {getRoleAdmin})\n     * - revoked role must not be the `PUBLIC_ROLE`\n     *\n     * Emits a {RoleRevoked} event if the account had the role.\n     */\n    function revokeRole(uint64 roleId, address account) external;\n\n    /**\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\n     * the role this call has no effect.\n     *\n     * Requirements:\n     *\n     * - the caller must be `callerConfirmation`.\n     *\n     * Emits a {RoleRevoked} event if the account had the role.\n     */\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\n\n    /**\n     * @dev Change admin role for a given role.\n     *\n     * Requirements:\n     *\n     * - the caller must be a global admin\n     *\n     * Emits a {RoleAdminChanged} event\n     */\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\n\n    /**\n     * @dev Change guardian role for a given role.\n     *\n     * Requirements:\n     *\n     * - the caller must be a global admin\n     *\n     * Emits a {RoleGuardianChanged} event\n     */\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\n\n    /**\n     * @dev Update the delay for granting a `roleId`.\n     *\n     * Requirements:\n     *\n     * - the caller must be a global admin\n     *\n     * Emits a {RoleGrantDelayChanged} event.\n     */\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\n\n    /**\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\n     *\n     * Requirements:\n     *\n     * - the caller must be a global admin\n     *\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\n     */\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\n\n    /**\n     * @dev Set the delay for changing the configuration of a given target contract.\n     *\n     * Requirements:\n     *\n     * - the caller must be a global admin\n     *\n     * Emits a {TargetAdminDelayUpdated} event.\n     */\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\n\n    /**\n     * @dev Set the closed flag for a contract.\n     *\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\n     *\n     * Requirements:\n     *\n     * - the caller must be a global admin\n     *\n     * Emits a {TargetClosed} event.\n     */\n    function setTargetClosed(address target, bool closed) external;\n\n    /**\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\n     */\n    function getSchedule(bytes32 id) external view returns (uint48);\n\n    /**\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\n     * been scheduled.\n     */\n    function getNonce(bytes32 id) external view returns (uint32);\n\n    /**\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\n     * required for the caller. The special value zero will automatically set the earliest possible time.\n     *\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\n     *\n     * Emits a {OperationScheduled} event.\n     *\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\n     * contract if it is using standard Solidity ABI encoding.\n     */\n    function schedule(\n        address target,\n        bytes calldata data,\n        uint48 when\n    ) external returns (bytes32 operationId, uint32 nonce);\n\n    /**\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\n     * execution delay is 0.\n     *\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\n     *\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\n     */\n    function execute(address target, bytes calldata data) external payable returns (uint32);\n\n    /**\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\n     * operation that is cancelled.\n     *\n     * Requirements:\n     *\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\n     *\n     * Emits a {OperationCanceled} event.\n     */\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\n\n    /**\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\n     *\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\n     * with all the verifications that it implies.\n     *\n     * Emit a {OperationExecuted} event.\n     */\n    function consumeScheduledOp(address caller, bytes calldata data) external;\n\n    /**\n     * @dev Hashing function for delayed operations.\n     */\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\n\n    /**\n     * @dev Changes the authority of a target managed by this manager instance.\n     *\n     * Requirements:\n     *\n     * - the caller must be a global admin\n     */\n    function updateAuthority(address target, address newAuthority) external;\n}\n"},{"file_path":"npm/@openzeppelin/contracts@5.4.0/access/manager/IAuthority.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAuthority.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Standard interface for permissioning originally defined in Dappsys.\n */\ninterface IAuthority {\n    /**\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\n     */\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\n}\n"},{"file_path":"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-20 standard as defined in the ERC.\n */\ninterface IERC20 {\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n\n    /**\n     * @dev Returns the value of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the value of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\n     * allowance mechanism. `value` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\n}\n"},{"file_path":"project/contracts/interfaces/IDiamondCut.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.28;\n\nimport \"../parallelizer/Storage.sol\";\n\n/// @title IDiamondCut\n/// @author Cooper Labs\n/// @custom:contact security@cooperlabs.xyz\n/// @dev Reference: EIP-2535 Diamonds\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/interfaces/IDiamondCut.sol by mudgen\n/// @dev This interface is an authorized fork of Angle's `IDiamondCut` interface\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IDiamondCut.sol\ninterface IDiamondCut {\n  /// @notice Add/replace/remove any number of functions and optionally execute a function with delegatecall\n  /// @param _diamondCut Contains the facet addresses and function selectors\n  /// @param _init The address of the contract or facet to execute _calldata\n  /// @param _calldata A function call, including function selector and arguments, executed with delegatecall on\n  /// _init\n  function diamondCut(FacetCut[] calldata _diamondCut, address _init, bytes calldata _calldata) external;\n}\n"},{"file_path":"project/contracts/interfaces/ITokenP.sol","source_code":"// SPDX-License-Identifier: GPL-3.0\npragma solidity 0.8.28;\n\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\n\n/// @title ITokenP\n/// @author Cooper Labs\n/// @custom:contact security@cooperlabs.xyz\n/// @notice Interface for the stablecoins `tokenP` contracts\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\ninterface ITokenP is IERC20 {\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n    MINTER ROLE ONLY FUNCTIONS                                            \n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\n\n  /// @notice Lets a whitelisted contract mint tokenPs\n  /// @param account Address to mint to\n  /// @param amount Amount to mint\n  function mint(address account, uint256 amount) external;\n\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\n  /// @param amount Amount of tokens to burn\n  /// @param burner Address to burn from\n  /// @param sender Address which requested the burn from `burner`\n  /// @dev This method is to be called by a contract with the minter right after being requested\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\n  /// @dev The method checks the allowance between the `sender` and the `burner`\n  function burnFrom(uint256 amount, address burner, address sender) external;\n\n  /// @notice Burns `amount` tokens from a `burner` address\n  /// @param amount Amount of tokens to burn\n  /// @param burner Address to burn from\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\n  /// requested to do so by an address willing to burn tokens from its address\n  function burnSelf(uint256 amount, address burner) external;\n\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n    EXTERNAL FUNCTIONS                                                \n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\n\n  /// @notice Amount of decimals of the stablecoin\n  function decimals() external view returns (uint8);\n}\n"},{"file_path":"project/contracts/interfaces/external/coinbase/ICbETH.sol","source_code":"// SPDX-License-Identifier: GPL-3.0\n\npragma solidity >=0.5.0;\n\n/// @title ICbETH\n/// @notice Interface for the `cbETH` contract\ninterface ICbETH {\n  function exchangeRate() external view returns (uint256);\n}\n"},{"file_path":"project/contracts/interfaces/external/frax/ISfrxETH.sol","source_code":"// SPDX-License-Identifier: GPL-3.0\n\npragma solidity >=0.5.0;\n\n/// @title ISfrxETH\n/// @notice Interface for the `sfrxETH` contract\ninterface ISfrxETH {\n  function pricePerShare() external view returns (uint256);\n}\n"},{"file_path":"project/contracts/interfaces/external/lido/IStETH.sol","source_code":"// SPDX-License-Identifier: GPL-3.0\n\npragma solidity >=0.5.0;\n\n/// @title IStETH\n/// @notice Interface for the `StETH` contract\ninterface IStETH {\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\n\n  function submit(address) external payable returns (uint256);\n\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\n}\n"},{"file_path":"project/contracts/interfaces/external/rocketPool/IRETH.sol","source_code":"// SPDX-License-Identifier: GPL-3.0\n\npragma solidity >=0.5.0;\n\n/// @title IRETH\n/// @notice Interface for the `rETH` contract\ninterface IRETH {\n  function getExchangeRate() external view returns (uint256);\n}\n"},{"file_path":"project/contracts/parallelizer/Storage.sol","source_code":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity 0.8.28;\n\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport { IAccessManager } from \"@openzeppelin/contracts/access/manager/IAccessManager.sol\";\nimport { ITokenP } from \"contracts/interfaces/ITokenP.sol\";\n\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n                                                        ENUMS                                                      \n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\n\nenum FacetCutAction {\n  Add,\n  Replace,\n  Remove\n}\n\nenum ManagerType {\n  EXTERNAL\n}\n\nenum ActionType {\n  Mint,\n  Burn,\n  Redeem\n}\n\nenum TrustedType {\n  Updater,\n  Seller\n}\n\nenum QuoteType {\n  MintExactInput,\n  MintExactOutput,\n  BurnExactInput,\n  BurnExactOutput\n}\n\nenum OracleReadType {\n  CHAINLINK_FEEDS,\n  EXTERNAL,\n  NO_ORACLE,\n  STABLE,\n  WSTETH,\n  CBETH,\n  RETH,\n  SFRXETH,\n  MAX,\n  MORPHO_ORACLE\n}\n\nenum OracleQuoteType {\n  UNIT,\n  TARGET\n}\n\nenum WhitelistType {\n  BACKED\n}\n\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n                                                    STRUCTS                                                     \n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\n\nstruct Permit2Details {\n  address to; // Address that will receive the funds\n  uint256 nonce; // Nonce of the transaction\n  bytes signature; // Permit signature of the user\n}\n\nstruct AuthorizationParams {\n  address from; // Payer's address (Authorizer)\n  uint256 value; // Amount authorized to be transferred\n  uint256 validAfter; // The time after which this is valid (unix time)\n  uint256 validBefore; // The time before which this is valid (unix time)\n  bytes32 nonce; // Unique nonce\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\n}\n\nstruct FacetCut {\n  address facetAddress; // Facet contract address\n  FacetCutAction action; // Can be add, remove or replace\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\"transfer(address,uint256)\"))\n}\n\nstruct Facet {\n  address facetAddress; // Facet contract address\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\"transfer(address,uint256)\"))\n}\n\nstruct FacetInfo {\n  address facetAddress; // Facet contract address\n  uint16 selectorPosition; // Position in the list of all selectors\n}\n\nstruct DiamondStorage {\n  bytes4[] selectors; // List of all available selectors\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\n  IAccessManager accessManager; // Contract handling access management\n}\n\nstruct ImplementationStorage {\n  address implementation; // Dummy implementation address for Etherscan usability\n}\n\nstruct ManagerStorage {\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\n  bytes config; // Additional configuration data\n}\n\nstruct Collateral {\n  uint8 isManaged; // If the collateral is managed through external strategies\n  uint8 isMintLive; // If minting from this asset is unpaused\n  uint8 isBurnLive; // If burning to this asset is unpaused\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\n  bytes oracleConfig; // Data about the oracle used for the collateral\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\n}\n\nstruct ParallelizerStorage {\n  ITokenP tokenP; // tokenP handled by the system\n  uint8 isRedemptionLive; // If redemption is unpaused\n  uint8 statusReentrant; // If call is reentrant or not\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\n  address[] collateralList; // List of collateral assets supported by the system\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\n    // keeper jobs on oracles\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\n    // a specific whitelist type\n  // Used for the surplus distribution\n  mapping(address => uint256) slippageTolerance;\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\n  uint256 lastReleasedAt;\n  uint256 totalShares; // The total shares of the totalShares for all payees\n  address[] payees; // The addresses of the payees\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\n}\n"},{"file_path":"project/contracts/parallelizer/facets/AccessManagedModifiers.sol","source_code":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity 0.8.28;\n\nimport { LibDiamond } from \"../libraries/LibDiamond.sol\";\nimport { LibStorage as s, ParallelizerStorage } from \"../libraries/LibStorage.sol\";\nimport \"../../utils/Errors.sol\";\nimport \"../../utils/Constants.sol\";\n\n/// @title AccessManagedModifiers\n/// @author Cooper Labs\n/// @custom:contact security@cooperlabs.xyz\n/// @dev This contract is an authorized fork of Angle's `AccessControlModifiers` contract\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/AccessControlModifiers.sol\n/// update access logic to use OpenZeppelin's `AccessManaged` logic\ncontract AccessManagedModifiers {\n  /// @notice Checks whether the `msg.sender` can call a function with a given selector\n  modifier restricted() {\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data)) revert AccessManagedUnauthorized(msg.sender);\n    _;\n  }\n\n  /// @notice Prevents a contract from calling itself, directly or indirectly\n  /// @dev This implementation is an adaptation of the OpenZepellin `ReentrancyGuard` for the purpose of this\n  /// Diamond Proxy system. The base implementation can be found here\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol\n  modifier nonReentrant() {\n    ParallelizerStorage storage ts = s.transmuterStorage();\n    // Reentrant protection\n    // On the first call, `ts.statusReentrant` will be `NOT_ENTERED`\n    if (ts.statusReentrant == ENTERED) revert ReentrantCall();\n    // Any calls to the `nonReentrant` modifier after this point will fail\n    ts.statusReentrant = ENTERED;\n\n    _;\n\n    // By storing the original value once again, a refund is triggered (see\n    // https://eips.ethereum.org/EIPS/eip-2200)\n    ts.statusReentrant = NOT_ENTERED;\n  }\n}\n"},{"file_path":"project/contracts/parallelizer/libraries/LibDiamond.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.28;\n\nimport { LibStorage as s } from \"./LibStorage.sol\";\nimport { IAccessManager } from \"@openzeppelin/contracts/access/manager/IAccessManager.sol\";\nimport { AuthorityUtils } from \"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\";\n\nimport \"../../utils/Errors.sol\";\nimport \"../../utils/Constants.sol\";\nimport \"../Storage.sol\";\n\n/// @title LibDiamond\n/// @author Cooper Labs\n/// @custom:contact security@cooperlabs.xyz\n/// @notice Helper library to deal with diamond proxies.\n/// @dev Reference: EIP-2535 Diamonds\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/libraries/LibDiamond.sol by mudgen\nlibrary LibDiamond {\n  event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\n\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n    INTERNAL FUNCTIONS                                                \n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\n\n  function isGovernor(address caller) internal view returns (bool) {\n    (bool isMember,) = s.diamondStorage().accessManager.hasRole(GOVERNOR_ROLE, caller);\n    return isMember;\n  }\n\n  /// @notice Checks whether `caller` can call `data` on `this`\n  function checkCanCall(address caller, bytes calldata data) internal returns (bool) {\n    IAccessManager accessManager = s.diamondStorage().accessManager;\n    (bool immediate, uint32 delay) =\n      AuthorityUtils.canCallWithDelay(address(accessManager), caller, address(this), bytes4(data[0:4]));\n    if (!immediate) {\n      if (delay > 0) {\n        ParallelizerStorage storage ts = s.transmuterStorage();\n        ts.consumingSchedule = true;\n        accessManager.consumeScheduledOp(caller, data);\n        ts.consumingSchedule = false;\n      } else {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  /// @notice Internal function version of `diamondCut`\n  function diamondCut(FacetCut[] memory _diamondCut, address _init, bytes memory _calldata) internal {\n    uint256 diamondCutLength = _diamondCut.length;\n    for (uint256 facetIndex; facetIndex < diamondCutLength; facetIndex++) {\n      bytes4[] memory functionSelectors = _diamondCut[facetIndex].functionSelectors;\n      address facetAddress = _diamondCut[facetIndex].facetAddress;\n\n      if (functionSelectors.length == 0) {\n        revert NoSelectorsProvidedForFacetForCut(facetAddress);\n      }\n\n      FacetCutAction action = _diamondCut[facetIndex].action;\n      if (action == FacetCutAction.Add) {\n        _addFunctions(facetAddress, functionSelectors);\n      } else if (action == FacetCutAction.Replace) {\n        _replaceFunctions(facetAddress, functionSelectors);\n      } else if (action == FacetCutAction.Remove) {\n        _removeFunctions(facetAddress, functionSelectors);\n      }\n    }\n\n    emit DiamondCut(_diamondCut, _init, _calldata);\n    _initializeDiamondCut(_init, _calldata);\n  }\n\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n    PRIVATE FUNCTIONS                                                \n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\n\n  /// @notice Does a delegate call on `_init` with `_calldata`\n  function _initializeDiamondCut(address _init, bytes memory _calldata) private {\n    if (_init == address(0)) {\n      return;\n    }\n    _enforceHasContractCode(_init);\n    (bool success, bytes memory error) = _init.delegatecall(_calldata);\n    if (!success) {\n      if (error.length > 0) {\n        assembly (\"memory-safe\") {\n          let returndata_size := mload(error)\n          revert(add(32, error), returndata_size)\n        }\n      } else {\n        revert InitializationFunctionReverted(_init, _calldata);\n      }\n    }\n  }\n\n  /// @notice Adds a new function to the diamond proxy\n  /// @dev Reverts if selectors are already existing\n  function _addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\n    if (_facetAddress == address(0)) {\n      revert CannotAddSelectorsToZeroAddress(_functionSelectors);\n    }\n    DiamondStorage storage ds = s.diamondStorage();\n    uint16 selectorCount = uint16(ds.selectors.length);\n    _enforceHasContractCode(_facetAddress);\n    uint256 functionSelectorsLength = _functionSelectors.length;\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\n      bytes4 selector = _functionSelectors[selectorIndex];\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\n      if (oldFacetAddress != address(0)) {\n        revert CannotAddFunctionToDiamondThatAlreadyExists(selector);\n      }\n      ds.selectorInfo[selector] = FacetInfo(_facetAddress, selectorCount);\n      ds.selectors.push(selector);\n      selectorCount++;\n    }\n  }\n\n  /// @notice Upgrades a function in the diamond proxy\n  /// @dev Reverts if selectors do not already exist\n  function _replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\n    DiamondStorage storage ds = s.diamondStorage();\n    if (_facetAddress == address(0)) {\n      revert CannotReplaceFunctionsFromFacetWithZeroAddress(_functionSelectors);\n    }\n    _enforceHasContractCode(_facetAddress);\n    uint256 functionSelectorsLength = _functionSelectors.length;\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\n      bytes4 selector = _functionSelectors[selectorIndex];\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\n      // Can't replace immutable functions -- functions defined directly in the diamond in this case\n      if (oldFacetAddress == address(this)) {\n        revert CannotReplaceImmutableFunction(selector);\n      }\n      if (oldFacetAddress == _facetAddress) {\n        revert CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(selector);\n      }\n      if (oldFacetAddress == address(0)) {\n        revert CannotReplaceFunctionThatDoesNotExists(selector);\n      }\n      // Replace old facet address\n      ds.selectorInfo[selector].facetAddress = _facetAddress;\n    }\n  }\n\n  /// @notice Removes a function in the diamond proxy\n  /// @dev Reverts if selectors do not already exist\n  function _removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\n    DiamondStorage storage ds = s.diamondStorage();\n    uint256 selectorCount = ds.selectors.length;\n    if (_facetAddress != address(0)) {\n      revert RemoveFacetAddressMustBeZeroAddress(_facetAddress);\n    }\n    uint256 functionSelectorsLength = _functionSelectors.length;\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\n      bytes4 selector = _functionSelectors[selectorIndex];\n      FacetInfo memory oldFacetAddressAndSelectorPosition = ds.selectorInfo[selector];\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(0)) {\n        revert CannotRemoveFunctionThatDoesNotExist(selector);\n      }\n\n      // Can't remove immutable functions -- functions defined directly in the diamond\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(this)) {\n        revert CannotRemoveImmutableFunction(selector);\n      }\n      // Replace selector with last selector\n      selectorCount--;\n      if (oldFacetAddressAndSelectorPosition.selectorPosition != selectorCount) {\n        bytes4 lastSelector = ds.selectors[selectorCount];\n        ds.selectors[oldFacetAddressAndSelectorPosition.selectorPosition] = lastSelector;\n        ds.selectorInfo[lastSelector].selectorPosition = oldFacetAddressAndSelectorPosition.selectorPosition;\n      }\n      // Delete last selector\n      ds.selectors.pop();\n      delete ds.selectorInfo[selector];\n    }\n  }\n\n  /// @notice Checks that an address has a non void bytecode\n  function _enforceHasContractCode(address _contract) private view {\n    uint256 contractSize;\n    assembly (\"memory-safe\") {\n      contractSize := extcodesize(_contract)\n    }\n    if (contractSize == 0) {\n      revert ContractHasNoCode();\n    }\n  }\n}\n"},{"file_path":"project/contracts/parallelizer/libraries/LibStorage.sol","source_code":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity 0.8.28;\n\nimport \"../../utils/Constants.sol\";\nimport { DiamondStorage, ImplementationStorage, ParallelizerStorage } from \"../Storage.sol\";\n\n/// @title LibStorage\n/// @author Cooper Labs\n/// @custom:contact security@cooperlabs.xyz\n/// @dev This library is an authorized fork of Angle's `LibStorage` library\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibStorage.sol\nlibrary LibStorage {\n  /// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot\n  /// @dev This struct handles the logic of the different facets used in the diamond proxy\n  function diamondStorage() internal pure returns (DiamondStorage storage ds) {\n    bytes32 position = DIAMOND_STORAGE_POSITION;\n    assembly (\"memory-safe\") {\n      ds.slot := position\n    }\n  }\n\n  /// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot\n  /// @dev This struct handles the particular logic of the Parallelizer system\n  function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {\n    bytes32 position = TRANSMUTER_STORAGE_POSITION;\n    assembly (\"memory-safe\") {\n      ts.slot := position\n    }\n  }\n\n  /// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot\n  /// @dev This struct handles the logic for making the contract easily usable on Etherscan\n  function implementationStorage() internal pure returns (ImplementationStorage storage ims) {\n    bytes32 position = IMPLEMENTATION_STORAGE_POSITION;\n    assembly (\"memory-safe\") {\n      ims.slot := position\n    }\n  }\n}\n"},{"file_path":"project/contracts/utils/Constants.sol","source_code":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity 0.8.28;\n\nimport { ICbETH } from \"contracts/interfaces/external/coinbase/ICbETH.sol\";\nimport { ISfrxETH } from \"contracts/interfaces/external/frax/ISfrxETH.sol\";\nimport { IStETH } from \"contracts/interfaces/external/lido/IStETH.sol\";\nimport { IRETH } from \"contracts/interfaces/external/rocketPool/IRETH.sol\";\n\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n                                                 STORAGE SLOTS                                                  \n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\n\n/// @dev Storage position of `DiamondStorage` structure\n/// @dev Equals `keccak256(\"diamond.standard.diamond.storage\") - 1`\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\n\n/// @dev Storage position of `ParallelizerStorage` structure\n/// @dev Equals `keccak256(\"diamond.standard.parallelizer.storage\") - 1`\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\n\n/// @dev Storage position of `ImplementationStorage` structure\n/// @dev Equals `keccak256(\"eip1967.proxy.implementation\") - 1`\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n                                                     MATHS                                                      \n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\n\nuint256 constant BASE_6 = 1e6;\nuint256 constant BASE_8 = 1e8;\nuint256 constant BASE_9 = 1e9;\nuint256 constant BASE_12 = 1e12;\nuint256 constant BPS = 1e14;\nuint256 constant BASE_18 = 1e18;\nuint256 constant HALF_BASE_27 = 1e27 / 2;\nuint256 constant BASE_27 = 1e27;\nuint256 constant BASE_36 = 1e36;\nuint256 constant MAX_BURN_FEE = 999_000_000;\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\nuint256 constant MAX_PAYEES = 10;\nuint256 constant SECONDS_PER_YEAR = 365 days;\nuint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;\n\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n                                                     REENTRANT                                                      \n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\n\n// The values being non-zero value makes deployment a bit more expensive,\n// but in exchange the refund on every call to nonReentrant will be lower in\n// amount. Since refunds are capped to a percentage of the total\n// transaction's gas, it is best to keep them low in cases like this one, to\n// increase the likelihood of the full refund coming into effect.\nuint8 constant NOT_ENTERED = 1;\nuint8 constant ENTERED = 2;\n\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n                                                     REENTRANT                                                      \n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\n\n// Role IDs for the AccessManager\nuint64 constant GOVERNOR_ROLE = 10;\nuint64 constant GUARDIAN_ROLE = 20;\nuint64 constant KEEPER_ROLE = 30;\n\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n                                               COMMON ADDRESSES                                                 \n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\n\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\naddress constant ODOS_ROUTER = 0xCf5540fFFCdC3d510B18bFcA6d2b9987b0772559;\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\n"},{"file_path":"project/contracts/utils/Errors.sol","source_code":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity 0.8.28;\n\nerror AboveCap();\nerror AccessManagedUnauthorized(address caller);\nerror AlreadyAdded();\nerror ArrayLengthMismatch();\nerror AuthorizationTransferMismatch();\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\nerror CannotRemoveImmutableFunction(bytes4 _selector);\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\nerror CannotReplaceImmutableFunction(bytes4 _selector);\nerror ContractHasNoCode();\nerror CollateralBacked();\nerror CannotBurnAllStableIssued();\nerror FunctionNotFound(bytes4 _functionSelector);\nerror IncorrectFacetCutAction(uint8 _action);\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\nerror InvalidChainlinkRate();\nerror InvalidLengths();\nerror InvalidNegativeFees();\nerror InvalidOracleType();\nerror InvalidParam();\nerror InvalidParams();\nerror InvalidRate();\nerror InvalidSwap();\nerror InvalidTokens();\nerror InvalidAccessManager();\nerror InvalidWhitelistStatus();\nerror ManagerHasAssets();\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\nerror NotAllowed();\nerror NotCollateral();\nerror NotGovernor();\nerror NotGuardian();\nerror NotTrusted();\nerror NotTrustedOrGuardian();\nerror NotWhitelisted();\nerror OdosSwapFailed();\nerror OracleUpdateFailed();\nerror SurplusBufferRatioNotSet();\nerror Paused();\nerror AlreadyPaused();\nerror NotPaused();\nerror ReentrantCall();\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\nerror TooBigAmountIn();\nerror TooLate();\nerror TooSmallAmountOut();\nerror ZeroAddress();\nerror ZeroAmount();\nerror ZeroSurplusAmount();\nerror SwapError();\nerror SlippageTooHigh();\nerror InsufficientFunds();\nerror Undercollateralized();\nerror StaleAccrual();\nerror NotInitialized();\n"}],"certified":false,"conflicting_implementations":null,"abi":[{"inputs":[{"internalType":"address","name":"caller","type":"address"}],"name":"AccessManagedUnauthorized","type":"error"},{"inputs":[{"internalType":"bytes4","name":"_selector","type":"bytes4"}],"name":"CannotAddFunctionToDiamondThatAlreadyExists","type":"error"},{"inputs":[{"internalType":"bytes4[]","name":"_selectors","type":"bytes4[]"}],"name":"CannotAddSelectorsToZeroAddress","type":"error"},{"inputs":[{"internalType":"bytes4","name":"_selector","type":"bytes4"}],"name":"CannotRemoveFunctionThatDoesNotExist","type":"error"},{"inputs":[{"internalType":"bytes4","name":"_selector","type":"bytes4"}],"name":"CannotRemoveImmutableFunction","type":"error"},{"inputs":[{"internalType":"bytes4","name":"_selector","type":"bytes4"}],"name":"CannotReplaceFunctionThatDoesNotExists","type":"error"},{"inputs":[{"internalType":"bytes4","name":"_selector","type":"bytes4"}],"name":"CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet","type":"error"},{"inputs":[{"internalType":"bytes4[]","name":"_selectors","type":"bytes4[]"}],"name":"CannotReplaceFunctionsFromFacetWithZeroAddress","type":"error"},{"inputs":[{"internalType":"bytes4","name":"_selector","type":"bytes4"}],"name":"CannotReplaceImmutableFunction","type":"error"},{"inputs":[],"name":"ContractHasNoCode","type":"error"},{"inputs":[{"internalType":"address","name":"_initializationContractAddress","type":"address"},{"internalType":"bytes","name":"_calldata","type":"bytes"}],"name":"InitializationFunctionReverted","type":"error"},{"inputs":[{"internalType":"address","name":"_facetAddress","type":"address"}],"name":"NoSelectorsProvidedForFacetForCut","type":"error"},{"inputs":[{"internalType":"address","name":"_facetAddress","type":"address"}],"name":"RemoveFacetAddressMustBeZeroAddress","type":"error"},{"anonymous":false,"inputs":[{"components":[{"internalType":"address","name":"facetAddress","type":"address"},{"internalType":"enum FacetCutAction","name":"action","type":"uint8"},{"internalType":"bytes4[]","name":"functionSelectors","type":"bytes4[]"}],"indexed":false,"internalType":"struct FacetCut[]","name":"_diamondCut","type":"tuple[]"},{"indexed":false,"internalType":"address","name":"_init","type":"address"},{"indexed":false,"internalType":"bytes","name":"_calldata","type":"bytes"}],"name":"DiamondCut","type":"event"},{"inputs":[{"components":[{"internalType":"address","name":"facetAddress","type":"address"},{"internalType":"enum FacetCutAction","name":"action","type":"uint8"},{"internalType":"bytes4[]","name":"functionSelectors","type":"bytes4[]"}],"internalType":"struct FacetCut[]","name":"_diamondCut","type":"tuple[]"},{"internalType":"address","name":"_init","type":"address"},{"internalType":"bytes","name":"_calldata","type":"bytes"}],"name":"diamondCut","outputs":[],"stateMutability":"nonpayable","type":"function"}],"is_changed_bytecode":false,"is_partially_verified":false,"constructor_args":null}