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

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

@@ -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

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/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)