@ensdomains/ensjs 2.0.0 → 3.0.0-alpha.1

package/src/index.ts

@@ -0,0 +1,506 @@
+import { ethers } from 'ethers'
+import ContractManager from './contracts'
+import { getContractAddress as _getContractAddress } from './contracts/getContractAddress'
+import { SupportedNetworkId } from './contracts/types'
+import type batch from './functions/batch'
+import type {
+  multicallWrapper,
+  resolverMulticallWrapper,
+  universalWrapper,
+} from './functions/batchWrappers'
+import type burnFuses from './functions/burnFuses'
+import type createSubname from './functions/createSubname'
+import type deleteSubname from './functions/deleteSubname'
+import type getExpiry from './functions/getExpiry'
+import type getFuses from './functions/getFuses'
+import type {
+  getHistory,
+  getHistoryDetailForTransactionHash,
+  getHistoryWithDetail,
+} from './functions/getHistory'
+import type getName from './functions/getName'
+import type getNames from './functions/getNames'
+import type getOwner from './functions/getOwner'
+import type getPrice from './functions/getPrice'
+import type getProfile from './functions/getProfile'
+import type getRecords from './functions/getRecords'
+import type getResolver from './functions/getResolver'
+import type {
+  getAddr,
+  getContentHash,
+  getText,
+  _getAddr,
+  _getContentHash,
+  _getText,
+} from './functions/getSpecificRecord'
+import type getSubnames from './functions/getSubnames'
+import type setName from './functions/setName'
+import type setRecords from './functions/setRecords'
+import type setResolver from './functions/setResolver'
+import type transferName from './functions/transferName'
+import type transferSubname from './functions/transferSubname'
+import type unwrapName from './functions/unwrapName'
+import type wrapName from './functions/wrapName'
+import GqlManager from './GqlManager'
+import singleCall from './utils/singleCall'
+
+type ENSOptions = {
+  graphURI?: string | null
+  getContractAddress?: typeof _getContractAddress
+}
+
+export type InternalENS = {
+  options?: ENSOptions
+  provider?: ethers.providers.Provider
+  graphURI?: string | null
+} & ENS
+
+export type ENSArgs<K extends keyof InternalENS> = {
+  [P in K]: InternalENS[P]
+}
+
+type OmitFirstArg<F> = F extends (x: any, ...args: infer P) => infer R
+  ? (...args: P) => R
+  : never
+
+type OmitFirstTwoArgs<F> = F extends (
+  x: any,
+  y: any,
+  ...args: infer P
+) => infer R
+  ? (...args: P) => R
+  : never
+
+type FirstArg<F> = F extends (x: infer A, ...args: any[]) => any ? A : never
+
+type FunctionDeps<F> = Extract<keyof FirstArg<F>, string>[]
+
+const graphURIEndpoints: Record<string, string> = {
+  1: 'https://api.thegraph.com/subgraphs/name/ensdomains/ens',
+  3: 'https://api.thegraph.com/subgraphs/name/ensdomains/ensropsten',
+  4: 'https://api.thegraph.com/subgraphs/name/ensdomains/ensrinkeby',
+  5: 'https://api.thegraph.com/subgraphs/name/ensdomains/ensgoerli',
+}
+
+export type RawFunction = {
+  raw: (...args: any[]) => Promise<{ to: string; data: string }>
+  decode: (...args: any[]) => Promise<any>
+}
+
+export type BatchFunctionResult<F extends RawFunction> = {
+  args: Parameters<OmitFirstArg<F['raw']>>
+  raw: F['raw']
+  decode: F['decode']
+}
+
+type BatchFunction<F extends RawFunction> = (
+  ...args: Parameters<OmitFirstArg<F['raw']>>
+) => BatchFunctionResult<F>
+
+export type RawFunctionWithBatch = {
+  batch: BatchFunction<any>
+} & RawFunction
+
+interface GeneratedRawFunction<F extends RawFunction>
+  extends Function,
+    RawFunction {
+  (...args: Parameters<OmitFirstArg<F['raw']>>): ReturnType<
+    OmitFirstTwoArgs<F['decode']>
+  >
+  batch: BatchFunction<F>
+}
+
+type CombineFunctionDeps<F> = F extends RawFunction
+  ? FunctionDeps<F['raw']> | FunctionDeps<F['decode']>
+  : never
+
+export interface GenericGeneratedRawFunction
+  extends Function,
+    RawFunctionWithBatch {}
+
+export class ENS {
+  [x: string]: any
+  protected options?: ENSOptions
+  protected provider?: ethers.providers.JsonRpcProvider
+  protected graphURI?: string | null
+  protected initialProvider?: ethers.providers.JsonRpcProvider
+  contracts?: ContractManager
+  getContractAddress = _getContractAddress
+  gqlInstance = new GqlManager()
+
+  constructor(options?: ENSOptions) {
+    this.options = options
+    this.getContractAddress = options?.getContractAddress || _getContractAddress
+  }
+
+  /**
+   * Checks for an initial provider and if it exists, sets it as the provider
+   * @returns {Promise<void>} - A promise that resolves when the provider is checked, and set if needed
+   */
+  private checkInitialProvider = async (): Promise<void> => {
+    if (!this.initialProvider) {
+      return
+    }
+    await this.setProvider(this.initialProvider)
+    return
+  }
+
+  /**
+   * Creates an object of ENS properties from an array
+   * @param {FunctionDeps} dependencies - An array of ENS properties
+   * @returns {Object} - An object of ENS properties
+   */
+  private forwardDependenciesFromArray = <F>(
+    dependencies: FunctionDeps<F>,
+  ): object =>
+    // Creates an object from entries of the array
+    Object.fromEntries(
+      // Maps over dependencies and create arrays for each, e.g. ['contracts', contractObj]
+      dependencies.map((dep) => [dep, this[dep as keyof InternalENS]]),
+    )
+
+  /**
+   * Creates a wrapper for a function to be dynamically imported, with the correct dependencies passed in
+   * @param {string} path - The path of the exported function
+   * @param {FunctionDeps} dependencies - An array of ENS properties
+   * @param {string} exportName - The export name of the target function
+   * @param {string} subFunc - The type of function being imported
+   * @returns {Function} - The generated wrapped function
+   */
+  private importGenerator = <F>(
+    path: string,
+    dependencies: FunctionDeps<F>,
+    exportName: string = 'default',
+    subFunc?: 'raw' | 'decode' | 'combine' | 'batch',
+    passthrough?: RawFunction,
+  ): Function => {
+    // if batch is specified, create batch func
+    if (subFunc === 'batch') {
+      return (...args: any[]) => ({ args, ...passthrough })
+    }
+
+    const thisRef = this
+    const mainFunc = async function (...args: any[]) {
+      // check the initial provider and set if it exists
+      await thisRef.checkInitialProvider()
+      // import the module dynamically
+      const mod = await import(
+        /* webpackMode: "lazy", webpackChunkName: "[request]", webpackPreload: true */
+        `./functions/${path}`
+      )
+
+      // if combine isn't specified, run normally
+      // otherwise, create a function from the raw and decode functions
+      if (subFunc !== 'combine') {
+        // get the function to call
+        const func = subFunc ? mod[exportName][subFunc] : mod[exportName]
+        // get the dependencies to forward to the function as the first arg
+        const dependenciesToForward =
+          thisRef.forwardDependenciesFromArray<F>(dependencies)
+        // return the function with the dependencies forwarded
+        return func(dependenciesToForward, ...args)
+      } else {
+        // get the dependencies to forward from raw and decode functions
+        const dependenciesToForward = thisRef.forwardDependenciesFromArray<
+          CombineFunctionDeps<F>
+        >(dependencies as any)
+
+        // return singleCall function with dependencies forwarded
+        return singleCall(
+          thisRef.provider!,
+          dependenciesToForward,
+          mod[exportName],
+          ...args,
+        )
+      }
+    }
+
+    // if subfunc is combine, add raw and decode property methods to the function
+    if (subFunc === 'combine') {
+      mainFunc.raw = this.importGenerator<F>(
+        path,
+        dependencies,
+        exportName,
+        'raw',
+      )
+      mainFunc.decode = this.importGenerator<F>(
+        path,
+        dependencies,
+        exportName,
+        'decode',
+      ) as (data: any, ...args: any[]) => Promise<any>
+      mainFunc.batch = this.importGenerator<F>(
+        path,
+        dependencies,
+        exportName,
+        'batch',
+        { raw: mainFunc.raw as any, decode: mainFunc.decode as any },
+      )
+    }
+
+    return mainFunc as Function
+  }
+
+  /**
+   * Generates a normal wrapped function
+   * @param {string} path - The path of the exported function
+   * @param {FunctionDeps} dependencies - An array of ENS properties
+   * @param {string} exportName - The export name of the target function
+   * @returns {OmitFirstArg} - The generated wrapped function
+   */
+  private generateFunction = <F>(
+    path: string,
+    dependencies: FunctionDeps<F>,
+    exportName: string = 'default',
+  ): OmitFirstArg<F> =>
+    this.importGenerator<F>(path, dependencies, exportName) as OmitFirstArg<F>
+
+  /**
+   * Generates a wrapped function from raw and decode exports
+   * @param {string} path - The path of the exported function
+   * @param {FunctionDeps} dependencies - An array of ENS properties
+   * @param {string} exportName - The export name of the target function
+   * @returns {GeneratedRawFunction} - The generated wrapped function
+   */
+  private generateRawFunction = <F extends RawFunction>(
+    path: string,
+    dependencies: FunctionDeps<F['raw']> | FunctionDeps<F['decode']>,
+    exportName: string = 'default',
+  ): GeneratedRawFunction<F> =>
+    this.importGenerator<F>(
+      path,
+      dependencies as any,
+      exportName,
+      'combine',
+    ) as GeneratedRawFunction<F>
+
+  /**
+   * Sets the provider for the ENS class
+   * @param {ethers.providers.JsonRpcProvider} provider - The provider to set
+   * @returns {Promise<void>} - A promise that resolves when the provider is set
+   */
+  public setProvider = async (
+    provider: ethers.providers.JsonRpcProvider,
+  ): Promise<void> => {
+    this.provider = provider
+    const network = (await this.provider.getNetwork()).chainId
+    if (this.options && this.options.graphURI) {
+      this.graphURI = this.options.graphURI
+    } else {
+      this.graphURI = graphURIEndpoints[network]
+    }
+    await this.gqlInstance.setUrl(this.graphURI)
+    this.contracts = new ContractManager(
+      this.provider,
+      this.getContractAddress(String(network) as SupportedNetworkId),
+    )
+    return
+  }
+
+  /**
+   * Creates a new ENS instance with a different provider, ideally should be used individually with any given function
+   * @param {ethers.providers.JsonRpcProvider} provider - The provider to use
+   * @returns {ENS} - A new ENS instance with the given provider
+   */
+  public withProvider = (provider: ethers.providers.JsonRpcProvider): ENS => {
+    const newENS = new ENS(this.options)
+    newENS.initialProvider = provider
+    return newENS
+  }
+
+  public batch = this.generateRawFunction<typeof batch>(
+    'initialGetters',
+    ['multicallWrapper'],
+    'batch',
+  )
+
+  public getProfile = this.generateFunction<typeof getProfile>(
+    'initialGetters',
+    [
+      'contracts',
+      'gqlInstance',
+      'getName',
+      'resolverMulticallWrapper',
+      '_getAddr',
+      '_getContentHash',
+      '_getText',
+    ],
+    'getProfile',
+  )
+
+  public getRecords = this.generateFunction<typeof getRecords>(
+    'initialGetters',
+    ['getProfile'],
+    'getRecords',
+  )
+
+  public getName = this.generateRawFunction<typeof getName>(
+    'initialGetters',
+    ['contracts'],
+    'getName',
+  )
+
+  public getResolver = this.generateRawFunction<typeof getResolver>(
+    'getResolver',
+    ['contracts'],
+  )
+
+  public getFuses = this.generateRawFunction<typeof getFuses>('getFuses', [
+    'contracts',
+  ])
+
+  public getHistory = this.generateFunction<typeof getHistory>(
+    'getHistory',
+    ['gqlInstance'],
+    'getHistory',
+  )
+
+  public getHistoryWithDetail = this.generateFunction<
+    typeof getHistoryWithDetail
+  >(
+    'getHistory',
+    ['contracts', 'gqlInstance', 'provider'],
+    'getHistoryWithDetail',
+  )
+
+  public getHistoryDetailForTransactionHash = this.generateFunction<
+    typeof getHistoryDetailForTransactionHash
+  >(
+    'getHistory',
+    ['contracts', 'provider'],
+    'getHistoryDetailForTransactionHash',
+  )
+
+  public getContentHash = this.generateRawFunction<typeof getContentHash>(
+    'initialGetters',
+    ['contracts', 'universalWrapper'],
+    'getContentHash',
+  )
+
+  public _getContentHash = this.generateRawFunction<typeof _getContentHash>(
+    'initialGetters',
+    ['contracts'],
+    '_getContentHash',
+  )
+
+  public getAddr = this.generateRawFunction<typeof getAddr>(
+    'initialGetters',
+    ['contracts', 'universalWrapper'],
+    'getAddr',
+  )
+
+  public _getAddr = this.generateRawFunction<typeof _getAddr>(
+    'initialGetters',
+    ['contracts'],
+    '_getAddr',
+  )
+
+  public getText = this.generateRawFunction<typeof getText>(
+    'initialGetters',
+    ['contracts', 'universalWrapper'],
+    'getText',
+  )
+
+  public _getText = this.generateRawFunction<typeof _getText>(
+    'initialGetters',
+    ['contracts'],
+    '_getText',
+  )
+
+  public getOwner = this.generateRawFunction<typeof getOwner>(
+    'initialGetters',
+    ['contracts', 'multicallWrapper'],
+    'getOwner',
+  )
+
+  public getExpiry = this.generateRawFunction<typeof getExpiry>(
+    'initialGetters',
+    ['contracts', 'multicallWrapper'],
+    'getExpiry',
+  )
+
+  public getSubnames = this.generateFunction<typeof getSubnames>(
+    'initialGetters',
+    ['gqlInstance'],
+    'getSubnames',
+  )
+
+  public getNames = this.generateFunction<typeof getNames>(
+    'initialGetters',
+    ['gqlInstance'],
+    'getNames',
+  )
+
+  public getPrice = this.generateRawFunction<typeof getPrice>(
+    'initialGetters',
+    ['contracts', 'multicallWrapper'],
+    'getPrice',
+  )
+
+  public universalWrapper = this.generateRawFunction<typeof universalWrapper>(
+    'initialGetters',
+    ['contracts'],
+    'universalWrapper',
+  )
+
+  public resolverMulticallWrapper = this.generateRawFunction<
+    typeof resolverMulticallWrapper
+  >('initialGetters', ['contracts'], 'resolverMulticallWrapper')
+
+  public multicallWrapper = this.generateRawFunction<typeof multicallWrapper>(
+    'initialGetters',
+    ['contracts'],
+    'multicallWrapper',
+  )
+
+  public setName = this.generateFunction<typeof setName>('setName', [
+    'contracts',
+    'provider',
+  ])
+
+  public setRecords = this.generateFunction<typeof setRecords>('setRecords', [
+    'contracts',
+    'provider',
+    'getResolver',
+  ])
+
+  public setResolver = this.generateFunction<typeof setResolver>(
+    'setResolver',
+    ['contracts', 'provider'],
+  )
+
+  public transferName = this.generateFunction<typeof transferName>(
+    'transferName',
+    ['contracts', 'provider'],
+  )
+
+  public wrapName = this.generateFunction<typeof wrapName>('wrapName', [
+    'contracts',
+    'provider',
+  ])
+
+  public unwrapName = this.generateFunction<typeof unwrapName>('unwrapName', [
+    'contracts',
+    'provider',
+  ])
+
+  public burnFuses = this.generateFunction<typeof burnFuses>('burnFuses', [
+    'contracts',
+    'provider',
+  ])
+
+  public createSubname = this.generateFunction<typeof createSubname>(
+    'createSubname',
+    ['contracts', 'provider'],
+  )
+
+  public deleteSubname = this.generateFunction<typeof deleteSubname>(
+    'deleteSubname',
+    ['contracts', 'provider', 'transferSubname'],
+  )
+
+  public transferSubname = this.generateFunction<typeof transferSubname>(
+    'transferSubname',
+    ['contracts', 'provider'],
+  )
+}

package/src/tests/batch.test.ts

@@ -0,0 +1,36 @@
+import { ENS } from '..'
+import setup from './setup'
+
+let ENSInstance: ENS
+
+beforeAll(async () => {
+  ;({ 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'),
+    )
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result[0]).toBe('Hello2')
+      expect(result[1]).toBe('0x866B3c4994e1416B7C738B9818b31dC246b95eEE')
+      expect(result[2]).toMatchObject({
+        name: 'jefflau.eth',
+        match: true,
+      })
+    }
+  })
+  it('should batch a single call', async () => {
+    const result = await ENSInstance.batch(
+      ENSInstance.getText.batch('jefflau.eth', 'description'),
+    )
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result[0]).toBe('Hello2')
+    }
+  })
+})

package/src/tests/batchWrappers.test.ts

@@ -0,0 +1,31 @@
+import { ENS } from '..'
+import setup from './setup'
+
+let ENSInstance: ENS
+
+beforeAll(async () => {
+  ;({ 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 universalResponse = await ENSInstance.universalWrapper(
+      'jefflau.eth',
+      batch.data,
+    )
+    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])
+    expect(decoded1).toBe('Hello2')
+    expect(decoded2).toBe('twitter.com')
+    expect(decoded3).toBe('0x866B3c4994e1416B7C738B9818b31dC246b95eEE')
+  })
+})

package/src/tests/burnFuses.test.ts

@@ -0,0 +1,43 @@
+import { BigNumber, ethers, utils } from 'ethers'
+import { ENS } from '..'
+import setup from './setup'
+
+let ENSInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
+let provider: ethers.providers.JsonRpcProvider
+let accounts: string[]
+
+beforeAll(async () => {
+  ;({ ENSInstance, revert, provider } = await setup())
+  accounts = await provider.listAccounts()
+})
+
+afterAll(async () => {
+  await revert()
+})
+
+describe('burnFuses', () => {
+  beforeEach(async () => {
+    await revert()
+  })
+  it('should return a burnFuses transaction and succeed', async () => {
+    const wrapNameTx = await ENSInstance.wrapName(
+      'parthtejpal.eth',
+      accounts[0],
+    )
+    await wrapNameTx.wait()
+
+    const tx = await ENSInstance.burnFuses('parthtejpal.eth', {
+      cannotUnwrap: true,
+      cannotCreateSubdomain: true,
+      cannotSetTtl: true,
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
+    const result = await nameWrapper.getFuses(utils.namehash('parthtejpal.eth'))
+    const fuseBN = result.fuses as BigNumber
+    expect(fuseBN.toHexString()).toBe('0x71')
+  })
+})

package/src/tests/createSubname.test.ts

@@ -0,0 +1,59 @@
+import { ethers, utils } from 'ethers'
+import { ENS } from '..'
+import setup from './setup'
+
+let ENSInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
+let createSnapshot: Awaited<ReturnType<typeof setup>>['createSnapshot']
+let provider: ethers.providers.JsonRpcProvider
+let accounts: string[]
+
+beforeAll(async () => {
+  ;({ ENSInstance, revert, createSnapshot, provider } = await setup())
+  accounts = await provider.listAccounts()
+})
+
+afterAll(async () => {
+  await revert()
+})
+
+describe('createSubname', () => {
+  beforeEach(async () => {
+    await revert()
+  })
+  it('should allow creating a subname on the registry', async () => {
+    const tx = await ENSInstance.createSubname({
+      contract: 'registry',
+      name: 'test.parthtejpal.eth',
+      owner: accounts[0],
+      options: { addressOrIndex: 0 },
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const registry = await ENSInstance.contracts!.getRegistry()!
+    const result = await registry.owner(utils.namehash('test.parthtejpal.eth'))
+    expect(result).toBe(accounts[0])
+  })
+  it('should allow creating a subname on the namewrapper', async () => {
+    const wrapNameTx = await ENSInstance.wrapName(
+      'parthtejpal.eth',
+      accounts[0],
+    )
+    await wrapNameTx.wait()
+    const tx = await ENSInstance.createSubname({
+      contract: 'nameWrapper',
+      name: 'test.parthtejpal.eth',
+      owner: accounts[0],
+      options: { addressOrIndex: 0 },
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
+    const result = await nameWrapper.ownerOf(
+      utils.namehash('test.parthtejpal.eth'),
+    )
+    expect(result).toBe(accounts[0])
+  })
+})