├── env.example
├── .gitignore
├── contracts
    ├── imported
    │   └── ENS.sol
    ├── ReverseRecords.sol
    └── Namehash.sol
├── .travis.yml
├── scripts
    ├── deploy.js
    └── real_data_test.js
├── README.md
├── hardhat.config.js
├── package.json
└── test
    └── ReverseRecords.js


/env.example:
--------------------------------------------------------------------------------
1 | MNEMONIC=hello
2 | INFURA_ID=infuraId
3 | ETHERSCANKEY=etherscankey


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | 
3 | #Hardhat files
4 | cache
5 | artifacts
6 | yarn-error.log
7 | .env
8 | 


--------------------------------------------------------------------------------
/contracts/imported/ENS.sol:
--------------------------------------------------------------------------------
1 | pragma solidity *;
2 | import '@ensdomains/ens/contracts/ENSRegistry.sol';
3 | import '@ensdomains/ens/contracts/ReverseRegistrar.sol';
4 | import '@ensdomains/ens/contracts/TestRegistrar.sol';
5 | // import '@ensdomains/resolver/contracts/PublicResolver.sol';
6 | 
7 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | sudo: required
 2 | 
 3 | dist: trusty
 4 | 
 5 | language: node_js
 6 | 
 7 | node_js:
 8 |   - '14'
 9 | install:
10 |   - npm install
11 | env:
12 |   - TASK=test
13 | matrix:
14 |   fast_finish: true
15 |   allow_failures:
16 | before_script:
17 |   - ganache-cli > /dev/null &
18 |   - sleep 5
19 | script:
20 |   - npm run $TASK
21 | 
22 | notifications:
23 |   email: false
24 | 


--------------------------------------------------------------------------------
/scripts/deploy.js:
--------------------------------------------------------------------------------
 1 | // We require the Hardhat Runtime Environment explicitly here. This is optional 
 2 | // but useful for running the script in a standalone fashion through `node <script>`.
 3 | //
 4 | // When running the script with `hardhat run <script>` you'll find the Hardhat
 5 | // Runtime Environment's members available in the global scope.
 6 | const hre = require("hardhat");
 7 | const REGISTRY_ADDRESS = '0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e'
 8 | async function main(env) {
 9 |   const ReverseRecords = await hre.ethers.getContractFactory("ReverseRecords");
10 |   reverseRecords = await ReverseRecords.deploy(REGISTRY_ADDRESS);
11 | 
12 |   await reverseRecords.deployed();
13 |   console.log(`ReverseRecords deployed to ${env.HARDHAT_NETWORK}:${reverseRecords.address}`);
14 | }
15 | 
16 | // We recommend this pattern to be able to use async/await everywhere
17 | // and properly handle errors.
18 | main(process.env)
19 |   .then(() => process.exit(0))
20 |   .catch(error => {
21 |     console.error(error);
22 |     process.exit(1);
23 |   });
24 | 


--------------------------------------------------------------------------------
/scripts/real_data_test.js:
--------------------------------------------------------------------------------
 1 | const hre = require("hardhat");
 2 | const CONTRACTS = {
 3 |   'ropsten': '0x5bBFe410e18DCcaebbf5fD7A00844d4255615258',
 4 |   'rinkeby': '0x196eC7109e127A353B709a20da25052617295F6f',
 5 |   'goerli': '0x333Fc8f550043f239a2CF79aEd5e9cF4A20Eb41e',
 6 |   'mainnet': '0x3671aE578E63FdF66ad4F3E12CC0c0d71Ac7510C'
 7 | }
 8 | 
 9 | async function main(env) {
10 |   console.log('hre.network.name', hre.network.name, CONTRACTS[hre.network.name]);
11 |   const reverseRecords = await hre.ethers.getContractAt('ReverseRecords', CONTRACTS[hre.network.name])
12 |   const addresses = [
13 |     '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
14 |     '0x5A384227B65FA093DEC03Ec34e111Db80A040615',
15 |     '0x983110309620D911731Ac0932219af06091b6744'
16 |   ]
17 |   const result = await reverseRecords.getNames(addresses)
18 |   for (let index = 0; index < result.length; index++) {
19 |     console.log(addresses[index], result[index])
20 |   }
21 | }
22 | 
23 | main(process.env)
24 |   .then(() => process.exit(0))
25 |   .catch(error => {
26 |     console.error(error);
27 |     process.exit(1);
28 |   });
29 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Reverse records
 2 | 
 3 | 
 4 | ## How to setup
 5 | 
 6 | ```
 7 | git clone https://github.com/ensdomains/reverse-records
 8 | cd reverse-records
 9 | cp env.example .env // Add your mnemonic, infura project id, and etherscan key
10 | yarn
11 | ```
12 | 
13 | ## CLI
14 | 
15 | ```
16 | yarn query:ropsten 0x123...,0x234...
17 | ```
18 | 
19 | ## Smart contract API
20 | 
21 | ### getNames([address])
22 | 
23 | Returns an array of string. If the given address does not have a reverse record or forward record setup, it returns an empty string.
24 | 
25 | ## Usage note
26 | 
27 | Make sure to compare that the returned names match with the normalised names to prevent from [homograph attack](https://en.wikipedia.org/wiki/IDN_homograph_attack)
28 | 
29 | Example
30 | 
31 | ```js
32 | const namehash = require('eth-ens-namehash');
33 | const allnames = await ReverseRecords.getNames(['0x123','0x124'])
34 | const validNames = allnames.filter((n) => namehash.normalize(n) === n )
35 | ```
36 | 
37 | 
38 | ## Deployed contract address
39 | 
40 | - Ropsten: [0x72c33B247e62d0f1927E8d325d0358b8f9971C68](https://ropsten.etherscan.io/address/0x72c33B247e62d0f1927E8d325d0358b8f9971C68)
41 | - Rinkeby: [0x196eC7109e127A353B709a20da25052617295F6f](https://rinkeby.etherscan.io/address/0x196eC7109e127A353B709a20da25052617295F6f)
42 | - Goerli: [0x333Fc8f550043f239a2CF79aEd5e9cF4A20Eb41e](https://goerli.etherscan.io/address/0x333Fc8f550043f239a2CF79aEd5e9cF4A20Eb41e)
43 | - Mainnet: [0x3671aE578E63FdF66ad4F3E12CC0c0d71Ac7510C](https://etherscan.io/address/0x3671aE578E63FdF66ad4F3E12CC0c0d71Ac7510C)
44 | 


--------------------------------------------------------------------------------
/hardhat.config.js:
--------------------------------------------------------------------------------
 1 | require("@nomiclabs/hardhat-waffle");
 2 | require('@ensdomains/ens');
 3 | require('@ensdomains/resolver');
 4 | require("@nomiclabs/hardhat-etherscan");
 5 | const dotenv = require("dotenv")
 6 | dotenv.config()
 7 | 
 8 | const CONTRACTS = {
 9 |   'ropsten': '0x5bBFe410e18DCcaebbf5fD7A00844d4255615258',
10 |   'rinkeby': '0x196eC7109e127A353B709a20da25052617295F6f',
11 |   'goerli': '0x333Fc8f550043f239a2CF79aEd5e9cF4A20Eb41e',
12 |   'mainnet': '0x3671aE578E63FdF66ad4F3E12CC0c0d71Ac7510C'
13 | }
14 | 
15 | const {
16 |   MNEMONIC = '',
17 |   INFURA_ID = '',
18 |   ETHERSCANKEY = ''
19 | } = process.env
20 | 
21 | task("names", "query reverse records")
22 |   .addParam("addresses", "List of accounts, comma delimited")
23 |   .setAction(async (taskArgs, hre) => {
24 |     const addresses = taskArgs.addresses.split(',')
25 |     const reverseRecords = await hre.ethers.getContractAt('ReverseRecords', CONTRACTS[hre.network.name])
26 |     console.log(await reverseRecords.getNames(addresses))
27 |   });
28 | 
29 | module.exports = {
30 |   networks: {
31 |     localhost: {
32 |       url: "http://127.0.0.1:8545"
33 |     },
34 |     hardhat: {
35 |     },
36 |     ropsten: {
37 |       url: `https://ropsten.infura.io/v3/${INFURA_ID}`,
38 |       chainId: 3,
39 |       gasPrice: 20000000000, // 20 gwei
40 |       accounts: {mnemonic: MNEMONIC}
41 |     },
42 |     rinkeby: {
43 |       url: `https://rinkeby.infura.io/v3/${INFURA_ID}`,
44 |       chainId: 4,
45 |       gasPrice: 20000000000, // 20 gwei
46 |       accounts: {mnemonic: MNEMONIC}
47 |     },
48 |     goerli: {
49 |       url: `https://goerli.infura.io/v3/${INFURA_ID}`,
50 |       chainId: 5,
51 |       gasPrice: 20000000000, // 20 gwei
52 |       accounts: {mnemonic: MNEMONIC}
53 |     },
54 |     mainnet: {
55 |       url: `https://mainnet.infura.io/v3/${INFURA_ID}`,
56 |       chainId: 1,
57 |       gasPrice: 120000000000, // 120 gwei
58 |       accounts: {mnemonic: MNEMONIC}
59 |     }
60 |   },
61 |   etherscan: {
62 |     apiKey: ETHERSCANKEY
63 |   },
64 |   solidity: {
65 |     compilers: [
66 |       {
67 |         version: "0.7.4"
68 |       }
69 |     ]
70 |   }
71 | }


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "@ensdomains/reverse-records",
 3 |   "version": "1.0.0",
 4 |   "description": "Returns multiple ENS reverse records with forward lookup check",
 5 |   "main": "index.js",
 6 |   "scripts": {
 7 |     "test": "hardhat test",
 8 |     "deploy:ropsten": "npx hardhat run --network ropsten scripts/deploy.js",
 9 |     "verify:ropsten": "npx hardhat verify --network ropsten 0x5bBFe410e18DCcaebbf5fD7A00844d4255615258 '0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e'",
10 |     "query:ropsten": "npx hardhat names --network ropsten --addresses",
11 |     "deploy:rinkeby": "npx hardhat run --network rinkeby scripts/deploy.js",
12 |     "verify:rinkeby": "npx hardhat verify --network rinkeby 0x196eC7109e127A353B709a20da25052617295F6f '0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e'",
13 |     "query:rinkeby": "npx hardhat names --network rinkeby --addresses",
14 |     "deploy:goerli": "npx hardhat run --network goerli scripts/deploy.js",
15 |     "verify:goerli": "npx hardhat verify --network goerli 0x333Fc8f550043f239a2CF79aEd5e9cF4A20Eb41e '0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e'",
16 |     "query:goerli": "npx hardhat names --network goerli --addresses",
17 |     "deploy:mainnet": "npx hardhat run --network mainnet scripts/deploy.js",
18 |     "verify:mainnet": "npx hardhat verify --network mainnet 0x3671aE578E63FdF66ad4F3E12CC0c0d71Ac7510C '0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e'",
19 |     "query:mainnet": "npx hardhat names --network mainnet --addresses",
20 |     "test:mainnet": "npx hardhat run --network mainnet scripts/real_data_test.js"
21 |   },
22 |   "keywords": [],
23 |   "author": "Makoto Inoue",
24 |   "license": "ISC",
25 |   "devDependencies": {
26 |     "@nomiclabs/hardhat-ethers": "^2.0.1",
27 |     "@nomiclabs/hardhat-etherscan": "^2.1.1",
28 |     "@nomiclabs/hardhat-waffle": "^2.0.1",
29 |     "chai": "^4.3.0",
30 |     "ethereum-waffle": "^3.3.0",
31 |     "ethers": "^5.0.31",
32 |     "graphql": "^15.5.0",
33 |     "hardhat": "^2.0.11"
34 |   },
35 |   "dependencies": {
36 |     "@ensdomains/buffer": "^0.0.10",
37 |     "@ensdomains/dnssec-oracle": "^0.2.0",
38 |     "@ensdomains/ens": "^0.5.0",
39 |     "@ensdomains/resolver": "^0.3.0",
40 |     "dotenv": "^8.2.0",
41 |     "eth-ens-namehash": "^2.0.8"
42 |   }
43 | }
44 | 


--------------------------------------------------------------------------------
/contracts/ReverseRecords.sol:
--------------------------------------------------------------------------------
 1 | pragma solidity ^0.7.4;pragma experimental ABIEncoderV2;
 2 | import "./Namehash.sol";
 3 | import '@ensdomains/ens/contracts/ENS.sol';
 4 | import '@ensdomains/ens/contracts/ReverseRegistrar.sol';
 5 | import '@ensdomains/resolver/contracts/Resolver.sol';
 6 | 
 7 | contract ReverseRecords {
 8 |     ENS ens;
 9 |     ReverseRegistrar registrar;
10 |     bytes32 private constant ADDR_REVERSE_NODE = 0x91d1777781884d03a6757a803996e38de2a42967fb37eeaca72729271025a9e2;
11 | 
12 |     /**
13 |      * The `constructor` takes ENS registry address
14 |      */
15 |     constructor(ENS _ens) {
16 |         ens = _ens;
17 |         registrar = ReverseRegistrar(ens.owner(ADDR_REVERSE_NODE));
18 |     }
19 | 
20 |     /**
21 |      * Read only function to return ens name only if both forward and reverse resolution are set     *
22 |      */
23 |     function getNames(address[] calldata addresses) external view returns (string[] memory r) {
24 |         r = new string[](addresses.length);
25 |         for(uint i = 0; i < addresses.length; i++) {
26 |             bytes32 node = node(addresses[i]);
27 |             address resolverAddress = ens.resolver(node);
28 |             if(resolverAddress != address(0x0)){
29 |                 Resolver resolver = Resolver(resolverAddress);
30 |                 string memory name = resolver.name(node);
31 |                 if(bytes(name).length == 0 ){
32 |                     continue;
33 |                 }
34 |                 bytes32 namehash = Namehash.namehash(name);
35 |                 address forwardResolverAddress = ens.resolver(namehash);
36 |                 if(forwardResolverAddress != address(0x0)){
37 |                     Resolver forwardResolver = Resolver(forwardResolverAddress);
38 |                     address forwardAddress = forwardResolver.addr(namehash);
39 |                     if(forwardAddress == addresses[i]){
40 |                         r[i] = name;
41 |                     }
42 |                 }
43 |             }
44 |         }
45 |         return r;
46 |     }
47 | 
48 |     function node(address addr) private pure returns (bytes32) {
49 |         return keccak256(abi.encodePacked(ADDR_REVERSE_NODE, sha3HexAddress(addr)));
50 |     }
51 | 
52 |     function sha3HexAddress(address addr) private pure returns (bytes32 ret) {
53 |         addr;
54 |         ret; // Stop warning us about unused variables
55 |         assembly {
56 |             let lookup := 0x3031323334353637383961626364656600000000000000000000000000000000
57 | 
58 |             for { let i := 40 } gt(i, 0) { } {
59 |                 i := sub(i, 1)
60 |                 mstore8(i, byte(and(addr, 0xf), lookup))
61 |                 addr := div(addr, 0x10)
62 |                 i := sub(i, 1)
63 |                 mstore8(i, byte(and(addr, 0xf), lookup))
64 |                 addr := div(addr, 0x10)
65 |             }
66 | 
67 |             ret := keccak256(0, 40)
68 |         }
69 |     }
70 | }


--------------------------------------------------------------------------------
/contracts/Namehash.sol:
--------------------------------------------------------------------------------
  1 | pragma solidity ^0.7.0;
  2 | 
  3 | library Strings {
  4 |     struct slice {
  5 |         uint _len;
  6 |         uint _ptr;
  7 |     }
  8 |     
  9 |     /*
 10 |      * @dev Returns a slice containing the entire string.
 11 |      * @param self The string to make a slice from.
 12 |      * @return A newly allocated slice containing the entire string.
 13 |      */
 14 |     function toSlice(string memory self) internal pure returns (slice memory) {
 15 |         uint ptr;
 16 |         assembly {
 17 |             ptr := add(self, 0x20)
 18 |         }
 19 |         return slice(bytes(self).length, ptr);
 20 |     }
 21 | 
 22 |     /*
 23 |      * @dev Returns the keccak-256 hash of the slice.
 24 |      * @param self The slice to hash.
 25 |      * @return The hash of the slice.
 26 |      */
 27 |     function keccak(slice memory self) internal pure returns (bytes32 ret) {
 28 |         assembly {
 29 |             ret := keccak256(mload(add(self, 32)), mload(self))
 30 |         }
 31 |     }
 32 | 
 33 |     /*
 34 |      * @dev Returns true if the slice is empty (has a length of 0).
 35 |      * @param self The slice to operate on.
 36 |      * @return True if the slice is empty, False otherwise.
 37 |      */
 38 |     function empty(slice memory self) internal pure returns (bool) {
 39 |         return self._len == 0;
 40 |     }
 41 |     
 42 |     // Returns the memory address of the first byte after the last occurrence of
 43 |     // `needle` in `self`, or the address of `self` if not found.
 44 |     function rfindPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {
 45 |         uint ptr;
 46 | 
 47 |         if (needlelen <= selflen) {
 48 |             if (needlelen <= 32) {
 49 |                 bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));
 50 | 
 51 |                 bytes32 needledata;
 52 |                 assembly { needledata := and(mload(needleptr), mask) }
 53 | 
 54 |                 ptr = selfptr + selflen - needlelen;
 55 |                 bytes32 ptrdata;
 56 |                 assembly { ptrdata := and(mload(ptr), mask) }
 57 | 
 58 |                 while (ptrdata != needledata) {
 59 |                     if (ptr <= selfptr)
 60 |                         return selfptr;
 61 |                     ptr--;
 62 |                     assembly { ptrdata := and(mload(ptr), mask) }
 63 |                 }
 64 |                 return ptr + needlelen;
 65 |             } else {
 66 |                 // For long needles, use hashing
 67 |                 bytes32 hash;
 68 |                 assembly { hash := keccak256(needleptr, needlelen) }
 69 |                 ptr = selfptr + (selflen - needlelen);
 70 |                 while (ptr >= selfptr) {
 71 |                     bytes32 testHash;
 72 |                     assembly { testHash := keccak256(ptr, needlelen) }
 73 |                     if (hash == testHash)
 74 |                         return ptr + needlelen;
 75 |                     ptr -= 1;
 76 |                 }
 77 |             }
 78 |         }
 79 |         return selfptr;
 80 |     }
 81 |     
 82 |     /*
 83 |      * @dev Splits the slice, setting `self` to everything before the last
 84 |      *      occurrence of `needle`, and `token` to everything after it. If
 85 |      *      `needle` does not occur in `self`, `self` is set to the empty slice,
 86 |      *      and `token` is set to the entirety of `self`.
 87 |      * @param self The slice to split.
 88 |      * @param needle The text to search for in `self`.
 89 |      * @param token An output parameter to which the first token is written.
 90 |      * @return `token`.
 91 |      */
 92 |     function rsplit(slice memory self, slice memory needle, slice memory token) internal pure returns (slice memory) {
 93 |         uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
 94 |         token._ptr = ptr;
 95 |         token._len = self._len - (ptr - self._ptr);
 96 |         if (ptr == self._ptr) {
 97 |             // Not found
 98 |             self._len = 0;
 99 |         } else {
100 |             self._len -= token._len + needle._len;
101 |         }
102 |         return token;
103 |     }
104 | }
105 | 
106 | library Namehash {
107 |     using Strings for *;
108 |     
109 |     function namehash(string memory name) pure internal returns(bytes32 hash) {
110 |         hash = bytes32(0);
111 |         Strings.slice memory nameslice = name.toSlice();
112 |         Strings.slice memory delim = ".".toSlice();
113 |         Strings.slice memory token;
114 |         for(nameslice.rsplit(delim, token); !token.empty(); nameslice.rsplit(delim, token)) {
115 |             hash = keccak256(abi.encodePacked(hash, token.keccak()));
116 |         }
117 |         return hash;
118 |     }
119 | }
120 | 


--------------------------------------------------------------------------------
/test/ReverseRecords.js:
--------------------------------------------------------------------------------
  1 | const { expect } = require("chai");
  2 | const namehash = require('eth-ens-namehash');
  3 | 
  4 | function sha3(name){
  5 |   return ethers.utils.keccak256(ethers.utils.toUtf8Bytes(name))
  6 | }
  7 | 
  8 | async function assertReverseRecord(ens, address){
  9 |   const reverseNode = `${address.slice(2)}.addr.reverse`
 10 |   let reverseResolverAddress, reverseResolver, reverseRecord, forwardResolverAddress, forwardResolver, forwardAddress
 11 |   try{
 12 |     reverseResolverAddress = await ens.resolver(namehash.hash(reverseNode))
 13 |     reverseResolver = await ethers.getContractAt('PublicResolver', reverseResolverAddress)
 14 |     reverseRecord = await reverseResolver.name(namehash.hash(reverseNode))
 15 |     forwardResolverAddress = await ens.resolver(namehash.hash(reverseRecord))  
 16 |     forwardResolver = await ethers.getContractAt('PublicResolver', forwardResolverAddress)
 17 |     forwardAddress = await forwardResolver['addr(bytes32)'](namehash.hash(reverseRecord))  
 18 |   }catch(e){
 19 |     // console.log(e)
 20 |   }
 21 |   return address === forwardAddress
 22 | }
 23 | 
 24 | describe("ReverseRecords contract", function() {
 25 |     let node, ens, resolver, registrar, ethNode
 26 |     before(async () => {
 27 |       const [owner, aAddr, bAddr, cAddr, dAddr, eAddr, fAddr, gAddr] = await ethers.getSigners();
 28 |       ethNode = namehash.hash('eth')
 29 |       node = namehash.hash(owner.address.slice(2).toLowerCase() + ".addr.reverse");
 30 |       const ENSRegistry = await ethers.getContractFactory("ENSRegistry");
 31 |       const PublicResolver = await ethers.getContractFactory("PublicResolver");
 32 |       const ReverseRegistrar = await ethers.getContractFactory("ReverseRegistrar");
 33 |       ens = await ENSRegistry.deploy();
 34 |       resolver = await PublicResolver.deploy(ens.address);
 35 |       registrar = await ReverseRegistrar.deploy(ens.address, resolver.address);
 36 |       await ens.setSubnodeOwner(namehash.hash(''), sha3('eth'), owner.address);
 37 |       await ens.setSubnodeOwner(namehash.hash(''), sha3('reverse'), owner.address);
 38 |     　await ens.setSubnodeOwner(namehash.hash('reverse'), sha3('addr'), registrar.address);
 39 |     })
 40 |         
 41 |     it("Reverse record", async function() {
 42 |       // aAddr: correct
 43 |       // bAddr: no reverse record set
 44 |       // cAddr: not the owner of c.eth
 45 |       // dAddr: ower of d.eth but no resolver set
 46 |       // eAddr: ower of e.eth and resolver set but no forward address set
 47 |       // fAddr: set empty string to reverse record
 48 |       // gAddr: correct
 49 |       const [owner, aAddr, bAddr, cAddr, dAddr, eAddr, fAddr, gAddr] = await ethers.getSigners();
 50 |       const PublicResolver = await ethers.getContractFactory("PublicResolver");
 51 |       const resolverArtifact = await hre.artifacts.readArtifact("PublicResolver")
 52 |       await ens.setSubnodeOwner(namehash.hash('eth'), sha3('a'), aAddr.address);
 53 |       await ens.setSubnodeOwner(namehash.hash('eth'), sha3('b'), bAddr.address);
 54 |       // No c
 55 |       await ens.setSubnodeOwner(namehash.hash('eth'), sha3('d'), dAddr.address);
 56 |       await ens.setSubnodeOwner(namehash.hash('eth'), sha3('e'), eAddr.address);
 57 |       await ens.setSubnodeOwner(namehash.hash('eth'), sha3('f'), fAddr.address);
 58 |       await ens.setSubnodeOwner(namehash.hash('eth'), sha3('g'), gAddr.address);
 59 | 
 60 |       await ens.connect(aAddr).setResolver(namehash.hash('a.eth'), resolver.address)
 61 |       await ens.connect(bAddr).setResolver(namehash.hash('b.eth'), resolver.address)
 62 |       // No c
 63 |       // No d
 64 |       await ens.connect(eAddr).setResolver(namehash.hash('e.eth'), resolver.address)
 65 |       await ens.connect(fAddr).setResolver(namehash.hash('f.eth'), resolver.address)
 66 |       await ens.connect(gAddr).setResolver(namehash.hash('g.eth'), resolver.address)
 67 | 
 68 |       // Setting forward records
 69 |       await await resolver.connect(aAddr)['setAddr(bytes32,address)'](namehash.hash('a.eth'), aAddr.address);
 70 |       await await resolver.connect(bAddr)['setAddr(bytes32,address)'](namehash.hash('b.eth'), bAddr.address);
 71 |       // No c
 72 |       // No d
 73 |       // No e
 74 |       await await resolver.connect(fAddr)['setAddr(bytes32,address)'](namehash.hash('f.eth'), fAddr.address);
 75 |       await await resolver.connect(gAddr)['setAddr(bytes32,address)'](namehash.hash('g.eth'), gAddr.address);
 76 | 
 77 |       // Setting reverse record
 78 |       await registrar.connect(aAddr).setName('a.eth')
 79 |       // No reverse record set on b
 80 |       await registrar.connect(cAddr).setName('c.eth')
 81 |       await registrar.connect(dAddr).setName('d.eth')
 82 |       await registrar.connect(eAddr).setName('e.eth')
 83 |       await registrar.connect(fAddr).setName('')
 84 |       await registrar.connect(gAddr).setName('g.eth')
 85 | 
 86 |       const ReverseRecords = await ethers.getContractFactory("ReverseRecords");
 87 |       const reverseRecords = await ReverseRecords.deploy(ens.address);
 88 |       const results = await reverseRecords.getNames([
 89 |         aAddr.address,
 90 |         bAddr.address,
 91 |         cAddr.address,
 92 |         dAddr.address,
 93 |         eAddr.address,
 94 |         fAddr.address,
 95 |         gAddr.address
 96 |       ]);
 97 |       expect(await assertReverseRecord(ens, aAddr.address)).to.be.true
 98 |       expect(results[0]).to.equal('a.eth');
 99 |       expect(await assertReverseRecord(ens, bAddr.address)).to.be.false
100 |       expect(results[1]).to.equal('');
101 |       expect(await assertReverseRecord(ens, cAddr.address)).to.be.false
102 |       expect(results[2]).to.equal('');
103 |       expect(await assertReverseRecord(ens, dAddr.address)).to.be.false
104 |       expect(results[3]).to.equal('');
105 |       expect(await assertReverseRecord(ens, eAddr.address)).to.be.false
106 |       expect(results[4]).to.equal('');
107 |       expect(await assertReverseRecord(ens, fAddr.address)).to.be.false
108 |       expect(results[5]).to.equal('');
109 |       expect(await assertReverseRecord(ens, gAddr.address)).to.be.true
110 |       expect(results[6]).to.equal('g.eth');
111 |     });
112 | });


--------------------------------------------------------------------------------