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

package/src/index.ts

@@ -1,49 +1,28 @@
-import { ethers } from 'ethers'
-import ContractManager from './contracts'
+import {
+  ContractTransaction,
+  PopulatedTransaction,
+} from '@ethersproject/contracts'
+import type {
+  JsonRpcProvider,
+  JsonRpcSigner,
+  Provider,
+} from '@ethersproject/providers'
 import { getContractAddress as _getContractAddress } from './contracts/getContractAddress'
+import ContractManager from './contracts/index'
 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 type getDNSOwner from './functions/getDNSOwner'
+import type FunctionTypes from './functions/types'
 import GqlManager from './GqlManager'
 import singleCall from './utils/singleCall'
+import writeTx from './utils/writeTx'
+
+export type {
+  Fuse,
+  FuseArrayPossibilities,
+  FuseObj,
+  NamedFusesToBurn,
+  UnnamedFuseType,
+  UnnamedFuseValues,
+} from './utils/fuses'
 
 type ENSOptions = {
   graphURI?: string | null
@@ -52,7 +31,8 @@ type ENSOptions = {
 
 export type InternalENS = {
   options?: ENSOptions
-  provider?: ethers.providers.Provider
+  provider?: Provider
+  signer: JsonRpcSigner
   graphURI?: string | null
 } & ENS
 
@@ -76,12 +56,40 @@ 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> = {
+type WriteOptions = {
+  addressOrIndex?: string | number
+  signer?: JsonRpcSigner
+}
+
+type OptionalWriteOptions<F> = F extends (
+  x: any,
+  arg_0: infer Z,
+  options?: infer P,
+) => infer R
+  ? (name: Z, options?: P & WriteOptions) => R
+  : F extends (x: any, arg_0: infer Z, options: infer P) => infer R
+  ? (name: Z, options: P & WriteOptions) => R
+  : never
+
+interface WriteFunction<F extends (...args: any) => any> extends Function {
+  (...args: Parameters<OptionalWriteOptions<F>>): Promise<
+    ContractTransaction & {
+      customData?: Record<string, any>
+    }
+  >
+  populateTransaction: (
+    ...args: Parameters<OptionalWriteOptions<F>>
+  ) => Promise<PopulatedTransaction>
+}
+
+/* eslint-disable @typescript-eslint/naming-convention */
+export 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',
 }
+/* eslint-enable @typescript-eslint/naming-convention */
 
 export type RawFunction = {
   raw: (...args: any[]) => Promise<{ to: string; data: string }>
@@ -119,14 +127,43 @@ export interface GenericGeneratedRawFunction
   extends Function,
     RawFunctionWithBatch {}
 
+interface GeneratedBatchFunction<F extends RawFunction>
+  extends Function,
+    RawFunction {
+  <I extends BatchFunctionResult<RawFunction>[]>(...args: I): Promise<
+    | {
+        [N in keyof I]: I[N] extends BatchFunctionResult<infer U>
+          ? Awaited<ReturnType<U['decode']>>
+          : never
+      }
+    | undefined
+  >
+  batch: BatchFunction<F>
+}
+
+export type FunctionSubtype =
+  | 'raw'
+  | 'decode'
+  | 'combine'
+  | 'batch'
+  | 'write'
+  | 'populateTransaction'
+
 export class ENS {
   [x: string]: any
+
   protected options?: ENSOptions
-  protected provider?: ethers.providers.JsonRpcProvider
+
+  protected provider?: JsonRpcProvider
+
   protected graphURI?: string | null
-  protected initialProvider?: ethers.providers.JsonRpcProvider
+
+  protected initialProvider?: JsonRpcProvider
+
   contracts?: ContractManager
+
   getContractAddress = _getContractAddress
+
   gqlInstance = new GqlManager()
 
   constructor(options?: ENSOptions) {
@@ -143,7 +180,6 @@ export class ENS {
       return
     }
     await this.setProvider(this.initialProvider)
-    return
   }
 
   /**
@@ -151,7 +187,7 @@ export class ENS {
    * @param {FunctionDeps} dependencies - An array of ENS properties
    * @returns {Object} - An object of ENS properties
    */
-  private forwardDependenciesFromArray = <F>(
+  protected forwardDependenciesFromArray = <F>(
     dependencies: FunctionDeps<F>,
   ): object =>
     // Creates an object from entries of the array
@@ -160,6 +196,30 @@ export class ENS {
       dependencies.map((dep) => [dep, this[dep as keyof InternalENS]]),
     )
 
+  // eslint-disable-next-line class-methods-use-this
+  protected getModule = async (path: string, exportName: string) => {
+    let mod = await import(
+      /* webpackMode: "lazy", webpackChunkName: "[request]", webpackPreload: true, webpackExclude: /.*\.ts$/ */
+      `./functions/${path}`
+    )
+
+    // if export is nested in default, use default
+    if (mod.default?.[exportName]) {
+      mod = mod.default
+    }
+    return mod
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  protected getFunction = (
+    subFunc: FunctionSubtype | undefined,
+    writeable: boolean | undefined,
+    exportName: string,
+    mod: any,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _path: string,
+  ) => (subFunc && !writeable ? mod[exportName][subFunc] : mod[exportName])
+
   /**
    * 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
@@ -172,7 +232,7 @@ export class ENS {
     path: string,
     dependencies: FunctionDeps<F>,
     exportName: string = 'default',
-    subFunc?: 'raw' | 'decode' | 'combine' | 'batch',
+    subFunc?: FunctionSubtype,
     passthrough?: RawFunction,
   ): Function => {
     // if batch is specified, create batch func
@@ -185,35 +245,58 @@ export class ENS {
       // 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}`
-      )
+      const mod = await thisRef.getModule(path, exportName)
 
       // if combine isn't specified, run normally
       // otherwise, create a function from the raw and decode functions
       if (subFunc !== 'combine') {
+        const writeable =
+          subFunc === 'write' || subFunc === 'populateTransaction'
         // get the function to call
-        const func = subFunc ? mod[exportName][subFunc] : mod[exportName]
+        const func = thisRef.getFunction(
+          subFunc,
+          writeable,
+          exportName,
+          mod,
+          path,
+        )
         // get the dependencies to forward to the function as the first arg
-        const dependenciesToForward =
+        let dependenciesToForward =
           thisRef.forwardDependenciesFromArray<F>(dependencies)
+
+        // if func is write func, inject signer into dependencies
+        if (writeable) {
+          const options = (args[1] || {}) as WriteOptions
+          const signer =
+            options.signer ||
+            thisRef.provider?.getSigner(options.addressOrIndex)
+          const populate = subFunc === 'populateTransaction'
+          if (!signer) {
+            throw new Error('No signer specified')
+          }
+          delete options.addressOrIndex
+          delete options.signer
+          dependenciesToForward = { ...dependenciesToForward, signer }
+          return func(dependenciesToForward, args[0], options).then(
+            writeTx(signer, populate),
+          )
+        }
+
         // 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,
-        )
       }
+      // 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,
+        thisRef.getFunction(undefined, undefined, exportName, mod, path),
+        ...args,
+      )
     }
 
     // if subfunc is combine, add raw and decode property methods to the function
@@ -237,6 +320,13 @@ export class ENS {
         'batch',
         { raw: mainFunc.raw as any, decode: mainFunc.decode as any },
       )
+    } else if (subFunc === 'write') {
+      mainFunc.populateTransaction = this.importGenerator<F>(
+        path,
+        dependencies,
+        exportName,
+        'populateTransaction',
+      )
     }
 
     return mainFunc as Function
@@ -256,6 +346,25 @@ export class ENS {
   ): OmitFirstArg<F> =>
     this.importGenerator<F>(path, dependencies, exportName) as OmitFirstArg<F>
 
+  /**
+   * Generates a write 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 generateWriteFunction = <F extends (...args: any) => any>(
+    path: string,
+    dependencies: FunctionDeps<F>,
+    exportName: string = 'default',
+  ): WriteFunction<F> =>
+    this.importGenerator<F>(
+      path,
+      dependencies,
+      exportName,
+      'write',
+    ) as WriteFunction<F>
+
   /**
    * Generates a wrapped function from raw and decode exports
    * @param {string} path - The path of the exported function
@@ -277,14 +386,14 @@ export class ENS {
 
   /**
    * Sets the provider for the ENS class
-   * @param {ethers.providers.JsonRpcProvider} provider - The provider to set
+   * @param {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> => {
+  public setProvider = async (provider: JsonRpcProvider): Promise<void> => {
     this.provider = provider
-    const network = (await this.provider.getNetwork()).chainId
+    const network = this.staticNetwork
+      ? this.provider._network.chainId
+      : (await this.provider.getNetwork()).chainId
     if (this.options && this.options.graphURI) {
       this.graphURI = this.options.graphURI
     } else {
@@ -295,27 +404,26 @@ export class ENS {
       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
+   * @param {JsonRpcProvider} provider - The provider to use
    * @returns {ENS} - A new ENS instance with the given provider
    */
-  public withProvider = (provider: ethers.providers.JsonRpcProvider): ENS => {
+  public withProvider = (provider: JsonRpcProvider): ENS => {
     const newENS = new ENS(this.options)
     newENS.initialProvider = provider
     return newENS
   }
 
-  public batch = this.generateRawFunction<typeof batch>(
+  public batch = this.generateRawFunction<FunctionTypes['batch']>(
     'initialGetters',
     ['multicallWrapper'],
     'batch',
-  )
+  ) as GeneratedBatchFunction<FunctionTypes['batch']>
 
-  public getProfile = this.generateFunction<typeof getProfile>(
+  public getProfile = this.generateFunction<FunctionTypes['getProfile']>(
     'initialGetters',
     [
       'contracts',
@@ -330,184 +438,209 @@ export class ENS {
     'getProfile',
   )
 
-  public getRecords = this.generateFunction<typeof getRecords>(
+  public getRecords = this.generateFunction<FunctionTypes['getRecords']>(
     'initialGetters',
     ['getProfile'],
     'getRecords',
   )
 
-  public getName = this.generateRawFunction<typeof getName>(
+  public getName = this.generateRawFunction<FunctionTypes['getName']>(
     'initialGetters',
     ['contracts'],
     'getName',
   )
 
-  public getResolver = this.generateRawFunction<typeof getResolver>(
+  public getResolver = this.generateRawFunction<FunctionTypes['getResolver']>(
     'getResolver',
     ['contracts'],
   )
 
-  public getFuses = this.generateRawFunction<typeof getFuses>('getFuses', [
-    'contracts',
-  ])
+  public getWrapperData = this.generateRawFunction<
+    FunctionTypes['getWrapperData']
+  >('getWrapperData', ['contracts'])
 
-  public getHistory = this.generateFunction<typeof getHistory>(
+  public getHistory = this.generateFunction<FunctionTypes['getHistory']>(
     'getHistory',
     ['gqlInstance'],
     'getHistory',
   )
 
-  public getHistoryWithDetail = this.generateFunction<
-    typeof getHistoryWithDetail
-  >(
-    'getHistory',
-    ['contracts', 'gqlInstance', 'provider'],
-    'getHistoryWithDetail',
-  )
+  public getContentHash = this.generateRawFunction<
+    FunctionTypes['getContentHash']
+  >('initialGetters', ['contracts', 'universalWrapper'], 'getContentHash')
 
-  public getHistoryDetailForTransactionHash = this.generateFunction<
-    typeof getHistoryDetailForTransactionHash
-  >(
-    'getHistory',
-    ['contracts', 'provider'],
-    'getHistoryDetailForTransactionHash',
-  )
+  public _getContentHash = this.generateRawFunction<
+    FunctionTypes['_getContentHash']
+  >('initialGetters', ['contracts'], '_getContentHash')
 
-  public getContentHash = this.generateRawFunction<typeof getContentHash>(
+  public getAddr = this.generateRawFunction<FunctionTypes['getAddr']>(
     'initialGetters',
     ['contracts', 'universalWrapper'],
-    'getContentHash',
+    'getAddr',
   )
 
-  public _getContentHash = this.generateRawFunction<typeof _getContentHash>(
+  public _getAddr = this.generateRawFunction<FunctionTypes['_getAddr']>(
     'initialGetters',
     ['contracts'],
-    '_getContentHash',
+    '_getAddr',
   )
 
-  public getAddr = this.generateRawFunction<typeof getAddr>(
+  public getText = this.generateRawFunction<FunctionTypes['getText']>(
     'initialGetters',
     ['contracts', 'universalWrapper'],
-    'getAddr',
+    'getText',
   )
 
-  public _getAddr = this.generateRawFunction<typeof _getAddr>(
+  public _getText = this.generateRawFunction<FunctionTypes['_getText']>(
     'initialGetters',
     ['contracts'],
-    '_getAddr',
+    '_getText',
   )
 
-  public getText = this.generateRawFunction<typeof getText>(
+  public getABI = this.generateRawFunction<FunctionTypes['getABI']>(
     'initialGetters',
     ['contracts', 'universalWrapper'],
-    'getText',
+    'getABI',
   )
 
-  public _getText = this.generateRawFunction<typeof _getText>(
+  public _getABI = this.generateRawFunction<FunctionTypes['_getABI']>(
     'initialGetters',
     ['contracts'],
-    '_getText',
+    '_getABI',
   )
 
-  public getOwner = this.generateRawFunction<typeof getOwner>(
+  public getOwner = this.generateRawFunction<FunctionTypes['getOwner']>(
     'initialGetters',
-    ['contracts', 'multicallWrapper'],
+    ['contracts', 'multicallWrapper', 'gqlInstance'],
     'getOwner',
   )
 
-  public getExpiry = this.generateRawFunction<typeof getExpiry>(
+  public getExpiry = this.generateRawFunction<FunctionTypes['getExpiry']>(
     'initialGetters',
     ['contracts', 'multicallWrapper'],
     'getExpiry',
   )
 
-  public getSubnames = this.generateFunction<typeof getSubnames>(
+  public getSubnames = this.generateFunction<FunctionTypes['getSubnames']>(
     'initialGetters',
     ['gqlInstance'],
     'getSubnames',
   )
 
-  public getNames = this.generateFunction<typeof getNames>(
+  public getNames = this.generateFunction<FunctionTypes['getNames']>(
     'initialGetters',
     ['gqlInstance'],
     'getNames',
   )
 
-  public getPrice = this.generateRawFunction<typeof getPrice>(
+  public getPrice = this.generateRawFunction<FunctionTypes['getPrice']>(
     'initialGetters',
     ['contracts', 'multicallWrapper'],
     'getPrice',
   )
 
-  public universalWrapper = this.generateRawFunction<typeof universalWrapper>(
+  public getDNSOwner = this.generateFunction<FunctionTypes['getDNSOwner']>(
+    'getDNSOwner',
+    [],
+  )
+
+  public supportsTLD = this.generateFunction<FunctionTypes['supportsTLD']>(
     'initialGetters',
+    ['getOwner', 'provider'],
+    'supportsTLD',
+  )
+
+  public getAvailable = this.generateRawFunction<FunctionTypes['getAvailable']>(
+    'getAvailable',
     ['contracts'],
-    'universalWrapper',
   )
 
+  public universalWrapper = this.generateRawFunction<
+    FunctionTypes['universalWrapper']
+  >('initialGetters', ['contracts'], 'universalWrapper')
+
   public resolverMulticallWrapper = this.generateRawFunction<
-    typeof resolverMulticallWrapper
+    FunctionTypes['resolverMulticallWrapper']
   >('initialGetters', ['contracts'], 'resolverMulticallWrapper')
 
-  public multicallWrapper = this.generateRawFunction<typeof multicallWrapper>(
-    'initialGetters',
+  public multicallWrapper = this.generateRawFunction<
+    FunctionTypes['multicallWrapper']
+  >('initialGetters', ['contracts'], 'multicallWrapper')
+
+  public setName = this.generateWriteFunction<FunctionTypes['setName']>(
+    'setName',
     ['contracts'],
-    'multicallWrapper',
   )
 
-  public setName = this.generateFunction<typeof setName>('setName', [
-    'contracts',
-    'provider',
-  ])
-
-  public setRecords = this.generateFunction<typeof setRecords>('setRecords', [
-    'contracts',
-    'provider',
-    'getResolver',
-  ])
+  public setRecords = this.generateWriteFunction<FunctionTypes['setRecords']>(
+    'setRecords',
+    ['contracts', 'provider', 'getResolver'],
+  )
 
-  public setResolver = this.generateFunction<typeof setResolver>(
-    'setResolver',
-    ['contracts', 'provider'],
+  public setRecord = this.generateWriteFunction<FunctionTypes['setRecord']>(
+    'setRecord',
+    ['contracts', 'provider', 'getResolver'],
   )
 
-  public transferName = this.generateFunction<typeof transferName>(
-    'transferName',
-    ['contracts', 'provider'],
+  public setResolver = this.generateWriteFunction<FunctionTypes['setResolver']>(
+    'setResolver',
+    ['contracts'],
   )
 
-  public wrapName = this.generateFunction<typeof wrapName>('wrapName', [
-    'contracts',
-    'provider',
-  ])
+  public transferName = this.generateWriteFunction<
+    FunctionTypes['transferName']
+  >('transferName', ['contracts'])
 
-  public unwrapName = this.generateFunction<typeof unwrapName>('unwrapName', [
-    'contracts',
-    'provider',
-  ])
+  public transferController = this.generateWriteFunction<
+    FunctionTypes['transferController']
+  >('transferController', ['contracts'])
 
-  public burnFuses = this.generateFunction<typeof burnFuses>('burnFuses', [
-    'contracts',
-    'provider',
-  ])
+  public wrapName = this.generateWriteFunction<FunctionTypes['wrapName']>(
+    'wrapName',
+    ['contracts', 'getExpiry'],
+  )
 
-  public createSubname = this.generateFunction<typeof createSubname>(
-    'createSubname',
-    ['contracts', 'provider'],
+  public unwrapName = this.generateWriteFunction<FunctionTypes['unwrapName']>(
+    'unwrapName',
+    ['contracts'],
   )
 
-  public deleteSubname = this.generateFunction<typeof deleteSubname>(
-    'deleteSubname',
-    ['contracts', 'provider', 'transferSubname'],
+  public burnFuses = this.generateWriteFunction<FunctionTypes['burnFuses']>(
+    'burnFuses',
+    ['contracts'],
   )
 
-  public transferSubname = this.generateFunction<typeof transferSubname>(
-    'transferSubname',
-    ['contracts', 'provider'],
+  public importDNSSECName = this.generateWriteFunction<
+    FunctionTypes['importDNSSECName']
+  >('importDNSSECName', ['contracts', 'provider', 'signer'])
+
+  public createSubname = this.generateWriteFunction<
+    FunctionTypes['createSubname']
+  >('createSubname', ['contracts', 'getExpiry'])
+
+  public deleteSubname = this.generateWriteFunction<
+    FunctionTypes['deleteSubname']
+  >('deleteSubname', ['contracts'])
+
+  public transferSubname = this.generateWriteFunction<
+    FunctionTypes['transferSubname']
+  >('transferSubname', ['contracts', 'getExpiry'])
+
+  public commitName = this.generateWriteFunction<FunctionTypes['commitName']>(
+    'commitName',
+    ['contracts'],
   )
 
-  public getDNSOwner = this.generateFunction<typeof getDNSOwner>(
-    'getDNSOwner',
-    [],
+  public registerName = this.generateWriteFunction<
+    FunctionTypes['registerName']
+  >('registerName', ['contracts'])
+
+  public renewNames = this.generateWriteFunction<FunctionTypes['renewNames']>(
+    'renewNames',
+    ['contracts'],
   )
+
+  public renewNameWithData = this.generateWriteFunction<
+    FunctionTypes['renewNameWithData']
+  >('renewNames', ['contracts'], 'renewNameWithData')
 }