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;

// ====================================================================
// |     ______                   _______                             |
// |    / _____________ __  __   / ____(_____  ____ _____  ________   |
// |   / /_  / ___/ __ `| |/_/  / /_  / / __ \/ __ `/ __ \/ ___/ _ \  |
// |  / __/ / /  / /_/ _>  <   / __/ / / / / / /_/ / / / / /__/  __/  |
// | /_/   /_/   \__,_/_/|_|  /_/   /_/_/ /_/\__,_/_/ /_/\___/\___/   |
// |                                                                  |
// ====================================================================
// ====================== MerkleProofChainlink ========================
// ====================================================================
// 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 Frax Oracle and pushes the price data to an L2 Frax Oracle
contract MerkleProofPriceSourceSfrxEth is ERC165Storage, Timelock2Step {
    /// @notice The address of the StateRootOracle on Layer 2
    IStateRootOracle public immutable STATE_ROOT_ORACLE;

    using FixedPointMathLib for uint256;

    struct OracleConfig {
        address layer1Oracle;
        uint96 lastBlockProofed;
    }

    /// @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 _fetchAndProofSfrxEth(
        address _sfrxEthAddress,
        uint96 _blockNumber,
        bytes[] memory _accountProofSfrxEth,
        bytes[] memory _storageProofTotalSupply,
        bytes[] memory _storageProofTotalAssets,
        bytes[] memory _storageProofRewards
    )
        internal
        view
        returns (uint256 totalSupply, uint256 totalAssets, uint192 lastRewards, uint32 rewardsCycleEnd, uint32 lastSync)
    {
        IStateRootOracle.BlockInfo memory _blockInfo = STATE_ROOT_ORACLE.getBlockInfo(_blockNumber);
        Verifier.Account memory _accountProofSfrxEth = MerkleTreeProver.proveStorageRoot({
            stateRootHash: _blockInfo.stateRootHash,
            proofAddress: _sfrxEthAddress,
            accountProof: _accountProofSfrxEth
        });
        totalSupply = uint256(
            MerkleTreeProver
                .proveStorageSlotValue({
                    storageRootHash: _accountProofSfrxEth.storageRoot,
                    slot: bytes32(uint256(2)),
                    storageProof: _storageProofTotalSupply
                })
                .value
        );

        totalAssets = uint256(
            MerkleTreeProver
                .proveStorageSlotValue({
                    storageRootHash: _accountProofSfrxEth.storageRoot,
                    slot: bytes32(uint256(7)),
                    storageProof: _storageProofTotalAssets
                })
                .value
        );
        uint256 rewardsPacked = uint256(
            MerkleTreeProver
                .proveStorageSlotValue({
                    storageRootHash: _accountProofSfrxEth.storageRoot,
                    slot: bytes32(uint256(6)),
                    storageProof: _storageProofRewards
                })
                .value
        );

        // Get the first 24 bytes on the slot
        lastRewards = uint192(bytes24(bytes32(rewardsPacked)));
        // get the last 8 bytes on the slot only take first 4
        rewardsCycleEnd = uint32(bytes4(bytes32(rewardsPacked) << 192));
        // get the last 4 bytes on the slot
        lastSync = uint32(bytes4(bytes32(rewardsPacked) << 224));
        if (totalSupply == 0) revert MustBeGtZero();
        if (lastRewards == 0) revert MustBeGtZero();
        if (lastSync == 0) revert MustBeGtZero();
        if (totalAssets == 0) revert MustBeGtZero();
    }

    function addRoundDataSfrxEth(
        IERC4626Receiver _sfrxEthAddress,
        uint96 _blockNumber,
        bytes[] memory _accountProofSfrxEth,
        bytes[] memory _storageProofTotalSupply,
        bytes[] memory _storageProofTotalAssets,
        bytes[] memory _storageProofRewards
    ) external {
        uint96 lastBlockProofed = oracleLookup[address(_sfrxEthAddress)].lastBlockProofed;
        if (lastBlockProofed != 0) {
            if (_blockNumber < lastBlockProofed) revert StalePush();
        }
        // Address of the L1 oracle
        address _proofAddress = oracleLookup[address(_sfrxEthAddress)].layer1Oracle;
        if (_proofAddress == address(0)) revert WrongOracleAddress();
        (
            uint256 totalSupply,
            uint256 totalStoredAssets,
            uint192 lastRewards,
            uint32 rewardsCycleEnd,
            uint32 lastSync
        ) = _fetchAndProofSfrxEth(
                _proofAddress,
                _blockNumber,
                _accountProofSfrxEth,
                _storageProofTotalSupply,
                _storageProofTotalAssets,
                _storageProofRewards
            );
        _sfrxEthAddress.updateErc4262VaultData(
            // _blockNumber,
            totalSupply,
            totalStoredAssets,
            lastRewards,
            rewardsCycleEnd,
            lastSync
        );
        oracleLookup[address(_sfrxEthAddress)].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 MerkleProofPriceSourceSfrxEth.OraclePair[]","name":"_oraclePairs","type":"tuple[]"}],"name":"addOraclePairs","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC4626Receiver","name":"_sfrxEthAddress","type":"address"},{"internalType":"uint96","name":"_blockNumber","type":"uint96"},{"internalType":"bytes[]","name":"_accountProofSfrxEth","type":"bytes[]"},{"internalType":"bytes[]","name":"_storageProofTotalSupply","type":"bytes[]"},{"internalType":"bytes[]","name":"_storageProofTotalAssets","type":"bytes[]"},{"internalType":"bytes[]","name":"_storageProofRewards","type":"bytes[]"}],"name":"addRoundDataSfrxEth","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

1648:7251:6:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;653:188:12;;;;;;:::i;:::-;;:::i;:::-;;;516:14:13;;509:22;491:41;;479:2;464:18;653:188:12;;;;;;;;1362:37:3;;;;;;;;;;;;719:42:13;707:55;;;689:74;;677:2;662:18;1362:37:3;543:226:13;4768:141:3;;;;;;:::i;:::-;;:::i;:::-;;1451:30;;;;;;;;;5433:188;;;:::i;1787:51:6:-;;;;;3703:845;;;;;;:::i;:::-;;:::i;7108:1456::-;;;;;;:::i;:::-;;:::i;2064:82::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;6171:42:13;6159:55;;;6141:74;;6263:26;6251:39;;;6246:2;6231:18;;6224:67;6114:18;2064:82:6;5969: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;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;3703:845:6:-;3782:18;:16;:18::i;:::-;3816:9;3811:731;3831:23;;;3811:731;;;3875:29;3907:12;;3920:1;3907:15;;;;;;;:::i;:::-;;;;;;3875:47;;;;;;;;;;:::i;:::-;3953:28;;;;;3940:69;:42;;;4007:1;3940:42;;;:12;:42;;;;;;;:55;3875:47;;-1:-1:-1;3940:55:6;:69;3936:318;;4110:28;;;;;;4097:42;;;;;;;;:12;:42;;;;;;;;:55;4192:28;;4036:203;;;;;4097:55;;;4036:203;;;7199:74:13;7309:55;7289:18;;;7282:83;4036:203:6;;;;;;7172:18:13;4036:203:6;;;3936:318;4325:28;;4280;;;;;;4267:42;;;;4325:28;4267:42;;;:12;:42;;;;;;;:86;;;;;;;;;;;;;;4488:28;;4424;;4372:159;;;;;;;;;;;;;-1:-1:-1;3856:3:6;;3811:731;;;;3703:845;;:::o;7108:1456::-;7447:38;;;7421:23;7447:38;;;:12;:38;;;;;:55;;;;;;7516:21;;7512:107;;7572:16;7557:31;;:12;:31;;;7553:55;;;7597:11;;;;;;;;;;;;;;7553:55;7688:38;;;;7664:21;7688:38;;;:12;:38;;;;;:51;;;7749:60;;7789:20;;;;;;;;;;;;;;7749:60;7833:19;7866:25;7905:19;7938:22;7974:15;8002:256;8041:13;8072:12;8102:20;8140:24;8182;8224:20;8002:21;:256::i;:::-;8268:209;;;;;;;;7631:25:13;;;7672:18;;;7665:34;;;7747:50;7735:63;;7715:18;;;7708:91;8268:209:6;7835:23:13;;;7815:18;;;7808:51;7896:23;;7875:19;;;7868:52;7819:439:6;;-1:-1:-1;7819:439:6;;-1:-1:-1;7819:439:6;;-1:-1:-1;7819:439:6;-1:-1:-1;7819:439:6;-1:-1:-1;8268:38:6;;;;;;7603:19:13;;8268:209:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;8487:38:6;;;;;;;;:12;:38;;;;;:70;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;7108:1456:6:o;5057:128:3:-;5118:25;:23;:25::i;:::-;5153;:23;:25::i;2783:115::-;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;4741:2361:6:-;5240:44;;;;;8106:26:13;8094:39;;5240:44:6;;;8076:58:13;5075:19:6;;;;;;;;;;;;5240:30;:17;:30;;;;8049:18:13;;5240:44:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;5193:91;;5294:44;5341:189;5404:10;:24;;;5456:15;5499:20;5341:33;:189::i;:::-;5294:236;;5575:253;5670:20;:32;;;5746:1;5730:19;;5785:24;5575:55;:253::i;:::-;:276;;;5540:321;;5907:253;6002:20;:32;;;6078:1;6062:19;;6117:24;5907:55;:253::i;:::-;:276;;;5872:321;;6203:21;6248:249;6343:20;:32;;;6419:1;6403:19;;6458:20;6248:55;:249::i;:::-;:272;;;;;6601:40;;;;;-1:-1:-1;6731:45:6;;;;;;;;-1:-1:-1;6841:45:6;;;;-1:-1:-1;6248:272:6;-1:-1:-1;6617:22:6;6900:16;;;6896:43;;6925:14;;;;;;;;;;;;;;6896:43;6953:11;:16;;6968:1;6953:16;6949:43;;6978:14;;;;;;;;;;;;;;6949:43;7006:8;:13;;7018:1;7006:13;7002:40;;7028:14;;;;;;;;;;;;;;7002:40;7056:11;7071:1;7056:16;7052:43;;7081:14;;;;;;;;;;;;;;7052:43;5183:1919;;;4741:2361;;;;;;;;;;;;:::o;4046:130:3:-;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;;8798:66:13;8785:2;8781:15;;;8777:88;2298:30:9;;;8765:101:13;2227:193:9;;8882: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;;;;;;9034:19:13;;9078:2;9069:12;;8905: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;;;;;;9034:19:13;;9078:2;9069:12;;8905: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;;;;;;9034:19:13;;9078:2;9069:12;;8905: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;;;;;;9034:19:13;;9078:2;9069:12;;8905:182;7676:42:8;;;;;;;;;;;;;7666:53;;;;;;7659:60;;7470:266;;;:::o;7564:166::-;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;774:154;860:42;853:5;849:54;842:5;839:65;829:93;;918:1;915;908:12;933:247;992:6;1045:2;1033:9;1024:7;1020:23;1016:32;1013:52;;;1061:1;1058;1051:12;1013:52;1100:9;1087:23;1119:31;1144:5;1119:31;:::i;1441:640::-;1557:6;1565;1618:2;1606:9;1597:7;1593:23;1589:32;1586:52;;;1634:1;1631;1624:12;1586:52;1674:9;1661:23;1707:18;1699:6;1696:30;1693:50;;;1739:1;1736;1729:12;1693:50;1762:22;;1815:4;1807:13;;1803:27;-1:-1:-1;1793:55:13;;1844:1;1841;1834:12;1793:55;1884:2;1871:16;1910:18;1902:6;1899:30;1896:50;;;1942:1;1939;1932:12;1896:50;1995:7;1990:2;1980:6;1977:1;1973:14;1969:2;1965:23;1961:32;1958:45;1955:65;;;2016:1;2013;2006:12;1955:65;2047:2;2039:11;;;;;2069:6;;-1:-1:-1;1441:640:13;-1:-1:-1;;;1441:640:13:o;2086:152::-;2172:20;;2201:31;2172:20;2201:31;:::i;2243:179::-;2310:20;;2370:26;2359:38;;2349:49;;2339:77;;2412:1;2409;2402:12;2427:184;2479:77;2476:1;2469:88;2576:4;2573:1;2566:15;2600:4;2597:1;2590:15;2616:251;2688:2;2682:9;;;2718:15;;2763:18;2748:34;;2784:22;;;2745:62;2742:88;;;2810:18;;:::i;:::-;2846:2;2839:22;2616:251;:::o;2872:334::-;2943:2;2937:9;2999:2;2989:13;;3004:66;2985:86;2973:99;;3102:18;3087:34;;3123:22;;;3084:62;3081:88;;;3149:18;;:::i;:::-;3185:2;3178:22;2872:334;;-1:-1:-1;2872:334:13:o;3211:1454::-;3263:5;3316:3;3309:4;3301:6;3297:17;3293:27;3283:55;;3334:1;3331;3324:12;3283:55;3374:6;3361:20;3404:18;3396:6;3393:30;3390:56;;;3426:18;;:::i;:::-;3472:6;3469:1;3465:14;3499:30;3523:4;3519:2;3515:13;3499:30;:::i;:::-;3565:19;;;3609:4;3641:15;;;3637:26;;;3600:14;;;;3675:15;;;3672:35;;;3703:1;3700;3693:12;3672:35;3739:4;3731:6;3727:17;3716:28;;3753:881;3769:6;3764:3;3761:15;3753:881;;;3857:3;3844:17;3893:18;3880:11;3877:35;3874:55;;;3925:1;3922;3915:12;3874:55;3952:24;;4011:2;4003:11;;3999:21;-1:-1:-1;3989:49:13;;4034:1;4031;4024:12;3989:49;4088:4;4084:2;4080:13;4067:27;4123:18;4113:8;4110:32;4107:58;;;4145:18;;:::i;:::-;4193:120;4307:4;4238:66;4231:4;4221:8;4217:19;4213:92;4209:103;4193:120;:::i;:::-;4326:25;;;4370:39;4378:17;;;4370:39;4367:48;-1:-1:-1;4364:68:13;;;4428:1;4425;4418:12;4364:68;4491:8;4486:2;4482;4478:11;4471:4;4462:7;4458:18;4445:55;4555:1;4548:4;4537:8;4528:7;4524:22;4520:33;4513:44;4582:7;4577:3;4570:20;;;;4619:4;4614:3;4610:14;4603:21;;3795:4;3790:3;3786:14;3779:21;;3753:881;;;4652:7;3211:1454;-1:-1:-1;;;;;;3211:1454:13:o;4670:1294::-;4934:6;4942;4950;4958;4966;4974;5027:3;5015:9;5006:7;5002:23;4998:33;4995:53;;;5044:1;5041;5034:12;4995:53;5067:47;5104:9;5067:47;:::i;:::-;5057:57;;5133:37;5166:2;5155:9;5151:18;5133:37;:::i;:::-;5123:47;;5221:2;5210:9;5206:18;5193:32;5248:18;5240:6;5237:30;5234:50;;;5280:1;5277;5270:12;5234:50;5303:59;5354:7;5345:6;5334:9;5330:22;5303:59;:::i;:::-;5293:69;;;5415:2;5404:9;5400:18;5387:32;5444:18;5434:8;5431:32;5428:52;;;5476:1;5473;5466:12;5428:52;5499:61;5552:7;5541:8;5530:9;5526:24;5499:61;:::i;:::-;5489:71;;;5613:3;5602:9;5598:19;5585:33;5643:18;5633:8;5630:32;5627:52;;;5675:1;5672;5665:12;5627:52;5698:61;5751:7;5740:8;5729:9;5725:24;5698:61;:::i;:::-;5688:71;;;5812:3;5801:9;5797:19;5784:33;5842:18;5832:8;5829:32;5826:52;;;5874:1;5871;5864:12;5826:52;5897:61;5950:7;5939:8;5928:9;5924:24;5897:61;:::i;:::-;5887:71;;;4670:1294;;;;;;;;:::o;6302:184::-;6354:77;6351:1;6344:88;6451:4;6448:1;6441:15;6475:4;6472:1;6465:15;6491:529;6578:6;6638:2;6626:9;6617:7;6613:23;6609:32;6653:2;6650:22;;;6668:1;6665;6658:12;6650:22;-1:-1:-1;6710:22:13;;:::i;:::-;6769:9;6756:23;6788:33;6813:7;6788:33;:::i;:::-;6830:22;;6904:2;6889:18;;6876:32;6917:33;6876:32;6917:33;:::i;:::-;6977:2;6966:14;;6959:31;6970:5;6491:529;-1:-1:-1;;;6491:529:13:o;8145:486::-;8242:6;8302:2;8290:9;8281:7;8277:23;8273:32;8317:2;8314:22;;;8332:1;8329;8322:12;8314:22;-1:-1:-1;8374:22:13;;:::i;:::-;8425:9;8419:16;8412:5;8405:31;8481:2;8470:9;8466:18;8460:25;8529:12;8520:7;8516:26;8507:7;8504:39;8494:67;;8557:1;8554;8547:12;9092:184;9144:77;9141:1;9134:88;9241:4;9238:1;9231:15;9265:4;9262:1;9255:15;9281:125;9346:9;;;9367:10;;;9364:36;;;9380:18;;:::i;9411:128::-;9478:9;;;9499:11;;;9496:37;;;9513:18;;:::i;9544:168::-;9617:9;;;9648;;9665:15;;;9659:22;;9645:37;9635:71;;9686:18;;:::i;9717:184::-;9769:77;9766:1;9759:88;9866:4;9863:1;9856:15;9890:4;9887:1;9880:15;9906:112;9938:1;9964;9954:35;;9969:18;;:::i;:::-;-1:-1:-1;10003:9:13;;9906:112::o;10023:120::-;10063:1;10089;10079:35;;10094:18;;:::i;:::-;-1:-1:-1;10128:9:13;;10023:120::o;10148:184::-;10200:77;10197:1;10190:88;10297:4;10294:1;10287:15;10321:4;10318:1;10311:15;10337:195;10376:3;10407:66;10400:5;10397:77;10394:103;;10477:18;;:::i;:::-;-1:-1:-1;10524:1:13;10513:13;;10337:195::o;10537:151::-;10627:4;10620:12;;;10606;;;10602:31;;10645:14;;10642:40;;;10662:18;;:::i;10693:375::-;10781:1;10799:5;10813:249;10834:1;10824:8;10821:15;10813:249;;;10884:4;10879:3;10875:14;10869:4;10866:24;10863:50;;;10893:18;;:::i;:::-;10943:1;10933:8;10929:16;10926:49;;;10957:16;;;;10926:49;11040:1;11036:16;;;;;10996:15;;10813:249;;;10693:375;;;;;;:::o;11073:1022::-;11122:5;11152:8;11142:80;;-1:-1:-1;11193:1:13;11207:5;;11142:80;11241:4;11231:76;;-1:-1:-1;11278:1:13;11292:5;;11231:76;11323:4;11341:1;11336:59;;;;11409:1;11404:174;;;;11316:262;;11336:59;11366:1;11357:10;;11380:5;;;11404:174;11441:3;11431:8;11428:17;11425:43;;;11448:18;;:::i;:::-;-1:-1:-1;;11504:1:13;11490:16;;11563:5;;11316:262;;11662:2;11652:8;11649:16;11643:3;11637:4;11634:13;11630:36;11624:2;11614:8;11611:16;11606:2;11600:4;11597:12;11593:35;11590:77;11587:203;;;-1:-1:-1;11699:19:13;;;11775:5;;11587:203;11822:102;11857:66;11847:8;11841:4;11822:102;:::i;:::-;12020:6;11952:66;11948:79;11939:7;11936:92;11933:118;;;12031:18;;:::i;:::-;12069:20;;11073:1022;-1:-1:-1;;;11073:1022:13:o;12100:131::-;12160:5;12189:36;12216:8;12210:4;12189:36;:::i

none