{"constructor_args":"0x0000000000000000000000003f0da1c363e34802c6f12f9c27276dc0e6696fd8000000000000000000000000b45ac37cc7ff7ec317e7d8c308781ece431639f60000000000000000000000000b93082d9b3c7c97facd250082899bacf3af388500112d8dc3c1543630ab80f0b203d96e427c4e622f198aeedeae79db41ad714235343964316339616338000000000000000000000000000000000000000000000000000000000000000000008eec10616802ef639ca55c98ac856553fadefbad","is_partially_verified":true,"is_changed_bytecode":false,"abi":[{"inputs":[{"internalType":"address","name":"initialAuthority","type":"address"},{"internalType":"contract INAVOracle","name":"oracle_","type":"address"},{"internalType":"address","name":"forwarder_","type":"address"},{"internalType":"bytes32","name":"expectedWorkflowId_","type":"bytes32"},{"internalType":"bytes10","name":"expectedWorkflowName_","type":"bytes10"},{"internalType":"address","name":"expectedWorkflowOwner_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"authority","type":"address"}],"name":"AccessManagedInvalidAuthority","type":"error"},{"inputs":[{"internalType":"address","name":"caller","type":"address"},{"internalType":"uint32","name":"delay","type":"uint32"}],"name":"AccessManagedRequiredDelay","type":"error"},{"inputs":[{"internalType":"address","name":"caller","type":"address"}],"name":"AccessManagedUnauthorized","type":"error"},{"inputs":[],"name":"InvalidMetadata","type":"error"},{"inputs":[],"name":"InvalidReport","type":"error"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"NotAContract","type":"error"},{"inputs":[{"internalType":"address","name":"caller","type":"address"}],"name":"UnauthorizedForwarder","type":"error"},{"inputs":[{"internalType":"bytes32","name":"workflowId","type":"bytes32"}],"name":"UnauthorizedWorkflowId","type":"error"},{"inputs":[{"internalType":"bytes10","name":"name","type":"bytes10"}],"name":"UnauthorizedWorkflowName","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"UnauthorizedWorkflowOwner","type":"error"},{"inputs":[{"internalType":"bytes32","name":"feedId","type":"bytes32"}],"name":"UnexpectedFeedId","type":"error"},{"inputs":[{"internalType":"uint256","name":"chainId","type":"uint256"}],"name":"WrongChain","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"WrongReceiver","type":"error"},{"inputs":[],"name":"ZeroAddress","type":"error"},{"inputs":[],"name":"ZeroWorkflowConfig","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"authority","type":"address"}],"name":"AuthorityUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"previous","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"current","type":"bytes32"}],"name":"ExpectedWorkflowIdUpdated","type":"event"},{"inputs":[],"name":"authority","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"expectedWorkflowId","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"expectedWorkflowName","outputs":[{"internalType":"bytes10","name":"","type":"bytes10"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"expectedWorkflowOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feedId","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"forwarder","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isConsumingScheduledOp","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"metadata","type":"bytes"},{"internalType":"bytes","name":"report","type":"bytes"}],"name":"onReport","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"oracle","outputs":[{"internalType":"contract INAVOracle","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newAuthority","type":"address"}],"name":"setAuthority","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"newExpectedWorkflowId","type":"bytes32"}],"name":"setExpectedWorkflowId","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"}],"conflicting_implementations":null,"certified":false,"additional_sources":[{"file_path":"../vendor/smart-contracts-oracle/lib/openzeppelin-contracts/contracts/access/manager/AccessManaged.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/AccessManaged.sol)\n\npragma solidity ^0.8.20;\n\nimport {AuthorityUtils} from \"./AuthorityUtils.sol\";\nimport {IAccessManager} from \"./IAccessManager.sol\";\nimport {IAccessManaged} from \"./IAccessManaged.sol\";\nimport {Context} from \"../../utils/Context.sol\";\n\n/**\n * @dev This contract module makes available a {restricted} modifier. Functions decorated with this modifier will be\n * permissioned according to an \"authority\": a contract like {AccessManager} that follows the {IAuthority} interface,\n * implementing a policy that allows certain callers to access certain functions.\n *\n * IMPORTANT: The `restricted` modifier should never be used on `internal` functions, judiciously used in `public`\n * functions, and ideally only used in `external` functions. See {restricted}.\n */\nabstract contract AccessManaged is Context, IAccessManaged {\n    address private _authority;\n\n    bool private _consumingSchedule;\n\n    /**\n     * @dev Initializes the contract connected to an initial authority.\n     */\n    constructor(address initialAuthority) {\n        _setAuthority(initialAuthority);\n    }\n\n    /**\n     * @dev Restricts access to a function as defined by the connected Authority for this contract and the\n     * caller and selector of the function that entered the contract.\n     *\n     * [IMPORTANT]\n     * ====\n     * In general, this modifier should only be used on `external` functions. It is okay to use it on `public`\n     * functions that are used as external entry points and are not called internally. Unless you know what you're\n     * doing, it should never be used on `internal` functions. Failure to follow these rules can have critical security\n     * implications! This is because the permissions are determined by the function that entered the contract, i.e. the\n     * function at the bottom of the call stack, and not the function where the modifier is visible in the source code.\n     * ====\n     *\n     * [WARNING]\n     * ====\n     * Avoid adding this modifier to the https://docs.soliditylang.org/en/v0.8.20/contracts.html#receive-ether-function[`receive()`]\n     * function or the https://docs.soliditylang.org/en/v0.8.20/contracts.html#fallback-function[`fallback()`]. These\n     * functions are the only execution paths where a function selector cannot be unambiguously determined from the calldata\n     * since the selector defaults to `0x00000000` in the `receive()` function and similarly in the `fallback()` function\n     * if no calldata is provided. (See {_checkCanCall}).\n     *\n     * The `receive()` function will always panic whereas the `fallback()` may panic depending on the calldata length.\n     * ====\n     */\n    modifier restricted() {\n        _checkCanCall(_msgSender(), _msgData());\n        _;\n    }\n\n    /// @inheritdoc IAccessManaged\n    function authority() public view virtual returns (address) {\n        return _authority;\n    }\n\n    /// @inheritdoc IAccessManaged\n    function setAuthority(address newAuthority) public virtual {\n        address caller = _msgSender();\n        if (caller != authority()) {\n            revert AccessManagedUnauthorized(caller);\n        }\n        if (newAuthority.code.length == 0) {\n            revert AccessManagedInvalidAuthority(newAuthority);\n        }\n        _setAuthority(newAuthority);\n    }\n\n    /// @inheritdoc IAccessManaged\n    function isConsumingScheduledOp() public view returns (bytes4) {\n        return _consumingSchedule ? this.isConsumingScheduledOp.selector : bytes4(0);\n    }\n\n    /**\n     * @dev Transfers control to a new authority. Internal function with no access restriction. Allows bypassing the\n     * permissions set by the current authority.\n     */\n    function _setAuthority(address newAuthority) internal virtual {\n        _authority = newAuthority;\n        emit AuthorityUpdated(newAuthority);\n    }\n\n    /**\n     * @dev Reverts if the caller is not allowed to call the function identified by a selector. Panics if the calldata\n     * is less than 4 bytes long.\n     */\n    function _checkCanCall(address caller, bytes calldata data) internal virtual {\n        (bool immediate, uint32 delay) = AuthorityUtils.canCallWithDelay(\n            authority(),\n            caller,\n            address(this),\n            bytes4(data[0:4])\n        );\n        if (!immediate) {\n            if (delay > 0) {\n                _consumingSchedule = true;\n                IAccessManager(authority()).consumeScheduledOp(caller, data);\n                _consumingSchedule = false;\n            } else {\n                revert AccessManagedUnauthorized(caller);\n            }\n        }\n    }\n}\n"},{"file_path":"../vendor/smart-contracts-oracle/lib/openzeppelin-contracts/contracts/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":"../vendor/smart-contracts-oracle/lib/openzeppelin-contracts/contracts/access/manager/IAccessManaged.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManaged.sol)\n\npragma solidity >=0.8.4;\n\ninterface IAccessManaged {\n    /**\n     * @dev Authority that manages this contract was updated.\n     */\n    event AuthorityUpdated(address authority);\n\n    error AccessManagedUnauthorized(address caller);\n    error AccessManagedRequiredDelay(address caller, uint32 delay);\n    error AccessManagedInvalidAuthority(address authority);\n\n    /**\n     * @dev Returns the current authority.\n     */\n    function authority() external view returns (address);\n\n    /**\n     * @dev Transfers control to a new authority. The caller must be the current authority.\n     */\n    function setAuthority(address) external;\n\n    /**\n     * @dev Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is\n     * being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs\n     * attacker controlled calls.\n     */\n    function isConsumingScheduledOp() external view returns (bytes4);\n}\n"},{"file_path":"../vendor/smart-contracts-oracle/lib/openzeppelin-contracts/contracts/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":"../vendor/smart-contracts-oracle/lib/openzeppelin-contracts/contracts/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":"../vendor/smart-contracts-oracle/lib/openzeppelin-contracts/contracts/utils/Context.sol","source_code":"// 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"},{"file_path":"../vendor/smart-contracts-oracle/lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"},{"file_path":"../vendor/smart-contracts-oracle/src/nav/interfaces/INAVDataProvider.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.30;\n\n/**\n * @title NAV Data Provider Interface\n * @notice Minimal read surface for a NAV value and its source-data timestamp.\n */\ninterface INAVDataProvider {\n    /**\n     * @notice Return the current NAV and the time its source data was observed.\n     * @return nav The latest NAV value with 18 decimal places.\n     * @return timestamp The source observation time in Unix seconds. An intermediary must preserve\n     *         this value rather than replace it with its own acceptance time.\n     */\n    function getCurrentNAV() external view returns (uint256 nav, uint256 timestamp);\n}\n"},{"file_path":"../vendor/smart-contracts-oracle/src/nav/interfaces/INAVOracle.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.30;\n\nimport {INAVDataProvider} from \"./INAVDataProvider.sol\";\n\n/// @notice How an accepted NAV round was produced. Emitted with every round for monitoring/audit.\nenum UpdateKind {\n    Bootstrap, // initial seed recorded by the NAVOracle constructor\n    Report, // automated up-or-flat write submitted through an authorized provider\n    Force, // authorized manual up-or-flat write for outage or recovery use\n    Markdown // delayed write-down; the only NAVOracle path that can decrease NAV\n}\n\n/// @notice Outcome of a {INAVOracle.submitReport} call.\n/// @dev NAVOracle returns a status for accepted reports and terminal no-write outcomes; future-dated\n///      observations and value-rail violations revert. Report providers are expected to treat a\n///      returned status as transport success, but that mapping is provider behavior.\nenum SubmitStatus {\n    Accepted,\n    IgnoredInProtection,\n    DiscardedNonMonotonic,\n    DiscardedStale\n}\n\n// ----- Shared events (file-level so NAVOracle and its report providers use one set of\n//       declarations without inheritance) -----\n\n/// @notice A new NAV round was accepted (any path — see kind).\nevent NAVUpdated(\n    uint80 indexed roundId, uint256 nav, uint256 observationTimestamp, UpdateKind kind\n);\n/// @notice Chainlink V2 event signatures emitted by NAVOracle when it records a core round.\n/// @dev `AnswerUpdated.current` is the raw 18-decimal core NAV, and the log emitter is NAVOracle.\n///      It is not a scaled feed answer: for example, an 8-decimal NAVFeed returns\n///      `floor(current / 1e10)` as `latestRoundData().answer`, while an 8-decimal NAVFeedProxy\n///      returns that value from both `latestAnswer()` and `latestRoundData().answer`.\nevent AnswerUpdated(int256 indexed current, uint256 indexed roundId, uint256 updatedAt);\nevent NewRound(uint256 indexed roundId, address indexed startedBy, uint256 startedAt);\n/// @notice A provider report arrived during Protection Mode and was ignored. The returned status\n///         can be mapped to transport acknowledgement by the provider.\nevent ReportIgnoredInProtection(bytes32 indexed feedId, uint256 nav, uint256 observationTimestamp);\n/// @notice A non-monotonic or stale provider observation was discarded.\n/// @dev NAVOracle returns a discard status; transport retry behavior belongs to the provider.\nevent ReportDiscarded(\n    bytes32 indexed feedId, uint256 nav, uint256 observationTimestamp, bytes4 reason\n);\n/// @notice An accepted provider report was written.\nevent ReportAccepted(\n    bytes32 indexed feedId, uint256 nav, uint256 observationTimestamp, uint256 deviationBps\n);\n/// @notice Protection Mode entered (`by` is the enterer; every entry consumes the one-shot arming).\nevent ProtectionModeEntered(address indexed by, uint256 indexed episodeId, string reason);\n/// @notice Protection Mode exited by an authorized caller.\nevent ProtectionModeExited(address indexed by);\n/// @notice Protection entry was re-armed by an authorized caller.\nevent ProtectionEntryRearmed(address indexed by);\n/// @notice A timelocked markdown executed: NAV decreased from previousNav to newNav.\nevent MarkdownApplied(uint80 indexed roundId, uint256 previousNav, uint256 newNav, string reason);\n/// @notice Authorized manual up-or-flat write.\nevent NAVForceUpdated(address indexed by, uint256 nav, uint256 observationTimestamp, string reason);\n/// @notice Constructor seed recorded as round 1 (no sink push).\nevent Bootstrapped(address indexed deployer, uint256 nav, uint256 dataTimestamp);\n\n// Configuration events.\nevent NormalBandUpdated(uint256 previous, uint256 current);\nevent ForceBandUpdated(uint256 previous, uint256 current);\nevent MaxNAVUpdated(uint256 previous, uint256 current);\n\n// ----- Shared errors (file-level for the same reason) -----\n\nerror ZeroAddress();\nerror ZeroFeedId();\nerror InvalidBounds();\nerror InvalidBand();\nerror InvalidVelocity();\nerror InvalidStaleness();\nerror NoData(uint80 roundId);\n/// @dev Used as the {ReportDiscarded} reason selector for a non-monotonic observation; the\n///      submission returns a discard status instead of reverting with this error.\nerror NonMonotonicObservation(uint256 observationTimestamp, uint256 lastObservationTs);\nerror ZeroObservationTimestamp();\nerror FutureObservation(uint256 observationTimestamp, uint256 blockTimestamp);\nerror StaleObservation(uint256 observationTimestamp);\nerror OutOfBounds(uint256 navValue);\nerror DeviationExceeded(uint256 navValue, uint256 currentNav, uint256 deviationBps);\nerror VelocityExceeded(uint256 navValue, uint256 moveWad, uint256 budgetWad);\nerror NAVMustNotDecrease(uint256 navValue, uint256 currentNav);\nerror ProtectionModeActive();\nerror ProtectionModeNotActive();\nerror ProtectionEntryNotArmed();\nerror MarkdownMustDecrease(uint256 navValue, uint256 currentNav);\nerror MarkdownBelowFloor(uint256 navValue, uint256 floor);\nerror MarkdownEpisodeMismatch(uint256 providedEpisode, uint256 currentEpisode);\nerror MarkdownTooFrequent(uint256 elapsed, uint256 required);\nerror MarkdownDelayNotElapsed(uint256 readyAt, uint256 nowTs);\nerror InvalidMarkdownDelay();\nerror ForceUpdateTooFrequent(uint256 elapsed, uint256 required);\n\n/**\n * @title INAVOracle\n * @notice Protocol-facing surface implemented by {NAVOracle}. NAV uses 18-decimal fixed-point units\n *         on this surface; an integrator-facing feed may scale values to different decimals.\n *\n * @dev NAVOracle ignores automated reports and blocks force writes during Protection Mode, while\n *      delayed markdowns remain available. If no markdown executes, the latest round timestamp\n *      remains unchanged. AccessManager scheduling and any market action triggered by feed\n *      staleness are deployment and integrator policy rather than guarantees of this interface.\n */\ninterface INAVOracle is INAVDataProvider {\n    /// @notice Number of decimals used by the protocol NAV surface.\n    /// @dev NAVOracle returns 18. The distinct name avoids confusing protocol NAV decimals with an\n    ///      AggregatorV3 feed's `decimals()`.\n    function navDecimals() external pure returns (uint8);\n\n    /// @notice Latest accepted round id (at least 1 because the constructor records the seed).\n    function latestRound() external view returns (uint80);\n\n    /// @notice Return a stored round. NAVOracle reverts {NoData} for a nonexistent round id.\n    function getRound(uint80 roundId) external view returns (uint256 answer, uint256 updatedAt);\n\n    /// @notice Whether Protection Mode is active.\n    /// @dev NAVOracle ignores reports and blocks force writes while active; markdowns remain\n    ///      available subject to their episode and timing gates.\n    function protectionMode() external view returns (bool);\n\n    /// @notice Monotonically increasing protection episode id used to bind NAVOracle markdowns.\n    function protectionEpisodeId() external view returns (uint256);\n\n    /// @notice Source-data timestamp associated with the current NAV value.\n    /// @dev Bootstrap and reports preserve their source observation time; force writes and\n    ///      markdowns use their execution block time. This is distinct from a round's `updatedAt`,\n    ///      which records when this oracle accepted the round. It can move backward when a report\n    ///      observed shortly before a force write is accepted afterward.\n    function currentDataTimestamp() external view returns (uint256);\n\n    /// @notice Timestamp used only for automated-report ordering and replay protection.\n    /// @dev NAVOracle initializes it from the constructor seed's source-data timestamp. Accepted\n    ///      reports and markdowns advance it; force writes do not. It is not necessarily the\n    ///      timestamp associated with the current NAV value; use {currentDataTimestamp} for that.\n    function lastObservationTs() external view returns (uint256);\n\n    /// @notice The feed identifier this oracle serves (report providers bind against it).\n    function feedId() external view returns (bytes32);\n\n    /// @notice Submit a NAV observation to the implementing oracle.\n    /// @dev NAVOracle restricts this call through its authority and enforces its value and ordering\n    ///      rails. Transport authentication, decoding, and chain/feed binding remain provider\n    ///      responsibilities; provider authorization is deployment wiring.\n    /// @param navValue NAV in 18-decimal fixed-point units.\n    /// @param observationTimestamp Observation time in Unix seconds.\n    /// @return status Accepted or terminal no-write outcome.\n    function submitReport(uint256 navValue, uint256 observationTimestamp)\n        external\n        returns (SubmitStatus);\n}\n"},{"file_path":"../vendor/smart-contracts-oracle/src/nav/interfaces/IReceiver.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.30;\n\n/// @title IReceiver — receives Keystone reports\n/// @notice Local declaration of Chainlink Keystone's `onReport(bytes,bytes)` callback.\n/// @dev Chainlink's upstream interface also inherits IERC165; this repository supplies IERC165\n///      separately in the implementation. KeystoneForwarder requires the receiver to advertise\n///      `type(IReceiver).interfaceId`. Adding functions directly to this interface changes that id\n///      and can cause the forwarder to reject delivery. A parity test pins the callback id.\ninterface IReceiver {\n    /// @notice Handle an incoming Keystone report.\n    /// @dev A reverted call may be retried. The receiver is responsible for discarding stale\n    ///      reports.\n    /// @param metadata Report's metadata.\n    /// @param report Workflow report.\n    function onReport(bytes calldata metadata, bytes calldata report) external;\n}\n"}],"is_verified_via_sourcify":false,"can_be_visualized_via_sol2uml":true,"evm_version":"shanghai","language":"solidity","is_verified_via_eth_bytecode_db":false,"is_fully_verified":false,"license_type":"none","is_blueprint":false,"name":"CREReportProvider","creation_bytecode":"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","external_libraries":[],"proxy_type":null,"implementations":[],"verified_at":"2026-07-27T20:28:25.032598Z","is_verified_via_verifier_alliance":false,"compiler_version":"v0.8.30+commit.73712a01","decoded_constructor_args":[["0x3f0DA1C363e34802C6f12F9C27276dC0e6696FD8",{"internalType":"address","name":"initialAuthority","type":"address"}],["0xb45AC37Cc7fF7ec317e7D8C308781ECe431639f6",{"internalType":"contract INAVOracle","name":"oracle_","type":"address"}],["0x0b93082D9b3C7C97fAcd250082899BAcf3af3885",{"internalType":"address","name":"forwarder_","type":"address"}],["0x00112d8dc3c1543630ab80f0b203d96e427c4e622f198aeedeae79db41ad7142",{"internalType":"bytes32","name":"expectedWorkflowId_","type":"bytes32"}],["0x35343964316339616338",{"internalType":"bytes10","name":"expectedWorkflowName_","type":"bytes10"}],["0x8eec10616802Ef639CA55c98ac856553fAdEfBaD",{"internalType":"address","name":"expectedWorkflowOwner_","type":"address"}]],"sourcify_repo_url":null,"optimization_runs":500,"compiler_settings":{"evmVersion":"shanghai","libraries":{},"metadata":{"appendCBOR":true,"bytecodeHash":"ipfs","useLiteralContent":false},"optimizer":{"enabled":true,"runs":500},"outputSelection":{"*":{"":["*"],"*":["*"]}},"remappings":["@openzeppelin/contracts/=../vendor/smart-contracts-oracle/lib/openzeppelin-contracts/contracts/","@chainlink/contracts-ccip/contracts/=../vendor/smart-contracts-oracle/lib/chainlink-local/lib/chainlink-ccip/chains/evm/contracts/","@chainlink/contracts-ccip/interfaces/=../vendor/smart-contracts-oracle/lib/chainlink-local/lib/chainlink-ccip/chains/evm/contracts/interfaces/","@chainlink/contracts-ccip/libraries/=../vendor/smart-contracts-oracle/lib/chainlink-local/lib/chainlink-ccip/chains/evm/contracts/libraries/","@chainlink/contracts-ccip/applications/=../vendor/smart-contracts-oracle/lib/chainlink-local/lib/chainlink-ccip/chains/evm/contracts/applications/","forge-std/=../vendor/smart-contracts-oracle/lib/forge-std/src/","oracle-src/=../vendor/smart-contracts-oracle/src/","oracle-script/=../vendor/smart-contracts-oracle/script/","src/=../vendor/smart-contracts-oracle/src/","@chainlink/contracts/=/private/tmp/codex-nav-http-reconciliation/vendor/smart-contracts-oracle/lib/chainlink-local/lib/chainlink-evm/contracts/","@chainlink/local/src/=/private/tmp/codex-nav-http-reconciliation/vendor/smart-contracts-oracle/lib/chainlink-local/src/","@openzeppelin/contracts-upgradeable/=/private/tmp/codex-nav-http-reconciliation/vendor/smart-contracts-oracle/lib/openzeppelin-contracts-upgradeable/contracts/","@openzeppelin/contracts@4.7.3/=/private/tmp/codex-nav-http-reconciliation/vendor/smart-contracts-oracle/lib/chainlink-local/src/vendor/openzeppelin-solidity/v4.7.3/contracts/","@openzeppelin/contracts@4.8.3/=/private/tmp/codex-nav-http-reconciliation/vendor/smart-contracts-oracle/lib/chainlink-local/src/vendor/openzeppelin-solidity/v4.8.3/contracts/","@openzeppelin/contracts@5.0.2/=/private/tmp/codex-nav-http-reconciliation/vendor/smart-contracts-oracle/lib/chainlink-local/src/vendor/openzeppelin-solidity/v5.0.2/contracts/","chainlink-ccip/=/private/tmp/codex-nav-http-reconciliation/vendor/smart-contracts-oracle/lib/chainlink-local/lib/chainlink-ccip/chains/evm/contracts/vendor/optimism/interop-lib/v0/src/","chainlink-local/=/private/tmp/codex-nav-http-reconciliation/vendor/smart-contracts-oracle/lib/chainlink-local/src/","chainlink/=../vendor/smart-contracts-oracle/lib/chainlink/","erc4626-tests/=/private/tmp/codex-nav-http-reconciliation/vendor/smart-contracts-oracle/lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/","halmos-cheatcodes/=/private/tmp/codex-nav-http-reconciliation/vendor/smart-contracts-oracle/lib/openzeppelin-contracts-upgradeable/lib/halmos-cheatcodes/src/","openzeppelin-contracts-upgradeable/=/private/tmp/codex-nav-http-reconciliation/vendor/smart-contracts-oracle/lib/openzeppelin-contracts-upgradeable/contracts/","openzeppelin-contracts/=/private/tmp/codex-nav-http-reconciliation/vendor/smart-contracts-oracle/lib/openzeppelin-contracts/contracts/","openzeppelin-foundry-upgrades/=/private/tmp/codex-nav-http-reconciliation/vendor/smart-contracts-oracle/lib/openzeppelin-foundry-upgrades/src/"],"viaIR":true},"is_verified":true,"verified_twin_address_hash":null,"optimization_enabled":true,"deployed_bytecode":"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","source_code":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.30;\n\nimport {AccessManaged} from \"@openzeppelin/contracts/access/manager/AccessManaged.sol\";\nimport {IERC165} from \"@openzeppelin/contracts/utils/introspection/IERC165.sol\";\nimport {IReceiver} from \"../interfaces/IReceiver.sol\";\n// solhint-disable-next-line no-global-import — pulls in the shared file-level events/errors too.\nimport \"../interfaces/INAVOracle.sol\";\n\n// Provider-specific CRE events and errors intentionally remain outside the provider-agnostic core\n// interface.\n\nevent ExpectedWorkflowIdUpdated(bytes32 indexed previous, bytes32 indexed current);\n\nerror UnauthorizedForwarder(address caller);\nerror UnauthorizedWorkflowId(bytes32 workflowId);\nerror UnauthorizedWorkflowName(bytes10 name);\nerror UnauthorizedWorkflowOwner(address owner);\nerror WrongReceiver(address receiver);\nerror UnexpectedFeedId(bytes32 feedId);\nerror WrongChain(uint256 chainId);\nerror InvalidReport();\nerror InvalidMetadata();\nerror ZeroWorkflowConfig();\nerror NotAContract(address target);\n\n/**\n * @title CREReportProvider — Chainlink CRE transport for the NAVOracle\n * @notice The oracle-network-specific half of report ingestion: authenticates the Keystone\n *         delivery (forwarder address, workflow id, workflow name + owner, metadata layout),\n *         decodes and binds the report\n *         (`abi.encode(chainId, receiver, feedId, navValue, observationTimestamp)`), and hands the\n *         observation to {INAVOracle.submitReport}.\n *\n *         Swapping oracle networks = deploy a new provider for the new transport and re-grant the\n *         submit permission on the core through the AccessManager. The provider authenticates and\n *         binds the transport payload; the core independently enforces numeric bounds, ordering,\n *         deviation, velocity, and non-decrease rules. A compromised authorized provider can still\n *         submit any observation that satisfies those rules.\n *\n * @dev Any {SubmitStatus} returned by the core is acknowledged by returning successfully from\n *      {onReport}; this includes accepted reports, reports ignored during protection, and stale or\n *      non-monotonic discards. Core reverts propagate to the forwarder. Retry behavior after a\n *      revert is external to this contract.\n *\n * @dev Keystone `workflowId` (metadata bytes [0,32)) is pinned because each provider deployment\n *      has exactly one writer workflow. Governance must rotate {expectedWorkflowId} before a new\n *      workflow revision begins delivery.\n */\ncontract CREReportProvider is IReceiver, IERC165, AccessManaged {\n    /// @notice The oracle core this provider feeds.\n    INAVOracle public immutable oracle;\n    /// @notice Feed id read from the core at deployment; every report must match it.\n    bytes32 public immutable feedId;\n\n    /// @notice The only address allowed to deliver (the chain's KeystoneForwarder).\n    address public immutable forwarder;\n    /// @notice The only CRE workflow id allowed to deliver through the forwarder.\n    bytes32 public expectedWorkflowId;\n    /// @notice The allowed CRE workflow name (Keystone metadata is bytes10).\n    bytes10 public immutable expectedWorkflowName;\n    /// @notice The allowed CRE workflow owner.\n    address public immutable expectedWorkflowOwner;\n\n    /// @dev The stable transport identity is complete and valid at deployment: the forwarder must\n    ///      be a contract, and every workflow identity field must be nonzero. Only the workflow id\n    ///      remains governance-rotatable because CRE workflow revisions can change it while the\n    ///      forwarder, workflow name, and workflow owner continue to identify the same source.\n    constructor(\n        address initialAuthority,\n        INAVOracle oracle_,\n        address forwarder_,\n        bytes32 expectedWorkflowId_,\n        bytes10 expectedWorkflowName_,\n        address expectedWorkflowOwner_\n    ) AccessManaged(initialAuthority) {\n        if (initialAuthority == address(0) || address(oracle_) == address(0)) revert ZeroAddress();\n        if (forwarder_ == address(0)) revert ZeroAddress();\n        if (forwarder_.code.length == 0) revert NotAContract(forwarder_);\n        if (\n            expectedWorkflowId_ == bytes32(0) || expectedWorkflowName_ == bytes10(0)\n                || expectedWorkflowOwner_ == address(0)\n        ) revert ZeroWorkflowConfig();\n        oracle = oracle_;\n        feedId = oracle_.feedId();\n        forwarder = forwarder_;\n        expectedWorkflowId = expectedWorkflowId_;\n        expectedWorkflowName = expectedWorkflowName_;\n        expectedWorkflowOwner = expectedWorkflowOwner_;\n    }\n\n    /// @inheritdoc IReceiver\n    /// @dev Authenticate → decode → bind → submit. This function changes no provider state, and the\n    ///      external oracle call occurs after every caller, metadata, and report check.\n    function onReport(bytes calldata metadata, bytes calldata report) external {\n        if (msg.sender != forwarder) revert UnauthorizedForwarder(msg.sender);\n\n        (bytes32 workflowId, bytes10 name, address owner) = _decodeMetadata(metadata);\n        if (workflowId != expectedWorkflowId) revert UnauthorizedWorkflowId(workflowId);\n        if (name != expectedWorkflowName) revert UnauthorizedWorkflowName(name);\n        if (owner != expectedWorkflowOwner) revert UnauthorizedWorkflowOwner(owner);\n\n        // Strict shape: abi.encode(chainId, receiver, feedId, nav, observationTimestamp).\n        // Exact length is the format boundary: any different report shape fails closed. Supporting\n        // another shape requires an explicit provider or workflow version change.\n        if (report.length != 160) revert InvalidReport();\n        (\n            uint256 reportChainId,\n            address reportReceiver,\n            bytes32 reportFeedId,\n            uint256 navValue,\n            uint256 observationTimestamp\n        ) = abi.decode(report, (uint256, address, bytes32, uint256, uint256));\n        // Bind the signed payload to this receiver. Keystone authenticates rawReport while the\n        // receiver is supplied separately to the forwarder, so chain + feed alone do not prevent\n        // the same signed report from being routed to another deployment of this provider.\n        if (reportReceiver != address(this)) revert WrongReceiver(reportReceiver);\n        // Bind the report to this chain. The core discards a same-chain replay whose observation\n        // timestamp is no newer than the last accepted observation.\n        if (reportChainId != block.chainid) revert WrongChain(reportChainId);\n        if (reportFeedId != feedId) revert UnexpectedFeedId(reportFeedId);\n\n        // Ignore the returned status so every non-reverting core outcome is acknowledged. Core\n        // reverts propagate, and the core emits the outcome event.\n        oracle.submitReport(navValue, observationTimestamp);\n    }\n\n    /// @dev Zero is rejected so a workflow-id rotation cannot disable delivery.\n    function setExpectedWorkflowId(bytes32 newExpectedWorkflowId) external restricted {\n        if (newExpectedWorkflowId == bytes32(0)) revert ZeroWorkflowConfig();\n        emit ExpectedWorkflowIdUpdated(expectedWorkflowId, newExpectedWorkflowId);\n        expectedWorkflowId = newExpectedWorkflowId;\n    }\n\n    // ----- ERC-165 -----\n    /// @inheritdoc IERC165\n    /// @dev The KeystoneForwarder checks the receiver advertises {IReceiver} support.\n    function supportsInterface(bytes4 interfaceId) external pure returns (bool) {\n        return\n            interfaceId == type(IReceiver).interfaceId || interfaceId == type(IERC165).interfaceId;\n    }\n\n    /// @dev Reads workflow id from [0,32), name from [32,42), and owner from [42,62).\n    ///      Metadata must be at least 64 bytes; bytes after the owner are ignored.\n    function _decodeMetadata(bytes calldata metadata)\n        private\n        pure\n        returns (bytes32 workflowId, bytes10 name, address owner)\n    {\n        if (metadata.length < 64) revert InvalidMetadata();\n        workflowId = bytes32(metadata[0:32]);\n        name = bytes10(metadata[32:42]);\n        owner = address(bytes20(metadata[42:62]));\n    }\n}\n","creation_status":"success","file_path":"../vendor/smart-contracts-oracle/src/nav/providers/CREReportProvider.sol"}