Cryo Explorer Ethereum Mainnet

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;

import "./lib/RLPReader.sol";
import "./lib/MerklePatriciaProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import { ISubdomainPricer } from "./pricers/ISubdomainPricer.sol"; // <-- use the canonical interface

interface IRegistrarView {
    function currentDuration(bytes32 parentNode) external view returns (uint64);
    function domainPricer(bytes32 parentNode) external view returns (address);
}

/**
 * @title BurnReceiptVerifier
 * @notice Verifies, on-chain, that a buyer self-burned >= required amount of the correct token
 *         for a given (parentNode, label). Proof is a Merkle-Patricia receipt proof anchored
 *         by blockhash(blockNumber); thus, the burn must be recorded within the last 256 blocks.
 *
 * Flow:
 *  - User burns token (emits Transfer(buyer -> 0x0, amount))
 *  - Frontend builds header+receipt+MPT proof client-side and calls recordSelfBurn(...)
 *  - Verifier:
 *      * anchors header with blockhash
 *      * verifies receipt inclusion against receiptsRoot
 *      * calls registrar.domainPricer(...) and registrar.currentDuration(...)
 *      * computes expected (token, required) via pricer.price(...)
 *      * scans logs for Transfer(buyer->0x0, amount) on expected token, requires amount >= required
 *      * stores {amount, token} for (buyer, parentNode, labelhash)
 *  - Registrar’s claimAfterSelfBurn(...) re-checks and consumes authorization (one-time).
 */
contract BurnReceiptVerifier is Ownable {
    using RLPReader for bytes;
    using RLPReader for RLPReader.RLPItem;

    /// @dev ERC20 Transfer topic = keccak256("Transfer(address,address,uint256)")
    bytes32 private constant TRANSFER_TOPIC =
        0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;

    IRegistrarView public registrar;
    uint8 public minConfirmations = 6; // small anti-reorg buffer; adjustable by owner

    struct Auth {
        uint256 amount; // actual burned (sum of matching logs)
        address token;  // token address observed in the receipt
    }
    // key = keccak256(buyer, parentNode, labelhash)
    mapping(bytes32 => Auth) private _auth;

    event RegistrarUpdated(address indexed oldReg, address indexed newReg);
    event MinConfirmationsUpdated(uint8 oldVal, uint8 newVal);
    event Authorized(address indexed buyer, bytes32 indexed parentNode, bytes32 indexed labelhash, address token, uint256 amount, uint256 blockNumber);
    event Consumed(address indexed buyer, bytes32 indexed parentNode, bytes32 indexed labelhash);

    constructor(address registrar_) {
        require(registrar_ != address(0), "registrar=0");
        registrar = IRegistrarView(registrar_);
        emit RegistrarUpdated(address(0), registrar_);
    }

    function setRegistrar(address registrar_) external onlyOwner {
        require(registrar_ != address(0), "registrar=0");
        emit RegistrarUpdated(address(registrar), registrar_);
        registrar = IRegistrarView(registrar_);
    }

    function setMinConfirmations(uint8 confs) external onlyOwner {
        emit MinConfirmationsUpdated(minConfirmations, confs);
        minConfirmations = confs;
    }

    // --------------------------- Public views for registrar ---------------------------

    function isAuthorized(address buyer, bytes32 parentNode, bytes32 labelhash) external view returns (bool) {
        return _auth[_key(buyer, parentNode, labelhash)].amount != 0;
    }

    function authorizedAmount(address buyer, bytes32 parentNode, bytes32 labelhash) external view returns (uint256) {
        return _auth[_key(buyer, parentNode, labelhash)].amount;
    }

    function authorizedToken(address buyer, bytes32 parentNode, bytes32 labelhash) external view returns (address) {
        return _auth[_key(buyer, parentNode, labelhash)].token;
    }

    function consume(address buyer, bytes32 parentNode, bytes32 labelhash) external {
        bytes32 k = _key(buyer, parentNode, labelhash);
        require(_auth[k].amount != 0, "not authorized");
        delete _auth[k];
        emit Consumed(buyer, parentNode, labelhash);
    }

    // --------------------------- Core: record proof of self-burn ---------------------------

    /**
     * @param buyer         The address that executed the burn tx (msg.sender in the burn call)
     * @param parentNode    The ENS parent node under which the label will be registered
     * @param label         The human-readable label (used by pricer; labelhash is keccak256(bytes(label)))
     * @param blockNumber   Block number containing the burn receipt
     * @param txIndex       Index of the burn transaction within the block
     * @param headerRlp     Full RLP-encoded block header for @blockNumber
     * @param receiptRlp    RLP-encoded receipt for the burn transaction (typed or legacy)
     * @param rlpParentNodes RLP-encoded list of MPT proof nodes along the receipt path
     */
    function recordSelfBurn(
        address buyer,
        bytes32 parentNode,
        string calldata label,
        uint256 blockNumber,
        uint256 txIndex,
        bytes calldata headerRlp,
        bytes calldata receiptRlp,
        bytes calldata rlpParentNodes
    ) external {
        require(address(registrar) != address(0), "registrar not set");
        require(block.number > blockNumber, "future block");
        unchecked {
            // reorg guard (minConfirmations) + freshness (≤256 blocks for blockhash)
            require(block.number - blockNumber >= minConfirmations, "too fresh");
            require(block.number - blockNumber <= 256, "expired");
        }

        // Anchor header by blockhash
        require(keccak256(headerRlp) == blockhash(blockNumber), "bad header");

        // Extract receiptsRoot from header (field index 5)
        RLPReader.RLPItem[] memory h = headerRlp.toRlpItem().toList();
        bytes32 receiptsRoot = bytes32(h[5].toBytes());

        // Verify receipt inclusion via MPT (key = RLP(txIndex))
        bytes memory key = _rlpEncodeUint(txIndex);
        bool ok = MerklePatriciaProof.verify(receiptRlp, key, rlpParentNodes, receiptsRoot);
        require(ok, "bad receipt proof");

        // Compute current price context trustlessly from registrar/pricer
        uint64 duration = registrar.currentDuration(parentNode);
        address pricerAddr = registrar.domainPricer(parentNode);
        require(pricerAddr != address(0), "no pricer");

        bytes32 labelhash = keccak256(bytes(label));
        (address expectedToken, uint256 required) = ISubdomainPricer(pricerAddr).price(labelhash, label, duration);

        // Parse receipt logs → sum matching Transfer(buyer->0x0) for expected token
        uint256 burned = _sumBurnedAmount(receiptRlp, expectedToken, buyer);
        require(burned >= required, "burn too small");

        // Store facts for one-time authorization
        bytes32 k = _key(buyer, parentNode, labelhash);
        _auth[k] = Auth({ amount: burned, token: expectedToken });

        emit Authorized(buyer, parentNode, labelhash, expectedToken, burned, blockNumber);
    }

    // --------------------------- Internal helpers ---------------------------

    function _key(address buyer, bytes32 parentNode, bytes32 labelhash) private pure returns (bytes32) {
        return keccak256(abi.encodePacked(buyer, parentNode, labelhash));
    }

    // Strips receipt type (EIP-2718) if present; returns the RLP list payload
    function _normalize(bytes memory receipt) private pure returns (bytes memory) {
        if (receipt.length > 0 && uint8(receipt[0]) <= 0x7f) {
            bytes memory out = new bytes(receipt.length - 1);
            for (uint256 i; i < out.length; ) { out[i] = receipt[i + 1]; unchecked { ++i; } }
            return out;
        }
        return receipt;
    }

    function _sumBurnedAmount(bytes memory receiptRlp, address token, address buyer) private pure returns (uint256 total) {
        bytes memory dec = _normalize(receiptRlp);
        RLPReader.RLPItem[] memory fields = dec.toRlpItem().toList();
        // fields: [status/postState, cumulativeGasUsed, logsBloom, logs]
        RLPReader.RLPItem[] memory logs = fields[3].toList();
        for (uint256 i = 0; i < logs.length; ) {
            RLPReader.RLPItem[] memory logEntry = logs[i].toList();
            address addr = logEntry[0].toAddress();
            if (addr == token) {
                RLPReader.RLPItem[] memory topics = logEntry[1].toList();
                if (topics.length >= 3) {
                    bytes32 sig = bytes32(topics[0].toBytes());
                    if (sig == TRANSFER_TOPIC) {
                        address fromTopic = address(uint160(uint256(bytes32(topics[1].toBytes()))));
                        address toTopic   = address(uint160(uint256(bytes32(topics[2].toBytes()))));
                        if (fromTopic == buyer && toTopic == address(0)) {
                            // data encodes uint256(value)
                            uint256 amount = _toUint(logEntry[2].toBytes());
                            total += amount;
                        }
                    }
                }
            }
            unchecked { ++i; }
        }
    }

    function _toUint(bytes memory b) private pure returns (uint256 x) {
        require(b.length <= 32, "overflow");
        assembly { x := mload(add(b, 32)) }
        if (b.length < 32) x >>= (8 * (32 - b.length));
    }

    // Minimal RLP encoding of a non-negative integer
    function _rlpEncodeUint(uint256 x) private pure returns (bytes memory) {
        if (x == 0) return hex"80";
        uint256 tmp = x; uint256 len;
        while (tmp != 0) { len++; tmp >>= 8; }
        if (len == 1 && x <= 0x7f) {
            bytes memory b1 = new bytes(1); b1[0] = bytes1(uint8(x)); return b1;
        }
        bytes memory out = new bytes(1 + len);
        out[0] = bytes1(uint8(0x80 + len));
        for (uint256 i = len; i > 0; ) { out[i] = bytes1(uint8(x & 0xff)); x >>= 8; unchecked { --i; } }
        return out;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;

import {RLPReader} from "./RLPReader.sol";

/**
 * @title MerklePatriciaProof
 * @notice Verifies inclusion proofs for Ethereum's Merkle‑Patricia Trie (MPT).
 * @dev API and logic adapted for Solidity ^0.8 from Polygon's fx-portal implementation.
 */
library MerklePatriciaProof {
    using RLPReader for bytes;
    using RLPReader for RLPReader.RLPItem;

    /**
     * @dev Verifies a Merkle‑Patricia proof.
     * @param value          RLP-encoded value stored at the leaf (e.g., the receipt RLP).
     * @param encodedPath    Path key used in the trie (NOT hashed) – for receipts/tx tries this is RLP(txIndex).
     * @param rlpParentNodes RLP-encoded list of proof nodes (concatenate the stack of RLP nodes as an RLP list).
     * @param root           Trie root hash (e.g., receiptsRoot).
     */
    function verify(
        bytes memory value,
        bytes memory encodedPath,
        bytes memory rlpParentNodes,
        bytes32 root
    ) internal pure returns (bool) {
        RLPReader.RLPItem[] memory parentNodes = rlpParentNodes.toRlpItem().toList();
        bytes memory path = _getNibbleArray(encodedPath);

        bytes32 nodeKey = root;
        uint256 pathPtr = 0;

        for (uint256 i = 0; i < parentNodes.length; i++) {
            bytes memory currentNode = parentNodes[i].toBytes();
            if (keccak256(currentNode) != nodeKey) return false;

            RLPReader.RLPItem[] memory node = currentNode.toRlpItem().toList();

            if (node.length == 17) {
                if (pathPtr == path.length) {
                    return keccak256(node[16].toBytes()) == keccak256(value);
                }
                uint8 nib = uint8(path[pathPtr]);
                if (nib > 16) return false;
                bytes memory next = node[nib].toBytes();
                if (next.length == 0) return false;

                if (next.length < 32) nodeKey = keccak256(next);
                else nodeKey = bytes32(bytes32FromBytes(next));
                pathPtr += 1;
            } else if (node.length == 2) {
                bytes memory partialPath = _getNibbleArray(node[0].toBytes());
                uint256 traverse = _nibblesToTraverse(partialPath, path, pathPtr);
                pathPtr += traverse;

                if (pathPtr == path.length) {
                    return keccak256(node[1].toBytes()) == keccak256(value);
                } else {
                    bytes memory next = node[1].toBytes();
                    if (next.length < 32) nodeKey = keccak256(next);
                    else nodeKey = bytes32(bytes32FromBytes(next));
                }
            } else {
                return false;
            }
        }

        return false;
    }

    function bytes32FromBytes(bytes memory b) private pure returns (bytes32 out) {
        require(b.length == 32, "MPT: invalid length");
        assembly { out := mload(add(b, 32)) }
    }

    function _nibblesToTraverse(
        bytes memory partialPath,
        bytes memory path,
        uint256 pathPtr
    ) private pure returns (uint256) {
        uint256 len = 0;
        if (partialPath.length == 0) return 0;
        while (len < partialPath.length && pathPtr + len < path.length) {
            if (partialPath[len] != path[pathPtr + len]) break;
            unchecked { ++len; }
        }
        return len;
    }

    // Expand bytes to nibbles and, if input is a compact-encoded node key,
    // strip the hex-prefix header.
    function _getNibbleArray(bytes memory b) private pure returns (bytes memory) {
        if (b.length == 0) return new bytes(0);

        bytes memory nibbles = new bytes(b.length * 2);
        for (uint256 i = 0; i < b.length; i++) {
            nibbles[2 * i]     = bytes1(uint8(b[i]) >> 4);
            nibbles[2 * i + 1] = bytes1(uint8(b[i]) & 0x0f);
        }

        if (nibbles.length == 0) return nibbles;

        uint8 hpNibble = uint8(nibbles[0]);
        if (hpNibble == 0 || hpNibble == 1 || hpNibble == 2 || hpNibble == 3) {
            uint256 offset = (hpNibble == 1 || hpNibble == 3) ? 1 : 2;
            bytes memory res = new bytes(nibbles.length - offset);
            for (uint256 i = 0; i < res.length; i++) { res[i] = nibbles[i + offset]; }
            return res;
        }

        return nibbles;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;

/**
 * @title RLPReader
 * @dev A lightweight RLP decoding library adapted for Solidity ^0.8.
 * Based on the MIT-licensed work of hamdiallam/solidity-rlp and Polygon's fx-portal.
 */
library RLPReader {
    uint8 private constant STRING_SHORT_START = 0x80;
    uint8 private constant STRING_LONG_START  = 0xb8;
    uint8 private constant LIST_SHORT_START   = 0xc0;
    uint8 private constant LIST_LONG_START    = 0xf8;

    struct RLPItem { uint256 len; uint256 memPtr; }
    struct Iterator { RLPItem item; uint256 nextPtr; }

    function toRlpItem(bytes memory item) internal pure returns (RLPItem memory) {
        uint256 memPtr; assembly { memPtr := add(item, 0x20) } return RLPItem(item.length, memPtr);
    }

    function iterator(RLPItem memory item) internal pure returns (Iterator memory it) {
        uint256 ptr = item.memPtr + _payloadOffset(item.memPtr); it = Iterator(item, ptr);
    }
    function hasNext(Iterator memory it) internal pure returns (bool) {
        return it.nextPtr < it.item.memPtr + it.item.len;
    }
    function next(Iterator memory it) internal pure returns (RLPItem memory subItem) {
        require(hasNext(it), "RLPReader: iterator overflow");
        uint256 ptr = it.nextPtr; uint256 itemLen = _itemLength(ptr);
        subItem = RLPItem(itemLen, ptr); it.nextPtr = ptr + itemLen;
    }

    function isList(RLPItem memory item) internal pure returns (bool) {
        uint8 b0; uint256 memPtr = item.memPtr; assembly { b0 := byte(0, mload(memPtr)) } return b0 >= LIST_SHORT_START;
    }

    function toList(RLPItem memory item) internal pure returns (RLPItem[] memory result) {
        require(isList(item), "RLPReader: item is not a list");
        uint256 items = numItems(item); result = new RLPItem[](items);
        uint256 memPtr = item.memPtr + _payloadOffset(item.memPtr);
        for (uint256 i; i < items; ) { uint256 len = _itemLength(memPtr); result[i] = RLPItem(len, memPtr); memPtr += len; unchecked { ++i; } }
    }

    function toBytes(RLPItem memory item) internal pure returns (bytes memory bts) {
        uint256 offset = _payloadOffset(item.memPtr); uint256 len = item.len - offset; bts = new bytes(len);
        uint256 src = item.memPtr + offset; uint256 dest; assembly { dest := add(bts, 0x20) } _copy(src, dest, len);
    }

    function toAddress(RLPItem memory item) internal pure returns (address addr) {
        require(item.len == 21 || (item.len > 21 && _payloadLen(item) == 20), "RLPReader: invalid address");
        uint256 offset = _payloadOffset(item.memPtr); uint256 mem = item.memPtr + offset;
        assembly { addr := div(mload(mem), 0x1000000000000000000000000) } // right shift by 12 bytes
    }

    function toUint(RLPItem memory item) internal pure returns (uint256 result) {
        uint256 offset = _payloadOffset(item.memPtr); uint256 len = item.len - offset;
        require(len > 0 && len <= 32, "RLPReader: invalid uint"); uint256 mem = item.memPtr + offset; assembly { result := mload(mem) }
        if (len < 32) { result >>= (8 * (32 - len)); }
    }

    function numItems(RLPItem memory item) internal pure returns (uint256) {
        require(isList(item), "RLPReader: not list"); uint256 count; uint256 currPtr = item.memPtr + _payloadOffset(item.memPtr); uint256 endPtr = item.memPtr + item.len;
        while (currPtr < endPtr) { currPtr += _itemLength(currPtr); count++; } return count;
    }

    function _payloadLen(RLPItem memory item) private pure returns (uint256) {
        uint256 offset = _payloadOffset(item.memPtr); return item.len - offset;
    }

    function _itemLength(uint256 memPtr) private pure returns (uint256 len) {
        uint256 byte0; assembly { byte0 := byte(0, mload(memPtr)) }
        if (byte0 < STRING_SHORT_START) { len = 1; }
        else if (byte0 < STRING_LONG_START) { len = byte0 - STRING_SHORT_START + 1; }
        else if (byte0 < LIST_SHORT_START) {
            uint256 llength = byte0 - STRING_LONG_START + 1; uint256 dataLen;
            assembly { dataLen := div(mload(add(memPtr, 1)), exp(256, sub(32, llength))) }
            len = 1 + llength + dataLen;
        } else if (byte0 < LIST_LONG_START) { len = byte0 - LIST_SHORT_START + 1; }
        else {
            uint256 llength = byte0 - LIST_LONG_START + 1; uint256 dataLen;
            assembly { dataLen := div(mload(add(memPtr, 1)), exp(256, sub(32, llength))) }
            len = 1 + llength + dataLen;
        }
    }

    function _payloadOffset(uint256 memPtr) private pure returns (uint256) {
        uint256 byte0; assembly { byte0 := byte(0, mload(memPtr)) }
        if (byte0 < STRING_SHORT_START) return 0;
        if (byte0 < STRING_LONG_START) return 1;
        if (byte0 < LIST_SHORT_START) return byte0 - (STRING_LONG_START - 1);
        if (byte0 < LIST_LONG_START) return 1;
        return byte0 - (LIST_LONG_START - 1);
    }

    function _copy(uint256 src, uint256 dest, uint256 len) private pure {
        if (len == 0) return;
        for (; len >= 32; len -= 32) { assembly { mstore(dest, mload(src)) } src += 32; dest += 32; }
        if (len == 0) return;
        uint256 mask; assembly {
            mask := sub(exp(256, sub(32, len)), 1)
            let srcpart := and(mload(src), not(mask))
            let destpart := and(mload(dest), mask)
            mstore(dest, or(destpart, srcpart))
        }
    }
}

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;

interface ISubdomainPricer {
    function price(
        bytes32 parentNode,
        string calldata label,
        uint256 duration
    ) external view returns (address token, uint256 price);
}