@ensdomains/ensjs 3.0.0-alpha.1 → 3.0.0-alpha.12

package/src/index.ts

@@ -1,4 +1,5 @@
-import { ethers } from 'ethers'
+import { JsonRpcSigner } from '@ethersproject/providers'
+import { ContractTransaction, ethers, PopulatedTransaction } from 'ethers'
 import ContractManager from './contracts'
 import { getContractAddress as _getContractAddress } from './contracts/getContractAddress'
 import { SupportedNetworkId } from './contracts/types'
@@ -11,13 +12,10 @@ import type {
 import type burnFuses from './functions/burnFuses'
 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'
@@ -35,6 +33,7 @@ import type {
 } from './functions/getSpecificRecord'
 import type getSubnames from './functions/getSubnames'
 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 +42,7 @@ 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'
 
 type ENSOptions = {
   graphURI?: string | null
@@ -52,6 +52,7 @@ type ENSOptions = {
 export type InternalENS = {
   options?: ENSOptions
   provider?: ethers.providers.Provider
+  signer: JsonRpcSigner
   graphURI?: string | null
 } & ENS
 
@@ -75,6 +76,28 @@ 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>
+  populateTransaction: (
+    ...args: Parameters<OptionalWriteOptions<F>>
+  ) => Promise<PopulatedTransaction>
+}
+
 const graphURIEndpoints: Record<string, string> = {
   1: 'https://api.thegraph.com/subgraphs/name/ensdomains/ens',
   3: 'https://api.thegraph.com/subgraphs/name/ensdomains/ensropsten',
@@ -171,7 +194,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,18 +214,40 @@ 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 {
@@ -236,6 +287,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 +313,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
@@ -321,6 +398,7 @@ export class ENS {
       'gqlInstance',
       'getName',
       'resolverMulticallWrapper',
+      'multicallWrapper',
       '_getAddr',
       '_getContentHash',
       '_getText',
@@ -355,22 +433,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'],
@@ -453,54 +515,62 @@ 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'],
+    ['transferSubname'],
   )
 
-  public transferSubname = this.generateFunction<typeof transferSubname>(
+  public transferSubname = this.generateWriteFunction<typeof transferSubname>(
     'transferSubname',
-    ['contracts', 'provider'],
+    ['contracts', 'getExpiry'],
+  )
+
+  public getDNSOwner = this.generateFunction<typeof getDNSOwner>(
+    'getDNSOwner',
+    [],
   )
 }

package/src/tests/populateTransaction.test.ts

@@ -0,0 +1,40 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import setup from '../tests/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()
+})
+
+jest.setTimeout(20000)
+
+describe('populateTransaction', () => {
+  beforeEach(async () => {
+    await revert()
+  })
+  it('should return a transaction successfully', async () => {
+    const tx = await ENSInstance.setName('fleek.eth')
+    expect(tx).toBeTruthy()
+    if (tx) {
+      await tx.wait()
+      expect(tx.hash).toBeTruthy()
+    }
+  })
+  it('should return a populated transaction successfully', async () => {
+    const tx = await ENSInstance.setName.populateTransaction('fleek.eth')
+    expect(tx).toBeTruthy()
+    if (tx) {
+      expect(tx).not.toHaveProperty('hash')
+    }
+  })
+})

package/src/tests/setup.ts

@@ -1,23 +1,27 @@
+import { config } from 'dotenv'
 import { ethers } from 'ethers'
+import { resolve } from 'path'
 import { ENS } from '../'
 import { ContractName, SupportedNetworkId } from '../contracts/types'
 
-const addresses = {
-  BaseRegistrarImplementation: '0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85',
-  Multicall: '0xcA11bde05977b3631167028862bE2a173976CA11',
-  NameWrapper: '0xD7D9C568Bc4C2343ab286096e1F851D33eEf49Af',
-  PublicResolver: '0x3bAa5F3ea7bFCC8948c4140f233d72c11eBF0bdB',
-  ENSRegistryWithFallback: '0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e',
-  ReverseRegistrar: '0x4696E2f7D9f4CA187155ff50D93C00172181ddd5',
-  UniversalResolver: '0xAbCd01ddDa102B0C32e8C5a371D7480dFA559DC3',
-}
+config({
+  path: resolve(__dirname, '../../.env.local'),
+  override: true,
+})
+
+const deploymentAddresses = JSON.parse(
+  process.env.DEPLOYMENT_ADDRESSES!,
+) as Record<ContractName | 'ENSRegistry', string>
 
 const createENS = (graphURI: string) =>
   new ENS({
     graphURI,
-    getContractAddress:
-      (_: SupportedNetworkId) => (contractName: ContractName) =>
-        addresses[contractName],
+    getContractAddress: (_: SupportedNetworkId) => (contractName) =>
+      deploymentAddresses[
+        contractName === 'ENSRegistryWithFallback'
+          ? 'ENSRegistry'
+          : contractName
+      ],
   })
 
 export default async (useReal?: boolean) => {
@@ -27,7 +31,7 @@ export default async (useReal?: boolean) => {
 
   const provider = new ethers.providers.JsonRpcProvider(
     'http://localhost:8545',
-    'ropsten',
+    1337,
   )
 
   let ENSInstance = createENS(graphURI)

package/src/tests/signerInjection.test.ts

@@ -0,0 +1,46 @@
+import { ContractTransaction, ethers } from 'ethers'
+import { ENS } from '..'
+import setup from '../tests/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()
+})
+
+jest.setTimeout(20000)
+
+describe('Signer Injection', () => {
+  beforeEach(async () => {
+    await revert()
+  })
+  it('should return a transaction successfully for a custom signer', async () => {
+    const signer = provider.getSigner(accounts[3])
+    const tx = await ENSInstance.setName('fleek.eth', {
+      signer,
+    })
+    expect(tx).toBeTruthy()
+    if (tx) {
+      await tx.wait()
+      expect(tx.from).toBe(accounts[3])
+    }
+  })
+  it('should return a transaction succesfully for a custom signer index', async () => {
+    const tx = (await ENSInstance.setName('fleek.eth', {
+      addressOrIndex: 3,
+    })) as ContractTransaction
+    expect(tx).toBeTruthy()
+    if (tx) {
+      await tx.wait()
+      expect(tx.from).toBe(accounts[3])
+    }
+  })
+})

package/src/tests/withProvider.test.ts

@@ -1,6 +1,6 @@
 import { ethers } from 'ethers'
 import { ENS } from '..'
-import setup from './setup'
+import setup from '../tests/setup'
 
 let ENSInstance: ENS
 let providerFake: ethers.providers.JsonRpcProvider
@@ -15,11 +15,11 @@ beforeAll(async () => {
 
 describe('withProvider', () => {
   it('should be able to use a new provider', async () => {
-    const addr = await ENSInstance.getAddr('jefflau.eth')
+    const addr = await ENSInstance.getAddr('with-profile.eth')
     expect(addr).toBeTruthy()
 
     try {
-      await ENSInstance.withProvider(providerFake).getOwner('jefflau.eth')
+      await ENSInstance.withProvider(providerFake).getOwner('with-profile.eth')
       expect(false).toBeTruthy()
     } catch {
       expect(true).toBeTruthy()

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/makeHashIndexes.ts

@@ -1,9 +1,9 @@
-import { ethers } from 'ethers'
+import { namehash } from './normalise'
 
 export const makeOtherIndexes = (data: string, findStr: string) =>
   Array.from(data.matchAll(findStr as any)).map((x: any) => x.index / 2 - 1)
 
 export const makeNamehashIndexes = (data: string, name: string) =>
-  Array.from(
-    data.matchAll(ethers.utils.namehash(name).substring(2) as any),
-  ).map((x: any) => x.index / 2 - 1)
+  Array.from(data.matchAll(namehash(name).substring(2) as any)).map(
+    (x: any) => x.index / 2 - 1,
+  )

package/src/utils/normalise.ts

@@ -1,4 +1,33 @@
+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)
 
 export const normalise = (name: string) =>
   name ? uts46.toUnicode(name, { useStd3ASCII: true }) : name
+
+export const namehash = (name: string): string => {
+  let result: string | Uint8Array = zeros
+
+  if (name) {
+    const labels = name.split('.')
+
+    for (var i = labels.length - 1; i >= 0; i--) {
+      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 {
+    result = hexlify(zeros)
+  }
+
+  return result as string
+}

package/src/utils/recordHelpers.ts

@@ -33,6 +33,47 @@ export const generateSetAddr = (
   )
 }
 
+export type RecordTypes = 'contentHash' | 'text' | 'addr'
+
+export type RecordInput<T extends RecordTypes> = T extends 'contentHash'
+  ? string
+  : RecordItem
+
+export function generateSingleRecordCall<T extends RecordTypes>(
+  namehash: string,
+  resolver: PublicResolver,
+  type: T,
+): (record: RecordInput<T>) => string {
+  if (type === 'contentHash') {
+    return (_r: RecordInput<T>) => {
+      const record = _r as string
+      let _contentHash = ''
+      if (record !== _contentHash) {
+        const encoded = encodeContenthash(record)
+        if (encoded.error) throw new Error(encoded.error)
+        _contentHash = encoded.encoded as string
+      }
+      return resolver.interface.encodeFunctionData('setContenthash', [
+        namehash,
+        _contentHash,
+      ])
+    }
+  } else {
+    return (_r: RecordInput<T>) => {
+      const record = _r as RecordItem
+      if (type === 'text') {
+        return resolver.interface.encodeFunctionData('setText', [
+          namehash,
+          record.key,
+          record.value,
+        ])
+      } else {
+        return generateSetAddr(namehash, record.key, record.value, resolver)
+      }
+    }
+  }
+}
+
 export const generateRecordCallArray = (
   namehash: string,
   records: RecordOptions,
@@ -41,31 +82,24 @@ export const generateRecordCallArray = (
   const calls: string[] = []
 
   if (records.contentHash) {
-    const contentHash =
-      records.contentHash === '' ? '' : encodeContenthash(records.contentHash)
-    const data = (resolver?.interface.encodeFunctionData as any)(
-      'setContenthash',
-      [namehash, contentHash],
-    )
+    const data = generateSingleRecordCall(
+      namehash,
+      resolver,
+      'contentHash',
+    )(records.contentHash)
     data && calls.push(data)
   }
 
   if (records.texts && records.texts.length > 0) {
-    records.texts.forEach(({ key, value }: RecordItem) => {
-      const data = resolver?.interface.encodeFunctionData('setText', [
-        namehash,
-        key,
-        value,
-      ])
-      data && calls.push(data)
-    })
+    records.texts
+      .map(generateSingleRecordCall(namehash, resolver, 'text'))
+      .forEach((call) => calls.push(call))
   }
 
   if (records.coinTypes && records.coinTypes.length > 0) {
-    records.coinTypes.forEach(({ key, value }: RecordItem) => {
-      const data = generateSetAddr(namehash, key, value, resolver!)
-      data && calls.push(data)
-    })
+    records.coinTypes
+      .map(generateSingleRecordCall(namehash, resolver, 'addr'))
+      .forEach((call) => calls.push(call))
   }
 
   return calls

package/src/utils/registerHelpers.ts

@@ -3,6 +3,7 @@ import type { FuseOptions } from '../@types/FuseOptions'
 import type { PublicResolver } from '../generated'
 import generateFuseInput from './generateFuseInput'
 import { labelhash } from './labels'
+import { namehash } from './normalise'
 import { generateRecordCallArray, RecordOptions } from './recordHelpers'
 
 export const randomSecret = () => {
@@ -28,11 +29,9 @@ export const makeCommitment = ({
   fuses?: FuseOptions
 }) => {
   const label = labelhash(name.split('.')[0])
-  const namehash = utils.namehash(name)
+  const hash = namehash(name)
   const resolverAddress = resolver.address
-  const data = records
-    ? generateRecordCallArray(namehash, records, resolver)
-    : []
+  const data = records ? generateRecordCallArray(hash, records, resolver) : []
   const secret = randomSecret()
   const fuseData = fuses ? generateFuseInput(fuses) : '0'
 

package/src/utils/wrapperExpiry.ts

@@ -0,0 +1,31 @@
+import { BigNumber } from 'ethers'
+import { ENSArgs } from '..'
+
+export type Expiry = string | number | Date | BigNumber
+
+export const MAX_EXPIRY = BigNumber.from(2).pow(64).sub(1)
+
+export const makeExpiry = async (
+  { getExpiry }: ENSArgs<'getExpiry'>,
+  name: string,
+  expiry?: Expiry,
+) => {
+  if (expiry) {
+    if (expiry instanceof Date) {
+      return BigNumber.from(expiry.getTime() / 1000)
+    } else if (expiry instanceof BigNumber) {
+      return expiry
+    } else {
+      return BigNumber.from(expiry)
+    }
+  } else {
+    if (name.endsWith('.eth')) {
+      const expResponse = await getExpiry(name)
+      if (!expResponse?.expiry)
+        throw new Error("Couldn't get expiry for name, please provide one.")
+      return BigNumber.from(expResponse.expiry.getTime() / 1000)
+    } else {
+      return MAX_EXPIRY
+    }
+  }
+}