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

package/src/functions/setRecord.test.ts

@@ -0,0 +1,315 @@
+import { formatsByName } from '@ensdomains/address-encoder'
+import { decodeFirst } from 'cbor'
+import { BigNumber } from 'ethers'
+import { arrayify, toUtf8String } from 'ethers/lib/utils'
+import { inflate } from 'pako'
+import { ENS } from '..'
+import setup from '../tests/setup'
+import { decodeContenthash } from '../utils/contentHash'
+import { hexEncodeName } from '../utils/hexEncodedName'
+import { namehash } from '../utils/normalise'
+import { generateABIInput } from '../utils/recordHelpers'
+
+let ensInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
+
+beforeAll(async () => {
+  ;({ ensInstance, revert } = await setup())
+})
+
+afterEach(async () => {
+  await revert()
+})
+
+const dummyABI = [
+  {
+    type: 'function',
+    name: 'supportsInterface',
+    constant: true,
+    stateMutability: 'view',
+    payable: false,
+    inputs: [
+      {
+        type: 'bytes4',
+      },
+    ],
+    outputs: [
+      {
+        type: 'bool',
+      },
+    ],
+  },
+]
+
+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(bytes,bytes)'](
+      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_LEGACY',
+        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(bytes,bytes)'](
+      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 an empty address record to be set', async () => {
+    const setRecord = await ensInstance.setRecord('test123.eth', {
+      type: 'addr',
+      record: {
+        key: 'BNB',
+        value: 'bnb1rrhqmj4fa28vlrnm89f6gjsgz3ya6h40ptckj0',
+      },
+      addressOrIndex: 1,
+    })
+    await setRecord.wait()
+
+    const universalResolver =
+      await ensInstance.contracts!.getUniversalResolver()!
+    const publicResolver = await ensInstance.contracts!.getPublicResolver()!
+    const getEncodedAddr = () =>
+      universalResolver['resolve(bytes,bytes)'](
+        hexEncodeName('test123.eth'),
+        publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [
+          namehash('test123.eth'),
+          '714',
+        ]),
+      )
+    const encodedAddr = await getEncodedAddr()
+    const [resultAddr] = publicResolver.interface.decodeFunctionResult(
+      'addr(bytes32,uint256)',
+      encodedAddr[0],
+    )
+    // record as hex
+    expect(resultAddr).toBe('0x18ee0dcaa9ea8ecf8e7b3953a44a081449dd5eaf')
+
+    const tx = await ensInstance.setRecord('test123.eth', {
+      type: 'addr',
+      record: {
+        key: 'BNB',
+        value: '',
+      },
+      addressOrIndex: 1,
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const encodedEmptyAddr = await getEncodedAddr()
+    const [resultEmptyAddr] = publicResolver.interface.decodeFunctionResult(
+      'addr(bytes32,uint256)',
+      encodedEmptyAddr[0],
+    )
+    // record as hex
+    expect(resultEmptyAddr).toBe('0x')
+  })
+
+  Object.keys(formatsByName).forEach((coinName) => {
+    it(`should allow an empty address record for ${coinName}`, async () => {
+      const tx = await ensInstance.setRecord('test123.eth', {
+        type: 'addr',
+        record: {
+          key: coinName,
+          value: '',
+        },
+        addressOrIndex: 1,
+      })
+      expect(tx).toBeTruthy()
+      await tx.wait()
+    })
+  })
+
+  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(bytes,bytes)'](
+      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')
+  })
+  it('should allow an abi record to be set from an object', async () => {
+    const tx = await ensInstance.setRecord('test123.eth', {
+      type: 'abi',
+      record: {
+        data: dummyABI,
+      },
+      addressOrIndex: 1,
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const universalResolver =
+      await ensInstance.contracts!.getUniversalResolver()!
+    const publicResolver = await ensInstance.contracts!.getPublicResolver()!
+    const encodedRes = await universalResolver['resolve(bytes,bytes)'](
+      hexEncodeName('test123.eth'),
+      publicResolver.interface.encodeFunctionData('ABI', [
+        namehash('test123.eth'),
+        '0x0f',
+      ]),
+    )
+    const [contentType, encodedABI] =
+      publicResolver.interface.decodeFunctionResult('ABI', encodedRes[0]) as [
+        BigNumber,
+        string,
+      ]
+
+    expect(contentType.toNumber()).toBe(1)
+    expect(toUtf8String(encodedABI)).toBe(JSON.stringify(dummyABI))
+  })
+  it('should allow a zlib encoded abi record to be set', async () => {
+    const encodedInput = await generateABIInput('zlib', dummyABI)
+    const tx = await ensInstance.setRecord('test123.eth', {
+      type: 'abi',
+      record: encodedInput,
+      addressOrIndex: 1,
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const universalResolver =
+      await ensInstance.contracts!.getUniversalResolver()!
+    const publicResolver = await ensInstance.contracts!.getPublicResolver()!
+    const encodedRes = await universalResolver['resolve(bytes,bytes)'](
+      hexEncodeName('test123.eth'),
+      publicResolver.interface.encodeFunctionData('ABI', [
+        namehash('test123.eth'),
+        '0x0f',
+      ]),
+    )
+    const [contentType, encodedABI] =
+      publicResolver.interface.decodeFunctionResult('ABI', encodedRes[0]) as [
+        BigNumber,
+        string,
+      ]
+
+    expect(contentType.toNumber()).toBe(2)
+    expect(inflate(arrayify(encodedABI), { to: 'string' })).toBe(
+      JSON.stringify(dummyABI),
+    )
+  })
+  it('should allow a cbor encoded abi record to be set', async () => {
+    const encodedInput = await generateABIInput('cbor', dummyABI)
+    const tx = await ensInstance.setRecord('test123.eth', {
+      type: 'abi',
+      record: encodedInput,
+      addressOrIndex: 1,
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const universalResolver =
+      await ensInstance.contracts!.getUniversalResolver()!
+    const publicResolver = await ensInstance.contracts!.getPublicResolver()!
+    const encodedRes = await universalResolver['resolve(bytes,bytes)'](
+      hexEncodeName('test123.eth'),
+      publicResolver.interface.encodeFunctionData('ABI', [
+        namehash('test123.eth'),
+        '0x0f',
+      ]),
+    )
+    const [contentType, encodedABI] =
+      publicResolver.interface.decodeFunctionResult('ABI', encodedRes[0]) as [
+        BigNumber,
+        string,
+      ]
+
+    expect(contentType.toNumber()).toBe(4)
+    expect(JSON.stringify(await decodeFirst(arrayify(encodedABI)))).toBe(
+      JSON.stringify(dummyABI),
+    )
+  })
+  it('should allow a uri abi record to be set', async () => {
+    const encodedInput = await generateABIInput('uri', 'https://example.com')
+    const tx = await ensInstance.setRecord('test123.eth', {
+      type: 'abi',
+      record: encodedInput,
+      addressOrIndex: 1,
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const universalResolver =
+      await ensInstance.contracts!.getUniversalResolver()!
+    const publicResolver = await ensInstance.contracts!.getPublicResolver()!
+    const encodedRes = await universalResolver['resolve(bytes,bytes)'](
+      hexEncodeName('test123.eth'),
+      publicResolver.interface.encodeFunctionData('ABI', [
+        namehash('test123.eth'),
+        '0x0f',
+      ]),
+    )
+    const [contentType, encodedABI] =
+      publicResolver.interface.decodeFunctionResult('ABI', encodedRes[0]) as [
+        BigNumber,
+        string,
+      ]
+
+    expect(contentType.toNumber()).toBe(8)
+    expect(toUtf8String(encodedABI)).toBe('https://example.com')
+  })
+})

package/src/functions/setRecord.ts

@@ -0,0 +1,64 @@
+import { ENSArgs } from '..'
+import { namehash } from '../utils/normalise'
+import { generateSingleRecordCall, RecordInput } from '../utils/recordHelpers'
+
+type BaseInput = {
+  resolverAddress?: string
+}
+
+type ContentHashInput = {
+  record: RecordInput<'contentHash'>
+  type: 'contentHash'
+}
+
+type AddrOrTextInput = {
+  record: RecordInput<'addr' | 'text'>
+  type: 'addr' | 'text'
+}
+
+type ABIInput = {
+  record: RecordInput<'abi'>
+  type: 'abi'
+}
+
+export default async function (
+  {
+    contracts,
+    provider,
+    getResolver,
+    signer,
+  }: ENSArgs<'contracts' | 'provider' | 'getResolver' | 'signer'>,
+  name: string,
+  {
+    record,
+    type,
+    resolverAddress,
+  }: BaseInput & (ContentHashInput | AddrOrTextInput | ABIInput),
+) {
+  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/functions/setRecords.test.ts

@@ -1,13 +1,34 @@
+import { toUtf8String } from 'ethers/lib/utils'
 import { ENS } from '..'
 import setup from '../tests/setup'
 import { hexEncodeName } from '../utils/hexEncodedName'
 import { namehash } from '../utils/normalise'
 
-let ENSInstance: ENS
+const dummyABI = [
+  {
+    type: 'function',
+    name: 'supportsInterface',
+    constant: true,
+    stateMutability: 'view',
+    payable: false,
+    inputs: [
+      {
+        type: 'bytes4',
+      },
+    ],
+    outputs: [
+      {
+        type: 'bool',
+      },
+    ],
+  },
+]
+
+let ensInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
 
 beforeAll(async () => {
-  ;({ ENSInstance, revert } = await setup())
+  ;({ ensInstance, revert } = await setup())
 })
 
 afterAll(async () => {
@@ -16,36 +37,43 @@ afterAll(async () => {
 
 describe('setRecords', () => {
   it('should return a transaction to the resolver and set successfully', async () => {
-    const tx = await ENSInstance.setRecords('parthtejpal.eth', {
+    const tx = await ensInstance.setRecords('test123.eth', {
       records: {
         coinTypes: [
-          { key: 'ETC', value: '0x42D63ae25990889E35F215bC95884039Ba354115' },
+          {
+            key: 'ETC_LEGACY',
+            value: '0x42D63ae25990889E35F215bC95884039Ba354115',
+          },
         ],
         texts: [{ key: 'foo', value: 'bar' }],
+        abi: {
+          data: dummyABI,
+        },
       },
+      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('parthtejpal.eth'),
-      publicResolver.interface.encodeFunctionData('text(bytes32,string)', [
-        namehash('parthtejpal.eth'),
+      await ensInstance.contracts!.getUniversalResolver()!
+    const publicResolver = await ensInstance.contracts!.getPublicResolver()!
+    const encodedText = await universalResolver['resolve(bytes,bytes)'](
+      hexEncodeName('test123.eth'),
+      publicResolver.interface.encodeFunctionData('text', [
+        namehash('test123.eth'),
         'foo',
       ]),
     )
-    const encodedAddr = await universalResolver.resolve(
-      hexEncodeName('parthtejpal.eth'),
+    const encodedAddr = await universalResolver['resolve(bytes,bytes)'](
+      hexEncodeName('test123.eth'),
       publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [
-        namehash('parthtejpal.eth'),
+        namehash('test123.eth'),
         '61',
       ]),
     )
     const [resultText] = publicResolver.interface.decodeFunctionResult(
-      'text(bytes32,string)',
+      'text',
       encodedText[0],
     )
     const [resultAddr] = publicResolver.interface.decodeFunctionResult(
@@ -56,5 +84,133 @@ describe('setRecords', () => {
     expect(resultAddr).toBe(
       '0x42D63ae25990889E35F215bC95884039Ba354115'.toLowerCase(),
     )
+
+    const encodedABI = await universalResolver['resolve(bytes,bytes)'](
+      hexEncodeName('test123.eth'),
+      publicResolver.interface.encodeFunctionData('ABI', [
+        namehash('test123.eth'),
+        '0x01',
+      ]),
+    )
+    const [contentType, resultABI] =
+      publicResolver.interface.decodeFunctionResult('ABI', encodedABI[0])
+    expect(contentType.toNumber()).toBe(1)
+    expect(toUtf8String(resultABI)).toBe(JSON.stringify(dummyABI))
+  })
+
+  describe('record types', () => {
+    it('should be able to set and delete a cointype for a wrapped name', async () => {
+      const tx = await ensInstance.setRecords('wrapped.eth', {
+        records: {
+          coinTypes: [
+            {
+              key: 'ETH',
+              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(bytes,bytes)'](
+        hexEncodeName('wrapped.eth'),
+        publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [
+          namehash('wrapped.eth'),
+          '60',
+        ]),
+      )
+      const [resultAddr] = publicResolver.interface.decodeFunctionResult(
+        'addr(bytes32,uint256)',
+        encodedAddr[0],
+      )
+      expect(resultAddr).toBe(
+        '0x42D63ae25990889E35F215bC95884039Ba354115'.toLowerCase(),
+      )
+
+      const tx2 = await ensInstance.setRecords('wrapped.eth', {
+        records: {
+          coinTypes: [
+            {
+              key: 'ETH',
+              value: '',
+            },
+          ],
+        },
+        addressOrIndex: 1,
+      })
+      expect(tx2).toBeTruthy()
+      await tx2.wait()
+
+      const encodedAddr2 = await universalResolver['resolve(bytes,bytes)'](
+        hexEncodeName('wrapped.eth'),
+        publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [
+          namehash('wrapped.eth'),
+          '60',
+        ]),
+      )
+      const [resultAddr2] = publicResolver.interface.decodeFunctionResult(
+        'addr(bytes32,uint256)',
+        encodedAddr2[0],
+      )
+      expect(resultAddr2).toBe(
+        '0x0000000000000000000000000000000000000000'.toLowerCase(),
+      )
+    })
+
+    it('should be able to set and delete a contenthash for a wrapped name', async () => {
+      const tx = await ensInstance.setRecords('wrapped.eth', {
+        records: {
+          contentHash: 'ipfs://QmRAQB6YaCyidP37UdDnjFY5vQuiBrcqdyoW1CuDgwxkD4',
+        },
+        addressOrIndex: 1,
+      })
+      expect(tx).toBeTruthy()
+      await tx.wait()
+
+      const universalResolver =
+        await ensInstance.contracts!.getUniversalResolver()!
+      const publicResolver = await ensInstance.contracts!.getPublicResolver()!
+
+      const encodedData = await universalResolver['resolve(bytes,bytes)'](
+        hexEncodeName('wrapped.eth'),
+        publicResolver.interface.encodeFunctionData('contenthash', [
+          namehash('wrapped.eth'),
+        ]),
+      )
+      const [resultData] = publicResolver.interface.decodeFunctionResult(
+        'contenthash',
+        encodedData[0],
+      )
+      expect(resultData).toBe(
+        '0xe3010170122029f2d17be6139079dc48696d1f582a8530eb9805b561eda517e22a892c7e3f1f'.toLowerCase(),
+      )
+
+      const tx2 = await ensInstance.setRecords('wrapped.eth', {
+        records: {
+          contentHash: '',
+        },
+        addressOrIndex: 1,
+      })
+      expect(tx2).toBeTruthy()
+      await tx2.wait()
+
+      const encodedAddr2 = await universalResolver['resolve(bytes,bytes)'](
+        hexEncodeName('wrapped.eth'),
+        publicResolver.interface.encodeFunctionData('contenthash', [
+          namehash('wrapped.eth'),
+        ]),
+      )
+      const [resultAddr2] = publicResolver.interface.decodeFunctionResult(
+        'contenthash',
+        encodedAddr2[0],
+      )
+      expect(resultAddr2).toBe('0x'.toLowerCase())
+    })
   })
 })

package/src/functions/setResolver.test.ts

@@ -1,14 +1,12 @@
-import { ethers } from 'ethers'
 import { ENS } from '..'
 import setup from '../tests/setup'
 import { hexEncodeName } from '../utils/hexEncodedName'
 
-let ENSInstance: ENS
+let ensInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
-let provider: ethers.providers.JsonRpcProvider
 
 beforeAll(async () => {
-  ;({ ENSInstance, revert, provider } = await setup())
+  ;({ ensInstance, revert } = await setup())
 })
 
 afterAll(async () => {
@@ -20,37 +18,34 @@ describe('setResolver', () => {
     await revert()
   })
   it('should return a transaction to the registry and set successfully', async () => {
-    const tx = await ENSInstance.setResolver('parthtejpal.eth', {
+    const tx = await ensInstance.setResolver('test123.eth', {
       contract: 'registry',
       resolver: '0xAEfF4f4d8e2cB51854BEa2244B3C5Fb36b41C7fC',
+      addressOrIndex: 1,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
 
     const universalResolver =
-      await ENSInstance.contracts!.getUniversalResolver()!
+      await ensInstance.contracts!.getUniversalResolver()!
     const [result] = await universalResolver.findResolver(
-      hexEncodeName('parthtejpal.eth'),
+      hexEncodeName('test123.eth'),
     )
     expect(result).toBe('0xAEfF4f4d8e2cB51854BEa2244B3C5Fb36b41C7fC')
   })
   it('should return a transaction to the namewrapper and set successfully', async () => {
-    const accounts = await provider.listAccounts()
-    const wrapNameTx = await ENSInstance.wrapName('parthtejpal.eth', {
-      wrappedOwner: accounts[0],
-    })
-    await wrapNameTx.wait()
-    const tx = await ENSInstance.setResolver('parthtejpal.eth', {
+    const tx = await ensInstance.setResolver('wrapped.eth', {
       contract: 'nameWrapper',
       resolver: '0xAEfF4f4d8e2cB51854BEa2244B3C5Fb36b41C7fC',
+      addressOrIndex: 1,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
 
     const universalResolver =
-      await ENSInstance.contracts!.getUniversalResolver()!
+      await ensInstance.contracts!.getUniversalResolver()!
     const [result] = await universalResolver.findResolver(
-      hexEncodeName('parthtejpal.eth'),
+      hexEncodeName('wrapped.eth'),
     )
     expect(result).toBe('0xAEfF4f4d8e2cB51854BEa2244B3C5Fb36b41C7fC')
   })

package/src/functions/setResolver.ts

@@ -13,7 +13,7 @@ export default async function (
   },
 ) {
   if (!resolver) {
-    resolver = (await contracts?.getPublicResolver()!).address
+    resolver = (await contracts!.getPublicResolver()!).address
   }
 
   switch (contract) {