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

package/src/functions/setRecord.test.ts

@@ -1,8 +1,13 @@
+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']
@@ -11,10 +16,30 @@ beforeAll(async () => {
   ;({ ensInstance, revert } = await setup())
 })
 
-afterAll(async () => {
+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', {
@@ -100,4 +125,125 @@ describe('setRecord', () => {
     )
     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

@@ -16,6 +16,11 @@ type AddrOrTextInput = {
   type: 'addr' | 'text'
 }
 
+type ABIInput = {
+  record: RecordInput<'abi'>
+  type: 'abi'
+}
+
 export default async function (
   {
     contracts,
@@ -28,7 +33,7 @@ export default async function (
     record,
     type,
     resolverAddress,
-  }: BaseInput & (ContentHashInput | AddrOrTextInput),
+  }: BaseInput & (ContentHashInput | AddrOrTextInput | ABIInput),
 ) {
   if (!name.includes('.')) {
     throw new Error('Input is not an ENS name')

package/src/functions/types.ts

@@ -20,9 +20,11 @@ import type getProfile from './getProfile'
 import type getRecords from './getRecords'
 import type getResolver from './getResolver'
 import type {
+  getABI,
   getAddr,
   getContentHash,
   getText,
+  _getABI,
   _getAddr,
   _getContentHash,
   _getText,
@@ -70,9 +72,11 @@ type Function = {
   getAddr: typeof getAddr
   getContentHash: typeof getContentHash
   getText: typeof getText
+  getABI: typeof getABI
   _getAddr: typeof _getAddr
   _getContentHash: typeof _getContentHash
   _getText: typeof _getText
+  _getABI: typeof _getABI
   getSubnames: typeof getSubnames
   getWrapperData: typeof getWrapperData
   importDNSSECName: typeof importDNSSECName

package/src/index.ts

@@ -497,6 +497,18 @@ export class ENS {
     '_getText',
   )
 
+  public getABI = this.generateRawFunction<FunctionTypes['getABI']>(
+    'initialGetters',
+    ['contracts', 'universalWrapper'],
+    'getABI',
+  )
+
+  public _getABI = this.generateRawFunction<FunctionTypes['_getABI']>(
+    'initialGetters',
+    ['contracts'],
+    '_getABI',
+  )
+
   public getOwner = this.generateRawFunction<FunctionTypes['getOwner']>(
     'initialGetters',
     ['contracts', 'multicallWrapper', 'gqlInstance'],

package/src/utils/recordHelpers.ts

@@ -1,4 +1,6 @@
 import { formatsByCoinType, formatsByName } from '@ensdomains/address-encoder'
+import type { BigNumberish } from 'ethers'
+import { isBytesLike, toUtf8Bytes } from 'ethers/lib/utils'
 import type { PublicResolver } from '../generated'
 import { encodeContenthash } from './contentHash'
 
@@ -7,11 +9,19 @@ type RecordItem = {
   value: string
 }
 
+type ABIEncodeAs = 'json' | 'zlib' | 'cbor' | 'uri'
+
+type ABIItem = {
+  contentType?: BigNumberish
+  data: object | string
+}
+
 export type RecordOptions = {
   clearRecords?: boolean
   contentHash?: string
   texts?: RecordItem[]
   coinTypes?: RecordItem[]
+  abi?: ABIItem
 }
 
 export const generateSetAddr = (
@@ -34,10 +44,44 @@ export const generateSetAddr = (
   )
 }
 
-export type RecordTypes = 'contentHash' | 'text' | 'addr'
+export const generateABIInput = async (
+  encodeAs: ABIEncodeAs,
+  data: object | string,
+) => {
+  let contentType: number
+  let encodedData: string | Buffer | Uint8Array
+  switch (encodeAs) {
+    case 'json':
+      contentType = 1
+      encodedData = JSON.stringify(data)
+      break
+    case 'zlib': {
+      contentType = 2
+      const { deflate } = await import('pako/dist/pako_deflate.min.js')
+      encodedData = deflate(JSON.stringify(data))
+      break
+    }
+    case 'cbor': {
+      contentType = 4
+      const { encode } = await import('cbor')
+      encodedData = encode(data)
+      break
+    }
+    default: {
+      contentType = 8
+      encodedData = data as string
+      break
+    }
+  }
+  return { contentType, data: encodedData }
+}
+
+export type RecordTypes = 'contentHash' | 'text' | 'addr' | 'abi'
 
 export type RecordInput<T extends RecordTypes> = T extends 'contentHash'
   ? string
+  : T extends 'abi'
+  ? ABIItem
   : RecordItem
 
 export function generateSingleRecordCall<T extends RecordTypes>(
@@ -60,6 +104,24 @@ export function generateSingleRecordCall<T extends RecordTypes>(
       ])
     }
   }
+  if (type === 'abi') {
+    return (_r: RecordInput<T>) => {
+      const record = _r as ABIItem
+      const { contentType = 1, data } = record
+      let encodedData = data as string | Uint8Array | Buffer
+      if (!isBytesLike(encodedData)) {
+        if (typeof encodedData === 'object') {
+          encodedData = JSON.stringify(encodedData)
+        }
+        encodedData = toUtf8Bytes(encodedData)
+      }
+      return resolver.interface.encodeFunctionData('setABI', [
+        namehash,
+        contentType,
+        encodedData,
+      ])
+    }
+  }
   return (_r: RecordInput<T>) => {
     const record = _r as RecordItem
     if (type === 'text') {