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

package/src/functions/getExpiry.test.ts

@@ -0,0 +1,59 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import setup from '../tests/setup'
+
+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()
+})
+
+afterAll(async () => {
+  await revert()
+})
+
+describe('getExpiry', () => {
+  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
+      expect(expiry).toBeInstanceOf(Date)
+      expect(gracePeriod).toBe(7776000000)
+    }
+  })
+  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.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 { 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 [_owner, _fuses, 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/{tests → functions}/getFuses.test.ts

@@ -1,6 +1,6 @@
 import { ethers } from 'ethers'
 import { ENS } from '..'
-import setup from './setup'
+import setup from '../tests/setup'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
@@ -12,8 +12,6 @@ let withWrappedSnapshot: any
 beforeAll(async () => {
   ;({ ENSInstance, revert, provider, createSnapshot } = await setup())
   accounts = await provider.listAccounts()
-  const tx = await ENSInstance.wrapName('parthtejpal.eth', accounts[0])
-  await tx.wait()
 
   withWrappedSnapshot = await createSnapshot()
 })
@@ -29,19 +27,12 @@ afterAll(async () => {
 
 describe('getFuses', () => {
   it('should return null for an unwrapped name', async () => {
-    const result = await ENSInstance.getFuses('jefflau.eth')
+    const result = await ENSInstance.getFuses('with-profile.eth')
     expect(result).toBeUndefined()
   })
   it('should return with canDoEverything set to true for a name with no fuses burned', async () => {
-    const tx = await ENSInstance.createSubname({
-      contract: 'nameWrapper',
-      name: 'test.parthtejpal.eth',
-      owner: accounts[0],
-      options: { addressOrIndex: 0 },
-    })
-    await tx.wait()
-
-    const result = await ENSInstance.getFuses('test.parthtejpal.eth')
+    const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
+    const result = await ENSInstance.getFuses('test.wrapped-with-subnames.eth')
     expect(result).toBeTruthy()
     if (result) {
       expect(result.fuseObj.canDoEverything).toBe(true)
@@ -55,13 +46,17 @@ describe('getFuses', () => {
     }
   })
   it('should return with other correct fuses', async () => {
-    const tx = await ENSInstance.burnFuses('parthtejpal.eth', {
-      cannotUnwrap: true,
-      cannotSetTtl: true,
-      cannotCreateSubdomain: true,
+    const tx = await ENSInstance.burnFuses('wrapped.eth', {
+      fusesToBurn: {
+        cannotUnwrap: true,
+        cannotSetTtl: true,
+        cannotCreateSubdomain: true,
+      },
+      addressOrIndex: 1,
     })
     await tx.wait()
-    const result = await ENSInstance.getFuses('parthtejpal.eth')
+
+    const result = await ENSInstance.getFuses('wrapped.eth')
     expect(result).toBeTruthy()
     if (result) {
       expect(result.fuseObj).toMatchObject({
@@ -77,27 +72,11 @@ describe('getFuses', () => {
       expect(result.rawFuses.toHexString()).toBe('0x71')
     }
   })
-  it('should return correct vulnerability data for an invulnerable node', async () => {
-    const result = await ENSInstance.getFuses('parthtejpal.eth')
-    expect(result).toBeTruthy()
-    if (result) {
-      expect(result.vulnerability).toBe('Safe')
-      expect(result.vulnerableNode).toBeNull()
-    }
-  })
-  it('should return correct vulnerability data for a vulnerable node', async () => {
-    const tx = await ENSInstance.createSubname({
-      name: 'test.parthtejpal.eth',
-      owner: accounts[0],
-      contract: 'nameWrapper',
-    })
-    await tx.wait()
-
-    const result = await ENSInstance.getFuses('test.parthtejpal.eth')
+  it('should return correct expiry', async () => {
+    const result = await ENSInstance.getFuses('wrapped.eth')
     expect(result).toBeTruthy()
     if (result) {
-      expect(result.vulnerability).toBe('SubdomainReplacementAllowed')
-      expect(result.vulnerableNode).toBe('parthtejpal.eth')
+      expect(result.expiryDate).toBeInstanceOf(Date)
     }
   })
 })

package/src/functions/getFuses.ts

@@ -1,6 +1,7 @@
-import { BigNumber, ethers, utils } from 'ethers'
+import { BigNumber } from 'ethers'
 import { ENSArgs } from '..'
 import { testable as fuseEnums } from '../utils/fuses'
+import { namehash } from '../utils/normalise'
 
 const NameSafety = [
   'Safe',
@@ -15,7 +16,7 @@ const raw = async ({ contracts }: ENSArgs<'contracts'>, name: string) => {
   return {
     to: nameWrapper.address,
     data: nameWrapper.interface.encodeFunctionData('getFuses', [
-      ethers.utils.namehash(name),
+      namehash(name),
     ]),
   }
 }
@@ -27,8 +28,12 @@ const decode = async (
 ) => {
   const nameWrapper = await contracts?.getNameWrapper()!
   try {
-    const [fuses, vulnerability, vulnerableNode] =
-      nameWrapper.interface.decodeFunctionResult('getFuses', data)
+    const [_fuses, expiry] = nameWrapper.interface.decodeFunctionResult(
+      'getFuses',
+      data,
+    )
+
+    const fuses = BigNumber.from(_fuses)
 
     const fuseObj = Object.fromEntries(
       Object.keys(fuseEnums).map((fuseEnum) => [
@@ -47,22 +52,12 @@ const decode = async (
       fuseObj.canDoEverything = false
     }
 
-    let returnVulnerableNode: string | null = null
-    if (utils.hexStripZeros(vulnerableNode) !== '0x') {
-      name.split('.').forEach((label, index, arr) => {
-        const node = arr.slice(index).join('.')
-        const nodehash = utils.namehash(node)
-        if (nodehash === vulnerableNode) {
-          returnVulnerableNode = node
-        }
-      })
-    }
+    const expiryDate = new Date(expiry * 1000)
 
     return {
       fuseObj,
-      vulnerability: NameSafety[vulnerability] || vulnerability,
-      vulnerableNode: returnVulnerableNode,
-      rawFuses: fuses as BigNumber,
+      expiryDate,
+      rawFuses: fuses,
     }
   } catch {
     return

package/src/functions/getHistory.test.ts

@@ -0,0 +1,29 @@
+import { ENS } from '..'
+import setup from '../tests/setup'
+
+let ENSInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
+
+beforeAll(async () => {
+  ;({ ENSInstance, revert } = await setup())
+})
+
+afterAll(async () => {
+  await revert()
+})
+
+describe('getHistory', () => {
+  it('should return null for a non-existent name', async () => {
+    const result = await ENSInstance.getHistory('test123123cool.eth')
+    expect(result).toBeUndefined()
+  })
+  it('should return the history of a name', async () => {
+    const result = await ENSInstance.getHistory('with-profile.eth')
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result).toHaveProperty('domain')
+      expect(result).toHaveProperty('resolver')
+      expect(result).toHaveProperty('registration')
+    }
+  })
+})

package/src/functions/getHistory.ts

@@ -2,7 +2,6 @@ import { formatsByCoinType } from '@ensdomains/address-encoder'
 import { ethers } from 'ethers'
 import { ENSArgs } from '..'
 import { decodeContenthash } from '../utils/contentHash'
-import { makeOtherIndexes } from '../utils/makeHashIndexes'
 
 type DomainEvent = 'NewOwner' | 'NewResolver' | 'Transfer' | 'NewTTL'
 type RegistrationEvent = 'NameRegistered' | 'NameRenewed' | 'NameTransferred'
@@ -63,7 +62,7 @@ const eventFormat: Record<
     NameChanged: (args: any) => ({ name: args.name }),
     AbiChanged: (args: any) => ({ contentType: args.contentType }),
     PubkeyChanged: (args: any) => ({ x: args.x, y: args.y }),
-    TextChanged: (args: any) => ({ key: args.key }),
+    TextChanged: (args: any) => ({ key: args.key, value: args.value }),
     ContenthashChanged: (args: any) => ({ hash: decodeContenthash(args.hash) }),
     InterfaceChanged: (args: any) => ({
       interfaceId: args.interfaceId,
@@ -86,37 +85,6 @@ const mapEvents = (eventArray: any[], type: EventTypes) =>
     data: eventFormat[type][event.__typename](event),
   }))
 
-const mapResultDetailDecode =
-  (publicResolver: ethers.Contract) => (result: any) => {
-    const hashIndexes = makeOtherIndexes(result.input, '10f13a8c')
-    const abiLengths = hashIndexes.map((x: number) => ({
-      index: x,
-      length:
-        x === 0
-          ? ethers.utils.hexDataLength(result.input)
-          : parseInt(ethers.utils.hexDataSlice(result.input, x - 32, x), 16),
-    }))
-    const ABIs = abiLengths.map(({ index, length }) =>
-      ethers.utils.hexDataSlice(result.input, index, index + length),
-    )
-    return ABIs.map((abi: string) => {
-      try {
-        return publicResolver.interface.decodeFunctionData(
-          'setText(bytes32,string,string)',
-          abi,
-        )
-      } catch {
-        return
-      }
-    })
-  }
-
-const expandDecode = (prev: any, curr: any) => {
-  if (!curr) return [...prev, { value: null }]
-  if (!curr.length) return [...prev, curr]
-  return [...prev, ...curr]
-}
-
 export async function getHistory(
   { gqlInstance }: ENSArgs<'gqlInstance'>,
   name: string,
@@ -200,6 +168,7 @@ export async function getHistory(
               }
               ...on TextChanged {
                 key
+                value
               }
               ...on ContenthashChanged {
                 hash
@@ -251,97 +220,3 @@ export async function getHistory(
     resolver: resolverHistory,
   }
 }
-
-export async function getHistoryWithDetail(
-  {
-    contracts,
-    gqlInstance,
-    provider,
-  }: ENSArgs<'contracts' | 'gqlInstance' | 'provider'>,
-  name: string,
-) {
-  const historyRes = await getHistory({ gqlInstance }, name)
-
-  if (!historyRes) return
-
-  const { domain, registration, resolver: resolverHistory } = historyRes
-
-  const textEvents = resolverHistory.filter(
-    (event) => event.type === 'TextChanged',
-  )
-
-  const transactions = textEvents.reduce((prev, curr) => {
-    if (prev.includes(curr.transactionHash)) {
-      return prev
-    }
-    return [...prev, curr.transactionHash]
-  }, [] as string[])
-
-  const publicResolver = await contracts?.getPublicResolver()!
-
-  const fetchResult = (
-    await ethers.utils.fetchJson(
-      provider!.connection,
-      JSON.stringify(
-        transactions.map((tx, i) => ({
-          jsonrpc: '2.0',
-          id: i,
-          method: 'eth_getTransactionByHash',
-          params: [tx],
-        })),
-      ),
-    )
-  )
-    .map((result: any) => result.result)
-    .map(mapResultDetailDecode(publicResolver))
-    .reduce(expandDecode, [])
-
-  const detailedResolverHistory = resolverHistory.map((event) => {
-    if (event.type !== 'TextChanged') return event
-    const { id } = event
-    const matchedTextInx = textEvents.findIndex((x) => x.id === id)
-    return {
-      ...event,
-      data: {
-        ...event.data,
-        value: fetchResult[matchedTextInx] && fetchResult[matchedTextInx].value,
-      },
-    }
-  })
-
-  return {
-    domain,
-    registration,
-    resolver: detailedResolverHistory,
-  }
-}
-
-export async function getHistoryDetailForTransactionHash(
-  { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
-  hash: string,
-  indexInTransaction?: number,
-) {
-  const publicResolver = await contracts?.getPublicResolver()!
-  const transaction = await provider!.getTransaction(hash)
-  if (!transaction) return
-  const result = mapResultDetailDecode(publicResolver)({
-    input: transaction.data,
-  })
-  if (!result || !result.length) return
-  if (typeof indexInTransaction === 'number') {
-    if (indexInTransaction + 1 > result.length) return
-    const resultItem = result[indexInTransaction]
-    if (
-      !resultItem ||
-      !resultItem.key ||
-      (!resultItem.value && resultItem.value !== '')
-    )
-      return
-    return { key: resultItem.key, value: resultItem.value }
-  }
-  return result.map((item: any) => {
-    if (!item.key) return
-    if (!item.value && item.value !== '') return { key: item.key, value: null }
-    return { key: item.key, value: item.value }
-  })
-}

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

@@ -1,6 +1,6 @@
 import { ethers } from 'ethers'
 import { ENS } from '..'
-import setup from './setup'
+import setup from '../tests/setup'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
@@ -19,11 +19,11 @@ afterAll(async () => {
 describe('getName', () => {
   it('should get a primary name from an address', async () => {
     const result = await ENSInstance.getName(
-      '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
     )
     expect(result).toBeTruthy()
     if (result) {
-      expect(result.name).toBe('jefflau.eth')
+      expect(result.name).toBe('with-profile.eth')
       expect(result.match).toBeTruthy()
     }
   })
@@ -31,16 +31,16 @@ describe('getName', () => {
     const result = await ENSInstance.getName(
       '0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0',
     )
-    expect(result).toBeUndefined()
+    expect(result?.name).toBeUndefined()
   })
   it('should return with a false match for a name with no forward resolution', async () => {
-    const tx = await ENSInstance.setName('jefflau.eth')
+    const tx = await ENSInstance.setName('with-profile.eth')
     await tx?.wait()
 
     const result = await ENSInstance.getName(accounts[0])
     expect(result).toBeTruthy()
     if (result) {
-      expect(result.name).toBe('jefflau.eth')
+      expect(result.name).toBe('with-profile.eth')
       expect(result.match).toBeFalsy()
     }
   })

package/src/functions/getName.ts

@@ -31,7 +31,7 @@ const decode = async (
       resolverAddress: result['3'],
     }
   } catch {
-    return { name: null, match: false }
+    return { name: undefined }
   }
 }