@ensdomains/ensjs 3.0.0-alpha.5 → 3.0.0-alpha.8

package/src/functions/getProfile.ts

@@ -3,6 +3,7 @@ import { ethers } from 'ethers'
 import { ENSArgs } from '..'
 import { decodeContenthash, DecodedContentHash } from '../utils/contentHash'
 import { hexEncodeName } from '../utils/hexEncodedName'
+import { namehash } from '../utils/normalise'
 import { parseInputType } from '../utils/validation'
 
 type InternalProfileOptions = {
@@ -136,7 +137,8 @@ const getDataForName = async (
   >,
   name: string,
   options: InternalProfileOptions,
-  fallbackResolver: string,
+  fallbackResolver?: string,
+  specificResolver?: string,
 ) => {
   const universalResolver = await contracts?.getUniversalResolver()
 
@@ -149,7 +151,17 @@ const getDataForName = async (
   let resolvedData: any
   let useFallbackResolver = false
   try {
-    resolvedData = await universalResolver?.resolve(hexEncodeName(name), data)
+    if (specificResolver) {
+      const publicResolver = await contracts?.getPublicResolver(
+        undefined,
+        specificResolver,
+      )
+      resolvedData = await publicResolver?.callStatic.multicall(
+        calls.map((x) => x.data),
+      )
+    } else {
+      resolvedData = await universalResolver?.resolve(hexEncodeName(name), data)
+    }
   } catch {
     useFallbackResolver = true
   }
@@ -158,15 +170,19 @@ const getDataForName = async (
   let recordData: any
 
   if (useFallbackResolver) {
-    resolverAddress = fallbackResolver
+    resolverAddress = specificResolver || fallbackResolver!
     recordData = await fetchWithoutResolverMulticall(
       { multicallWrapper },
       calls,
       resolverAddress,
     )
   } else {
-    resolverAddress = resolvedData['1']
-    ;[recordData] = await resolverMulticallWrapper.decode(resolvedData['0'])
+    resolverAddress = specificResolver || resolvedData['1']
+    if (specificResolver) {
+      recordData = resolvedData
+    } else {
+      ;[recordData] = await resolverMulticallWrapper.decode(resolvedData['0'])
+    }
   }
 
   const matchAddress = recordData[calls.findIndex((x) => x.key === '60')]
@@ -298,10 +314,11 @@ const graphFetch = async (
   { gqlInstance }: ENSArgs<'gqlInstance'>,
   name: string,
   wantedRecords?: ProfileOptions,
+  resolverAddress?: string,
 ) => {
   const query = gqlInstance.gql`
-    query getRecords($name: String!) {
-      domains(where: { name: $name }) {
+    query getRecords($id: String!) {
+      domain(id: $id) {
         isMigrated
         createdAt
         resolver {
@@ -317,13 +334,44 @@ const graphFetch = async (
     }
   `
 
+  const customResolverQuery = gqlInstance.gql`
+    query getRecordsWithCustomResolver($id: String!, $resolverId: String!) {
+      domain(id: $id) {
+        isMigrated
+        createdAt
+      }
+      resolver(id: $resolverId) {
+        texts
+        coinTypes
+        contentHash
+        addr {
+          id
+        }
+      }
+    }
+  `
+
   const client = gqlInstance.client
 
-  const { domains } = await client.request(query, { name })
+  const id = namehash(name)
 
-  if (!domains || domains.length === 0) return
+  let domain: any
+  let resolverResponse: any
 
-  const [{ resolver: resolverResponse, isMigrated, createdAt }] = domains
+  if (!resolverAddress) {
+    ;({ domain } = await client.request(query, { id }))
+    resolverResponse = domain?.resolver
+  } else {
+    const resolverId = `${resolverAddress}-${id}`
+    ;({ resolver: resolverResponse, domain } = await client.request(
+      customResolverQuery,
+      { id, resolverId },
+    ))
+  }
+
+  if (!domain) return
+
+  const { isMigrated, createdAt } = domain
 
   let returnedRecords: ProfileResponse = {}
 
@@ -333,7 +381,7 @@ const graphFetch = async (
     return {
       isMigrated,
       createdAt,
-      graphResolverAddress: resolverResponse.address,
+      graphResolverAddress: resolverResponse.address || resolverAddress,
     }
 
   Object.keys(wantedRecords).forEach((key: string) => {
@@ -351,7 +399,7 @@ const graphFetch = async (
     ...returnedRecords,
     isMigrated,
     createdAt,
-    graphResolverAddress: resolverResponse.address,
+    graphResolverAddress: resolverResponse.address || resolverAddress,
   }
 }
 
@@ -361,6 +409,10 @@ type ProfileOptions = {
   coinTypes?: boolean | string[]
 }
 
+type InputProfileOptions = ProfileOptions & {
+  resolverAddress?: string
+}
+
 const getProfileFromName = async (
   {
     contracts,
@@ -380,13 +432,23 @@ const getProfileFromName = async (
     | 'multicallWrapper'
   >,
   name: string,
-  options?: ProfileOptions,
+  options?: InputProfileOptions,
 ) => {
+  const { resolverAddress, ..._options } = options || {}
+  const optsLength = Object.keys(_options).length
   const usingOptions =
-    !options || options?.texts === true || options?.coinTypes === true
-      ? options || { contentHash: true, texts: true, coinTypes: true }
+    !optsLength || _options?.texts === true || _options?.coinTypes === true
+      ? optsLength
+        ? _options
+        : { contentHash: true, texts: true, coinTypes: true }
       : undefined
-  const graphResult = await graphFetch({ gqlInstance }, name, usingOptions)
+
+  const graphResult = await graphFetch(
+    { gqlInstance },
+    name,
+    usingOptions,
+    resolverAddress,
+  )
   if (!graphResult) return
   const {
     isMigrated,
@@ -398,7 +460,7 @@ const getProfileFromName = async (
     createdAt: string
     graphResolverAddress?: string
   } & InternalProfileOptions = graphResult
-  if (!graphResolverAddress)
+  if (!graphResolverAddress && !options?.resolverAddress)
     return { isMigrated, createdAt, message: "Name doesn't have a resolver" }
   const result = await getDataForName(
     {
@@ -412,6 +474,7 @@ const getProfileFromName = async (
     name,
     usingOptions ? wantedRecords : (options as InternalProfileOptions),
     graphResolverAddress,
+    options?.resolverAddress!,
   )
   if (!result)
     return { isMigrated, createdAt, message: "Records fetch didn't complete" }
@@ -439,7 +502,7 @@ const getProfileFromAddress = async (
     | 'multicallWrapper'
   >,
   address: string,
-  options?: ProfileOptions,
+  options?: InputProfileOptions,
 ) => {
   let name
   try {
@@ -492,7 +555,7 @@ export default async function (
     | 'multicallWrapper'
   >,
   nameOrAddress: string,
-  options?: ProfileOptions,
+  options?: InputProfileOptions,
 ): Promise<ResolvedProfile | undefined> {
   if (options && options.coinTypes && typeof options.coinTypes !== 'boolean') {
     options.coinTypes = options.coinTypes.map((coin: string) => {

package/src/functions/getRecords.ts

@@ -5,6 +5,7 @@ type ProfileOptions = {
   contentHash?: boolean
   texts?: boolean | string[]
   coinTypes?: boolean | string[]
+  resolverAddress?: string
 }
 
 export default async function (

package/src/functions/setName.ts

@@ -15,18 +15,18 @@ export default async function (
 
   const reverseRegistrar = (await contracts?.getReverseRegistrar())?.connect(
     signer,
-  )
+  )!
 
   if (address) {
-    const publicResolver = await contracts?.getPublicResolver()
+    const publicResolver = await contracts?.getPublicResolver()!
 
-    return reverseRegistrar?.setNameForAddr(
+    return reverseRegistrar.populateTransaction.setNameForAddr(
       address,
       signerAddress,
-      resolver || publicResolver!.address,
+      resolver || publicResolver.address,
       name,
     )
   }
 
-  return reverseRegistrar?.setName(name)
+  return reverseRegistrar.populateTransaction.setName(name)
 }

package/src/functions/setRecords.ts

@@ -35,10 +35,10 @@ export default async function (
 
   const resolver = (
     await contracts?.getPublicResolver(provider, resolverToUse)
-  )?.connect(signer)
+  )?.connect(signer)!
   const hash = namehash(name)
 
   const calls: string[] = generateRecordCallArray(hash, records, resolver!)
 
-  return resolver?.multicall(calls)
+  return resolver.populateTransaction.multicall(calls)
 }

package/src/functions/setResolver.ts

@@ -19,11 +19,14 @@ export default async function (
   switch (contract) {
     case 'registry': {
       const registry = (await contracts?.getRegistry())!.connect(signer)
-      return registry.setResolver(namehash(name), resolver)
+      return registry.populateTransaction.setResolver(namehash(name), resolver)
     }
     case 'nameWrapper': {
       const nameWrapper = (await contracts?.getNameWrapper())!.connect(signer)
-      return nameWrapper.setResolver(namehash(name), resolver)
+      return nameWrapper.populateTransaction.setResolver(
+        namehash(name),
+        resolver,
+      )
     }
     default: {
       throw new Error(`Unknown contract: ${contract}`)

package/src/functions/transferName.ts

@@ -18,7 +18,7 @@ export default async function (
   switch (contract) {
     case 'registry': {
       const registry = (await contracts?.getRegistry())!.connect(signer)
-      return registry.setOwner(namehash(name), newOwner)
+      return registry.populateTransaction.setOwner(namehash(name), newOwner)
     }
     case 'baseRegistrar': {
       const baseRegistrar = (await contracts?.getBaseRegistrar())!.connect(
@@ -28,7 +28,9 @@ export default async function (
       if (labels.length > 2 || labels[labels.length - 1] !== 'eth') {
         throw new Error('Invalid name for baseRegistrar')
       }
-      return baseRegistrar['safeTransferFrom(address,address,uint256)'](
+      return baseRegistrar.populateTransaction[
+        'safeTransferFrom(address,address,uint256)'
+      ](
         address,
         newOwner,
         ethers.utils.solidityKeccak256(['string'], [labels[0]]),
@@ -36,7 +38,7 @@ export default async function (
     }
     case 'nameWrapper': {
       const nameWrapper = (await contracts?.getNameWrapper())!.connect(signer)
-      return nameWrapper.safeTransferFrom(
+      return nameWrapper.populateTransaction.safeTransferFrom(
         address,
         newOwner,
         namehash(name),

package/src/functions/transferSubname.ts

@@ -22,12 +22,21 @@ export default async function (
     case 'registry': {
       const registry = (await contracts?.getRegistry()!).connect(signer)
 
-      return registry.setSubnodeOwner(parentNodehash, labelhash, address)
+      return registry.populateTransaction.setSubnodeOwner(
+        parentNodehash,
+        labelhash,
+        address,
+      )
     }
     case 'nameWrapper': {
       const nameWrapper = (await contracts?.getNameWrapper()!).connect(signer)
 
-      return nameWrapper.setSubnodeOwner(parentNodehash, label, address, '0')
+      return nameWrapper.populateTransaction.setSubnodeOwner(
+        parentNodehash,
+        label,
+        address,
+        '0',
+      )
     }
     default: {
       throw new Error(`Unknown contract: ${contract}`)

package/src/functions/unwrapName.ts

@@ -24,12 +24,20 @@ export default async function (
       throw new Error('newRegistrant must be specified for .eth names')
     }
 
-    return nameWrapper.unwrapETH2LD(labelhash, newRegistrant, newController)
+    return nameWrapper.populateTransaction.unwrapETH2LD(
+      labelhash,
+      newRegistrant,
+      newController,
+    )
   } else {
     if (newRegistrant) {
       throw new Error('newRegistrant can only be specified for .eth names')
     }
 
-    return nameWrapper.unwrap(parentNodehash, labelhash, newController)
+    return nameWrapper.populateTransaction.unwrap(
+      parentNodehash,
+      labelhash,
+      newController,
+    )
   }
 }

package/src/functions/wrapName.ts

@@ -23,12 +23,9 @@ async function wrapETH(
     [labels[0], wrappedOwner, '0x0', decodedFuses, resolverAddress],
   )
 
-  return baseRegistrar['safeTransferFrom(address,address,uint256,bytes)'](
-    address,
-    nameWrapper.address,
-    labelhash,
-    data,
-  )
+  return baseRegistrar.populateTransaction[
+    'safeTransferFrom(address,address,uint256,bytes)'
+  ](address, nameWrapper.address, labelhash, data)
 }
 
 async function wrapOther(
@@ -54,7 +51,7 @@ async function wrapOther(
     )
   }
 
-  return nameWrapper.wrap(
+  return nameWrapper.populateTransaction.wrap(
     hexEncodeName(name),
     wrappedOwner,
     decodedFuses,
@@ -63,7 +60,7 @@ async function wrapOther(
 }
 
 export default async function (
-  { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
+  { contracts, signer, populate }: ENSArgs<'contracts' | 'signer' | 'populate'>,
   name: string,
   {
     wrappedOwner,

package/src/index.ts

@@ -1,4 +1,5 @@
-import { ethers, Signer } 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'
@@ -44,6 +45,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
@@ -53,7 +55,7 @@ type ENSOptions = {
 export type InternalENS = {
   options?: ENSOptions
   provider?: ethers.providers.Provider
-  signer: Signer
+  signer: JsonRpcSigner
   graphURI?: string | null
 } & ENS
 
@@ -79,10 +81,10 @@ type FunctionDeps<F> = Extract<keyof FirstArg<F>, string>[]
 
 type WriteOptions = {
   addressOrIndex?: string | number
-  signer?: Signer
+  signer?: JsonRpcSigner
 }
 
-type WriteFunction<F> = F extends (
+type OptionalWriteOptions<F> = F extends (
   x: any,
   arg_0: infer Z,
   options?: infer P,
@@ -92,6 +94,13 @@ type WriteFunction<F> = F extends (
   ? (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',
@@ -188,7 +197,13 @@ export class ENS {
     path: string,
     dependencies: FunctionDeps<F>,
     exportName: string = 'default',
-    subFunc?: 'raw' | 'decode' | 'combine' | 'batch' | 'write',
+    subFunc?:
+      | 'raw'
+      | 'decode'
+      | 'combine'
+      | 'batch'
+      | 'write'
+      | 'populateTransaction',
     passthrough?: RawFunction,
   ): Function => {
     // if batch is specified, create batch func
@@ -202,35 +217,38 @@ 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 && subFunc !== 'write'
-            ? mod[exportName][subFunc]
-            : mod[exportName]
+          subFunc && !writeable ? mod[exportName][subFunc] : mod[exportName]
         // get the dependencies to forward to the function as the first arg
         let dependenciesToForward =
           thisRef.forwardDependenciesFromArray<F>(dependencies)
 
         // if func is write func, inject signer into dependencies
-        if (subFunc === 'write') {
+        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)
+          return func(dependenciesToForward, args[0], options).then(
+            writeTx(signer, populate),
+          )
         }
 
         // return the function with the dependencies forwarded
@@ -272,6 +290,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
@@ -298,7 +323,7 @@ export class ENS {
    * @param {string} exportName - The export name of the target function
    * @returns {OmitFirstArg} - The generated wrapped function
    */
-  private generateWriteFunction = <F>(
+  private generateWriteFunction = <F extends (...args: any) => any>(
     path: string,
     dependencies: FunctionDeps<F>,
     exportName: string = 'default',

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/signerInjection.test.ts

@@ -1,4 +1,4 @@
-import { ethers } from 'ethers'
+import { ContractTransaction, ethers } from 'ethers'
 import { ENS } from '..'
 import setup from '../tests/setup'
 
@@ -24,7 +24,9 @@ describe('Signer Injection', () => {
   })
   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 })
+    const tx = await ENSInstance.setName('fleek.eth', {
+      signer,
+    })
     expect(tx).toBeTruthy()
     if (tx) {
       await tx.wait()
@@ -32,7 +34,9 @@ describe('Signer Injection', () => {
     }
   })
   it('should return a transaction succesfully for a custom signer index', async () => {
-    const tx = await ENSInstance.setName('fleek.eth', { addressOrIndex: 3 })
+    const tx = (await ENSInstance.setName('fleek.eth', {
+      addressOrIndex: 3,
+    })) as ContractTransaction
     expect(tx).toBeTruthy()
     if (tx) {
       await tx.wait()

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])
 
@@ -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]))
+      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 {

package/src/utils/writeTx.ts

@@ -0,0 +1,6 @@
+import { JsonRpcSigner } from '@ethersproject/providers'
+import type { PopulatedTransaction } from 'ethers'
+
+export default (signer: JsonRpcSigner, populate: boolean) =>
+  (tx: PopulatedTransaction) =>
+    populate ? tx : signer.sendTransaction(tx)