Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: ISC
pragma solidity ^0.8.19;

// ====================================================================
// |     ______                   _______                             |
// |    / _____________ __  __   / ____(_____  ____ _____  ________   |
// |   / /_  / ___/ __ `| |/_/  / /_  / / __ \/ __ `/ __ \/ ___/ _ \  |
// |  / __/ / /  / /_/ _>  <   / __/ / / / / / /_/ / / / / /__/  __/  |
// | /_/   /_/   \__,_/_/|_|  /_/   /_/_/ /_/\__,_/_/ /_/\___/\___/   |
// |                                                                  |
// ====================================================================
// ======================== MerkleProofSUSDe ==========================
// ====================================================================
// Frax Finance: https://github.com/FraxFinance

// ====================================================================
import { ERC165Storage } from "src/contracts/utils/ERC165Storage.sol";
import { Timelock2Step } from "frax-std/access-control/v1/Timelock2Step.sol";
import { ITimelock2Step } from "frax-std/access-control/v1/interfaces/ITimelock2Step.sol";
import { MerkleTreeProver } from "./lib/MerkleTreeProver.sol";
import { StateProofVerifier as Verifier } from "./lib/StateProofVerifier.sol";
import { IERC4626Receiver } from "src/contracts/interfaces/IERC4626Receiver.sol";
import { IStateRootOracle } from "./interfaces/IStateRootOracle.sol";
import { FixedPointMathLib } from "@solmate/utils/FixedPointMathLib.sol";

/// @title MerkleProofPriceSource
/// @notice Proves price round data from an L1 price source and pushes the price data to an L2 Oracle
contract MerkleProofPriceSourceSUSDe is ERC165Storage, Timelock2Step {
    /// @notice The address of the StateRootOracle on Layer 2
    IStateRootOracle public immutable STATE_ROOT_ORACLE;
    address constant UNDERLYING_L1 = 0x4c9EDD5852cd905f086C759E8383e09bff1E68B3;
    /**
     * @notice Equivalent to:
     * bytes32 slot = keccak256(
     *      abi.encodePacked(
     *          uint256(uint160(0x9D39A5DE30e57443BfF2A8307A4256c8797A3497)),
     *          uint256(2)
     *      )
     * )
     */
    bytes32 constant BALANCE_SLOT = 0x396a2330c3e96731d20b554a4cd7844bd51ef95f0419f3cf9913a09b68863984;

    using FixedPointMathLib for uint256;

    struct OracleConfig {
        address layer1Oracle;
        uint96 lastBlockProofed;
    }

    struct SUSDeProof {
        bytes[] _accountProofSUSDe;
        bytes[] _storageProofTS;
        bytes[] _storageProofLastDist;
        bytes[] _storageProofVestingAmount;
        bytes[] _accountProofUSDe;
        bytes[] _storageProofUSDeBalance;
    }

    /// @notice Configuration linking Frax Oracles for the same asset on L1 / L2
    mapping(address layer2FraxOracle => OracleConfig layer1Config) public oracleLookup;

    /// @notice The ```constructor``` function
    /// @param _stateRootOracle Address of the L2 StateRootOracle
    /// @param _timelockAddress Address of Timelock contract on L2
    constructor(address _stateRootOracle, address _timelockAddress) Timelock2Step() {
        _setTimelock({ _newTimelock: _timelockAddress });
        _registerInterface({ interfaceId: type(ITimelock2Step).interfaceId });

        STATE_ROOT_ORACLE = IStateRootOracle(_stateRootOracle);
    }

    // ====================================================================
    // Events
    // ====================================================================

    /// @notice The ```OraclePairAdded``` event is emitted when a new Frax Oracle pair is added
    /// @param fraxOracleLayer1 The address of the layer 1 Frax Oracle
    /// @param fraxOracleLayer2 The address of the layer 2 Frax Oracle
    event OraclePairAdded(address indexed fraxOracleLayer1, address indexed fraxOracleLayer2);

    // ====================================================================
    // Configuration Setters
    // ====================================================================

    /// @dev A pair of addresses that are the Frax Oracles for the same asset on layer 1 and layer 2
    struct OraclePair {
        address layer1FraxOracle;
        address layer2FraxOracle;
    }

    /// @notice The ```addOraclePairs``` function sets an L1/L2 pair if they haven't been set already
    /// @param _oraclePairs List of OraclePairs representing the same oracle on L1 and L2
    function addOraclePairs(OraclePair[] calldata _oraclePairs) external {
        _requireTimelock();

        for (uint256 i = 0; i < _oraclePairs.length; ++i) {
            OraclePair memory _oraclePair = _oraclePairs[i];
            if (oracleLookup[_oraclePair.layer2FraxOracle].layer1Oracle != address(0)) {
                revert OraclePairAlreadySet({
                    fraxOracleLayer1: oracleLookup[_oraclePair.layer2FraxOracle].layer1Oracle,
                    fraxOracleLayer2: _oraclePair.layer2FraxOracle
                });
            }
            oracleLookup[_oraclePair.layer2FraxOracle].layer1Oracle = _oraclePair.layer1FraxOracle;
            emit OraclePairAdded({
                fraxOracleLayer1: _oraclePair.layer1FraxOracle,
                fraxOracleLayer2: _oraclePair.layer2FraxOracle
            });
        }
    }

    // ====================================================================
    // Proof / Add Price Function
    // ====================================================================

    function _fetchAndProofSUSDe(
        address _sUSDeAddress,
        uint96 _blockNumber,
        SUSDeProof calldata proof
    )
        internal
        view
        returns (
            uint256 totalSupply,
            uint256 totalAssetsBalance,
            uint256 lastDistributionTimestamp,
            uint256 vestingAmount
        )
    {
        IStateRootOracle.BlockInfo memory _blockInfo = STATE_ROOT_ORACLE.getBlockInfo(_blockNumber);
        Verifier.Account memory accountProofSUSDe = MerkleTreeProver.proveStorageRoot({
            stateRootHash: _blockInfo.stateRootHash,
            proofAddress: _sUSDeAddress,
            accountProof: proof._accountProofSUSDe
        });
        totalSupply = uint256(
            MerkleTreeProver
                .proveStorageSlotValue({
                    storageRootHash: accountProofSUSDe.storageRoot,
                    slot: bytes32(uint256(6)),
                    storageProof: proof._storageProofTS
                })
                .value
        );
        lastDistributionTimestamp = uint256(
            MerkleTreeProver
                .proveStorageSlotValue({
                    storageRootHash: accountProofSUSDe.storageRoot,
                    slot: bytes32(uint256(14)),
                    storageProof: proof._storageProofLastDist
                })
                .value
        );
        vestingAmount = uint256(
            MerkleTreeProver
                .proveStorageSlotValue({
                    storageRootHash: accountProofSUSDe.storageRoot,
                    slot: bytes32(uint256(13)),
                    storageProof: proof._storageProofVestingAmount
                })
                .value
        );
        {
            Verifier.Account memory accountProofUSDe = MerkleTreeProver.proveStorageRoot({
                stateRootHash: _blockInfo.stateRootHash,
                proofAddress: UNDERLYING_L1,
                accountProof: proof._accountProofUSDe
            });
            totalAssetsBalance = uint256(
                MerkleTreeProver
                    .proveStorageSlotValue({
                        storageRootHash: accountProofUSDe.storageRoot,
                        slot: BALANCE_SLOT,
                        storageProof: proof._storageProofUSDeBalance
                    })
                    .value
            );
        }
        if (vestingAmount == 0) revert MustBeGtZero();
        if (totalAssetsBalance == 0) revert MustBeGtZero();
        if (lastDistributionTimestamp == 0) revert MustBeGtZero();
        if (totalSupply == 0) revert MustBeGtZero();
    }

    function addRoundDataSUSDe(
        IERC4626Receiver _sUSDeAddress,
        uint96 _blockNumber,
        SUSDeProof calldata proof
    ) external {
        uint96 lastBlockProofed = oracleLookup[address(_sUSDeAddress)].lastBlockProofed;
        if (lastBlockProofed != 0) {
            if (_blockNumber < lastBlockProofed) revert StalePush();
        }
        // Address of the L1 oracle
        address _proofAddress = oracleLookup[address(_sUSDeAddress)].layer1Oracle;
        if (_proofAddress == address(0)) revert WrongOracleAddress();
        (
            uint256 totalSupply,
            uint256 totalAssetsBalance,
            uint256 lastDistributionTimestamp,
            uint256 vestingAmount
        ) = _fetchAndProofSUSDe(_proofAddress, _blockNumber, proof);
        _sUSDeAddress.updateSUSDeVaultData(
            _blockNumber,
            totalSupply,
            totalAssetsBalance,
            vestingAmount,
            lastDistributionTimestamp
        );
        oracleLookup[address(_sUSDeAddress)].lastBlockProofed = _blockNumber;
    }

    // ====================================================================
    // Errors
    // ====================================================================

    error OraclePairAlreadySet(address fraxOracleLayer1, address fraxOracleLayer2);
    error WrongOracleAddress();
    error StalePush();
    error MustBeGtZero();
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165Storage.sol)
pragma solidity ^0.8.0;

import { ERC165 } from "@openzeppelin/contracts/utils/introspection/ERC165.sol";

/**
 * @dev Storage based implementation of the {IERC165} interface.
 *
 * Contracts may inherit from this and call {_registerInterface} to declare
 * their support of an interface.
 */
abstract contract ERC165Storage is ERC165 {
    /**
     * @dev Mapping of interface ids to whether or not it's supported.
     */
    mapping(bytes4 => bool) private _supportedInterfaces;

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return super.supportsInterface(interfaceId) || _supportedInterfaces[interfaceId];
    }

    /**
     * @dev Registers the contract as an implementer of the interface defined by
     * `interfaceId`. Support of the actual ERC165 interface is automatic and
     * registering its interface id is not required.
     *
     * See {IERC165-supportsInterface}.
     *
     * Requirements:
     *
     * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`).
     */
    function _registerInterface(bytes4 interfaceId) internal virtual {
        require(interfaceId != 0xffffffff, "ERC165: invalid interface id");
        _supportedInterfaces[interfaceId] = true;
    }
}

// SPDX-License-Identifier: ISC
pragma solidity >=0.8.0;

// ====================================================================
// |     ______                   _______                             |
// |    / _____________ __  __   / ____(_____  ____ _____  ________   |
// |   / /_  / ___/ __ `| |/_/  / /_  / / __ \/ __ `/ __ \/ ___/ _ \  |
// |  / __/ / /  / /_/ _>  <   / __/ / / / / / /_/ / / / / /__/  __/  |
// | /_/   /_/   \__,_/_/|_|  /_/   /_/_/ /_/\__,_/_/ /_/\___/\___/   |
// |                                                                  |
// ====================================================================
// ========================== Timelock2Step ===========================
// ====================================================================
// Frax Finance: https://github.com/FraxFinance

// Primary Author
// Drake Evans: https://github.com/DrakeEvans

// Reviewers
// Dennis: https://github.com/denett

// ====================================================================

/// @title Timelock2Step
/// @author Drake Evans (Frax Finance) https://github.com/drakeevans
/// @dev Inspired by the OpenZeppelin's Ownable2Step contract
/// @notice  An abstract contract which contains 2-step transfer and renounce logic for a timelock address
abstract contract Timelock2Step {
    /// @notice The pending timelock address
    address public pendingTimelockAddress;

    /// @notice The current timelock address
    address public timelockAddress;

    constructor() {
        timelockAddress = msg.sender;
    }

    /// @notice Emitted when timelock is transferred
    error OnlyTimelock();

    /// @notice Emitted when pending timelock is transferred
    error OnlyPendingTimelock();

    /// @notice The ```TimelockTransferStarted``` event is emitted when the timelock transfer is initiated
    /// @param previousTimelock The address of the previous timelock
    /// @param newTimelock The address of the new timelock
    event TimelockTransferStarted(address indexed previousTimelock, address indexed newTimelock);

    /// @notice The ```TimelockTransferred``` event is emitted when the timelock transfer is completed
    /// @param previousTimelock The address of the previous timelock
    /// @param newTimelock The address of the new timelock
    event TimelockTransferred(address indexed previousTimelock, address indexed newTimelock);

    /// @notice The ```_isSenderTimelock``` function checks if msg.sender is current timelock address
    /// @return Whether or not msg.sender is current timelock address
    function _isSenderTimelock() internal view returns (bool) {
        return msg.sender == timelockAddress;
    }

    /// @notice The ```_requireTimelock``` function reverts if msg.sender is not current timelock address
    function _requireTimelock() internal view {
        if (msg.sender != timelockAddress) revert OnlyTimelock();
    }

    /// @notice The ```_isSenderPendingTimelock``` function checks if msg.sender is pending timelock address
    /// @return Whether or not msg.sender is pending timelock address
    function _isSenderPendingTimelock() internal view returns (bool) {
        return msg.sender == pendingTimelockAddress;
    }

    /// @notice The ```_requirePendingTimelock``` function reverts if msg.sender is not pending timelock address
    function _requirePendingTimelock() internal view {
        if (msg.sender != pendingTimelockAddress) revert OnlyPendingTimelock();
    }

    /// @notice The ```_transferTimelock``` function initiates the timelock transfer
    /// @dev This function is to be implemented by a public function
    /// @param _newTimelock The address of the nominated (pending) timelock
    function _transferTimelock(address _newTimelock) internal {
        pendingTimelockAddress = _newTimelock;
        emit TimelockTransferStarted(timelockAddress, _newTimelock);
    }

    /// @notice The ```_acceptTransferTimelock``` function completes the timelock transfer
    /// @dev This function is to be implemented by a public function
    function _acceptTransferTimelock() internal {
        pendingTimelockAddress = address(0);
        _setTimelock(msg.sender);
    }

    /// @notice The ```_setTimelock``` function sets the timelock address
    /// @dev This function is to be implemented by a public function
    /// @param _newTimelock The address of the new timelock
    function _setTimelock(address _newTimelock) internal {
        emit TimelockTransferred(timelockAddress, _newTimelock);
        timelockAddress = _newTimelock;
    }

    /// @notice The ```transferTimelock``` function initiates the timelock transfer
    /// @dev Must be called by the current timelock
    /// @param _newTimelock The address of the nominated (pending) timelock
    function transferTimelock(address _newTimelock) external virtual {
        _requireTimelock();
        _transferTimelock(_newTimelock);
    }

    /// @notice The ```acceptTransferTimelock``` function completes the timelock transfer
    /// @dev Must be called by the pending timelock
    function acceptTransferTimelock() external virtual {
        _requirePendingTimelock();
        _acceptTransferTimelock();
    }

    /// @notice The ```renounceTimelock``` function renounces the timelock after setting pending timelock to current timelock
    /// @dev Pending timelock must be set to current timelock before renouncing, creating a 2-step renounce process
    function renounceTimelock() external virtual {
        _requireTimelock();
        _requirePendingTimelock();
        _transferTimelock(address(0));
        _setTimelock(address(0));
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity >=0.8.0;

interface ITimelock2Step {
    event TimelockTransferStarted(address indexed previousTimelock, address indexed newTimelock);
    event TimelockTransferred(address indexed previousTimelock, address indexed newTimelock);

    function acceptTransferTimelock() external;

    function pendingTimelockAddress() external view returns (address);

    function renounceTimelock() external;

    function timelockAddress() external view returns (address);

    function transferTimelock(address _newTimelock) external;
}

//SPDX-License-Identifier: ISC
pragma solidity ^0.8.20;

// ====================================================================
// |     ______                   _______                             |
// |    / _____________ __  __   / ____(_____  ____ _____  ________   |
// |   / /_  / ___/ __ `| |/_/  / /_  / / __ \/ __ `/ __ \/ ___/ _ \  |
// |  / __/ / /  / /_/ _>  <   / __/ / / / / / /_/ / / / / /__/  __/  |
// | /_/   /_/   \__,_/_/|_|  /_/   /_/_/ /_/\__,_/_/ /_/\___/\___/   |
// |                                                                  |
// ====================================================================
// ========================= MerkleTreeProver =========================
// ====================================================================
// Frax Finance: https://github.com/FraxFinance

// Authors
// Jon Walch: https://github.com/jonwalch
// Dennis: https://github.com/denett

// Reviewers
// Drake Evans: https://github.com/DrakeEvans

// ====================================================================
import { RLPReader } from "rlp/RLPReader.sol";
import { StateProofVerifier as Verifier } from "./StateProofVerifier.sol";

/// @title MerkleTreeProver
/// @author Jon Walch (Frax Finance) https://github.com/jonwalch
/// @notice Helper function library for interacting with StateProofVerifier and RLPReader
library MerkleTreeProver {
    using RLPReader for bytes;
    using RLPReader for RLPReader.RLPItem;

    /// @notice The ```proveStorageRoot``` function is a helper function for StateProofVerifier.extractAccountFromProof()
    /// @param stateRootHash The hash of the state root
    /// @param proofAddress The address of the contract we're proving
    /// @param accountProof The accountProof retrieved from eth_getProof
    function proveStorageRoot(
        bytes32 stateRootHash,
        address proofAddress,
        bytes[] memory accountProof
    ) internal view returns (Verifier.Account memory accountPool) {
        RLPReader.RLPItem[] memory accountProofRlp = new RLPReader.RLPItem[](accountProof.length);
        for (uint256 i = 0; i < accountProof.length; ++i) {
            accountProofRlp[i] = accountProof[i].toRlpItem();
        }
        accountPool = Verifier.extractAccountFromProof({
            _addressHash: keccak256(abi.encodePacked(proofAddress)),
            _stateRootHash: stateRootHash,
            _proof: accountProofRlp
        });
    }

    /// @notice The ```proveStorageSlotValue``` function is a helper function for StateProofVerifier.extractSlotValueFromProof()
    /// @param storageRootHash The hash of the storage root
    /// @param slot The slot we want to prove for the contract
    /// @param storageProof The storageProof.proof retrieved from eth_getProof
    function proveStorageSlotValue(
        bytes32 storageRootHash,
        bytes32 slot,
        bytes[] memory storageProof
    ) internal view returns (Verifier.SlotValue memory slotValue) {
        RLPReader.RLPItem[] memory storageProofRlp = new RLPReader.RLPItem[](storageProof.length);
        for (uint256 i = 0; i < storageProof.length; ++i) {
            storageProofRlp[i] = storageProof[i].toRlpItem();
        }
        slotValue = Verifier.extractSlotValueFromProof({
            _slotHash: keccak256(abi.encodePacked(slot)),
            _storageRootHash: storageRootHash,
            _proof: storageProofRlp
        });
    }
}

// SPDX-License-Identifier: MIT
// Copied from https://github.com/lidofinance/curve-merkle-oracle/blob/1033b3e84142317ffd8f366b52e489d5eb49c73f/contracts/StateProofVerifier.sol
pragma solidity ^0.8.20;

import { RLPReader } from "rlp/RLPReader.sol";
import { MerklePatriciaProofVerifier } from "./MerklePatriciaProofVerifier.sol";

/**
 * @title A helper library for verification of Merkle Patricia account and state proofs.
 */
library StateProofVerifier {
    using RLPReader for RLPReader.RLPItem;
    using RLPReader for bytes;

    uint256 constant HEADER_STATE_ROOT_INDEX = 3;
    uint256 constant HEADER_NUMBER_INDEX = 8;
    uint256 constant HEADER_TIMESTAMP_INDEX = 11;

    struct BlockHeader {
        bytes32 hash;
        bytes32 stateRootHash;
        uint256 number;
        uint256 timestamp;
    }

    struct Account {
        bool exists;
        uint256 nonce;
        uint256 balance;
        bytes32 storageRoot;
        bytes32 codeHash;
    }

    struct SlotValue {
        bool exists;
        uint256 value;
    }

    /**
     * @notice Parses block header and verifies its presence onchain within the latest 256 blocks.
     * @param _headerRlpBytes RLP-encoded block header.
     */
    function verifyBlockHeader(bytes memory _headerRlpBytes) internal view returns (BlockHeader memory) {
        BlockHeader memory header = parseBlockHeader(_headerRlpBytes);
        // ensure that the block is actually in the blockchain
        require(header.hash == blockhash(header.number), "blockhash mismatch");
        return header;
    }

    /**
     * @notice Parses RLP-encoded block header.
     * @param _headerRlpBytes RLP-encoded block header.
     */
    function parseBlockHeader(bytes memory _headerRlpBytes) internal pure returns (BlockHeader memory) {
        BlockHeader memory result;
        RLPReader.RLPItem[] memory headerFields = _headerRlpBytes.toRlpItem().toList();

        require(headerFields.length > HEADER_TIMESTAMP_INDEX);

        result.stateRootHash = bytes32(headerFields[HEADER_STATE_ROOT_INDEX].toUint());
        result.number = headerFields[HEADER_NUMBER_INDEX].toUint();
        result.timestamp = headerFields[HEADER_TIMESTAMP_INDEX].toUint();
        result.hash = keccak256(_headerRlpBytes);

        return result;
    }

    /**
     * @notice Verifies Merkle Patricia proof of an account and extracts the account fields.
     *
     * @param _addressHash Keccak256 hash of the address corresponding to the account.
     * @param _stateRootHash MPT root hash of the Ethereum state trie.
     */
    function extractAccountFromProof(
        bytes32 _addressHash, // keccak256(abi.encodePacked(address))
        bytes32 _stateRootHash,
        RLPReader.RLPItem[] memory _proof
    ) internal pure returns (Account memory) {
        bytes memory acctRlpBytes = MerklePatriciaProofVerifier.extractProofValue(
            _stateRootHash,
            abi.encodePacked(_addressHash),
            _proof
        );

        Account memory account;

        if (acctRlpBytes.length == 0) {
            return account;
        }

        RLPReader.RLPItem[] memory acctFields = acctRlpBytes.toRlpItem().toList();
        require(acctFields.length == 4);

        account.exists = true;
        account.nonce = acctFields[0].toUint();
        account.balance = acctFields[1].toUint();
        account.storageRoot = bytes32(acctFields[2].toUint());
        account.codeHash = bytes32(acctFields[3].toUint());

        return account;
    }

    /**
     * @notice Verifies Merkle Patricia proof of a slot and extracts the slot's value.
     *
     * @param _slotHash Keccak256 hash of the slot position.
     * @param _storageRootHash MPT root hash of the account's storage trie.
     */
    function extractSlotValueFromProof(
        bytes32 _slotHash,
        bytes32 _storageRootHash,
        RLPReader.RLPItem[] memory _proof
    ) internal pure returns (SlotValue memory) {
        bytes memory valueRlpBytes = MerklePatriciaProofVerifier.extractProofValue(
            _storageRootHash,
            abi.encodePacked(_slotHash),
            _proof
        );

        SlotValue memory value;

        if (valueRlpBytes.length != 0) {
            value.exists = true;
            value.value = valueRlpBytes.toRlpItem().toUint();
        }

        return value;
    }
}

// SPDX-License-Identifier: ISC
pragma solidity ^0.8.19;

interface IERC4626Receiver {
    function updateErc4262VaultData(
        uint96 _l1BlockNumber,
        uint256 _totalSupply,
        uint256 _totalAssets,
        uint192 _lastRewardsAmount,
        uint32 _lastSync,
        uint32 _rewardsCycleEnd
    ) external;

    function updateErc4262VaultData(
        uint256 _totalSupply,
        uint256 _totalAssets,
        uint192 _lastRewardsAmount,
        uint32 _lastSync,
        uint32 _rewardsCycleEnd
    ) external;

    /// @notice Information about the current rewards cycle
    struct RewardsCycleData {
        uint40 cycleEnd; // Timestamp of the end of the current rewards cycle
        uint40 lastSync; // Timestamp of the last time the rewards cycle was synced
        uint216 rewardCycleAmount; // Amount of rewards to be distributed in the current cycle
    }

    function updatesFRAXData(
        uint96 _l1BlockNumber,
        uint256 _totalSupply,
        uint256 _totalAssets,
        uint256 _lastDistributionAmount,
        RewardsCycleData memory data
    ) external;

    function updateMaxDistributionPerSecond(uint96 _l1BlockNumber, uint256 maxPerSecond) external;
    function updateDaiVaultData(uint96 _l1BlockNumber, uint256 _dsr, uint256 _rho, uint256 _chi) external;

    function getPrices() external view returns (bool, uint256, uint256);

    function dsr() external view returns (uint256);
    function chi() external view returns (uint256);
    function rho() external view returns (uint256);

    function updateSUSDeVaultData(
        uint96 _l1BlockNumber,
        uint256 _totalSupply,
        uint256 _totalAssets,
        uint256 _vestingAmount,
        uint256 _lastDistributionTimestamp
    ) external;

    function updateEzEthRateData(uint96 _l1BlockNumber, uint256 _l1Timestamp, uint256 _ezEthRate) external;

    function updateFpiOracleData(
        uint96 _l1BlockNumber,
        uint256 _rampPeriod,
        uint256 _lastUpdateTime,
        uint256 _pegPriceTarget,
        uint256 _pegpriceLast
    ) external;

    function updateRsEthOracle(uint96 _l1blockNumber, uint256 _l1Timestamp, uint256 _rsEthPrice) external;

    function pricePerShare() external view returns (uint256);

    function updateWstEthRateData(uint96 _l1BlockNumber, uint256 _l1Timestamp, uint256 _wstEthRate) external;
}

// SPDX-License-Identifier: ISC
pragma solidity ^0.8.20;

interface IStateRootOracle {
    struct BlockInfo {
        bytes32 stateRootHash;
        uint40 timestamp;
    }

    function getBlockInfo(uint256 blockNumber) external view returns (BlockInfo memory _blockInfo);
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;

/// @notice Arithmetic library with operations for fixed-point numbers.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/utils/FixedPointMathLib.sol)
/// @author Inspired by USM (https://github.com/usmfum/USM/blob/master/contracts/WadMath.sol)
library FixedPointMathLib {
    /*//////////////////////////////////////////////////////////////
                    SIMPLIFIED FIXED POINT OPERATIONS
    //////////////////////////////////////////////////////////////*/

    uint256 internal constant WAD = 1e18; // The scalar of ETH and most ERC20s.

    function mulWadDown(uint256 x, uint256 y) internal pure returns (uint256) {
        return mulDivDown(x, y, WAD); // Equivalent to (x * y) / WAD rounded down.
    }

    function mulWadUp(uint256 x, uint256 y) internal pure returns (uint256) {
        return mulDivUp(x, y, WAD); // Equivalent to (x * y) / WAD rounded up.
    }

    function divWadDown(uint256 x, uint256 y) internal pure returns (uint256) {
        return mulDivDown(x, WAD, y); // Equivalent to (x * WAD) / y rounded down.
    }

    function divWadUp(uint256 x, uint256 y) internal pure returns (uint256) {
        return mulDivUp(x, WAD, y); // Equivalent to (x * WAD) / y rounded up.
    }

    /*//////////////////////////////////////////////////////////////
                    LOW LEVEL FIXED POINT OPERATIONS
    //////////////////////////////////////////////////////////////*/

    function mulDivDown(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 z) {
        assembly {
            // Store x * y in z for now.
            z := mul(x, y)

            // Equivalent to require(denominator != 0 && (x == 0 || (x * y) / x == y))
            if iszero(and(iszero(iszero(denominator)), or(iszero(x), eq(div(z, x), y)))) {
                revert(0, 0)
            }

            // Divide z by the denominator.
            z := div(z, denominator)
        }
    }

    function mulDivUp(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 z) {
        assembly {
            // Store x * y in z for now.
            z := mul(x, y)

            // Equivalent to require(denominator != 0 && (x == 0 || (x * y) / x == y))
            if iszero(and(iszero(iszero(denominator)), or(iszero(x), eq(div(z, x), y)))) {
                revert(0, 0)
            }

            // First, divide z - 1 by the denominator and add 1.
            // We allow z - 1 to underflow if z is 0, because we multiply the
            // end result by 0 if z is zero, ensuring we return 0 if z is zero.
            z := mul(iszero(iszero(z)), add(div(sub(z, 1), denominator), 1))
        }
    }

    function rpow(
        uint256 x,
        uint256 n,
        uint256 scalar
    ) internal pure returns (uint256 z) {
        assembly {
            switch x
            case 0 {
                switch n
                case 0 {
                    // 0 ** 0 = 1
                    z := scalar
                }
                default {
                    // 0 ** n = 0
                    z := 0
                }
            }
            default {
                switch mod(n, 2)
                case 0 {
                    // If n is even, store scalar in z for now.
                    z := scalar
                }
                default {
                    // If n is odd, store x in z for now.
                    z := x
                }

                // Shifting right by 1 is like dividing by 2.
                let half := shr(1, scalar)

                for {
                    // Shift n right by 1 before looping to halve it.
                    n := shr(1, n)
                } n {
                    // Shift n right by 1 each iteration to halve it.
                    n := shr(1, n)
                } {
                    // Revert immediately if x ** 2 would overflow.
                    // Equivalent to iszero(eq(div(xx, x), x)) here.
                    if shr(128, x) {
                        revert(0, 0)
                    }

                    // Store x squared.
                    let xx := mul(x, x)

                    // Round to the nearest number.
                    let xxRound := add(xx, half)

                    // Revert if xx + half overflowed.
                    if lt(xxRound, xx) {
                        revert(0, 0)
                    }

                    // Set x to scaled xxRound.
                    x := div(xxRound, scalar)

                    // If n is even:
                    if mod(n, 2) {
                        // Compute z * x.
                        let zx := mul(z, x)

                        // If z * x overflowed:
                        if iszero(eq(div(zx, x), z)) {
                            // Revert if x is non-zero.
                            if iszero(iszero(x)) {
                                revert(0, 0)
                            }
                        }

                        // Round to the nearest number.
                        let zxRound := add(zx, half)

                        // Revert if zx + half overflowed.
                        if lt(zxRound, zx) {
                            revert(0, 0)
                        }

                        // Return properly scaled zxRound.
                        z := div(zxRound, scalar)
                    }
                }
            }
        }
    }

    /*//////////////////////////////////////////////////////////////
                        GENERAL NUMBER UTILITIES
    //////////////////////////////////////////////////////////////*/

    function sqrt(uint256 x) internal pure returns (uint256 z) {
        assembly {
            // Start off with z at 1.
            z := 1

            // Used below to help find a nearby power of 2.
            let y := x

            // Find the lowest power of 2 that is at least sqrt(x).
            if iszero(lt(y, 0x100000000000000000000000000000000)) {
                y := shr(128, y) // Like dividing by 2 ** 128.
                z := shl(64, z) // Like multiplying by 2 ** 64.
            }
            if iszero(lt(y, 0x10000000000000000)) {
                y := shr(64, y) // Like dividing by 2 ** 64.
                z := shl(32, z) // Like multiplying by 2 ** 32.
            }
            if iszero(lt(y, 0x100000000)) {
                y := shr(32, y) // Like dividing by 2 ** 32.
                z := shl(16, z) // Like multiplying by 2 ** 16.
            }
            if iszero(lt(y, 0x10000)) {
                y := shr(16, y) // Like dividing by 2 ** 16.
                z := shl(8, z) // Like multiplying by 2 ** 8.
            }
            if iszero(lt(y, 0x100)) {
                y := shr(8, y) // Like dividing by 2 ** 8.
                z := shl(4, z) // Like multiplying by 2 ** 4.
            }
            if iszero(lt(y, 0x10)) {
                y := shr(4, y) // Like dividing by 2 ** 4.
                z := shl(2, z) // Like multiplying by 2 ** 2.
            }
            if iszero(lt(y, 0x8)) {
                // Equivalent to 2 ** z.
                z := shl(1, z)
            }

            // Shifting right by 1 is like dividing by 2.
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))

            // Compute a rounded down version of z.
            let zRoundDown := div(x, z)

            // If zRoundDown is smaller, use it.
            if lt(zRoundDown, z) {
                z := zRoundDown
            }
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/ERC165.sol)

pragma solidity ^0.8.20;

import {IERC165} from "./IERC165.sol";

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC-165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// SPDX-License-Identifier: Apache-2.0

/*
 * @author Hamdi Allam [email protected]
 * Please reach out with any questions or concerns
 */
pragma solidity >=0.5.10 <0.9.0;

library RLPReader {
    uint8 constant STRING_SHORT_START = 0x80;
    uint8 constant STRING_LONG_START = 0xb8;
    uint8 constant LIST_SHORT_START = 0xc0;
    uint8 constant LIST_LONG_START = 0xf8;
    uint8 constant WORD_SIZE = 32;

    struct RLPItem {
        uint256 len;
        uint256 memPtr;
    }

    struct Iterator {
        RLPItem item; // Item that's being iterated over.
        uint256 nextPtr; // Position of the next item in the list.
    }

    /*
     * @dev Returns the next element in the iteration. Reverts if it has not next element.
     * @param self The iterator.
     * @return The next element in the iteration.
     */
    function next(Iterator memory self) internal pure returns (RLPItem memory) {
        require(hasNext(self));

        uint256 ptr = self.nextPtr;
        uint256 itemLength = _itemLength(ptr);
        self.nextPtr = ptr + itemLength;

        return RLPItem(itemLength, ptr);
    }

    /*
     * @dev Returns true if the iteration has more elements.
     * @param self The iterator.
     * @return true if the iteration has more elements.
     */
    function hasNext(Iterator memory self) internal pure returns (bool) {
        RLPItem memory item = self.item;
        return self.nextPtr < item.memPtr + item.len;
    }

    /*
     * @param item RLP encoded bytes
     */
    function toRlpItem(bytes memory item) internal pure returns (RLPItem memory) {
        uint256 memPtr;
        assembly {
            memPtr := add(item, 0x20)
        }

        return RLPItem(item.length, memPtr);
    }

    /*
     * @dev Create an iterator. Reverts if item is not a list.
     * @param self The RLP item.
     * @return An 'Iterator' over the item.
     */
    function iterator(RLPItem memory self) internal pure returns (Iterator memory) {
        require(isList(self));

        uint256 ptr = self.memPtr + _payloadOffset(self.memPtr);
        return Iterator(self, ptr);
    }

    /*
     * @param the RLP item.
     */
    function rlpLen(RLPItem memory item) internal pure returns (uint256) {
        return item.len;
    }

    /*
     * @param the RLP item.
     * @return (memPtr, len) pair: location of the item's payload in memory.
     */
    function payloadLocation(RLPItem memory item) internal pure returns (uint256, uint256) {
        uint256 offset = _payloadOffset(item.memPtr);
        uint256 memPtr = item.memPtr + offset;
        uint256 len = item.len - offset; // data length
        return (memPtr, len);
    }

    /*
     * @param the RLP item.
     */
    function payloadLen(RLPItem memory item) internal pure returns (uint256) {
        (, uint256 len) = payloadLocation(item);
        return len;
    }

    /*
     * @param the RLP item containing the encoded list.
     */
    function toList(RLPItem memory item) internal pure returns (RLPItem[] memory) {
        require(isList(item));

        uint256 items = numItems(item);
        RLPItem[] memory result = new RLPItem[](items);

        uint256 memPtr = item.memPtr + _payloadOffset(item.memPtr);
        uint256 dataLen;
        for (uint256 i = 0; i < items; i++) {
            dataLen = _itemLength(memPtr);
            result[i] = RLPItem(dataLen, memPtr);
            memPtr = memPtr + dataLen;
        }

        require(memPtr - item.memPtr == item.len);

        return result;
    }

    // @return indicator whether encoded payload is a list. negate this function call for isData.
    function isList(RLPItem memory item) internal pure returns (bool) {
        if (item.len == 0) return false;

        uint8 byte0;
        uint256 memPtr = item.memPtr;
        assembly {
            byte0 := byte(0, mload(memPtr))
        }

        if (byte0 < LIST_SHORT_START) return false;
        return true;
    }

    /*
     * @dev A cheaper version of keccak256(toRlpBytes(item)) that avoids copying memory.
     * @return keccak256 hash of RLP encoded bytes.
     */
    function rlpBytesKeccak256(RLPItem memory item) internal pure returns (bytes32) {
        uint256 ptr = item.memPtr;
        uint256 len = item.len;
        bytes32 result;
        assembly {
            result := keccak256(ptr, len)
        }
        return result;
    }

    /*
     * @dev A cheaper version of keccak256(toBytes(item)) that avoids copying memory.
     * @return keccak256 hash of the item payload.
     */
    function payloadKeccak256(RLPItem memory item) internal pure returns (bytes32) {
        (uint256 memPtr, uint256 len) = payloadLocation(item);
        bytes32 result;
        assembly {
            result := keccak256(memPtr, len)
        }
        return result;
    }

    /** RLPItem conversions into data types **/

    // @returns raw rlp encoding in bytes
    function toRlpBytes(RLPItem memory item) internal pure returns (bytes memory) {
        bytes memory result = new bytes(item.len);
        if (result.length == 0) return result;

        uint256 ptr;
        assembly {
            ptr := add(0x20, result)
        }

        copy(item.memPtr, ptr, item.len);
        return result;
    }

    // any non-zero byte except "0x80" is considered true
    function toBoolean(RLPItem memory item) internal pure returns (bool) {
        require(item.len == 1);
        uint256 result;
        uint256 memPtr = item.memPtr;
        assembly {
            result := byte(0, mload(memPtr))
        }

        // SEE Github Issue #5.
        // Summary: Most commonly used RLP libraries (i.e Geth) will encode
        // "0" as "0x80" instead of as "0". We handle this edge case explicitly
        // here.
        if (result == 0 || result == STRING_SHORT_START) {
            return false;
        } else {
            return true;
        }
    }

    function toAddress(RLPItem memory item) internal pure returns (address) {
        // 1 byte for the length prefix
        require(item.len == 21);

        return address(uint160(toUint(item)));
    }

    function toUint(RLPItem memory item) internal pure returns (uint256) {
        require(item.len > 0 && item.len <= 33);

        (uint256 memPtr, uint256 len) = payloadLocation(item);

        uint256 result;
        assembly {
            result := mload(memPtr)

            // shift to the correct location if neccesary
            if lt(len, 32) {
                result := div(result, exp(256, sub(32, len)))
            }
        }

        return result;
    }

    // enforces 32 byte length
    function toUintStrict(RLPItem memory item) internal pure returns (uint256) {
        // one byte prefix
        require(item.len == 33);

        uint256 result;
        uint256 memPtr = item.memPtr + 1;
        assembly {
            result := mload(memPtr)
        }

        return result;
    }

    function toBytes(RLPItem memory item) internal pure returns (bytes memory) {
        require(item.len > 0);

        (uint256 memPtr, uint256 len) = payloadLocation(item);
        bytes memory result = new bytes(len);

        uint256 destPtr;
        assembly {
            destPtr := add(0x20, result)
        }

        copy(memPtr, destPtr, len);
        return result;
    }

    /*
     * Private Helpers
     */

    // @return number of payload items inside an encoded list.
    function numItems(RLPItem memory item) private pure returns (uint256) {
        if (item.len == 0) return 0;

        uint256 count = 0;
        uint256 currPtr = item.memPtr + _payloadOffset(item.memPtr);
        uint256 endPtr = item.memPtr + item.len;
        while (currPtr < endPtr) {
            currPtr = currPtr + _itemLength(currPtr); // skip over an item
            count++;
        }

        return count;
    }

    // @return entire rlp item byte length
    function _itemLength(uint256 memPtr) private pure returns (uint256) {
        uint256 itemLen;
        uint256 byte0;
        assembly {
            byte0 := byte(0, mload(memPtr))
        }

        if (byte0 < STRING_SHORT_START) {
            itemLen = 1;
        } else if (byte0 < STRING_LONG_START) {
            itemLen = byte0 - STRING_SHORT_START + 1;
        } else if (byte0 < LIST_SHORT_START) {
            assembly {
                let byteLen := sub(byte0, 0xb7) // # of bytes the actual length is
                memPtr := add(memPtr, 1) // skip over the first byte

                /* 32 byte word size */
                let dataLen := div(mload(memPtr), exp(256, sub(32, byteLen))) // right shifting to get the len
                itemLen := add(dataLen, add(byteLen, 1))
            }
        } else if (byte0 < LIST_LONG_START) {
            itemLen = byte0 - LIST_SHORT_START + 1;
        } else {
            assembly {
                let byteLen := sub(byte0, 0xf7)
                memPtr := add(memPtr, 1)

                let dataLen := div(mload(memPtr), exp(256, sub(32, byteLen))) // right shifting to the correct length
                itemLen := add(dataLen, add(byteLen, 1))
            }
        }

        return itemLen;
    }

    // @return number of bytes until the data
    function _payloadOffset(uint256 memPtr) private pure returns (uint256) {
        uint256 byte0;
        assembly {
            byte0 := byte(0, mload(memPtr))
        }

        if (byte0 < STRING_SHORT_START) {
            return 0;
        } else if (byte0 < STRING_LONG_START || (byte0 >= LIST_SHORT_START && byte0 < LIST_LONG_START)) {
            return 1;
        } else if (byte0 < LIST_SHORT_START) {
            // being explicit
            return byte0 - (STRING_LONG_START - 1) + 1;
        } else {
            return byte0 - (LIST_LONG_START - 1) + 1;
        }
    }

    /*
     * @param src Pointer to source
     * @param dest Pointer to destination
     * @param len Amount of memory to copy from the source
     */
    function copy(uint256 src, uint256 dest, uint256 len) private pure {
        if (len == 0) return;

        // copy as many word sizes as possible
        for (; len >= WORD_SIZE; len -= WORD_SIZE) {
            assembly {
                mstore(dest, mload(src))
            }

            src += WORD_SIZE;
            dest += WORD_SIZE;
        }

        if (len > 0) {
            // left over bytes. Mask is used to remove unwanted bytes from the word
            uint256 mask = 256**(WORD_SIZE - len) - 1;
            assembly {
                let srcpart := and(mload(src), not(mask)) // zero out src
                let destpart := and(mload(dest), mask) // retrieve the bytes
                mstore(dest, or(destpart, srcpart))
            }
        }
    }
}

// SPDX-License-Identifier: MIT
// Copied from https://github.com/lidofinance/curve-merkle-oracle/blob/1033b3e84142317ffd8f366b52e489d5eb49c73f/contracts/MerklePatriciaProofVerifier.sol
/**
 * Copied from https://github.com/lorenzb/proveth/blob/c74b20e/onchain/ProvethVerifier.sol
 * with minor performance and code style-related modifications.
 */
pragma solidity ^0.8.20;

import { RLPReader } from "rlp/RLPReader.sol";

library MerklePatriciaProofVerifier {
    using RLPReader for RLPReader.RLPItem;
    using RLPReader for bytes;

    /// @dev Validates a Merkle-Patricia-Trie proof.
    ///      If the proof proves the inclusion of some key-value pair in the
    ///      trie, the value is returned. Otherwise, i.e. if the proof proves
    ///      the exclusion of a key from the trie, an empty byte array is
    ///      returned.
    /// @param rootHash is the Keccak-256 hash of the root node of the MPT.
    /// @param path is the key of the node whose inclusion/exclusion we are
    ///        proving.
    /// @param stack is the stack of MPT nodes (starting with the root) that
    ///        need to be traversed during verification.
    /// @return value whose inclusion is proved or an empty byte array for
    ///         a proof of exclusion
    function extractProofValue(
        bytes32 rootHash,
        bytes memory path,
        RLPReader.RLPItem[] memory stack
    ) internal pure returns (bytes memory value) {
        bytes memory mptKey = _decodeNibbles(path, 0);
        uint256 mptKeyOffset = 0;

        bytes32 nodeHashHash;
        RLPReader.RLPItem[] memory node;

        RLPReader.RLPItem memory rlpValue;

        if (stack.length == 0) {
            // Root hash of empty Merkle-Patricia-Trie
            require(rootHash == 0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421);
            return new bytes(0);
        }

        // Traverse stack of nodes starting at root.
        for (uint256 i = 0; i < stack.length; i++) {
            // We use the fact that an rlp encoded list consists of some
            // encoding of its length plus the concatenation of its
            // *rlp-encoded* items.

            // The root node is hashed with Keccak-256 ...
            if (i == 0 && rootHash != stack[i].rlpBytesKeccak256()) {
                revert();
            }
            // ... whereas all other nodes are hashed with the MPT
            // hash function.
            if (i != 0 && nodeHashHash != _mptHashHash(stack[i])) {
                revert();
            }
            // We verified that stack[i] has the correct hash, so we
            // may safely decode it.
            node = stack[i].toList();

            if (node.length == 2) {
                // Extension or Leaf node

                bool isLeaf;
                bytes memory nodeKey;
                (isLeaf, nodeKey) = _merklePatriciaCompactDecode(node[0].toBytes());

                uint256 prefixLength = _sharedPrefixLength(mptKeyOffset, mptKey, nodeKey);
                mptKeyOffset += prefixLength;

                if (prefixLength < nodeKey.length) {
                    // Proof claims divergent extension or leaf. (Only
                    // relevant for proofs of exclusion.)
                    // An Extension/Leaf node is divergent iff it "skips" over
                    // the point at which a Branch node should have been had the
                    // excluded key been included in the trie.
                    // Example: Imagine a proof of exclusion for path [1, 4],
                    // where the current node is a Leaf node with
                    // path [1, 3, 3, 7]. For [1, 4] to be included, there
                    // should have been a Branch node at [1] with a child
                    // at 3 and a child at 4.

                    // Sanity check
                    if (i < stack.length - 1) {
                        // divergent node must come last in proof
                        revert();
                    }

                    return new bytes(0);
                }

                if (isLeaf) {
                    // Sanity check
                    if (i < stack.length - 1) {
                        // leaf node must come last in proof
                        revert();
                    }

                    if (mptKeyOffset < mptKey.length) {
                        return new bytes(0);
                    }

                    rlpValue = node[1];
                    return rlpValue.toBytes();
                } else {
                    // extension
                    // Sanity check
                    if (i == stack.length - 1) {
                        // shouldn't be at last level
                        revert();
                    }

                    if (!node[1].isList()) {
                        // rlp(child) was at least 32 bytes. node[1] contains
                        // Keccak256(rlp(child)).
                        nodeHashHash = node[1].payloadKeccak256();
                    } else {
                        // rlp(child) was less than 32 bytes. node[1] contains
                        // rlp(child).
                        nodeHashHash = node[1].rlpBytesKeccak256();
                    }
                }
            } else if (node.length == 17) {
                // Branch node

                if (mptKeyOffset != mptKey.length) {
                    // we haven't consumed the entire path, so we need to look at a child
                    uint8 nibble = uint8(mptKey[mptKeyOffset]);
                    mptKeyOffset += 1;
                    if (nibble >= 16) {
                        // each element of the path has to be a nibble
                        revert();
                    }

                    if (_isEmptyBytesequence(node[nibble])) {
                        // Sanity
                        if (i != stack.length - 1) {
                            // leaf node should be at last level
                            revert();
                        }

                        return new bytes(0);
                    } else if (!node[nibble].isList()) {
                        nodeHashHash = node[nibble].payloadKeccak256();
                    } else {
                        nodeHashHash = node[nibble].rlpBytesKeccak256();
                    }

                    if (i == stack.length - 1) {
                        // need to process the child now
                        revert();
                    }
                } else {
                    // we have consumed the entire mptKey, so we need to look at what's contained in this node.

                    // Sanity
                    if (i != stack.length - 1) {
                        // should be at last level
                        revert();
                    }

                    return node[16].toBytes();
                }
            }
        }
    }

    /// @dev Computes the hash of the Merkle-Patricia-Trie hash of the RLP item.
    ///      Merkle-Patricia-Tries use a weird "hash function" that outputs
    ///      *variable-length* hashes: If the item is shorter than 32 bytes,
    ///      the MPT hash is the item. Otherwise, the MPT hash is the
    ///      Keccak-256 hash of the item.
    ///      The easiest way to compare variable-length byte sequences is
    ///      to compare their Keccak-256 hashes.
    /// @param item The RLP item to be hashed.
    /// @return Keccak-256(MPT-hash(item))
    function _mptHashHash(RLPReader.RLPItem memory item) private pure returns (bytes32) {
        if (item.len < 32) {
            return item.rlpBytesKeccak256();
        } else {
            return keccak256(abi.encodePacked(item.rlpBytesKeccak256()));
        }
    }

    function _isEmptyBytesequence(RLPReader.RLPItem memory item) private pure returns (bool) {
        if (item.len != 1) {
            return false;
        }
        uint8 b;
        uint256 memPtr = item.memPtr;
        assembly {
            b := byte(0, mload(memPtr))
        }
        return b == 0x80; /* empty byte string */
    }

    function _merklePatriciaCompactDecode(
        bytes memory compact
    ) private pure returns (bool isLeaf, bytes memory nibbles) {
        require(compact.length > 0);
        uint256 first_nibble = (uint8(compact[0]) >> 4) & 0xF;
        uint256 skipNibbles;
        if (first_nibble == 0) {
            skipNibbles = 2;
            isLeaf = false;
        } else if (first_nibble == 1) {
            skipNibbles = 1;
            isLeaf = false;
        } else if (first_nibble == 2) {
            skipNibbles = 2;
            isLeaf = true;
        } else if (first_nibble == 3) {
            skipNibbles = 1;
            isLeaf = true;
        } else {
            // Not supposed to happen!
            revert();
        }
        return (isLeaf, _decodeNibbles(compact, skipNibbles));
    }

    function _decodeNibbles(bytes memory compact, uint256 skipNibbles) private pure returns (bytes memory nibbles) {
        require(compact.length > 0);

        uint256 length = compact.length * 2;
        require(skipNibbles <= length);
        length -= skipNibbles;

        nibbles = new bytes(length);
        uint256 nibblesLength = 0;

        for (uint256 i = skipNibbles; i < skipNibbles + length; i += 1) {
            if (i % 2 == 0) {
                nibbles[nibblesLength] = bytes1((uint8(compact[i / 2]) >> 4) & 0xF);
            } else {
                nibbles[nibblesLength] = bytes1((uint8(compact[i / 2]) >> 0) & 0xF);
            }
            nibblesLength += 1;
        }

        assert(nibblesLength == nibbles.length);
    }

    function _sharedPrefixLength(uint256 xsOffset, bytes memory xs, bytes memory ys) private pure returns (uint256) {
        uint256 i;
        for (i = 0; i + xsOffset < xs.length && i < ys.length; i++) {
            if (xs[i + xsOffset] != ys[i]) {
                return i;
            }
        }
        return i;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC-165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[ERC].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

{
  "remappings": [
    "ds-test/=node_modules/ds-test/src/",
    "forge-std/=node_modules/forge-std/src/",
    "frax-std/=node_modules/frax-standard-solidity/src/",
    "script/=src/script/",
    "src/=src/",
    "test/=src/test/",
    "interfaces/=src/contracts/interfaces/",
    "arbitrum/=node_modules/@arbitrum/",
    "rlp/=node_modules/solidity-rlp/contracts/",
    "@solmate/=node_modules/@rari-capital/solmate/src/",
    "@arbitrum/=node_modules/@arbitrum/",
    "@chainlink/=node_modules/@chainlink/",
    "@mean-finance/=node_modules/@mean-finance/",
    "@openzeppelin/=node_modules/@openzeppelin/",
    "@rari-capital/=node_modules/@rari-capital/",
    "@uniswap/=node_modules/@uniswap/",
    "dev-fraxswap/=node_modules/dev-fraxswap/",
    "frax-standard-solidity/=node_modules/frax-standard-solidity/",
    "prb-math/=node_modules/prb-math/",
    "solidity-bytes-utils/=node_modules/solidity-bytes-utils/",
    "solidity-rlp/=node_modules/solidity-rlp/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 1000000
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "none",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "evmVersion": "shanghai",
  "viaIR": false,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_stateRootOracle","type":"address"},{"internalType":"address","name":"_timelockAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"MustBeGtZero","type":"error"},{"inputs":[],"name":"OnlyPendingTimelock","type":"error"},{"inputs":[],"name":"OnlyTimelock","type":"error"},{"inputs":[{"internalType":"address","name":"fraxOracleLayer1","type":"address"},{"internalType":"address","name":"fraxOracleLayer2","type":"address"}],"name":"OraclePairAlreadySet","type":"error"},{"inputs":[],"name":"StalePush","type":"error"},{"inputs":[],"name":"WrongOracleAddress","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"fraxOracleLayer1","type":"address"},{"indexed":true,"internalType":"address","name":"fraxOracleLayer2","type":"address"}],"name":"OraclePairAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousTimelock","type":"address"},{"indexed":true,"internalType":"address","name":"newTimelock","type":"address"}],"name":"TimelockTransferStarted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousTimelock","type":"address"},{"indexed":true,"internalType":"address","name":"newTimelock","type":"address"}],"name":"TimelockTransferred","type":"event"},{"inputs":[],"name":"STATE_ROOT_ORACLE","outputs":[{"internalType":"contract IStateRootOracle","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"acceptTransferTimelock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"layer1FraxOracle","type":"address"},{"internalType":"address","name":"layer2FraxOracle","type":"address"}],"internalType":"struct MerkleProofPriceSourceSUSDe.OraclePair[]","name":"_oraclePairs","type":"tuple[]"}],"name":"addOraclePairs","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC4626Receiver","name":"_sUSDeAddress","type":"address"},{"internalType":"uint96","name":"_blockNumber","type":"uint96"},{"components":[{"internalType":"bytes[]","name":"_accountProofSUSDe","type":"bytes[]"},{"internalType":"bytes[]","name":"_storageProofTS","type":"bytes[]"},{"internalType":"bytes[]","name":"_storageProofLastDist","type":"bytes[]"},{"internalType":"bytes[]","name":"_storageProofVestingAmount","type":"bytes[]"},{"internalType":"bytes[]","name":"_accountProofUSDe","type":"bytes[]"},{"internalType":"bytes[]","name":"_storageProofUSDeBalance","type":"bytes[]"}],"internalType":"struct MerkleProofPriceSourceSUSDe.SUSDeProof","name":"proof","type":"tuple"}],"name":"addRoundDataSUSDe","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"layer2FraxOracle","type":"address"}],"name":"oracleLookup","outputs":[{"internalType":"address","name":"layer1Oracle","type":"address"},{"internalType":"uint96","name":"lastBlockProofed","type":"uint96"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingTimelockAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceTimelock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"timelockAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_newTimelock","type":"address"}],"name":"transferTimelock","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000ed403d48e2bc946438b5686aa1ad65056ccf9512000000000000000000000000b26b24e6aaa874a428d7eef6002b291d24ccf271

-----Decoded View---------------
Arg [0] : _stateRootOracle (address): 0xeD403d48e2bC946438B5686AA1AD65056Ccf9512
Arg [1] : _timelockAddress (address): 0xb26B24e6aAA874a428D7eeF6002b291d24ccF271

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000ed403d48e2bc946438b5686aa1ad65056ccf9512
Arg [1] : 000000000000000000000000b26b24e6aaa874a428d7eef6002b291d24ccf271

1644:7771:6:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;653:188:12;;;;;;:::i;:::-;;:::i;:::-;;;516:14:13;;509:22;491:41;;479:2;464:18;653:188:12;;;;;;;;8019:1061:6;;;;;;:::i;:::-;;:::i;:::-;;1362:37:3;;;;;;;;;;;;1657:42:13;1645:55;;;1627:74;;1615:2;1600:18;1362:37:3;1481:226:13;4768:141:3;;;;;;:::i;:::-;;:::i;1451:30::-;;;;;;;;;5433:188;;;:::i;1781:51:6:-;;;;;4379:845;;;;;;:::i;:::-;;:::i;2740:82::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;3085:42:13;3073:55;;;3055:74;;3177:26;3165:39;;;3160:2;3145:18;;3138:67;3028:18;2740:82:6;2883:328:13;5057:128:3;;;:::i;653:188:12:-;738:4;877:25:0;862:40;;;;761:73:12;;;-1:-1:-1;801:33:12;;;:20;:33;;;;;;;;;;;;;761:73;754:80;653:188;-1:-1:-1;;653:188:12:o;8019:1061:6:-;8201:36;;;8175:23;8201:36;;;:12;:36;;;;;:53;;;;;;8268:21;;8264:107;;8324:16;8309:31;;:12;:31;;;8305:55;;;8349:11;;;;;;;;;;;;;;8305:55;8440:36;;;;8416:21;8440:36;;;:12;:36;;;;;:49;;;8499:60;;8539:20;;;;;;;;;;;;;;8499:60;8583:19;8616:26;8656:33;8703:21;8737:55;8757:13;8772:12;8786:5;8737:19;:55::i;:::-;8802:193;;;;;3503:26:13;3491:39;;8802:193:6;;;3473:58:13;3547:18;;;3540:34;;;3590:18;;;3583:34;;;3633:18;;;3626:34;;;3676:19;;;3669:35;;;8569:223:6;;-1:-1:-1;8569:223:6;;-1:-1:-1;8569:223:6;-1:-1:-1;8569:223:6;-1:-1:-1;8802:34:6;;;;;;3445:19:13;;8802:193:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;9005:36:6;;;;;;;;:12;:36;;;;;:68;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;8019:1061:6:o;4768:141:3:-;4843:18;:16;:18::i;:::-;4871:31;4889:12;4871:17;:31::i;:::-;4768:141;:::o;5433:188::-;5488:18;:16;:18::i;:::-;5516:25;:23;:25::i;:::-;5551:29;5577:1;5551:17;:29::i;:::-;5590:24;5611:1;5590:12;:24::i;:::-;5433:188::o;4379:845:6:-;4458:18;:16;:18::i;:::-;4492:9;4487:731;4507:23;;;4487:731;;;4551:29;4583:12;;4596:1;4583:15;;;;;;;:::i;:::-;;;;;;4551:47;;;;;;;;;;:::i;:::-;4629:28;;;;;4616:69;:42;;;4683:1;4616:42;;;:12;:42;;;;;;;:55;4551:47;;-1:-1:-1;4616:55:6;:69;4612:318;;4786:28;;;;;;4773:42;;;;;;;;:12;:42;;;;;;;;:55;4868:28;;4712:203;;;;;4773:55;;;4712:203;;;5432:74:13;5542:55;5522:18;;;5515:83;4712:203:6;;;;;;5405:18:13;4712:203:6;;;4612:318;5001:28;;4956;;;;;;4943:42;;;;5001:28;4943:42;;;:12;:42;;;;;;;:86;;;;;;;;;;;;;;5164:28;;5100;;5048:159;;;;;;;;;;;;;-1:-1:-1;4532:3:6;;4487:731;;;;4379:845;;:::o;5057:128:3:-;5118:25;:23;:25::i;:::-;5153;:23;:25::i;5417:2596:6:-;5820:44;;;;;5784:26:13;5772:39;;5820:44:6;;;5754:58:13;5607:19:6;;;;;;;;;;5820:30;:17;:30;;;;5727:18:13;;5820:44:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;5981:24;;5773:91;;-1:-1:-1;5874:41:6;;5918:191;;6033:13;6074:24;:5;;:24;:::i;:::-;5918:191;;;:::i;:::-;:33;:191::i;:::-;6249:29;;;;5874:235;;-1:-1:-1;6154:247:6;;6322:1;6361:21;;;;:5;:21;:::i;:::-;6154:247;;;:::i;:::-;:55;:247::i;:::-;:270;;;6588:29;;;;6154:270;;-1:-1:-1;6493:254:6;;6661:2;6701:27;;;;:5;:27;:::i;6493:254::-;:277;;;6444:336;;6827:259;6922:17;:29;;;6995:2;6979:20;;7035:5;:32;;;;;;;;:::i;6827:259::-;:282;;;7253:24;;6827:282;;-1:-1:-1;7143:40:6;;7186:206;;1871:42;7354:23;;;;:5;:23;:::i;7186:206::-;7555:28;;;;7143:249;;-1:-1:-1;7452:268:6;;2188:66;7667:30;;;;:5;:30;:::i;7452:268::-;:295;;;7406:355;;7129:643;7785:13;7802:1;7785:18;7781:45;;7812:14;;;;;;;;;;;;;;7781:45;7840:18;7862:1;7840:23;7836:50;;7872:14;;;;;;;;;;;;;;7836:50;7900:25;7929:1;7900:30;7896:57;;7939:14;;;;;;;;;;;;;;7896:57;7967:11;7982:1;7967:16;7963:43;;7992:14;;;;;;;;;;;;;;7963:43;5763:2250;;5417:2596;;;;;;;:::o;2783:115:3:-;2853:15;;;;2839:10;:29;2835:56;;2877:14;;;;;;;;;;;;;;3699:181;3767:22;:37;;;;;;;;;;;;;;3843:15;;3819:54;;3767:37;;3843:15;;3819:54;;-1:-1:-1;;3819:54:3;3699:181;:::o;3327:136::-;3404:22;;;;3390:10;:36;3386:70;;3435:21;;;;;;;;;;;;;;4385:165;4473:15;;4453:50;;;;;;;4473:15;;4453:50;;4473:15;;4453:50;4513:15;:30;;;;;;;;;;;;;;;4385:165::o;4046:130::-;4100:22;:35;;;;;;4145:24;4158:10;4145:12;:24::i;1782:645:9:-;1935:35;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1935:35:9;1982:42;2051:12;:19;2027:44;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;2027:44:9;;;;;;;;;;;;;;;-1:-1:-1;1982:89:9;-1:-1:-1;2086:9:9;2081:123;2105:12;:19;2101:1;:23;2081:123;;;2166:27;:12;2179:1;2166:15;;;;;;;;:::i;:::-;;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;1699:28:5;;;;;;;;1707:11;;1699:28;;1657:15;;;1699:28;;;;;;;;1513:221;2166:27:9;2145:15;2161:1;2145:18;;;;;;;;:::i;:::-;;;;;;;;;;:48;2126:3;;2081:123;;;-1:-1:-1;2298:30:9;;8526:66:13;8513:2;8509:15;;;8505:88;2298:30:9;;;8493:101:13;2227:193:9;;8610:12:13;;2298:30:9;;;;;;;;;;;;2288:41;;;;;;2359:13;2394:15;2227:32;:193::i;:::-;2213:207;1782:645;-1:-1:-1;;;;;1782:645:9:o;2764:637::-;-1:-1:-1;;;;;;;;;;;;;;;;;2963:42:9;3032:12;:19;3008:44;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;3008:44:9;;;;;;;;;;;;;;;-1:-1:-1;2963:89:9;-1:-1:-1;3067:9:9;3062:123;3086:12;:19;3082:1;:23;3062:123;;;3147:27;:12;3160:1;3147:15;;;;;;;;:::i;:27::-;3126:15;3142:1;3126:18;;;;;;;;:::i;:::-;;;;;;;;;;:48;3107:3;;3062:123;;;;3206:188;3293:4;3276:22;;;;;;8762:19:13;;8806:2;8797:12;;8633:182;3276:22:9;;;;;;;;;;;;;3266:33;;;;;;3331:15;3368;3206:34;:188::i;2565:930:10:-;2772:14;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2772:14:10;2798:25;2826:147;2885:14;2930:12;2913:30;;;;;;8762:19:13;;8806:2;8797:12;;8633:182;2913:30:10;;;;;;;;;;;;;2957:6;2826:45;:147::i;:::-;2798:175;;2984:22;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2984:22:10;3021:12;:19;3044:1;3021:24;3017:69;;3068:7;-1:-1:-1;3061:14:10;;-1:-1:-1;3061:14:10;3017:69;3096:37;3136:33;:24;:12;-1:-1:-1;;;;;;;;;;;;;;;;;1699:28:5;;;;;;;;1707:11;;1699:28;;1657:15;;;1699:28;;;;;;;;1513:221;3136:24:10;:31;:33::i;:::-;3096:73;;3187:10;:17;3208:1;3187:22;3179:31;;;;;;3238:4;3221:21;;3268:13;;:22;;:10;;3221:14;;3268:13;;;;:::i;:::-;;;;;;;:20;:22::i;:::-;3252:13;;;:38;3318:13;;:22;;:10;;3329:1;;3318:13;;;;;;:::i;:22::-;3300:15;;;:40;3380:13;;:22;;:10;;3391:1;;3380:13;;;;;;:::i;:22::-;3350:19;;;:53;3440:13;;:22;;:10;;3451:1;;3440:13;;;;;;:::i;:22::-;3413:16;;;:50;-1:-1:-1;3413:7:10;-1:-1:-1;;2565:930:10;;;;;;:::o;3748:581::-;-1:-1:-1;;;;;;;;;;;;;;;;;3944:26:10;3973:146;4032:16;4079:9;4062:27;;;;;;8762:19:13;;8806:2;8797:12;;8633:182;3973:146:10;-1:-1:-1;;;;;;;;;;;;;;;;;3944:175:10;;-1:-1:-1;4167:20:10;;:25;4163:137;;4223:4;4208:19;;-1:-1:-1;;;;;;;;;;;;;;;;;1699:28:5;;;;;;;;1707:11;;1699:28;;1657:15;;;1699:28;;;;4255:34:10;;:32;:34::i;:::-;4241:11;;;:48;4317:5;3748:581;-1:-1:-1;;;;;3748:581:10:o;1267:5638:8:-;1418:18;1448:19;1470:23;1485:4;1491:1;1470:14;:23::i;:::-;1448:45;;1503:20;1526:1;1503:24;;1538:20;1568:31;1610:33;-1:-1:-1;;;;;;;;;;;;;;;;;;;1610:33:8;1658:5;:12;1674:1;1658:17;1654:223;;1766:66;1754:78;;1746:87;;;;;;-1:-1:-1;;1854:12:8;;;1864:1;1854:12;;;;;;;;;-1:-1:-1;1847:19:8;;-1:-1:-1;;;1847:19:8;1654:223;1945:9;1940:4959;1964:5;:12;1960:1;:16;1940:4959;;;2238:6;;:50;;;;;2260:28;:5;2266:1;2260:8;;;;;;;;:::i;:::-;;;;;;;4208:11:5;;;;4243:8;;4318:19;;;4104:272;2260:28:8;2248:8;:40;;2238:50;2234:97;;;2308:8;;;2234:97;2445:6;;;;;:48;;;2471:22;2484:5;2490:1;2484:8;;;;;;;;:::i;:::-;;;;;;;2471:12;:22::i;:::-;2455:12;:38;;2445:48;2441:95;;;2513:8;;;2441:95;2662:17;:5;2668:1;2662:8;;;;;;;;:::i;:::-;;;;;;;:15;:17::i;:::-;2655:24;;2698:4;:11;2713:1;2698:16;2694:4195;;2777:11;2806:20;2864:47;2893:17;:4;2898:1;2893:7;;;;;;;;:::i;:::-;;;;;;;:15;:17::i;:::-;2864:28;:47::i;:::-;2844:67;;-1:-1:-1;2844:67:8;-1:-1:-1;2930:20:8;2953:50;2973:12;2987:6;2844:67;2953:19;:50::i;:::-;2930:73;-1:-1:-1;3021:28:8;2930:73;3021:28;;:::i;:::-;;;3087:7;:14;3072:12;:29;3068:994;;;3876:1;3861:5;:12;:16;;;;:::i;:::-;3857:1;:20;3853:149;;;3971:8;;;3853:149;4041:1;4031:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4031:12:8;;4024:19;;;;;;;;;;;;;3068:994;4084:6;4080:1175;;;4173:1;4158:5;:12;:16;;;;:::i;:::-;4154:1;:20;4150:144;;;4263:8;;;4150:144;4335:6;:13;4320:12;:28;4316:102;;;4393:1;4383:12;;4316:102;4451:4;4456:1;4451:7;;;;;;;;:::i;:::-;;;;;;;4440:18;;4487;:8;:16;:18::i;:::-;4480:25;;;;;;;;;;;;;4080:1175;4645:1;4630:5;:12;:16;;;;:::i;:::-;4625:1;:21;4621:138;;4728:8;;;4621:138;4786:16;:4;4791:1;4786:7;;;;;;;;:::i;:::-;;;;;;;:14;:16::i;:::-;4781:456;;4973:26;:4;4978:1;4973:7;;;;;;;;:::i;:::-;;;;;;;:24;:26::i;:::-;4958:41;;4781:456;;;5187:27;:4;5192:1;5187:7;;;;;;;;:::i;:27::-;5172:42;;4781:456;2716:2553;;;2694:4195;;;5279:4;:11;5294:2;5279:17;5275:1614;;5368:6;:13;5352:12;:29;5348:1527;;5495:12;5516:6;5523:12;5516:20;;;;;;;;:::i;:::-;;;;;;;;-1:-1:-1;5559:17:8;5575:1;5559:17;;:::i;:::-;;;5612:2;5602:6;:12;;;5598:146;;5713:8;;;5598:146;5770:34;5791:4;5796:6;5791:12;;;;;;;;;;:::i;:::-;;;;;;;5770:20;:34::i;:::-;5766:556;;;5890:1;5875:5;:12;:16;;;;:::i;:::-;5870:1;:21;5866:157;;5988:8;;;5866:157;-1:-1:-1;;6056:12:8;;;6066:1;6056:12;;;;;;;;;-1:-1:-1;6049:19:8;;-1:-1:-1;;;;;6049:19:8;5766:556;6102:21;:4;6107:6;6102:12;;;;;;;;;;:::i;:21::-;6097:225;;6166:31;:4;6171:6;6166:12;;;;;;;;;;:::i;:31::-;6151:46;;6097:225;;;6267:32;:4;6272:6;6267:12;;;;;;;;;;:::i;:32::-;6252:47;;6097:225;6368:1;6353:5;:12;:16;;;;:::i;:::-;6348:1;:21;6344:141;;6454:8;;;6344:141;5383:1120;5348:1527;;;6698:1;6683:5;:12;:16;;;;:::i;:::-;6678:1;:21;6674:135;;6778:8;;;6674:135;6838:18;:4;6843:2;6838:8;;;;;;;;:::i;:18::-;6831:25;;;;;;;;;;5348:1527;1978:3;;1940:4959;;;;1438:5467;;;;;1267:5638;;;;;:::o;2946:571:5:-;3006:16;3042:12;3049:4;3042:6;:12::i;:::-;3034:21;;;;;;3066:13;3082:14;3091:4;3082:8;:14::i;:::-;3066:30;;3106:23;3146:5;3132:20;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;3132:20:5;;;;;;;;;;;;;;;;3106:46;;3163:14;3194:27;3209:4;:11;;;3194:14;:27::i;:::-;3180:4;:11;;;:41;;;;:::i;:::-;3163:58;-1:-1:-1;3231:15:5;;3256:179;3280:5;3276:1;:9;3256:179;;;3316:19;3328:6;3316:11;:19::i;:::-;3306:29;;3361:24;;;;;;;;3369:7;3361:24;;;;3378:6;3361:24;;;3349:6;3356:1;3349:9;;;;;;;;:::i;:::-;;;;;;;;;;:36;3408:16;3417:7;3408:6;:16;:::i;:::-;3399:25;-1:-1:-1;3287:3:5;;3256:179;;;-1:-1:-1;3477:8:5;;3462:11;;;;3453:20;;:6;:20;:::i;:::-;:32;3445:41;;;;;;-1:-1:-1;3504:6:5;;2946:571;-1:-1:-1;;;;2946:571:5:o;6101:467::-;6188:8;;6161:7;;6188:12;;;;:30;;-1:-1:-1;6204:8:5;;6216:2;-1:-1:-1;6204:14:5;6188:30;6180:39;;;;;;6231:14;6247:11;6262:21;6278:4;6262:15;:21::i;:::-;6351:13;;6230:53;;-1:-1:-1;6230:53:5;-1:-1:-1;6447:2:5;6439:11;;6436:92;;;6504:2;6500:12;;;6495:3;6491:22;6479:35;;6436:92;6555:6;6101:467;-1:-1:-1;;;;6101:467:5:o;8886:747:8:-;8975:20;9032:1;9015:7;:14;:18;9007:27;;;;;;9045:14;9062:7;:14;9079:1;9062:18;;;;:::i;:::-;9045:35;;9113:6;9098:11;:21;;9090:30;;;;;;9130:21;9140:11;9130:21;;:::i;:::-;;;9182:6;9172:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;9172:17:8;-1:-1:-1;9162:27:8;-1:-1:-1;9199:21:8;9252:11;9235:342;9269:20;9283:6;9269:11;:20;:::i;:::-;9265:1;:24;9235:342;;;9317:5;9321:1;9317;:5;:::i;:::-;9326:1;9317:10;9313:222;;9405:1;9386:7;9394:5;9398:1;9394;:5;:::i;:::-;9386:14;;;;;;;;:::i;:::-;;;;;;;;;9380:21;;:26;;;;9410:3;9379:34;9372:42;;9347:7;9355:13;9347:22;;;;;;;;:::i;:::-;;;;:67;;;;;;;;;;;9313:222;;;9511:1;9492:7;9500:5;9504:1;9500;:5;:::i;:::-;9492:14;;;;;;;;:::i;:::-;;;;;;;;;9486:21;;:26;;;;9516:3;9485:34;9478:42;;9453:7;9461:13;9453:22;;;;;;;;:::i;:::-;;;;:67;;;;;;;;;;;9313:222;9548:18;9565:1;9548:18;;:::i;:::-;;-1:-1:-1;9291:6:8;9296:1;9291:6;;:::i;:::-;;;9235:342;;;;9611:7;:14;9594:13;:31;9587:39;;;;:::i;:::-;8997:636;;8886:747;;;;:::o;7470:266::-;7545:7;7579:2;7568:4;:8;;;:13;7564:166;;;4208:11:5;;;;4243:8;;4318:19;;7604:24:8;4104:272:5;7564:166:8;4208:11:5;;;;4243:8;;4318:19;;7676:42:8;;;;;;8762:19:13;;8806:2;8797:12;;8633:182;7676:42:8;;;;;;;;;;;;;7666:53;;;;;;7659:60;;7470:266;;;:::o;6909:379:5:-;7002:8;;6970:12;;6994:21;;;;;;7027:14;7043:11;7058:21;7074:4;7058:15;:21::i;:::-;7026:53;;;;7089:19;7121:3;7111:14;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7111:14:5;-1:-1:-1;7089:36:5;-1:-1:-1;7199:4:5;7195:17;;7232:26;7237:6;7195:17;7254:3;7232:4;:26::i;:::-;-1:-1:-1;7275:6:5;6909:379;-1:-1:-1;;;;6909:379:5:o;8083:797:8:-;8179:11;8192:20;8249:1;8232:7;:14;:18;8224:27;;;;;;8261:20;8306:1;8291:7;8299:1;8291:10;;;;;;;;:::i;:::-;;;;;;;;8285:22;;8311:3;8284:30;;-1:-1:-1;8324:19:8;8357:17;;;8353:458;;-1:-1:-1;8428:5:8;;-1:-1:-1;8404:1:8;8353:458;;;8454:12;8470:1;8454:17;8450:361;;-1:-1:-1;8525:5:8;;-1:-1:-1;8501:1:8;8450:361;;;8551:12;8567:1;8551:17;8547:264;;-1:-1:-1;8622:4:8;;-1:-1:-1;8598:1:8;8547:264;;;8647:12;8663:1;8647:17;8643:168;;-1:-1:-1;8694:1:8;;-1:-1:-1;8694:1:8;8643:168;8828:6;8836:36;8851:7;8860:11;8836:14;:36::i;:::-;8820:53;;;;;;8083:797;;;:::o;9639:321::-;9742:7;;9780:156;9807:9;;9792:12;9796:8;9792:1;:12;:::i;:::-;:24;:41;;;;;9824:2;:9;9820:1;:13;9792:41;9780:156;;;9878:2;9881:1;9878:5;;;;;;;;:::i;:::-;;;;;;;9858:2;9861:12;9865:8;9861:1;:12;:::i;:::-;9858:16;;;;;;;;:::i;:::-;;;;;;;:25;9854:72;;9910:1;-1:-1:-1;9903:8:8;;9854:72;9835:3;;;;:::i;:::-;;;;9780:156;;3621:321:5;3701:8;;3681:4;;3701:13;;3697:31;;-1:-1:-1;3723:5:5;;3621:321;-1:-1:-1;3621:321:5:o;3697:31::-;3777:11;;;;3838:13;;3739:11;3830:22;;328:4;3876:24;;3872:42;;;-1:-1:-1;3909:5:5;;3621:321;-1:-1:-1;;;3621:321:5:o;3872:42::-;-1:-1:-1;3931:4:5;;3621:321;-1:-1:-1;;;3621:321:5:o;4534:270::-;4604:7;4624:14;4640:11;4655:21;4671:4;4655:15;:21::i;:::-;4743:22;;;4534:270;-1:-1:-1;;;;4534:270:5:o;7742:335:8:-;7845:8;;7825:4;;7857:1;7845:13;7841:56;;-1:-1:-1;7881:5:8;;7742:335;-1:-1:-1;7742:335:8:o;7841:56::-;-1:-1:-1;7940:11:8;;;7997:13;7906:7;7989:22;8042:4;8037:9;;7742:335::o;7396:424:5:-;7480:8;;7457:7;;7480:13;;7476:27;;-1:-1:-1;7502:1:5;;7396:424;-1:-1:-1;7396:424:5:o;7476:27::-;7514:13;7530:1;7514:17;;7541:15;7573:27;7588:4;:11;;;7573:14;:27::i;:::-;7559:4;:11;;;:41;;;;:::i;:::-;7541:59;;7610:14;7641:4;:8;;;7627:4;:11;;;:22;;;;:::i;:::-;7610:39;;7659:132;7676:6;7666:7;:16;7659:132;;;7718:20;7730:7;7718:11;:20::i;:::-;7708:30;;:7;:30;:::i;:::-;7698:40;-1:-1:-1;7773:7:5;;;;:::i;:::-;;;;7659:132;;;-1:-1:-1;7808:5:5;;7396:424;-1:-1:-1;;;7396:424:5:o;9184:581::-;9328:13;;9246:7;;9320:22;;239:4;9366:26;;9362:397;;;-1:-1:-1;9415:1:5;;9184:581;-1:-1:-1;;9184:581:5:o;9362:397::-;284:4;9437:25;;;:83;;-1:-1:-1;328:4:5;9467:25;;;;;:52;;-1:-1:-1;371:4:5;9496:23;;9467:52;9433:326;;;-1:-1:-1;9543:1:5;;9184:581;-1:-1:-1;;9184:581:5:o;9433:326::-;328:4;9565:24;;9561:198;;;9651:21;9671:1;284:4;9651:21;:::i;:::-;9642:31;;;;:5;:31;:::i;:::-;:35;;9676:1;9642:35;:::i;9561:198::-;9724:19;9742:1;371:4;9724:19;:::i;7869:1263::-;8035:13;;7928:7;;;;8027:22;;239:4;8073:26;;8069:1032;;;8125:1;8115:11;;8069:1032;;;284:4;8147:25;;8143:958;;;8198:26;239:4;8198:5;:26;:::i;:::-;:30;;8227:1;8198:30;:::i;:::-;8188:40;;8143:958;;;328:4;8249:24;;8245:856;;;8342:4;8335:5;8331:16;8421:1;8413:6;8409:14;8399:24;;8560:7;8556:2;8552:16;8547:3;8543:26;8534:6;8528:13;8524:46;8657:1;8648:7;8644:15;8635:7;8631:29;8620:40;;;;8245:856;;;371:4;8694:23;;8690:411;;;8743:24;328:4;8743:5;:24;:::i;8690:411::-;8855:4;8848:5;8844:16;8899:1;8891:6;8887:14;8877:24;;8970:7;8966:2;8962:16;8957:3;8953:26;8944:6;8938:13;8934:46;9074:1;9065:7;9061:15;9052:7;9048:29;9037:40;;;;8690:411;-1:-1:-1;9118:7:5;7869:1263;-1:-1:-1;;7869:1263:5:o;2390:281::-;2459:7;2468;2487:14;2504:27;2519:4;:11;;;2504:14;:27::i;:::-;2487:44;;2541:14;2572:6;2558:4;:11;;;:20;;;;:::i;:::-;2541:37;;2588:11;2613:6;2602:4;:8;;;:17;;;;:::i;:::-;2652:6;;2588:31;;-1:-1:-1;2390:281:5;;-1:-1:-1;;;;2390:281:5:o;9923:768::-;10004:3;10011:1;10004:8;10000:21;;9923:768;;;:::o;10000:21::-;408:2;10085:16;;10078:194;;10175:10;;10162:24;;10214:16;408:2;10181:3;10214:16;:::i;:::-;;-1:-1:-1;10244:17:5;408:2;10244:17;;:::i;:::-;;-1:-1:-1;10103:16:5;408:2;10103:16;;:::i;:::-;;;10078:194;;;10286:7;;10282:403;;10393:12;10433:1;10414:15;10426:3;408:2;10414:15;:::i;:::-;10408:22;;:3;:22;:::i;:::-;:26;;;;:::i;:::-;10494:10;;10569:11;;10565:22;;10506:9;;10490:26;10639:21;10626:35;;-1:-1:-1;9923:768:5;;;:::o;14:332:13:-;72:6;125:2;113:9;104:7;100:23;96:32;93:52;;;141:1;138;131:12;93:52;180:9;167:23;230:66;223:5;219:78;212:5;209:89;199:117;;312:1;309;302:12;543:172;647:42;640:5;636:54;629:5;626:65;616:93;;705:1;702;695:12;720:756;851:6;859;867;920:2;908:9;899:7;895:23;891:32;888:52;;;936:1;933;926:12;888:52;975:9;962:23;994:49;1037:5;994:49;:::i;:::-;1062:5;-1:-1:-1;1119:2:13;1104:18;;1091:32;1167:26;1154:40;;1142:53;;1132:81;;1209:1;1206;1199:12;1132:81;1232:7;-1:-1:-1;1290:2:13;1275:18;;1262:32;1317:18;1306:30;;1303:50;;;1349:1;1346;1339:12;1303:50;1372:22;;1428:3;1410:16;;;1406:26;1403:46;;;1445:1;1442;1435:12;1403:46;1468:2;1458:12;;;720:756;;;;;:::o;1712:265::-;1771:6;1824:2;1812:9;1803:7;1799:23;1795:32;1792:52;;;1840:1;1837;1830:12;1792:52;1879:9;1866:23;1898:49;1941:5;1898:49;:::i;2238:640::-;2354:6;2362;2415:2;2403:9;2394:7;2390:23;2386:32;2383:52;;;2431:1;2428;2421:12;2383:52;2471:9;2458:23;2504:18;2496:6;2493:30;2490:50;;;2536:1;2533;2526:12;2490:50;2559:22;;2612:4;2604:13;;2600:27;-1:-1:-1;2590:55:13;;2641:1;2638;2631:12;2590:55;2681:2;2668:16;2707:18;2699:6;2696:30;2693:50;;;2739:1;2736;2729:12;2693:50;2792:7;2787:2;2777:6;2774:1;2770:14;2766:2;2762:23;2758:32;2755:45;2752:65;;;2813:1;2810;2803:12;2752:65;2844:2;2836:11;;;;;2866:6;;-1:-1:-1;2238:640:13;-1:-1:-1;;;2238:640:13:o;3715:184::-;3767:77;3764:1;3757:88;3864:4;3861:1;3854:15;3888:4;3885:1;3878:15;3904:184;3956:77;3953:1;3946:88;4053:4;4050:1;4043:15;4077:4;4074:1;4067:15;4093:251;4165:2;4159:9;;;4195:15;;4240:18;4225:34;;4261:22;;;4222:62;4219:88;;;4287:18;;:::i;:::-;4323:2;4316:22;4093:251;:::o;4349:334::-;4420:2;4414:9;4476:2;4466:13;;4481:66;4462:86;4450:99;;4579:18;4564:34;;4600:22;;;4561:62;4558:88;;;4626:18;;:::i;:::-;4662:2;4655:22;4349:334;;-1:-1:-1;4349:334:13:o;4688:565::-;4775:6;4835:2;4823:9;4814:7;4810:23;4806:32;4850:2;4847:22;;;4865:1;4862;4855:12;4847:22;-1:-1:-1;4907:22:13;;:::i;:::-;4966:9;4953:23;4985:51;5028:7;4985:51;:::i;:::-;5045:22;;5119:2;5104:18;;5091:32;5132:51;5091:32;5132:51;:::i;:::-;5210:2;5199:14;;5192:31;5203:5;4688:565;-1:-1:-1;;;4688:565:13:o;5823:486::-;5920:6;5980:2;5968:9;5959:7;5955:23;5951:32;5995:2;5992:22;;;6010:1;6007;6000:12;5992:22;-1:-1:-1;6052:22:13;;:::i;:::-;6103:9;6097:16;6090:5;6083:31;6159:2;6148:9;6144:18;6138:25;6207:12;6198:7;6194:26;6185:7;6182:39;6172:67;;6235:1;6232;6225:12;6314:615;6418:4;6424:6;6484:11;6471:25;6574:66;6563:8;6547:14;6543:29;6539:102;6519:18;6515:127;6505:155;;6656:1;6653;6646:12;6505:155;6683:33;;6735:20;;;-1:-1:-1;6778:18:13;6767:30;;6764:50;;;6810:1;6807;6800:12;6764:50;6843:4;6831:17;;-1:-1:-1;6894:1:13;6890:14;;;6874;6870:35;6860:46;;6857:66;;;6919:1;6916;6909:12;6857:66;6314:615;;;;;:::o;6934:1425::-;7070:9;7108:18;7100:6;7097:30;7094:56;;;7130:18;;:::i;:::-;7176:6;7173:1;7169:14;7203:30;7227:4;7223:2;7219:13;7203:30;:::i;:::-;7267:19;;;7339:14;;;;7311:4;7302:14;;;7376;7365:26;;7362:46;;;7404:1;7401;7394:12;7362:46;7428:5;7442:884;7458:6;7453:3;7450:15;7442:884;;;7546:3;7533:17;7582:18;7569:11;7566:35;7563:55;;;7614:1;7611;7604:12;7563:55;7641:23;;7706:14;7699:4;7691:13;;7687:34;7677:62;;7735:1;7732;7725:12;7677:62;7781:2;7768:16;7813:18;7803:8;7800:32;7797:58;;;7835:18;;:::i;:::-;7883:120;7997:4;7928:66;7921:4;7911:8;7907:19;7903:92;7899:103;7883:120;:::i;:::-;8032:8;8023:7;8016:25;8090:14;8083:4;8072:8;8068:2;8064:17;8060:28;8057:48;8054:68;;;8118:1;8115;8108:12;8054:68;8183:8;8176:4;8172:2;8168:13;8161:4;8152:7;8148:18;8135:57;8247:1;8240:4;8229:8;8220:7;8216:22;8212:33;8205:44;8274:7;8269:3;8262:20;;;;8311:4;8306:3;8302:14;8295:21;;7484:4;7479:3;7475:14;7468:21;;7442:884;;;-1:-1:-1;8348:5:13;6934:1425;-1:-1:-1;;;;;6934:1425:13:o;8820:184::-;8872:77;8869:1;8862:88;8969:4;8966:1;8959:15;8993:4;8990:1;8983:15;9009:125;9074:9;;;9095:10;;;9092:36;;;9108:18;;:::i;9139:128::-;9206:9;;;9227:11;;;9224:37;;;9241:18;;:::i;9272:168::-;9345:9;;;9376;;9393:15;;;9387:22;;9373:37;9363:71;;9414:18;;:::i;9445:184::-;9497:77;9494:1;9487:88;9594:4;9591:1;9584:15;9618:4;9615:1;9608:15;9634:112;9666:1;9692;9682:35;;9697:18;;:::i;:::-;-1:-1:-1;9731:9:13;;9634:112::o;9751:120::-;9791:1;9817;9807:35;;9822:18;;:::i;:::-;-1:-1:-1;9856:9:13;;9751:120::o;9876:184::-;9928:77;9925:1;9918:88;10025:4;10022:1;10015:15;10049:4;10046:1;10039:15;10065:195;10104:3;10135:66;10128:5;10125:77;10122:103;;10205:18;;:::i;:::-;-1:-1:-1;10252:1:13;10241:13;;10065:195::o;10265:151::-;10355:4;10348:12;;;10334;;;10330:31;;10373:14;;10370:40;;;10390:18;;:::i;10421:375::-;10509:1;10527:5;10541:249;10562:1;10552:8;10549:15;10541:249;;;10612:4;10607:3;10603:14;10597:4;10594:24;10591:50;;;10621:18;;:::i;:::-;10671:1;10661:8;10657:16;10654:49;;;10685:16;;;;10654:49;10768:1;10764:16;;;;;10724:15;;10541:249;;;10421:375;;;;;;:::o;10801:1022::-;10850:5;10880:8;10870:80;;-1:-1:-1;10921:1:13;10935:5;;10870:80;10969:4;10959:76;;-1:-1:-1;11006:1:13;11020:5;;10959:76;11051:4;11069:1;11064:59;;;;11137:1;11132:174;;;;11044:262;;11064:59;11094:1;11085:10;;11108:5;;;11132:174;11169:3;11159:8;11156:17;11153:43;;;11176:18;;:::i;:::-;-1:-1:-1;;11232:1:13;11218:16;;11291:5;;11044:262;;11390:2;11380:8;11377:16;11371:3;11365:4;11362:13;11358:36;11352:2;11342:8;11339:16;11334:2;11328:4;11325:12;11321:35;11318:77;11315:203;;;-1:-1:-1;11427:19:13;;;11503:5;;11315:203;11550:102;11585:66;11575:8;11569:4;11550:102;:::i;:::-;11748:6;11680:66;11676:79;11667:7;11664:92;11661:118;;;11759:18;;:::i;:::-;11797:20;;10801:1022;-1:-1:-1;;;10801:1022:13:o;11828:131::-;11888:5;11917:36;11944:8;11938:4;11917:36;:::i

none