Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: BUSL-1.1

pragma solidity 0.7.6;
pragma abicoder v2;

import "./utility/LayerZeroPacket.sol";
import "./utility/UltraLightNodeEVMDecoder.sol";
import "../interfaces/IValidationLibraryHelperV2.sol";
import "../interfaces/ILayerZeroValidationLibrary.sol";

interface IStargate {
    // Stargate objects for abi encoding / decoding
    struct SwapObj {
        uint amount;
        uint eqFee;
        uint eqReward;
        uint lpFee;
        uint protocolFee;
        uint lkbRemove;
    }

    struct CreditObj {
        uint credits;
        uint idealBalance;
    }
}

contract MPTValidator01 is ILayerZeroValidationLibrary, IValidationLibraryHelperV2 {
    using RLPDecode for RLPDecode.RLPItem;
    using RLPDecode for RLPDecode.Iterator;

    uint8 public proofType = 1;
    uint8 public utilsVersion = 4;
    bytes32 public constant PACKET_SIGNATURE = 0xe9bded5f24a4168e4f3bf44e00298c993b22376aad8c58c7dda9718a54cbea82;

    address public immutable stargateBridgeAddress;
    address public immutable stargateTokenAddress;

    constructor(address _stargateBridgeAddress, address _stargateTokenAddress) {
        stargateBridgeAddress = _stargateBridgeAddress;
        stargateTokenAddress = _stargateTokenAddress;
    }

    function validateProof(bytes32 _receiptsRoot, bytes calldata _transactionProof, uint _remoteAddressSize) external view override returns (LayerZeroPacket.Packet memory packet) {
        require(_remoteAddressSize > 0, "ProofLib: invalid address size");
        (bytes[] memory proof, uint[] memory receiptSlotIndex, uint logIndex) = abi.decode(_transactionProof, (bytes[], uint[], uint));

        ULNLog memory log = _getVerifiedLog(_receiptsRoot, receiptSlotIndex, logIndex, proof);
        require(log.topicZeroSig == PACKET_SIGNATURE, "ProofLib: packet not recognized"); //data

        packet = LayerZeroPacket.getPacketV2(log.data, _remoteAddressSize, log.contractAddress);

        if (packet.dstAddress == stargateBridgeAddress) packet.payload = _secureStgPayload(packet.payload);

        if (packet.dstAddress == stargateTokenAddress) packet.payload = _secureStgTokenPayload(packet.payload);

        return packet;
    }

    function _secureStgTokenPayload(bytes memory _payload) internal pure returns (bytes memory) {
        (bytes memory toAddressBytes, uint qty) = abi.decode(_payload, (bytes, uint));

        address toAddress = address(0);
        if (toAddressBytes.length > 0) {
            assembly {
                toAddress := mload(add(toAddressBytes, 20))
            }
        }

        if (toAddress == address(0)) {
            address deadAddress = address(0x000000000000000000000000000000000000dEaD);
            bytes memory newToAddressBytes = abi.encodePacked(deadAddress);
            return abi.encode(newToAddressBytes, qty);
        }

        // default to return the original payload
        return _payload;
    }

    function _secureStgPayload(bytes memory _payload) internal view returns (bytes memory) {
        // functionType is uint8 even though the encoding will take up the side of uint256
        uint8 functionType;
        assembly {
            functionType := mload(add(_payload, 32))
        }

        // TYPE_SWAP_REMOTE == 1 && only if the payload has a payload
        // only swapRemote inside of stargate can call sgReceive on an user supplied to address
        // thus we do not care about the other type functions even if the toAddress is overly long.
        if (functionType == 1) {
            // decode the _payload with its types
            (, uint srcPoolId, uint dstPoolId, uint dstGasForCall, IStargate.CreditObj memory c, IStargate.SwapObj memory s, bytes memory toAddressBytes, bytes memory contractCallPayload) = abi.decode(_payload, (uint8, uint, uint, uint, IStargate.CreditObj, IStargate.SwapObj, bytes, bytes));

            // if contractCallPayload.length > 0 need to check if the to address is a contract or not
            if (contractCallPayload.length > 0) {
                // otherwise, need to check if the payload can be delivered to the toAddress
                address toAddress = address(0);
                if (toAddressBytes.length > 0) {
                    assembly {
                        toAddress := mload(add(toAddressBytes, 20))
                    }
                }

                // 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
                // we can guarantee that if a size > 0, then the contract is definitely a contract address in this context
                uint size;
                assembly {
                    size := extcodesize(toAddress)
                }

                if (size == 0) {
                    // size == 0 indicates its not a contract, payload wont be delivered
                    // secure the _payload to make sure funds can be delivered to the toAddress
                    bytes memory newToAddressBytes = abi.encodePacked(toAddress);
                    bytes memory securePayload = abi.encode(functionType, srcPoolId, dstPoolId, dstGasForCall, c, s, newToAddressBytes, bytes(""));
                    return securePayload;
                }
            }
        }

        // default to return the original payload
        return _payload;
    }

    function secureStgTokenPayload(bytes memory _payload) external pure returns (bytes memory) {
        return _secureStgTokenPayload(_payload);
    }

    function secureStgPayload(bytes memory _payload) external view returns (bytes memory) {
        return _secureStgPayload(_payload);
    }

    function _getVerifiedLog(bytes32 hashRoot, uint[] memory paths, uint logIndex, bytes[] memory proof) internal pure returns (ULNLog memory) {
        require(paths.length == proof.length, "ProofLib: invalid proof size");
        require(proof.length > 0, "ProofLib: proof size must > 0");
        RLPDecode.RLPItem memory item;
        bytes memory proofBytes;

        for (uint i = 0; i < proof.length; i++) {
            proofBytes = proof[i];
            require(hashRoot == keccak256(proofBytes), "ProofLib: invalid hashlink");
            item = RLPDecode.toRlpItem(proofBytes).safeGetItemByIndex(paths[i]);
            if (i < proof.length - 1) hashRoot = bytes32(item.toUint());
        }

        // burning status + gasUsed + logBloom
        RLPDecode.RLPItem memory logItem = item.typeOffset().safeGetItemByIndex(3);
        RLPDecode.Iterator memory it = logItem.safeGetItemByIndex(logIndex).iterator();
        ULNLog memory log;
        log.contractAddress = bytes32(it.next().toUint());
        log.topicZeroSig = bytes32(it.next().safeGetItemByIndex(0).toUint());
        log.data = it.next().toBytes();

        return log;
    }

    function getUtilsVersion() external view override returns (uint8) {
        return utilsVersion;
    }

    function getProofType() external view override returns (uint8) {
        return proofType;
    }

    function getVerifyLog(bytes32 hashRoot, uint[] memory receiptSlotIndex, uint logIndex, bytes[] memory proof) external pure override returns (ULNLog memory) {
        return _getVerifiedLog(hashRoot, receiptSlotIndex, logIndex, proof);
    }

    function getPacket(bytes memory data, uint sizeOfSrcAddress, bytes32 ulnAddress) external pure override returns (LayerZeroPacket.Packet memory) {
        return LayerZeroPacket.getPacketV2(data, sizeOfSrcAddress, ulnAddress);
    }
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity 0.7.6;

import "./Buffer.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";

library LayerZeroPacket {
    using Buffer for Buffer.buffer;
    using SafeMath for uint;

    struct Packet {
        uint16 srcChainId;
        uint16 dstChainId;
        uint64 nonce;
        address dstAddress;
        bytes srcAddress;
        bytes32 ulnAddress;
        bytes payload;
    }

    function getPacket(
        bytes memory data,
        uint16 srcChain,
        uint sizeOfSrcAddress,
        bytes32 ulnAddress
    ) internal pure returns (LayerZeroPacket.Packet memory) {
        uint16 dstChainId;
        address dstAddress;
        uint size;
        uint64 nonce;

        // The log consists of the destination chain id and then a bytes payload
        //      0--------------------------------------------31
        // 0   |  total bytes size
        // 32  |  destination chain id
        // 64  |  bytes offset
        // 96  |  bytes array size
        // 128 |  payload
        assembly {
            dstChainId := mload(add(data, 32))
            size := mload(add(data, 96)) /// size of the byte array
            nonce := mload(add(data, 104)) // offset to convert to uint64  128  is index -24
            dstAddress := mload(add(data, sub(add(128, sizeOfSrcAddress), 4))) // offset to convert to address 12 -8
        }

        Buffer.buffer memory srcAddressBuffer;
        srcAddressBuffer.init(sizeOfSrcAddress);
        srcAddressBuffer.writeRawBytes(0, data, 136, sizeOfSrcAddress); // 128 + 8

        uint payloadSize = size.sub(28).sub(sizeOfSrcAddress);
        Buffer.buffer memory payloadBuffer;
        payloadBuffer.init(payloadSize);
        payloadBuffer.writeRawBytes(0, data, sizeOfSrcAddress.add(156), payloadSize); // 148 + 8
        return LayerZeroPacket.Packet(srcChain, dstChainId, nonce, dstAddress, srcAddressBuffer.buf, ulnAddress, payloadBuffer.buf);
    }

    function getPacketV2(
        bytes memory data,
        uint sizeOfSrcAddress,
        bytes32 ulnAddress
    ) internal pure returns (LayerZeroPacket.Packet memory) {
        // packet def: abi.encodePacked(nonce, srcChain, srcAddress, dstChain, dstAddress, payload);
        // data def: abi.encode(packet) = offset(32) + length(32) + packet
        //              if from EVM
        // 0 - 31       0 - 31          |  total bytes size
        // 32 - 63      32 - 63         |  location
        // 64 - 95      64 - 95         |  size of the packet
        // 96 - 103     96 - 103        |  nonce
        // 104 - 105    104 - 105       |  srcChainId
        // 106 - P      106 - 125       |  srcAddress, where P = 106 + sizeOfSrcAddress - 1,
        // P+1 - P+2    126 - 127       |  dstChainId
        // P+3 - P+22   128 - 147       |  dstAddress
        // P+23 - END   148 - END       |  payload

        // decode the packet
        uint256 realSize;
        uint64 nonce;
        uint16 srcChain;
        uint16 dstChain;
        address dstAddress;
        assembly {
            realSize := mload(add(data, 64))
            nonce := mload(add(data, 72)) // 104 - 32
            srcChain := mload(add(data, 74)) // 106 - 32
            dstChain := mload(add(data, add(76, sizeOfSrcAddress))) // P + 3 - 32 = 105 + size + 3 - 32 = 76 + size
            dstAddress := mload(add(data, add(96, sizeOfSrcAddress))) // P + 23 - 32 = 105 + size + 23 - 32 = 96 + size
        }

        require(srcChain != 0, "LayerZeroPacket: invalid packet");

        Buffer.buffer memory srcAddressBuffer;
        srcAddressBuffer.init(sizeOfSrcAddress);
        srcAddressBuffer.writeRawBytes(0, data, 106, sizeOfSrcAddress);

        uint nonPayloadSize = sizeOfSrcAddress.add(32);// 2 + 2 + 8 + 20, 32 + 20 = 52 if sizeOfSrcAddress == 20
        uint payloadSize = realSize.sub(nonPayloadSize);
        Buffer.buffer memory payloadBuffer;
        payloadBuffer.init(payloadSize);
        payloadBuffer.writeRawBytes(0, data, nonPayloadSize.add(96), payloadSize);

        return LayerZeroPacket.Packet(srcChain, dstChain, nonce, dstAddress, srcAddressBuffer.buf, ulnAddress, payloadBuffer.buf);
    }

    function getPacketV3(
        bytes memory data,
        uint sizeOfSrcAddress,
        bytes32 ulnAddress
    ) internal pure returns (LayerZeroPacket.Packet memory) {
        // data def: abi.encodePacked(nonce, srcChain, srcAddress, dstChain, dstAddress, payload);
        //              if from EVM
        // 0 - 31       0 - 31          |  total bytes size
        // 32 - 39      32 - 39         |  nonce
        // 40 - 41      40 - 41         |  srcChainId
        // 42 - P       42 - 61         |  srcAddress, where P = 41 + sizeOfSrcAddress,
        // P+1 - P+2    62 - 63         |  dstChainId
        // P+3 - P+22   64 - 83         |  dstAddress
        // P+23 - END   84 - END        |  payload

        // decode the packet
        uint256 realSize = data.length;
        uint nonPayloadSize = sizeOfSrcAddress.add(32);// 2 + 2 + 8 + 20, 32 + 20 = 52 if sizeOfSrcAddress == 20
        require(realSize >= nonPayloadSize, "LayerZeroPacket: invalid packet");
        uint payloadSize = realSize - nonPayloadSize;

        uint64 nonce;
        uint16 srcChain;
        uint16 dstChain;
        address dstAddress;
        assembly {
            nonce := mload(add(data, 8)) // 40 - 32
            srcChain := mload(add(data, 10)) // 42 - 32
            dstChain := mload(add(data, add(12, sizeOfSrcAddress))) // P + 3 - 32 = 41 + size + 3 - 32 = 12 + size
            dstAddress := mload(add(data, add(32, sizeOfSrcAddress))) // P + 23 - 32 = 41 + size + 23 - 32 = 32 + size
        }

        require(srcChain != 0, "LayerZeroPacket: invalid packet");

        Buffer.buffer memory srcAddressBuffer;
        srcAddressBuffer.init(sizeOfSrcAddress);
        srcAddressBuffer.writeRawBytes(0, data, 42, sizeOfSrcAddress);

        Buffer.buffer memory payloadBuffer;
        if (payloadSize > 0) {
            payloadBuffer.init(payloadSize);
            payloadBuffer.writeRawBytes(0, data, nonPayloadSize.add(32), payloadSize);
        }

        return LayerZeroPacket.Packet(srcChain, dstChain, nonce, dstAddress, srcAddressBuffer.buf, ulnAddress, payloadBuffer.buf);
    }
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity ^0.7.0;
pragma abicoder v2;

import "./RLPDecode.sol";

library UltraLightNodeEVMDecoder {
    using RLPDecode for RLPDecode.RLPItem;
    using RLPDecode for RLPDecode.Iterator;

    struct Log {
        address contractAddress;
        bytes32 topicZero;
        bytes data;
    }

    function getReceiptLog(bytes memory data, uint logIndex) internal pure returns (Log memory) {
        RLPDecode.Iterator memory it = RLPDecode.toRlpItem(data).iterator();
        uint idx;
        while (it.hasNext()) {
            if (idx == 3) {
                return toReceiptLog(it.next().getItemByIndex(logIndex).toRlpBytes());
            } else it.next();
            idx++;
        }
        revert("no log index in receipt");
    }

    function toReceiptLog(bytes memory data) internal pure returns (Log memory) {
        RLPDecode.Iterator memory it = RLPDecode.toRlpItem(data).iterator();
        Log memory log;

        uint idx;
        while (it.hasNext()) {
            if (idx == 0) {
                log.contractAddress = it.next().toAddress();
            } else if (idx == 1) {
                RLPDecode.RLPItem memory item = it.next().getItemByIndex(0);
                log.topicZero = bytes32(item.toUint());
            } else if (idx == 2) log.data = it.next().toBytes();
            else it.next();
            idx++;
        }
        return log;
    }
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity >=0.7.0;
pragma abicoder v2;

import "../proof/utility/LayerZeroPacket.sol";

interface IValidationLibraryHelperV2 {
    struct ULNLog {
        bytes32 contractAddress;
        bytes32 topicZeroSig;
        bytes data;
    }

    function getVerifyLog(bytes32 hashRoot, uint[] calldata receiptSlotIndex, uint logIndex, bytes[] calldata proof) external pure returns (ULNLog memory);

    function getPacket(bytes calldata data, uint sizeOfSrcAddress, bytes32 ulnAddress) external pure returns (LayerZeroPacket.Packet memory);

    function getUtilsVersion() external view returns (uint8);

    function getProofType() external view returns (uint8);
}

// SPDX-License-Identifier: BUSL-1.1

pragma solidity >=0.7.0;
pragma abicoder v2;

import "../proof/utility/LayerZeroPacket.sol";

interface ILayerZeroValidationLibrary {
    function validateProof(bytes32 blockData, bytes calldata _data, uint _remoteAddressSize) external returns (LayerZeroPacket.Packet memory packet);
}

// SPDX-License-Identifier: BUSL-1.1

// https://github.com/ensdomains/buffer

pragma solidity ^0.7.0;

/**
 * @dev A library for working with mutable byte buffers in Solidity.
 *
 * Byte buffers are mutable and expandable, and provide a variety of primitives
 * for writing to them. At any time you can fetch a bytes object containing the
 * current contents of the buffer. The bytes object should not be stored between
 * operations, as it may change due to resizing of the buffer.
 */
library Buffer {
    /**
     * @dev Represents a mutable buffer. Buffers have a current value (buf) and
     *      a capacity. The capacity may be longer than the current value, in
     *      which case it can be extended without the need to allocate more memory.
     */
    struct buffer {
        bytes buf;
        uint capacity;
    }

    /**
     * @dev Initializes a buffer with an initial capacity.a co
     * @param buf The buffer to initialize.
     * @param capacity The number of bytes of space to allocate the buffer.
     * @return The buffer, for chaining.
     */
    function init(buffer memory buf, uint capacity) internal pure returns (buffer memory) {
        if (capacity % 32 != 0) {
            capacity += 32 - (capacity % 32);
        }
        // Allocate space for the buffer data
        buf.capacity = capacity;
        assembly {
            let ptr := mload(0x40)
            mstore(buf, ptr)
            mstore(ptr, 0)
            mstore(0x40, add(32, add(ptr, capacity)))
        }
        return buf;
    }


    /**
     * @dev Writes a byte string to a buffer. Resizes if doing so would exceed
     *      the capacity of the buffer.
     * @param buf The buffer to append to.
     * @param off The start offset to write to.
     * @param rawData The data to append.
     * @param len The number of bytes to copy.
     * @return The original buffer, for chaining.
     */
    function writeRawBytes(
        buffer memory buf,
        uint off,
        bytes memory rawData,
        uint offData,
        uint len
    ) internal pure returns (buffer memory) {
        if (off + len > buf.capacity) {
            resize(buf, max(buf.capacity, len + off) * 2);
        }

        uint dest;
        uint src;
        assembly {
            // Memory address of the buffer data
            let bufptr := mload(buf)
            // Length of existing buffer data
            let buflen := mload(bufptr)
            // Start address = buffer address + offset + sizeof(buffer length)
            dest := add(add(bufptr, 32), off)
            // Update buffer length if we're extending it
            if gt(add(len, off), buflen) {
                mstore(bufptr, add(len, off))
            }
            src := add(rawData, offData)
        }

        // Copy word-length chunks while possible
        for (; len >= 32; len -= 32) {
            assembly {
                mstore(dest, mload(src))
            }
            dest += 32;
            src += 32;
        }

        // Copy remaining bytes
        uint mask = 256**(32 - len) - 1;
        assembly {
            let srcpart := and(mload(src), not(mask))
            let destpart := and(mload(dest), mask)
            mstore(dest, or(destpart, srcpart))
        }

        return buf;
    }

    /**
     * @dev Writes a byte string to a buffer. Resizes if doing so would exceed
     *      the capacity of the buffer.
     * @param buf The buffer to append to.
     * @param off The start offset to write to.
     * @param data The data to append.
     * @param len The number of bytes to copy.
     * @return The original buffer, for chaining.
     */
    function write(buffer memory buf, uint off, bytes memory data, uint len) internal pure returns (buffer memory) {
        require(len <= data.length);

        if (off + len > buf.capacity) {
            resize(buf, max(buf.capacity, len + off) * 2);
        }

        uint dest;
        uint src;
        assembly {
        // Memory address of the buffer data
            let bufptr := mload(buf)
        // Length of existing buffer data
            let buflen := mload(bufptr)
        // Start address = buffer address + offset + sizeof(buffer length)
            dest := add(add(bufptr, 32), off)
        // Update buffer length if we're extending it
            if gt(add(len, off), buflen) {
                mstore(bufptr, add(len, off))
            }
            src := add(data, 32)
        }

        // Copy word-length chunks while possible
        for (; len >= 32; len -= 32) {
            assembly {
                mstore(dest, mload(src))
            }
            dest += 32;
            src += 32;
        }

        // Copy remaining bytes
        uint mask = 256**(32 - len) - 1;
        assembly {
            let srcpart := and(mload(src), not(mask))
            let destpart := and(mload(dest), mask)
            mstore(dest, or(destpart, srcpart))
        }

        return buf;
    }

    function append(buffer memory buf, bytes memory data) internal pure returns (buffer memory) {
        return write(buf, buf.buf.length, data, data.length);
    }

    function resize(buffer memory buf, uint capacity) private pure {
        bytes memory oldbuf = buf.buf;
        init(buf, capacity);
        append(buf, oldbuf);
    }

    function max(uint a, uint b) private pure returns (uint) {
        if (a > b) {
            return a;
        }
        return b;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b > a) return (false, 0);
        return (true, a - b);
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) return (true, 0);
        uint256 c = a * b;
        if (c / a != b) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a / b);
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a % b);
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SafeMath: subtraction overflow");
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) return 0;
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: division by zero");
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: modulo by zero");
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        return a - b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a % b;
    }
}

// SPDX-License-Identifier: BUSL-1.1

// https://github.com/hamdiallam/solidity-rlp

pragma solidity ^0.7.0;

library RLPDecode {
    uint8 constant STRING_SHORT_START = 0x80;
    uint8 constant STRING_LONG_START = 0xb8;
    uint8 constant LIST_SHORT_START = 0xc0;
    uint8 constant LIST_LONG_START = 0xf8;
    uint8 constant WORD_SIZE = 32;

    struct RLPItem {
        uint len;
        uint memPtr;
    }

    struct Iterator {
        RLPItem item; // Item that's being iterated over.
        uint nextPtr; // Position of the next item in the list.
    }

    /*
     * @dev Returns the next element in the iteration. Reverts if it has not next element.
     * @param self The iterator.
     * @return The next element in the iteration.
     */
    function next(Iterator memory self) internal pure returns (RLPItem memory) {
        require(hasNext(self), "RLPDecoder iterator has no next");

        uint ptr = self.nextPtr;
        uint itemLength = _itemLength(ptr);
        self.nextPtr = ptr + itemLength;

        return RLPItem(itemLength, ptr);
    }

    /*
     * @dev Returns true if the iteration has more elements.
     * @param self The iterator.
     * @return true if the iteration has more elements.
     */
    function hasNext(Iterator memory self) internal pure returns (bool) {
        RLPItem memory item = self.item;
        return self.nextPtr < item.memPtr + item.len;
    }

    /*
     * @param item RLP encoded bytes
     */

    function toRlpItem(bytes memory item) internal pure returns (RLPItem memory) {
        uint memPtr;
        assembly {
            memPtr := add(item, 0x20)
        }
        // offset the pointer if the first byte

        uint8 byte0;
        assembly {
            byte0 := byte(0, mload(memPtr))
        }
        uint len = item.length;
        if (len > 0 && byte0 < LIST_SHORT_START) {
            assembly {
                memPtr := add(memPtr, 0x01)
            }
            len -= 1;
        }
        return RLPItem(len, memPtr);
    }

    /*
     * @dev Create an iterator. Reverts if item is not a list.
     * @param self The RLP item.
     * @return An 'Iterator' over the item.
     */
    function iterator(RLPItem memory self) internal pure returns (Iterator memory) {
        require(isList(self), "RLPDecoder iterator is not list");

        uint ptr = self.memPtr + _payloadOffset(self.memPtr);
        return Iterator(self, ptr);
    }

    /*
     * @param item RLP encoded bytes
     */
    function rlpLen(RLPItem memory item) internal pure returns (uint) {
        return item.len;
    }

    /*
     * @param item RLP encoded bytes
     */
    function payloadLen(RLPItem memory item) internal pure returns (uint) {
        uint offset = _payloadOffset(item.memPtr);
        require(item.len >= offset, "RLPDecoder: invalid uint RLP item offset size");
        return item.len - offset;
    }

    /*
     * @param item RLP encoded list in bytes
     */
    function toList(RLPItem memory item) internal pure returns (RLPItem[] memory) {
        require(isList(item), "RLPDecoder iterator is not a list");

        uint items = numItems(item);
        RLPItem[] memory result = new RLPItem[](items);

        uint memPtr = item.memPtr + _payloadOffset(item.memPtr);
        uint dataLen;
        for (uint i = 0; i < items; i++) {
            dataLen = _itemLength(memPtr);
            result[i] = RLPItem(dataLen, memPtr);
            memPtr = memPtr + dataLen;
        }

        return result;
    }

    /*
     * @param get the RLP item by index. save gas.
     */
    function getItemByIndex(RLPItem memory item, uint idx) internal pure returns (RLPItem memory) {
        require(isList(item), "RLPDecoder iterator is not a list");

        uint memPtr = item.memPtr + _payloadOffset(item.memPtr);
        uint dataLen;
        for (uint i = 0; i < idx; i++) {
            dataLen = _itemLength(memPtr);
            memPtr = memPtr + dataLen;
        }
        dataLen = _itemLength(memPtr);
        return RLPItem(dataLen, memPtr);
    }


    /*
     * @param get the RLP item by index. save gas.
     */
    function safeGetItemByIndex(RLPItem memory item, uint idx) internal pure returns (RLPItem memory) {
        require(isList(item), "RLPDecoder iterator is not a list");
        require(idx < numItems(item), "RLP item out of bounds");
        uint endPtr = item.memPtr + item.len;

        uint memPtr = item.memPtr + _payloadOffset(item.memPtr);
        uint dataLen;
        for (uint i = 0; i < idx; i++) {
            dataLen = _itemLength(memPtr);
            memPtr = memPtr + dataLen;
        }
        dataLen = _itemLength(memPtr);

        require(memPtr + dataLen <= endPtr, "RLP item overflow");
        return RLPItem(dataLen, memPtr);
    }

    /*
     * @param offset the receipt bytes item
     */
    function typeOffset(RLPItem memory item) internal pure returns (RLPItem memory) {
        uint offset = _payloadOffset(item.memPtr);
        uint8 byte0;
        uint memPtr = item.memPtr;
        uint len = item.len;
        assembly {
            memPtr := add(memPtr, offset)
            byte0 := byte(0, mload(memPtr))
        }
        if (len >0 && byte0 < LIST_SHORT_START) {
            assembly {
                memPtr := add(memPtr, 0x01)
            }
            len -= 1;
        }
        return RLPItem(len, memPtr);
    }

    // @return indicator whether encoded payload is a list. negate this function call for isData.
    function isList(RLPItem memory item) internal pure returns (bool) {
        if (item.len == 0) return false;

        uint8 byte0;
        uint memPtr = item.memPtr;
        assembly {
            byte0 := byte(0, mload(memPtr))
        }

        if (byte0 < LIST_SHORT_START) return false;
        return true;
    }

    /** RLPItem conversions into data types **/

    // @returns raw rlp encoding in bytes
    function toRlpBytes(RLPItem memory item) internal pure returns (bytes memory) {
        bytes memory result = new bytes(item.len);
        if (result.length == 0) return result;

        uint ptr;
        assembly {
            ptr := add(0x20, result)
        }

        copy(item.memPtr, ptr, item.len);
        return result;
    }

    // any non-zero byte except "0x80" is considered true
    function toBoolean(RLPItem memory item) internal pure returns (bool) {
        require(item.len == 1, "RLPDecoder toBoolean invalid length");
        uint result;
        uint memPtr = item.memPtr;
        assembly {
            result := byte(0, mload(memPtr))
        }

        // SEE Github Issue #5.
        // Summary: Most commonly used RLP libraries (i.e Geth) will encode
        // "0" as "0x80" instead of as "0". We handle this edge case explicitly
        // here.
        if (result == 0 || result == STRING_SHORT_START) {
            return false;
        } else {
            return true;
        }
    }

    function toAddress(RLPItem memory item) internal pure returns (address) {
        // 1 byte for the length prefix
        require(item.len == 21, "RLPDecoder toAddress invalid length");

        return address(toUint(item));
    }

    function toUint(RLPItem memory item) internal pure returns (uint) {
        require(item.len > 0 && item.len <= 33, "RLPDecoder toUint invalid length");

        uint offset = _payloadOffset(item.memPtr);
        require(item.len >= offset, "RLPDecoder: invalid RLP item offset size");
        uint len = item.len - offset;

        uint result;
        uint memPtr = item.memPtr + offset;
        assembly {
            result := mload(memPtr)

            // shift to the correct location if necessary
            if lt(len, 32) {
                result := div(result, exp(256, sub(32, len)))
            }
        }

        return result;
    }

    // enforces 32 byte length
    function toUintStrict(RLPItem memory item) internal pure returns (uint) {
        // one byte prefix
        require(item.len == 33, "RLPDecoder toUintStrict invalid length");

        uint result;
        uint memPtr = item.memPtr + 1;
        assembly {
            result := mload(memPtr)
        }

        return result;
    }

    function toBytes(RLPItem memory item) internal pure returns (bytes memory) {
        require(item.len > 0, "RLPDecoder toBytes invalid length");

        uint offset = _payloadOffset(item.memPtr);
        require(item.len >= offset, "RLPDecoder: invalid RLP item offset size");
        uint len = item.len - offset; // data length
        bytes memory result = new bytes(len);

        uint destPtr;
        assembly {
            destPtr := add(0x20, result)
        }

        copy(item.memPtr + offset, destPtr, len);
        return result;
    }

    /*
     * Private Helpers
     */

    // @return number of payload items inside an encoded list.
    function numItems(RLPItem memory item) internal pure returns (uint) {
        if (item.len == 0) return 0;

        uint count = 0;
        uint currPtr = item.memPtr + _payloadOffset(item.memPtr);
        uint endPtr = item.memPtr + item.len;
        while (currPtr < endPtr) {
            currPtr = currPtr + _itemLength(currPtr); // skip over an item
            count++;
        }

        return count;
    }

    // @return entire rlp item byte length
    function _itemLength(uint memPtr) private pure returns (uint) {
        uint itemLen;
        uint byte0;
        assembly {
            byte0 := byte(0, mload(memPtr))
        }

        if (byte0 < STRING_SHORT_START) itemLen = 1;
        else if (byte0 < STRING_LONG_START) itemLen = byte0 - STRING_SHORT_START + 1;
        else if (byte0 < LIST_SHORT_START) {
            assembly {
                let byteLen := sub(byte0, 0xb7) // # of bytes the actual length is
                memPtr := add(memPtr, 1) // skip over the first byte

                /* 32 byte word size */
                let dataLen := div(mload(memPtr), exp(256, sub(32, byteLen))) // right shifting to get the len
                itemLen := add(dataLen, add(byteLen, 1))
            }
        } else if (byte0 < LIST_LONG_START) {
            itemLen = byte0 - LIST_SHORT_START + 1;
        } else {
            assembly {
                let byteLen := sub(byte0, 0xf7)
                memPtr := add(memPtr, 1)

                let dataLen := div(mload(memPtr), exp(256, sub(32, byteLen))) // right shifting to the correct length
                itemLen := add(dataLen, add(byteLen, 1))
            }
        }

        return itemLen;
    }

    // @return number of bytes until the data
    function _payloadOffset(uint memPtr) private pure returns (uint) {
        uint byte0;
        assembly {
            byte0 := byte(0, mload(memPtr))
        }

        if (byte0 < STRING_SHORT_START) return 0;
        else if (byte0 < STRING_LONG_START || (byte0 >= LIST_SHORT_START && byte0 < LIST_LONG_START)) return 1;
        else if (byte0 < LIST_SHORT_START)
            // being explicit
            return byte0 - (STRING_LONG_START - 1) + 1;
        else return byte0 - (LIST_LONG_START - 1) + 1;
    }

    /*
     * @param src Pointer to source
     * @param dest Pointer to destination
     * @param len Amount of memory to copy from the source
     */
    function copy(
        uint src,
        uint dest,
        uint len
    ) private pure {
        if (len == 0) return;

        // copy as many word sizes as possible
        for (; len >= WORD_SIZE; len -= WORD_SIZE) {
            assembly {
                mstore(dest, mload(src))
            }

            src += WORD_SIZE;
            dest += WORD_SIZE;
        }

        // left over bytes. Mask is used to remove unwanted bytes from the word
        uint mask = 256**(WORD_SIZE - len) - 1;
        assembly {
            let srcpart := and(mload(src), not(mask)) // zero out src
            let destpart := and(mload(dest), mask) // retrieve the bytes
            mstore(dest, or(destpart, srcpart))
        }
    }
}

{
  "optimizer": {
    "enabled": true,
    "runs": 30000
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "metadata": {
    "useLiteralContent": true
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_stargateBridgeAddress","type":"address"},{"internalType":"address","name":"_stargateTokenAddress","type":"address"}],"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":"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":[],"name":"getProofType","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getUtilsVersion","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"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[]"}],"name":"getVerifyLog","outputs":[{"components":[{"internalType":"bytes32","name":"contractAddress","type":"bytes32"},{"internalType":"bytes32","name":"topicZeroSig","type":"bytes32"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct IValidationLibraryHelperV2.ULNLog","name":"","type":"tuple"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"proofType","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"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":"stargateTokenAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"utilsVersion","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"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":"view","type":"function"}]

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

000000000000000000000000352d8275aae3e0c2404d9f68f6cee084b5beb3dd0000000000000000000000006694340fc020c5e6b96567843da2df01b2ce1eb6

-----Decoded View---------------
Arg [0] : _stargateBridgeAddress (address): 0x352d8275AAE3e0c2404d9f68f6cEE084B5bEB3DD
Arg [1] : _stargateTokenAddress (address): 0x6694340fc020c5E6B96567843da2df01b2CE1eb6

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000352d8275aae3e0c2404d9f68f6cee084b5beb3dd
Arg [1] : 0000000000000000000000006694340fc020c5e6b96567843da2df01b2ce1eb6