{
  "address": "0xcbD35a9b849342AD34a71e072D9947D4AFb4E164",
  "abi": [
    {
      "inputs": [],
      "name": "PACKET_SIGNATURE",
      "outputs": [
        {
          "internalType": "bytes32",
          "name": "",
          "type": "bytes32"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "bytes",
          "name": "data",
          "type": "bytes"
        },
        {
          "internalType": "uint16",
          "name": "srcChain",
          "type": "uint16"
        },
        {
          "internalType": "uint256",
          "name": "sizeOfSrcAddress",
          "type": "uint256"
        },
        {
          "internalType": "bytes32",
          "name": "ulnAddress",
          "type": "bytes32"
        }
      ],
      "name": "getPacket",
      "outputs": [
        {
          "components": [
            {
              "internalType": "uint16",
              "name": "srcChainId",
              "type": "uint16"
            },
            {
              "internalType": "uint16",
              "name": "dstChainId",
              "type": "uint16"
            },
            {
              "internalType": "uint64",
              "name": "nonce",
              "type": "uint64"
            },
            {
              "internalType": "address",
              "name": "dstAddress",
              "type": "address"
            },
            {
              "internalType": "bytes",
              "name": "srcAddress",
              "type": "bytes"
            },
            {
              "internalType": "bytes32",
              "name": "ulnAddress",
              "type": "bytes32"
            },
            {
              "internalType": "bytes",
              "name": "payload",
              "type": "bytes"
            }
          ],
          "internalType": "struct LayerZeroPacket.Packet",
          "name": "",
          "type": "tuple"
        }
      ],
      "stateMutability": "pure",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "bytes32",
          "name": "hashRoot",
          "type": "bytes32"
        },
        {
          "internalType": "uint256[]",
          "name": "receiptSlotIndex",
          "type": "uint256[]"
        },
        {
          "internalType": "uint256",
          "name": "logIndex",
          "type": "uint256"
        },
        {
          "internalType": "bytes[]",
          "name": "proof",
          "type": "bytes[]"
        }
      ],
      "name": "getVerifyLog",
      "outputs": [
        {
          "components": [
            {
              "internalType": "bytes32",
              "name": "contractAddress",
              "type": "bytes32"
            },
            {
              "internalType": "bytes32",
              "name": "topicZeroSig",
              "type": "bytes32"
            },
            {
              "internalType": "bytes",
              "name": "data",
              "type": "bytes"
            }
          ],
          "internalType": "struct MPTValidatorV2.ULNLog",
          "name": "",
          "type": "tuple"
        }
      ],
      "stateMutability": "pure",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "bytes32",
          "name": "_receiptsRoot",
          "type": "bytes32"
        },
        {
          "internalType": "bytes",
          "name": "_transactionProof",
          "type": "bytes"
        },
        {
          "internalType": "uint256",
          "name": "_remoteAddressSize",
          "type": "uint256"
        }
      ],
      "name": "validateProof",
      "outputs": [
        {
          "components": [
            {
              "internalType": "uint16",
              "name": "srcChainId",
              "type": "uint16"
            },
            {
              "internalType": "uint16",
              "name": "dstChainId",
              "type": "uint16"
            },
            {
              "internalType": "uint64",
              "name": "nonce",
              "type": "uint64"
            },
            {
              "internalType": "address",
              "name": "dstAddress",
              "type": "address"
            },
            {
              "internalType": "bytes",
              "name": "srcAddress",
              "type": "bytes"
            },
            {
              "internalType": "bytes32",
              "name": "ulnAddress",
              "type": "bytes32"
            },
            {
              "internalType": "bytes",
              "name": "payload",
              "type": "bytes"
            }
          ],
          "internalType": "struct LayerZeroPacket.Packet",
          "name": "packet",
          "type": "tuple"
        }
      ],
      "stateMutability": "pure",
      "type": "function"
    }
  ],
  "transactionHash": "0x127e091eb99c3a5dd4570ba702e9941638c4faddbc2533bec701fec35ac531b4",
  "receipt": {
    "to": null,
    "from": "0x9F403140Bc0574D7d36eA472b82DAa1Bbd4eF327",
    "contractAddress": "0xcbD35a9b849342AD34a71e072D9947D4AFb4E164",
    "transactionIndex": 17,
    "gasUsed": "1276088",
    "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
    "blockHash": "0xea75eff744bd1cb8cb302a124721086809f7770697cc4c6dffb326c332b1a687",
    "transactionHash": "0x127e091eb99c3a5dd4570ba702e9941638c4faddbc2533bec701fec35ac531b4",
    "logs": [],
    "blockNumber": 12662538,
    "cumulativeGasUsed": "5715118",
    "status": 1,
    "byzantium": true
  },
  "args": [],
  "numDeployments": 1,
  "solcInputHash": "191256a60eaf0ca67de509f7a44f428a",
  "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"PACKET_SIGNATURE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"uint16\",\"name\":\"srcChain\",\"type\":\"uint16\"},{\"internalType\":\"uint256\",\"name\":\"sizeOfSrcAddress\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"ulnAddress\",\"type\":\"bytes32\"}],\"name\":\"getPacket\",\"outputs\":[{\"components\":[{\"internalType\":\"uint16\",\"name\":\"srcChainId\",\"type\":\"uint16\"},{\"internalType\":\"uint16\",\"name\":\"dstChainId\",\"type\":\"uint16\"},{\"internalType\":\"uint64\",\"name\":\"nonce\",\"type\":\"uint64\"},{\"internalType\":\"address\",\"name\":\"dstAddress\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"srcAddress\",\"type\":\"bytes\"},{\"internalType\":\"bytes32\",\"name\":\"ulnAddress\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"internalType\":\"struct LayerZeroPacket.Packet\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"hashRoot\",\"type\":\"bytes32\"},{\"internalType\":\"uint256[]\",\"name\":\"receiptSlotIndex\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256\",\"name\":\"logIndex\",\"type\":\"uint256\"},{\"internalType\":\"bytes[]\",\"name\":\"proof\",\"type\":\"bytes[]\"}],\"name\":\"getVerifyLog\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"contractAddress\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"topicZeroSig\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"internalType\":\"struct MPTValidatorV2.ULNLog\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"_receiptsRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"_transactionProof\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"_remoteAddressSize\",\"type\":\"uint256\"}],\"name\":\"validateProof\",\"outputs\":[{\"components\":[{\"internalType\":\"uint16\",\"name\":\"srcChainId\",\"type\":\"uint16\"},{\"internalType\":\"uint16\",\"name\":\"dstChainId\",\"type\":\"uint16\"},{\"internalType\":\"uint64\",\"name\":\"nonce\",\"type\":\"uint64\"},{\"internalType\":\"address\",\"name\":\"dstAddress\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"srcAddress\",\"type\":\"bytes\"},{\"internalType\":\"bytes32\",\"name\":\"ulnAddress\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"internalType\":\"struct LayerZeroPacket.Packet\",\"name\":\"packet\",\"type\":\"tuple\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/libraries/EVMValidatorV2.sol\":\"EVMValidatorV2\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":30000},\"remappings\":[]},\"sources\":{\"@layerzerolabs/proof-evm/contracts/ILayerZeroValidationLibrary.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\n\\npragma solidity >=0.7.0;\\npragma abicoder v2;\\n\\nimport \\\"./utility/LayerZeroPacket.sol\\\";\\n\\ninterface ILayerZeroValidationLibrary {\\n    function validateProof(bytes32 blockData, bytes calldata _data, uint _remoteAddressSize) external returns (LayerZeroPacket.Packet memory packet);\\n}\\n\",\"keccak256\":\"0x95c6e0790b93e54be2fdd579b85541bae7b0258ff96bfc68825c3b9bc804368b\",\"license\":\"BUSL-1.1\"},\"@layerzerolabs/proof-evm/contracts/MPTValidatorV2.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\n\\npragma solidity 0.7.6;\\npragma abicoder v2;\\n\\nimport \\\"./utility/LayerZeroPacket.sol\\\";\\nimport \\\"./utility/Buffer.sol\\\";\\nimport \\\"./ILayerZeroValidationLibrary.sol\\\";\\nimport \\\"./utility/UltraLightNodeEVMDecoder.sol\\\";\\n\\ncontract MPTValidatorV2 is ILayerZeroValidationLibrary {\\n    using RLPDecode for RLPDecode.RLPItem;\\n    using RLPDecode for RLPDecode.Iterator;\\n    using Buffer for Buffer.buffer;\\n    using SafeMath for uint;\\n\\n    bytes32 public constant PACKET_SIGNATURE = 0xe8d23d927749ec8e512eb885679c2977d57068839d8cca1a85685dbbea0648f6;\\n\\n    struct ULNLog{\\n        bytes32 contractAddress;\\n        bytes32 topicZeroSig;\\n        bytes data;\\n    }\\n\\n    function validateProof(bytes32 _receiptsRoot, bytes calldata _transactionProof, uint _remoteAddressSize) external pure override returns (LayerZeroPacket.Packet memory packet) {\\n        (uint16 remoteChainId, bytes[] memory proof, uint[] memory receiptSlotIndex, uint logIndex) = abi.decode(_transactionProof, (uint16, bytes[], uint[], uint));\\n\\n        ULNLog memory log = _getVerifiedLog(_receiptsRoot, receiptSlotIndex, logIndex, proof);\\n        require(log.topicZeroSig == PACKET_SIGNATURE, \\\"ProofLib: packet not recognized\\\"); //data\\n\\n        return _getPacket(log.data, remoteChainId, _remoteAddressSize, log.contractAddress);\\n    }\\n\\n    function _getVerifiedLog(bytes32 hashRoot, uint[] memory paths, uint logIndex, bytes[] memory proof) internal pure returns(ULNLog memory) {\\n        require(paths.length == proof.length, \\\"ProofLib: invalid proof size\\\");\\n\\n        RLPDecode.RLPItem memory item;\\n        bytes memory proofBytes;\\n\\n        for (uint i = 0; i < proof.length; i++) {\\n            proofBytes = proof[i];\\n            require(hashRoot == keccak256(proofBytes), \\\"ProofLib: invalid hashlink\\\");\\n            item = RLPDecode.toRlpItem(proofBytes).safeGetItemByIndex(paths[i]);\\n            if (i < proof.length - 1) hashRoot = bytes32(item.toUint());\\n        }\\n\\n        // burning status + gasUsed + logBloom\\n        RLPDecode.RLPItem memory logItem = item.typeOffset().safeGetItemByIndex(3);\\n        RLPDecode.Iterator memory it =  logItem.safeGetItemByIndex(logIndex).iterator();\\n        ULNLog memory log;\\n        log.contractAddress = bytes32(it.next().toUint());\\n        log.topicZeroSig = bytes32(it.next().getItemByIndex(0).toUint());\\n        log.data = it.next().toBytes();\\n\\n        return log;\\n    }\\n\\n    // profiling and test\\n    function getVerifyLog(bytes32 hashRoot, uint[] memory receiptSlotIndex, uint logIndex, bytes[] memory proof) external pure returns(ULNLog memory){\\n        return _getVerifiedLog(hashRoot, receiptSlotIndex, logIndex, proof);\\n    }\\n\\n    function getPacket(bytes memory data, uint16 srcChain, uint sizeOfSrcAddress, bytes32 ulnAddress) external pure returns(LayerZeroPacket.Packet memory) {\\n        return _getPacket(data, srcChain, sizeOfSrcAddress, ulnAddress);\\n    }\\n\\n    function _getPacket(\\n        bytes memory data,\\n        uint16 srcChain,\\n        uint sizeOfSrcAddress,\\n        bytes32 ulnAddress\\n    ) internal pure returns (LayerZeroPacket.Packet memory) {\\n        uint16 dstChainId;\\n        address dstAddress;\\n        uint size;\\n        uint64 nonce;\\n\\n        // The log consists of the destination chain id and then a bytes payload\\n        //      0--------------------------------------------31\\n        // 0   |  destination chain id\\n        // 32  |  defines bytes array\\n        // 64  |\\n        // 96  |  bytes array size\\n        // 128 |  payload\\n        assembly {\\n            dstChainId := mload(add(data, 32))\\n            size := mload(add(data, 96)) /// size of the byte array\\n            nonce := mload(add(data, 104)) // offset to convert to uint64  128  is index -24\\n            dstAddress := mload(add(data, sub(add(128, sizeOfSrcAddress), 4))) // offset to convert to address 12 -8\\n        }\\n\\n        Buffer.buffer memory srcAddressBuffer;\\n        srcAddressBuffer.init(sizeOfSrcAddress);\\n        srcAddressBuffer.writeRawBytes(0, data, 136, sizeOfSrcAddress); // 128 + 8\\n\\n        uint payloadSize = size.sub(20).sub(sizeOfSrcAddress);\\n        Buffer.buffer memory payloadBuffer;\\n        payloadBuffer.init(payloadSize);\\n        payloadBuffer.writeRawBytes(0, data, sizeOfSrcAddress.add(156), payloadSize); // 148 + 8\\n        return LayerZeroPacket.Packet(srcChain, dstChainId, nonce, dstAddress, srcAddressBuffer.buf, ulnAddress, payloadBuffer.buf);\\n    }\\n}\\n\",\"keccak256\":\"0x9b011ae6660a0e5ae36168239d079a6755754635b018a4280bc966bb8c8e62ac\",\"license\":\"BUSL-1.1\"},\"@layerzerolabs/proof-evm/contracts/utility/Buffer.sol\":{\"content\":\"// SPDX-License-Identifier: BSD-2-Clause\\n// https://github.com/ensdomains/buffer\\n\\npragma solidity ^0.7.0;\\n\\n/**\\n * @dev A library for working with mutable byte buffers in Solidity.\\n *\\n * Byte buffers are mutable and expandable, and provide a variety of primitives\\n * for writing to them. At any time you can fetch a bytes object containing the\\n * current contents of the buffer. The bytes object should not be stored between\\n * operations, as it may change due to resizing of the buffer.\\n */\\nlibrary Buffer {\\n    /**\\n     * @dev Represents a mutable buffer. Buffers have a current value (buf) and\\n     *      a capacity. The capacity may be longer than the current value, in\\n     *      which case it can be extended without the need to allocate more memory.\\n     */\\n    struct buffer {\\n        bytes buf;\\n        uint capacity;\\n    }\\n\\n    /**\\n     * @dev Initializes a buffer with an initial capacity.a co\\n     * @param buf The buffer to initialize.\\n     * @param capacity The number of bytes of space to allocate the buffer.\\n     * @return The buffer, for chaining.\\n     */\\n    function init(buffer memory buf, uint capacity) internal pure returns (buffer memory) {\\n        if (capacity % 32 != 0) {\\n            capacity += 32 - (capacity % 32);\\n        }\\n        // Allocate space for the buffer data\\n        buf.capacity = capacity;\\n        assembly {\\n            let ptr := mload(0x40)\\n            mstore(buf, ptr)\\n            mstore(ptr, 0)\\n            mstore(0x40, add(32, add(ptr, capacity)))\\n        }\\n        return buf;\\n    }\\n\\n\\n    /**\\n     * @dev Writes a byte string to a buffer. Resizes if doing so would exceed\\n     *      the capacity of the buffer.\\n     * @param buf The buffer to append to.\\n     * @param off The start offset to write to.\\n     * @param rawData The data to append.\\n     * @param len The number of bytes to copy.\\n     * @return The original buffer, for chaining.\\n     */\\n    function writeRawBytes(\\n        buffer memory buf,\\n        uint off,\\n        bytes memory rawData,\\n        uint offData,\\n        uint len\\n    ) internal pure returns (buffer memory) {\\n        if (off + len > buf.capacity) {\\n            resize(buf, max(buf.capacity, len + off) * 2);\\n        }\\n\\n        uint dest;\\n        uint src;\\n        assembly {\\n            // Memory address of the buffer data\\n            let bufptr := mload(buf)\\n            // Length of existing buffer data\\n            let buflen := mload(bufptr)\\n            // Start address = buffer address + offset + sizeof(buffer length)\\n            dest := add(add(bufptr, 32), off)\\n            // Update buffer length if we're extending it\\n            if gt(add(len, off), buflen) {\\n                mstore(bufptr, add(len, off))\\n            }\\n            src := add(rawData, offData)\\n        }\\n\\n        // Copy word-length chunks while possible\\n        for (; len >= 32; len -= 32) {\\n            assembly {\\n                mstore(dest, mload(src))\\n            }\\n            dest += 32;\\n            src += 32;\\n        }\\n\\n        // Copy remaining bytes\\n        uint mask = 256**(32 - len) - 1;\\n        assembly {\\n            let srcpart := and(mload(src), not(mask))\\n            let destpart := and(mload(dest), mask)\\n            mstore(dest, or(destpart, srcpart))\\n        }\\n\\n        return buf;\\n    }\\n\\n    /**\\n     * @dev Writes a byte string to a buffer. Resizes if doing so would exceed\\n     *      the capacity of the buffer.\\n     * @param buf The buffer to append to.\\n     * @param off The start offset to write to.\\n     * @param data The data to append.\\n     * @param len The number of bytes to copy.\\n     * @return The original buffer, for chaining.\\n     */\\n    function write(buffer memory buf, uint off, bytes memory data, uint len) internal pure returns (buffer memory) {\\n        require(len <= data.length);\\n\\n        if (off + len > buf.capacity) {\\n            resize(buf, max(buf.capacity, len + off) * 2);\\n        }\\n\\n        uint dest;\\n        uint src;\\n        assembly {\\n        // Memory address of the buffer data\\n            let bufptr := mload(buf)\\n        // Length of existing buffer data\\n            let buflen := mload(bufptr)\\n        // Start address = buffer address + offset + sizeof(buffer length)\\n            dest := add(add(bufptr, 32), off)\\n        // Update buffer length if we're extending it\\n            if gt(add(len, off), buflen) {\\n                mstore(bufptr, add(len, off))\\n            }\\n            src := add(data, 32)\\n        }\\n\\n        // Copy word-length chunks while possible\\n        for (; len >= 32; len -= 32) {\\n            assembly {\\n                mstore(dest, mload(src))\\n            }\\n            dest += 32;\\n            src += 32;\\n        }\\n\\n        // Copy remaining bytes\\n        uint mask = 256**(32 - len) - 1;\\n        assembly {\\n            let srcpart := and(mload(src), not(mask))\\n            let destpart := and(mload(dest), mask)\\n            mstore(dest, or(destpart, srcpart))\\n        }\\n\\n        return buf;\\n    }\\n\\n    function append(buffer memory buf, bytes memory data) internal pure returns (buffer memory) {\\n        return write(buf, buf.buf.length, data, data.length);\\n    }\\n\\n    function resize(buffer memory buf, uint capacity) private pure {\\n        bytes memory oldbuf = buf.buf;\\n        init(buf, capacity);\\n        append(buf, oldbuf);\\n    }\\n\\n    function max(uint a, uint b) private pure returns (uint) {\\n        if (a > b) {\\n            return a;\\n        }\\n        return b;\\n    }\\n}\\n\",\"keccak256\":\"0x4fb738133f8453cd2d28d530ee66b3b45a7969ba6372c008bcb0479fa3f6e8f9\",\"license\":\"BSD-2-Clause\"},\"@layerzerolabs/proof-evm/contracts/utility/LayerZeroPacket.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\n\\npragma solidity 0.7.6;\\n\\nimport \\\"@openzeppelin/contracts/math/SafeMath.sol\\\";\\n\\nlibrary LayerZeroPacket {\\n    struct Packet {\\n        uint16 srcChainId;\\n        uint16 dstChainId;\\n        uint64 nonce;\\n        address dstAddress;\\n        bytes srcAddress;\\n        bytes32 ulnAddress;\\n        bytes payload;\\n    }\\n}\\n\",\"keccak256\":\"0x56febca8fff31450f2ca79625d8a9a4ca43aab9cb33f48e181553756aae51f7f\",\"license\":\"BUSL-1.1\"},\"@layerzerolabs/proof-evm/contracts/utility/RLPDecode.sol\":{\"content\":\"// SPDX-License-Identifier: Apache-2.0\\n// https://github.com/hamdiallam/solidity-rlp\\n\\npragma solidity ^0.7.0;\\n\\nlibrary RLPDecode {\\n    uint8 constant STRING_SHORT_START = 0x80;\\n    uint8 constant STRING_LONG_START = 0xb8;\\n    uint8 constant LIST_SHORT_START = 0xc0;\\n    uint8 constant LIST_LONG_START = 0xf8;\\n    uint8 constant WORD_SIZE = 32;\\n\\n    struct RLPItem {\\n        uint len;\\n        uint memPtr;\\n    }\\n\\n    struct Iterator {\\n        RLPItem item; // Item that's being iterated over.\\n        uint nextPtr; // Position of the next item in the list.\\n    }\\n\\n    /*\\n     * @dev Returns the next element in the iteration. Reverts if it has not next element.\\n     * @param self The iterator.\\n     * @return The next element in the iteration.\\n     */\\n    function next(Iterator memory self) internal pure returns (RLPItem memory) {\\n        require(hasNext(self), \\\"RLPDecoder iterator has no next\\\");\\n\\n        uint ptr = self.nextPtr;\\n        uint itemLength = _itemLength(ptr);\\n        self.nextPtr = ptr + itemLength;\\n\\n        return RLPItem(itemLength, ptr);\\n    }\\n\\n    /*\\n     * @dev Returns true if the iteration has more elements.\\n     * @param self The iterator.\\n     * @return true if the iteration has more elements.\\n     */\\n    function hasNext(Iterator memory self) internal pure returns (bool) {\\n        RLPItem memory item = self.item;\\n        return self.nextPtr < item.memPtr + item.len;\\n    }\\n\\n    /*\\n     * @param item RLP encoded bytes\\n     */\\n\\n    function toRlpItem(bytes memory item) internal pure returns (RLPItem memory) {\\n        uint memPtr;\\n        assembly {\\n            memPtr := add(item, 0x20)\\n        }\\n        // offset the pointer if the first byte\\n\\n        uint8 byte0;\\n        assembly {\\n            byte0 := byte(0, mload(memPtr))\\n        }\\n        uint len = item.length;\\n        if (byte0 < LIST_SHORT_START) {\\n            assembly {\\n                memPtr := add(memPtr, 0x01)\\n            }\\n            len -= 1;\\n        }\\n        return RLPItem(len, memPtr);\\n    }\\n\\n    /*\\n     * @dev Create an iterator. Reverts if item is not a list.\\n     * @param self The RLP item.\\n     * @return An 'Iterator' over the item.\\n     */\\n    function iterator(RLPItem memory self) internal pure returns (Iterator memory) {\\n        require(isList(self), \\\"RLPDecoder iterator is not list\\\");\\n\\n        uint ptr = self.memPtr + _payloadOffset(self.memPtr);\\n        return Iterator(self, ptr);\\n    }\\n\\n    /*\\n     * @param item RLP encoded bytes\\n     */\\n    function rlpLen(RLPItem memory item) internal pure returns (uint) {\\n        return item.len;\\n    }\\n\\n    /*\\n     * @param item RLP encoded bytes\\n     */\\n    function payloadLen(RLPItem memory item) internal pure returns (uint) {\\n        return item.len - _payloadOffset(item.memPtr);\\n    }\\n\\n    /*\\n     * @param item RLP encoded list in bytes\\n     */\\n    function toList(RLPItem memory item) internal pure returns (RLPItem[] memory) {\\n        require(isList(item), \\\"RLPDecoder iterator is not a list\\\");\\n\\n        uint items = numItems(item);\\n        RLPItem[] memory result = new RLPItem[](items);\\n\\n        uint memPtr = item.memPtr + _payloadOffset(item.memPtr);\\n        uint dataLen;\\n        for (uint i = 0; i < items; i++) {\\n            dataLen = _itemLength(memPtr);\\n            result[i] = RLPItem(dataLen, memPtr);\\n            memPtr = memPtr + dataLen;\\n        }\\n\\n        return result;\\n    }\\n\\n    /*\\n     * @param get the RLP item by index. save gas.\\n     */\\n    function getItemByIndex(RLPItem memory item, uint idx) internal pure returns (RLPItem memory) {\\n        require(isList(item), \\\"RLPDecoder iterator is not a list\\\");\\n\\n        uint memPtr = item.memPtr + _payloadOffset(item.memPtr);\\n        uint dataLen;\\n        for (uint i = 0; i < idx; i++) {\\n            dataLen = _itemLength(memPtr);\\n            memPtr = memPtr + dataLen;\\n        }\\n        dataLen = _itemLength(memPtr);\\n        return RLPItem(dataLen, memPtr);\\n    }\\n\\n\\n    /*\\n     * @param get the RLP item by index. save gas.\\n     */\\n    function safeGetItemByIndex(RLPItem memory item, uint idx) internal pure returns (RLPItem memory) {\\n        require(isList(item), \\\"RLPDecoder iterator is not a list\\\");\\n\\n        uint endPtr = item.memPtr + item.len;\\n\\n        uint memPtr = item.memPtr + _payloadOffset(item.memPtr);\\n        uint dataLen;\\n        for (uint i = 0; i < idx; i++) {\\n            dataLen = _itemLength(memPtr);\\n            memPtr = memPtr + dataLen;\\n        }\\n        dataLen = _itemLength(memPtr);\\n\\n        require(memPtr + dataLen <= endPtr, \\\"RLP item overflow\\\");\\n        return RLPItem(dataLen, memPtr);\\n    }\\n\\n    /*\\n     * @param offset the receipt bytes item\\n     */\\n    function typeOffset(RLPItem memory item) internal pure returns (RLPItem memory) {\\n        uint offset = _payloadOffset(item.memPtr);\\n        uint8 byte0;\\n        uint memPtr = item.memPtr;\\n        uint len = item.len;\\n        assembly {\\n            memPtr := add(memPtr, offset)\\n            byte0 := byte(0, mload(memPtr))\\n        }\\n        if (byte0 < LIST_SHORT_START) {\\n            assembly {\\n                memPtr := add(memPtr, 0x01)\\n            }\\n            len -= 1;\\n        }\\n        return RLPItem(len, memPtr);\\n    }\\n\\n    // @return indicator whether encoded payload is a list. negate this function call for isData.\\n    function isList(RLPItem memory item) internal pure returns (bool) {\\n        if (item.len == 0) return false;\\n\\n        uint8 byte0;\\n        uint memPtr = item.memPtr;\\n        assembly {\\n            byte0 := byte(0, mload(memPtr))\\n        }\\n\\n        if (byte0 < LIST_SHORT_START) return false;\\n        return true;\\n    }\\n\\n    /** RLPItem conversions into data types **/\\n\\n    // @returns raw rlp encoding in bytes\\n    function toRlpBytes(RLPItem memory item) internal pure returns (bytes memory) {\\n        bytes memory result = new bytes(item.len);\\n        if (result.length == 0) return result;\\n\\n        uint ptr;\\n        assembly {\\n            ptr := add(0x20, result)\\n        }\\n\\n        copy(item.memPtr, ptr, item.len);\\n        return result;\\n    }\\n\\n    // any non-zero byte except \\\"0x80\\\" is considered true\\n    function toBoolean(RLPItem memory item) internal pure returns (bool) {\\n        require(item.len == 1, \\\"RLPDecoder toBoolean invalid length\\\");\\n        uint result;\\n        uint memPtr = item.memPtr;\\n        assembly {\\n            result := byte(0, mload(memPtr))\\n        }\\n\\n        // SEE Github Issue #5.\\n        // Summary: Most commonly used RLP libraries (i.e Geth) will encode\\n        // \\\"0\\\" as \\\"0x80\\\" instead of as \\\"0\\\". We handle this edge case explicitly\\n        // here.\\n        if (result == 0 || result == STRING_SHORT_START) {\\n            return false;\\n        } else {\\n            return true;\\n        }\\n    }\\n\\n    function toAddress(RLPItem memory item) internal pure returns (address) {\\n        // 1 byte for the length prefix\\n        require(item.len == 21, \\\"RLPDecoder toAddress invalid length\\\");\\n\\n        return address(toUint(item));\\n    }\\n\\n    function toUint(RLPItem memory item) internal pure returns (uint) {\\n        require(item.len > 0 && item.len <= 33, \\\"RLPDecoder toUint invalid length\\\");\\n\\n        uint offset = _payloadOffset(item.memPtr);\\n        uint len = item.len - offset;\\n\\n        uint result;\\n        uint memPtr = item.memPtr + offset;\\n        assembly {\\n            result := mload(memPtr)\\n\\n            // shift to the correct location if necessary\\n            if lt(len, 32) {\\n                result := div(result, exp(256, sub(32, len)))\\n            }\\n        }\\n\\n        return result;\\n    }\\n\\n    // enforces 32 byte length\\n    function toUintStrict(RLPItem memory item) internal pure returns (uint) {\\n        // one byte prefix\\n        require(item.len == 33, \\\"RLPDecoder toUintStrict invalid length\\\");\\n\\n        uint result;\\n        uint memPtr = item.memPtr + 1;\\n        assembly {\\n            result := mload(memPtr)\\n        }\\n\\n        return result;\\n    }\\n\\n    function toBytes(RLPItem memory item) internal pure returns (bytes memory) {\\n        require(item.len > 0, \\\"RLPDecoder toBytes invalid length\\\");\\n\\n        uint offset = _payloadOffset(item.memPtr);\\n        uint len = item.len - offset; // data length\\n        bytes memory result = new bytes(len);\\n\\n        uint destPtr;\\n        assembly {\\n            destPtr := add(0x20, result)\\n        }\\n\\n        copy(item.memPtr + offset, destPtr, len);\\n        return result;\\n    }\\n\\n    /*\\n     * Private Helpers\\n     */\\n\\n    // @return number of payload items inside an encoded list.\\n    function numItems(RLPItem memory item) internal pure returns (uint) {\\n        if (item.len == 0) return 0;\\n\\n        uint count = 0;\\n        uint currPtr = item.memPtr + _payloadOffset(item.memPtr);\\n        uint endPtr = item.memPtr + item.len;\\n        while (currPtr < endPtr) {\\n            currPtr = currPtr + _itemLength(currPtr); // skip over an item\\n            count++;\\n        }\\n\\n        return count;\\n    }\\n\\n    // @return entire rlp item byte length\\n    function _itemLength(uint memPtr) private pure returns (uint) {\\n        uint itemLen;\\n        uint byte0;\\n        assembly {\\n            byte0 := byte(0, mload(memPtr))\\n        }\\n\\n        if (byte0 < STRING_SHORT_START) itemLen = 1;\\n        else if (byte0 < STRING_LONG_START) itemLen = byte0 - STRING_SHORT_START + 1;\\n        else if (byte0 < LIST_SHORT_START) {\\n            assembly {\\n                let byteLen := sub(byte0, 0xb7) // # of bytes the actual length is\\n                memPtr := add(memPtr, 1) // skip over the first byte\\n\\n                /* 32 byte word size */\\n                let dataLen := div(mload(memPtr), exp(256, sub(32, byteLen))) // right shifting to get the len\\n                itemLen := add(dataLen, add(byteLen, 1))\\n            }\\n        } else if (byte0 < LIST_LONG_START) {\\n            itemLen = byte0 - LIST_SHORT_START + 1;\\n        } else {\\n            assembly {\\n                let byteLen := sub(byte0, 0xf7)\\n                memPtr := add(memPtr, 1)\\n\\n                let dataLen := div(mload(memPtr), exp(256, sub(32, byteLen))) // right shifting to the correct length\\n                itemLen := add(dataLen, add(byteLen, 1))\\n            }\\n        }\\n\\n        return itemLen;\\n    }\\n\\n    // @return number of bytes until the data\\n    function _payloadOffset(uint memPtr) private pure returns (uint) {\\n        uint byte0;\\n        assembly {\\n            byte0 := byte(0, mload(memPtr))\\n        }\\n\\n        if (byte0 < STRING_SHORT_START) return 0;\\n        else if (byte0 < STRING_LONG_START || (byte0 >= LIST_SHORT_START && byte0 < LIST_LONG_START)) return 1;\\n        else if (byte0 < LIST_SHORT_START)\\n            // being explicit\\n            return byte0 - (STRING_LONG_START - 1) + 1;\\n        else return byte0 - (LIST_LONG_START - 1) + 1;\\n    }\\n\\n    /*\\n     * @param src Pointer to source\\n     * @param dest Pointer to destination\\n     * @param len Amount of memory to copy from the source\\n     */\\n    function copy(\\n        uint src,\\n        uint dest,\\n        uint len\\n    ) private pure {\\n        if (len == 0) return;\\n\\n        // copy as many word sizes as possible\\n        for (; len >= WORD_SIZE; len -= WORD_SIZE) {\\n            assembly {\\n                mstore(dest, mload(src))\\n            }\\n\\n            src += WORD_SIZE;\\n            dest += WORD_SIZE;\\n        }\\n\\n        // left over bytes. Mask is used to remove unwanted bytes from the word\\n        uint mask = 256**(WORD_SIZE - len) - 1;\\n        assembly {\\n            let srcpart := and(mload(src), not(mask)) // zero out src\\n            let destpart := and(mload(dest), mask) // retrieve the bytes\\n            mstore(dest, or(destpart, srcpart))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x3a0d47bc8517b4e7c9ee5382f6037921b2542c438898d79f4dd2fadca21ede95\",\"license\":\"Apache-2.0\"},\"@layerzerolabs/proof-evm/contracts/utility/UltraLightNodeEVMDecoder.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\n\\npragma solidity ^0.7.0;\\npragma abicoder v2;\\n\\nimport \\\"./RLPDecode.sol\\\";\\n\\nlibrary UltraLightNodeEVMDecoder {\\n    using RLPDecode for RLPDecode.RLPItem;\\n    using RLPDecode for RLPDecode.Iterator;\\n\\n    struct Log {\\n        address contractAddress;\\n        bytes32 topicZero;\\n        bytes data;\\n    }\\n\\n    function getReceiptLog(bytes memory data, uint logIndex) internal pure returns (Log memory) {\\n        RLPDecode.Iterator memory it = RLPDecode.toRlpItem(data).iterator();\\n        uint idx;\\n        while (it.hasNext()) {\\n            if (idx == 3) {\\n                return toReceiptLog(it.next().getItemByIndex(logIndex).toRlpBytes());\\n            } else it.next();\\n            idx++;\\n        }\\n        revert(\\\"no log index in receipt\\\");\\n    }\\n\\n    function toReceiptLog(bytes memory data) internal pure returns (Log memory) {\\n        RLPDecode.Iterator memory it = RLPDecode.toRlpItem(data).iterator();\\n        Log memory log;\\n\\n        uint idx;\\n        while (it.hasNext()) {\\n            if (idx == 0) {\\n                log.contractAddress = it.next().toAddress();\\n            } else if (idx == 1) {\\n                RLPDecode.RLPItem memory item = it.next().getItemByIndex(0);\\n                log.topicZero = bytes32(item.toUint());\\n            } else if (idx == 2) log.data = it.next().toBytes();\\n            else it.next();\\n            idx++;\\n        }\\n        return log;\\n    }\\n}\\n\",\"keccak256\":\"0xa5a921e346276438893241fb9719b074bed6e215d37e372f91b2712cb9f46567\",\"license\":\"BUSL-1.1\"},\"@openzeppelin/contracts/math/SafeMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.7.0;\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations with added overflow\\n * checks.\\n *\\n * Arithmetic operations in Solidity wrap on overflow. This can easily result\\n * in bugs, because programmers usually assume that an overflow raises an\\n * error, which is the standard behavior in high level programming languages.\\n * `SafeMath` restores this intuition by reverting the transaction when an\\n * operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeMath {\\n    /**\\n     * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n     *\\n     * _Available since v3.4._\\n     */\\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n        uint256 c = a + b;\\n        if (c < a) return (false, 0);\\n        return (true, c);\\n    }\\n\\n    /**\\n     * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n     *\\n     * _Available since v3.4._\\n     */\\n    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n        if (b > a) return (false, 0);\\n        return (true, a - b);\\n    }\\n\\n    /**\\n     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n     *\\n     * _Available since v3.4._\\n     */\\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n        // benefit is lost if 'b' is also tested.\\n        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n        if (a == 0) return (true, 0);\\n        uint256 c = a * b;\\n        if (c / a != b) return (false, 0);\\n        return (true, c);\\n    }\\n\\n    /**\\n     * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n     *\\n     * _Available since v3.4._\\n     */\\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n        if (b == 0) return (false, 0);\\n        return (true, a / b);\\n    }\\n\\n    /**\\n     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n     *\\n     * _Available since v3.4._\\n     */\\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n        if (b == 0) return (false, 0);\\n        return (true, a % b);\\n    }\\n\\n    /**\\n     * @dev Returns the addition of two unsigned integers, reverting on\\n     * overflow.\\n     *\\n     * Counterpart to Solidity's `+` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - Addition cannot overflow.\\n     */\\n    function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n        uint256 c = a + b;\\n        require(c >= a, \\\"SafeMath: addition overflow\\\");\\n        return c;\\n    }\\n\\n    /**\\n     * @dev Returns the subtraction of two unsigned integers, reverting on\\n     * overflow (when the result is negative).\\n     *\\n     * Counterpart to Solidity's `-` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - Subtraction cannot overflow.\\n     */\\n    function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n        require(b <= a, \\\"SafeMath: subtraction overflow\\\");\\n        return a - b;\\n    }\\n\\n    /**\\n     * @dev Returns the multiplication of two unsigned integers, reverting on\\n     * overflow.\\n     *\\n     * Counterpart to Solidity's `*` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - Multiplication cannot overflow.\\n     */\\n    function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n        if (a == 0) return 0;\\n        uint256 c = a * b;\\n        require(c / a == b, \\\"SafeMath: multiplication overflow\\\");\\n        return c;\\n    }\\n\\n    /**\\n     * @dev Returns the integer division of two unsigned integers, reverting on\\n     * division by zero. The result is rounded towards zero.\\n     *\\n     * Counterpart to Solidity's `/` operator. Note: this function uses a\\n     * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n     * uses an invalid opcode to revert (consuming all remaining gas).\\n     *\\n     * Requirements:\\n     *\\n     * - The divisor cannot be zero.\\n     */\\n    function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n        require(b > 0, \\\"SafeMath: division by zero\\\");\\n        return a / b;\\n    }\\n\\n    /**\\n     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n     * reverting when dividing by zero.\\n     *\\n     * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n     * opcode (which leaves remaining gas untouched) while Solidity uses an\\n     * invalid opcode to revert (consuming all remaining gas).\\n     *\\n     * Requirements:\\n     *\\n     * - The divisor cannot be zero.\\n     */\\n    function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n        require(b > 0, \\\"SafeMath: modulo by zero\\\");\\n        return a % b;\\n    }\\n\\n    /**\\n     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n     * overflow (when the result is negative).\\n     *\\n     * CAUTION: This function is deprecated because it requires allocating memory for the error\\n     * message unnecessarily. For custom revert reasons use {trySub}.\\n     *\\n     * Counterpart to Solidity's `-` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - Subtraction cannot overflow.\\n     */\\n    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n        require(b <= a, errorMessage);\\n        return a - b;\\n    }\\n\\n    /**\\n     * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n     * division by zero. The result is rounded towards zero.\\n     *\\n     * CAUTION: This function is deprecated because it requires allocating memory for the error\\n     * message unnecessarily. For custom revert reasons use {tryDiv}.\\n     *\\n     * Counterpart to Solidity's `/` operator. Note: this function uses a\\n     * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n     * uses an invalid opcode to revert (consuming all remaining gas).\\n     *\\n     * Requirements:\\n     *\\n     * - The divisor cannot be zero.\\n     */\\n    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n        require(b > 0, errorMessage);\\n        return a / b;\\n    }\\n\\n    /**\\n     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n     * reverting with custom message when dividing by zero.\\n     *\\n     * CAUTION: This function is deprecated because it requires allocating memory for the error\\n     * message unnecessarily. For custom revert reasons use {tryMod}.\\n     *\\n     * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n     * opcode (which leaves remaining gas untouched) while Solidity uses an\\n     * invalid opcode to revert (consuming all remaining gas).\\n     *\\n     * Requirements:\\n     *\\n     * - The divisor cannot be zero.\\n     */\\n    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n        require(b > 0, errorMessage);\\n        return a % b;\\n    }\\n}\\n\",\"keccak256\":\"0xe22a1fc7400ae196eba2ad1562d0386462b00a6363b742d55a2fd2021a58586f\",\"license\":\"MIT\"},\"contracts/libraries/EVMValidatorV2.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\n\\npragma solidity 0.7.6;\\npragma abicoder v2;\\n\\nimport \\\"@layerzerolabs/proof-evm/contracts/MPTValidatorV2.sol\\\";\\n\\ncontract EVMValidatorV2 is MPTValidatorV2 {}\\n\",\"keccak256\":\"0x2f986170873b716add4f425456b04458d83c0dae05a67cf76424d5182d45972a\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
  "bytecode": "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",
  "deployedBytecode": "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",
  "devdoc": {
    "kind": "dev",
    "methods": {},
    "version": 1
  },
  "userdoc": {
    "kind": "user",
    "methods": {},
    "version": 1
  },
  "storageLayout": {
    "storage": [],
    "types": null
  }
}