@ensdomains/ensjs 3.0.0-alpha.4 → 3.0.0-alpha.41

package/src/functions/deleteSubname.test.ts

@@ -1,16 +1,12 @@
-import { ethers } from 'ethers'
 import { ENS } from '..'
-import { namehash } from '../utils/normalise'
 import setup from '../tests/setup'
+import { namehash } from '../utils/normalise'
 
-let ENSInstance: ENS
+let ensInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
-let provider: ethers.providers.JsonRpcProvider
-let accounts: string[]
 
 beforeAll(async () => {
-  ;({ ENSInstance, revert, provider } = await setup())
-  accounts = await provider.listAccounts()
+  ;({ ensInstance, revert } = await setup())
 })
 
 afterAll(async () => {
@@ -22,50 +18,52 @@ describe('deleteSubname', () => {
     await revert()
   })
   it('should allow deleting a subname on the registry', async () => {
-    const createSubnameTx = await ENSInstance.createSubname({
+    const tx = await ensInstance.deleteSubname('test.with-subnames.eth', {
       contract: 'registry',
-      name: 'test.parthtejpal.eth',
-      owner: accounts[0],
-      options: { addressOrIndex: 0 },
+      addressOrIndex: 1,
     })
-    await createSubnameTx.wait()
-
-    const tx = await ENSInstance.deleteSubname(
-      'test.parthtejpal.eth',
-      'registry',
-      { addressOrIndex: 0 },
-    )
     expect(tx).toBeTruthy()
     await tx.wait()
 
-    const registry = await ENSInstance.contracts!.getRegistry()!
-    const result = await registry.owner(namehash('test.parthtejpal.eth'))
+    const registry = await ensInstance.contracts!.getRegistry()!
+    const result = await registry.owner(namehash('test.with-subnames.eth'))
     expect(result).toBe('0x0000000000000000000000000000000000000000')
   })
+
   it('should allow deleting a subname on the nameWrapper', async () => {
-    const wrapNameTx = await ENSInstance.wrapName(
-      'parthtejpal.eth',
-      accounts[0],
-    )
-    await wrapNameTx.wait()
-    const createSubnameTx = await ENSInstance.createSubname({
-      contract: 'nameWrapper',
-      name: 'test.parthtejpal.eth',
-      owner: accounts[0],
-      options: { addressOrIndex: 0 },
-    })
-    await createSubnameTx.wait()
+    const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
 
-    const tx = await ENSInstance.deleteSubname(
-      'test.parthtejpal.eth',
-      'nameWrapper',
-      { addressOrIndex: 0 },
+    const tx = await ensInstance.deleteSubname(
+      'test.wrapped-with-subnames.eth',
+      {
+        contract: 'nameWrapper',
+        addressOrIndex: 1,
+      },
     )
     expect(tx).toBeTruthy()
     await tx.wait()
 
-    const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
-    const result = await nameWrapper.ownerOf(namehash('test.parthtejpal.eth'))
+    const result = await nameWrapper.ownerOf(
+      namehash('test.wrapped-with-subnames.eth'),
+    )
     expect(result).toBe('0x0000000000000000000000000000000000000000')
   })
+
+  it('should not allow deleting 1LD', async () => {
+    await expect(
+      ensInstance.deleteSubname('eth', {
+        contract: 'nameWrapper',
+        addressOrIndex: 1,
+      }),
+    ).rejects.toThrow()
+  })
+
+  it('should not allow deleting 2LD', async () => {
+    await expect(
+      ensInstance.deleteSubname('test123.eth', {
+        contract: 'registry',
+        addressOrIndex: 1,
+      }),
+    ).rejects.toThrow()
+  })
 })

package/src/functions/deleteSubname.ts

@@ -1,19 +1,53 @@
+import { keccak256 as solidityKeccak256 } from '@ethersproject/solidity'
 import { ENSArgs } from '..'
+import { namehash } from '../utils/normalise'
+
+type Args = {
+  contract: 'registry' | 'nameWrapper'
+}
 
 export default async function (
-  {
-    contracts,
-    provider,
-    transferSubname,
-  }: ENSArgs<'contracts' | 'provider' | 'transferSubname'>,
+  { contracts, signer }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>,
   name: string,
-  contract: 'registry' | 'nameWrapper',
-  options?: { addressOrIndex?: string | number },
+  { contract }: Args,
 ) {
-  return transferSubname(
-    name,
-    contract,
-    '0x0000000000000000000000000000000000000000',
-    options,
-  )
+  const labels = name.split('.')
+
+  if (labels.length < 3) {
+    throw new Error(`${name} is not a valid subname`)
+  }
+
+  const label = labels.shift() as string
+  const labelhash = solidityKeccak256(['string'], [label])
+  const parentNodehash = namehash(labels.join('.'))
+
+  switch (contract) {
+    case 'registry': {
+      const registry = (await contracts!.getRegistry()!).connect(signer)
+
+      return registry.populateTransaction.setSubnodeRecord(
+        parentNodehash,
+        labelhash,
+        '0x0000000000000000000000000000000000000000',
+        '0x0000000000000000000000000000000000000000',
+        0,
+      )
+    }
+    case 'nameWrapper': {
+      const nameWrapper = (await contracts!.getNameWrapper()!).connect(signer)
+
+      return nameWrapper.populateTransaction.setSubnodeRecord(
+        parentNodehash,
+        label,
+        '0x0000000000000000000000000000000000000000',
+        '0x0000000000000000000000000000000000000000',
+        0,
+        0,
+        0,
+      )
+    }
+    default: {
+      throw new Error(`Unknown contract: ${contract}`)
+    }
+  }
 }

package/src/functions/getAvailable.test.ts

@@ -0,0 +1,21 @@
+import { ENS } from '..'
+import setup from '../tests/setup'
+
+let ensInstance: ENS
+
+beforeAll(async () => {
+  ;({ ensInstance } = await setup())
+})
+
+describe('getAvailable', () => {
+  it('should return false for a name that is unavailable', async () => {
+    const result = await ensInstance.getAvailable('test123.eth')
+    expect(typeof result).toBe('boolean')
+    expect(result).toBe(false)
+  })
+  it('should return true for a name that is available', async () => {
+    const result = await ensInstance.getAvailable('available-name.eth')
+    expect(typeof result).toBe('boolean')
+    expect(result).toBe(true)
+  })
+})

package/src/functions/getAvailable.ts

@@ -0,0 +1,37 @@
+import { ENSArgs } from '..'
+import { labelhash } from '../utils/labels'
+
+const raw = async ({ contracts }: ENSArgs<'contracts'>, name: string) => {
+  const baseRegistrar = await contracts?.getBaseRegistrar()!
+
+  const labels = name.split('.')
+  if (labels.length !== 2 || labels[1] !== 'eth') {
+    throw new Error('Currently only .eth names can be checked for availability')
+  }
+
+  return {
+    to: baseRegistrar.address,
+    data: baseRegistrar.interface.encodeFunctionData('available', [
+      labelhash(labels[0]),
+    ]),
+  }
+}
+
+const decode = async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
+  if (data === null) return
+  const baseRegistrar = await contracts?.getBaseRegistrar()!
+  try {
+    const result = baseRegistrar.interface.decodeFunctionResult(
+      'available',
+      data,
+    )
+    return result['0'] as boolean
+  } catch {
+    return
+  }
+}
+
+export default {
+  raw,
+  decode,
+}

package/src/functions/getDNSOwner.test.ts

@@ -1,13 +1,11 @@
-import * as packet from 'dns-packet'
-import fetch from 'node-fetch'
 import nock from 'nock'
-
 import getDNSOwner, { encodeURLParams } from './getDNSOwner'
 
-function hex_decode(string: string) {
-  let bytes: any[] = []
-  string.replace(/../g, function (pair) {
+function hexDecode(string: string) {
+  const bytes: any[] = []
+  string.replace(/../g, (pair) => {
     bytes.push(parseInt(pair, 16))
+    return pair
   })
   return new Uint8Array(bytes).buffer
 }
@@ -25,21 +23,14 @@ describe('encodeURLParams', () => {
 })
 
 describe('getDNSOwner', () => {
-  beforeAll(() => {
-    global.fetch = fetch
-  })
-  afterAll(() => {
-    global.fetch = undefined
-  })
   it('should return the address from the result of a dnsQuery', async () => {
     const dnsName = 'brantly.xyz'
 
-    const scope = nock('https://cloudflare-dns.com:443', {
+    nock('https://cloudflare-dns.com:443', {
       encodedQueryParams: true,
     })
       .get('/dns-query')
       .query((queryObject) => {
-        console.log('queryObject: ', queryObject)
         return (
           queryObject.ct === 'application/dns-udpwireformat' &&
           queryObject.dns ===
@@ -49,7 +40,7 @@ describe('getDNSOwner', () => {
       .reply(
         200,
         Buffer.from(
-          hex_decode(
+          hexDecode(
             '000181a00001000200000001045f656e73076272616e746c790378797a0000100001c00c0010000100000e10002d2c613d307839383331313033303936323044393131373331416330393332323139616630363039316236373434c00c002e000100000e10009f0010080300000e1062df366962c23569d89d076272616e746c790378797a0039c894ca1d7a60c1356e478066d39961a78ec1edbe62e1eb0f13d7947bb72097654648dc79be075ca32625f02e60267f45e88d7c05e9c3ec0cf21ab2dca67a8fbeb8e995644726357628446b888a144cafef5cbfca120c6511fe36de9d3c62dee27680825190c5404ca503904b98dbf62d9122f6fda393dc04b14a89ceb68c7a00002904d0000080000000',
           ),
         ),
@@ -77,12 +68,11 @@ describe('getDNSOwner', () => {
   it('should throw if there is an error in the DNS query', async () => {
     const dnsName = 'nick.xyz'
 
-    const scope = nock('https://cloudflare-dns.com:443', {
+    nock('https://cloudflare-dns.com:443', {
       encodedQueryParams: true,
     })
       .get('/dns-query')
       .query((queryObject) => {
-        console.log('queryObject: ', queryObject)
         return (
           queryObject.ct === 'application/dns-udpwireformat' &&
           queryObject.dns ===
@@ -92,7 +82,7 @@ describe('getDNSOwner', () => {
       .reply(
         200,
         Buffer.from(
-          hex_decode(
+          hexDecode(
             '000181830001000000010001045f656e73046e69636b0378797a0000100001c0110006000100000258003b046e7337310d646f6d61696e636f6e74726f6c03636f6d0003646e73056a6f6d6178036e6574007876d1800000708000001c2000093a800000025800002904d0000080000000',
           ),
         ),
@@ -115,7 +105,7 @@ describe('getDNSOwner', () => {
       )
     try {
       await getDNSOwner({}, dnsName)
-    } catch (error) {
+    } catch (error: any) {
       expect(error.message).toEqual('DNS query failed: NXDOMAIN')
     }
   })

package/src/functions/getDNSOwner.ts

@@ -1,3 +1,4 @@
+import { _fetchData } from '@ethersproject/web'
 import * as packet from 'dns-packet'
 
 export function encodeURLParams(p: { [key: string]: string }): string {
@@ -7,16 +8,17 @@ export function encodeURLParams(p: { [key: string]: string }): string {
 }
 
 export const getDNS = async (q: packet.Packet): Promise<packet.Packet> => {
-  const response = await global.fetch(
-    `https://cloudflare-dns.com/dns-query?${encodeURLParams({
-      ct: 'application/dns-udpwireformat',
-      dns: packet.encode(q)?.toString('base64'),
-      ts: Date.now().toString(),
-    })}`,
+  const url = `https://cloudflare-dns.com/dns-query?${encodeURLParams({
+    ct: 'application/dns-udpwireformat',
+    dns: packet.encode(q)?.toString('base64'),
+    ts: Date.now().toString(),
+  })}`
+  const response = await _fetchData(url, undefined)
+  const arrayBuffer = response.buffer.slice(
+    response.byteOffset,
+    response.byteLength + response.byteOffset,
   )
-  const arrayBuffer = await response.arrayBuffer()
-  // @ts-ignore:next-line
-  const fromArrayBuffer = Buffer.from(arrayBuffer);
+  const fromArrayBuffer = Buffer.from(arrayBuffer)
   return packet.decode(fromArrayBuffer)
 }
 

package/src/functions/getExpiry.test.ts

@@ -1,15 +1,11 @@
-import { ethers } from 'ethers'
 import { ENS } from '..'
 import setup from '../tests/setup'
 
-let ENSInstance: ENS
+let ensInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
-let provider: ethers.providers.JsonRpcProvider
-let accounts: string[]
 
 beforeAll(async () => {
-  ;({ ENSInstance, revert, provider } = await setup())
-  accounts = await provider.listAccounts()
+  ;({ ensInstance, revert } = await setup())
 })
 
 afterAll(async () => {
@@ -17,8 +13,8 @@ afterAll(async () => {
 })
 
 describe('getExpiry', () => {
-  it('should get the expiry for a name', async () => {
-    const result = await ENSInstance.getExpiry('jefflau.eth')
+  it('should get the expiry for a .eth name with no other args', async () => {
+    const result = await ensInstance.getExpiry('with-profile.eth')
     expect(result).toBeTruthy()
     if (result) {
       const { expiry, gracePeriod } = result
@@ -26,9 +22,31 @@ describe('getExpiry', () => {
       expect(gracePeriod).toBe(7776000000)
     }
   })
-  it('should throw an error for a non .eth name', async () => {
+  it('should get the expiry for a wrapped name', async () => {
+    const result = await ensInstance.getExpiry('wrapped.eth', {
+      contract: 'nameWrapper',
+    })
+
+    expect(result).toBeTruthy()
+    if (result) {
+      const { expiry, gracePeriod } = result
+      expect(expiry).toBeInstanceOf(Date)
+      expect(gracePeriod).toBe(null)
+    }
+  })
+  it('should throw an error for a non .eth name if not wrapped', async () => {
+    try {
+      await ensInstance.getExpiry('sub.with-profile.eth')
+      expect(false).toBeTruthy()
+    } catch {
+      expect(true).toBeTruthy()
+    }
+  })
+  it('should throw an error for a non .eth name if registrar is specified', async () => {
     try {
-      await ENSInstance.getExpiry('sub.jefflau.eth')
+      await ensInstance.getExpiry('sub.with-profile.eth', {
+        contract: 'registrar',
+      })
       expect(false).toBeTruthy()
     } catch {
       expect(true).toBeTruthy()

package/src/functions/getExpiry.ts

@@ -1,19 +1,24 @@
-import { BigNumber } from 'ethers'
-import { solidityKeccak256 } from 'ethers/lib/utils'
+import { BigNumber } from '@ethersproject/bignumber/lib/bignumber'
+import { keccak256 as solidityKeccak256 } from '@ethersproject/solidity'
 import { ENSArgs } from '..'
+import { namehash } from '../utils/normalise'
 
-const raw = async (
-  { contracts, multicallWrapper }: ENSArgs<'contracts' | 'multicallWrapper'>,
-  name: string,
-) => {
-  const baseRegistrar = await contracts?.getBaseRegistrar()!
+type ContractOption = 'registrar' | 'nameWrapper'
 
-  const labels = name.split('.')
+type Args = {
+  contract?: ContractOption
+}
 
+const getRegistrarExpiry = async (
+  { contracts, multicallWrapper }: ENSArgs<'contracts' | 'multicallWrapper'>,
+  labels: string[],
+) => {
   if (labels.length > 2 || labels[1] !== 'eth') {
-    throw new Error('Only .eth names have expiry dates')
+    throw new Error('Only .eth names have expiry dates on the registrar')
   }
 
+  const baseRegistrar = await contracts?.getBaseRegistrar()!
+
   const expiryCall = baseRegistrar.interface.encodeFunctionData('nameExpires', [
     solidityKeccak256(['string'], [labels[0]]),
   ])
@@ -32,11 +37,49 @@ const raw = async (
   ])
 }
 
-const decode = async (
+const getWrapperExpiry = async (
+  { contracts }: ENSArgs<'contracts'>,
+  labels: string[],
+) => {
+  const nameWrapper = await contracts?.getNameWrapper()!
+  const expiryCall = nameWrapper.interface.encodeFunctionData('getData', [
+    namehash(labels.join('.')),
+  ])
+  return {
+    to: nameWrapper.address,
+    data: expiryCall,
+  }
+}
+
+const getContractToUse = (
+  contract: ContractOption | undefined,
+  labels: string[],
+) => {
+  if (contract) return contract
+  if (labels.length === 2 && labels[1] === 'eth') {
+    return 'registrar'
+  }
+  return 'nameWrapper'
+}
+
+const raw = async (
+  ensArgs: ENSArgs<'contracts' | 'multicallWrapper'>,
+  name: string,
+  { contract }: Args = {},
+) => {
+  const labels = name.split('.')
+
+  const contractToUse = getContractToUse(contract, labels)
+
+  return contractToUse === 'nameWrapper'
+    ? getWrapperExpiry(ensArgs, labels)
+    : getRegistrarExpiry(ensArgs, labels)
+}
+
+const decodeRegistrarExpiry = async (
   { contracts, multicallWrapper }: ENSArgs<'contracts' | 'multicallWrapper'>,
   data: string,
 ) => {
-  if (data === null) return
   const result = await multicallWrapper.decode(data)
   const baseRegistrar = await contracts?.getBaseRegistrar()!
   try {
@@ -57,6 +100,41 @@ const decode = async (
   }
 }
 
+const decodeWrapperExpiry = async (
+  { contracts }: ENSArgs<'contracts'>,
+  data: string,
+) => {
+  const nameWrapper = await contracts?.getNameWrapper()!
+  try {
+    const [, , expiry] = nameWrapper.interface.decodeFunctionResult(
+      'getData',
+      data,
+    )
+    return {
+      expiry: new Date(expiry * 1000),
+      gracePeriod: null,
+    }
+  } catch {
+    return
+  }
+}
+
+const decode = async (
+  ensArgs: ENSArgs<'contracts' | 'multicallWrapper'>,
+  data: string,
+  name: string,
+  { contract }: Args = {},
+) => {
+  if (data === null) return
+
+  const labels = name.split('.')
+  const contractToUse = getContractToUse(contract, labels)
+
+  return contractToUse === 'nameWrapper'
+    ? decodeWrapperExpiry(ensArgs, data)
+    : decodeRegistrarExpiry(ensArgs, data)
+}
+
 export default {
   raw,
   decode,

package/src/functions/getHistory.test.ts

@@ -1,22 +1,24 @@
 import { ENS } from '..'
 import setup from '../tests/setup'
 
-let ENSInstance: ENS
+let ensInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
 
 beforeAll(async () => {
-  ;({ ENSInstance } = await setup())
-  jest.setTimeout(20000)
+  ;({ ensInstance, revert } = await setup())
 })
 
-describe('getHistory', () => {
-  let textEventsWithValue: any[]
+afterAll(async () => {
+  await revert()
+})
 
+describe('getHistory', () => {
   it('should return null for a non-existent name', async () => {
-    const result = await ENSInstance.getHistory('test123123cool.eth')
+    const result = await ensInstance.getHistory('test123123cool.eth')
     expect(result).toBeUndefined()
   })
   it('should return the history of a name', async () => {
-    const result = await ENSInstance.getHistory('jefflau.eth')
+    const result = await ensInstance.getHistory('with-profile.eth')
     expect(result).toBeTruthy()
     if (result) {
       expect(result).toHaveProperty('domain')
@@ -24,78 +26,13 @@ describe('getHistory', () => {
       expect(result).toHaveProperty('registration')
     }
   })
-  describe('getHistoryWithDetail', () => {
-    it('should return null for a non-existent name', async () => {
-      const result = await ENSInstance.getHistoryWithDetail(
-        'test123123cool.eth',
-      )
-      expect(result).toBeUndefined()
-    })
-    it('should return the history of a name with TextChanged event detail', async () => {
-      const result = await ENSInstance.getHistoryWithDetail('jefflau.eth')
-      expect(result).toBeTruthy()
-      if (result) {
-        const textEvents = result.resolver.filter(
-          (x) => x.type === 'TextChanged',
-        )
-        textEvents.forEach((event) =>
-          expect(event.data).toHaveProperty('value'),
-        )
-        textEventsWithValue = textEvents
-      }
-    })
-  })
-  describe('getHistoryDetailForTransactionHash', () => {
-    it('should throw an error for an invalid transaction hash', async () => {
-      try {
-        await ENSInstance.getHistoryDetailForTransactionHash('0x234')
-        expect(false).toBeTruthy()
-      } catch (error) {
-        expect((error as any).message).toContain('invalid hash')
-      }
-    })
-    it('should return null for a transaction hash with no text events', async () => {
-      const result = await ENSInstance.getHistoryDetailForTransactionHash(
-        '0x0fd7b555e3076ef38dbbe2e40deefe44c9a0530d43f6b3f60dbed4ba49d229b7',
-      )
-      expect(result).toBeUndefined()
-    })
-    it('should return single item for a given transaction hash with one event', async () => {
-      const eventToUse = textEventsWithValue[0]
-      const result = (await ENSInstance.getHistoryDetailForTransactionHash(
-        eventToUse.transactionHash,
-      )) as { key: any; value: any }[]
-      expect(result).toHaveLength(1)
-      if (result) {
-        expect(result[0]).toMatchObject(eventToUse.data)
-      }
-    })
-    it('should return multiple items for a given transaction hash with multiple events', async () => {
-      const hash =
-        '0x002b7cc3c85168d885a38226a28fac349d13cbaff7f3db4fa3af31f22b863079'
-      const dataArr = [
-        { key: 'description', value: 'Not so super description' },
-        { key: 'url', value: 'facebook.com' },
-      ]
-      const result = (await ENSInstance.getHistoryDetailForTransactionHash(
-        hash,
-      )) as { key: any; value: any }[]
-      expect(result).toHaveLength(dataArr.length)
-      if (result) {
-        result.forEach((item, index) =>
-          expect(item).toMatchObject(dataArr[index]),
-        )
-      }
-    })
-    it('should return a single item when an index is specified for a hash', async () => {
-      const hash =
-        '0x002b7cc3c85168d885a38226a28fac349d13cbaff7f3db4fa3af31f22b863079'
-      const data = { key: 'url', value: 'facebook.com' }
-      const result = (await ENSInstance.getHistoryDetailForTransactionHash(
-        hash,
-        1,
-      )) as { key: any; value: any }
-      expect(result).toMatchObject(data)
-    })
+  it('should return the history of a wrapped name', async () => {
+    const result = await ensInstance.getHistory('wrapped.eth')
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result).toHaveProperty('domain')
+      expect(result).toHaveProperty('resolver')
+      expect(result).toHaveProperty('registration')
+    }
   })
 })