@ensdomains/ensjs 3.0.0-alpha.3 → 3.0.0-alpha.31

package/src/index.ts

@@ -1,6 +1,7 @@
-import { ethers } from 'ethers'
-import ContractManager from './contracts'
+import type { JsonRpcSigner } from '@ethersproject/providers'
+import { ContractTransaction, ethers, PopulatedTransaction } from 'ethers'
 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 {
@@ -9,15 +10,12 @@ import type {
   universalWrapper,
 } from './functions/batchWrappers'
 import type burnFuses from './functions/burnFuses'
+import type commitName from './functions/commitName'
 import type createSubname from './functions/createSubname'
 import type deleteSubname from './functions/deleteSubname'
+import type getDNSOwner from './functions/getDNSOwner'
 import type getExpiry from './functions/getExpiry'
-import type getFuses from './functions/getFuses'
-import type {
-  getHistory,
-  getHistoryDetailForTransactionHash,
-  getHistoryWithDetail,
-} from './functions/getHistory'
+import type { getHistory } from './functions/getHistory'
 import type getName from './functions/getName'
 import type getNames from './functions/getNames'
 import type getOwner from './functions/getOwner'
@@ -34,16 +32,35 @@ import type {
   _getText,
 } from './functions/getSpecificRecord'
 import type getSubnames from './functions/getSubnames'
+import type getWrapperData from './functions/getWrapperData'
+import type registerName from './functions/registerName'
+import type {
+  // eslint-disable-next-line import/no-named-default
+  default as renewNames,
+  renewNameWithData,
+} from './functions/renewNames'
 import type setName from './functions/setName'
+import type setRecord from './functions/setRecord'
 import type setRecords from './functions/setRecords'
 import type setResolver from './functions/setResolver'
+import type transferController from './functions/transferController'
 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 GqlManager from './GqlManager'
 import singleCall from './utils/singleCall'
+import writeTx from './utils/writeTx'
+import importDNSSECName from './functions/importDNSSECName'
+
+export type {
+  Fuse,
+  FuseArrayPossibilities,
+  FuseObj,
+  NamedFusesToBurn,
+  UnnamedFuseType,
+  UnnamedFuseValues,
+} from './utils/fuses'
 
 type ENSOptions = {
   graphURI?: string | null
@@ -53,6 +70,7 @@ type ENSOptions = {
 export type InternalENS = {
   options?: ENSOptions
   provider?: ethers.providers.Provider
+  signer: JsonRpcSigner
   graphURI?: string | null
 } & ENS
 
@@ -76,12 +94,40 @@ type FirstArg<F> = F extends (x: infer A, ...args: any[]) => any ? A : never
 
 type FunctionDeps<F> = Extract<keyof FirstArg<F>, 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 */
 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 }>
@@ -121,12 +167,19 @@ export interface GenericGeneratedRawFunction
 
 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) {
@@ -143,7 +196,6 @@ export class ENS {
       return
     }
     await this.setProvider(this.initialProvider)
-    return
   }
 
   /**
@@ -172,7 +224,13 @@ export class ENS {
     path: string,
     dependencies: FunctionDeps<F>,
     exportName: string = 'default',
-    subFunc?: 'raw' | 'decode' | 'combine' | 'batch',
+    subFunc?:
+      | 'raw'
+      | 'decode'
+      | 'combine'
+      | 'batch'
+      | 'write'
+      | 'populateTransaction',
     passthrough?: RawFunction,
   ): Function => {
     // if batch is specified, create batch func
@@ -186,37 +244,55 @@ export class ENS {
       await thisRef.checkInitialProvider()
       // import the module dynamically
       const mod = await import(
-        /* webpackMode: "lazy", webpackChunkName: "[request]", webpackPreload: true */
+        /* webpackMode: "lazy", webpackChunkName: "[request]", webpackPreload: true, webpackExclude: /.*\.ts$/ */
         `./functions/${path}`
       )
 
       // 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]
-        if(dependencies.length === 0) {
-          return func(...args)
-        }
+        const func =
+          subFunc && !writeable ? mod[exportName][subFunc] : mod[exportName]
         // 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,
+        mod[exportName],
+        ...args,
+      )
     }
 
     // if subfunc is combine, add raw and decode property methods to the function
@@ -240,6 +316,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
@@ -259,6 +342,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
@@ -298,7 +400,6 @@ export class ENS {
       this.provider,
       this.getContractAddress(String(network) as SupportedNetworkId),
     )
-    return
   }
 
   /**
@@ -350,9 +451,10 @@ export class ENS {
     ['contracts'],
   )
 
-  public getFuses = this.generateRawFunction<typeof getFuses>('getFuses', [
-    'contracts',
-  ])
+  public getWrapperData = this.generateRawFunction<typeof getWrapperData>(
+    'getWrapperData',
+    ['contracts'],
+  )
 
   public getHistory = this.generateFunction<typeof getHistory>(
     'getHistory',
@@ -360,22 +462,6 @@ export class ENS {
     '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'],
@@ -442,6 +528,11 @@ export class ENS {
     'getPrice',
   )
 
+  public getDNSOwner = this.generateFunction<typeof getDNSOwner>(
+    'getDNSOwner',
+    [],
+  )
+
   public universalWrapper = this.generateRawFunction<typeof universalWrapper>(
     'initialGetters',
     ['contracts'],
@@ -458,59 +549,85 @@ export class ENS {
     'multicallWrapper',
   )
 
-  public setName = this.generateFunction<typeof setName>('setName', [
+  public setName = this.generateWriteFunction<typeof setName>('setName', [
     'contracts',
-    'provider',
   ])
 
-  public setRecords = this.generateFunction<typeof setRecords>('setRecords', [
+  public setRecords = this.generateWriteFunction<typeof setRecords>(
+    'setRecords',
+    ['contracts', 'provider', 'getResolver'],
+  )
+
+  public setRecord = this.generateWriteFunction<typeof setRecord>('setRecord', [
     'contracts',
     'provider',
     'getResolver',
   ])
 
-  public setResolver = this.generateFunction<typeof setResolver>(
+  public setResolver = this.generateWriteFunction<typeof setResolver>(
     'setResolver',
-    ['contracts', 'provider'],
+    ['contracts'],
   )
 
-  public transferName = this.generateFunction<typeof transferName>(
+  public transferName = this.generateWriteFunction<typeof transferName>(
     'transferName',
-    ['contracts', 'provider'],
+    ['contracts'],
   )
 
-  public wrapName = this.generateFunction<typeof wrapName>('wrapName', [
-    'contracts',
-    'provider',
-  ])
+  public transferController = this.generateWriteFunction<
+    typeof transferController
+  >('transferController', ['contracts'])
 
-  public unwrapName = this.generateFunction<typeof unwrapName>('unwrapName', [
+  public wrapName = this.generateWriteFunction<typeof wrapName>('wrapName', [
     'contracts',
-    'provider',
+    'getExpiry',
   ])
 
-  public burnFuses = this.generateFunction<typeof burnFuses>('burnFuses', [
+  public unwrapName = this.generateWriteFunction<typeof unwrapName>(
+    'unwrapName',
+    ['contracts'],
+  )
+
+  public burnFuses = this.generateWriteFunction<typeof burnFuses>('burnFuses', [
     'contracts',
-    'provider',
   ])
 
-  public createSubname = this.generateFunction<typeof createSubname>(
+  public importDNSSECName = this.generateWriteFunction<typeof importDNSSECName>(
+    'importDNSSECName',
+    ['contracts', 'provider', 'signer'],
+  )
+
+  public createSubname = this.generateWriteFunction<typeof createSubname>(
     'createSubname',
-    ['contracts', 'provider'],
+    ['contracts', 'getExpiry'],
   )
 
-  public deleteSubname = this.generateFunction<typeof deleteSubname>(
+  public deleteSubname = this.generateWriteFunction<typeof deleteSubname>(
     'deleteSubname',
-    ['contracts', 'provider', 'transferSubname'],
+    ['contracts'],
   )
 
-  public transferSubname = this.generateFunction<typeof transferSubname>(
+  public transferSubname = this.generateWriteFunction<typeof transferSubname>(
     'transferSubname',
-    ['contracts', 'provider'],
+    ['contracts', 'getExpiry'],
   )
 
-  public getDNSOwner = this.generateFunction<typeof getDNSOwner>(
-    'getDNSOwner',
-    [],
+  public commitName = this.generateWriteFunction<typeof commitName>(
+    'commitName',
+    ['contracts'],
+  )
+
+  public registerName = this.generateWriteFunction<typeof registerName>(
+    'registerName',
+    ['contracts'],
   )
+
+  public renewNames = this.generateWriteFunction<typeof renewNames>(
+    'renewNames',
+    ['contracts'],
+  )
+
+  public renewNameWithData = this.generateWriteFunction<
+    typeof renewNameWithData
+  >('renewNames', ['contracts'], 'renewNameWithData')
 }

package/src/utils/ccip.ts

@@ -0,0 +1,148 @@
+import type { BaseProvider, TransactionRequest } from '@ethersproject/providers'
+import { BigNumber, Transaction } from 'ethers'
+import {
+  arrayify,
+  BytesLike,
+  hexConcat,
+  hexDataSlice,
+  toUtf8String,
+} from 'ethers/lib/utils'
+
+function bytesPad(value: Uint8Array): Uint8Array {
+  if (value.length % 32 === 0) {
+    return value
+  }
+
+  const result = new Uint8Array(Math.ceil(value.length / 32) * 32)
+  result.set(value)
+  return result
+}
+
+function numPad(value: number): Uint8Array {
+  const result = arrayify(value)
+  if (result.length > 32) {
+    throw new Error('internal; should not happen')
+  }
+
+  const padded = new Uint8Array(32)
+  padded.set(result, 32 - result.length)
+  return padded
+}
+
+// ABI Encodes a series of (bytes, bytes, ...)
+function encodeBytes(datas: Array<BytesLike>) {
+  const result: Array<Uint8Array> = []
+
+  let byteCount = 0
+
+  // Add place-holders for pointers as we add items
+  for (let i = 0; i < datas.length; i += 1) {
+    result.push(new Uint8Array(0))
+    byteCount += 32
+  }
+
+  for (let i = 0; i < datas.length; i += 1) {
+    const data = arrayify(datas[i])
+
+    // Update the bytes offset
+    result[i] = numPad(byteCount)
+
+    // The length and padded value of data
+    result.push(numPad(data.length))
+    result.push(bytesPad(data))
+    byteCount += 32 + Math.ceil(data.length / 32) * 32
+  }
+
+  return hexConcat(result)
+}
+
+function _parseBytes(result: string, start: number): null | string {
+  if (result === '0x') {
+    return null
+  }
+
+  const offset = BigNumber.from(
+    hexDataSlice(result, start, start + 32),
+  ).toNumber()
+  const length = BigNumber.from(
+    hexDataSlice(result, offset, offset + 32),
+  ).toNumber()
+
+  return hexDataSlice(result, offset + 32, offset + 32 + length)
+}
+
+function _parseString(result: string, start: number): null | string {
+  try {
+    const bytes = _parseBytes(result, start)
+    if (bytes == null) return null
+    return toUtf8String(bytes)
+  } catch (error) {}
+  return null
+}
+
+const ccipLookup = async (
+  provider: BaseProvider,
+  transaction: TransactionRequest,
+  result: string,
+) => {
+  const txSender = transaction.to!
+  try {
+    const data = hexDataSlice(result, 4)
+
+    // Check the sender of the OffchainLookup matches the transaction
+    const sender = hexDataSlice(data, 0, 32)
+    if (!BigNumber.from(sender).eq(txSender)) {
+      throw new Error('CCIP Read sender did not match')
+    }
+
+    // Read the URLs from the response
+    const urls: Array<string> = []
+    const urlsOffset = BigNumber.from(hexDataSlice(data, 32, 64)).toNumber()
+    const urlsLength = BigNumber.from(
+      hexDataSlice(data, urlsOffset, urlsOffset + 32),
+    ).toNumber()
+    const urlsData = hexDataSlice(data, urlsOffset + 32)
+    for (let u = 0; u < urlsLength; u += 1) {
+      const url = _parseString(urlsData, u * 32)
+      if (url == null) {
+        throw new Error('CCIP Read contained corrupt URL string')
+      }
+      urls.push(url)
+    }
+
+    // Get the CCIP calldata to forward
+    const calldata = _parseBytes(data, 64)
+
+    // Get the callbackSelector (bytes4)
+    if (!BigNumber.from(hexDataSlice(data, 100, 128)).isZero()) {
+      throw new Error('CCIP Read callback selected included junk')
+    }
+    const callbackSelector = hexDataSlice(data, 96, 100)
+
+    // Get the extra data to send back to the contract as context
+    const extraData = _parseBytes(data, 128)
+
+    const ccipResult = await provider.ccipReadFetch(
+      <Transaction>transaction,
+      calldata!,
+      urls,
+    )
+    if (ccipResult == null) {
+      throw new Error('CCIP Read disabled or provided no URLs')
+    }
+
+    const tx = {
+      to: sender,
+      data: hexConcat([
+        callbackSelector,
+        encodeBytes([ccipResult, extraData!]),
+      ]),
+    }
+
+    return await provider._call(tx, 'latest', 1)
+  } catch (error) {
+    console.error(error)
+  }
+}
+
+export default ccipLookup

package/src/utils/consts.ts

@@ -0,0 +1 @@
+export const EMPTY_ADDRESS = '0x0000000000000000000000000000000000000000'

package/src/utils/contentHash.ts

@@ -26,13 +26,16 @@ function matchProtocol(text: string) {
 }
 
 export function decodeContenthash(encoded: any) {
-  let decoded, protocolType, error
+  let decoded
+  let protocolType
+  let error
   if (!encoded || encoded === '0x') {
     return {}
   }
   if (encoded.error) {
     return { protocolType: null, decoded: encoded.error }
-  } else if (encoded === false) {
+  }
+  if (encoded === false) {
     return { protocolType: null, decoded: 'invalid value' }
   }
   if (encoded) {
@@ -80,12 +83,12 @@ export function isValidContenthash(encoded: any) {
 }
 
 export function getProtocolType(encoded: any) {
-  let protocolType, decoded
+  let protocolType
+  let decoded
   try {
-    let matched = matchProtocol(encoded)
+    const matched = matchProtocol(encoded)
     if (matched) {
-      protocolType = matched[1]
-      decoded = matched[2]
+      ;[, protocolType, decoded] = matched
     }
     return {
       protocolType,
@@ -101,38 +104,37 @@ export function encodeContenthash(text: string) {
   let contentType
   let encoded: string | boolean = false
   let error
-  if (!!text) {
-    let matched = matchProtocol(text)
+  if (text) {
+    const matched = matchProtocol(text)
     if (matched) {
-      contentType = matched[1]
-      content = matched[2]
+      ;[, contentType, content] = matched
     }
     try {
       if (contentType === 'ipfs') {
         if (content.length >= 4) {
-          encoded = '0x' + contentHash.encode('ipfs-ns', content)
+          encoded = `0x${contentHash.encode('ipfs-ns', content)}`
         }
       } else if (contentType === 'ipns') {
-        encoded = '0x' + contentHash.encode('ipns-ns', content)
+        encoded = `0x${contentHash.encode('ipns-ns', content)}`
       } else if (contentType === 'bzz') {
         if (content.length >= 4) {
-          encoded = '0x' + contentHash.fromSwarm(content)
+          encoded = `0x${contentHash.fromSwarm(content)}`
         }
       } else if (contentType === 'onion') {
-        if (content.length == 16) {
-          encoded = '0x' + contentHash.encode('onion', content)
+        if (content.length === 16) {
+          encoded = `0x${contentHash.encode('onion', content)}`
         }
       } else if (contentType === 'onion3') {
-        if (content.length == 56) {
-          encoded = '0x' + contentHash.encode('onion3', content)
+        if (content.length === 56) {
+          encoded = `0x${contentHash.encode('onion3', content)}`
         }
       } else if (contentType === 'sia') {
-        if (content.length == 46) {
-          encoded = '0x' + contentHash.encode('skynet-ns', content)
+        if (content.length === 46) {
+          encoded = `0x${contentHash.encode('skynet-ns', content)}`
         }
       } else if (contentType === 'arweave') {
-        if (content.length == 43) {
-          encoded = '0x' + contentHash.encode('arweave-ns', content)
+        if (content.length === 43) {
+          encoded = `0x${contentHash.encode('arweave-ns', content)}`
         }
       } else {
         console.warn('Unsupported protocol or invalid value', {
@@ -144,7 +146,7 @@ export function encodeContenthash(text: string) {
       const errorMessage = 'Error encoding content hash'
       console.warn(errorMessage, { text, encoded })
       error = errorMessage
-      //throw 'Error encoding content hash'
+      // throw 'Error encoding content hash'
     }
   }
   return { encoded, error }

package/src/utils/createReverseNode.ts

@@ -1,2 +1,2 @@
 export default (address: string) =>
-  address.toLowerCase().substring(2) + '.addr.reverse'
+  `${address.toLowerCase().substring(2)}.addr.reverse`