@ensdomains/ensjs 3.0.0-alpha.1 → 3.0.0-alpha.12

package/src/functions/getSubnames.ts

@@ -1,7 +1,7 @@
-import { namehash } from 'ethers/lib/utils';
 import { ENSArgs } from '..'
-import { truncateFormat } from '../utils/format';
-import { decryptName } from '../utils/labels';
+import { truncateFormat } from '../utils/format'
+import { decryptName } from '../utils/labels'
+import { namehash } from '../utils/normalise'
 
 type Subname = {
   id: string
@@ -21,17 +21,24 @@ type Params = {
   pageSize?: number
   orderDirection?: 'asc' | 'desc'
   orderBy?: 'createdAt' | 'labelName'
-  lastSubnames: Array<any>
+  lastSubnames?: Array<any>
   isLargeQuery?: boolean
 }
 
 const largeQuery = async (
-    { gqlInstance } : ENSArgs<'gqlInstance'>, 
-    { name, page, pageSize = 10, orderDirection, orderBy, lastSubnames }: Params
-  ) => {
-  const client = gqlInstance.client;
+  { gqlInstance }: ENSArgs<'gqlInstance'>,
+  {
+    name,
+    page,
+    pageSize = 10,
+    orderDirection,
+    orderBy,
+    lastSubnames = [],
+  }: Params,
+) => {
+  const client = gqlInstance.client
 
-  let finalQuery = gqlInstance.gql `
+  let finalQuery = gqlInstance.gql`
     query getSubnames(
       $id: ID! 
       $first: Int
@@ -62,35 +69,35 @@ const largeQuery = async (
         }
       }
     }
-  `;
-     let queryVars = {
-          id: namehash(name),
-          first: pageSize,
-          lastCreatedAt: lastSubnames[lastSubnames.length - 1]?.createdAt,
-          orderBy,
-          orderDirection,
-      };
-  const { domain } = await client.request(finalQuery, queryVars);
+  `
+  let queryVars = {
+    id: namehash(name),
+    first: pageSize,
+    lastCreatedAt: lastSubnames[lastSubnames.length - 1]?.createdAt,
+    orderBy,
+    orderDirection,
+  }
+  const { domain } = await client.request(finalQuery, queryVars)
   const subdomains = domain.subdomains.map((subname: any) => {
-      const decrypted = decryptName(subname.name);
-      return {
-          ...subname,
-          name: decrypted,
-          truncatedName: truncateFormat(decrypted),
-      };
-  });
+    const decrypted = decryptName(subname.name)
+    return {
+      ...subname,
+      name: decrypted,
+      truncatedName: truncateFormat(decrypted),
+    }
+  })
 
   return {
     subnames: subdomains,
-    subnameCount: domain.subdomainCount
+    subnameCount: domain.subdomainCount,
   }
-};
+}
 
-const smallQuery =  async (
-  { gqlInstance } : ENSArgs<'gqlInstance'>, 
-  { name, page, pageSize = 10, orderDirection, orderBy } : Params
-  ) => {
-  const client = gqlInstance.client;
+const smallQuery = async (
+  { gqlInstance }: ENSArgs<'gqlInstance'>,
+  { name, page, pageSize = 10, orderDirection, orderBy }: Params,
+) => {
+  const client = gqlInstance.client
   const subdomainsGql = `
   id
   labelName
@@ -102,11 +109,11 @@ const smallQuery =  async (
   owner {
     id
   }
-`;
-  let queryVars = {};
-  let finalQuery = '';
+`
+  let queryVars = {}
+  let finalQuery = ''
   if (typeof page !== 'number') {
-      finalQuery = gqlInstance.gql `
+    finalQuery = gqlInstance.gql`
     query getSubnames(
       $id: ID! 
       $orderBy: Domain_orderBy 
@@ -123,15 +130,14 @@ const smallQuery =  async (
         }
       }
     }
-  `;
-      queryVars = {
-          id: namehash(name),
-          orderBy,
-          orderDirection,
-      };
-  }
-  else {
-      finalQuery = gqlInstance.gql `
+  `
+    queryVars = {
+      id: namehash(name),
+      orderBy,
+      orderDirection,
+    }
+  } else {
+    finalQuery = gqlInstance.gql`
     query getSubnames(
       $id: ID! 
       $first: Int
@@ -153,36 +159,39 @@ const smallQuery =  async (
         }
       }
     }
-  `;
-      queryVars = {
-          id: namehash(name),
-          first: pageSize,
-          skip: (page || 0) * pageSize,
-          orderBy,
-          orderDirection,
-      };
+  `
+    queryVars = {
+      id: namehash(name),
+      first: pageSize,
+      skip: (page || 0) * pageSize,
+      orderBy,
+      orderDirection,
+    }
   }
-  const { domain } = await client.request(finalQuery, queryVars);
+  const { domain } = await client.request(finalQuery, queryVars)
   const subdomains = domain.subdomains.map((subname: any) => {
-      const decrypted = decryptName(subname.name);
-      return {
-          ...subname,
-          name: decrypted,
-          truncatedName: truncateFormat(decrypted),
-      };
-  });
+    const decrypted = decryptName(subname.name)
+    return {
+      ...subname,
+      name: decrypted,
+      truncatedName: truncateFormat(decrypted),
+    }
+  })
 
   return {
     subnames: subdomains,
-    subnameCount: domain.subdomainCount
+    subnameCount: domain.subdomainCount,
   }
-};
+}
 
-const getSubnames = (injected : ENSArgs<'gqlInstance'>, functionArgs: Params): Promise<{ subnames: Subname[], subnameCount: number}> => {
-  if(functionArgs.isLargeQuery) {
+const getSubnames = (
+  injected: ENSArgs<'gqlInstance'>,
+  functionArgs: Params,
+): Promise<{ subnames: Subname[]; subnameCount: number }> => {
+  if (functionArgs.isLargeQuery) {
     return largeQuery(injected, functionArgs)
-  }  
+  }
   return smallQuery(injected, functionArgs)
 }
 
-export default getSubnames;
+export default getSubnames

package/src/{tests → functions}/makeCommitment.test.ts

@@ -1,6 +1,6 @@
 import { ENS } from '..'
+import setup from '../tests/setup'
 import { makeCommitment } from '../utils/registerHelpers'
-import setup from './setup'
 
 let ENSInstance: ENS
 
@@ -13,7 +13,7 @@ describe('makeCommitment', () => {
     const resolver = await ENSInstance.contracts!.getPublicResolver()!
     const commitment = makeCommitment({
       name: 'test.eth',
-      owner: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      owner: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       duration: 1 * 365 * 24 * 60 * 60,
       resolver: resolver,
     })

package/src/functions/normalise.test.ts

@@ -0,0 +1,22 @@
+import { namehash } from '../utils/normalise'
+
+describe('normalise', () => {
+  it('should namehash an empty string', () => {
+    const hash = namehash('')
+    expect(hash).toEqual(
+      '0x0000000000000000000000000000000000000000000000000000000000000000',
+    )
+  })
+  it('should namehash a TLD', () => {
+    const hash = namehash('eth')
+    expect(hash).toEqual(
+      '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae',
+    )
+  })
+  it('should namehash a 2LD', () => {
+    const hash = namehash('foo.eth')
+    expect(hash).toEqual(
+      '0xde9b09fd7c5f901e23a3f19fecc54828e9c848539801e86591bd9801b019f84f',
+    )
+  })
+})

package/src/{tests → functions}/setName.test.ts

@@ -1,7 +1,7 @@
 import { ethers } from 'ethers'
 import { ENS } from '..'
+import setup from '../tests/setup'
 import { hexEncodeName } from '../utils/hexEncodedName'
-import setup from './setup'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
@@ -22,37 +22,37 @@ describe('setName', () => {
     await revert()
   })
   it('should return a transaction for a name and set successfully', async () => {
-    const tx = await ENSInstance.setName('fleek.eth')
+    const tx = await ENSInstance.setName('test123.eth', { addressOrIndex: 1 })
     expect(tx).toBeTruthy()
     await tx?.wait()
 
     const universalResolver =
       await ENSInstance.contracts!.getUniversalResolver()!
-    const reverseNode = accounts[0].toLowerCase().substring(2) + '.addr.reverse'
+    const reverseNode = accounts[1].toLowerCase().substring(2) + '.addr.reverse'
     const result = await universalResolver.reverse(hexEncodeName(reverseNode))
-    expect(result[0]).toBe('fleek.eth')
+    expect(result[0]).toBe('test123.eth')
   })
   it("should return a transaction for setting another address' name", async () => {
-    jest.setTimeout(20000)
     const registry = (await ENSInstance.contracts!.getRegistry()!).connect(
-      provider.getSigner(),
+      provider.getSigner(1),
     )
     const setApprovedForAllTx = await registry.setApprovalForAll(
-      accounts[1],
+      accounts[2],
       true,
     )
     await setApprovedForAllTx?.wait()
 
-    const tx = await ENSInstance.setName('fleek.eth', accounts[0], undefined, {
-      addressOrIndex: 1,
+    const tx = await ENSInstance.setName('test123.eth', {
+      address: accounts[1],
+      addressOrIndex: 2,
     })
     expect(tx).toBeTruthy()
     await tx?.wait()
 
     const universalResolver =
       await ENSInstance.contracts!.getUniversalResolver()!
-    const reverseNode = accounts[0].toLowerCase().substring(2) + '.addr.reverse'
+    const reverseNode = accounts[1].toLowerCase().substring(2) + '.addr.reverse'
     const result = await universalResolver.reverse(hexEncodeName(reverseNode))
-    expect(result[0]).toBe('fleek.eth')
+    expect(result[0]).toBe('test123.eth')
   })
 })

package/src/functions/setName.ts

@@ -1,34 +1,32 @@
 import { ENSArgs } from '..'
 
 export default async function (
-  { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
+  { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
   name: string,
-  address?: string,
-  resolver?: string,
-  options?: { addressOrIndex?: string | number },
+  {
+    address,
+    resolver,
+  }: {
+    address?: string
+    resolver?: string
+  } = {},
 ) {
-  const signerAddress = await provider
-    ?.getSigner(options?.addressOrIndex)
-    .getAddress()
-
-  if (!signerAddress) {
-    throw new Error('No signer found')
-  }
+  const signerAddress = await signer.getAddress()
 
   const reverseRegistrar = (await contracts?.getReverseRegistrar())?.connect(
-    provider?.getSigner()!,
-  )
+    signer,
+  )!
 
   if (address) {
-    const publicResolver = await contracts?.getPublicResolver()
+    const publicResolver = await contracts?.getPublicResolver()!
 
-    return reverseRegistrar?.setNameForAddr(
+    return reverseRegistrar.populateTransaction.setNameForAddr(
       address,
       signerAddress,
-      resolver || publicResolver!.address,
+      resolver || publicResolver.address,
       name,
     )
   }
 
-  return reverseRegistrar?.setName(name)
+  return reverseRegistrar.populateTransaction.setName(name)
 }

package/src/functions/setRecord.test.ts

@@ -0,0 +1,103 @@
+import { ENS } from '..'
+import setup from '../tests/setup'
+import { decodeContenthash } from '../utils/contentHash'
+import { hexEncodeName } from '../utils/hexEncodedName'
+import { namehash } from '../utils/normalise'
+
+let ENSInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
+
+beforeAll(async () => {
+  ;({ ENSInstance, revert } = await setup())
+})
+
+afterAll(async () => {
+  await revert()
+})
+
+describe('setRecord', () => {
+  it('should allow a text record set', async () => {
+    const tx = await ENSInstance.setRecord('test123.eth', {
+      type: 'text',
+      record: { key: 'foo', value: 'bar' },
+      addressOrIndex: 1,
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const universalResolver =
+      await ENSInstance.contracts!.getUniversalResolver()!
+    const publicResolver = await ENSInstance.contracts!.getPublicResolver()!
+    const encodedText = await universalResolver.resolve(
+      hexEncodeName('test123.eth'),
+      publicResolver.interface.encodeFunctionData('text', [
+        namehash('test123.eth'),
+        'foo',
+      ]),
+    )
+    const [resultText] = publicResolver.interface.decodeFunctionResult(
+      'text',
+      encodedText[0],
+    )
+    expect(resultText).toBe('bar')
+  })
+  it('should allow an address record set', async () => {
+    const tx = await ENSInstance.setRecord('test123.eth', {
+      type: 'addr',
+      record: {
+        key: 'ETC',
+        value: '0x42D63ae25990889E35F215bC95884039Ba354115',
+      },
+      addressOrIndex: 1,
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const universalResolver =
+      await ENSInstance.contracts!.getUniversalResolver()!
+    const publicResolver = await ENSInstance.contracts!.getPublicResolver()!
+    const encodedAddr = await universalResolver.resolve(
+      hexEncodeName('test123.eth'),
+      publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [
+        namehash('test123.eth'),
+        '61',
+      ]),
+    )
+    const [resultAddr] = publicResolver.interface.decodeFunctionResult(
+      'addr(bytes32,uint256)',
+      encodedAddr[0],
+    )
+    expect(resultAddr).toBe(
+      '0x42D63ae25990889E35F215bC95884039Ba354115'.toLowerCase(),
+    )
+  })
+  it('should allow a contenthash record set', async () => {
+    const tx = await ENSInstance.setRecord('test123.eth', {
+      type: 'contentHash',
+      record:
+        'ipns://k51qzi5uqu5dgox2z23r6e99oqency055a6xt92xzmyvpz8mwz5ycjavm0u150',
+      addressOrIndex: 1,
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const universalResolver =
+      await ENSInstance.contracts!.getUniversalResolver()!
+    const publicResolver = await ENSInstance.contracts!.getPublicResolver()!
+    const encodedContent = await universalResolver.resolve(
+      hexEncodeName('test123.eth'),
+      publicResolver.interface.encodeFunctionData('contenthash', [
+        namehash('test123.eth'),
+      ]),
+    )
+    const [resultContent] = publicResolver.interface.decodeFunctionResult(
+      'contenthash',
+      encodedContent[0],
+    )
+    const content = decodeContenthash(resultContent)
+    expect(content.decoded).toBe(
+      'k51qzi5uqu5dgox2z23r6e99oqency055a6xt92xzmyvpz8mwz5ycjavm0u150',
+    )
+    expect(content.protocolType).toBe('ipns')
+  })
+})

package/src/functions/setRecord.ts

@@ -0,0 +1,63 @@
+import { ENSArgs } from '..'
+import { namehash } from '../utils/normalise'
+import {
+  generateSingleRecordCall,
+  RecordInput,
+  RecordTypes,
+} from '../utils/recordHelpers'
+
+type BaseInput = {
+  resolverAddress?: string
+}
+
+type ContentHashInput = {
+  record: RecordInput<'contentHash'>
+  type: 'contentHash'
+}
+
+type AddrOrTextInput = {
+  record: RecordInput<'addr' | 'text'>
+  type: 'addr' | 'text'
+}
+
+export default async function <T extends RecordTypes>(
+  {
+    contracts,
+    provider,
+    getResolver,
+    signer,
+  }: ENSArgs<'contracts' | 'provider' | 'getResolver' | 'signer'>,
+  name: string,
+  {
+    record,
+    type,
+    resolverAddress,
+  }: BaseInput & (ContentHashInput | AddrOrTextInput),
+) {
+  if (!name.includes('.')) {
+    throw new Error('Input is not an ENS name')
+  }
+
+  let resolverToUse: string
+  if (resolverAddress) {
+    resolverToUse = resolverAddress
+  } else {
+    resolverToUse = await getResolver(name)
+  }
+
+  if (!resolverToUse) {
+    throw new Error('No resolver found for input address')
+  }
+
+  const resolver = (
+    await contracts?.getPublicResolver(provider, resolverToUse)
+  )?.connect(signer)!
+  const hash = namehash(name)
+
+  const call = generateSingleRecordCall(hash, resolver, type)(record)
+
+  return {
+    to: resolver.address,
+    data: call,
+  }
+}

package/src/{tests → functions}/setRecords.test.ts

@@ -1,7 +1,7 @@
-import { utils } from 'ethers'
 import { ENS } from '..'
+import setup from '../tests/setup'
 import { hexEncodeName } from '../utils/hexEncodedName'
-import setup from './setup'
+import { namehash } from '../utils/normalise'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
@@ -16,11 +16,14 @@ afterAll(async () => {
 
 describe('setRecords', () => {
   it('should return a transaction to the resolver and set successfully', async () => {
-    const tx = await ENSInstance.setRecords('parthtejpal.eth', {
-      coinTypes: [
-        { key: 'ETC', value: '0x42D63ae25990889E35F215bC95884039Ba354115' },
-      ],
-      texts: [{ key: 'foo', value: 'bar' }],
+    const tx = await ENSInstance.setRecords('test123.eth', {
+      records: {
+        coinTypes: [
+          { key: 'ETC', value: '0x42D63ae25990889E35F215bC95884039Ba354115' },
+        ],
+        texts: [{ key: 'foo', value: 'bar' }],
+      },
+      addressOrIndex: 1,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
@@ -29,21 +32,21 @@ describe('setRecords', () => {
       await ENSInstance.contracts!.getUniversalResolver()!
     const publicResolver = await ENSInstance.contracts!.getPublicResolver()!
     const encodedText = await universalResolver.resolve(
-      hexEncodeName('parthtejpal.eth'),
-      publicResolver.interface.encodeFunctionData('text(bytes32,string)', [
-        utils.namehash('parthtejpal.eth'),
+      hexEncodeName('test123.eth'),
+      publicResolver.interface.encodeFunctionData('text', [
+        namehash('test123.eth'),
         'foo',
       ]),
     )
     const encodedAddr = await universalResolver.resolve(
-      hexEncodeName('parthtejpal.eth'),
+      hexEncodeName('test123.eth'),
       publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [
-        utils.namehash('parthtejpal.eth'),
+        namehash('test123.eth'),
         '61',
       ]),
     )
     const [resultText] = publicResolver.interface.decodeFunctionResult(
-      'text(bytes32,string)',
+      'text',
       encodedText[0],
     )
     const [resultAddr] = publicResolver.interface.decodeFunctionResult(

package/src/functions/setRecords.ts

@@ -1,5 +1,5 @@
-import { ethers } from 'ethers'
 import { ENSArgs } from '..'
+import { namehash } from '../utils/normalise'
 import { generateRecordCallArray, RecordOptions } from '../utils/recordHelpers'
 
 export default async function (
@@ -7,32 +7,38 @@ export default async function (
     contracts,
     provider,
     getResolver,
-  }: ENSArgs<'contracts' | 'provider' | 'getResolver'>,
+    signer,
+  }: ENSArgs<'contracts' | 'provider' | 'getResolver' | 'signer'>,
   name: string,
-  records: RecordOptions,
+  {
+    records,
+    resolverAddress,
+  }: {
+    records: RecordOptions
+    resolverAddress?: string
+  },
 ) {
   if (!name.includes('.')) {
     throw new Error('Input is not an ENS name')
   }
 
-  const resolverAddress = await getResolver(name)
-
-  if (!resolverAddress) {
-    throw new Error('No resolver found for input address')
+  let resolverToUse: string
+  if (resolverAddress) {
+    resolverToUse = resolverAddress
+  } else {
+    resolverToUse = await getResolver(name)
   }
 
-  const address = await provider?.getSigner().getAddress()
-
-  if (!address) {
-    throw new Error('No signer found')
+  if (!resolverToUse) {
+    throw new Error('No resolver found for input address')
   }
 
   const resolver = (
-    await contracts?.getPublicResolver(provider, resolverAddress)
-  )?.connect(provider?.getSigner()!)
-  const namehash = ethers.utils.namehash(name)
+    await contracts?.getPublicResolver(provider, resolverToUse)
+  )?.connect(signer)!
+  const hash = namehash(name)
 
-  const calls: string[] = generateRecordCallArray(namehash, records, resolver!)
+  const calls: string[] = generateRecordCallArray(hash, records, resolver!)
 
-  return resolver?.multicall(calls)
+  return resolver.populateTransaction.multicall(calls)
 }