{ "address": "0x489197C8a154874E3b4B4F3794f3C99b71B3Ab63", "transactionHash": "0xce6341b5642a85f270f24425da6923806da0ef9f9d526845ba398af6e2980c63", "abi": [ { "inputs": [ { "internalType": "bytes", "name": "data", "type": "bytes" }, { "internalType": "bytes", "name": "hash", "type": "bytes" } ], "name": "verify", "outputs": [ { "internalType": "bool", "name": "", "type": "bool" } ], "stateMutability": "pure", "type": "function" } ], "transactionHash": "0xce6341b5642a85f270f24425da6923806da0ef9f9d526845ba398af6e2980c63", "receipt": { "to": null, "from": "0xa303ddC620aa7d1390BACcc8A495508B183fab59", "contractAddress": "0x489197C8a154874E3b4B4F3794f3C99b71B3Ab63", "transactionIndex": 16, "gasUsed": "209402", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "blockHash": "0xc8fcd0d424bf8c9680685c2866eda09e7723b229632203af832ca1992d5d6fa1", "transactionHash": "0xce6341b5642a85f270f24425da6923806da0ef9f9d526845ba398af6e2980c63", "logs": [], "blockNumber": 6470036, "cumulativeGasUsed": "4502372", "status": 1, "byzantium": true }, "args": [], "solcInputHash": "7948b60c3b601df824761a337a51d661", "metadata": "{\"compiler\":{\"version\":\"0.8.4+commit.c7e474f2\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"hash\",\"type\":\"bytes\"}],\"name\":\"verify\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}],\"devdoc\":{\"details\":\"Implements the DNSSEC SHA256 digest.\",\"kind\":\"dev\",\"methods\":{\"verify(bytes,bytes)\":{\"details\":\"Verifies a cryptographic hash.\",\"params\":{\"data\":\"The data to hash.\",\"hash\":\"The hash to compare to.\"},\"returns\":{\"_0\":\"True iff the hashed data matches the provided hash value.\"}}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/dnssec-oracle/digests/SHA256Digest.sol\":\"SHA256Digest\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":10000},\"remappings\":[]},\"sources\":{\"contracts/dnssec-oracle/BytesUtils.sol\":{\"content\":\"pragma solidity ^0.8.4;\\n\\nlibrary BytesUtils {\\n /*\\n * @dev Returns the keccak-256 hash of a byte range.\\n * @param self The byte string to hash.\\n * @param offset The position to start hashing at.\\n * @param len The number of bytes to hash.\\n * @return The hash of the byte range.\\n */\\n function keccak(bytes memory self, uint offset, uint len) internal pure returns (bytes32 ret) {\\n require(offset + len <= self.length);\\n assembly {\\n ret := keccak256(add(add(self, 32), offset), len)\\n }\\n }\\n\\n\\n /*\\n * @dev Returns a positive number if `other` comes lexicographically after\\n * `self`, a negative number if it comes before, or zero if the\\n * contents of the two bytes are equal.\\n * @param self The first bytes to compare.\\n * @param other The second bytes to compare.\\n * @return The result of the comparison.\\n */\\n function compare(bytes memory self, bytes memory other) internal pure returns (int) {\\n return compare(self, 0, self.length, other, 0, other.length);\\n }\\n\\n /*\\n * @dev Returns a positive number if `other` comes lexicographically after\\n * `self`, a negative number if it comes before, or zero if the\\n * contents of the two bytes are equal. Comparison is done per-rune,\\n * on unicode codepoints.\\n * @param self The first bytes to compare.\\n * @param offset The offset of self.\\n * @param len The length of self.\\n * @param other The second bytes to compare.\\n * @param otheroffset The offset of the other string.\\n * @param otherlen The length of the other string.\\n * @return The result of the comparison.\\n */\\n function compare(bytes memory self, uint offset, uint len, bytes memory other, uint otheroffset, uint otherlen) internal pure returns (int) {\\n uint shortest = len;\\n if (otherlen < len)\\n shortest = otherlen;\\n\\n uint selfptr;\\n uint otherptr;\\n\\n assembly {\\n selfptr := add(self, add(offset, 32))\\n otherptr := add(other, add(otheroffset, 32))\\n }\\n for (uint idx = 0; idx < shortest; idx += 32) {\\n uint a;\\n uint b;\\n assembly {\\n a := mload(selfptr)\\n b := mload(otherptr)\\n }\\n if (a != b) {\\n // Mask out irrelevant bytes and check again\\n uint mask;\\n if (shortest > 32) {\\n mask = type(uint256).max;\\n } else {\\n mask = ~(2 ** (8 * (32 - shortest + idx)) - 1);\\n }\\n int diff = int(a & mask) - int(b & mask);\\n if (diff != 0)\\n return diff;\\n }\\n selfptr += 32;\\n otherptr += 32;\\n }\\n\\n return int(len) - int(otherlen);\\n }\\n\\n /*\\n * @dev Returns true if the two byte ranges are equal.\\n * @param self The first byte range to compare.\\n * @param offset The offset into the first byte range.\\n * @param other The second byte range to compare.\\n * @param otherOffset The offset into the second byte range.\\n * @param len The number of bytes to compare\\n * @return True if the byte ranges are equal, false otherwise.\\n */\\n function equals(bytes memory self, uint offset, bytes memory other, uint otherOffset, uint len) internal pure returns (bool) {\\n return keccak(self, offset, len) == keccak(other, otherOffset, len);\\n }\\n\\n /*\\n * @dev Returns true if the two byte ranges are equal with offsets.\\n * @param self The first byte range to compare.\\n * @param offset The offset into the first byte range.\\n * @param other The second byte range to compare.\\n * @param otherOffset The offset into the second byte range.\\n * @return True if the byte ranges are equal, false otherwise.\\n */\\n function equals(bytes memory self, uint offset, bytes memory other, uint otherOffset) internal pure returns (bool) {\\n return keccak(self, offset, self.length - offset) == keccak(other, otherOffset, other.length - otherOffset);\\n }\\n\\n /*\\n * @dev Compares a range of 'self' to all of 'other' and returns True iff\\n * they are equal.\\n * @param self The first byte range to compare.\\n * @param offset The offset into the first byte range.\\n * @param other The second byte range to compare.\\n * @return True if the byte ranges are equal, false otherwise.\\n */\\n function equals(bytes memory self, uint offset, bytes memory other) internal pure returns (bool) {\\n return self.length >= offset + other.length && equals(self, offset, other, 0, other.length);\\n }\\n\\n /*\\n * @dev Returns true if the two byte ranges are equal.\\n * @param self The first byte range to compare.\\n * @param other The second byte range to compare.\\n * @return True if the byte ranges are equal, false otherwise.\\n */\\n function equals(bytes memory self, bytes memory other) internal pure returns(bool) {\\n return self.length == other.length && equals(self, 0, other, 0, self.length);\\n }\\n\\n /*\\n * @dev Returns the 8-bit number at the specified index of self.\\n * @param self The byte string.\\n * @param idx The index into the bytes\\n * @return The specified 8 bits of the string, interpreted as an integer.\\n */\\n function readUint8(bytes memory self, uint idx) internal pure returns (uint8 ret) {\\n return uint8(self[idx]);\\n }\\n\\n /*\\n * @dev Returns the 16-bit number at the specified index of self.\\n * @param self The byte string.\\n * @param idx The index into the bytes\\n * @return The specified 16 bits of the string, interpreted as an integer.\\n */\\n function readUint16(bytes memory self, uint idx) internal pure returns (uint16 ret) {\\n require(idx + 2 <= self.length);\\n assembly {\\n ret := and(mload(add(add(self, 2), idx)), 0xFFFF)\\n }\\n }\\n\\n /*\\n * @dev Returns the 32-bit number at the specified index of self.\\n * @param self The byte string.\\n * @param idx The index into the bytes\\n * @return The specified 32 bits of the string, interpreted as an integer.\\n */\\n function readUint32(bytes memory self, uint idx) internal pure returns (uint32 ret) {\\n require(idx + 4 <= self.length);\\n assembly {\\n ret := and(mload(add(add(self, 4), idx)), 0xFFFFFFFF)\\n }\\n }\\n\\n /*\\n * @dev Returns the 32 byte value at the specified index of self.\\n * @param self The byte string.\\n * @param idx The index into the bytes\\n * @return The specified 32 bytes of the string.\\n */\\n function readBytes32(bytes memory self, uint idx) internal pure returns (bytes32 ret) {\\n require(idx + 32 <= self.length);\\n assembly {\\n ret := mload(add(add(self, 32), idx))\\n }\\n }\\n\\n /*\\n * @dev Returns the 32 byte value at the specified index of self.\\n * @param self The byte string.\\n * @param idx The index into the bytes\\n * @return The specified 32 bytes of the string.\\n */\\n function readBytes20(bytes memory self, uint idx) internal pure returns (bytes20 ret) {\\n require(idx + 20 <= self.length);\\n assembly {\\n ret := and(mload(add(add(self, 32), idx)), 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000000)\\n }\\n }\\n\\n /*\\n * @dev Returns the n byte value at the specified index of self.\\n * @param self The byte string.\\n * @param idx The index into the bytes.\\n * @param len The number of bytes.\\n * @return The specified 32 bytes of the string.\\n */\\n function readBytesN(bytes memory self, uint idx, uint len) internal pure returns (bytes32 ret) {\\n require(len <= 32);\\n require(idx + len <= self.length);\\n assembly {\\n let mask := not(sub(exp(256, sub(32, len)), 1))\\n ret := and(mload(add(add(self, 32), idx)), mask)\\n }\\n }\\n\\n function memcpy(uint dest, uint src, uint len) private pure {\\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\\n /*\\n * @dev Copies a substring into a new byte string.\\n * @param self The byte string to copy from.\\n * @param offset The offset to start copying at.\\n * @param len The number of bytes to copy.\\n */\\n function substring(bytes memory self, uint offset, uint len) internal pure returns(bytes memory) {\\n require(offset + len <= self.length);\\n\\n bytes memory ret = new bytes(len);\\n uint dest;\\n uint src;\\n\\n assembly {\\n dest := add(ret, 32)\\n src := add(add(self, 32), offset)\\n }\\n memcpy(dest, src, len);\\n\\n return ret;\\n }\\n\\n // Maps characters from 0x30 to 0x7A to their base32 values.\\n // 0xFF represents invalid characters in that range.\\n bytes constant base32HexTable = hex'00010203040506070809FFFFFFFFFFFFFF0A0B0C0D0E0F101112131415161718191A1B1C1D1E1FFFFFFFFFFFFFFFFFFFFF0A0B0C0D0E0F101112131415161718191A1B1C1D1E1F';\\n\\n /**\\n * @dev Decodes unpadded base32 data of up to one word in length.\\n * @param self The data to decode.\\n * @param off Offset into the string to start at.\\n * @param len Number of characters to decode.\\n * @return The decoded data, left aligned.\\n */\\n function base32HexDecodeWord(bytes memory self, uint off, uint len) internal pure returns(bytes32) {\\n require(len <= 52);\\n\\n uint ret = 0;\\n uint8 decoded;\\n for(uint i = 0; i < len; i++) {\\n bytes1 char = self[off + i];\\n require(char >= 0x30 && char <= 0x7A);\\n decoded = uint8(base32HexTable[uint(uint8(char)) - 0x30]);\\n require(decoded <= 0x20);\\n if(i == len - 1) {\\n break;\\n }\\n ret = (ret << 5) | decoded;\\n }\\n\\n uint bitlen = len * 5;\\n if(len % 8 == 0) {\\n // Multiple of 8 characters, no padding\\n ret = (ret << 5) | decoded;\\n } else if(len % 8 == 2) {\\n // Two extra characters - 1 byte\\n ret = (ret << 3) | (decoded >> 2);\\n bitlen -= 2;\\n } else if(len % 8 == 4) {\\n // Four extra characters - 2 bytes\\n ret = (ret << 1) | (decoded >> 4);\\n bitlen -= 4;\\n } else if(len % 8 == 5) {\\n // Five extra characters - 3 bytes\\n ret = (ret << 4) | (decoded >> 1);\\n bitlen -= 1;\\n } else if(len % 8 == 7) {\\n // Seven extra characters - 4 bytes\\n ret = (ret << 2) | (decoded >> 3);\\n bitlen -= 3;\\n } else {\\n revert();\\n }\\n\\n return bytes32(ret << (256 - bitlen));\\n }\\n}\",\"keccak256\":\"0x83315df2e54c74451577c70da2c267c3459802b08b9aeec6516302eee70f796e\"},\"contracts/dnssec-oracle/digests/Digest.sol\":{\"content\":\"pragma solidity ^0.8.4;\\n\\n/**\\n* @dev An interface for contracts implementing a DNSSEC digest.\\n*/\\ninterface Digest {\\n /**\\n * @dev Verifies a cryptographic hash.\\n * @param data The data to hash.\\n * @param hash The hash to compare to.\\n * @return True iff the hashed data matches the provided hash value.\\n */\\n function verify(bytes calldata data, bytes calldata hash) external virtual pure returns (bool);\\n}\\n\",\"keccak256\":\"0x259720cef78c019d38b908bc7dd524f087c58d8c40792cebcdd4e982c628bc9a\"},\"contracts/dnssec-oracle/digests/SHA256Digest.sol\":{\"content\":\"pragma solidity ^0.8.4;\\n\\nimport \\\"./Digest.sol\\\";\\nimport \\\"../BytesUtils.sol\\\";\\n\\n/**\\n* @dev Implements the DNSSEC SHA256 digest.\\n*/\\ncontract SHA256Digest is Digest {\\n using BytesUtils for *;\\n\\n function verify(bytes calldata data, bytes calldata hash) external override pure returns (bool) {\\n require(hash.length == 32, \\\"Invalid sha256 hash length\\\");\\n return sha256(data) == hash.readBytes32(0);\\n }\\n}\\n\",\"keccak256\":\"0xd4661871bc8d4ddd7186631d1126693ea0b5c435e4b0c793b1c3ffbcc426f4dd\"}},\"version\":1}", "bytecode": "0x608060405234801561001057600080fd5b506102d6806100206000396000f3fe608060405234801561001057600080fd5b506004361061002b5760003560e01c8063f7e83aee14610030575b600080fd5b61004361003e3660046101ea565b610057565b604051901515815260200160405180910390f35b6000602082146100c7576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601a60248201527f496e76616c6964207368613235362068617368206c656e677468000000000000604482015260640160405180910390fd5b61010b600084848080601f01602080910402602001604051908101604052809392919081815260200183838082843760009201919091525092939250506101679050565b6002868660405161011d929190610253565b602060405180830381855afa15801561013a573d6000803e3d6000fd5b5050506040513d601f19601f8201168201806040525081019061015d91906101d2565b1495945050505050565b8151600090610177836020610263565b111561018257600080fd5b50016020015190565b60008083601f84011261019c578182fd5b50813567ffffffffffffffff8111156101b3578182fd5b6020830191508360208285010111156101cb57600080fd5b9250929050565b6000602082840312156101e3578081fd5b5051919050565b600080600080604085870312156101ff578283fd5b843567ffffffffffffffff80821115610216578485fd5b6102228883890161018b565b9096509450602087013591508082111561023a578384fd5b506102478782880161018b565b95989497509550505050565b8183823760009101908152919050565b6000821982111561029b577f4e487b710000000000000000000000000000000000000000000000000000000081526011600452602481fd5b50019056fea26469706673582212203051cc7fb887b402236ea99f1be5b5a7c267481805c4f4215f88af1c2df6596964736f6c63430008040033", "deployedBytecode": "0x608060405234801561001057600080fd5b506004361061002b5760003560e01c8063f7e83aee14610030575b600080fd5b61004361003e3660046101ea565b610057565b604051901515815260200160405180910390f35b6000602082146100c7576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601a60248201527f496e76616c6964207368613235362068617368206c656e677468000000000000604482015260640160405180910390fd5b61010b600084848080601f01602080910402602001604051908101604052809392919081815260200183838082843760009201919091525092939250506101679050565b6002868660405161011d929190610253565b602060405180830381855afa15801561013a573d6000803e3d6000fd5b5050506040513d601f19601f8201168201806040525081019061015d91906101d2565b1495945050505050565b8151600090610177836020610263565b111561018257600080fd5b50016020015190565b60008083601f84011261019c578182fd5b50813567ffffffffffffffff8111156101b3578182fd5b6020830191508360208285010111156101cb57600080fd5b9250929050565b6000602082840312156101e3578081fd5b5051919050565b600080600080604085870312156101ff578283fd5b843567ffffffffffffffff80821115610216578485fd5b6102228883890161018b565b9096509450602087013591508082111561023a578384fd5b506102478782880161018b565b95989497509550505050565b8183823760009101908152919050565b6000821982111561029b577f4e487b710000000000000000000000000000000000000000000000000000000081526011600452602481fd5b50019056fea26469706673582212203051cc7fb887b402236ea99f1be5b5a7c267481805c4f4215f88af1c2df6596964736f6c63430008040033", "devdoc": { "details": "Implements the DNSSEC SHA256 digest.", "kind": "dev", "methods": { "verify(bytes,bytes)": { "details": "Verifies a cryptographic hash.", "params": { "data": "The data to hash.", "hash": "The hash to compare to." }, "returns": { "_0": "True iff the hashed data matches the provided hash value." } } }, "version": 1 }, "userdoc": { "kind": "user", "methods": {}, "version": 1 }, "storageLayout": { "storage": [], "types": null } }