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

package/src/functions/getSpecificRecord.test.ts

@@ -1,24 +1,143 @@
 import { ENS } from '..'
 import setup from '../tests/setup'
 
-let ENSInstance: ENS
+let ensInstance: ENS
 
 beforeAll(async () => {
-  ;({ ENSInstance } = await setup())
+  ;({ ensInstance } = await setup())
 })
 
+const dummyABI = [
+  {
+    type: 'event',
+    anonymous: false,
+    name: 'ABIChanged',
+    inputs: [
+      {
+        type: 'bytes32',
+        indexed: true,
+      },
+      {
+        type: 'uint256',
+        indexed: true,
+      },
+    ],
+  },
+  {
+    type: 'event',
+    anonymous: false,
+    name: 'VersionChanged',
+    inputs: [
+      {
+        type: 'bytes32',
+        indexed: true,
+      },
+      {
+        type: 'uint64',
+      },
+    ],
+  },
+  {
+    type: 'function',
+    name: 'ABI',
+    constant: true,
+    stateMutability: 'view',
+    payable: false,
+    inputs: [
+      {
+        type: 'bytes32',
+      },
+      {
+        type: 'uint256',
+      },
+    ],
+    outputs: [
+      {
+        type: 'uint256',
+      },
+      {
+        type: 'bytes',
+      },
+    ],
+  },
+  {
+    type: 'function',
+    name: 'clearRecords',
+    constant: false,
+    payable: false,
+    inputs: [
+      {
+        type: 'bytes32',
+      },
+    ],
+    outputs: [],
+  },
+  {
+    type: 'function',
+    name: 'recordVersions',
+    constant: true,
+    stateMutability: 'view',
+    payable: false,
+    inputs: [
+      {
+        type: 'bytes32',
+      },
+    ],
+    outputs: [
+      {
+        type: 'uint64',
+      },
+    ],
+  },
+  {
+    type: 'function',
+    name: 'setABI',
+    constant: false,
+    payable: false,
+    inputs: [
+      {
+        type: 'bytes32',
+      },
+      {
+        type: 'uint256',
+      },
+      {
+        type: 'bytes',
+      },
+    ],
+    outputs: [],
+  },
+  {
+    type: 'function',
+    name: 'supportsInterface',
+    constant: true,
+    stateMutability: 'view',
+    payable: false,
+    inputs: [
+      {
+        type: 'bytes4',
+      },
+    ],
+    outputs: [
+      {
+        type: 'bool',
+      },
+    ],
+  },
+]
+
 describe('getSpecificRecord', () => {
   describe('getContentHash', () => {
     it('should return null for a non-existent name', async () => {
-      const result = await ENSInstance.getContentHash('test123123cool.eth')
+      const result = await ensInstance.getContentHash('test123123cool.eth')
       expect(result).toBeUndefined()
     })
     it('should return null for a name with no contenthash record', async () => {
-      const result = await ENSInstance.getContentHash('jefflau.eth')
+      const result = await ensInstance.getContentHash('with-profile.eth')
       expect(result).toBeUndefined()
     })
     it('should return the contenthash for a name with the record set', async () => {
-      const result = await ENSInstance.getContentHash('matoken.eth')
+      const result = await ensInstance.getContentHash('with-contenthash.eth')
       expect(result).toMatchObject({
         protocolType: 'ipfs',
         decoded: 'bafybeico3uuyj3vphxpvbowchdwjlrlrh62awxscrnii7w7flu5z6fk77y',
@@ -29,13 +148,16 @@ describe('getSpecificRecord', () => {
 
   describe('getText', () => {
     it('should return a record from a key', async () => {
-      const result = await ENSInstance.getText('jefflau.eth', 'description')
+      const result = await ensInstance.getText(
+        'with-profile.eth',
+        'description',
+      )
       expect(result).toBe('Hello2')
     })
 
     it('should return null for a non-existent key', async () => {
-      const result = await ENSInstance.getText(
-        'jefflau.eth',
+      const result = await ensInstance.getText(
+        'with-profile.eth',
         'thiskeydoesntexist',
       )
       expect(result).toBeUndefined()
@@ -44,32 +166,75 @@ describe('getSpecificRecord', () => {
 
   describe('getAddr', () => {
     it('should return the ETH addr record if no coinType is provided', async () => {
-      const result = await ENSInstance.getAddr('jefflau.eth')
-      expect(result).toBe('0x866B3c4994e1416B7C738B9818b31dC246b95eEE')
+      const result = await ensInstance.getAddr('with-profile.eth')
+      expect(result).toBe('0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC')
     })
     it('should return the correct address based on a coin ID input as a number', async () => {
-      const result = await ENSInstance.getAddr('jefflau.eth', 61)
+      const result = await ensInstance.getAddr('with-profile.eth', 61)
       expect((result as any).addr).toBe(
-        '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+        '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       )
-      expect((result as any).coin).toBe('ETC')
+      expect((result as any).coin).toBe('ETC_LEGACY')
     })
     it('should return the correct address based on a coin ID input as a string', async () => {
-      const result = await ENSInstance.getAddr('jefflau.eth', '61')
+      const result = await ensInstance.getAddr('with-profile.eth', '61')
       expect((result as any).addr).toBe(
-        '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+        '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       )
-      expect((result as any).coin).toBe('ETC')
+      expect((result as any).coin).toBe('ETC_LEGACY')
     })
     it('should return the correct address based on a coin name', async () => {
-      const result = await ENSInstance.getAddr('jefflau.eth', 'ETC')
+      const result = await ensInstance.getAddr('with-profile.eth', 'ETC_LEGACY')
       expect((result as any).addr).toBe(
-        '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+        '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       )
-      expect((result as any).coin).toBe('ETC')
+      expect((result as any).coin).toBe('ETC_LEGACY')
     })
     it('should return null for a non-existent coin', async () => {
-      const result = await ENSInstance.getAddr('jefflau.eth', 'BNB')
+      const result = await ensInstance.getAddr('with-profile.eth', 'BNB')
+      expect(result).toBeUndefined()
+    })
+  })
+
+  describe('getABI', () => {
+    it('should return object for type 1 ABI', async () => {
+      const result = await ensInstance.getABI('with-type-1-abi.eth')
+      expect(result).toBeTruthy()
+      if (result) {
+        expect(result.contentType).toBe(1)
+        expect(result.decoded).toBe(true)
+        expect(result.abi).toMatchObject(dummyABI)
+      }
+    })
+    it('should return object for type 2 ABI', async () => {
+      const result = await ensInstance.getABI('with-type-2-abi.eth')
+      expect(result).toBeTruthy()
+      if (result) {
+        expect(result.contentType).toBe(2)
+        expect(result.decoded).toBe(true)
+        expect(result.abi).toMatchObject(dummyABI)
+      }
+    })
+    it('should return object for type 4 ABI', async () => {
+      const result = await ensInstance.getABI('with-type-4-abi.eth')
+      expect(result).toBeTruthy()
+      if (result) {
+        expect(result.contentType).toBe(4)
+        expect(result.decoded).toBe(true)
+        expect(result.abi).toMatchObject(dummyABI)
+      }
+    })
+    it('should return unresolved URI for type 8 ABI', async () => {
+      const result = await ensInstance.getABI('with-type-8-abi.eth')
+      expect(result).toBeTruthy()
+      if (result) {
+        expect(result.contentType).toBe(8)
+        expect(result.decoded).toBe(false)
+        expect(result.abi).toBe('https://example.com')
+      }
+    })
+    it('should return undefined if unsupported contentType', async () => {
+      const result = await ensInstance.getABI('with-type-256-abi.eth')
       expect(result).toBeUndefined()
     })
   })

package/src/functions/getSpecificRecord.ts

@@ -1,5 +1,7 @@
 import { formatsByCoinType, formatsByName } from '@ensdomains/address-encoder'
-import { ethers } from 'ethers'
+import { BigNumber } from '@ethersproject/bignumber'
+import { arrayify, hexStripZeros, isBytesLike } from '@ethersproject/bytes'
+import { toUtf8String } from '@ethersproject/strings'
 import { ENSArgs } from '..'
 import { decodeContenthash } from '../utils/contentHash'
 import { namehash } from '../utils/normalise'
@@ -15,11 +17,17 @@ export const _getContentHash = {
     }
   },
   decode: async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
+    let response: any
     const publicResolver = await contracts?.getPublicResolver()!
-    const [response] = publicResolver.interface.decodeFunctionResult(
-      'contenthash',
-      data,
-    )
+    try {
+      ;[response] = publicResolver.interface.decodeFunctionResult(
+        'contenthash',
+        data,
+      )
+    } catch {
+      return
+    }
+
     if (!response) {
       return
     }
@@ -28,8 +36,8 @@ export const _getContentHash = {
 
     if (
       !decodedContent ||
-      (ethers.utils.isBytesLike(decodedContent.decoded) &&
-        ethers.utils.hexStripZeros(decodedContent.decoded) === '0x') ||
+      (isBytesLike(decodedContent.decoded) &&
+        hexStripZeros(decodedContent.decoded) === '0x') ||
       Object.keys(decodedContent).length === 0
     ) {
       return
@@ -45,7 +53,7 @@ export const getContentHash = {
     name: string,
   ) => {
     const prData = await _getContentHash.raw({ contracts }, name)
-    return await universalWrapper.raw(name, prData.data)
+    return universalWrapper.raw(name, prData.data)
   },
   decode: async (
     { contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>,
@@ -53,7 +61,7 @@ export const getContentHash = {
   ) => {
     const urData = await universalWrapper.decode(data)
     if (!urData) return
-    return await _getContentHash.decode({ contracts }, urData.data)
+    return _getContentHash.decode({ contracts }, urData.data)
   },
 }
 
@@ -81,7 +89,7 @@ export const _getText = {
     if (!response) {
       return
     }
-    return response
+    return response as string
   },
 }
 
@@ -92,7 +100,7 @@ export const getText = {
     key: string,
   ) => {
     const prData = await _getText.raw({ contracts }, name, key)
-    return await universalWrapper.raw(name, prData.data)
+    return universalWrapper.raw(name, prData.data)
   },
   decode: async (
     { contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>,
@@ -100,7 +108,7 @@ export const getText = {
   ) => {
     const urData = await universalWrapper.decode(data)
     if (!urData) return
-    return await _getText.decode({ contracts }, urData.data)
+    return _getText.decode({ contracts }, urData.data)
   },
 }
 
@@ -136,7 +144,7 @@ export const _getAddr = {
       }
     }
     const formatter =
-      typeof coinType === 'string' && isNaN(parseInt(coinType))
+      typeof coinType === 'string' && Number.isNaN(parseInt(coinType))
         ? formatsByName[coinType]
         : formatsByCoinType[
             typeof coinType === 'number' ? coinType : parseInt(coinType)
@@ -168,7 +176,7 @@ export const _getAddr = {
 
     const publicResolver = await contracts?.getPublicResolver()!
     const formatter =
-      typeof coinType === 'string' && isNaN(parseInt(coinType))
+      typeof coinType === 'string' && Number.isNaN(parseInt(coinType))
         ? formatsByName[coinType]
         : formatsByCoinType[
             typeof coinType === 'number' ? coinType : parseInt(coinType)
@@ -190,7 +198,7 @@ export const _getAddr = {
 
     if (!response) return
 
-    if (ethers.utils.hexStripZeros(response) === '0x') {
+    if (hexStripZeros(response) === '0x') {
       return
     }
 
@@ -215,7 +223,7 @@ export const getAddr = {
     coinType?: string | number,
   ) => {
     const prData = await _getAddr.raw({ contracts }, name, coinType)
-    return await universalWrapper.raw(name, prData.data)
+    return universalWrapper.raw(name, prData.data)
   },
   decode: async (
     { contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>,
@@ -225,141 +233,98 @@ export const getAddr = {
   ) => {
     const urData = await universalWrapper.decode(data)
     if (!urData) return
-    return await _getAddr.decode({ contracts }, urData.data, _name, coinType)
+    return _getAddr.decode({ contracts }, urData.data, _name, coinType)
   },
 }
 
-// export async function getAddr(
-//   { contracts }: ENSArgs<'contracts'>,
-//   name: string,
-//   coinType?: string | number,
-// ) {
-//   if (!coinType) {
-//     coinType = 60
-//   }
-
-//   const universalResolver = await contracts?.getUniversalResolver()
-//   const publicResolver = await contracts?.getPublicResolver()
-//   const formatter =
-//     typeof coinType === 'string'
-//       ? formatsByName[coinType]
-//       : formatsByCoinType[coinType]
-
-//   if (!formatter) {
-//     throw new Error(`Coin type ${coinType} is not supported`)
-//   }
-
-//   const data = publicResolver?.interface.encodeFunctionData(
-//     'addr(bytes32,uint256)',
-//     [ethers.utils.namehash(name), formatter.coinType],
-//   )
-//   const result = await universalResolver?.resolve(hexEncodeName(name), data)
-
-//   const [encodedAddr] = ethers.utils.defaultAbiCoder.decode(
-//     ['bytes'],
-//     result['0'],
-//   )
-
-//   if (ethers.utils.hexStripZeros(encodedAddr) === '0x') {
-//     return
-//   }
-
-//   const decodedAddr = formatter.encoder(
-//     Buffer.from(encodedAddr.slice(2), 'hex'),
-//   )
-
-//   if (!decodedAddr) {
-//     return
-//   }
+// Supported content types as bitwise OR
+// ID 1: JSON
+// ID 2: zlib compressed JSON
+// ID 4: CBOR
+// ID 8: URI
+const supportedContentTypes = '0xf'
 
-//   return decodedAddr
-// }
-
-// export const getContentHash = {
-//   raw: async ({ contracts }: ENSArgs<'contracts'>, name: string) => {
-//     const universalResolver = await contracts?.getUniversalResolver()!
-//     const publicResolver = await contracts?.getPublicResolver()!
-//     const prData = publicResolver.interface.encodeFunctionData(
-//       'contenthash(bytes32)',
-//       [ethers.utils.namehash(name)],
-//     )
-//     const urData = universalResolver.interface.encodeFunctionData(
-//       'resolve(bytes,bytes)',
-//       [hexEncodeName(name), prData],
-//     )
-
-//     return {
-//       to: universalResolver.address,
-//       data: urData,
-//     }
-//   },
-//   decode: async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
-//     const universalResolver = await contracts?.getUniversalResolver()!
-//     const publicResolver = await contracts?.getPublicResolver()!
-//     const response = universalResolver.interface.decodeFunctionResult(
-//       'resolve(bytes,bytes)',
-//       data,
-//     )
-
-//     if (!response || !response[1]) {
-//       return
-//     }
-
-//     const [encodedContentHash] = publicResolver.interface.decodeFunctionResult(
-//       'contenthash(bytes32)',
-//       response[0],
-//     )
-
-//     if (ethers.utils.hexStripZeros(encodedContentHash) === '0x') {
-//       return
-//     }
-
-//     return decodeContenthash(encodedContentHash)
-//   },
-// }
-
-// const getText = {
-//   raw: async (
-//     { contracts }: ENSArgs<'contracts'>,
-//     name: string,
-//     key: string,
-//   ) => {
-//     const universalResolver = await contracts?.getUniversalResolver()!
-//     const publicResolver = await contracts?.getPublicResolver()!
-//     const data = publicResolver.interface.encodeFunctionData(
-//       'text(bytes32,string)',
-//       [ethers.utils.namehash(name), key],
-//     )
-
-//     return {
-//       to: universalResolver.address,
-//       data: universalResolver.interface.encodeFunctionData(
-//         'resolve(bytes,bytes)',
-//         [hexEncodeName(name), data],
-//       ),
-//     }
-//   },
-//   decode: async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
-//     const universalResolver = await contracts?.getUniversalResolver()!
-//     const publicResolver = await contracts?.getPublicResolver()!
-//     const response = universalResolver.interface.decodeFunctionResult(
-//       'resolve(bytes,bytes)',
-//       data,
-//     )
-
-//     if (!response || !response[1]) {
-//       return
-//     }
-
-//     const [decodedText] = publicResolver.interface.decodeFunctionResult(
-//       'text(bytes32,string)',
-//       response[0],
-//     )
-
-//     if (decodedText === '') {
-//       return
-//     }
+export const _getABI = {
+  raw: async ({ contracts }: ENSArgs<'contracts'>, name: string) => {
+    const publicResolver = await contracts?.getPublicResolver()!
+    return {
+      to: '0x0000000000000000000000000000000000000000',
+      data: publicResolver.interface.encodeFunctionData('ABI', [
+        namehash(name),
+        supportedContentTypes,
+      ]),
+    }
+  },
+  decode: async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
+    const publicResolver = await contracts?.getPublicResolver()!
+    const [bnContentType, encodedABIData] =
+      publicResolver.interface.decodeFunctionResult('ABI', data)
+    if (!bnContentType || !data) {
+      return
+    }
+    const contentType = (bnContentType as BigNumber).toNumber()
+    if (!contentType) {
+      return
+    }
+    let abiData: string | object
+    let decoded = false
+    switch (contentType) {
+      // JSON
+      case 1:
+        abiData = JSON.parse(toUtf8String(encodedABIData))
+        decoded = true
+        break
+      // zlib compressed JSON
+      case 2: {
+        const { inflate } = await import('pako/dist/pako_inflate.min.js')
+        abiData = JSON.parse(
+          inflate(arrayify(encodedABIData), { to: 'string' }),
+        )
+        decoded = true
+        break
+      }
+      // CBOR
+      case 4: {
+        const { decodeFirst } = await import('cbor')
+        abiData = await decodeFirst(arrayify(encodedABIData))
+        decoded = true
+        break
+      }
+      // URI
+      case 8:
+        abiData = toUtf8String(encodedABIData)
+        decoded = false
+        break
+      default:
+        try {
+          abiData = toUtf8String(encodedABIData)
+        } catch {
+          abiData = encodedABIData
+        }
+        decoded = false
+    }
+    return {
+      contentType,
+      decoded,
+      abi: abiData,
+    }
+  },
+}
 
-//     return decodedText
-//   },
-// }
+export const getABI = {
+  raw: async (
+    { contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>,
+    name: string,
+  ) => {
+    const prData = await _getABI.raw({ contracts }, name)
+    return universalWrapper.raw(name, prData.data)
+  },
+  decode: async (
+    { contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>,
+    data: string,
+  ) => {
+    const urData = await universalWrapper.decode(data)
+    if (!urData) return
+    return _getABI.decode({ contracts }, urData.data)
+  },
+}