@ensdomains/ensjs 3.0.0-alpha.5 → 3.0.0-alpha.51

package/src/GqlManager.ts

@@ -1,18 +1,114 @@
+import type {
+  Kind,
+  parse as Parse,
+  print as Print,
+  SelectionSetNode,
+  visit as Visit,
+} from 'graphql'
+import type { gql, GraphQLClient } from 'graphql-request'
+import type Traverse from 'traverse'
+import { namehash } from './utils/normalise'
+
+const generateSelection = (selection: any) => ({
+  kind: 'Field' as Kind.FIELD,
+  name: {
+    kind: 'Name' as Kind.NAME,
+    value: selection,
+  },
+  arguments: [],
+  directives: [],
+  alias: undefined,
+  selectionSet: undefined,
+})
+
+export const enter = (node: SelectionSetNode) => {
+  let hasName = false
+  let hasId = false
+
+  for (const selection of node.selections) {
+    if ('name' in selection) {
+      if (selection.name.value === 'name') hasName = true
+      else if (selection.name.value === 'id') hasId = true
+    }
+  }
+
+  if (hasName && !hasId) {
+    // eslint-disable-next-line no-param-reassign
+    node.selections = [...node.selections, generateSelection('id')]
+    return node
+  }
+}
+
+export const requestMiddleware =
+  (visit: typeof Visit, parse: typeof Parse, print: typeof Print) =>
+  (request: any) => {
+    const requestBody = JSON.parse(request.body)
+    const rawQuery = requestBody.query
+    const parsedQuery = parse(rawQuery)
+    const updatedQuery = visit(parsedQuery, {
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      SelectionSet: {
+        enter,
+      },
+    })
+
+    return {
+      ...request,
+      body: JSON.stringify({ ...requestBody, query: print(updatedQuery) }),
+    }
+  }
+
+export const responseMiddleware =
+  (traverse: typeof Traverse) => (response: any) => {
+    // eslint-disable-next-line func-names
+    traverse(response).forEach(function (responseItem: any) {
+      if (responseItem instanceof Object && responseItem.name) {
+        // Name already in hashed form
+        if (responseItem.name && responseItem.name.includes('[')) {
+          return
+        }
+
+        const hashedName = namehash(responseItem.name)
+        if (responseItem.id !== hashedName) {
+          this.update({ ...responseItem, name: hashedName, invalidName: true })
+        }
+      }
+    })
+    return response
+  }
+
 export default class GqlManager {
-  public gql: any = () => null
-  public client?: any | null = null
+  // eslint-disable-next-line class-methods-use-this
+  public gql: typeof gql | ((query: TemplateStringsArray) => string) = (
+    query: TemplateStringsArray,
+  ) => query.join()
+
+  public client:
+    | GraphQLClient
+    | {
+        request: () => Promise<null>
+      } = {
+    request: () => Promise.resolve(null),
+  }
 
   public setUrl = async (url: string | null) => {
     if (url) {
-      const imported = await import('graphql-request')
-      this.client = new imported.GraphQLClient(url)
+      const [imported, traverse, { visit, parse, print }] = await Promise.all([
+        import('graphql-request'),
+        import('traverse'),
+        import('graphql/language'),
+      ])
+
+      this.client = new imported.GraphQLClient(url, {
+        requestMiddleware: requestMiddleware(visit, parse, print),
+        responseMiddleware: responseMiddleware(traverse.default),
+      })
       this.gql = imported.gql
     } else {
-      this.client = null
-      this.gql = () => null
+      this.client = {
+        request: () => Promise.resolve(null),
+      }
+      this.gql = (query: TemplateStringsArray) => query.join()
     }
   }
-
-  public request = (...arg: any[]) =>
-    this.client ? this.client.request(...arg) : null
 }

package/src/contracts/baseRegistrar.ts

@@ -1,5 +1,5 @@
-import { ethers } from 'ethers'
+import type { JsonRpcProvider } from '@ethersproject/providers'
 import { BaseRegistrarImplementation__factory } from '../generated/factories/BaseRegistrarImplementation__factory'
 
-export default (provider: ethers.providers.JsonRpcProvider, address: string) =>
+export default (provider: JsonRpcProvider, address: string) =>
   BaseRegistrarImplementation__factory.connect(address, provider)

package/src/contracts/bulkRenewal.ts

@@ -0,0 +1,6 @@
+import type { JsonRpcProvider } from '@ethersproject/providers'
+import { BulkRenewal__factory } from '../generated/factories/BulkRenewal__factory'
+
+// 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/contracts/dnsRegistrar.ts

@@ -0,0 +1,5 @@
+import type { JsonRpcProvider } from '@ethersproject/providers'
+import { DNSRegistrar__factory } from '../generated/factories/DNSRegistrar__factory'
+
+export default (provider: JsonRpcProvider, address: string) =>
+  DNSRegistrar__factory.connect(address, provider)

package/src/contracts/ethRegistrarController.ts

@@ -1,5 +1,5 @@
-import { ethers } from 'ethers'
+import type { JsonRpcProvider } from '@ethersproject/providers'
 import { ETHRegistrarController__factory } from '../generated/factories/ETHRegistrarController__factory'
 
-export default (provider: ethers.providers.JsonRpcProvider, address: string) =>
+export default (provider: JsonRpcProvider, address: string) =>
   ETHRegistrarController__factory.connect(address, provider)

package/src/contracts/factories.ts

@@ -0,0 +1,48 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import type { BaseRegistrarImplementation__factory } from '../generated/factories/BaseRegistrarImplementation__factory'
+import type { BulkRenewal__factory } from '../generated/factories/BulkRenewal__factory'
+import type { DefaultReverseResolver__factory } from '../generated/factories/DefaultReverseResolver__factory'
+import type { DNSRegistrar__factory } from '../generated/factories/DNSRegistrar__factory'
+import type { DNSSECImpl__factory } from '../generated/factories/DNSSECImpl__factory'
+import type { ENSRegistry__factory } from '../generated/factories/ENSRegistry__factory'
+import type { ETHRegistrarController__factory } from '../generated/factories/ETHRegistrarController__factory'
+import type { Multicall__factory } from '../generated/factories/Multicall__factory'
+import type { NameWrapper__factory } from '../generated/factories/NameWrapper__factory'
+import type { P256SHA256Algorithm__factory } from '../generated/factories/P256SHA256Algorithm__factory'
+import type { PublicResolver__factory } from '../generated/factories/PublicResolver__factory'
+import type { ReverseRegistrar__factory } from '../generated/factories/ReverseRegistrar__factory'
+import type { Root__factory } from '../generated/factories/Root__factory'
+import type { RSASHA1Algorithm__factory } from '../generated/factories/RSASHA1Algorithm__factory'
+import type { RSASHA256Algorithm__factory } from '../generated/factories/RSASHA256Algorithm__factory'
+import type { SHA1Digest__factory } from '../generated/factories/SHA1Digest__factory'
+import type { SHA1NSEC3Digest__factory } from '../generated/factories/SHA1NSEC3Digest__factory'
+import type { SHA256Digest__factory } from '../generated/factories/SHA256Digest__factory'
+import type { StaticMetadataService__factory } from '../generated/factories/StaticMetadataService__factory'
+import type { TLDPublicSuffixList__factory } from '../generated/factories/TLDPublicSuffixList__factory'
+import type { UniversalResolver__factory } from '../generated/factories/UniversalResolver__factory'
+
+type Factories = {
+  BaseRegistrarImplementation: BaseRegistrarImplementation__factory
+  DefaultReverseResolver: DefaultReverseResolver__factory
+  DNSRegistrar: DNSRegistrar__factory
+  DNSSECImpl: DNSSECImpl__factory
+  ENSRegistry: ENSRegistry__factory
+  ETHRegistrarController: ETHRegistrarController__factory
+  P256SHA256Algorithm: P256SHA256Algorithm__factory
+  PublicResolver: PublicResolver__factory
+  ReverseRegistrar: ReverseRegistrar__factory
+  Root: Root__factory
+  RSASHA1Algorithm: RSASHA1Algorithm__factory
+  RSASHA256Algorithm: RSASHA256Algorithm__factory
+  SHA1Digest: SHA1Digest__factory
+  SHA1NSEC3Digest: SHA1NSEC3Digest__factory
+  SHA256Digest: SHA256Digest__factory
+  TLDPublicSuffixList: TLDPublicSuffixList__factory
+  Multicall: Multicall__factory
+  NameWrapper: NameWrapper__factory
+  StaticMetadataService: StaticMetadataService__factory
+  UniversalResolver: UniversalResolver__factory
+  BulkRenewal: BulkRenewal__factory
+}
+
+export default Factories

package/src/contracts/getContractAddress.ts

@@ -4,24 +4,37 @@ const addresses: Record<
   ContractName,
   Partial<Record<SupportedNetworkId, string>> | string
 > = {
+  /* eslint-disable @typescript-eslint/naming-convention */
   BaseRegistrarImplementation: {
     '1': '0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85',
     '3': '0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85',
     '4': '0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85',
     '5': '0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85',
   },
+  DNSRegistrar: {
+    '1': '0x58774Bb8acD458A640aF0B88238369A167546ef2',
+    '3': '0xdB328BA5FEcb432AF325Ca59E3778441eF5aa14F',
+    '5': '0x8edc487D26F6c8Fa76e032066A3D4F87E273515d',
+  },
   ETHRegistrarController: {
     '1': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
-    '3': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
+    '3': '0xa5627AB7Ae47063B533622C34FEBDb52d3281dF8',
     '4': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
-    '5': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
+    '5': '0xCc5e7dB10E65EED1BBD105359e7268aa660f6734',
   },
   Multicall: '0xcA11bde05977b3631167028862bE2a173976CA11',
-  NameWrapper: '0x0000000000000000000000000000000000000000',
+  NameWrapper: {
+    '1': '0x0000000000000000000000000000000000000000',
+    '3': '0xF82155e2a43Be0871821E9654Fc8Ae894FB8307C',
+    '4': '0x0000000000000000000000000000000000000000',
+    '5': '0x114D4603199df73e7D157787f8778E21fCd13066',
+  },
   PublicResolver: {
     '1': '0x4976fb03C32e5B8cfe2b6cCB31c09Ba78EBaBa41',
+    '3': '0x13F0659Ee6bb7484C884FEeFb7F75C93951ef837',
+    '5': '0xd7a4F6473f32aC2Af804B3686AE8F1932bC35750',
   },
-  ENSRegistryWithFallback: {
+  ENSRegistry: {
     '1': '0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e',
     '3': '0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e',
     '4': '0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e',
@@ -29,11 +42,19 @@ const addresses: Record<
   },
   ReverseRegistrar: {
     '1': '0x084b1c3C81545d370f3634392De611CaaBFf8148',
+    '3': '0x806246b52f8cB61655d3038c58D2f63Aa55d4edE',
+    '5': '0x4f7A657451358a22dc397d5eE7981FfC526cd856',
   },
   UniversalResolver: {
-    '1': '0x580AF46E06DaaD47eb5940526FD64d95b815Cb70',
-    '4': '0x74e20bd2a1fe0cdbe45b9a1d89cb7e0a45b36376',
+    '1': '0xE4Acdd618deED4e6d2f03b9bf62dc6118FC9A4da',
+    '5': '0xA292E2E58d4ddEb29C33c63173d0E8B7a2A4c62e',
+  },
+  BulkRenewal: {
+    '1': '0xfF252725f6122A92551A5FA9a6b6bf10eb0Be035',
+    '3': '0x051b02245D826757EfaF5C6209D4D79FB39FBC45',
+    '5': '0xa9e1df95a79C768aA435805b28E1B54Bb5ead063',
   },
+  /* eslint-enable @typescript-eslint/naming-convention */
 }
 
 export type ContractAddressFetch = (contractName: ContractName) => string

package/src/contracts/index.ts

@@ -1,68 +1,92 @@
-import { ethers } from 'ethers'
-import getBaseRegistrar from './baseRegistrar'
-import getEthRegistrarController from './ethRegistrarController'
+import type { Interface } from '@ethersproject/abi'
+import type { Signer } from '@ethersproject/abstract-signer'
+import type { BaseContract } from '@ethersproject/contracts'
+import type { Provider } from '@ethersproject/providers'
+import type { BaseRegistrarImplementation } from '../generated/BaseRegistrarImplementation'
+import type { BulkRenewal } from '../generated/BulkRenewal'
+import type { DNSRegistrar } from '../generated/DNSRegistrar'
+import type { ENSRegistry } from '../generated/ENSRegistry'
+import type { ETHRegistrarController } from '../generated/ETHRegistrarController'
+import type { Multicall } from '../generated/Multicall'
+import type { NameWrapper } from '../generated/NameWrapper'
+import type { PublicResolver } from '../generated/PublicResolver'
+import type { ReverseRegistrar } from '../generated/ReverseRegistrar'
+import type { UniversalResolver } from '../generated/UniversalResolver'
 import { ContractAddressFetch } from './getContractAddress'
-import getMulticall from './multicall'
-import getNameWrapper from './nameWrapper'
-import getPublicResolver from './publicResolver'
-import getRegistry from './registry'
-import getReverseRegistrar from './reverseRegistrar'
 import { ContractName } from './types'
-import getUniversalResolver from './universalResolver'
+
+type BaseFactory = {
+  readonly abi: object
+  createInterface(): Interface
+  connect(address: string, signerOrProvider: Signer | Provider): BaseContract
+}
 
 export default class ContractManager {
-  private provider: ethers.providers.Provider
+  private provider: Provider
+
   private fetchAddress: ContractAddressFetch
 
+  // eslint-disable-next-line class-methods-use-this
+  protected getModule = async (name: string) => {
+    const mod = await import(
+      /* webpackMode: "lazy", webpackChunkName: "[request]", webpackPreload: true, webpackExclude: /.*\.ts$/ */
+      `../generated/factories/${name}__factory`
+    )
+    return mod[`${name}__factory`] as BaseFactory
+  }
+
   constructor(
-    provider: ethers.providers.Provider,
+    provider: Provider,
     fetchAddress: ContractAddressFetch,
+    getModule?: (name: string) => Promise<BaseFactory>,
   ) {
     this.provider = provider
     this.fetchAddress = fetchAddress
+    if (getModule) {
+      this.getModule = getModule
+    }
   }
 
-  private generateContractGetter = <C extends (...args: any) => any>(
+  private generateContractGetter = <C extends BaseContract>(
     name: ContractName,
-    func: C,
-  ) => {
-    return async (
-      passedProvider?: any,
-      address?: string,
-    ): Promise<ReturnType<C>> => {
+  ): ((passedProvider?: any, address?: string) => Promise<C>) => {
+    return async (passedProvider, address) => {
+      const mod = await this.getModule(name)
       const inputAddress = address || this.fetchAddress(name)
       const provider = passedProvider || this.provider
-      return func(provider, inputAddress)
+      return mod.connect(inputAddress, provider) as C
     }
   }
 
-  public getPublicResolver = this.generateContractGetter(
-    'PublicResolver',
-    getPublicResolver,
-  )
-  public getUniversalResolver = this.generateContractGetter(
-    'UniversalResolver',
-    getUniversalResolver,
-  )
-  public getRegistry = this.generateContractGetter(
-    'ENSRegistryWithFallback',
-    getRegistry,
-  )
-  public getReverseRegistrar = this.generateContractGetter(
-    'ReverseRegistrar',
-    getReverseRegistrar,
-  )
-  public getNameWrapper = this.generateContractGetter(
-    'NameWrapper',
-    getNameWrapper,
-  )
-  public getBaseRegistrar = this.generateContractGetter(
-    'BaseRegistrarImplementation',
-    getBaseRegistrar,
-  )
-  public getEthRegistrarController = this.generateContractGetter(
-    'ETHRegistrarController',
-    getEthRegistrarController,
-  )
-  public getMulticall = this.generateContractGetter('Multicall', getMulticall)
+  public getPublicResolver =
+    this.generateContractGetter<PublicResolver>('PublicResolver')
+
+  public getUniversalResolver =
+    this.generateContractGetter<UniversalResolver>('UniversalResolver')
+
+  public getRegistry = this.generateContractGetter<ENSRegistry>('ENSRegistry')
+
+  public getReverseRegistrar =
+    this.generateContractGetter<ReverseRegistrar>('ReverseRegistrar')
+
+  public getNameWrapper =
+    this.generateContractGetter<NameWrapper>('NameWrapper')
+
+  public getDNSRegistrar =
+    this.generateContractGetter<DNSRegistrar>('DNSRegistrar')
+
+  public getBaseRegistrar =
+    this.generateContractGetter<BaseRegistrarImplementation>(
+      'BaseRegistrarImplementation',
+    )
+
+  public getEthRegistrarController =
+    this.generateContractGetter<ETHRegistrarController>(
+      'ETHRegistrarController',
+    )
+
+  public getMulticall = this.generateContractGetter<Multicall>('Multicall')
+
+  public getBulkRenewal =
+    this.generateContractGetter<BulkRenewal>('BulkRenewal')
 }

package/src/contracts/multicall.ts

@@ -1,24 +1,5 @@
-import { ethers } from 'ethers'
+import type { JsonRpcProvider } from '@ethersproject/providers'
 import { Multicall__factory } from '../generated/factories/Multicall__factory'
 
-const ABI = [
-  'function aggregate(tuple(address target, bytes callData)[] calls) payable returns (uint256 blockNumber, bytes[] returnData)',
-  'function aggregate3(tuple(address target, bool allowFailure, bytes callData)[] calls) payable returns (tuple(bool success, bytes returnData)[] returnData)',
-  'function aggregate3Value(tuple(address target, bool allowFailure, uint256 value, bytes callData)[] calls) payable returns (tuple(bool success, bytes returnData)[] returnData)',
-  'function blockAndAggregate(tuple(address target, bytes callData)[] calls) payable returns (uint256 blockNumber, bytes32 blockHash, tuple(bool success, bytes returnData)[] returnData)',
-  'function getBasefee() view returns (uint256 basefee)',
-  'function getBlockHash(uint256 blockNumber) view returns (bytes32 blockHash)',
-  'function getBlockNumber() view returns (uint256 blockNumber)',
-  'function getChainId() view returns (uint256 chainid)',
-  'function getCurrentBlockCoinbase() view returns (address coinbase)',
-  'function getCurrentBlockDifficulty() view returns (uint256 difficulty)',
-  'function getCurrentBlockGasLimit() view returns (uint256 gaslimit)',
-  'function getCurrentBlockTimestamp() view returns (uint256 timestamp)',
-  'function getEthBalance(address addr) view returns (uint256 balance)',
-  'function getLastBlockHash() view returns (bytes32 blockHash)',
-  'function tryAggregate(bool requireSuccess, tuple(address target, bytes callData)[] calls) payable returns (tuple(bool success, bytes returnData)[] returnData)',
-  'function tryBlockAndAggregate(bool requireSuccess, tuple(address target, bytes callData)[] calls) payable returns (uint256 blockNumber, bytes32 blockHash, tuple(bool success, bytes returnData)[] returnData)',
-]
-
-export default (provider: ethers.providers.JsonRpcProvider, address: string) =>
+export default (provider: JsonRpcProvider, address: string) =>
   Multicall__factory.connect(address, provider)

package/src/contracts/nameWrapper.ts

@@ -1,5 +1,5 @@
-import { ethers } from 'ethers'
+import type { JsonRpcProvider } from '@ethersproject/providers'
 import { NameWrapper__factory } from '../generated/factories/NameWrapper__factory'
 
-export default (provider: ethers.providers.JsonRpcProvider, address: string) =>
+export default (provider: JsonRpcProvider, address: string) =>
   NameWrapper__factory.connect(address, provider)

package/src/contracts/publicResolver.ts

@@ -1,5 +1,5 @@
-import { ethers } from 'ethers'
+import type { JsonRpcProvider } from '@ethersproject/providers'
 import { PublicResolver__factory } from '../generated/factories/PublicResolver__factory'
 
-export default (provider: ethers.providers.JsonRpcProvider, address: string) =>
+export default (provider: JsonRpcProvider, address: string) =>
   PublicResolver__factory.connect(address, provider)

package/src/contracts/registry.ts

@@ -1,5 +1,5 @@
-import { ethers } from 'ethers'
+import type { JsonRpcProvider } from '@ethersproject/providers'
 import { ENSRegistry__factory } from '../generated/factories/ENSRegistry__factory'
 
-export default (provider: ethers.providers.JsonRpcProvider, address: string) =>
+export default (provider: JsonRpcProvider, address: string) =>
   ENSRegistry__factory.connect(address, provider)

package/src/contracts/reverseRegistrar.ts

@@ -1,5 +1,5 @@
-import { ethers } from 'ethers'
+import type { JsonRpcProvider } from '@ethersproject/providers'
 import { ReverseRegistrar__factory } from '../generated/factories/ReverseRegistrar__factory'
 
-export default (provider: ethers.providers.JsonRpcProvider, address: string) =>
+export default (provider: JsonRpcProvider, address: string) =>
   ReverseRegistrar__factory.connect(address, provider)

package/src/contracts/types.ts

@@ -5,7 +5,9 @@ export type ContractName =
   | 'ETHRegistrarController'
   | 'Multicall'
   | 'NameWrapper'
+  | 'DNSRegistrar'
   | 'PublicResolver'
-  | 'ENSRegistryWithFallback'
+  | 'ENSRegistry'
   | 'ReverseRegistrar'
   | 'UniversalResolver'
+  | 'BulkRenewal'

package/src/contracts/universalResolver.ts

@@ -1,5 +1,5 @@
-import { ethers } from 'ethers'
+import type { JsonRpcProvider } from '@ethersproject/providers'
 import { UniversalResolver__factory } from '../generated/factories/UniversalResolver__factory'
 
-export default (provider: ethers.providers.JsonRpcProvider, address: string) =>
+export default (provider: JsonRpcProvider, address: string) =>
   UniversalResolver__factory.connect(address, provider)

package/src/functions/batch.test.ts

@@ -1,32 +1,32 @@
 import { ENS } from '..'
 import setup from '../tests/setup'
 
-let ENSInstance: ENS
+let ensInstance: ENS
 
 beforeAll(async () => {
-  ;({ ENSInstance } = await setup())
+  ;({ ensInstance } = await setup())
 })
 
 describe('batch', () => {
   it('should batch calls together', async () => {
-    const result = await ENSInstance.batch(
-      ENSInstance.getText.batch('jefflau.eth', 'description'),
-      ENSInstance.getAddr.batch('jefflau.eth'),
-      ENSInstance.getName.batch('0x866B3c4994e1416B7C738B9818b31dC246b95eEE'),
+    const result = await ensInstance.batch(
+      ensInstance.getText.batch('with-profile.eth', 'description'),
+      ensInstance.getAddr.batch('with-profile.eth'),
+      ensInstance.getName.batch('0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC'),
     )
     expect(result).toBeTruthy()
     if (result) {
       expect(result[0]).toBe('Hello2')
-      expect(result[1]).toBe('0x866B3c4994e1416B7C738B9818b31dC246b95eEE')
+      expect(result[1]).toBe('0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC')
       expect(result[2]).toMatchObject({
-        name: 'jefflau.eth',
+        name: 'with-profile.eth',
         match: true,
       })
     }
   })
   it('should batch a single call', async () => {
-    const result = await ENSInstance.batch(
-      ENSInstance.getText.batch('jefflau.eth', 'description'),
+    const result = await ensInstance.batch(
+      ensInstance.getText.batch('with-profile.eth', 'description'),
     )
     expect(result).toBeTruthy()
     if (result) {

package/src/functions/batch.ts

@@ -1,3 +1,4 @@
+import { TransactionRequest } from '@ethersproject/abstract-provider'
 import { BatchFunctionResult, ENSArgs, RawFunction } from '..'
 
 const raw = async (
@@ -5,28 +6,37 @@ const raw = async (
   ...items: BatchFunctionResult<RawFunction>[]
 ) => {
   const rawDataArr: { to: string; data: string }[] = await Promise.all(
-    items.map(({ args, raw }, i: number) => {
-      if (!raw) {
+    items.map(({ args, raw: rawRef }, i: number) => {
+      if (!rawRef) {
         throw new Error(`Function ${i} is not batchable`)
       }
-      return raw(...args)
+      return rawRef(...args)
     }),
   )
-  return multicallWrapper.raw(rawDataArr)
+  const response = await multicallWrapper.raw(rawDataArr)
+  return { ...response, passthrough: rawDataArr }
 }
 
 const decode = async (
   { multicallWrapper }: ENSArgs<'multicallWrapper'>,
   data: string,
+  passthrough: TransactionRequest & { passthrough?: any }[],
   ...items: BatchFunctionResult<RawFunction>[]
 ): Promise<any[] | undefined> => {
-  const response = await multicallWrapper.decode(data)
+  const response = await multicallWrapper.decode(data, passthrough)
   if (!response) return
 
   return Promise.all(
-    response.map((ret: any, i: number) =>
-      items[i].decode(ret.returnData, ...items[i].args),
-    ),
+    response.map((ret: any, i: number) => {
+      if (passthrough[i].passthrough) {
+        return items[i].decode(
+          ret.returnData,
+          passthrough[i].passthrough,
+          ...items[i].args,
+        )
+      }
+      return items[i].decode(ret.returnData, ...items[i].args)
+    }),
   )
 }
 

package/src/functions/batchWrappers.test.ts

@@ -1,31 +1,31 @@
 import { ENS } from '..'
 import setup from '../tests/setup'
 
-let ENSInstance: ENS
+let ensInstance: ENS
 
 beforeAll(async () => {
-  ;({ ENSInstance } = await setup())
+  ;({ ensInstance } = await setup())
 })
 
 describe('batchWrappers', () => {
   it('should batch calls together', async () => {
-    const batch = await ENSInstance.resolverMulticallWrapper.raw([
-      await ENSInstance._getText.raw('jefflau.eth', 'description'),
-      await ENSInstance._getText.raw('jefflau.eth', 'url'),
-      await ENSInstance._getAddr.raw('jefflau.eth'),
+    const batch = await ensInstance.resolverMulticallWrapper.raw([
+      await ensInstance._getText.raw('with-profile.eth', 'description'),
+      await ensInstance._getText.raw('with-profile.eth', 'url'),
+      await ensInstance._getAddr.raw('with-profile.eth'),
     ])
-    const universalResponse = await ENSInstance.universalWrapper(
-      'jefflau.eth',
+    const universalResponse = await ensInstance.universalWrapper(
+      'with-profile.eth',
       batch.data,
     )
-    const [batchDecoded] = await ENSInstance.resolverMulticallWrapper.decode(
+    const [batchDecoded] = await ensInstance.resolverMulticallWrapper.decode(
       universalResponse?.data,
     )
-    const decoded1 = await ENSInstance._getText.decode(batchDecoded[0])
-    const decoded2 = await ENSInstance._getText.decode(batchDecoded[1])
-    const decoded3 = await ENSInstance._getAddr.decode(batchDecoded[2])
+    const decoded1 = await ensInstance._getText.decode(batchDecoded[0])
+    const decoded2 = await ensInstance._getText.decode(batchDecoded[1])
+    const decoded3 = await ensInstance._getAddr.decode(batchDecoded[2])
     expect(decoded1).toBe('Hello2')
     expect(decoded2).toBe('twitter.com')
-    expect(decoded3).toBe('0x866B3c4994e1416B7C738B9818b31dC246b95eEE')
+    expect(decoded3).toBe('0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC')
   })
 })