{ "address": "0x7C423BB94844E734d347d794C88057cf0C68c321", "transactionHash": "0x84f62b5a276f40a7e033ff6cbd110b0486ce10e7bc2695fac30f5010c46db7d8", "abi": [ { "inputs": [ { "internalType": "bytes", "name": "salt", "type": "bytes" }, { "internalType": "bytes", "name": "data", "type": "bytes" }, { "internalType": "uint256", "name": "iterations", "type": "uint256" } ], "name": "hash", "outputs": [ { "internalType": "bytes32", "name": "", "type": "bytes32" } ], "stateMutability": "pure", "type": "function" } ], "transactionHash": "0x84f62b5a276f40a7e033ff6cbd110b0486ce10e7bc2695fac30f5010c46db7d8", "receipt": { "to": null, "from": "0xa303ddC620aa7d1390BACcc8A495508B183fab59", "contractAddress": "0x7C423BB94844E734d347d794C88057cf0C68c321", "transactionIndex": 3, "gasUsed": "752907", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "blockHash": "0x24123b63dd143f6ff63df1746b2cafacb0c8f32f76170b781ca9e30c9105f049", "transactionHash": "0x84f62b5a276f40a7e033ff6cbd110b0486ce10e7bc2695fac30f5010c46db7d8", "logs": [], "blockNumber": 6470039, "cumulativeGasUsed": "1093773", "status": 1, "byzantium": true }, "args": [], "solcInputHash": "7948b60c3b601df824761a337a51d661", "metadata": "{\"compiler\":{\"version\":\"0.8.4+commit.c7e474f2\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"salt\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"iterations\",\"type\":\"uint256\"}],\"name\":\"hash\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}],\"devdoc\":{\"details\":\"Implements the DNSSEC iterated SHA1 digest used for NSEC3 records.\",\"kind\":\"dev\",\"methods\":{\"hash(bytes,bytes,uint256)\":{\"details\":\"Performs an NSEC3 iterated hash.\",\"params\":{\"data\":\"The data to hash.\",\"iterations\":\"The number of iterations to perform.\",\"salt\":\"The salt value to use on each iteration.\"},\"returns\":{\"_0\":\"The result of the iterated hash operation.\"}}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/dnssec-oracle/nsec3digests/SHA1NSEC3Digest.sol\":\"SHA1NSEC3Digest\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":10000},\"remappings\":[]},\"sources\":{\"@ensdomains/buffer/contracts/Buffer.sol\":{\"content\":\"pragma solidity ^0.8.4;\\n\\n/**\\n* @dev A library for working with mutable byte buffers in Solidity.\\n*\\n* Byte buffers are mutable and expandable, and provide a variety of primitives\\n* for writing to them. At any time you can fetch a bytes object containing the\\n* current contents of the buffer. The bytes object should not be stored between\\n* operations, as it may change due to resizing of the buffer.\\n*/\\nlibrary Buffer {\\n /**\\n * @dev Represents a mutable buffer. Buffers have a current value (buf) and\\n * a capacity. The capacity may be longer than the current value, in\\n * which case it can be extended without the need to allocate more memory.\\n */\\n struct buffer {\\n bytes buf;\\n uint capacity;\\n }\\n\\n /**\\n * @dev Initializes a buffer with an initial capacity.\\n * @param buf The buffer to initialize.\\n * @param capacity The number of bytes of space to allocate the buffer.\\n * @return The buffer, for chaining.\\n */\\n function init(buffer memory buf, uint capacity) internal pure returns(buffer memory) {\\n if (capacity % 32 != 0) {\\n capacity += 32 - (capacity % 32);\\n }\\n // Allocate space for the buffer data\\n buf.capacity = capacity;\\n assembly {\\n let ptr := mload(0x40)\\n mstore(buf, ptr)\\n mstore(ptr, 0)\\n mstore(0x40, add(32, add(ptr, capacity)))\\n }\\n return buf;\\n }\\n\\n /**\\n * @dev Initializes a new buffer from an existing bytes object.\\n * Changes to the buffer may mutate the original value.\\n * @param b The bytes object to initialize the buffer with.\\n * @return A new buffer.\\n */\\n function fromBytes(bytes memory b) internal pure returns(buffer memory) {\\n buffer memory buf;\\n buf.buf = b;\\n buf.capacity = b.length;\\n return buf;\\n }\\n\\n function resize(buffer memory buf, uint capacity) private pure {\\n bytes memory oldbuf = buf.buf;\\n init(buf, capacity);\\n append(buf, oldbuf);\\n }\\n\\n function max(uint a, uint b) private pure returns(uint) {\\n if (a > b) {\\n return a;\\n }\\n return b;\\n }\\n\\n /**\\n * @dev Sets buffer length to 0.\\n * @param buf The buffer to truncate.\\n * @return The original buffer, for chaining..\\n */\\n function truncate(buffer memory buf) internal pure returns (buffer memory) {\\n assembly {\\n let bufptr := mload(buf)\\n mstore(bufptr, 0)\\n }\\n return buf;\\n }\\n\\n /**\\n * @dev Writes a byte string to a buffer. Resizes if doing so would exceed\\n * the capacity of the buffer.\\n * @param buf The buffer to append to.\\n * @param off The start offset to write to.\\n * @param data The data to append.\\n * @param len The number of bytes to copy.\\n * @return The original buffer, for chaining.\\n */\\n function write(buffer memory buf, uint off, bytes memory data, uint len) internal pure returns(buffer memory) {\\n require(len <= data.length);\\n\\n if (off + len > buf.capacity) {\\n resize(buf, max(buf.capacity, len + off) * 2);\\n }\\n\\n uint dest;\\n uint src;\\n assembly {\\n // Memory address of the buffer data\\n let bufptr := mload(buf)\\n // Length of existing buffer data\\n let buflen := mload(bufptr)\\n // Start address = buffer address + offset + sizeof(buffer length)\\n dest := add(add(bufptr, 32), off)\\n // Update buffer length if we're extending it\\n if gt(add(len, off), buflen) {\\n mstore(bufptr, add(len, off))\\n }\\n src := add(data, 32)\\n }\\n\\n // Copy word-length chunks while possible\\n for (; len >= 32; len -= 32) {\\n assembly {\\n mstore(dest, mload(src))\\n }\\n dest += 32;\\n src += 32;\\n }\\n\\n // Copy remaining bytes\\n unchecked {\\n uint mask = (256 ** (32 - len)) - 1;\\n assembly {\\n let srcpart := and(mload(src), not(mask))\\n let destpart := and(mload(dest), mask)\\n mstore(dest, or(destpart, srcpart))\\n }\\n }\\n\\n return buf;\\n }\\n\\n /**\\n * @dev Appends a byte string to a buffer. Resizes if doing so would exceed\\n * the capacity of the buffer.\\n * @param buf The buffer to append to.\\n * @param data The data to append.\\n * @param len The number of bytes to copy.\\n * @return The original buffer, for chaining.\\n */\\n function append(buffer memory buf, bytes memory data, uint len) internal pure returns (buffer memory) {\\n return write(buf, buf.buf.length, data, len);\\n }\\n\\n /**\\n * @dev Appends a byte string to a buffer. Resizes if doing so would exceed\\n * the capacity of the buffer.\\n * @param buf The buffer to append to.\\n * @param data The data to append.\\n * @return The original buffer, for chaining.\\n */\\n function append(buffer memory buf, bytes memory data) internal pure returns (buffer memory) {\\n return write(buf, buf.buf.length, data, data.length);\\n }\\n\\n /**\\n * @dev Writes a byte to the buffer. Resizes if doing so would exceed the\\n * capacity of the buffer.\\n * @param buf The buffer to append to.\\n * @param off The offset to write the byte at.\\n * @param data The data to append.\\n * @return The original buffer, for chaining.\\n */\\n function writeUint8(buffer memory buf, uint off, uint8 data) internal pure returns(buffer memory) {\\n if (off >= buf.capacity) {\\n resize(buf, buf.capacity * 2);\\n }\\n\\n assembly {\\n // Memory address of the buffer data\\n let bufptr := mload(buf)\\n // Length of existing buffer data\\n let buflen := mload(bufptr)\\n // Address = buffer address + sizeof(buffer length) + off\\n let dest := add(add(bufptr, off), 32)\\n mstore8(dest, data)\\n // Update buffer length if we extended it\\n if eq(off, buflen) {\\n mstore(bufptr, add(buflen, 1))\\n }\\n }\\n return buf;\\n }\\n\\n /**\\n * @dev Appends a byte to the buffer. Resizes if doing so would exceed the\\n * capacity of the buffer.\\n * @param buf The buffer to append to.\\n * @param data The data to append.\\n * @return The original buffer, for chaining.\\n */\\n function appendUint8(buffer memory buf, uint8 data) internal pure returns(buffer memory) {\\n return writeUint8(buf, buf.buf.length, data);\\n }\\n\\n /**\\n * @dev Writes up to 32 bytes to the buffer. Resizes if doing so would\\n * exceed the capacity of the buffer.\\n * @param buf The buffer to append to.\\n * @param off The offset to write at.\\n * @param data The data to append.\\n * @param len The number of bytes to write (left-aligned).\\n * @return The original buffer, for chaining.\\n */\\n function write(buffer memory buf, uint off, bytes32 data, uint len) private pure returns(buffer memory) {\\n if (len + off > buf.capacity) {\\n resize(buf, (len + off) * 2);\\n }\\n\\n unchecked {\\n uint mask = (256 ** len) - 1;\\n // Right-align data\\n data = data >> (8 * (32 - len));\\n assembly {\\n // Memory address of the buffer data\\n let bufptr := mload(buf)\\n // Address = buffer address + sizeof(buffer length) + off + len\\n let dest := add(add(bufptr, off), len)\\n mstore(dest, or(and(mload(dest), not(mask)), data))\\n // Update buffer length if we extended it\\n if gt(add(off, len), mload(bufptr)) {\\n mstore(bufptr, add(off, len))\\n }\\n }\\n }\\n return buf;\\n }\\n\\n /**\\n * @dev Writes a bytes20 to the buffer. Resizes if doing so would exceed the\\n * capacity of the buffer.\\n * @param buf The buffer to append to.\\n * @param off The offset to write at.\\n * @param data The data to append.\\n * @return The original buffer, for chaining.\\n */\\n function writeBytes20(buffer memory buf, uint off, bytes20 data) internal pure returns (buffer memory) {\\n return write(buf, off, bytes32(data), 20);\\n }\\n\\n /**\\n * @dev Appends a bytes20 to the buffer. Resizes if doing so would exceed\\n * the capacity of the buffer.\\n * @param buf The buffer to append to.\\n * @param data The data to append.\\n * @return The original buffer, for chhaining.\\n */\\n function appendBytes20(buffer memory buf, bytes20 data) internal pure returns (buffer memory) {\\n return write(buf, buf.buf.length, bytes32(data), 20);\\n }\\n\\n /**\\n * @dev Appends a bytes32 to the buffer. Resizes if doing so would exceed\\n * the capacity of the buffer.\\n * @param buf The buffer to append to.\\n * @param data The data to append.\\n * @return The original buffer, for chaining.\\n */\\n function appendBytes32(buffer memory buf, bytes32 data) internal pure returns (buffer memory) {\\n return write(buf, buf.buf.length, data, 32);\\n }\\n\\n /**\\n * @dev Writes an integer to the buffer. Resizes if doing so would exceed\\n * the capacity of the buffer.\\n * @param buf The buffer to append to.\\n * @param off The offset to write at.\\n * @param data The data to append.\\n * @param len The number of bytes to write (right-aligned).\\n * @return The original buffer, for chaining.\\n */\\n function writeInt(buffer memory buf, uint off, uint data, uint len) private pure returns(buffer memory) {\\n if (len + off > buf.capacity) {\\n resize(buf, (len + off) * 2);\\n }\\n\\n uint mask = (256 ** len) - 1;\\n assembly {\\n // Memory address of the buffer data\\n let bufptr := mload(buf)\\n // Address = buffer address + off + sizeof(buffer length) + len\\n let dest := add(add(bufptr, off), len)\\n mstore(dest, or(and(mload(dest), not(mask)), data))\\n // Update buffer length if we extended it\\n if gt(add(off, len), mload(bufptr)) {\\n mstore(bufptr, add(off, len))\\n }\\n }\\n return buf;\\n }\\n\\n /**\\n * @dev Appends a byte to the end of the buffer. Resizes if doing so would\\n * exceed the capacity of the buffer.\\n * @param buf The buffer to append to.\\n * @param data The data to append.\\n * @return The original buffer.\\n */\\n function appendInt(buffer memory buf, uint data, uint len) internal pure returns(buffer memory) {\\n return writeInt(buf, buf.buf.length, data, len);\\n }\\n}\\n\",\"keccak256\":\"0x18e42be1a3e4f7b4442d7ab0b524af5e09163503439954faf0ab3792cce91caa\"},\"contracts/dnssec-oracle/SHA1.sol\":{\"content\":\"pragma solidity >=0.8.4;\\n\\nlibrary SHA1 {\\n event Debug(bytes32 x);\\n\\n function sha1(bytes memory data) internal pure returns(bytes20 ret) {\\n assembly {\\n // Get a safe scratch location\\n let scratch := mload(0x40)\\n\\n // Get the data length, and point data at the first byte\\n let len := mload(data)\\n data := add(data, 32)\\n\\n // Find the length after padding\\n let totallen := add(and(add(len, 1), 0xFFFFFFFFFFFFFFC0), 64)\\n switch lt(sub(totallen, len), 9)\\n case 1 { totallen := add(totallen, 64) }\\n\\n let h := 0x6745230100EFCDAB890098BADCFE001032547600C3D2E1F0\\n\\n function readword(ptr, off, count) -> result {\\n result := 0\\n if lt(off, count) {\\n result := mload(add(ptr, off))\\n count := sub(count, off)\\n if lt(count, 32) {\\n let mask := not(sub(exp(256, sub(32, count)), 1))\\n result := and(result, mask)\\n }\\n }\\n }\\n\\n for { let i := 0 } lt(i, totallen) { i := add(i, 64) } {\\n mstore(scratch, readword(data, i, len))\\n mstore(add(scratch, 32), readword(data, add(i, 32), len))\\n\\n // If we loaded the last byte, store the terminator byte\\n switch lt(sub(len, i), 64)\\n case 1 { mstore8(add(scratch, sub(len, i)), 0x80) }\\n\\n // If this is the last block, store the length\\n switch eq(i, sub(totallen, 64))\\n case 1 { mstore(add(scratch, 32), or(mload(add(scratch, 32)), mul(len, 8))) }\\n\\n // Expand the 16 32-bit words into 80\\n for { let j := 64 } lt(j, 128) { j := add(j, 12) } {\\n let temp := xor(xor(mload(add(scratch, sub(j, 12))), mload(add(scratch, sub(j, 32)))), xor(mload(add(scratch, sub(j, 56))), mload(add(scratch, sub(j, 64)))))\\n temp := or(and(mul(temp, 2), 0xFFFFFFFEFFFFFFFEFFFFFFFEFFFFFFFEFFFFFFFEFFFFFFFEFFFFFFFEFFFFFFFE), and(div(temp, 0x80000000), 0x0000000100000001000000010000000100000001000000010000000100000001))\\n mstore(add(scratch, j), temp)\\n }\\n for { let j := 128 } lt(j, 320) { j := add(j, 24) } {\\n let temp := xor(xor(mload(add(scratch, sub(j, 24))), mload(add(scratch, sub(j, 64)))), xor(mload(add(scratch, sub(j, 112))), mload(add(scratch, sub(j, 128)))))\\n temp := or(and(mul(temp, 4), 0xFFFFFFFCFFFFFFFCFFFFFFFCFFFFFFFCFFFFFFFCFFFFFFFCFFFFFFFCFFFFFFFC), and(div(temp, 0x40000000), 0x0000000300000003000000030000000300000003000000030000000300000003))\\n mstore(add(scratch, j), temp)\\n }\\n\\n let x := h\\n let f := 0\\n let k := 0\\n for { let j := 0 } lt(j, 80) { j := add(j, 1) } {\\n switch div(j, 20)\\n case 0 {\\n // f = d xor (b and (c xor d))\\n f := xor(div(x, 0x100000000000000000000), div(x, 0x10000000000))\\n f := and(div(x, 0x1000000000000000000000000000000), f)\\n f := xor(div(x, 0x10000000000), f)\\n k := 0x5A827999\\n }\\n case 1{\\n // f = b xor c xor d\\n f := xor(div(x, 0x1000000000000000000000000000000), div(x, 0x100000000000000000000))\\n f := xor(div(x, 0x10000000000), f)\\n k := 0x6ED9EBA1\\n }\\n case 2 {\\n // f = (b and c) or (d and (b or c))\\n f := or(div(x, 0x1000000000000000000000000000000), div(x, 0x100000000000000000000))\\n f := and(div(x, 0x10000000000), f)\\n f := or(and(div(x, 0x1000000000000000000000000000000), div(x, 0x100000000000000000000)), f)\\n k := 0x8F1BBCDC\\n }\\n case 3 {\\n // f = b xor c xor d\\n f := xor(div(x, 0x1000000000000000000000000000000), div(x, 0x100000000000000000000))\\n f := xor(div(x, 0x10000000000), f)\\n k := 0xCA62C1D6\\n }\\n // temp = (a leftrotate 5) + f + e + k + w[i]\\n let temp := and(div(x, 0x80000000000000000000000000000000000000000000000), 0x1F)\\n temp := or(and(div(x, 0x800000000000000000000000000000000000000), 0xFFFFFFE0), temp)\\n temp := add(f, temp)\\n temp := add(and(x, 0xFFFFFFFF), temp)\\n temp := add(k, temp)\\n temp := add(div(mload(add(scratch, mul(j, 4))), 0x100000000000000000000000000000000000000000000000000000000), temp)\\n x := or(div(x, 0x10000000000), mul(temp, 0x10000000000000000000000000000000000000000))\\n x := or(and(x, 0xFFFFFFFF00FFFFFFFF000000000000FFFFFFFF00FFFFFFFF), mul(or(and(div(x, 0x4000000000000), 0xC0000000), and(div(x, 0x400000000000000000000), 0x3FFFFFFF)), 0x100000000000000000000))\\n }\\n\\n h := and(add(h, x), 0xFFFFFFFF00FFFFFFFF00FFFFFFFF00FFFFFFFF00FFFFFFFF)\\n }\\n ret := mul(or(or(or(or(and(div(h, 0x100000000), 0xFFFFFFFF00000000000000000000000000000000), and(div(h, 0x1000000), 0xFFFFFFFF000000000000000000000000)), and(div(h, 0x10000), 0xFFFFFFFF0000000000000000)), and(div(h, 0x100), 0xFFFFFFFF00000000)), and(h, 0xFFFFFFFF)), 0x1000000000000000000000000)\\n }\\n }\\n}\",\"keccak256\":\"0x43d6fc9dfba44bcc5d696ac24d8e1b90355942b41c8324ea31dce1ebfce82263\"},\"contracts/dnssec-oracle/nsec3digests/NSEC3Digest.sol\":{\"content\":\"pragma solidity ^0.8.4;\\n\\n/**\\n * @dev Interface for contracts that implement NSEC3 digest algorithms.\\n */\\ninterface NSEC3Digest {\\n /**\\n * @dev Performs an NSEC3 iterated hash.\\n * @param salt The salt value to use on each iteration.\\n * @param data The data to hash.\\n * @param iterations The number of iterations to perform.\\n * @return The result of the iterated hash operation.\\n */\\n function hash(bytes calldata salt, bytes calldata data, uint iterations) external virtual pure returns (bytes32);\\n}\\n\",\"keccak256\":\"0xb3b61aee6bb472158b7ace6b5644dcb668271296b98a6dcde24dc72e3cdf4950\"},\"contracts/dnssec-oracle/nsec3digests/SHA1NSEC3Digest.sol\":{\"content\":\"pragma solidity ^0.8.4;\\n\\nimport \\\"./NSEC3Digest.sol\\\";\\nimport \\\"../SHA1.sol\\\";\\nimport \\\"@ensdomains/buffer/contracts/Buffer.sol\\\";\\n/**\\n* @dev Implements the DNSSEC iterated SHA1 digest used for NSEC3 records.\\n*/\\ncontract SHA1NSEC3Digest is NSEC3Digest {\\n using Buffer for Buffer.buffer;\\n\\n function hash(bytes calldata salt, bytes calldata data, uint iterations) external override pure returns (bytes32) {\\n Buffer.buffer memory buf;\\n buf.init(salt.length + data.length + 16);\\n\\n buf.append(data);\\n buf.append(salt);\\n bytes20 h = SHA1.sha1(buf.buf);\\n if (iterations > 0) {\\n buf.truncate();\\n buf.appendBytes20(bytes20(0));\\n buf.append(salt);\\n\\n for (uint i = 0; i < iterations; i++) {\\n buf.writeBytes20(0, h);\\n h = SHA1.sha1(buf.buf);\\n }\\n }\\n\\n return bytes32(h);\\n }\\n}\\n\",\"keccak256\":\"0x2255d276d74fa236875f6cddd3061ce07189f84acd04538d002dbaa78daa48a0\"}},\"version\":1}", "bytecode": "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", "deployedBytecode": "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", "devdoc": { "details": "Implements the DNSSEC iterated SHA1 digest used for NSEC3 records.", "kind": "dev", "methods": { "hash(bytes,bytes,uint256)": { "details": "Performs an NSEC3 iterated hash.", "params": { "data": "The data to hash.", "iterations": "The number of iterations to perform.", "salt": "The salt value to use on each iteration." }, "returns": { "_0": "The result of the iterated hash operation." } } }, "version": 1 }, "userdoc": { "kind": "user", "methods": {}, "version": 1 }, "storageLayout": { "storage": [], "types": null } }