Contract 0xa2F428617a523837d4adC81C67a296d42FD95e86 1

ENS  
 
 
Txn Hash
Method
Block
From
To
Value
0xdd3e16e0f76e35f4924fe825fc201cc8f10fbce7214304ddda8c5c4effa2d10eProve And Claim130295902021-08-15 11:50:05473 days 13 hrs agoENS Name thingelstad.eth IN  ENS: DNS Registrar0 Ether0.0221481121
0xcb32bcae13a9a29ac5445a9857c305a59540ff7afaac55f629c31f163b40030bProve And Claim130055712021-08-11 18:41:46477 days 7 hrs agoENS Name fictions.eth IN  ENS: DNS Registrar0 Ether0.0444746542.30838493
0x35a7ebc5fa5e3962392cd632d4f661722bcd97c2b687764fce8bbe1d212f5834Prove And Claim129922452021-08-09 17:17:08479 days 8 hrs agoENS Name lluis.eth IN  ENS: DNS Registrar0 Ether0.0465065848.18970298
0x024d411281841bf814f0b36081ad16fea65726f87405edec0dc27a22afa0a198Prove And Claim129710622021-08-06 11:07:38482 days 14 hrs agoENS Name 6c5331.eth IN  ENS: DNS Registrar0 Ether0.0240505530
0x781e90a124c9f2ca7d5f408d1e14f8c336315d25187a052fae4fe8cf9e0a31bcProve And Claim129654282021-08-05 14:14:29483 days 11 hrs ago0x8106f085262b2dd861d2764590619036b16bb3c0 IN  ENS: DNS Registrar0 Ether0.100876895.88913125
0x542ce168b726c84e6ad2e1ce2310b476e1ebc9f74cd5f4ab0bbd592db04e5a5eProve And Claim129531572021-08-03 15:43:12485 days 10 hrs agoENS Name nathanmisner.eth IN  ENS: DNS Registrar0 Ether0.0452741550
0x62e5212a11a3a74f0352658322e6ba89679b1284e425a438c74f5d540701a128Prove And Claim129420562021-08-01 21:33:27487 days 4 hrs agoENS Name digitalconsultantsllc.eth IN  ENS: DNS Registrar0 Ether0.0338046432
0xb900d541e6268e4ceb11bf2a1fb63972a8396ffb2aeef411db4241140ccee6b3Prove And Claim129173112021-07-28 23:33:40491 days 2 hrs ago0xfa321bf55bda4df52883c297a2be7e75dce2813c IN  ENS: DNS Registrar0 Ether0.024737424
0x9fd4ecf4645b49cebd743e37dea8d05f9cf104d09d0617315edaf7b04b7b03c6Prove And Claim129173092021-07-28 23:33:35491 days 2 hrs ago0xfa321bf55bda4df52883c297a2be7e75dce2813c IN  ENS: DNS Registrar0 Ether0.026432824
0x3b2362147d4231482abbaf9837e6eca8f4fb50db3619dbdbc273f2231e93f9aaProve And Claim129085332021-07-27 14:16:55492 days 11 hrs ago0xd5ec9759a13aebc17cbc92d3a636d19291953e7e IN  ENS: DNS Registrar0 Ether0.0446185757
0xf2960015de6d2af952a9491932c099879e7b84af22e369b8371314530dba3671Claim129031482021-07-26 17:31:50493 days 8 hrs ago0xb30b09da480dd907907d98af5102c2034ed7df60 IN  ENS: DNS Registrar0 Ether0.0028737640
0x7363c5f54d41397f5b6b56470719a08c1fefb908015676f75937f39f5ea1caf2Claim128995642021-07-26 3:53:17493 days 21 hrs ago0xb30b09da480dd907907d98af5102c2034ed7df60 IN  ENS: DNS Registrar0 Ether0.0017788820
0x8768bff10a21fd304d53105ce25bc9ffe021a49d5efa3ae66c224bc589367e88Prove And Claim128985632021-07-26 0:11:47494 days 1 hr agoENS Name lluis.eth IN  ENS: DNS Registrar0 Ether0.0177268419
0x685df602b34606fff064ad9ec7d51c2ba4ee468b436f46a92b8d143788a964ebProve And Claim128871822021-07-24 5:35:49495 days 20 hrs agoENS Name zachf.eth IN  ENS: DNS Registrar0 Ether0.0109099310.1
0xc3fbe1525f6079ba82f14c71f3844c4ea86bfd54d9afb355fb3fbbceb2e5a51bProve And Claim128670422021-07-21 2:02:18498 days 23 hrs agoENS Name alicanc.eth IN  ENS: DNS Registrar0 Ether0.0077050716.5
0x3542ed20bf0fa3f3f5e986d01bb602a21f335a1718efee2c067b4c8fbebdca82Prove And Claim128668562021-07-21 1:22:51499 days 24 mins ago0x157545bfd441453921049998128ff090c1c11230 IN  ENS: DNS Registrar0 Ether0.0103901513
0xa311be7e9a1b1d3c2c52a7b762c0b14f20ee7721b27efc36c68abee3132328bbProve And Claim128638222021-07-20 13:59:53499 days 11 hrs ago0x5bc63adae21612794e3f128c985342e17a3f430b IN  ENS: DNS Registrar0 Ether0.0205752322
0x40b138252bdeab43fe8bbe28ecee42e3bf99bca67c877a35f4f90e0d17a70b1aClaim128524762021-07-18 19:26:34501 days 6 hrs agoENS Name alexpearson.eth IN  ENS: DNS Registrar0 Ether0.0012500618.15
0xbb6e0ea3ff84e38f3c560f908f3ff66b1fe97ea486ba512894a7eff91cce5a1fProve And Claim128524502021-07-18 19:21:50501 days 6 hrs agoENS Name alexpearson.eth IN  ENS: DNS Registrar0 Ether0.0146708317.6
0x3678b220e38bedfec85ebb12b9af9cbcf11778d7f51a33f02490a4ffb16c9eaaProve And Claim128519752021-07-18 17:34:20501 days 8 hrs ago0xc2f4bc2732202d410357eae0cd3d575a0761ef78 IN  ENS: DNS Registrar0 Ether0.0198375517.6
0xae4b393b81482c625f167ab5d14e7955abc5ea78a8330afd57df4fa097480311Prove And Claim128469222021-07-17 22:25:47502 days 3 hrs agoENS Name alexpearson.eth IN  ENS: DNS Registrar0 Ether0.003568811
0xc5c9027b437ae2d796535fa2bee3559edb6b00ec5c90f0d59cacd98c2214f094Prove And Claim128300352021-07-15 6:50:13504 days 18 hrs agoENS Name alexpearson.eth IN  ENS: DNS Registrar0 Ether0.0058394318
0x95229801335a69ab02e9d66d8b0b3864c3893e8b4b7836d9755f674c47be83e7Prove And Claim128299412021-07-15 6:33:10504 days 19 hrs agoENS Name darksaber.eth IN  ENS: DNS Registrar0 Ether0.0313450529
0x6c75b8b02ab86b0ee0913a99701802f78717f64233e0bca4a66129b24121ca46Prove And Claim127865842021-07-08 12:00:48511 days 13 hrs agoENS Name zecircle.eth IN  ENS: DNS Registrar0 Ether0.0243393819.00000145
0xf88727c29a5d75acf22c6834c5308130f1d0926ebd69497458d82d96b7b2bd5aProve And Claim127665472021-07-05 8:57:53514 days 16 hrs agoENS Name murloc.eth IN  ENS: DNS Registrar0 Ether0.0116159910
[ Download CSV Export 
View more zero value Internal Transactions in Advanced View mode
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
DNSRegistrar

Compiler Version
v0.5.16+commit.9c3226ce

Optimization Enabled:
No with 200 runs

Other Settings:
default evmVersion, None license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2020-01-30
*/

// File: @ensdomains/ens/contracts/ENS.sol

pragma solidity >=0.4.24;

interface ENS {

    // Logged when the owner of a node assigns a new owner to a subnode.
    event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner);

    // Logged when the owner of a node transfers ownership to a new account.
    event Transfer(bytes32 indexed node, address owner);

    // Logged when the resolver for a node changes.
    event NewResolver(bytes32 indexed node, address resolver);

    // Logged when the TTL of a node changes
    event NewTTL(bytes32 indexed node, uint64 ttl);

    // Logged when an operator is added or removed.
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    function setRecord(bytes32 node, address owner, address resolver, uint64 ttl) external;
    function setSubnodeRecord(bytes32 node, bytes32 label, address owner, address resolver, uint64 ttl) external;
    function setSubnodeOwner(bytes32 node, bytes32 label, address owner) external returns(bytes32);
    function setResolver(bytes32 node, address resolver) external;
    function setOwner(bytes32 node, address owner) external;
    function setTTL(bytes32 node, uint64 ttl) external;
    function setApprovalForAll(address operator, bool approved) external;
    function owner(bytes32 node) external view returns (address);
    function resolver(bytes32 node) external view returns (address);
    function ttl(bytes32 node) external view returns (uint64);
    function recordExists(bytes32 node) external view returns (bool);
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

// File: @ensdomains/ens/contracts/ENSRegistry.sol

pragma solidity ^0.5.0;


/**
 * The ENS registry contract.
 */
contract ENSRegistry is ENS {

    struct Record {
        address owner;
        address resolver;
        uint64 ttl;
    }

    mapping (bytes32 => Record) records;
    mapping (address => mapping(address => bool)) operators;

    // Permits modifications only by the owner of the specified node.
    modifier authorised(bytes32 node) {
        address owner = records[node].owner;
        require(owner == msg.sender || operators[owner][msg.sender]);
        _;
    }

    /**
     * @dev Constructs a new ENS registrar.
     */
    constructor() public {
        records[0x0].owner = msg.sender;
    }

    /**
     * @dev Sets the record for a node.
     * @param node The node to update.
     * @param owner The address of the new owner.
     * @param resolver The address of the resolver.
     * @param ttl The TTL in seconds.
     */
    function setRecord(bytes32 node, address owner, address resolver, uint64 ttl) external {
        setOwner(node, owner);
        _setResolverAndTTL(node, resolver, ttl);
    }

    /**
     * @dev Sets the record for a subnode.
     * @param node The parent node.
     * @param label The hash of the label specifying the subnode.
     * @param owner The address of the new owner.
     * @param resolver The address of the resolver.
     * @param ttl The TTL in seconds.
     */
    function setSubnodeRecord(bytes32 node, bytes32 label, address owner, address resolver, uint64 ttl) external {
        bytes32 subnode = setSubnodeOwner(node, label, owner);
        _setResolverAndTTL(subnode, resolver, ttl);
    }

    /**
     * @dev Transfers ownership of a node to a new address. May only be called by the current owner of the node.
     * @param node The node to transfer ownership of.
     * @param owner The address of the new owner.
     */
    function setOwner(bytes32 node, address owner) public authorised(node) {
        _setOwner(node, owner);
        emit Transfer(node, owner);
    }

    /**
     * @dev Transfers ownership of a subnode keccak256(node, label) to a new address. May only be called by the owner of the parent node.
     * @param node The parent node.
     * @param label The hash of the label specifying the subnode.
     * @param owner The address of the new owner.
     */
    function setSubnodeOwner(bytes32 node, bytes32 label, address owner) public authorised(node) returns(bytes32) {
        bytes32 subnode = keccak256(abi.encodePacked(node, label));
        _setOwner(subnode, owner);
        emit NewOwner(node, label, owner);
        return subnode;
    }

    /**
     * @dev Sets the resolver address for the specified node.
     * @param node The node to update.
     * @param resolver The address of the resolver.
     */
    function setResolver(bytes32 node, address resolver) public authorised(node) {
        emit NewResolver(node, resolver);
        records[node].resolver = resolver;
    }

    /**
     * @dev Sets the TTL for the specified node.
     * @param node The node to update.
     * @param ttl The TTL in seconds.
     */
    function setTTL(bytes32 node, uint64 ttl) public authorised(node) {
        emit NewTTL(node, ttl);
        records[node].ttl = ttl;
    }

    /**
     * @dev Enable or disable approval for a third party ("operator") to manage
     *  all of `msg.sender`'s ENS records. Emits the ApprovalForAll event.
     * @param operator Address to add to the set of authorized operators.
     * @param approved True if the operator is approved, false to revoke approval.
     */
    function setApprovalForAll(address operator, bool approved) external {
        operators[msg.sender][operator] = approved;
        emit ApprovalForAll(msg.sender, operator, approved);
    }

    /**
     * @dev Returns the address that owns the specified node.
     * @param node The specified node.
     * @return address of the owner.
     */
    function owner(bytes32 node) public view returns (address) {
        address addr = records[node].owner;
        if (addr == address(this)) {
            return address(0x0);
        }

        return addr;
    }

    /**
     * @dev Returns the address of the resolver for the specified node.
     * @param node The specified node.
     * @return address of the resolver.
     */
    function resolver(bytes32 node) public view returns (address) {
        return records[node].resolver;
    }

    /**
     * @dev Returns the TTL of a node, and any records associated with it.
     * @param node The specified node.
     * @return ttl of the node.
     */
    function ttl(bytes32 node) public view returns (uint64) {
        return records[node].ttl;
    }

    /**
     * @dev Returns whether a record has been imported to the registry.
     * @param node The specified node.
     * @return Bool if record exists
     */
    function recordExists(bytes32 node) public view returns (bool) {
        return records[node].owner != address(0x0);
    }

    /**
     * @dev Query if an address is an authorized operator for another address.
     * @param owner The address that owns the records.
     * @param operator The address that acts on behalf of the owner.
     * @return True if `operator` is an approved operator for `owner`, false otherwise.
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool) {
        return operators[owner][operator];
    }

    function _setOwner(bytes32 node, address owner) internal {
        records[node].owner = owner;
    }

    function _setResolverAndTTL(bytes32 node, address resolver, uint64 ttl) internal {
        if(resolver != records[node].resolver) {
            records[node].resolver = resolver;
            emit NewResolver(node, resolver);
        }

        if(ttl != records[node].ttl) {
            records[node].ttl = ttl;
            emit NewTTL(node, ttl);
        }
    }
}

// File: @ensdomains/dnssec-oracle/contracts/DNSSEC.sol

pragma solidity ^0.5.0;

interface DNSSEC {

    event AlgorithmUpdated(uint8 id, address addr);
    event DigestUpdated(uint8 id, address addr);
    event NSEC3DigestUpdated(uint8 id, address addr);
    event RRSetUpdated(bytes name, bytes rrset);

    function submitRRSets(bytes calldata data, bytes calldata proof) external returns (bytes memory);
    function submitRRSet(bytes calldata input, bytes calldata sig, bytes calldata proof) external returns (bytes memory);
    function deleteRRSet(uint16 deleteType, bytes calldata deleteName, bytes calldata nsec, bytes calldata sig, bytes calldata proof) external;
    function rrdata(uint16 dnstype, bytes calldata name) external view returns (uint32, uint64, bytes20);

}

// File: @ensdomains/dnssec-oracle/contracts/BytesUtils.sol

pragma solidity >0.4.23;

library BytesUtils {
    /*
    * @dev Returns the keccak-256 hash of a byte range.
    * @param self The byte string to hash.
    * @param offset The position to start hashing at.
    * @param len The number of bytes to hash.
    * @return The hash of the byte range.
    */
    function keccak(bytes memory self, uint offset, uint len) internal pure returns (bytes32 ret) {
        require(offset + len <= self.length);
        assembly {
            ret := keccak256(add(add(self, 32), offset), len)
        }
    }


    /*
    * @dev Returns a positive number if `other` comes lexicographically after
    *      `self`, a negative number if it comes before, or zero if the
    *      contents of the two bytes are equal.
    * @param self The first bytes to compare.
    * @param other The second bytes to compare.
    * @return The result of the comparison.
    */
    function compare(bytes memory self, bytes memory other) internal pure returns (int) {
        return compare(self, 0, self.length, other, 0, other.length);
    }

    /*
    * @dev Returns a positive number if `other` comes lexicographically after
    *      `self`, a negative number if it comes before, or zero if the
    *      contents of the two bytes are equal. Comparison is done per-rune,
    *      on unicode codepoints.
    * @param self The first bytes to compare.
    * @param offset The offset of self.
    * @param len    The length of self.
    * @param other The second bytes to compare.
    * @param otheroffset The offset of the other string.
    * @param otherlen    The length of the other string.
    * @return The result of the comparison.
    */
    function compare(bytes memory self, uint offset, uint len, bytes memory other, uint otheroffset, uint otherlen) internal pure returns (int) {
        uint shortest = len;
        if (otherlen < len)
        shortest = otherlen;

        uint selfptr;
        uint otherptr;

        assembly {
            selfptr := add(self, add(offset, 32))
            otherptr := add(other, add(otheroffset, 32))
        }
        for (uint idx = 0; idx < shortest; idx += 32) {
            uint a;
            uint b;
            assembly {
                a := mload(selfptr)
                b := mload(otherptr)
            }
            if (a != b) {
                // Mask out irrelevant bytes and check again
                uint mask;
                if (shortest > 32) {
                    mask = uint256(- 1); // aka 0xffffff....
                } else {
                    mask = ~(2 ** (8 * (32 - shortest + idx)) - 1);
                }
                uint diff = (a & mask) - (b & mask);
                if (diff != 0)
                return int(diff);
            }
            selfptr += 32;
            otherptr += 32;
        }

        return int(len) - int(otherlen);
    }

    /*
    * @dev Returns true if the two byte ranges are equal.
    * @param self The first byte range to compare.
    * @param offset The offset into the first byte range.
    * @param other The second byte range to compare.
    * @param otherOffset The offset into the second byte range.
    * @param len The number of bytes to compare
    * @return True if the byte ranges are equal, false otherwise.
    */
    function equals(bytes memory self, uint offset, bytes memory other, uint otherOffset, uint len) internal pure returns (bool) {
        return keccak(self, offset, len) == keccak(other, otherOffset, len);
    }

    /*
    * @dev Returns true if the two byte ranges are equal with offsets.
    * @param self The first byte range to compare.
    * @param offset The offset into the first byte range.
    * @param other The second byte range to compare.
    * @param otherOffset The offset into the second byte range.
    * @return True if the byte ranges are equal, false otherwise.
    */
    function equals(bytes memory self, uint offset, bytes memory other, uint otherOffset) internal pure returns (bool) {
        return keccak(self, offset, self.length - offset) == keccak(other, otherOffset, other.length - otherOffset);
    }

    /*
    * @dev Compares a range of 'self' to all of 'other' and returns True iff
    *      they are equal.
    * @param self The first byte range to compare.
    * @param offset The offset into the first byte range.
    * @param other The second byte range to compare.
    * @return True if the byte ranges are equal, false otherwise.
    */
    function equals(bytes memory self, uint offset, bytes memory other) internal pure returns (bool) {
        return self.length >= offset + other.length && equals(self, offset, other, 0, other.length);
    }

    /*
    * @dev Returns true if the two byte ranges are equal.
    * @param self The first byte range to compare.
    * @param other The second byte range to compare.
    * @return True if the byte ranges are equal, false otherwise.
    */
    function equals(bytes memory self, bytes memory other) internal pure returns(bool) {
        return self.length == other.length && equals(self, 0, other, 0, self.length);
    }

    /*
    * @dev Returns the 8-bit number at the specified index of self.
    * @param self The byte string.
    * @param idx The index into the bytes
    * @return The specified 8 bits of the string, interpreted as an integer.
    */
    function readUint8(bytes memory self, uint idx) internal pure returns (uint8 ret) {
        return uint8(self[idx]);
    }

    /*
    * @dev Returns the 16-bit number at the specified index of self.
    * @param self The byte string.
    * @param idx The index into the bytes
    * @return The specified 16 bits of the string, interpreted as an integer.
    */
    function readUint16(bytes memory self, uint idx) internal pure returns (uint16 ret) {
        require(idx + 2 <= self.length);
        assembly {
            ret := and(mload(add(add(self, 2), idx)), 0xFFFF)
        }
    }

    /*
    * @dev Returns the 32-bit number at the specified index of self.
    * @param self The byte string.
    * @param idx The index into the bytes
    * @return The specified 32 bits of the string, interpreted as an integer.
    */
    function readUint32(bytes memory self, uint idx) internal pure returns (uint32 ret) {
        require(idx + 4 <= self.length);
        assembly {
            ret := and(mload(add(add(self, 4), idx)), 0xFFFFFFFF)
        }
    }

    /*
    * @dev Returns the 32 byte value at the specified index of self.
    * @param self The byte string.
    * @param idx The index into the bytes
    * @return The specified 32 bytes of the string.
    */
    function readBytes32(bytes memory self, uint idx) internal pure returns (bytes32 ret) {
        require(idx + 32 <= self.length);
        assembly {
            ret := mload(add(add(self, 32), idx))
        }
    }

    /*
    * @dev Returns the 32 byte value at the specified index of self.
    * @param self The byte string.
    * @param idx The index into the bytes
    * @return The specified 32 bytes of the string.
    */
    function readBytes20(bytes memory self, uint idx) internal pure returns (bytes20 ret) {
        require(idx + 20 <= self.length);
        assembly {
            ret := and(mload(add(add(self, 32), idx)), 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000000)
        }
    }

    /*
    * @dev Returns the n byte value at the specified index of self.
    * @param self The byte string.
    * @param idx The index into the bytes.
    * @param len The number of bytes.
    * @return The specified 32 bytes of the string.
    */
    function readBytesN(bytes memory self, uint idx, uint len) internal pure returns (bytes32 ret) {
        require(len <= 32);
        require(idx + len <= self.length);
        assembly {
            let mask := not(sub(exp(256, sub(32, len)), 1))
            ret := and(mload(add(add(self, 32), idx)),  mask)
        }
    }

    function memcpy(uint dest, uint src, uint len) private pure {
        // 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))
        }
    }

    /*
    * @dev Copies a substring into a new byte string.
    * @param self The byte string to copy from.
    * @param offset The offset to start copying at.
    * @param len The number of bytes to copy.
    */
    function substring(bytes memory self, uint offset, uint len) internal pure returns(bytes memory) {
        require(offset + len <= self.length);

        bytes memory ret = new bytes(len);
        uint dest;
        uint src;

        assembly {
            dest := add(ret, 32)
            src := add(add(self, 32), offset)
        }
        memcpy(dest, src, len);

        return ret;
    }

    // Maps characters from 0x30 to 0x7A to their base32 values.
    // 0xFF represents invalid characters in that range.
    bytes constant base32HexTable = hex'00010203040506070809FFFFFFFFFFFFFF0A0B0C0D0E0F101112131415161718191A1B1C1D1E1FFFFFFFFFFFFFFFFFFFFF0A0B0C0D0E0F101112131415161718191A1B1C1D1E1F';

    /**
     * @dev Decodes unpadded base32 data of up to one word in length.
     * @param self The data to decode.
     * @param off Offset into the string to start at.
     * @param len Number of characters to decode.
     * @return The decoded data, left aligned.
     */
    function base32HexDecodeWord(bytes memory self, uint off, uint len) internal pure returns(bytes32) {
        require(len <= 52);

        uint ret = 0;
        uint8 decoded;
        for(uint i = 0; i < len; i++) {
            bytes1 char = self[off + i];
            require(char >= 0x30 && char <= 0x7A);
            decoded = uint8(base32HexTable[uint(uint8(char)) - 0x30]);
            require(decoded <= 0x20);
            if(i == len - 1) {
                break;
            }
            ret = (ret << 5) | decoded;
        }

        uint bitlen = len * 5;
        if(len % 8 == 0) {
            // Multiple of 8 characters, no padding
            ret = (ret << 5) | decoded;
        } else if(len % 8 == 2) {
            // Two extra characters - 1 byte
            ret = (ret << 3) | (decoded >> 2);
            bitlen -= 2;
        } else if(len % 8 == 4) {
            // Four extra characters - 2 bytes
            ret = (ret << 1) | (decoded >> 4);
            bitlen -= 4;
        } else if(len % 8 == 5) {
            // Five extra characters - 3 bytes
            ret = (ret << 4) | (decoded >> 1);
            bitlen -= 1;
        } else if(len % 8 == 7) {
            // Seven extra characters - 4 bytes
            ret = (ret << 2) | (decoded >> 3);
            bitlen -= 3;
        } else {
            revert();
        }

        return bytes32(ret << (256 - bitlen));
    }
}

// File: @ensdomains/buffer/contracts/Buffer.sol

pragma solidity >0.4.18;

/**
* @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.
    * @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 Initializes a new buffer from an existing bytes object.
    *      Changes to the buffer may mutate the original value.
    * @param b The bytes object to initialize the buffer with.
    * @return A new buffer.
    */
    function fromBytes(bytes memory b) internal pure returns(buffer memory) {
        buffer memory buf;
        buf.buf = b;
        buf.capacity = b.length;
        return buf;
    }

    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;
    }

    /**
    * @dev Sets buffer length to 0.
    * @param buf The buffer to truncate.
    * @return The original buffer, for chaining..
    */
    function truncate(buffer memory buf) internal pure returns (buffer memory) {
        assembly {
            let bufptr := mload(buf)
            mstore(bufptr, 0)
        }
        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;
    }

    /**
    * @dev Appends 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 data The data to append.
    * @param len The number of bytes to copy.
    * @return The original buffer, for chaining.
    */
    function append(buffer memory buf, bytes memory data, uint len) internal pure returns (buffer memory) {
        return write(buf, buf.buf.length, data, len);
    }

    /**
    * @dev Appends 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 data The data to append.
    * @return The original buffer, for chaining.
    */
    function append(buffer memory buf, bytes memory data) internal pure returns (buffer memory) {
        return write(buf, buf.buf.length, data, data.length);
    }

    /**
    * @dev Writes a byte to the buffer. Resizes if doing so would exceed the
    *      capacity of the buffer.
    * @param buf The buffer to append to.
    * @param off The offset to write the byte at.
    * @param data The data to append.
    * @return The original buffer, for chaining.
    */
    function writeUint8(buffer memory buf, uint off, uint8 data) internal pure returns(buffer memory) {
        if (off >= buf.capacity) {
            resize(buf, buf.capacity * 2);
        }

        assembly {
            // Memory address of the buffer data
            let bufptr := mload(buf)
            // Length of existing buffer data
            let buflen := mload(bufptr)
            // Address = buffer address + sizeof(buffer length) + off
            let dest := add(add(bufptr, off), 32)
            mstore8(dest, data)
            // Update buffer length if we extended it
            if eq(off, buflen) {
                mstore(bufptr, add(buflen, 1))
            }
        }
        return buf;
    }

    /**
    * @dev Appends a byte to the buffer. Resizes if doing so would exceed the
    *      capacity of the buffer.
    * @param buf The buffer to append to.
    * @param data The data to append.
    * @return The original buffer, for chaining.
    */
    function appendUint8(buffer memory buf, uint8 data) internal pure returns(buffer memory) {
        return writeUint8(buf, buf.buf.length, data);
    }

    /**
    * @dev Writes up to 32 bytes to the buffer. Resizes if doing so would
    *      exceed the capacity of the buffer.
    * @param buf The buffer to append to.
    * @param off The offset to write at.
    * @param data The data to append.
    * @param len The number of bytes to write (left-aligned).
    * @return The original buffer, for chaining.
    */
    function write(buffer memory buf, uint off, bytes32 data, uint len) private pure returns(buffer memory) {
        if (len + off > buf.capacity) {
            resize(buf, (len + off) * 2);
        }

        uint mask = 256 ** len - 1;
        // Right-align data
        data = data >> (8 * (32 - len));
        assembly {
            // Memory address of the buffer data
            let bufptr := mload(buf)
            // Address = buffer address + sizeof(buffer length) + off + len
            let dest := add(add(bufptr, off), len)
            mstore(dest, or(and(mload(dest), not(mask)), data))
            // Update buffer length if we extended it
            if gt(add(off, len), mload(bufptr)) {
                mstore(bufptr, add(off, len))
            }
        }
        return buf;
    }

    /**
    * @dev Writes a bytes20 to the buffer. Resizes if doing so would exceed the
    *      capacity of the buffer.
    * @param buf The buffer to append to.
    * @param off The offset to write at.
    * @param data The data to append.
    * @return The original buffer, for chaining.
    */
    function writeBytes20(buffer memory buf, uint off, bytes20 data) internal pure returns (buffer memory) {
        return write(buf, off, bytes32(data), 20);
    }

    /**
    * @dev Appends a bytes20 to the buffer. Resizes if doing so would exceed
    *      the capacity of the buffer.
    * @param buf The buffer to append to.
    * @param data The data to append.
    * @return The original buffer, for chhaining.
    */
    function appendBytes20(buffer memory buf, bytes20 data) internal pure returns (buffer memory) {
        return write(buf, buf.buf.length, bytes32(data), 20);
    }

    /**
    * @dev Appends a bytes32 to the buffer. Resizes if doing so would exceed
    *      the capacity of the buffer.
    * @param buf The buffer to append to.
    * @param data The data to append.
    * @return The original buffer, for chaining.
    */
    function appendBytes32(buffer memory buf, bytes32 data) internal pure returns (buffer memory) {
        return write(buf, buf.buf.length, data, 32);
    }

    /**
    * @dev Writes an integer to the buffer. Resizes if doing so would exceed
    *      the capacity of the buffer.
    * @param buf The buffer to append to.
    * @param off The offset to write at.
    * @param data The data to append.
    * @param len The number of bytes to write (right-aligned).
    * @return The original buffer, for chaining.
    */
    function writeInt(buffer memory buf, uint off, uint data, uint len) private pure returns(buffer memory) {
        if (len + off > buf.capacity) {
            resize(buf, (len + off) * 2);
        }

        uint mask = 256 ** len - 1;
        assembly {
            // Memory address of the buffer data
            let bufptr := mload(buf)
            // Address = buffer address + off + sizeof(buffer length) + len
            let dest := add(add(bufptr, off), len)
            mstore(dest, or(and(mload(dest), not(mask)), data))
            // Update buffer length if we extended it
            if gt(add(off, len), mload(bufptr)) {
                mstore(bufptr, add(off, len))
            }
        }
        return buf;
    }

    /**
     * @dev Appends a byte to the end of the buffer. Resizes if doing so would
     * exceed the capacity of the buffer.
     * @param buf The buffer to append to.
     * @param data The data to append.
     * @return The original buffer.
     */
    function appendInt(buffer memory buf, uint data, uint len) internal pure returns(buffer memory) {
        return writeInt(buf, buf.buf.length, data, len);
    }
}

// File: @ensdomains/dnssec-oracle/contracts/RRUtils.sol

pragma solidity >0.4.23;



/**
* @dev RRUtils is a library that provides utilities for parsing DNS resource records.
*/
library RRUtils {
    using BytesUtils for *;
    using Buffer for *;

    /**
    * @dev Returns the number of bytes in the DNS name at 'offset' in 'self'.
    * @param self The byte array to read a name from.
    * @param offset The offset to start reading at.
    * @return The length of the DNS name at 'offset', in bytes.
    */
    function nameLength(bytes memory self, uint offset) internal pure returns(uint) {
        uint idx = offset;
        while (true) {
            assert(idx < self.length);
            uint labelLen = self.readUint8(idx);
            idx += labelLen + 1;
            if (labelLen == 0) {
                break;
            }
        }
        return idx - offset;
    }

    /**
    * @dev Returns a DNS format name at the specified offset of self.
    * @param self The byte array to read a name from.
    * @param offset The offset to start reading at.
    * @return The name.
    */
    function readName(bytes memory self, uint offset) internal pure returns(bytes memory ret) {
        uint len = nameLength(self, offset);
        return self.substring(offset, len);
    }

    /**
    * @dev Returns the number of labels in the DNS name at 'offset' in 'self'.
    * @param self The byte array to read a name from.
    * @param offset The offset to start reading at.
    * @return The number of labels in the DNS name at 'offset', in bytes.
    */
    function labelCount(bytes memory self, uint offset) internal pure returns(uint) {
        uint count = 0;
        while (true) {
            assert(offset < self.length);
            uint labelLen = self.readUint8(offset);
            offset += labelLen + 1;
            if (labelLen == 0) {
                break;
            }
            count += 1;
        }
        return count;
    }

    /**
    * @dev An iterator over resource records.
    */
    struct RRIterator {
        bytes data;
        uint offset;
        uint16 dnstype;
        uint16 class;
        uint32 ttl;
        uint rdataOffset;
        uint nextOffset;
    }

    /**
    * @dev Begins iterating over resource records.
    * @param self The byte string to read from.
    * @param offset The offset to start reading at.
    * @return An iterator object.
    */
    function iterateRRs(bytes memory self, uint offset) internal pure returns (RRIterator memory ret) {
        ret.data = self;
        ret.nextOffset = offset;
        next(ret);
    }

    /**
    * @dev Returns true iff there are more RRs to iterate.
    * @param iter The iterator to check.
    * @return True iff the iterator has finished.
    */
    function done(RRIterator memory iter) internal pure returns(bool) {
        return iter.offset >= iter.data.length;
    }

    /**
    * @dev Moves the iterator to the next resource record.
    * @param iter The iterator to advance.
    */
    function next(RRIterator memory iter) internal pure {
        iter.offset = iter.nextOffset;
        if (iter.offset >= iter.data.length) {
            return;
        }

        // Skip the name
        uint off = iter.offset + nameLength(iter.data, iter.offset);

        // Read type, class, and ttl
        iter.dnstype = iter.data.readUint16(off);
        off += 2;
        iter.class = iter.data.readUint16(off);
        off += 2;
        iter.ttl = iter.data.readUint32(off);
        off += 4;

        // Read the rdata
        uint rdataLength = iter.data.readUint16(off);
        off += 2;
        iter.rdataOffset = off;
        iter.nextOffset = off + rdataLength;
    }

    /**
    * @dev Returns the name of the current record.
    * @param iter The iterator.
    * @return A new bytes object containing the owner name from the RR.
    */
    function name(RRIterator memory iter) internal pure returns(bytes memory) {
        return iter.data.substring(iter.offset, nameLength(iter.data, iter.offset));
    }

    /**
    * @dev Returns the rdata portion of the current record.
    * @param iter The iterator.
    * @return A new bytes object containing the RR's RDATA.
    */
    function rdata(RRIterator memory iter) internal pure returns(bytes memory) {
        return iter.data.substring(iter.rdataOffset, iter.nextOffset - iter.rdataOffset);
    }

    /**
    * @dev Checks if a given RR type exists in a type bitmap.
    * @param self The byte string to read the type bitmap from.
    * @param offset The offset to start reading at.
    * @param rrtype The RR type to check for.
    * @return True if the type is found in the bitmap, false otherwise.
    */
    function checkTypeBitmap(bytes memory self, uint offset, uint16 rrtype) internal pure returns (bool) {
        uint8 typeWindow = uint8(rrtype >> 8);
        uint8 windowByte = uint8((rrtype & 0xff) / 8);
        uint8 windowBitmask = uint8(uint8(1) << (uint8(7) - uint8(rrtype & 0x7)));
        for (uint off = offset; off < self.length;) {
            uint8 window = self.readUint8(off);
            uint8 len = self.readUint8(off + 1);
            if (typeWindow < window) {
                // We've gone past our window; it's not here.
                return false;
            } else if (typeWindow == window) {
                // Check this type bitmap
                if (len * 8 <= windowByte) {
                    // Our type is past the end of the bitmap
                    return false;
                }
                return (self.readUint8(off + windowByte + 2) & windowBitmask) != 0;
            } else {
                // Skip this type bitmap
                off += len + 2;
            }
        }

        return false;
    }

    function compareNames(bytes memory self, bytes memory other) internal pure returns (int) {
        if (self.equals(other)) {
            return 0;
        }

        uint off;
        uint otheroff;
        uint prevoff;
        uint otherprevoff;
        uint counts = labelCount(self, 0);
        uint othercounts = labelCount(other, 0);

        // Keep removing labels from the front of the name until both names are equal length
        while (counts > othercounts) {
            prevoff = off;
            off = progress(self, off);
            counts--;
        }

        while (othercounts > counts) {
            otherprevoff = otheroff;
            otheroff = progress(other, otheroff);
            othercounts--;
        }

        // Compare the last nonequal labels to each other
        while (counts > 0 && !self.equals(off, other, otheroff)) {
            prevoff = off;
            off = progress(self, off);
            otherprevoff = otheroff;
            otheroff = progress(other, otheroff);
            counts -= 1;
        }

        if (off == 0) {
            return -1;
        }
        if(otheroff == 0) {
            return 1;
        }

        return self.compare(prevoff + 1, self.readUint8(prevoff), other, otherprevoff + 1, other.readUint8(otherprevoff));
    }

    function progress(bytes memory body, uint off) internal pure returns(uint) {
        return off + 1 + body.readUint8(off);
    }
}

// File: @ensdomains/dnsregistrar/contracts/DNSClaimChecker.sol

pragma solidity ^0.5.0;





library DNSClaimChecker {

    using BytesUtils for bytes;
    using RRUtils for *;
    using Buffer for Buffer.buffer;

    uint16 constant CLASS_INET = 1;
    uint16 constant TYPE_TXT = 16;

    function getLabels(bytes memory name) internal view returns (bytes32, bytes32) {
        uint len = name.readUint8(0);
        uint second = name.readUint8(len + 1);

        require(name.readUint8(len + second + 2) == 0);

        return (name.keccak(1, len), keccak256(abi.encodePacked(bytes32(0), name.keccak(2 + len, second))));
    }

    function getOwnerAddress(DNSSEC oracle, bytes memory name, bytes memory proof)
        internal
        view
        returns (address, bool)
    {
        // Add "_ens." to the front of the name.
        Buffer.buffer memory buf;
        buf.init(name.length + 5);
        buf.append("\x04_ens");
        buf.append(name);
        bytes20 hash;
        uint64 inserted;
        // Check the provided TXT record has been validated by the oracle
        (, inserted, hash) = oracle.rrdata(TYPE_TXT, buf.buf);
        if (hash == bytes20(0) && proof.length == 0) return (address(0x0), false);

        require(hash == bytes20(keccak256(proof)));

        for (RRUtils.RRIterator memory iter = proof.iterateRRs(0); !iter.done(); iter.next()) {
            require(inserted + iter.ttl >= now, "DNS record is stale; refresh or delete it before proceeding.");

            bool found;
            address addr;
            (addr, found) = parseRR(proof, iter.rdataOffset);
            if (found) {
                return (addr, true);
            }
        }

        return (address(0x0), false);
    }

    function parseRR(bytes memory rdata, uint idx) internal pure returns (address, bool) {
        while (idx < rdata.length) {
            uint len = rdata.readUint8(idx); idx += 1;

            bool found;
            address addr;
            (addr, found) = parseString(rdata, idx, len);

            if (found) return (addr, true);
            idx += len;
        }

        return (address(0x0), false);
    }

    function parseString(bytes memory str, uint idx, uint len) internal pure returns (address, bool) {
        // TODO: More robust parsing that handles whitespace and multiple key/value pairs
        if (str.readUint32(idx) != 0x613d3078) return (address(0x0), false); // 0x613d3078 == 'a=0x'
        if (len < 44) return (address(0x0), false);
        return hexToAddress(str, idx + 4);
    }

    function hexToAddress(bytes memory str, uint idx) internal pure returns (address, bool) {
        if (str.length - idx < 40) return (address(0x0), false);
        uint ret = 0;
        for (uint i = idx; i < idx + 40; i++) {
            ret <<= 4;
            uint x = str.readUint8(i);
            if (x >= 48 && x < 58) {
                ret |= x - 48;
            } else if (x >= 65 && x < 71) {
                ret |= x - 55;
            } else if (x >= 97 && x < 103) {
                ret |= x - 87;
            } else {
                return (address(0x0), false);
            }
        }
        return (address(ret), true);
    }

}

// File: @ensdomains/dnsregistrar/contracts/DNSRegistrar.sol

pragma solidity ^0.5.0;




/**
 * @dev An ENS registrar that allows the owner of a DNS name to claim the
 *      corresponding name in ENS.
 */
contract DNSRegistrar {

    DNSSEC public oracle;
    ENS public ens;

    bytes4 constant private INTERFACE_META_ID = bytes4(keccak256("supportsInterface(bytes4)"));
    bytes4 constant private DNSSEC_CLAIM_ID = bytes4(
        keccak256("claim(bytes,bytes)") ^
        keccak256("proveAndClaim(bytes,bytes,bytes)") ^
        keccak256("oracle()")
    );

    event Claim(bytes32 indexed node, address indexed owner, bytes dnsname);

    constructor(DNSSEC _dnssec, ENS _ens) public {
        oracle = _dnssec;
        ens = _ens;
    }

    /**
     * @dev Claims a name by proving ownership of its DNS equivalent.
     * @param name The name to claim, in DNS wire format.
     * @param proof A DNS RRSet proving ownership of the name. Must be verified
     *        in the DNSSEC oracle before calling. This RRSET must contain a TXT
     *        record for '_ens.' + name, with the value 'a=0x...'. Ownership of
     *        the name will be transferred to the address specified in the TXT
     *        record.
     */
    function claim(bytes memory name, bytes memory proof) public {
        address addr;
        (addr,) = DNSClaimChecker.getOwnerAddress(oracle, name, proof);

        bytes32 labelHash;
        bytes32 rootNode;
        (labelHash, rootNode) = DNSClaimChecker.getLabels(name);

        ens.setSubnodeOwner(rootNode, labelHash, addr);
        emit Claim(keccak256(abi.encodePacked(rootNode, labelHash)), addr, name);
    }

    /**
     * @dev Submits proofs to the DNSSEC oracle, then claims a name using those proofs.
     * @param name The name to claim, in DNS wire format.
     * @param input The data to be passed to the Oracle's `submitProofs` function. The last
     *        proof must be the TXT record required by the registrar.
     * @param proof The proof record for the first element in input.
     */
    function proveAndClaim(bytes memory name, bytes memory input, bytes memory proof) public {
        proof = oracle.submitRRSets(input, proof);
        claim(name, proof);
    }

    function supportsInterface(bytes4 interfaceID) external pure returns (bool) {
        return interfaceID == INTERFACE_META_ID ||
               interfaceID == DNSSEC_CLAIM_ID;
    }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"contract DNSSEC","name":"_dnssec","type":"address"},{"internalType":"contract ENS","name":"_ens","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"node","type":"bytes32"},{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"bytes","name":"dnsname","type":"bytes"}],"name":"Claim","type":"event"},{"constant":false,"inputs":[{"internalType":"bytes","name":"name","type":"bytes"},{"internalType":"bytes","name":"proof","type":"bytes"}],"name":"claim","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"ens","outputs":[{"internalType":"contract ENS","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"oracle","outputs":[{"internalType":"contract DNSSEC","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"bytes","name":"name","type":"bytes"},{"internalType":"bytes","name":"input","type":"bytes"},{"internalType":"bytes","name":"proof","type":"bytes"}],"name":"proveAndClaim","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"bytes4","name":"interfaceID","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"pure","type":"function"}]

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

00000000000000000000000058a6618b3049c113460ab4ec62f2c68996e9ed7c00000000000000000000000000000000000c2e074ec69a0dfb2997ba6c7d2e1e

-----Decoded View---------------
Arg [0] : _dnssec (address): 0x58a6618b3049C113460AB4eC62f2c68996E9eD7C
Arg [1] : _ens (address): 0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 00000000000000000000000058a6618b3049c113460ab4ec62f2c68996e9ed7c
Arg [1] : 00000000000000000000000000000000000c2e074ec69a0dfb2997ba6c7d2e1e


Deployed ByteCode Sourcemap

41907:2269:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;41907:2269:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43989:184;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;43989:184:0;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;41965:14;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;41938:20;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;42965:430;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;42965:430:0;;;;;;;;;;21:11:-1;8;5:28;2:2;;;46:1;43;36:12;2:2;42965:430:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;42965:430:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;42965:430:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;42965:430:0;;;;;;;;;;;;;;;;;21:11:-1;8;5:28;2:2;;;46:1;43;36:12;2:2;42965:430:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;42965:430:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;42965:430:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;42965:430:0;;;;;;;;;;;;;;;:::i;:::-;;43803:178;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;43803:178:0;;;;;;;;;;21:11:-1;8;5:28;2:2;;;46:1;43;36:12;2:2;43803:178:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;43803:178:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;43803:178:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;43803:178:0;;;;;;;;;;;;;;;;;21:11:-1;8;5:28;2:2;;;46:1;43;36:12;2:2;43803:178:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;43803:178:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;43803:178:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;43803:178:0;;;;;;;;;;;;;;;;;21:11:-1;8;5:28;2:2;;;46:1;43;36:12;2:2;43803:178:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;43803:178:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;43803:178:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;43803:178:0;;;;;;;;;;;;;;;:::i;:::-;;43989:184;44059:4;42039:38;;;;;;;;;;;;;;;;;;;44083:32;;;:11;:32;;;;:82;;;;42244:21;;;;;;;;;;;;;;;;;;;42187:45;;;;;;;;;;;;;;;;;;;42144:31;;;;;;;;;;;;;;;;;;;:88;:121;44135:30;;;:11;:30;;;;44083:82;44076:89;;43989:184;;;:::o;41965:14::-;;;;;;;;;;;;;:::o;41938:20::-;;;;;;;;;;;;;:::o;42965:430::-;43037:12;43070:52;43102:6;;;;;;;;;;;43110:4;43116:5;43070:31;:52::i;:::-;43060:62;;;;;43135:17;43163:16;43214:31;43240:4;43214:25;:31::i;:::-;43190:55;;;;;;;;43258:3;;;;;;;;;;;:19;;;43278:8;43288:9;43299:4;43258:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;43258:46:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;43258:46:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;43258:46:0;;;;;;;;;;;;;;;;;43376:4;43320:67;;43353:8;43363:9;43336:37;;;;;;;;;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;43336:37:0;;;43326:48;;;;;;43320:67;43382:4;43320:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;43320:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42965:430;;;;;:::o;43803:178::-;43911:6;;;;;;;;;;;:19;;;43931:5;43938;43911:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;43911:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;43911:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;43911:33:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;43911:33:0;;;;;;39:16:-1;36:1;17:17;2:54;43911:33:0;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;13:2;8:3;5:11;2:2;;;29:1;26;19:12;2:2;43911:33:0;;;;;;;;;;;;;19:11:-1;14:3;11:20;8:2;;;44:1;41;34:12;8:2;71:11;66:3;62:21;55:28;;123:4;118:3;114:14;159:9;141:16;138:31;135:2;;;182:1;179;172:12;135:2;219:3;213:10;330:9;325:1;311:12;307:20;289:16;285:43;282:58;261:11;247:12;244:29;233:115;230:2;;;361:1;358;351:12;230:2;384:12;379:3;372:25;420:4;415:3;411:14;404:21;;0:432;;43911:33:0;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;43911:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43903:41;;43955:18;43961:4;43967:5;43955;:18::i;:::-;43803:178;;;:::o;39055:1126::-;39184:7;39193:4;39265:24;;:::i;:::-;39300:25;39323:1;39309:4;:11;:15;39300:3;:8;;:25;;;;:::i;:::-;;39336:22;;;;;;;;;;;;;;;;;;:3;:10;;:22;;;;:::i;:::-;;39369:16;39380:4;39369:3;:10;;:16;;;;:::i;:::-;;39396:12;39419:15;39541:6;:13;;;38691:2;39565:3;:7;;;39541:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;39541:32:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;39541:32:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;39541:32:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;39541:32:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39520:53;;;;;;;;;;;39604:1;39596:10;;39588:18;;;:4;:18;;;;:39;;;;;39626:1;39610:5;:12;:17;39588:39;39584:73;;;39645:3;39651:5;39629:28;;;;;;;;;;;;39584:73;39704:5;39694:16;;;;;;39678:33;;;:4;:33;;;;39670:42;;;;;;39730:30;;:::i;:::-;39763:19;39780:1;39763:5;:16;;:19;;;;:::i;:::-;39730:52;;39725:408;39785:11;:4;:9;:11::i;:::-;39725:408;;39857:3;39845:4;:8;;;39834:19;;:8;:19;:26;;;;39826:99;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39942:10;39967:12;40010:32;40018:5;40025:4;:16;;;40010:7;:32::i;:::-;39994:48;;;;;;;;40061:5;40057:65;;;40095:4;40101;40087:19;;;;;;;;;;;;40057:65;39725:408;;39798:11;:4;:9;:11::i;:::-;39725:408;;;;40161:3;40167:5;40145:28;;;;;;;;;;39055:1126;;;;;;;:::o;38702:345::-;38763:7;38772;38792:8;38803:17;38818:1;38803:4;:14;;:17;;;;:::i;:::-;38792:28;;;;38831:11;38845:23;38866:1;38860:3;:7;38845:4;:14;;:23;;;;:::i;:::-;38831:37;;;;38925:1;38889:32;38919:1;38910:6;38904:3;:12;:16;38889:4;:14;;:32;;;;:::i;:::-;:37;;;38881:46;;;;;;38948:19;38960:1;38963:3;38948:4;:11;;:19;;;;;:::i;:::-;39004:1;38996:10;;39008:28;39024:3;39020:1;:7;39029:6;39008:4;:11;;:28;;;;;:::i;:::-;38979:58;;;;;;;;;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;38979:58:0;;;38969:69;;;;;;38940:99;;;;;;38702:345;;;:::o;21123:468::-;21193:13;;:::i;:::-;21240:1;21234:2;21223:8;:13;;;;;;:18;21219:83;;21287:2;21276:8;:13;;;;;;21270:2;:20;21258:32;;;;21219:83;21374:8;21359:3;:12;;:23;;;;;21434:4;21428:11;21465:3;21460;21453:16;21495:1;21490:3;21483:14;21541:8;21536:3;21532:18;21528:2;21524:27;21518:4;21511:41;21402:161;21580:3;21573:10;;21123:468;;;;:::o;25216:163::-;25293:13;;:::i;:::-;25326:45;25332:3;25337;:7;;;:14;25353:4;25359;:11;25326:5;:45::i;:::-;25319:52;;25216:163;;;;:::o;33480:186::-;33555:21;;:::i;:::-;33600:4;33589:3;:8;;:15;;;;33632:6;33615:3;:14;;:23;;;;;33649:9;33654:3;33649:4;:9::i;:::-;33480:186;;;;:::o;33844:123::-;33904:4;33943;:9;;;:16;33928:4;:11;;;:31;;33921:38;;33844:123;;;:::o;40189:424::-;40259:7;40268:4;40285:280;40298:5;:12;40292:3;:18;40285:280;;;40327:8;40338:20;40354:3;40338:5;:15;;:20;;;;:::i;:::-;40327:31;;;;40367:1;40360:8;;;;40385:10;40410:12;40453:28;40465:5;40472:3;40477;40453:11;:28::i;:::-;40437:44;;;;;;;;40502:5;40498:30;;;40517:4;40523;40509:19;;;;;;;;;40498:30;40550:3;40543:10;;;;40285:280;;;;;;40593:3;40599:5;40577:28;;;;;;;40189:424;;;;;;:::o;34096:704::-;34173:4;:15;;;34159:4;:11;;:29;;;;;34218:4;:9;;;:16;34203:4;:11;;;:31;34199:70;;34251:7;;34199:70;34307:8;34332:34;34343:4;:9;;;34354:4;:11;;;34332:10;:34::i;:::-;34318:4;:11;;;:48;34307:59;;34432:25;34453:3;34432:4;:9;;;:20;;:25;;;;:::i;:::-;34417:4;:12;;:40;;;;;;;;;;;34475:1;34468:8;;;;34500:25;34521:3;34500:4;:9;;;:20;;:25;;;;:::i;:::-;34487:4;:10;;:38;;;;;;;;;;;34543:1;34536:8;;;;34566:25;34587:3;34566:4;:9;;;:20;;:25;;;;:::i;:::-;34555:4;:8;;:36;;;;;;;;;;;34609:1;34602:8;;;;34650:16;34669:25;34690:3;34669:4;:9;;;:20;;:25;;;;:::i;:::-;34650:44;;;;34712:1;34705:8;;;;34743:3;34724:4;:16;;:22;;;;;34781:11;34775:3;:17;34757:4;:15;;:35;;;;;34096:704;;;;:::o;14161:124::-;14232:9;14267:4;14272:3;14267:9;;;;;;;;;;;;;;;;14261:16;;14254:23;;14161:124;;;;:::o;9012:243::-;9093:11;9141:4;:11;9134:3;9125:6;:12;:27;;9117:36;;;;;;9233:3;9224:6;9219:2;9213:4;9209:13;9205:26;9195:42;9188:49;;9173:75;;;;;:::o;23083:1367::-;23178:13;;:::i;:::-;23219:4;:11;23212:3;:18;;23204:27;;;;;;23260:3;:12;;;23254:3;23248;:9;:24;23244:102;;;23289:45;23296:3;23332:1;23301:28;23305:3;:12;;;23325:3;23319;:9;23301:3;:28::i;:::-;:32;23289:6;:45::i;:::-;23244:102;23358:9;23378:8;23491:3;23485:10;23576:6;23570:13;23706:3;23701:2;23693:6;23689:15;23685:25;23677:33;;23804:6;23798:3;23793;23789:13;23786:25;23783:2;;;23855:3;23850;23846:13;23838:6;23831:29;23783:2;23906;23900:4;23896:13;23889:20;;23406:514;;23983:171;23997:2;23990:3;:9;23983:171;;24074:3;24068:10;24062:4;24055:24;24116:2;24108:10;;;;24140:2;24133:9;;;;24008:2;24001:9;;;;23983:171;;;24199:9;24231:1;24224:3;24219:2;:8;24211:3;:17;:21;24199:33;;24302:4;24298:9;24292:3;24286:10;24282:26;24355:4;24348;24342:11;24338:22;24400:7;24390:8;24387:21;24381:4;24374:35;24252:168;;24439:3;24432:10;;;;;23083:1367;;;;;;:::o;40621:395::-;40703:7;40712:4;40847:10;40824:19;40839:3;40824;:14;;:19;;;;:::i;:::-;:33;;;40820:67;;40875:3;40881:5;40859:28;;;;;;;;;40820:67;40932:2;40926:3;:8;40922:42;;;40952:3;40958:5;40936:28;;;;;;;;;40922:42;40982:26;40995:3;41006:1;41000:3;:7;40982:12;:26::i;:::-;40975:33;;;;40621:395;;;;;;;:::o;31517:378::-;31591:4;31608:8;31619:6;31608:17;;31636:222;31643:4;31636:222;;;31677:4;:11;31671:3;:17;31664:25;;;;31704:13;31720:19;31735:3;31720:4;:14;;:19;;;;:::i;:::-;31704:35;;;;31772:1;31761:8;:12;31754:19;;;;31804:1;31792:8;:13;31788:59;;;31826:5;;;31788:59;31636:222;;;;31881:6;31875:3;:12;31868:19;;;31517:378;;;;:::o;14537:228::-;14609:10;14651:4;:11;14646:1;14640:3;:7;:22;;14632:31;;;;;;14740:6;14733:3;14729:1;14723:4;14719:12;14715:22;14709:29;14705:42;14698:49;;14683:75;;;;:::o;15017:232::-;15089:10;15131:4;:11;15126:1;15120:3;:7;:22;;15112:31;;;;;;15220:10;15213:3;15209:1;15203:4;15199:12;15195:22;15189:29;15185:46;15178:53;;15163:79;;;;:::o;22214:139::-;22264:4;22289:1;22285;:5;22281:46;;;22314:1;22307:8;;;;22281:46;22344:1;22337:8;;22214:139;;;;;:::o;22035:171::-;22109:19;22131:3;:7;;;22109:29;;22149:19;22154:3;22159:8;22149:4;:19::i;:::-;;22179;22186:3;22191:6;22179;:19::i;:::-;;22035:171;;;:::o;41024:656::-;41097:7;41106:4;41146:2;41140:3;41127;:10;:16;:21;41123:55;;;41166:3;41172:5;41150:28;;;;;;;;;41123:55;41189:8;41200:1;41189:12;;41217:6;41226:3;41217:12;;41212:423;41241:2;41235:3;:8;41231:1;:12;41212:423;;;41273:1;41265:9;;;;;41289:6;41298:16;41312:1;41298:3;:13;;:16;;;;:::i;:::-;41289:25;;;;41338:2;41333:1;:7;;:17;;;;;41348:2;41344:1;:6;41333:17;41329:295;;;41382:2;41378:1;:6;41371:13;;;;41329:295;;;41415:2;41410:1;:7;;:17;;;;;41425:2;41421:1;:6;41410:17;41406:218;;;41459:2;41455:1;:6;41448:13;;;;41406:218;;;41492:2;41487:1;:7;;:18;;;;;41502:3;41498:1;:7;41487:18;41483:141;;;41537:2;41533:1;:6;41526:13;;;;41483:141;;;41596:3;41602:5;41580:28;;;;;;;;;;;;41483:141;41406:218;41329:295;41212:423;41245:3;;;;;;;41212:423;;;;41661:3;41667:4;41645:27;;;;;;;;41024:656;;;;;;:::o;41907:2269::-;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o

Swarm Source

bzzr://d76dc26a3cdd3b49801c7ef99757cc79e7e6156f3d53b70380459ea54cae68aa
Block Transaction Difficulty Gas Used Reward
Block Uncle Number Difficulty Gas Used Reward
Loading
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.

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.