@ensdomains/ensjs 3.0.0-alpha.2 → 3.0.0-alpha.21

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,13 @@ 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,7 +33,10 @@ import type {
   _getText,
 } from './functions/getSpecificRecord'
 import type getSubnames from './functions/getSubnames'
+import type registerName from './functions/registerName'
+import type renewNames 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 transferName from './functions/transferName'
@@ -43,6 +45,16 @@ import type unwrapName from './functions/unwrapName'
 import type wrapName from './functions/wrapName'
 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,6 +64,7 @@ type ENSOptions = {
 export type InternalENS = {
   options?: ENSOptions
   provider?: ethers.providers.Provider
+  signer: JsonRpcSigner
   graphURI?: string | null
 } & ENS
 
@@ -75,12 +88,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 }>
@@ -120,12 +161,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) {
@@ -142,7 +190,6 @@ export class ENS {
       return
     }
     await this.setProvider(this.initialProvider)
-    return
   }
 
   /**
@@ -171,7 +218,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
@@ -185,34 +238,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]
+        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
@@ -236,6 +310,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
@@ -255,6 +336,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
@@ -294,7 +394,6 @@ export class ENS {
       this.provider,
       this.getContractAddress(String(network) as SupportedNetworkId),
     )
-    return
   }
 
   /**
@@ -356,22 +455,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'],
@@ -438,6 +521,11 @@ export class ENS {
     'getPrice',
   )
 
+  public getDNSOwner = this.generateFunction<typeof getDNSOwner>(
+    'getDNSOwner',
+    [],
+  )
+
   public universalWrapper = this.generateRawFunction<typeof universalWrapper>(
     'initialGetters',
     ['contracts'],
@@ -454,54 +542,72 @@ 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', [
+  public wrapName = this.generateWriteFunction<typeof wrapName>('wrapName', [
     'contracts',
-    'provider',
+    'getExpiry',
   ])
 
-  public unwrapName = this.generateFunction<typeof unwrapName>('unwrapName', [
-    'contracts',
-    'provider',
-  ])
+  public unwrapName = this.generateWriteFunction<typeof unwrapName>(
+    'unwrapName',
+    ['contracts'],
+  )
 
-  public burnFuses = this.generateFunction<typeof burnFuses>('burnFuses', [
+  public burnFuses = this.generateWriteFunction<typeof burnFuses>('burnFuses', [
     'contracts',
-    'provider',
   ])
 
-  public createSubname = this.generateFunction<typeof createSubname>(
+  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 commitName = this.generateWriteFunction<typeof commitName>(
+    'commitName',
+    ['contracts'],
+  )
+
+  public registerName = this.generateWriteFunction<typeof registerName>(
+    'registerName',
+    ['contracts'],
+  )
+
+  public renewNames = this.generateWriteFunction<typeof renewNames>(
+    'renewNames',
+    ['contracts'],
   )
 }

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`

package/src/utils/fuses.ts

@@ -7,7 +7,7 @@ const CANNOT_CREATE_SUBDOMAIN = 32
 const PARENT_CANNOT_CONTROL = 64
 const CAN_DO_EVERYTHING = 0
 
-export const testable = {
+export const fuseEnum = {
   CANNOT_UNWRAP,
   CANNOT_BURN_FUSES,
   CANNOT_TRANSFER,
@@ -15,9 +15,57 @@ export const testable = {
   CANNOT_SET_TTL,
   CANNOT_CREATE_SUBDOMAIN,
   PARENT_CANNOT_CONTROL,
-}
+} as const
+
+export const unnamedFuses = [
+  128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144,
+  524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, 67108864,
+  134217728, 268435456, 536870912, 1073741824, 2147483648, 4294967296,
+] as const
 
-export default {
-  ...testable,
+const fullFuseEnum = {
+  ...fuseEnum,
   CAN_DO_EVERYTHING,
 }
+
+export type FuseObj = typeof fuseEnum
+export type CurrentFuses = { [f in keyof FuseObj]: boolean }
+export type UnnamedFuseType = typeof unnamedFuses
+export type Fuse = keyof FuseObj
+export type UnnamedFuseValues = UnnamedFuseType[number]
+
+// We need this type so that the following type isn't infinite. This type limits the max length of the fuse array to 7.
+export type FuseArrayPossibilities =
+  | [Fuse]
+  | [Fuse, Fuse]
+  | [Fuse, Fuse, Fuse]
+  | [Fuse, Fuse, Fuse, Fuse]
+  | [Fuse, Fuse, Fuse, Fuse, Fuse]
+  | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse]
+  | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse, Fuse]
+
+/**
+ * This type creates a type error if there are any duplicate fuses.
+ * It effectively works like a reduce function, starting with 0 included types, adding a type each time, and then checking for duplicates.
+ *
+ * @template A The array to check for duplicates.
+ * @template B The union of all checked existing types.
+ */
+// CLAUSE A: This extension unwraps the type as a fuse tuple.
+type FusesWithoutDuplicates<A, B = never> = A extends FuseArrayPossibilities
+  ? // CLAUSE A > TRUE: CLAUSE B: Pick out the first item in the current array, separating the current item from the rest.
+    A extends [infer Head, ...infer Tail]
+    ? // CLAUSE B > TRUE: CLAUSE C: Check if the current item is a duplicate based on the input union.
+      Head extends B
+      ? // CLAUSE C > TRUE: Duplicate found, return an empty array to throw a type error.
+        []
+      : // CLAUSE C > FALSE: Return a new array to continue the recursion, adds the current item type to the union.
+        [Head, ...FusesWithoutDuplicates<Tail, Head | B>]
+    : // CLAUSE B > FALSE: Return the input array as there is no more array elements to check.
+      A
+  : // CLAUSE A > FALSE: Return an empty array as it isn't a fuse tuple.
+    []
+
+export type NamedFusesToBurn = FusesWithoutDuplicates<FuseArrayPossibilities>
+
+export default fullFuseEnum

package/src/utils/labels.ts

@@ -1,6 +1,8 @@
 import { solidityKeccak256 } from 'ethers/lib/utils'
 import { truncateFormat } from './format'
 
+const hasLocalStorage = typeof localStorage !== 'undefined'
+
 export const labelhash = (input: string) =>
   solidityKeccak256(['string'], [input])
 
@@ -17,7 +19,7 @@ export function decodeLabelhash(hash: string) {
     throw Error('Expected encoded labelhash to have a length of 66')
   }
 
-  return `${hash.slice(1, -1)}`
+  return `0x${hash.slice(1, -1)}`
 }
 
 export function encodeLabelhash(hash: string) {
@@ -37,13 +39,13 @@ export function isEncodedLabelhash(hash: string) {
 }
 
 function getLabels() {
-  return localStorage
+  return hasLocalStorage
     ? JSON.parse(localStorage.getItem('ensjs:labels') as string) || {}
     : {}
 }
 
 function _saveLabel(hash: string, label: any) {
-  if (!localStorage) return hash
+  if (!hasLocalStorage) return hash
   const labels = getLabels()
   localStorage.setItem(
     'ensjs:labels',
@@ -106,7 +108,7 @@ export function decryptName(name: string) {
 export const truncateUndecryptedName = (name: string) => truncateFormat(name)
 
 export function checkLocalStorageSize() {
-  if (!localStorage) return 'Empty (0 KB)'
+  if (!hasLocalStorage) return 'Empty (0 KB)'
   let allStrings = ''
   for (const key in window.localStorage) {
     if (Object.prototype.hasOwnProperty.call(window.localStorage, key)) {

package/src/utils/normalise.ts

@@ -1,5 +1,6 @@
 import { concat, hexlify, keccak256, toUtf8Bytes } from 'ethers/lib/utils'
 import uts46 from 'idna-uts46-hx/uts46bundle.js'
+import { decodeLabelhash, isEncodedLabelhash } from './labels'
 
 const zeros = new Uint8Array(32)
 zeros.fill(0)
@@ -7,16 +8,21 @@ zeros.fill(0)
 export const normalise = (name: string) =>
   name ? uts46.toUnicode(name, { useStd3ASCII: true }) : name
 
-export const namehash = (inputName: string): string => {
+export const namehash = (name: string): string => {
   let result: string | Uint8Array = zeros
 
-  const name = normalise(inputName)
-
   if (name) {
     const labels = name.split('.')
 
-    for (var i = labels.length - 1; i >= 0; i--) {
-      const labelSha = keccak256(toUtf8Bytes(labels[i]))
+    for (let i = labels.length - 1; i >= 0; i -= 1) {
+      let labelSha: string
+      if (isEncodedLabelhash(labels[i])) {
+        labelSha = decodeLabelhash(labels[i])
+      } else {
+        const normalised = normalise(labels[i])
+        labelSha = keccak256(toUtf8Bytes(normalised))
+      }
+
       result = keccak256(concat([result, labelSha]))
     }
   } else {