{
  "address": "0x4EE2F9B7cf3A68966c370F3eb2C16613d3235245",
  "abi": [
    {
      "inputs": [],
      "name": "PacketSignature",
      "outputs": [
        {
          "internalType": "bytes32",
          "name": "",
          "type": "bytes32"
        }
      ],
      "stateMutability": "view",
      "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[]"
        },
        {
          "internalType": "uint256[]",
          "name": "pointers",
          "type": "uint256[]"
        }
      ],
      "name": "getVerifyLog",
      "outputs": [
        {
          "components": [
            {
              "internalType": "bytes32",
              "name": "contractAddress",
              "type": "bytes32"
            },
            {
              "internalType": "bytes32",
              "name": "topicZeroSig",
              "type": "bytes32"
            },
            {
              "internalType": "bytes",
              "name": "data",
              "type": "bytes"
            }
          ],
          "internalType": "struct MPTValidator.ULNLog",
          "name": "",
          "type": "tuple"
        }
      ],
      "stateMutability": "view",
      "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": "0x49ab0e4a9dbadea75b4ea7883314c48d27906e46802cc4e894517a3df3e8ece2",
  "receipt": {
    "to": null,
    "from": "0x9F403140Bc0574D7d36eA472b82DAa1Bbd4eF327",
    "contractAddress": "0x4EE2F9B7cf3A68966c370F3eb2C16613d3235245",
    "transactionIndex": 0,
    "gasUsed": "17655249",
    "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
    "blockHash": "0xc6979a22a58d503aaa18620fe1ea2145191b5ba398d42a2c028d9804f731cc1b",
    "transactionHash": "0x49ab0e4a9dbadea75b4ea7883314c48d27906e46802cc4e894517a3df3e8ece2",
    "logs": [],
    "blockNumber": 7919849,
    "cumulativeGasUsed": "8238129",
    "status": 1,
    "byzantium": true
  },
  "args": [],
  "numDeployments": 1,
  "solcInputHash": "a1e1c38c600013c198072c1dbc348301",
  "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"PacketSignature\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"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[]\"},{\"internalType\":\"uint256[]\",\"name\":\"pointers\",\"type\":\"uint256[]\"}],\"name\":\"getVerifyLog\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"contractAddress\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"topicZeroSig\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"internalType\":\"struct MPTValidator.ULNLog\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"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/EVMValidator.sol\":\"EVMValidator\"},\"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/MPTValidator.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\n\\npragma solidity 0.7.6;\\npragma abicoder v2;\\n\\nimport \\\"./utility/LayerZeroPacket.sol\\\";\\nimport \\\"./utility/UltraLightNodeEVMDecoder.sol\\\";\\nimport \\\"./ILayerZeroValidationLibrary.sol\\\";\\n\\ncontract MPTValidator is ILayerZeroValidationLibrary {\\n    using LayerZeroPacket for bytes;\\n    using RLPDecode for RLPDecode.RLPItem;\\n    using RLPDecode for RLPDecode.Iterator;\\n\\n    bytes32 public constant PacketSignature = 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 pointers, uint receiptIndex, uint logIndex) = abi.decode(_transactionProof, (uint16, bytes[], uint[], uint, uint));\\n\\n        ULNLog memory log = _getVerifiedLog(_receiptsRoot, receiptIndex, logIndex, proof, pointers);\\n        require(log.topicZeroSig == PacketSignature, \\\"LayerZero: packet not recognized\\\"); //data\\n\\n        return log.data.getPacket(remoteChainId, _remoteAddressSize, log.contractAddress);\\n    }\\n\\n    function _getVerifiedLog(bytes32 hashRoot, uint receiptSlotIndex, uint logIndex, bytes[] memory proof, uint[] memory pointers) internal pure returns(ULNLog memory) {\\n        // walk and assert the hash links of MPT\\n        uint pointer;\\n        bytes memory proofBytes;\\n        for (uint i = 0; i < proof.length; i++) {\\n            proofBytes = proof[i];\\n            require(hashRoot == keccak256(proofBytes), \\\"LayerZero: invalid hashlink\\\");\\n            if (i < pointers.length) {\\n                pointer = pointers[i];\\n                assembly { hashRoot := mload(add(add(proofBytes, pointer), 32)) }\\n            }\\n        }\\n\\n        // build the iterator for the proofBytes\\n        RLPDecode.Iterator memory it = RLPDecode.toRlpItem(proofBytes).iterator();\\n\\n        // get the receipt item from either branch or leaf node\\n        RLPDecode.RLPItem memory receiptItem = it.item.getItemByIndex(receiptSlotIndex);\\n        // it = targetReceiptIter\\n        it = receiptItem.typeOffset().iterator();\\n        it.next(); // status\\n        it.next(); // gasUsed\\n        it.next(); // logBloom\\n\\n        // it = targetLogIter\\n        it =  it.next().getItemByIndex(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 receiptSlotIndex, uint logIndex, bytes[] memory proof, uint[] memory pointers) external view returns(ULNLog memory){\\n        return _getVerifiedLog(hashRoot, receiptSlotIndex, logIndex, proof, pointers);\\n    }\\n}\\n\",\"keccak256\":\"0xa7b15a781b802a317990de5fc82bf1e47df8fab0d52b734b2055759aad88876b\",\"license\":\"BUSL-1.1\"},\"@layerzerolabs/proof-evm/contracts/utility/Buffer.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\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     * @dev Initializes a new buffer from an existing bytes object.\\n     *      Changes to the buffer may mutate the original value.\\n     * @param b The bytes object to initialize the buffer with.\\n     * @return A new buffer.\\n     */\\n    function fromBytes(bytes memory b) internal pure returns (buffer memory) {\\n        buffer memory buf;\\n        buf.buf = b;\\n        buf.capacity = b.length;\\n        return buf;\\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    /**\\n     * @dev Sets buffer length to 0.\\n     * @param buf The buffer to truncate.\\n     * @return The original buffer, for chaining..\\n     */\\n    function truncate(buffer memory buf) internal pure returns (buffer memory) {\\n        assembly {\\n            let bufptr := mload(buf)\\n            mstore(bufptr, 0)\\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    /**\\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(buffer memory buf, uint off, bytes memory rawData, uint offData, uint len) 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 Appends 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 data The data to append.\\n     * @param len The number of bytes to copy.\\n     * @return The original buffer, for chaining.\\n     */\\n    function append(buffer memory buf, bytes memory data, uint len) internal pure returns (buffer memory) {\\n        return write(buf, buf.buf.length, data, len);\\n    }\\n\\n    /**\\n     * @dev Appends 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 data The data to append.\\n     * @return The original buffer, for chaining.\\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    /**\\n     * @dev Writes a byte to the buffer. Resizes if doing so would exceed the\\n     *      capacity of the buffer.\\n     * @param buf The buffer to append to.\\n     * @param off The offset to write the byte at.\\n     * @param data The data to append.\\n     * @return The original buffer, for chaining.\\n     */\\n    function writeUint8(buffer memory buf, uint off, uint8 data) internal pure returns (buffer memory) {\\n        if (off >= buf.capacity) {\\n            resize(buf, buf.capacity * 2);\\n        }\\n\\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            // Address = buffer address + sizeof(buffer length) + off\\n            let dest := add(add(bufptr, off), 32)\\n            mstore8(dest, data)\\n            // Update buffer length if we extended it\\n            if eq(off, buflen) {\\n                mstore(bufptr, add(buflen, 1))\\n            }\\n        }\\n        return buf;\\n    }\\n\\n    /**\\n     * @dev Appends a byte to the buffer. Resizes if doing so would exceed the\\n     *      capacity of the buffer.\\n     * @param buf The buffer to append to.\\n     * @param data The data to append.\\n     * @return The original buffer, for chaining.\\n     */\\n    function appendUint8(buffer memory buf, uint8 data) internal pure returns (buffer memory) {\\n        return writeUint8(buf, buf.buf.length, data);\\n    }\\n\\n    /**\\n     * @dev Writes up to 32 bytes to the buffer. Resizes if doing so would\\n     *      exceed the capacity of the buffer.\\n     * @param buf The buffer to append to.\\n     * @param off The offset to write at.\\n     * @param data The data to append.\\n     * @param len The number of bytes to write (left-aligned).\\n     * @return The original buffer, for chaining.\\n     */\\n    function write(buffer memory buf, uint off, bytes32 data, uint len) private pure returns (buffer memory) {\\n        if (len + off > buf.capacity) {\\n            resize(buf, (len + off) * 2);\\n        }\\n\\n        uint mask = 256**len - 1;\\n        // Right-align data\\n        data = data >> (8 * (32 - len));\\n        assembly {\\n            // Memory address of the buffer data\\n            let bufptr := mload(buf)\\n            // Address = buffer address + sizeof(buffer length) + off + len\\n            let dest := add(add(bufptr, off), len)\\n            mstore(dest, or(and(mload(dest), not(mask)), data))\\n            // Update buffer length if we extended it\\n            if gt(add(off, len), mload(bufptr)) {\\n                mstore(bufptr, add(off, len))\\n            }\\n        }\\n        return buf;\\n    }\\n\\n    /**\\n     * @dev Writes a bytes20 to the buffer. Resizes if doing so would exceed the\\n     *      capacity of the buffer.\\n     * @param buf The buffer to append to.\\n     * @param off The offset to write at.\\n     * @param data The data to append.\\n     * @return The original buffer, for chaining.\\n     */\\n    function writeBytes20(buffer memory buf, uint off, bytes20 data) internal pure returns (buffer memory) {\\n        return write(buf, off, bytes32(data), 20);\\n    }\\n\\n    /**\\n     * @dev Appends a bytes20 to the buffer. Resizes if doing so would exceed\\n     *      the capacity of the buffer.\\n     * @param buf The buffer to append to.\\n     * @param data The data to append.\\n     * @return The original buffer, for chhaining.\\n     */\\n    function appendBytes20(buffer memory buf, bytes20 data) internal pure returns (buffer memory) {\\n        return write(buf, buf.buf.length, bytes32(data), 20);\\n    }\\n\\n    function appendBytes8(buffer memory buf, bytes8 data) internal pure returns (buffer memory) {\\n        return write(buf, buf.buf.length, bytes32(data), 8);\\n    }\\n\\n    /**\\n     * @dev Appends a bytes32 to the buffer. Resizes if doing so would exceed\\n     *      the capacity of the buffer.\\n     * @param buf The buffer to append to.\\n     * @param data The data to append.\\n     * @return The original buffer, for chaining.\\n     */\\n    function appendBytes32(buffer memory buf, bytes32 data) internal pure returns (buffer memory) {\\n        return write(buf, buf.buf.length, data, 32);\\n    }\\n\\n    /**\\n     * @dev Writes an integer to the 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 offset to write at.\\n     * @param data The data to append.\\n     * @param len The number of bytes to write (right-aligned).\\n     * @return The original buffer, for chaining.\\n     */\\n    function writeInt(buffer memory buf, uint off, uint data, uint len) private pure returns (buffer memory) {\\n        if (len + off > buf.capacity) {\\n            resize(buf, (len + off) * 2);\\n        }\\n\\n        uint mask = 256**len - 1;\\n        assembly {\\n            // Memory address of the buffer data\\n            let bufptr := mload(buf)\\n            // Address = buffer address + off + sizeof(buffer length) + len\\n            let dest := add(add(bufptr, off), len)\\n            mstore(dest, or(and(mload(dest), not(mask)), data))\\n            // Update buffer length if we extended it\\n            if gt(add(off, len), mload(bufptr)) {\\n                mstore(bufptr, add(off, len))\\n            }\\n        }\\n        return buf;\\n    }\\n\\n    /**\\n     * @dev Appends a byte to the end of the buffer. Resizes if doing so would\\n     * exceed the capacity of the buffer.\\n     * @param buf The buffer to append to.\\n     * @param data The data to append.\\n     * @return The original buffer.\\n     */\\n    function appendInt(buffer memory buf, uint data, uint len) internal pure returns (buffer memory) {\\n        return writeInt(buf, buf.buf.length, data, len);\\n    }\\n}\\n\",\"keccak256\":\"0xd36292241497a4c87999f67474a705be05065da0fab98ff77a2c43f4617f98e8\",\"license\":\"BUSL-1.1\"},\"@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\\\";\\nimport \\\"./Buffer.sol\\\";\\n\\nlibrary LayerZeroPacket {\\n    using Buffer for Buffer.buffer;\\n    using SafeMath for uint;\\n\\n    //---------------------------------------------------------------------------\\n    // packet\\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    function getPacket(bytes memory data, uint16 srcChain, uint sizeOfSrcAddress, bytes32 ulnAddress) internal pure returns (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 Packet(srcChain, dstChainId, nonce, address(dstAddress), srcAddressBuffer.buf, ulnAddress, payloadBuffer.buf);\\n    }\\n}\\n\",\"keccak256\":\"0xc8c36b46586e279380a43cedd6cb0bb04c869580f3cb41402576468c6ca56743\",\"license\":\"BUSL-1.1\"},\"@layerzerolabs/proof-evm/contracts/utility/RLPDecode.sol\":{\"content\":\"// SPDX-License-Identifier: Apache-2.0\\n\\n/*\\n* @author Hamdi Allam hamdi.allam97@gmail.com\\n* Please reach out with any questions or concerns\\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    //\\n    //        return RLPItem(item.length, memPtr);\\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   * @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            // shfit to the correct location if neccesary\\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(uint src, uint dest, uint len) 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\":\"0x5757f0b7af3f4286fbb5ccb8e43321b2f7024da8cb390832bc5f24a79dd3a162\",\"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/EVMValidator.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\n\\npragma solidity 0.7.6;\\npragma abicoder v2;\\n\\nimport \\\"@layerzerolabs/proof-evm/contracts/MPTValidator.sol\\\";\\n\\ncontract EVMValidator is MPTValidator {}\\n\",\"keccak256\":\"0x12867355b8d4219ffe70561e4b18990a12b90b878c8cbfe90062cb4fbec5bfd5\",\"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
  }
}