fix setting abi and add tests

packages/ensjs/src/functions/wallet/setAbiRecord.test.ts

@@ -136,21 +136,47 @@ it('should allow an abi record to be set with uri content type', async () => {
   expect(response!.decoded).toBe(true)
 })
 
-it('should allow an abi record to be set to blank', async () => {
-  const tx = await setAbiRecord(walletClient, {
+type EncodeAs = Parameters<typeof encodeAbi>[0]['encodeAs']
+const ABI_TEST_CASES: { encodeAs: EncodeAs; name: string }[] = [
+  {
+    encodeAs: 'json',
     name: 'with-type-1-abi.eth',
-    encodedAbi: null,
-    resolverAddress: (await getResolver(publicClient, {
-      name: 'test123.eth',
-    }))!,
-    account: accounts[1],
-  })
-  expect(tx).toBeTruthy()
-  const receipt = await waitForTransaction(tx)
-  expect(receipt.status).toBe('success')
+  },
+  {
+    encodeAs: 'zlib',
+    name: 'with-type-2-abi.eth',
+  },
+  {
+    encodeAs: 'cbor',
+    name: 'with-type-4-abi.eth',
+  },
+  {
+    encodeAs: 'uri',
+    name: 'with-type-8-abi.eth',
+  },
+]
 
-  const response = await getAbiRecord(publicClient, {
-    name: 'test123.eth',
+ABI_TEST_CASES.forEach(({ encodeAs, name }) => {
+  it(`should allow an abi record to be set to null with ${encodeAs} content type`, async () => {
+    const encodedAbi = await encodeAbi({
+      encodeAs,
+      data: null,
+    })
+    const tx = await setAbiRecord(walletClient, {
+      name,
+      encodedAbi,
+      resolverAddress: (await getResolver(publicClient, {
+        name,
+      }))!,
+      account: accounts[1],
+    })
+    expect(tx).toBeTruthy()
+    const receipt = await waitForTransaction(tx)
+    expect(receipt.status).toBe('success')
+
+    const response = await getAbiRecord(publicClient, {
+      name,
+    })
+    expect(response).toBeNull()
   })
-  expect(response).toBeNull()
 })

packages/ensjs/src/functions/wallet/setAbiRecord.ts

@@ -22,7 +22,7 @@ export type SetAbiRecordDataParameters = {
   /** Name to set ABI for */
   name: string
   /** Encoded ABI data to set */
-  encodedAbi: EncodedAbi | null
+  encodedAbi: EncodedAbi
   /** Resolver address to set ABI on */
   resolverAddress: Address
 }
@@ -47,12 +47,11 @@ export const makeFunctionData = <
   _wallet: WalletWithEns<Transport, TChain, TAccount>,
   { name, encodedAbi, resolverAddress }: SetAbiRecordDataParameters,
 ): SetAbiRecordDataReturnType => {
-  const encodedAbi_ = encodedAbi || { contentType: 0, encodedData: null }
   return {
     to: resolverAddress,
     data: encodeSetAbi({
       namehash: namehash(name),
-      ...encodedAbi_,
+      ...encodedAbi,
     } as EncodeSetAbiParameters),
   }
 }

packages/ensjs/src/functions/wallet/setRecords.test.ts

@@ -93,6 +93,63 @@ it('should return a transaction to the resolver and set successfully', async ()
     ]
   `)
 })
+it('should return a transaction to the resolver and delete successfully', async () => {
+  const setupTx = await setRecords(walletClient, {
+    name: 'test123.eth',
+    resolverAddress: (await getResolver(publicClient, {
+      name: 'test123.eth',
+    }))!,
+    coins: [
+      {
+        coin: 'etcLegacy',
+        value: '0x42D63ae25990889E35F215bC95884039Ba354115',
+      },
+    ],
+    texts: [{ key: 'foo', value: 'bar' }],
+    abi: await encodeAbi({ encodeAs: 'json', data: dummyABI }),
+    account: accounts[1],
+  })
+  await waitForTransaction(setupTx)
+  const checkRecords = await getRecords(publicClient, {
+    name: 'test123.eth',
+    records: {
+      coins: ['etcLegacy'],
+      texts: ['foo'],
+      abi: true,
+    },
+  })
+  expect(checkRecords.abi!.abi).not.toBeNull()
+  expect(checkRecords.coins).toHaveLength(1)
+  expect(checkRecords.texts).toHaveLength(1)
+  const tx = await setRecords(walletClient, {
+    name: 'test123.eth',
+    resolverAddress: (await getResolver(publicClient, {
+      name: 'test123.eth',
+    }))!,
+    coins: [
+      {
+        coin: 'etcLegacy',
+        value: '',
+      },
+    ],
+    texts: [{ key: 'foo', value: '' }],
+    abi: await encodeAbi({ encodeAs: 'json', data: null }),
+    account: accounts[1],
+  })
+  await waitForTransaction(tx)
+
+  const records = await getRecords(publicClient, {
+    name: 'test123.eth',
+    records: {
+      coins: ['etcLegacy'],
+      texts: ['foo'],
+      abi: true,
+    },
+  })
+  expect(records.abi).toBeNull()
+  expect(records.coins).toHaveLength(0)
+  expect(records.texts).toHaveLength(0)
+})
 it('should error if there are no records to set', async () => {
   await expect(
     setRecords(walletClient, {

packages/ensjs/src/utils/encoders/encodeAbi.ts

@@ -20,11 +20,11 @@ export type EncodeAbiParameters<TEncodeAs extends AbiEncodeAs = AbiEncodeAs> =
   TEncodeAs extends 'uri'
     ? {
         encodeAs: TEncodeAs
-        data: string
+        data: string | null
       }
     : {
         encodeAs: TEncodeAs
-        data: Record<any, any>
+        data: Record<any, any> | null
       }
 
 export type EncodedAbi<TContentType extends AbiContentType = AbiContentType> = {
@@ -76,23 +76,23 @@ export const encodeAbi = async <
   switch (encodeAs) {
     case 'json':
       contentType = 1
-      encodedData = stringToHex(JSON.stringify(data))
+      encodedData = data ? stringToHex(JSON.stringify(data)) : '0x'
       break
     case 'zlib': {
       contentType = 2
       const { deflate } = await import('pako/dist/pako_deflate.min.js')
-      encodedData = bytesToHex(deflate(JSON.stringify(data)))
+      encodedData = data ? bytesToHex(deflate(JSON.stringify(data))) : '0x'
       break
     }
     case 'cbor': {
       contentType = 4
       const { cborEncode } = await import('@ensdomains/address-encoder/utils')
-      encodedData = bytesToHex(new Uint8Array(cborEncode(data)))
+      encodedData = data ? bytesToHex(new Uint8Array(cborEncode(data))) : '0x'
       break
     }
     default: {
       contentType = 8
-      encodedData = stringToHex(data as string)
+      encodedData = data ? stringToHex(data as string) : '0x'
       break
     }
   }

packages/ensjs/src/utils/encoders/encodeSetAbi.test.ts

@@ -4,8 +4,8 @@ import { encodeSetAbi, type EncodeSetAbiParameters } from './encodeSetAbi.js'
 describe('encodeSetAbi', () => {
   const namehash =
     '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef'
-  const contentType = 0
-  const encodedData = null
+  const contentType = 1
+  const encodedData = '0x'
 
   const parameters: EncodeSetAbiParameters = {
     namehash,
@@ -15,7 +15,7 @@ describe('encodeSetAbi', () => {
 
   it('encodes the setAbi function data correctly', () => {
     const expected =
-      '0x623195b01234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000'
+      '0x623195b01234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000'
     const result = encodeSetAbi(parameters)
     expect(result).toEqual(expected)
   })

packages/ensjs/src/utils/encoders/encodeSetAbi.ts

@@ -4,7 +4,7 @@ import type { EncodedAbi } from './encodeAbi.js'
 
 export type EncodeSetAbiParameters = {
   namehash: Hex
-} & (EncodedAbi | { contentType: 0; encodedData: null })
+} & EncodedAbi
 
 export type EncodeSetAbiReturnType = Hex
 
@@ -16,6 +16,6 @@ export const encodeSetAbi = ({
   return encodeFunctionData({
     abi: publicResolverSetAbiSnippet,
     functionName: 'setABI',
-    args: [namehash, BigInt(contentType), encodedData ?? '0x'],
+    args: [namehash, BigInt(contentType), encodedData],
   })
 }

packages/ensjs/src/utils/generateRecordCallArray.test.ts

@@ -44,18 +44,6 @@ it('adds contentHash call when contentHash is defined', () => {
     ]
   `)
 })
-it('adds abi call when abi is null', () => {
-  expect(
-    generateRecordCallArray({
-      namehash: namehash('test.eth'),
-      abi: null,
-    }),
-  ).toMatchInlineSnapshot(`
-    [
-      "0x623195b0eb4f647bea6caa36333c816d7b46fdcb05f9466ecacc140ea8c66faf15b3d9f1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000",
-    ]
-  `)
-})
 it('does not add abi call when abi is undefined', () => {
   expect(
     generateRecordCallArray({

packages/ensjs/src/utils/generateRecordCallArray.ts

@@ -26,7 +26,7 @@ export type RecordOptions = Prettify<{
   /** Array of coin records */
   coins?: Omit<EncodeSetAddrParameters, 'namehash'>[]
   /** ABI value */
-  abi?: EncodedAbi | null
+  abi?: EncodedAbi
 }>
 
 export const generateRecordCallArray = ({
@@ -49,8 +49,7 @@ export const generateRecordCallArray = ({
   }
 
   if (abi !== undefined) {
-    const abi_ = abi ?? { contentType: 0, encodedData: null }
-    const data = encodeSetAbi({ namehash, ...abi_ } as EncodeSetAbiParameters)
+    const data = encodeSetAbi({ namehash, ...abi } as EncodeSetAbiParameters)
     if (data) calls.push(data)
   }