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

package/src/functions/batchWrappers.ts

@@ -1,5 +1,6 @@
-import { ethers } from 'ethers'
+import type { TransactionRequest } from '@ethersproject/providers'
 import { ENSArgs } from '..'
+import ccipLookup from '../utils/ccip'
 import { hexEncodeName } from '../utils/hexEncodedName'
 
 export const universalWrapper = {
@@ -11,16 +12,16 @@ export const universalWrapper = {
     const universalResolver = await contracts?.getUniversalResolver()!
     return {
       to: universalResolver.address,
-      data: universalResolver.interface.encodeFunctionData('resolve', [
-        hexEncodeName(name),
-        data,
-      ]),
+      data: universalResolver.interface.encodeFunctionData(
+        'resolve(bytes,bytes)',
+        [hexEncodeName(name), data],
+      ),
     }
   },
   decode: async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
     const universalResolver = await contracts?.getUniversalResolver()!
     const response = universalResolver.interface.decodeFunctionResult(
-      'resolve',
+      'resolve(bytes,bytes)',
       data,
     )
     if (!response || !response[0]) {
@@ -58,9 +59,9 @@ export const resolverMulticallWrapper = {
 }
 
 export const multicallWrapper = {
-  raw: async function (
+  async raw(
     { contracts }: ENSArgs<'contracts'>,
-    transactions: ethers.providers.TransactionRequest[],
+    transactions: TransactionRequest[],
     requireSuccess: boolean = false,
   ) {
     const multicall = await contracts?.getMulticall()!
@@ -75,7 +76,11 @@ export const multicallWrapper = {
       ]),
     }
   },
-  decode: async function ({ contracts }: ENSArgs<'contracts'>, data: string) {
+  async decode(
+    { contracts, provider }: ENSArgs<'contracts' | 'provider'>,
+    data: string,
+    transactions: TransactionRequest[],
+  ) {
     if (!data) return
     const multicall = await contracts?.getMulticall()!
     try {
@@ -83,8 +88,34 @@ export const multicallWrapper = {
         'tryAggregate',
         data,
       )
-      return result
-    } catch {
+      const ccipChecked = await Promise.all(
+        (result as [boolean, string][]).map(
+          async ([success, returnData], i) => {
+            let newArr: [boolean, string] = [success, returnData]
+            // OffchainLookup(address,string[],bytes,bytes4,bytes)
+            if (!success && returnData.startsWith('0x556f1830')) {
+              try {
+                const newData = await ccipLookup(
+                  provider!,
+                  transactions[i],
+                  returnData,
+                )
+                if (newData) {
+                  newArr = [true, newData]
+                }
+              } catch {}
+            }
+            return {
+              ...newArr,
+              success: newArr[0],
+              returnData: newArr[1],
+            }
+          },
+        ),
+      )
+      return ccipChecked
+    } catch (e: any) {
+      console.error(e)
       return
     }
   },

package/src/functions/ccip.test.ts

@@ -0,0 +1,77 @@
+import dotenv from 'dotenv'
+import { ENS } from '..'
+import setup from '../tests/setup'
+
+dotenv.config()
+
+let ensInstance: ENS
+
+beforeAll(async () => {
+  ;({ ensInstance } = await setup(true))
+})
+
+jest.setTimeout(20000)
+
+describe('CCIP', () => {
+  describe('getProfile', () => {
+    it('should return a profile from a ccip-read name', async () => {
+      const result = await ensInstance.getProfile('1.offchainexample.eth', {
+        fallback: {
+          texts: ['email', 'description'],
+          contentHash: true,
+          coinTypes: ['LTC', '60'],
+        },
+      })
+      expect(result).toBeTruthy()
+      if (result) {
+        expect(result.address).toBe(
+          '0x41563129cDbbD0c5D3e1c86cf9563926b243834d',
+        )
+      }
+    })
+    it('should return a profile from arb-resolver.eth', async () => {
+      const result = await ensInstance.getProfile('arb-resolver.eth', {
+        fallback: {
+          texts: ['email', 'description'],
+          contentHash: true,
+          coinTypes: ['LTC', '60'],
+        },
+      })
+      expect(result).toBeTruthy()
+      if (result) {
+        expect(result.address).toBe(
+          '0xA5313060f9FA6B607AC8Ca8728a851166c9f6127',
+        )
+      }
+    })
+  })
+  describe('batch', () => {
+    it('allows batch ccip', async () => {
+      const result = await ensInstance.batch(
+        ensInstance.getAddr.batch('1.offchainexample.eth'),
+        ensInstance.getAddr.batch('1.offchainexample.eth', 'LTC'),
+        ensInstance.getText.batch('1.offchainexample.eth', 'email'),
+      )
+      expect(result).toBeTruthy()
+      if (result) {
+        expect(result[0]).toBe('0x41563129cDbbD0c5D3e1c86cf9563926b243834d')
+        expect(result[1]).toStrictEqual({
+          coin: 'LTC',
+          addr: 'MQMcJhpWHYVeQArcZR3sBgyPZxxRtnH441',
+        })
+        expect(result[2]).toBe('nick@ens.domains')
+      }
+    })
+    it('allows nested batch ccip', async () => {
+      const result = await ensInstance.batch(
+        ensInstance.batch.batch(
+          ensInstance.getAddr.batch('1.offchainexample.eth'),
+        ),
+      )
+      expect(result).toBeTruthy()
+      if (result) {
+        expect(result[0]![0]).toBe('0x41563129cDbbD0c5D3e1c86cf9563926b243834d')
+      }
+    })
+  })
+})

package/src/functions/commitName.test.ts

@@ -0,0 +1,58 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import setup from '../tests/setup'
+import { randomSecret } from '../utils/registerHelpers'
+
+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('commitName', () => {
+  beforeEach(async () => {
+    await revert()
+  })
+  it('should return a populated commit transaction with extra data and succeed', async () => {
+    const { customData, ...popTx } =
+      await ensInstance.commitName.populateTransaction('commitment.eth', {
+        duration: 31536000,
+        owner: accounts[1],
+        addressOrIndex: accounts[1],
+      })
+    expect(popTx).toBeTruthy()
+    expect(customData).toHaveProperty('secret')
+    expect(customData).toHaveProperty('commitment')
+
+    const tx = await provider.getSigner().sendTransaction(popTx)
+    await tx.wait()
+
+    const controller = await ensInstance.contracts!.getEthRegistrarController()!
+    const commitment = await controller.commitments(customData!.commitment)
+    expect(commitment).toBeTruthy()
+  })
+  it('should return a customised commmit transaction and succeed', async () => {
+    const secret = randomSecret()
+    const tx = await ensInstance.commitName('commitment.eth', {
+      duration: 31536000,
+      owner: accounts[1],
+      addressOrIndex: accounts[1],
+      secret,
+    })
+    await tx.wait()
+    expect(tx.customData).toBeTruthy()
+    expect(tx.customData!.secret).toBe(secret)
+
+    const controller = await ensInstance.contracts!.getEthRegistrarController()!
+    const commitment = await controller.commitments(tx.customData!.commitment)
+    expect(commitment).toBeTruthy()
+  })
+})

package/src/functions/commitName.ts

@@ -0,0 +1,38 @@
+import { ENSArgs } from '..'
+import { CommitmentParams, makeCommitment } from '../utils/registerHelpers'
+import { wrappedLabelLengthCheck } from '../utils/wrapper'
+
+type Params = Omit<CommitmentParams, 'resolver' | 'name'> & {
+  resolverAddress?: string
+}
+
+export default async function (
+  { contracts }: ENSArgs<'contracts'>,
+  name: string,
+  { resolverAddress, ...params }: Params,
+) {
+  const labels = name.split('.')
+  if (labels.length !== 2 || labels[1] !== 'eth')
+    throw new Error('Currently only .eth TLD registrations are supported')
+
+  wrappedLabelLengthCheck(labels[0])
+
+  const controller = await contracts!.getEthRegistrarController()
+  const resolver = await contracts!.getPublicResolver(
+    undefined,
+    resolverAddress,
+  )
+  const { secret, commitment } = makeCommitment({
+    name,
+    resolver,
+    ...params,
+  })
+
+  return {
+    ...(await controller.populateTransaction.commit(commitment)),
+    customData: {
+      secret,
+      commitment,
+    },
+  }
+}

package/src/functions/createSubname.test.ts

@@ -3,14 +3,13 @@ import { ENS } from '..'
 import setup from '../tests/setup'
 import { namehash } from '../utils/normalise'
 
-let ENSInstance: ENS
+let ensInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
-let createSnapshot: Awaited<ReturnType<typeof setup>>['createSnapshot']
 let provider: ethers.providers.JsonRpcProvider
 let accounts: string[]
 
 beforeAll(async () => {
-  ;({ ENSInstance, revert, createSnapshot, provider } = await setup())
+  ;({ ensInstance, revert, provider } = await setup())
   accounts = await provider.listAccounts()
 })
 
@@ -23,33 +22,29 @@ describe('createSubname', () => {
     await revert()
   })
   it('should allow creating a subname on the registry', async () => {
-    const tx = await ENSInstance.createSubname('test.parthtejpal.eth', {
+    const tx = await ensInstance.createSubname('test.test123.eth', {
       contract: 'registry',
       owner: accounts[0],
-      addressOrIndex: 0,
+      addressOrIndex: 1,
     })
     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.test123.eth'))
     expect(result).toBe(accounts[0])
   })
   it('should allow creating a subname on the namewrapper', async () => {
-    const wrapNameTx = await ENSInstance.wrapName('parthtejpal.eth', {
-      wrappedOwner: accounts[0],
-    })
-    await wrapNameTx.wait()
-    const tx = await ENSInstance.createSubname('test.parthtejpal.eth', {
+    const tx = await ensInstance.createSubname('test.wrapped.eth', {
       contract: 'nameWrapper',
       owner: accounts[0],
-      addressOrIndex: 0,
+      addressOrIndex: 1,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
 
-    const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
-    const result = await nameWrapper.ownerOf(namehash('test.parthtejpal.eth'))
+    const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+    const result = await nameWrapper.ownerOf(namehash('test.wrapped.eth'))
     expect(result).toBe(accounts[0])
   })
 })

package/src/functions/createSubname.ts

@@ -1,8 +1,9 @@
-import { ethers } from 'ethers'
+import { BigNumber } from '@ethersproject/bignumber'
+import { keccak256 as solidityKeccak256 } from '@ethersproject/solidity'
 import { ENSArgs } from '..'
-import { FuseOptions } from '../@types/FuseOptions'
-import generateFuseInput from '../utils/generateFuseInput'
+import { CombinedFuseInput, encodeFuses } from '../utils/fuses'
 import { namehash } from '../utils/normalise'
+import { Expiry, makeExpiry, wrappedLabelLengthCheck } from '../utils/wrapper'
 
 type BaseArgs = {
   owner: string
@@ -12,13 +13,18 @@ type BaseArgs = {
 
 type NameWrapperArgs = {
   contract: 'nameWrapper'
-  fuses?: FuseOptions
+  fuses?: CombinedFuseInput
+  expiry?: Expiry
 } & BaseArgs
 
 type Args = BaseArgs | NameWrapperArgs
 
 export default async function (
-  { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
+  {
+    contracts,
+    signer,
+    getExpiry,
+  }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>,
   name: string,
   { owner, resolverAddress, contract, ...wrapperArgs }: Args,
 ) {
@@ -37,12 +43,12 @@ export default async function (
   }
 
   const label = labels.shift() as string
-  const labelhash = ethers.utils.solidityKeccak256(['string'], [label])
+  const labelhash = solidityKeccak256(['string'], [label])
   const parentNodehash = namehash(labels.join('.'))
 
   switch (contract) {
     case 'registry': {
-      const registry = (await contracts?.getRegistry()!).connect(signer)
+      const registry = (await contracts!.getRegistry()!).connect(signer)
 
       return registry.populateTransaction.setSubnodeRecord(
         parentNodehash,
@@ -53,12 +59,18 @@ export default async function (
       )
     }
     case 'nameWrapper': {
-      const nameWrapper = (await contracts?.getNameWrapper()!).connect(signer)
+      wrappedLabelLengthCheck(label)
+      const nameWrapper = (await contracts!.getNameWrapper()!).connect(signer)
+      const expiry: BigNumber = await makeExpiry(
+        { getExpiry },
+        name,
+        'expiry' in wrapperArgs ? wrapperArgs.expiry : undefined,
+      )
 
       const generatedFuses =
         'fuses' in wrapperArgs && wrapperArgs.fuses
-          ? generateFuseInput(wrapperArgs.fuses)
-          : '0'
+          ? encodeFuses(wrapperArgs.fuses)
+          : 0
 
       return nameWrapper.populateTransaction.setSubnodeRecord(
         parentNodehash,
@@ -67,6 +79,7 @@ export default async function (
         resolverAddress,
         0,
         generatedFuses,
+        expiry,
       )
     }
     default: {

package/src/functions/deleteSubname.test.ts

@@ -3,16 +3,20 @@ import { ENS } from '..'
 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())
+  ;({ ensInstance, revert, provider } = await setup())
   accounts = await provider.listAccounts()
 })
 
+beforeEach(async () => {
+  await revert()
+})
+
 afterAll(async () => {
   await revert()
 })
@@ -21,52 +25,178 @@ describe('deleteSubname', () => {
   beforeEach(async () => {
     await revert()
   })
-  it('should allow deleting a subname on the registry', async () => {
-    const createSubnameTx = await ENSInstance.createSubname(
-      'test.parthtejpal.eth',
-      {
-        contract: 'registry',
-        owner: accounts[0],
-        addressOrIndex: 0,
-      },
-    )
-    await createSubnameTx.wait()
+  it('should allow deleting a subname on the registry by parent owner', async () => {
+    const registry = await ensInstance.contracts!.getRegistry()!
+    const parentOwner = await registry.owner(namehash('with-subnames.eth'))
 
-    const tx = await ENSInstance.deleteSubname('test.parthtejpal.eth', {
+    const tx = await ensInstance.deleteSubname('test.with-subnames.eth', {
       contract: 'registry',
-      addressOrIndex: 0,
+      addressOrIndex: parentOwner,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
 
-    const registry = await ENSInstance.contracts!.getRegistry()!
-    const result = await registry.owner(namehash('test.parthtejpal.eth'))
+    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', {
-      wrappedOwner: accounts[0],
-    })
-    await wrapNameTx.wait()
-    const createSubnameTx = await ENSInstance.createSubname(
-      'test.parthtejpal.eth',
+
+  it('should allow deleting a subname on the nameWrapper by parent owner', async () => {
+    const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+
+    const parentOwner = await nameWrapper.ownerOf(
+      namehash('wrapped-with-subnames.eth'),
+    )
+
+    const tx = await ensInstance.deleteSubname(
+      'test.wrapped-with-subnames.eth',
       {
         contract: 'nameWrapper',
-        owner: accounts[0],
-        addressOrIndex: 0,
+        method: 'setSubnodeOwner',
+        addressOrIndex: parentOwner,
       },
     )
-    await createSubnameTx.wait()
+    expect(tx).toBeTruthy()
+    await tx.wait()
 
-    const tx = await ENSInstance.deleteSubname('test.parthtejpal.eth', {
+    const result = await nameWrapper.ownerOf(
+      namehash('test.wrapped-with-subnames.eth'),
+    )
+    expect(result).toBe('0x0000000000000000000000000000000000000000')
+  })
+
+  it('should allow deleting a subname on the nameWrapper by name owner', async () => {
+    const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+
+    const nameOwner = await nameWrapper.ownerOf(
+      namehash('addr.wrapped-with-subnames.eth'),
+    )
+
+    await ensInstance.deleteSubname('addr.wrapped-with-subnames.eth', {
       contract: 'nameWrapper',
-      addressOrIndex: 0,
+      method: 'setRecord',
+      addressOrIndex: nameOwner,
+    })
+
+    const result = await nameWrapper.ownerOf(
+      namehash('addr.wrapped-with-subnames.eth'),
+    )
+    expect(result).toBe('0x0000000000000000000000000000000000000000')
+  })
+
+  it('should allow deleting a subname on the nameWrapper with PCC burned by name owner', async () => {
+    const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+
+    const parentOwner = await nameWrapper.ownerOf(
+      namehash('wrapped-with-subnames.eth'),
+    )
+
+    const tx0 = await ensInstance.setFuses('wrapped-with-subnames.eth', {
+      named: ['CANNOT_UNWRAP'],
+      addressOrIndex: parentOwner,
     })
+    expect(tx0).toBeTruthy()
+    await tx0.wait()
+
+    const tx1 = await ensInstance.setChildFuses(
+      'xyz.wrapped-with-subnames.eth',
+      {
+        fuses: {
+          parent: {
+            named: ['PARENT_CANNOT_CONTROL'],
+          },
+        },
+        addressOrIndex: parentOwner,
+      },
+    )
+    expect(tx1).toBeTruthy()
+    await tx1.wait()
+
+    const nameOwner = await nameWrapper.ownerOf(
+      namehash('xyz.wrapped-with-subnames.eth'),
+    )
+
+    expect(parentOwner === nameOwner).toBe(false)
+
+    const tx = await ensInstance.deleteSubname(
+      'xyz.wrapped-with-subnames.eth',
+      {
+        contract: 'nameWrapper',
+        method: 'setRecord',
+        addressOrIndex: nameOwner,
+      },
+    )
     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('xyz.wrapped-with-subnames.eth'),
+    )
     expect(result).toBe('0x0000000000000000000000000000000000000000')
   })
+
+  it('should NOT allow deleting a subname on the nameWrapper with PCC burned by parent owner', async () => {
+    const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
+
+    const parentOwner = await nameWrapper.ownerOf(
+      namehash('wrapped-with-subnames.eth'),
+    )
+
+    const tx0 = await ensInstance.setFuses('wrapped-with-subnames.eth', {
+      named: ['CANNOT_UNWRAP'],
+      addressOrIndex: parentOwner,
+    })
+    expect(tx0).toBeTruthy()
+    await tx0.wait()
+
+    const tx1 = await ensInstance.setChildFuses(
+      'legacy.wrapped-with-subnames.eth',
+      {
+        fuses: {
+          parent: {
+            named: ['PARENT_CANNOT_CONTROL'],
+          },
+        },
+        addressOrIndex: parentOwner,
+      },
+    )
+    expect(tx1).toBeTruthy()
+    await tx1.wait()
+
+    const checkOwner = await nameWrapper.ownerOf(
+      namehash('legacy.wrapped-with-subnames.eth'),
+    )
+    expect(checkOwner).toBe(accounts[2])
+
+    await expect(
+      ensInstance.deleteSubname('legacy.wrapped-with-subnames.eth', {
+        contract: 'nameWrapper',
+        method: 'setSubnodeOwner',
+        addressOrIndex: parentOwner,
+      }),
+    ).rejects.toThrow()
+
+    const result = await nameWrapper.ownerOf(
+      namehash('legacy.wrapped-with-subnames.eth'),
+    )
+    expect(result).toBe(accounts[2])
+  })
+
+  it('should not allow deleting 1LD', async () => {
+    await expect(
+      ensInstance.deleteSubname('eth', {
+        contract: 'nameWrapper',
+        method: 'setRecord',
+        addressOrIndex: 1,
+      }),
+    ).rejects.toThrow()
+  })
+
+  it('should not allow deleting 2LD', async () => {
+    await expect(
+      ensInstance.deleteSubname('test123.eth', {
+        contract: 'registry',
+        addressOrIndex: 1,
+      }),
+    ).rejects.toThrow()
+  })
 })