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

package/dist/types/utils/recordHelpers.d.ts

@@ -1,17 +1,29 @@
+/// <reference types="node" />
+import type { BigNumberish } from 'ethers';
 import type { PublicResolver } from '../generated';
 declare type RecordItem = {
     key: string;
     value: string;
 };
+declare type ABIEncodeAs = 'json' | 'zlib' | 'cbor' | 'uri';
+declare type ABIItem = {
+    contentType?: BigNumberish;
+    data: object | string;
+};
 export declare type RecordOptions = {
     clearRecords?: boolean;
     contentHash?: string;
     texts?: RecordItem[];
     coinTypes?: RecordItem[];
+    abi?: ABIItem;
 };
 export declare const generateSetAddr: (namehash: string, coinType: string, address: string, resolver: PublicResolver) => string;
-export declare type RecordTypes = 'contentHash' | 'text' | 'addr';
-export declare type RecordInput<T extends RecordTypes> = T extends 'contentHash' ? string : RecordItem;
+export declare const generateABIInput: (encodeAs: ABIEncodeAs, data: object | string) => Promise<{
+    contentType: number;
+    data: string | Uint8Array | Buffer;
+}>;
+export declare type RecordTypes = 'contentHash' | 'text' | 'addr' | 'abi';
+export declare type RecordInput<T extends RecordTypes> = T extends 'contentHash' ? string : T extends 'abi' ? ABIItem : RecordItem;
 export declare function generateSingleRecordCall<T extends RecordTypes>(namehash: string, resolver: PublicResolver, type: T): (record: RecordInput<T>) => string;
 export declare const generateRecordCallArray: (namehash: string, records: RecordOptions, resolver: PublicResolver) => string[];
 export {};

package/dist/types/utils/writeTx.d.ts

@@ -5,15 +5,15 @@ declare const _default: (signer: JsonRpcSigner, populate: boolean) => ({ customD
     to?: string | undefined;
     from?: string | undefined;
     nonce?: number | undefined;
-    gasLimit?: import("@ethersproject/bignumber").BigNumber | undefined;
-    gasPrice?: import("@ethersproject/bignumber").BigNumber | undefined;
+    gasLimit?: import("ethers").BigNumber | undefined;
+    gasPrice?: import("ethers").BigNumber | undefined;
     data?: string | undefined;
-    value?: import("@ethersproject/bignumber").BigNumber | undefined;
+    value?: import("ethers").BigNumber | undefined;
     chainId?: number | undefined;
     type?: number | undefined;
     accessList?: import("@ethersproject/transactions").AccessList | undefined;
-    maxFeePerGas?: import("@ethersproject/bignumber").BigNumber | undefined;
-    maxPriorityFeePerGas?: import("@ethersproject/bignumber").BigNumber | undefined;
+    maxFeePerGas?: import("ethers").BigNumber | undefined;
+    maxPriorityFeePerGas?: import("ethers").BigNumber | undefined;
     ccipReadEnabled?: boolean | undefined;
 } | Promise<import("@ethersproject/abstract-provider").TransactionResponse | (import("@ethersproject/abstract-provider").TransactionResponse & {
     customData: CustomData;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ensdomains/ensjs",
-  "version": "3.0.0-alpha.40",
+  "version": "3.0.0-alpha.41",
   "description": "ENS javascript library for contract interaction",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.mjs",
@@ -59,10 +59,12 @@
     "@ensdomains/content-hash": "^2.5.7",
     "@ensdomains/dnsprovejs": "^0.4.1",
     "@ensdomains/dnssecoraclejs": "^0.2.7",
+    "cbor": "^8.1.0",
     "dns-packet": "^5.3.1",
     "graphql": "^16.3.0",
     "graphql-request": "next",
     "idna-uts46-hx": "3.4.0",
+    "pako": "^2.1.0",
     "traverse": "^0.6.6"
   },
   "devDependencies": {
@@ -91,6 +93,7 @@
     "@typechain/ethers-v5": "^10.1.0",
     "@types/bn.js": "^5.1.0",
     "@types/jest": "^27.4.1",
+    "@types/pako": "^2.0.0",
     "@types/traverse": "^0.6.32",
     "dotenv": "^16.0.0",
     "esbuild": "^0.15.6",

package/src/@types/pako.d.ts

@@ -0,0 +1,188 @@
+/* eslint-disable max-classes-per-file */
+// Type definitions for pako 2.0
+// Project: https://github.com/nodeca/pako
+// Definitions by: Caleb Eggensperger <https://github.com/calebegg>
+//                 Muhammet Öztürk <https://github.com/hlthi>
+//                 Thibault Poisson <https://github.com/OrIOg>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+enum constants {
+  // FlushValues
+  Z_NO_FLUSH = 0,
+  Z_PARTIAL_FLUSH = 1,
+  Z_SYNC_FLUSH = 2,
+  Z_FULL_FLUSH = 3,
+  Z_FINISH = 4,
+  Z_BLOCK = 5,
+  Z_TREES = 6,
+  // StrategyValues
+  Z_FILTERED = 1,
+  Z_HUFFMAN_ONLY = 2,
+  Z_RLE = 3,
+  Z_FIXED = 4,
+  Z_DEFAULT_STRATEGY = 0,
+  // ReturnCodes
+  Z_OK = 0,
+  Z_STREAM_END = 1,
+  Z_NEED_DICT = 2,
+  Z_ERRNO = -1,
+  Z_STREAM_ERROR = -2,
+  Z_DATA_ERROR = -3,
+  Z_BUF_ERROR = -5,
+}
+
+type FlushValues =
+  | constants.Z_NO_FLUSH
+  | constants.Z_PARTIAL_FLUSH
+  | constants.Z_SYNC_FLUSH
+  | constants.Z_FINISH
+  | constants.Z_BLOCK
+  | constants.Z_TREES
+
+type StrategyValues =
+  | constants.Z_FILTERED
+  | constants.Z_HUFFMAN_ONLY
+  | constants.Z_RLE
+  | constants.Z_FIXED
+  | constants.Z_DEFAULT_STRATEGY
+
+type ReturnCodes =
+  | constants.Z_OK
+  | constants.Z_STREAM_END
+  | constants.Z_NEED_DICT
+  | constants.Z_ERRNO
+  | constants.Z_STREAM_ERROR
+  | constants.Z_DATA_ERROR
+  | constants.Z_BUF_ERROR
+  | constants.Z_DEFAULT_STRATEGY
+
+interface DeflateOptions {
+  level?: -1 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | undefined
+  windowBits?: number | undefined
+  memLevel?: number | undefined
+  strategy?: StrategyValues | undefined
+  dictionary?: any
+  raw?: boolean | undefined
+  chunkSize?: number | undefined
+  gzip?: boolean | undefined
+  header?: Header | undefined
+}
+
+interface DeflateFunctionOptions {
+  level?: -1 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | undefined
+  windowBits?: number | undefined
+  memLevel?: number | undefined
+  strategy?: StrategyValues | undefined
+  dictionary?: any
+  raw?: boolean | undefined
+}
+
+interface InflateOptions {
+  windowBits?: number | undefined
+  dictionary?: any
+  raw?: boolean | undefined
+  to?: 'string' | undefined
+  chunkSize?: number | undefined
+}
+
+interface InflateFunctionOptions {
+  windowBits?: number | undefined
+  raw?: boolean | undefined
+  to?: 'string' | undefined
+}
+
+interface Header {
+  text?: boolean | undefined
+  time?: number | undefined
+  os?: number | undefined
+  extra?: number[] | undefined
+  name?: string | undefined
+  comment?: string | undefined
+  hcrc?: boolean | undefined
+}
+
+type Data = Uint8Array | ArrayBuffer
+
+declare module 'pako/dist/pako_inflate.min.js' {
+  /**
+   * Decompress data with inflate/ungzip and options. Autodetect format via wrapper header
+   * by default. That's why we don't provide separate ungzip method.
+   */
+  function inflate(
+    data: Data,
+    options: InflateFunctionOptions & { to: 'string' },
+  ): string
+  function inflate(data: Data, options?: InflateFunctionOptions): Uint8Array
+
+  /**
+   * The same as inflate, but creates raw data, without wrapper (header and adler32 crc).
+   */
+  function inflateRaw(
+    data: Data,
+    options: InflateFunctionOptions & { to: 'string' },
+  ): string
+  function inflateRaw(data: Data, options?: InflateFunctionOptions): Uint8Array
+
+  /**
+   * Just shortcut to inflate, because it autodetects format by header.content. Done for convenience.
+   */
+  function ungzip(
+    data: Data,
+    options: InflateFunctionOptions & { to: 'string' },
+  ): string
+  function ungzip(data: Data, options?: InflateFunctionOptions): Uint8Array
+
+  // https://github.com/nodeca/pako/blob/893381abcafa10fa2081ce60dae7d4d8e873a658/lib/inflate.js
+  class Inflate {
+    constructor(options?: InflateOptions)
+    header?: Header | undefined
+
+    err: ReturnCodes
+
+    msg: string
+
+    result: Uint8Array | string
+    onData(chunk: Data): void
+    onEnd(status: number): void
+    push(data: Data, mode?: FlushValues | boolean): boolean
+  }
+}
+
+declare module 'pako/dist/pako_deflate.min.js' {
+  /**
+   * Compress data with deflate algorithm and options.
+   */
+  function deflate(
+    data: Data | string,
+    options?: DeflateFunctionOptions,
+  ): Uint8Array
+
+  /**
+   * The same as deflate, but creates raw data, without wrapper (header and adler32 crc).
+   */
+  function deflateRaw(
+    data: Data | string,
+    options?: DeflateFunctionOptions,
+  ): Uint8Array
+
+  /**
+   * The same as deflate, but create gzip wrapper instead of deflate one.
+   */
+  function gzip(
+    data: Data | string,
+    options?: DeflateFunctionOptions,
+  ): Uint8Array
+
+  class Deflate {
+    constructor(options?: DeflateOptions)
+    err: ReturnCodes
+
+    msg: string
+
+    result: Uint8Array
+    onData(chunk: Data): void
+    onEnd(status: number): void
+    push(data: Data | string, mode?: FlushValues | boolean): boolean
+  }
+}

package/src/contracts/bulkRenewal.ts

@@ -1,6 +1,6 @@
 import type { JsonRpcProvider } from '@ethersproject/providers'
 import { BulkRenewal__factory } from '../generated/factories/BulkRenewal__factory'
 
-// Use a higher-order function to overide the address that is passed in from getContractAddress()
+// Use a higher-order function to override the address that is passed in from getContractAddress()
 export default (provider: JsonRpcProvider, address: string) =>
   BulkRenewal__factory.connect(address, provider)

package/src/functions/getSpecificRecord.test.ts

@@ -7,6 +7,125 @@ beforeAll(async () => {
   ;({ 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 () => {
@@ -76,4 +195,47 @@ describe('getSpecificRecord', () => {
       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 { hexStripZeros, isBytesLike } from '@ethersproject/bytes'
+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'
@@ -234,3 +236,95 @@ export const getAddr = {
     return _getAddr.decode({ contracts }, urData.data, _name, coinType)
   },
 }
+
+// Supported content types as bitwise OR
+// ID 1: JSON
+// ID 2: zlib compressed JSON
+// ID 4: CBOR
+// ID 8: URI
+const supportedContentTypes = '0xf'
+
+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,
+    }
+  },
+}
+
+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)
+  },
+}