{ "address": "0x50500CCD11e29f14008c7778a6ceD655727a21C3", "abi": [ { "inputs": [ { "internalType": "address", "name": "_stargateBridgeAddress", "type": "address" }, { "internalType": "address", "name": "_stgTokenAddress", "type": "address" }, { "internalType": "uint16", "name": "_localChainId", "type": "uint16" } ], "stateMutability": "nonpayable", "type": "constructor" }, { "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 MPTValidatorStgV3.ULNLog", "name": "", "type": "tuple" } ], "stateMutability": "pure", "type": "function" }, { "inputs": [], "name": "localChainId", "outputs": [ { "internalType": "uint16", "name": "", "type": "uint16" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "bytes", "name": "_payload", "type": "bytes" } ], "name": "secureStgPayload", "outputs": [ { "internalType": "bytes", "name": "", "type": "bytes" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "bytes", "name": "_payload", "type": "bytes" } ], "name": "secureStgTokenPayload", "outputs": [ { "internalType": "bytes", "name": "", "type": "bytes" } ], "stateMutability": "pure", "type": "function" }, { "inputs": [], "name": "stargateBridgeAddress", "outputs": [ { "internalType": "address", "name": "", "type": "address" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "stgTokenAddress", "outputs": [ { "internalType": "address", "name": "", "type": "address" } ], "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": "", "type": "tuple" } ], "stateMutability": "view", "type": "function" } ], "transactionHash": "0x2002129c52461003d8d020fc384df5ec540ecae10e27a5da647059238f489b32", "receipt": { "to": null, "from": "0xc9424BA7E09a46f50F8AA89203C61149091aDBCd", "contractAddress": "0x50500CCD11e29f14008c7778a6ceD655727a21C3", "transactionIndex": 9, "gasUsed": "1729484", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "blockHash": "0x000181b90000010b95805ce8bcd8db17b9e85f0cc7c5fcbb5aec2f9c2c932d33", "transactionHash": "0x2002129c52461003d8d020fc384df5ec540ecae10e27a5da647059238f489b32", "logs": [], "blockNumber": 34976197, "cumulativeGasUsed": "2862582", "status": 1, "byzantium": true }, "args": [ "0x45A01E4e04F14f7A4a6702c74187c5F6222033cd", "0x2F6F07CDcf3588944Bf4C42aC74ff24bF56e7590", 12 ], "numDeployments": 1, "solcInputHash": "0b2b10c1ffe4a777786e02ed2167eab5", "metadata": "{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_stargateBridgeAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_stgTokenAddress\",\"type\":\"address\"},{\"internalType\":\"uint16\",\"name\":\"_localChainId\",\"type\":\"uint16\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"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 MPTValidatorStgV3.ULNLog\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"localChainId\",\"outputs\":[{\"internalType\":\"uint16\",\"name\":\"\",\"type\":\"uint16\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"_payload\",\"type\":\"bytes\"}],\"name\":\"secureStgPayload\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"_payload\",\"type\":\"bytes\"}],\"name\":\"secureStgTokenPayload\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"stargateBridgeAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"stgTokenAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"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\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/libraries/EVMValidatorStgV3.sol\":\"EVMValidatorStgV3\"},\"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/MPTValidatorStgV3.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 MPTValidatorStgV3 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 address immutable public stargateBridgeAddress;\\n address immutable public stgTokenAddress;\\n uint16 immutable public localChainId;\\n\\n\\n constructor (address _stargateBridgeAddress, address _stgTokenAddress, uint16 _localChainId) {\\n stargateBridgeAddress = _stargateBridgeAddress;\\n stgTokenAddress = _stgTokenAddress;\\n localChainId = _localChainId;\\n }\\n\\n struct ULNLog{\\n bytes32 contractAddress;\\n bytes32 topicZeroSig;\\n bytes data;\\n }\\n\\n // Stargate objects for abi encoding / decoding\\n struct SwapObj {\\n uint256 amount;\\n uint256 eqFee;\\n uint256 eqReward;\\n uint256 lpFee;\\n uint256 protocolFee;\\n uint256 lkbRemove;\\n }\\n\\n struct CreditObj {\\n uint256 credits;\\n uint256 idealBalance;\\n }\\n\\n function validateProof(bytes32 _receiptsRoot, bytes calldata _transactionProof, uint _remoteAddressSize) external view override returns (LayerZeroPacket.Packet memory) {\\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 LayerZeroPacket.Packet memory packet = _getPacket(log.data, remoteChainId, _remoteAddressSize, log.contractAddress);\\n\\n require(packet.dstChainId == localChainId, \\\"ProofLib: invalid destination chain ID\\\");\\n\\n if (packet.dstAddress == stargateBridgeAddress) packet.payload = _secureStgPayload(packet.payload);\\n\\n if (packet.dstAddress == stgTokenAddress) packet.payload = _secureStgTokenPayload(packet.payload);\\n\\n return packet;\\n }\\n\\n function _secureStgTokenPayload(bytes memory _payload) internal pure returns (bytes memory) {\\n (bytes memory toAddressBytes, uint256 qty) = abi.decode(_payload, (bytes, uint256));\\n\\n address toAddress = address(0);\\n if (toAddressBytes.length > 0) {\\n assembly { toAddress := mload(add(toAddressBytes, 20))}\\n }\\n\\n if (toAddress == address(0)) {\\n address deadAddress = address(0x000000000000000000000000000000000000dEaD);\\n bytes memory newToAddressBytes = abi.encodePacked(deadAddress);\\n return abi.encode(newToAddressBytes, qty);\\n }\\n\\n // default to return the original payload\\n return _payload;\\n }\\n\\n function _secureStgPayload(bytes memory _payload) internal view returns (bytes memory) {\\n // functionType is uint8 even though the encoding will take up the side of uint256\\n uint8 functionType;\\n assembly { functionType := mload(add(_payload, 32)) }\\n\\n // TYPE_SWAP_REMOTE == 1 && only if the payload has a payload\\n // only swapRemote inside of stargate can call sgReceive on an user supplied to address\\n // thus we do not care about the other type functions even if the toAddress is overly long.\\n if (functionType == 1) {\\n // decode the _payload with its types\\n (\\n ,\\n uint256 srcPoolId,\\n uint256 dstPoolId,\\n uint256 dstGasForCall,\\n CreditObj memory c,\\n SwapObj memory s,\\n bytes memory toAddressBytes,\\n bytes memory contractCallPayload\\n ) = abi.decode(_payload, (uint8, uint256, uint256, uint256, CreditObj, SwapObj, bytes, bytes));\\n\\n // if contractCallPayload.length > 0 need to check if the to address is a contract or not\\n if (contractCallPayload.length > 0) {\\n // otherwise, need to check if the payload can be delivered to the toAddress\\n address toAddress = address(0);\\n if (toAddressBytes.length > 0) {\\n assembly { toAddress := mload(add(toAddressBytes, 20)) }\\n }\\n\\n // check if the toAddress is a contract. We are not concerned about addresses that pretend to be wallets. because worst case we just delete their payload if being malicious\\n // we can guarantee that if a size > 0, then the contract is definitely a contract address in this context\\n uint size;\\n assembly { size := extcodesize(toAddress) }\\n\\n if (size == 0) {\\n // size == 0 indicates its not a contract, payload wont be delivered\\n // secure the _payload to make sure funds can be delivered to the toAddress\\n bytes memory newToAddressBytes = abi.encodePacked(toAddress);\\n bytes memory securePayload = abi.encode(functionType, srcPoolId, dstPoolId, dstGasForCall, c, s, newToAddressBytes, bytes(\\\"\\\"));\\n return securePayload;\\n }\\n }\\n }\\n\\n // default to return the original payload\\n return _payload;\\n }\\n\\n function secureStgTokenPayload(bytes memory _payload) external pure returns(bytes memory) {\\n return _secureStgTokenPayload(_payload);\\n }\\n\\n function secureStgPayload(bytes memory _payload) external view returns(bytes memory) {\\n return _secureStgPayload(_payload);\\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\":\"0x89b37d35bc9ee3d6eb6fb44de426a23f172a8d9177d043dd46ebb46cf42668f5\",\"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/EVMValidatorStgV3.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\n\\npragma solidity 0.7.6;\\npragma abicoder v2;\\n\\nimport \\\"@layerzerolabs/proof-evm/contracts/MPTValidatorStgV3.sol\\\";\\n\\ncontract EVMValidatorStgV3 is MPTValidatorStgV3 {\\n constructor (address _stargateBridgeAddress, address _stgTokenAddress, uint16 _localChainId) MPTValidatorStgV3(_stargateBridgeAddress, _stgTokenAddress, _localChainId) {}\\n}\\n\",\"keccak256\":\"0xeb427258fa13cd0bb7234a496a7eb044c7e0274fd63041fb50c41ee4e1699446\",\"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 } }