@ensdomains/ensjs 3.0.0-alpha.6 → 3.0.0-alpha.60

package/src/functions/deleteSubname.ts

@@ -1,16 +1,70 @@
+import { keccak256 as solidityKeccak256 } from '@ethersproject/solidity'
 import { ENSArgs } from '..'
+import { namehash } from '../utils/normalise'
+
+type BaseArgs = {
+  contract: 'registry' | 'nameWrapper'
+  method?: 'setRecord' | 'setSubnodeOwner'
+}
+
+type NameWrapperArgs = {
+  contract: 'nameWrapper'
+  method: 'setRecord' | 'setSubnodeOwner'
+}
+
+type Args = BaseArgs | NameWrapperArgs
 
 export default async function (
-  { transferSubname }: ENSArgs<'transferSubname'>,
+  { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
   name: string,
-  {
-    contract,
-  }: {
-    contract: 'registry' | 'nameWrapper'
-  },
+  { contract, ...args }: Args,
 ) {
-  return transferSubname.populateTransaction(name, {
-    contract,
-    address: '0x0000000000000000000000000000000000000000',
-  })
+  const labels = name.split('.')
+  if (labels.length < 3) {
+    throw new Error(`${name} is not a valid subname`)
+  }
+
+  switch (contract) {
+    case 'registry': {
+      const registry = (await contracts!.getRegistry()!).connect(signer)
+      const label = labels.shift() as string
+      const labelhash = solidityKeccak256(['string'], [label])
+      const parentNodehash = namehash(labels.join('.'))
+
+      return registry.populateTransaction.setSubnodeRecord(
+        parentNodehash,
+        labelhash,
+        '0x0000000000000000000000000000000000000000',
+        '0x0000000000000000000000000000000000000000',
+        0,
+      )
+    }
+    case 'nameWrapper': {
+      const nameWrapper = (await contracts!.getNameWrapper()!).connect(signer)
+      const { method } = args as NameWrapperArgs
+
+      if (method === 'setRecord') {
+        const node = namehash(name)
+        return nameWrapper.populateTransaction.setRecord(
+          node,
+          '0x0000000000000000000000000000000000000000',
+          '0x0000000000000000000000000000000000000000',
+          0,
+        )
+      }
+
+      const label = labels.shift() as string
+      const parentNodehash = namehash(labels.join('.'))
+      return nameWrapper.populateTransaction.setSubnodeOwner(
+        parentNodehash,
+        label,
+        '0x0000000000000000000000000000000000000000',
+        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/getDecryptedName.test.ts

@@ -0,0 +1,49 @@
+import { ENS } from '../index'
+import setup from '../tests/setup'
+
+let ensInstance: ENS
+
+beforeAll(async () => {
+  ;({ ensInstance } = await setup())
+})
+
+describe('getDecryptedName', () => {
+  it('should decrypt a wrapped name with on-chain data', async () => {
+    const result = await ensInstance.getDecryptedName(
+      '[9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb658].wrapped-with-subnames.eth',
+    )
+    expect(result).toBeDefined()
+    expect(result).toBe('test.wrapped-with-subnames.eth')
+  })
+  it('should decrypt a name via namehash lookup', async () => {
+    const result = await ensInstance.getDecryptedName(
+      '[f81b517a242b218999ec8eec0ea6e2ddbef2a367a14e93f4a32a39e260f686ad].eth',
+    )
+    expect(result).toBeDefined()
+    expect(result).toBe('test123.eth')
+  })
+  it('should decrypt a name via labelhash lookup', async () => {
+    const result = await ensInstance.getDecryptedName(
+      '[4d2920c35d976f8478bee89292ba85074d1bbea73f1571363b41a1629e1bac68].with-unknown-subnames.eth',
+    )
+    expect(result).toBeDefined()
+    expect(result).toBe('aaa123.with-unknown-subnames.eth')
+  })
+  it('should partially decrypt a name when allowIncomplete is true', async () => {
+    const result = await ensInstance.getDecryptedName(
+      '[7bffb6e3ebf801bbc438fea5c11d957ba49978bdc8d52b71cba974139d22edea].[6c14e1739568670447af1d5af8a571008f7a582068af18bcd7ac2dbc13bb37c1].eth',
+      true,
+    )
+    expect(result).toBeDefined()
+    expect(result).toBe(
+      '[7bffb6e3ebf801bbc438fea5c11d957ba49978bdc8d52b71cba974139d22edea].with-unknown-subnames.eth',
+    )
+  })
+  it('should not partially decrypt a name when allowIncomplete is false', async () => {
+    const result = await ensInstance.getDecryptedName(
+      '[7bffb6e3ebf801bbc438fea5c11d957ba49978bdc8d52b71cba974139d22edea].[6c14e1739568670447af1d5af8a571008f7a582068af18bcd7ac2dbc13bb37c1].eth',
+      false,
+    )
+    expect(result).toBeUndefined()
+  })
+})

package/src/functions/getDecryptedName.ts

@@ -0,0 +1,119 @@
+import { hexStripZeros } from '@ethersproject/bytes'
+import { ENSArgs } from '../index'
+import { hexDecodeName } from '../utils/hexEncodedName'
+import {
+  checkIsDecrypted,
+  decodeLabelhash,
+  getEncryptedLabelAmount,
+  isEncodedLabelhash,
+} from '../utils/labels'
+import { namehash } from '../utils/normalise'
+
+const raw = async (
+  { contracts }: ENSArgs<'contracts'>,
+  name: string,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  allowIncomplete?: boolean,
+) => {
+  const nameWrapper = await contracts?.getNameWrapper()!
+
+  return {
+    to: nameWrapper.address,
+    data: nameWrapper.interface.encodeFunctionData('names', [namehash(name)]),
+  }
+}
+
+const generateNameQuery = (labels: string[]) => {
+  let query = ''
+
+  for (let i = 0; i < labels.length; i += 1) {
+    const label = labels[i]
+    if (isEncodedLabelhash(label)) {
+      query += `
+        label${i}: domains(where: { labelhash: "${decodeLabelhash(
+        label,
+      ).toLowerCase()}", labelName_not: null }) {
+          labelName
+        }
+      `
+    }
+  }
+
+  return query
+}
+
+const decode = async (
+  { contracts, gqlInstance }: ENSArgs<'contracts' | 'gqlInstance'>,
+  data: string,
+  name: string,
+  allowIncomplete: boolean = false,
+) => {
+  if (data !== null) {
+    const nameWrapper = await contracts?.getNameWrapper()!
+    try {
+      const result = nameWrapper.interface.decodeFunctionResult('names', data)
+      if (hexStripZeros(result['0']) !== '0x') {
+        const decoded = hexDecodeName(result['0'])
+        if (decoded && decoded !== '.') return decoded
+      }
+    } catch (e: any) {
+      console.error('Error decoding name: ', e)
+      return
+    }
+  }
+
+  if (checkIsDecrypted(name)) return name
+  // if the name isn't wrapped, try to fetch the name from an existing Domain entity
+  // also try to fetch the label names from any Domain entities that have a corresponding labelhash
+  const labels = name.split('.')
+  const decryptedNameQuery = gqlInstance.gql`
+        query decodedName($id: String!) {
+          namehashLookup: domains(where: { id: $id }) {
+            name
+          }
+          ${generateNameQuery(labels)}
+        }
+      `
+
+  const decryptedNameResult = await gqlInstance.client.request(
+    decryptedNameQuery,
+    {
+      id: namehash(name),
+    },
+  )
+
+  if (!decryptedNameResult) return
+
+  const namehashLookupResult = decryptedNameResult?.namehashLookup[0]?.name
+  let bestResult: string | undefined = namehashLookupResult
+  if (namehashLookupResult && checkIsDecrypted(namehashLookupResult)) {
+    return namehashLookupResult
+  }
+
+  const { namehashLookup: _, ...labelNames } = decryptedNameResult
+  if (Object.keys(labelNames).length !== 0) {
+    for (const [key, value] of Object.entries<[{ labelName?: string }]>(
+      labelNames,
+    )) {
+      if (value.length && value[0].labelName) {
+        labels[parseInt(key.replace('label', ''))] = value[0].labelName
+      }
+    }
+    const labelLookupResult = labels.join('.')
+    if (
+      !namehashLookupResult ||
+      getEncryptedLabelAmount(namehashLookupResult) >
+        getEncryptedLabelAmount(labelLookupResult)
+    )
+      bestResult = labelLookupResult
+  }
+
+  if (!bestResult || (!allowIncomplete && !checkIsDecrypted(bestResult))) return
+
+  return bestResult
+}
+
+export default {
+  raw,
+  decode,
+}

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,25 @@
-import { BigNumber } from 'ethers'
-import { solidityKeccak256 } from 'ethers/lib/utils'
+import { BigNumber } from '@ethersproject/bignumber'
+import { keccak256 as solidityKeccak256 } from '@ethersproject/solidity'
 import { ENSArgs } from '..'
+import { namehash } from '../utils/normalise'
+import { checkIsDotEth } from '../utils/validation'
 
-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 +38,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 (checkIsDotEth(labels)) {
+    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 +101,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,