Sepolia Testnet

Contract

0x97627EF07A99a77d3Eb436b5C9062cD6c52BCd9c

Overview

ETH Balance

0 ETH

Multichain Info

N/A
Transaction Hash
Method
Block
From
To
0x6080806060470302024-06-05 21:55:2437 days ago1717624524IN
 Contract Creation
0 ETH0.004448126.58814239

Advanced mode:
Parent Transaction Hash Block From To
View All Internal Transactions
Loading...
Loading

Similar Match Source Code
This contract matches the deployed Bytecode of the Source Code for Contract 0xE47b13aD...F3881D361
The constructor portion of the code might be different and could alter the actual behaviour of the contract

Contract Name:
RLPReader

Compiler Version
v0.8.22+commit.4fc1097e

Optimization Enabled:
Yes with 200 runs

Other Settings:
paris EvmVersion

Contract Source Code (Solidity Standard Json-Input format)

File 1 of 2 : RLPReader.sol
// SPDX-License-Identifier: Apache-2.0
pragma solidity >=0.5.10 <0.9.0;

import "./lib/Lib_RLPReader.sol";

/// @title RLPReader
/// @author LightLink Hummingbird
/// @custom:version v1.1.0-beta
/// @notice A contract that reads RLP encoded data.
contract RLPReader {
    using Lib_RLPReader for bytes;
    using Lib_RLPReader for uint;
    using Lib_RLPReader for Lib_RLPReader.RLPItem;
    using Lib_RLPReader for Lib_RLPReader.Iterator;

    /// @notice Returns the block header from the RLP encoded data.
    /// @param rlpHeader - The RLP encoded block header.
    /// @return parentHash - The parent hash.
    /// @return sha3Uncles - The sha3 uncles.
    /// @return coinbase - The coinbase address.
    /// @return stateRoot - The state root.
    /// @return transactionsRoot - The transactions root.
    /// @return receiptsRoot - The receipts root.
    /// @return difficulty - The difficulty.
    /// @return number - The block number.
    /// @return gasLimit - The gas limit.
    /// @return gasUsed - The gas used.
    /// @return timestamp - The timestamp.
    /// @return nonce - The nonce.
    function toBlockHeader(
        bytes memory rlpHeader
    )
        public
        pure
        returns (
            bytes32 parentHash,
            bytes32 sha3Uncles,
            address coinbase,
            bytes32 stateRoot,
            bytes32 transactionsRoot,
            bytes32 receiptsRoot,
            uint difficulty,
            uint number,
            uint gasLimit,
            uint gasUsed,
            uint timestamp,
            uint nonce
        )
    {
        Lib_RLPReader.Iterator memory it = rlpHeader.toRlpItem().iterator();
        uint idx;
        while (it.hasNext()) {
            if (idx == 0) parentHash = bytes32(it.next().toUint());
            else if (idx == 1) sha3Uncles = bytes32(it.next().toUint());
            else if (idx == 2) coinbase = it.next().toAddress();
            else if (idx == 3) stateRoot = bytes32(it.next().toUint());
            else if (idx == 4) transactionsRoot = bytes32(it.next().toUint());
            else if (idx == 5) receiptsRoot = bytes32(it.next().toUint());
            else if (idx == 7) difficulty = it.next().toUint();
            else if (idx == 8) number = it.next().toUint();
            else if (idx == 9) gasLimit = it.next().toUint();
            else if (idx == 10) gasUsed = it.next().toUint();
            else if (idx == 11) timestamp = it.next().toUint();
            else if (idx == 14) nonce = it.next().toUint();
            else it.next();

            idx++;
        }
    }

    /// @notice Returns the legacy transaction from the RLP encoded data.
    /// @param rlpTx - The RLP encoded transaction.
    /// @return nonce - The nonce.
    /// @return gasPrice - The gas price.
    /// @return gasLimit - The gas limit.
    /// @return to - The recipient address.
    /// @return value - The value.
    /// @return data - The data.
    /// @return v - The v value.
    /// @return r - The r value.
    /// @return s - The s value.
    function toLegacyTx(
        bytes memory rlpTx
    )
        public
        pure
        returns (
            uint nonce,
            uint gasPrice,
            uint gasLimit,
            address to,
            uint value,
            bytes memory data,
            uint v,
            uint r,
            uint s
        )
    {
        Lib_RLPReader.Iterator memory it = rlpTx.toRlpItem().iterator();
        uint idx;
        while (it.hasNext()) {
            if (idx == 0) nonce = it.next().toUint();
            else if (idx == 1) gasPrice = it.next().toUint();
            else if (idx == 2) gasLimit = it.next().toUint();
            else if (idx == 3) to = it.next().toAddress();
            else if (idx == 4) value = it.next().toUint();
            else if (idx == 5) data = it.next().toBytes();
            else if (idx == 6) v = it.next().toUint();
            else if (idx == 7) r = it.next().toUint();
            else if (idx == 8) s = it.next().toUint();
            else it.next();
            idx++;
        }
        return (nonce, gasPrice, gasLimit, to, value, data, v, r, s);
    }

    /// @notice Returns the deposit transaction from the RLP encoded data.
    /// @param rlpTx - The RLP encoded transaction.
    /// @return chainId - The chain ID.
    /// @return nonce - The nonce.
    /// @return gasPrice - The gas price.
    /// @return gasLimit - The gas limit.
    /// @return to - The recipient address.
    /// @return value - The value.
    /// @return data - The data.
    /// @return v - The v value.
    /// @return r - The r value.
    /// @return s - The s value.
    function toDepositTx(
        bytes memory rlpTx
    )
        public
        pure
        returns (
            uint chainId,
            uint nonce,
            uint gasPrice,
            uint gasLimit,
            address to,
            uint value,
            bytes memory data,
            uint v,
            uint r,
            uint s
        )
    {
        Lib_RLPReader.Iterator memory it = rlpTx.toRlpItem().iterator();
        uint idx;
        while (it.hasNext()) {
            if (idx == 0) chainId = it.next().toUint();
            else if (idx == 1) nonce = it.next().toUint();
            else if (idx == 2) gasPrice = it.next().toUint();
            else if (idx == 3) gasLimit = it.next().toUint();
            else if (idx == 4) to = it.next().toAddress();
            else if (idx == 5) value = it.next().toUint();
            else if (idx == 6) data = it.next().toBytes();
            else if (idx == 7) v = it.next().toUint();
            else if (idx == 8) r = it.next().toUint();
            else if (idx == 9) s = it.next().toUint();
            else it.next();

            idx++;
        }
    }
}

File 2 of 2 : Lib_RLPReader.sol
// SPDX-License-Identifier: Apache-2.0

/*
 * @author Hamdi Allam [email protected]
 * Please reach out with any questions or concerns
 */
pragma solidity >=0.5.10 <0.9.0;

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

    struct RLPItem {
        uint256 len;
        uint256 memPtr;
    }

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

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

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

        return RLPItem(itemLength, ptr);
    }

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

    /*
     * @param item RLP encoded bytes
     */
    function toRlpItem(
        bytes memory item
    ) internal pure returns (RLPItem memory) {
        uint256 memPtr;
        assembly {
            memPtr := add(item, 0x20)
        }

        return RLPItem(item.length, memPtr);
    }

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

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

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

    /*
     * @param the RLP item.
     * @return (memPtr, len) pair: location of the item's payload in memory.
     */
    function payloadLocation(
        RLPItem memory item
    ) internal pure returns (uint256, uint256) {
        uint256 offset = _payloadOffset(item.memPtr);
        uint256 memPtr = item.memPtr + offset;
        uint256 len = item.len - offset; // data length
        return (memPtr, len);
    }

    /*
     * @param the RLP item.
     */
    function payloadLen(RLPItem memory item) internal pure returns (uint256) {
        (, uint256 len) = payloadLocation(item);
        return len;
    }

    /*
     * @param the RLP item containing the encoded list.
     */
    function toList(
        RLPItem memory item
    ) internal pure returns (RLPItem[] memory) {
        require(isList(item));

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

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

        return result;
    }

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

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

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

    /*
     * @dev A cheaper version of keccak256(toRlpBytes(item)) that avoids copying memory.
     * @return keccak256 hash of RLP encoded bytes.
     */
    function rlpBytesKeccak256(
        RLPItem memory item
    ) internal pure returns (bytes32) {
        uint256 ptr = item.memPtr;
        uint256 len = item.len;
        bytes32 result;
        assembly {
            result := keccak256(ptr, len)
        }
        return result;
    }

    /*
     * @dev A cheaper version of keccak256(toBytes(item)) that avoids copying memory.
     * @return keccak256 hash of the item payload.
     */
    function payloadKeccak256(
        RLPItem memory item
    ) internal pure returns (bytes32) {
        (uint256 memPtr, uint256 len) = payloadLocation(item);
        bytes32 result;
        assembly {
            result := keccak256(memPtr, len)
        }
        return result;
    }

    /** RLPItem conversions into data types **/

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

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

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

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

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

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

        return address(uint160(toUint(item)));
    }

    function toUint(RLPItem memory item) internal pure returns (uint256) {
        require(item.len > 0 && item.len <= 33);

        (uint256 memPtr, uint256 len) = payloadLocation(item);

        uint256 result;
        assembly {
            result := mload(memPtr)

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

        return result;
    }

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

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

        return result;
    }

    function toBytes(RLPItem memory item) internal pure returns (bytes memory) {
        require(item.len > 0);

        (uint256 memPtr, uint256 len) = payloadLocation(item);
        bytes memory result = new bytes(len);

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

        copy(memPtr, destPtr, len);
        return result;
    }

    /*
     * Private Helpers
     */

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

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

        return count;
    }

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

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

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

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

        return itemLen;
    }

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

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

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

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

            src += WORD_SIZE;
            dest += WORD_SIZE;
        }

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

Settings
{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "viaIR": true,
  "evmVersion": "paris",
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

Contract ABI

[{"inputs":[{"internalType":"bytes","name":"rlpHeader","type":"bytes"}],"name":"toBlockHeader","outputs":[{"internalType":"bytes32","name":"parentHash","type":"bytes32"},{"internalType":"bytes32","name":"sha3Uncles","type":"bytes32"},{"internalType":"address","name":"coinbase","type":"address"},{"internalType":"bytes32","name":"stateRoot","type":"bytes32"},{"internalType":"bytes32","name":"transactionsRoot","type":"bytes32"},{"internalType":"bytes32","name":"receiptsRoot","type":"bytes32"},{"internalType":"uint256","name":"difficulty","type":"uint256"},{"internalType":"uint256","name":"number","type":"uint256"},{"internalType":"uint256","name":"gasLimit","type":"uint256"},{"internalType":"uint256","name":"gasUsed","type":"uint256"},{"internalType":"uint256","name":"timestamp","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes","name":"rlpTx","type":"bytes"}],"name":"toDepositTx","outputs":[{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"gasPrice","type":"uint256"},{"internalType":"uint256","name":"gasLimit","type":"uint256"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"uint256","name":"v","type":"uint256"},{"internalType":"uint256","name":"r","type":"uint256"},{"internalType":"uint256","name":"s","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes","name":"rlpTx","type":"bytes"}],"name":"toLegacyTx","outputs":[{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"gasPrice","type":"uint256"},{"internalType":"uint256","name":"gasLimit","type":"uint256"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"uint256","name":"v","type":"uint256"},{"internalType":"uint256","name":"r","type":"uint256"},{"internalType":"uint256","name":"s","type":"uint256"}],"stateMutability":"pure","type":"function"}]

Deployed Bytecode

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

Block Transaction Difficulty Gas Used Reward
View All Blocks Produced

Block Uncle Number Difficulty Gas Used Reward
View All Uncles
Loading...
Loading

Validator Index Block Amount
View All Withdrawals

Transaction Hash Block Value Eth2 PubKey Valid
View All Deposits
[ Download: CSV Export  ]

A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.