Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity 0.8.18;

import {RLPReader} from "contracts/RLPReader.sol";
import {StateProofVerifier as Verifier} from "../libs/StateProofVerifier.sol";

interface IBlockHashOracle {
    function get_block_hash(uint256 _number) external view returns (bytes32);
    function get_state_root(uint256 _number) external view returns (bytes32);
}

interface IRelayer {
    struct Message {
        address target;
        bytes data;
    }

    function relay(uint256 agent, Message[] calldata messages) external;
}

/// @title Message Digest Verifier
/// @author Curve Finance
contract MessageDigestVerifier {
    using RLPReader for bytes;
    using RLPReader for RLPReader.RLPItem;

    address constant BROADCASTER = 0x7BA33456EC00812C6B6BB6C1C3dfF579c34CC2cc;
    bytes32 constant BROADCASTER_HASH =
        keccak256(abi.encodePacked(BROADCASTER));

    uint256 constant OWNERSHIP_AGENT = 1;
    uint256 constant PARAMETER_AGENT = 2;
    uint256 constant EMERGENCY_AGENT = 4;

    address public immutable BLOCK_HASH_ORACLE;
    address public immutable RELAYER;

    mapping (uint256 => uint256) public nonce;

    constructor(address _block_hash_oracle, address _relayer) {
        BLOCK_HASH_ORACLE = _block_hash_oracle;
        RELAYER = _relayer;
    }

    /// Verify a message digest and optionally execute.
    /// @param _agent The agent which produced the execution digest. (1 = OWNERSHIP, 2 = PARAMETER, 4 = EMERGENCY)
    /// @param _messages The sequence of messages to execute.
    /// @param _block_header_rlp The block header of any block in which the gauge has its type set.
    /// @param _proof_rlp The state proof of the gauge types.
    function verifyMessagesByBlockHash(
        uint256 _agent,
        IRelayer.Message[] memory _messages,
        bytes memory _block_header_rlp,
        bytes memory _proof_rlp
    ) external {
        Verifier.BlockHeader memory block_header = Verifier.parseBlockHeader(
            _block_header_rlp
        );
        require(block_header.hash != bytes32(0)); // dev: invalid blockhash
        require(
            block_header.hash ==
                IBlockHashOracle(BLOCK_HASH_ORACLE).get_block_hash(
                    block_header.number
                )
        ); // dev: blockhash mismatch

        _verifyMessages(_agent, _messages, block_header.stateRootHash, _proof_rlp);
    }

    /// Verify a message digest and optionally execute.
    /// @param _agent The agent which produced the execution digest. (1 = OWNERSHIP, 2 = PARAMETER, 4 = EMERGENCY)
    /// @param _messages The sequence of messages to execute.
    /// @param _block_number Number of the block to use state root hash.
    /// @param _proof_rlp The state proof of the gauge types.
    function verifyMessagesByStateRoot(
        uint256 _agent,
        IRelayer.Message[] memory _messages,
        uint256 _block_number,
        bytes memory _proof_rlp
    ) external {
        bytes32 state_root = IBlockHashOracle(BLOCK_HASH_ORACLE).get_state_root(_block_number);

        _verifyMessages(_agent, _messages, state_root, _proof_rlp);
    }

    function _verifyMessages(
        uint256 _agent,
        IRelayer.Message[] memory _messages,
        bytes32 _state_root,
        bytes memory _proof_rlp
    ) internal {
        require(
            _agent == OWNERSHIP_AGENT ||
                _agent == PARAMETER_AGENT ||
                _agent == EMERGENCY_AGENT
        );
        require(_messages.length != 0);

        // convert _proof_rlp into a list of `RLPItem`s
        RLPReader.RLPItem[] memory proofs = _proof_rlp.toRlpItem().toList();
        require(proofs.length == 3); // dev: invalid number of proofs

        // 0th proof is the account proof for the Broadcaster contract
        Verifier.Account memory account = Verifier.extractAccountFromProof(
            BROADCASTER_HASH, // position of the account is the hash of its address
            _state_root,
            proofs[0].toList()
        );
        require(account.exists); // dev: Broadcaster account does not exist

        uint256 cur_nonce = nonce[_agent];

        Verifier.SlotValue memory slot = Verifier.extractSlotValueFromProof(
            keccak256(
                abi.encode(
                    keccak256( // self.digest[_agent][_chain_id][_nonce]
                        abi.encode(
                            keccak256( // self.digest[_agent][_chain_id]
                                abi.encode(
                                    keccak256(abi.encode(8, _agent)), // self.digest[_agent]
                                    block.chainid
                                )
                            ),
                            cur_nonce
                        )
                    )
                )
            ),
            account.storageRoot,
            proofs[1].toList()
        );

        require(slot.exists && slot.value != 0);
        require(keccak256(abi.encode(_messages)) == bytes32(slot.value));

        uint256 deadline = Verifier.extractSlotValueFromProof(
            keccak256(
                abi.encode(
                    keccak256( // self.deadline[_agent][_chain_id][_nonce]
                        abi.encode(
                            keccak256( // self.deadline[_agent][_chain_id]
                                abi.encode(
                                    keccak256(abi.encode(9, _agent)), // self.deadline[_agent]
                                    block.chainid
                                )
                            ),
                            cur_nonce
                        )
                    )
                )
            ),
            account.storageRoot,
            proofs[2].toList()
        ).value;

        ++nonce[_agent];
        if (block.timestamp <= deadline) {
            IRelayer(RELAYER).relay(_agent, _messages);
        }
    }
}

// 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.8.18;

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;
        }

        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
pragma solidity 0.8.18;

import {MerklePatriciaProofVerifier} from "contracts/libs/MerklePatriciaProofVerifier.sol";
import {RLPReader} from "contracts/RLPReader.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: MIT
pragma solidity 0.8.18;

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

/**
 * Copied from https://github.com/lidofinance/curve-merkle-oracle/blob/1033b3e/contracts/MerklePatriciaProofVerifier.sol
 * with minor code style-related modifications and solidity version constraints loosened.
 *
 * Copied from https://github.com/lorenzb/proveth/blob/c74b20e/onchain/ProvethVerifier.sol
 * with minor performance and code style-related modifications.
 */
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();
                    }
                } 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;
    }
}

{
  "evmVersion": "paris",
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "libraries": {
    "ScrvusdProver.sol": {}
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_block_hash_oracle","type":"address"},{"internalType":"address","name":"_relayer","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"BLOCK_HASH_ORACLE","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"RELAYER","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"nonce","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_agent","type":"uint256"},{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct IRelayer.Message[]","name":"_messages","type":"tuple[]"},{"internalType":"bytes","name":"_block_header_rlp","type":"bytes"},{"internalType":"bytes","name":"_proof_rlp","type":"bytes"}],"name":"verifyMessagesByBlockHash","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_agent","type":"uint256"},{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct IRelayer.Message[]","name":"_messages","type":"tuple[]"},{"internalType":"uint256","name":"_block_number","type":"uint256"},{"internalType":"bytes","name":"_proof_rlp","type":"bytes"}],"name":"verifyMessagesByStateRoot","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000e35a879e5efb4f1bb7f70dcf3250f2e19f096bd8000000000000000000000000e5de15a9c9bbedb4f5ec13b131e61245f2983a69

-----Decoded View---------------
Arg [0] : _block_hash_oracle (address): 0xe35A879E5EfB4F1Bb7F70dCF3250f2e19f096bd8
Arg [1] : _relayer (address): 0xE5De15A9C9bBedb4F5EC13B131E61245f2983A69

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000e35a879e5efb4f1bb7f70dcf3250f2e19f096bd8
Arg [1] : 000000000000000000000000e5de15a9c9bbedb4f5ec13b131e61245f2983a69

606:5284:3:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1015:42;;;;;;;;-1:-1:-1;;;;;178:32:4;;;160:51;;148:2;133:18;1015:42:3;;;;;;;;2759:355;;;;;;:::i;:::-;;:::i;:::-;;1063:32;;;;;1102:41;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;4174:25:4;;;4162:2;4147:18;1102:41:3;4028:177:4;1692:693:3;;;;;;:::i;:::-;;:::i;2759:355::-;2973:65;;-1:-1:-1;;;2973:65:3;;;;;4174:25:4;;;2952:18:3;;2990:17;-1:-1:-1;;;;;2973:50:3;;;;4147:18:4;;2973:65:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2952:86;;3049:58;3065:6;3073:9;3084:10;3096;3049:15;:58::i;:::-;2942:172;2759:355;;;;:::o;1692:693::-;1894:40;1937:66;1976:17;1937:25;:66::i;:::-;2021:17;;1894:109;;-1:-1:-1;2013:40:3;;;;;;2219:19;;;;;2147:109;;-1:-1:-1;;;2147:109:3;;;;;4174:25:4;;;;2164:17:3;-1:-1:-1;;;;;2147:50:3;;;;4147:18:4;;2147:109:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2110:17;;:146;2089:177;;;;;;2304:74;2320:6;2328:9;2339:12;:26;;;2367:10;3120:2768;923:1;3322:6;:25;:70;;;;965:1;3367:6;:25;3322:70;:115;;;;1007:1;3412:6;:25;3322:115;3301:146;;;;;;3465:9;:16;3485:1;3465:21;3457:30;;;;;;3554:33;3590:31;:22;:10;-1:-1:-1;;;;;;;;;;;;;;;;;1701:28:0;;;;;;;;1709:11;;1701:28;;1659:15;;;1701:28;;;;;;;;1515:221;3590:22:3;:29;:31::i;:::-;3554:67;;3639:6;:13;3656:1;3639:18;3631:27;;;;;;851:29;;-1:-1:-1;;;851:29:3;;;5399:66:4;3773:31:3;;3807:183;;5481:12:4;;851:29:3;;;;;;;;;;;;841:40;;;;;;3937:11;3962:18;:6;3969:1;3962:9;;;;;;;;:::i;:::-;;;;;;;:16;:18::i;:::-;3807:32;:183::i;:::-;4008:14;;3773:217;;-1:-1:-1;4000:23:3;;;;;;4077:17;4097:13;;;;;;;;;;;;4513:21;;4524:1;4513:21;;;5816:36:4;;;;5868:18;;;5861:34;;;4097:13:3;4077:17;4154:713;;5789:18:4;;4513:21:3;;;-1:-1:-1;;4513:21:3;;;;;;;;;4503:32;;4513:21;4503:32;;;;4455:188;;;6080:25:4;4596:13:3;6121:18:4;;;6114:34;6053:18;;4455:188:3;;;-1:-1:-1;;4455:188:3;;;;;;;;;4378:295;;4455:188;4378:295;;;;4338:400;;;6080:25:4;6121:18;;6114:34;;;6053:18;;4338:400:3;;;-1:-1:-1;;4338:400:3;;;;;;;;;4261:499;;4338:400;4261:499;;;;4229:549;;;4174:25:4;4147:18;4229:549:3;;;;;;;;;;;;4202:590;;;;;;4806:7;:19;;;4839:18;:6;4846:1;4839:9;;;;;;;;:::i;:18::-;4154:34;:713::i;:::-;4886:11;;4121:746;;-1:-1:-1;4886:30:3;;;;-1:-1:-1;4901:10:3;;;;:15;;4886:30;4878:39;;;;;;4979:4;:10;;;4971:19;;4956:9;4945:21;;;;;;;;:::i;:::-;;;;;;;;;;;;;4935:32;;;;;;:55;4927:64;;;;;;5384:21;;;5395:1;5384:21;;;5816:36:4;5868:18;;;5861:34;;;5002:16:3;;5021:719;;5789:18:4;;5384:21:3;;;-1:-1:-1;;5384:21:3;;;;;;;;;5374:32;;5384:21;5374:32;;;;5326:190;;;6080:25:4;5469:13:3;6121:18:4;;;6114:34;6053:18;;5326:190:3;;;-1:-1:-1;;5326:190:3;;;;;;;;;5247:299;;5326:190;5247:299;;;;5207:404;;;6080:25:4;6121:18;;6114:34;;;6053:18;;5207:404:3;;;-1:-1:-1;;5207:404:3;;;;;;;;;5128:505;;5207:404;5128:505;;;;5096:555;;;4174:25:4;4147:18;5096:555:3;;;;;;;;;;;;5069:596;;;;;;5679:7;:19;;;5712:18;:6;5719:1;5712:9;;;;;;;;:::i;5021:719::-;:725;;;5002:744;;5759:5;:13;5765:6;5759:13;;;;;;;;;;;;5757:15;;;;;:::i;:::-;;;;-1:-1:-1;5786:15:3;:27;-1:-1:-1;5782:100:3;;5829:42;;-1:-1:-1;;;5829:42:3;;-1:-1:-1;;;;;5838:7:3;5829:23;;;;:42;;5853:6;;5861:9;;5829:42;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5782:100;3291:2597;;;;;3120:2768;;;;:::o;1570:610:2:-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1701:28:0;;;;;;;;1709:11;;1701:28;;1659:15;;;1701:28;;;;-1:-1:-1;;;;;1768:36:2;;3590:29:3;:31::i;1768:36:2:-;1726:78;;544:2;1823:12;:19;:44;1815:53;;;;;;1910:46;:12;449:1;1910:37;;;;;;;;:::i;:::-;;;;;;;:44;:46::i;:::-;1879:20;;;:78;1983:33;;:42;;:12;;495:1;;1983:33;;;;;;:::i;:42::-;1967:13;;;:58;2054:36;;:45;;:12;;544:2;;2054:36;;;;;;:::i;:45::-;2035:16;;;:64;-1:-1:-1;2123:26:2;;;;;;;;;;2109:40;;-1:-1:-1;2035:6:2;1570:610::o;2948:519:0:-;3008:16;3044:12;3051:4;3044:6;:12::i;:::-;3036:21;;;;;;3068:13;3084:14;3093:4;3084:8;:14::i;:::-;3068:30;;3108:23;3148:5;3134:20;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;3134:20:0;;;;;;;;;;;;;;;;3108:46;;3165:14;3196:27;3211:4;:11;;;3196:14;:27::i;:::-;3182:4;:11;;;:41;;;;:::i;:::-;3165:58;-1:-1:-1;3233:15:0;;3258:179;3282:5;3278:1;:9;3258:179;;;3318:19;3330:6;3318:11;:19::i;:::-;3308:29;;3363:24;;;;;;;;3371:7;3363:24;;;;3380:6;3363:24;;;3351:6;3358:1;3351:9;;;;;;;;:::i;:::-;;;;;;;;;;:36;3410:16;3419:7;3410:6;:16;:::i;:::-;3401:25;-1:-1:-1;3289:3:0;;;;:::i;:::-;;;;3258:179;;;-1:-1:-1;3454:6:0;;2948:519;-1:-1:-1;;;;;2948:519:0:o;2461:942:2:-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2706:25:2;2734:147;2793:14;2838:12;2821:30;;;;;;9114:19:4;;9158:2;9149:12;;8985:182;2821:30:2;;;;;;;;;;;;;2865:6;2734:45;:147::i;:::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2706:175:2;;-1:-1:-1;2929:12:2;:19;2952:1;2929:24;2925:69;;2976:7;-1:-1:-1;2969:14:2;;-1:-1:-1;2969:14:2;2925:69;3004:37;3044:33;:24;:12;-1:-1:-1;;;;;;;;;;;;;;;;;1701:28:0;;;;;;;;1709:11;;1701:28;;1659:15;;;1701:28;;;;;;;;1515:221;3044:33:2;3004:73;;3095:10;:17;3116:1;3095:22;3087:31;;;;;;3146:4;3129:21;;3176:13;;:22;;:10;;3129:14;;3176:13;;;;:::i;:22::-;3160:13;;;:38;3226:13;;:22;;:10;;3237:1;;3226:13;;;;;;:::i;:22::-;3208:15;;;:40;3288:13;;:22;;:10;;3299:1;;3288:13;;;;;;:::i;:22::-;3258:19;;;:53;3348:13;;:22;;:10;;3359:1;;3348:13;;;;;;:::i;:22::-;3321:16;;;:50;-1:-1:-1;3321:7:2;-1:-1:-1;;2461:942:2;;;;;;:::o;3657:593::-;-1:-1:-1;;;;;;;;;;;;;;;;;3865:26:2;3894:146;3953:16;4000:9;3983:27;;;;;;9114:19:4;;9158:2;9149:12;;8985:182;3894:146:2;-1:-1:-1;;;;;;;;;;;;;;;;;3865:175:2;;-1:-1:-1;4088:20:2;;:25;4084:137;;4144:4;4129:19;;-1:-1:-1;;;;;;;;;;;;;;;;;1701:28:0;;;;;;;;1709:11;;1701:28;;1659:15;;;1701:28;;;;4176:34:2;;:32;:34::i;:::-;4162:11;;;:48;4084:137;4238:5;3657:593;-1:-1:-1;;;;;3657:593:2:o;6051:467:0:-;6138:8;;6111:7;;6138:12;;;;:30;;-1:-1:-1;6154:8:0;;6166:2;-1:-1:-1;6154:14:0;6138:30;6130:39;;;;;;6181:14;6197:11;6212:21;6228:4;6212:15;:21::i;:::-;6301:13;;6180:53;;-1:-1:-1;6180:53:0;-1:-1:-1;6397:2:0;6389:11;;6386:92;;;6454:2;6450:12;;;6445:3;6441:22;6429:35;;6386:92;6505:6;6051:467;-1:-1:-1;;;;6051:467:0:o;3571:321::-;3651:8;;3631:4;;3651:13;;3647:31;;-1:-1:-1;3673:5:0;;3571:321;-1:-1:-1;3571:321:0:o;3647:31::-;3727:11;;;;3788:13;;3689:11;3780:22;;330:4;3826:24;;3822:42;;;-1:-1:-1;3859:5:0;;3571:321;-1:-1:-1;;;3571:321:0:o;3822:42::-;-1:-1:-1;3881:4:0;;3571:321;-1:-1:-1;;;3571:321:0:o;7346:424::-;7430:8;;7407:7;;7430:13;;7426:27;;-1:-1:-1;7452:1:0;;7346:424;-1:-1:-1;7346:424:0:o;7426:27::-;7464:13;7491:15;7523:27;7538:4;:11;;;7523:14;:27::i;:::-;7509:4;:11;;;:41;;;;:::i;:::-;7491:59;;7560:14;7591:4;:8;;;7577:4;:11;;;:22;;;;:::i;:::-;7560:39;;7609:132;7626:6;7616:7;:16;7609:132;;;7668:20;7680:7;7668:11;:20::i;:::-;7658:30;;:7;:30;:::i;:::-;7648:40;-1:-1:-1;7723:7:0;;;;:::i;:::-;;;;7609:132;;;-1:-1:-1;7758:5:0;;7346:424;-1:-1:-1;;;7346:424:0:o;9134:581::-;9278:13;;9196:7;;9270:22;;241:4;9316:26;;9312:397;;;-1:-1:-1;9365:1:0;;9134:581;-1:-1:-1;;9134:581:0:o;9312:397::-;286:4;9387:25;;;:83;;-1:-1:-1;330:4:0;9417:25;;;;;:52;;-1:-1:-1;373:4:0;9446:23;;9417:52;9383:326;;;-1:-1:-1;9493:1:0;;9134:581;-1:-1:-1;;9134:581:0:o;9383:326::-;330:4;9515:24;;9511:198;;;9601:21;9621:1;286:4;9601:21;:::i;:::-;9592:31;;;;:5;:31;:::i;:::-;:35;;9626:1;9592:35;:::i;9511:198::-;9674:19;9692:1;373:4;9674:19;:::i;7819:1263::-;7985:13;;7878:7;;;;7977:22;;241:4;8023:26;;8019:1032;;;8075:1;8065:11;;8019:1032;;;286:4;8097:25;;8093:958;;;8148:26;241:4;8148:5;:26;:::i;:::-;:30;;8177:1;8148:30;:::i;:::-;8138:40;;8093:958;;;330:4;8199:24;;8195:856;;;8292:4;8285:5;8281:16;8371:1;8363:6;8359:14;8349:24;;8510:7;8506:2;8502:16;8497:3;8493:26;8484:6;8478:13;8474:46;8607:1;8598:7;8594:15;8585:7;8581:29;8570:40;;;;8195:856;;;373:4;8644:23;;8640:411;;;8693:24;330:4;8693:5;:24;:::i;8640:411::-;8805:4;8798:5;8794:16;8849:1;8841:6;8837:14;8827:24;;8920:7;8916:2;8912:16;8907:3;8903:26;8894:6;8888:13;8884:46;9024:1;9015:7;9011:15;9002:7;8998:29;8987:40;;;;8640:411;-1:-1:-1;9068:7:0;7819:1263;-1:-1:-1;;7819:1263:0:o;1330:5641:1:-;1481:18;1511:19;1533:23;1548:4;1554:1;1533:14;:23::i;:::-;1511:45;;1566:20;1601;1631:31;1673:33;-1:-1:-1;;;;;;;;;;;;;;;;;;;1673:33:1;1721:5;:12;1737:1;1721:17;1717:273;;1866:66;1834:98;;1809:137;;;;;;-1:-1:-1;;1967:12:1;;;1977:1;1967:12;;;;;;;;;-1:-1:-1;1960:19:1;;-1:-1:-1;;;1960:19:1;1717:273;2058:9;2053:4912;2077:5;:12;2073:1;:16;2053:4912;;;2351:6;;:50;;;;;2373:28;:5;2379:1;2373:8;;;;;;;;:::i;:::-;;;;;;;4158:11:0;;;;4193:8;;4268:19;;;4054:272;2373:28:1;2361:8;:40;;2351:50;2347:97;;;2421:8;;;2347:97;2558:6;;;;;:48;;;2584:22;2597:5;2603:1;2597:8;;;;;;;;:::i;:::-;;;;;;;2584:12;:22::i;:::-;2568:12;:38;;2558:48;2554:95;;;2626:8;;;2554:95;2775:17;:5;2781:1;2775:8;;;;;;;;:::i;:17::-;2768:24;;2811:4;:11;2826:1;2811:16;2807:4148;;2890:11;2919:20;2977:85;3027:17;:4;3032:1;3027:7;;;;;;;;:::i;:::-;;;;;;;:15;:17::i;:::-;2977:28;:85::i;:::-;2957:105;;-1:-1:-1;2957:105:1;-1:-1:-1;3081:20:1;3104:128;3145:12;3179:6;2957:105;3104:19;:128::i;:::-;3081:151;-1:-1:-1;3250:28:1;3081:151;3250:28;;:::i;:::-;;;3316:7;:14;3301:12;:29;3297:994;;;4105:1;4090:5;:12;:16;;;;:::i;:::-;4086:1;:20;4082:149;;;4200:8;;;4082:149;4270:1;4260:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4260:12:1;;4253:19;;;;;;;;;;;;;3297:994;4313:6;4309:1175;;;4402:1;4387:5;:12;:16;;;;:::i;:::-;4383:1;:20;4379:144;;;4492:8;;;4379:144;4564:6;:13;4549:12;:28;4545:102;;;4622:1;4612:12;;4545:102;4680:4;4685:1;4680:7;;;;;;;;:::i;:::-;;;;;;;4669:18;;4716;:8;:16;:18::i;:::-;4709:25;;;;;;;;;;;;;4309:1175;4874:1;4859:5;:12;:16;;;;:::i;:::-;4854:1;:21;4850:138;;4957:8;;;4850:138;5015:16;:4;5020:1;5015:7;;;;;;;;:::i;:::-;;;;;;;:14;:16::i;:::-;5010:456;;5202:26;:4;5207:1;5202:7;;;;;;;;:::i;:::-;;;;;;;:24;:26::i;:::-;5187:41;;5010:456;;;5416:27;:4;5421:1;5416:7;;;;;;;;:::i;:27::-;5401:42;;5010:456;2829:2669;;;2807:4148;;;5508:4;:11;5523:2;5508:17;5504:1451;;5597:6;:13;5581:12;:29;5577:1364;;5724:12;5745:6;5752:12;5745:20;;;;;;;;:::i;:::-;;;;;;;;-1:-1:-1;5788:17:1;5804:1;5788:17;;:::i;:::-;;;5841:2;5831:6;:12;;;5827:146;;5942:8;;;5827:146;5999:34;6020:4;6025:6;6020:12;;;;;;;;;;:::i;:::-;;;;;;;5999:20;:34::i;:::-;5995:556;;;6119:1;6104:5;:12;:16;;;;:::i;:::-;6099:1;:21;6095:157;;6217:8;;;6095:157;-1:-1:-1;;6285:12:1;;;6295:1;6285:12;;;;;;;;;-1:-1:-1;6278:19:1;;-1:-1:-1;;;;;6278:19:1;5995:556;6331:21;:4;6336:6;6331:12;;;;;;;;;;:::i;:21::-;6326:225;;6395:31;:4;6400:6;6395:12;;;;;;;;;;:::i;:31::-;6380:46;;6326:225;;;6496:32;:4;6501:6;6496:12;;;;;;;;;;:::i;:32::-;6481:47;;6326:225;5612:957;5577:1364;;;6764:1;6749:5;:12;:16;;;;:::i;:::-;6744:1;:21;6740:135;;6844:8;;;6740:135;6904:18;:4;6909:2;6904:8;;;;;;;;:::i;:18::-;6897:25;;;;;;;;;;5577:1364;2091:3;;;;:::i;:::-;;;;2053:4912;;;;1501:5470;;;;;1330:5641;;;;;:::o;2392:281:0:-;2461:7;2470;2489:14;2506:27;2521:4;:11;;;2506:14;:27::i;:::-;2489:44;;2543:14;2574:6;2560:4;:11;;;:20;;;;:::i;:::-;2543:37;;2590:11;2615:6;2604:4;:8;;;:17;;;;:::i;:::-;2654:6;;2590:31;;-1:-1:-1;2392:281:0;;-1:-1:-1;;;;2392:281:0:o;8980:845:1:-;9091:20;9148:1;9131:7;:14;:18;9123:27;;;;;;9161:14;9178:7;:14;9195:1;9178:18;;;;:::i;:::-;9161:35;;9229:6;9214:11;:21;;9206:30;;;;;;9246:21;9256:11;9246:21;;:::i;:::-;;;9298:6;9288:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;9288:17:1;-1:-1:-1;9278:27:1;-1:-1:-1;9315:21:1;9368:11;9351:418;9385:20;9399:6;9385:11;:20;:::i;:::-;9381:1;:24;9351:418;;;9433:5;9437:1;9433;:5;:::i;:::-;9442:1;9433:10;9429:298;;9542:1;9523:7;9531:5;9535:1;9531;:5;:::i;:::-;9523:14;;;;;;;;:::i;:::-;;;;;;;;;9517:21;;:26;;;;9547:3;9516:34;9488:80;;9463:7;9471:13;9463:22;;;;;;;;:::i;:::-;;;;:105;-1:-1:-1;;;;;9463:105:1;;;;;;;;;9429:298;;;9686:1;9667:7;9675:5;9679:1;9675;:5;:::i;:::-;9667:14;;;;;;;;:::i;:::-;;;;;;;;;9661:21;;:26;;;;9691:3;9660:34;9632:80;;9607:7;9615:13;9607:22;;;;;;;;:::i;:::-;;;;:105;-1:-1:-1;;;;;9607:105:1;;;;;;;;;9429:298;9740:18;9757:1;9740:18;;:::i;:::-;;-1:-1:-1;9407:6:1;9412:1;9407:6;;:::i;:::-;;;9351:418;;;;9803:7;:14;9786:13;:31;9779:39;;;;:::i;:::-;9113:712;;8980:845;;;;:::o;7536:280::-;7625:7;7659:2;7648:4;:8;;;:13;7644:166;;;4158:11:0;;;;4193:8;;4268:19;;7684:24:1;7677:31;7536:280;-1:-1:-1;;7536:280:1:o;7644:166::-;4158:11:0;;;;4193:8;;4268:19;;7756:42:1;;;;;;9114:19:4;;9158:2;9149:12;;8985:182;7756:42:1;;;;;;;;;;;;;7746:53;;;;;;7739:60;;7536:280;;;:::o;6859:379:0:-;6952:8;;6920:12;;6944:21;;;;;;6977:14;6993:11;7008:21;7024:4;7008:15;:21::i;:::-;6976:53;;;;7039:19;7071:3;7061:14;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7061:14:0;-1:-1:-1;7039:36:0;-1:-1:-1;7149:4:0;7145:17;;7182:26;7187:6;7145:17;7204:3;7182:4;:26::i;:::-;-1:-1:-1;7225:6:0;6859:379;-1:-1:-1;;;;6859:379:0:o;8177:797:1:-;8273:11;8286:20;8343:1;8326:7;:14;:18;8318:27;;;;;;8355:20;8400:1;8385:7;8393:1;8385:10;;;;;;;;:::i;:::-;;;;;;;;8379:22;;8405:3;8378:30;;-1:-1:-1;8418:19:1;8451:17;;;8447:458;;-1:-1:-1;8522:5:1;;-1:-1:-1;8498:1:1;8447:458;;;8548:12;8564:1;8548:17;8544:361;;-1:-1:-1;8619:5:1;;-1:-1:-1;8595:1:1;8544:361;;;8645:12;8661:1;8645:17;8641:264;;-1:-1:-1;8716:4:1;;-1:-1:-1;8692:1:1;8641:264;;;8741:12;8757:1;8741:17;8737:168;;-1:-1:-1;8788:1:1;;-1:-1:-1;8788:1:1;8737:168;8922:6;8930:36;8945:7;8954:11;8930:14;:36::i;:::-;8914:53;;;;;;8177:797;;;:::o;9831:351::-;9964:7;;10002:156;10029:9;;10014:12;10018:8;10014:1;:12;:::i;:::-;:24;:41;;;;;10046:2;:9;10042:1;:13;10014:41;10002:156;;;10100:2;10103:1;10100:5;;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;;10100:5:1;10080:2;10083:12;10087:8;10083:1;:12;:::i;:::-;10080:16;;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;;10080:16:1;:25;10076:72;;10132:1;-1:-1:-1;10125:8:1;;10076:72;10057:3;;;;:::i;:::-;;;;10002:156;;4484:270:0;4554:7;4574:14;4590:11;4605:21;4621:4;4605:15;:21::i;:::-;4693:22;;;4484:270;-1:-1:-1;;;;4484:270:0:o;7822:349:1:-;7939:8;;7919:4;;7951:1;7939:13;7935:56;;-1:-1:-1;7975:5:1;;7822:349;-1:-1:-1;7822:349:1:o;7935:56::-;-1:-1:-1;8034:11:1;;;8091:13;8000:7;8083:22;8136:4;8131:9;;7822:349::o;9873:768:0:-;9954:3;9961:1;9954:8;9950:21;;9873:768;;;:::o;9950:21::-;410:2;10035:16;;10028:194;;10125:10;;10112:24;;10164:16;410:2;10131:3;10164:16;:::i;:::-;;-1:-1:-1;10194:17:0;410:2;10194:17;;:::i;:::-;;-1:-1:-1;10053:16:0;410:2;10053:16;;:::i;:::-;;;10028:194;;;10236:7;;10232:403;;10343:12;10383:1;10364:15;10376:3;410:2;10364:15;:::i;:::-;10358:22;;:3;:22;:::i;:::-;:26;;;;:::i;:::-;10444:10;;10519:11;;10515:22;;10456:9;;10440:26;10589:21;10576:35;;-1:-1:-1;10232:403:0;9873:768;;;:::o;222:127:4:-;283:10;278:3;274:20;271:1;264:31;314:4;311:1;304:15;338:4;335:1;328:15;354:257;426:4;420:11;;;458:17;;505:18;490:34;;526:22;;;487:62;484:88;;;552:18;;:::i;:::-;588:4;581:24;354:257;:::o;616:275::-;687:2;681:9;752:2;733:13;;-1:-1:-1;;729:27:4;717:40;;787:18;772:34;;808:22;;;769:62;766:88;;;834:18;;:::i;:::-;870:2;863:22;616:275;;-1:-1:-1;616:275:4:o;896:530::-;938:5;991:3;984:4;976:6;972:17;968:27;958:55;;1009:1;1006;999:12;958:55;1045:6;1032:20;1071:18;1067:2;1064:26;1061:52;;;1093:18;;:::i;:::-;1137:55;1180:2;1161:13;;-1:-1:-1;;1157:27:4;1186:4;1153:38;1137:55;:::i;:::-;1217:2;1208:7;1201:19;1263:3;1256:4;1251:2;1243:6;1239:15;1235:26;1232:35;1229:55;;;1280:1;1277;1270:12;1229:55;1345:2;1338:4;1330:6;1326:17;1319:4;1310:7;1306:18;1293:55;1393:1;1368:16;;;1386:4;1364:27;1357:38;;;;1372:7;896:530;-1:-1:-1;;;896:530:4:o;1431:1666::-;1492:5;1545:3;1538:4;1530:6;1526:17;1522:27;1512:55;;1563:1;1560;1553:12;1512:55;1599:6;1586:20;1625:4;1648:18;1685:2;1681;1678:10;1675:36;;;1691:18;;:::i;:::-;1737:2;1734:1;1730:10;1760:28;1784:2;1780;1776:11;1760:28;:::i;:::-;1822:15;;;1892;;;1888:24;;;1853:12;;;;1924:15;;;1921:35;;;1952:1;1949;1942:12;1921:35;1988:2;1980:6;1976:15;1965:26;;2000:1068;2016:6;2011:3;2008:15;2000:1068;;;2102:3;2089:17;2138:2;2125:11;2122:19;2119:109;;;2182:1;2211:2;2207;2200:14;2119:109;2251:24;;2298:4;2326:12;;;-1:-1:-1;;2322:26:4;2318:35;-1:-1:-1;2315:125:4;;;2394:1;2423:2;2419;2412:14;2315:125;2466:22;;:::i;:::-;2529:11;;;2516:25;-1:-1:-1;;;;;2576:33:4;;2564:46;;2554:144;;2652:1;2681:2;2677;2670:14;2554:144;2711:22;;2775:11;;;2762:25;;2803:16;;;2800:109;;;2861:1;2891:3;2886;2879:16;2800:109;2945:49;2990:3;2985:2;2974:8;2970:2;2966:17;2962:26;2945:49;:::i;:::-;2929:14;;;2922:73;3008:18;;-1:-1:-1;;2033:12:4;;;;3046;;;;2000:1068;;;3086:5;1431:1666;-1:-1:-1;;;;;;;;1431:1666:4:o;3102:736::-;3247:6;3255;3263;3271;3324:3;3312:9;3303:7;3299:23;3295:33;3292:53;;;3341:1;3338;3331:12;3292:53;3377:9;3364:23;3354:33;;3438:2;3427:9;3423:18;3410:32;3461:18;3502:2;3494:6;3491:14;3488:34;;;3518:1;3515;3508:12;3488:34;3541:68;3601:7;3592:6;3581:9;3577:22;3541:68;:::i;:::-;3531:78;;3656:2;3645:9;3641:18;3628:32;3618:42;;3713:2;3702:9;3698:18;3685:32;3669:48;;3742:2;3732:8;3729:16;3726:36;;;3758:1;3755;3748:12;3726:36;;3781:51;3824:7;3813:8;3802:9;3798:24;3781:51;:::i;:::-;3771:61;;;3102:736;;;;;;;:::o;3843:180::-;3902:6;3955:2;3943:9;3934:7;3930:23;3926:32;3923:52;;;3971:1;3968;3961:12;3923:52;-1:-1:-1;3994:23:4;;3843:180;-1:-1:-1;3843:180:4:o;4210:866::-;4364:6;4372;4380;4388;4441:3;4429:9;4420:7;4416:23;4412:33;4409:53;;;4458:1;4455;4448:12;4409:53;4494:9;4481:23;4471:33;;4555:2;4544:9;4540:18;4527:32;4578:18;4619:2;4611:6;4608:14;4605:34;;;4635:1;4632;4625:12;4605:34;4658:68;4718:7;4709:6;4698:9;4694:22;4658:68;:::i;:::-;4648:78;;4779:2;4768:9;4764:18;4751:32;4735:48;;4808:2;4798:8;4795:16;4792:36;;;4824:1;4821;4814:12;4792:36;4847:51;4890:7;4879:8;4868:9;4864:24;4847:51;:::i;:::-;4837:61;;4951:2;4940:9;4936:18;4923:32;4907:48;;4980:2;4970:8;4967:16;4964:36;;;4996:1;4993;4986:12;5081:184;5151:6;5204:2;5192:9;5183:7;5179:23;5175:32;5172:52;;;5220:1;5217;5210:12;5172:52;-1:-1:-1;5243:16:4;;5081:184;-1:-1:-1;5081:184:4:o;5504:127::-;5565:10;5560:3;5556:20;5553:1;5546:31;5596:4;5593:1;5586:15;5620:4;5617:1;5610:15;6341:1250;6401:3;6439:5;6433:12;6466:6;6461:3;6454:19;6492:4;6533:2;6528:3;6524:12;6558:11;6585;6578:18;;6635:6;6632:1;6628:14;6621:5;6617:26;6605:38;;6677:2;6670:5;6666:14;6698:1;6719;6729:836;6745:6;6740:3;6737:15;6729:836;;;6810:16;;;6798:29;;6850:13;;6920:9;;-1:-1:-1;;;;;6916:35:4;6903:49;;6991:11;;6985:18;6886:4;7023:13;;;7016:25;;;7070:19;;7109:13;;;7102:31;;;7157:1;;7171:165;7187:8;7182:3;7179:17;7171:165;;;7293:22;;;7289:31;;7283:38;7262:14;;;7278:2;7258:23;7251:71;7206:12;;;;7171:165;;;7385:19;;;7359:2;7381:28;;;7374:39;;;7543:12;;;;7475:2;7452:17;;;-1:-1:-1;;7448:31:4;7438:42;;;7434:51;;;;-1:-1:-1;;7508:15:4;;;;6771:1;6762:11;6729:836;;;-1:-1:-1;7581:4:4;;6341:1250;-1:-1:-1;;;;;;;;6341:1250:4:o;7596:318::-;7825:2;7814:9;7807:21;7788:4;7845:63;7904:2;7893:9;7889:18;7881:6;7845:63;:::i;8189:127::-;8250:10;8245:3;8241:20;8238:1;8231:31;8281:4;8278:1;8271:15;8305:4;8302:1;8295:15;8321:135;8360:3;8381:17;;;8378:43;;8401:18;;:::i;:::-;-1:-1:-1;8448:1:4;8437:13;;8321:135::o;8461:389::-;8718:6;8707:9;8700:25;8761:2;8756;8745:9;8741:18;8734:30;8681:4;8781:63;8840:2;8829:9;8825:18;8817:6;8781:63;:::i;8855:125::-;8920:9;;;8941:10;;;8938:36;;;8954:18;;:::i;9172:151::-;9262:4;9255:12;;;9241;;;9237:31;;9280:14;;9277:40;;;9297:18;;:::i;9328:128::-;9395:9;;;9416:11;;;9413:37;;;9430:18;;:::i;9461:168::-;9534:9;;;9565;;9582:15;;;9576:22;;9562:37;9552:71;;9603:18;;:::i;9634:127::-;9695:10;9690:3;9686:20;9683:1;9676:31;9726:4;9723:1;9716:15;9750:4;9747:1;9740:15;9766:112;9798:1;9824;9814:35;;9829:18;;:::i;:::-;-1:-1:-1;9863:9:4;;9766:112::o;9883:120::-;9923:1;9949;9939:35;;9954:18;;:::i;:::-;-1:-1:-1;9988:9:4;;9883:120::o;10008:127::-;10069:10;10064:3;10060:20;10057:1;10050:31;10100:4;10097:1;10090:15;10124:4;10121:1;10114:15;10140:422;10229:1;10272:5;10229:1;10286:270;10307:7;10297:8;10294:21;10286:270;;;10366:4;10362:1;10358:6;10354:17;10348:4;10345:27;10342:53;;;10375:18;;:::i;:::-;10425:7;10415:8;10411:22;10408:55;;;10445:16;;;;10408:55;10524:22;;;;10484:15;;;;10286:270;;;10290:3;10140:422;;;;;:::o;10567:806::-;10616:5;10646:8;10636:80;;-1:-1:-1;10687:1:4;10701:5;;10636:80;10735:4;10725:76;;-1:-1:-1;10772:1:4;10786:5;;10725:76;10817:4;10835:1;10830:59;;;;10903:1;10898:130;;;;10810:218;;10830:59;10860:1;10851:10;;10874:5;;;10898:130;10935:3;10925:8;10922:17;10919:43;;;10942:18;;:::i;:::-;-1:-1:-1;;10998:1:4;10984:16;;11013:5;;10810:218;;11112:2;11102:8;11099:16;11093:3;11087:4;11084:13;11080:36;11074:2;11064:8;11061:16;11056:2;11050:4;11047:12;11043:35;11040:77;11037:159;;;-1:-1:-1;11149:19:4;;;11181:5;;11037:159;11228:34;11253:8;11247:4;11228:34;:::i;:::-;11298:6;11294:1;11290:6;11286:19;11277:7;11274:32;11271:58;;;11309:18;;:::i;:::-;11347:20;;10567:806;-1:-1:-1;;;10567:806:4:o;11378:131::-;11438:5;11467:36;11494:8;11488:4;11467:36;:::i

ipfs://fcb99e82a1ff843107a0cf45461e7d1d5af84375c906965f7668ee9ee65f703e