@ensdomains/ensjs 2.1.0 → 3.0.0-alpha.11

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

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

package/src/utils/contentHash.ts

@@ -0,0 +1,151 @@
+import contentHash from '@ensdomains/content-hash'
+import { utils } from 'ethers'
+
+export type DecodedContentHash = {
+  protocolType?: any
+  decoded?: any
+  error?: any
+}
+
+const supportedCodecs = [
+  'ipns-ns',
+  'ipfs-ns',
+  'swarm-ns',
+  'onion',
+  'onion3',
+  'skynet-ns',
+  'arweave-ns',
+]
+
+function matchProtocol(text: string) {
+  return (
+    text.match(/^(ipfs|sia|ipns|bzz|onion|onion3|arweave):\/\/(.*)/) ||
+    text.match(/\/(ipfs)\/(.*)/) ||
+    text.match(/\/(ipns)\/(.*)/)
+  )
+}
+
+export function decodeContenthash(encoded: any) {
+  let decoded, protocolType, error
+  if (!encoded || encoded === '0x') {
+    return {}
+  }
+  if (encoded.error) {
+    return { protocolType: null, decoded: encoded.error }
+  } else if (encoded === false) {
+    return { protocolType: null, decoded: 'invalid value' }
+  }
+  if (encoded) {
+    try {
+      decoded = contentHash.decode(encoded)
+      const codec = contentHash.getCodec(encoded)
+      if (codec === 'ipfs-ns') {
+        protocolType = 'ipfs'
+      } else if (codec === 'ipns-ns') {
+        protocolType = 'ipns'
+      } else if (codec === 'swarm-ns') {
+        protocolType = 'bzz'
+      } else if (codec === 'onion') {
+        protocolType = 'onion'
+      } else if (codec === 'onion3') {
+        protocolType = 'onion3'
+      } else if (codec === 'skynet-ns') {
+        protocolType = 'sia'
+      } else if (codec === 'arweave-ns') {
+        protocolType = 'arweave'
+      } else {
+        decoded = encoded
+      }
+    } catch (e: any) {
+      error = e.message
+    }
+  }
+  return { protocolType, decoded, error }
+}
+
+export function validateContent(encoded: any) {
+  return (
+    contentHash.isHashOfType(encoded, contentHash.Types.ipfs) ||
+    contentHash.isHashOfType(encoded, contentHash.Types.swarm)
+  )
+}
+
+export function isValidContenthash(encoded: any) {
+  try {
+    const codec = contentHash.getCodec(encoded)
+    return utils.isHexString(encoded) && supportedCodecs.includes(codec)
+  } catch (e) {
+    console.log(e)
+  }
+}
+
+export function getProtocolType(encoded: any) {
+  let protocolType, decoded
+  try {
+    let matched = matchProtocol(encoded)
+    if (matched) {
+      protocolType = matched[1]
+      decoded = matched[2]
+    }
+    return {
+      protocolType,
+      decoded,
+    }
+  } catch (e) {
+    console.log(e)
+  }
+}
+
+export function encodeContenthash(text: string) {
+  let content = text
+  let contentType
+  let encoded: string | boolean = false
+  let error
+  if (!!text) {
+    let matched = matchProtocol(text)
+    if (matched) {
+      contentType = matched[1]
+      content = matched[2]
+    }
+    try {
+      if (contentType === 'ipfs') {
+        if (content.length >= 4) {
+          encoded = '0x' + contentHash.encode('ipfs-ns', content)
+        }
+      } else if (contentType === 'ipns') {
+        encoded = '0x' + contentHash.encode('ipns-ns', content)
+      } else if (contentType === 'bzz') {
+        if (content.length >= 4) {
+          encoded = '0x' + contentHash.fromSwarm(content)
+        }
+      } else if (contentType === 'onion') {
+        if (content.length == 16) {
+          encoded = '0x' + contentHash.encode('onion', content)
+        }
+      } else if (contentType === 'onion3') {
+        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)
+        }
+      } else if (contentType === 'arweave') {
+        if (content.length == 43) {
+          encoded = '0x' + contentHash.encode('arweave-ns', content)
+        }
+      } else {
+        console.warn('Unsupported protocol or invalid value', {
+          contentType,
+          text,
+        })
+      }
+    } catch (err) {
+      const errorMessage = 'Error encoding content hash'
+      console.warn(errorMessage, { text, encoded })
+      error = errorMessage
+      //throw 'Error encoding content hash'
+    }
+  }
+  return { encoded, error }
+}

package/src/utils/createReverseNode.ts

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

package/src/utils/format.ts

@@ -0,0 +1,8 @@
+export const formatHashed = (name: string): string =>
+  name.replace(/(\[)(.{64})(\])/g, '0x$2')
+
+export const truncateFormat = (name: string): string =>
+  name.replace(/(\[.{3})(.{58})(.{3}\])/g, '$1...$3')
+
+export const bracketFormat = (name: string): string =>
+  name.replace(/(0x)(.{64})(?=\.)/g, '[$2]')

package/src/utils/fuses.ts

@@ -0,0 +1,23 @@
+const CANNOT_UNWRAP = 1
+const CANNOT_BURN_FUSES = 2
+const CANNOT_TRANSFER = 4
+const CANNOT_SET_RESOLVER = 8
+const CANNOT_SET_TTL = 16
+const CANNOT_CREATE_SUBDOMAIN = 32
+const PARENT_CANNOT_CONTROL = 64
+const CAN_DO_EVERYTHING = 0
+
+export const testable = {
+  CANNOT_UNWRAP,
+  CANNOT_BURN_FUSES,
+  CANNOT_TRANSFER,
+  CANNOT_SET_RESOLVER,
+  CANNOT_SET_TTL,
+  CANNOT_CREATE_SUBDOMAIN,
+  PARENT_CANNOT_CONTROL,
+}
+
+export default {
+  ...testable,
+  CAN_DO_EVERYTHING,
+}

package/src/utils/generateFuseInput.ts

@@ -0,0 +1,18 @@
+import { ethers } from 'ethers'
+import { FuseOptions } from '../@types/FuseOptions'
+import fuses from './fuses'
+
+export default (fuseOptions: FuseOptions) => {
+  const fuseKeys = Object.keys(fuseOptions)
+    .filter((opt) => fuseOptions[opt as keyof FuseOptions] === true)
+    .map((opt) =>
+      opt
+        .split(/(?=[A-Z])/)
+        .join('_')
+        .toUpperCase(),
+    )
+  const bigNumberFuses = fuseKeys.reduce((prev, curr) => {
+    return prev.or(fuses[curr as keyof typeof fuses])
+  }, ethers.BigNumber.from(0))
+  return bigNumberFuses.toHexString()
+}

package/src/utils/hexEncodedName.ts

@@ -0,0 +1,4 @@
+import packet from 'dns-packet'
+
+export const hexEncodeName = (name: string) =>
+  `0x${packet.name.encode(name).toString('hex')}`

package/src/utils/labels.ts

@@ -0,0 +1,121 @@
+import { solidityKeccak256 } from 'ethers/lib/utils'
+import { truncateFormat } from './format'
+
+const hasLocalStorage = typeof localStorage !== 'undefined'
+
+export const labelhash = (input: string) =>
+  solidityKeccak256(['string'], [input])
+
+export const keccakFromString = (input: string) => labelhash(input)
+
+export function decodeLabelhash(hash: string) {
+  if (!(hash.startsWith('[') && hash.endsWith(']'))) {
+    throw Error(
+      'Expected encoded labelhash to start and end with square brackets',
+    )
+  }
+
+  if (hash.length !== 66) {
+    throw Error('Expected encoded labelhash to have a length of 66')
+  }
+
+  return `0x${hash.slice(1, -1)}`
+}
+
+export function encodeLabelhash(hash: string) {
+  if (!hash.startsWith('0x')) {
+    throw new Error('Expected label hash to start with 0x')
+  }
+
+  if (hash.length !== 66) {
+    throw new Error('Expected label hash to have a length of 66')
+  }
+
+  return `[${hash.slice(2)}]`
+}
+
+export function isEncodedLabelhash(hash: string) {
+  return hash.startsWith('[') && hash.endsWith(']') && hash.length === 66
+}
+
+function getLabels() {
+  return hasLocalStorage
+    ? JSON.parse(localStorage.getItem('ensjs:labels') as string) || {}
+    : {}
+}
+
+function _saveLabel(hash: string, label: any) {
+  if (!hasLocalStorage) return hash
+  const labels = getLabels()
+  localStorage.setItem(
+    'ensjs:labels',
+    JSON.stringify({
+      ...labels,
+      [hash]: label,
+    }),
+  )
+  return hash
+}
+
+export function saveLabel(label: string) {
+  const hash = `${labelhash(label.toLowerCase())}`
+  return _saveLabel(hash, label)
+}
+
+export function saveName(name: string) {
+  const nameArray = name.split('.')
+  nameArray.forEach((label: any) => {
+    saveLabel(label)
+  })
+}
+
+// eslint-disable-next-line consistent-return
+export function checkLabel(hash: string): string | undefined {
+  const labels = getLabels()
+  if (isEncodedLabelhash(hash)) {
+    return labels[decodeLabelhash(hash)]
+  }
+
+  if (hash.startsWith('0x')) {
+    return labels[`${hash.slice(2)}`]
+  }
+}
+
+export function encodeLabel(label: any) {
+  try {
+    return encodeLabelhash(label)
+  } catch {
+    return label
+  }
+}
+
+export function parseName(name: string) {
+  const nameArray = name.split('.')
+  return nameArray.map((label: any) => encodeLabel(label)).join('.')
+}
+
+export function checkIsDecrypted(string: string | string[]) {
+  return !string?.includes('[')
+}
+
+export function decryptName(name: string) {
+  return name
+    .split('.')
+    .map((label: any) => checkLabel(label) || label)
+    .join('.')
+}
+
+export const truncateUndecryptedName = (name: string) => truncateFormat(name)
+
+export function checkLocalStorageSize() {
+  if (!hasLocalStorage) return 'Empty (0 KB)'
+  let allStrings = ''
+  for (const key in window.localStorage) {
+    if (Object.prototype.hasOwnProperty.call(window.localStorage, key)) {
+      allStrings += window.localStorage[key]
+    }
+  }
+  return allStrings
+    ? `${3 + (allStrings.length * 16) / (8 * 1024)} KB`
+    : 'Empty (0 KB)'
+}

package/src/utils/makeHashIndexes.ts

@@ -0,0 +1,9 @@
+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(namehash(name).substring(2) as any)).map(
+    (x: any) => x.index / 2 - 1,
+  )

package/src/utils/normalise.ts

@@ -0,0 +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

@@ -0,0 +1,106 @@
+import { formatsByCoinType, formatsByName } from '@ensdomains/address-encoder'
+import type { PublicResolver } from '../generated'
+import { encodeContenthash } from './contentHash'
+
+type RecordItem = {
+  key: string
+  value: string
+}
+
+export type RecordOptions = {
+  contentHash?: string
+  texts?: RecordItem[]
+  coinTypes?: RecordItem[]
+}
+
+export const generateSetAddr = (
+  namehash: string,
+  coinType: string,
+  address: string,
+  resolver: PublicResolver,
+) => {
+  let coinTypeInstance
+  if (!isNaN(parseInt(coinType))) {
+    coinTypeInstance = formatsByCoinType[parseInt(coinType)]
+  } else {
+    coinTypeInstance = formatsByName[coinType.toUpperCase()]
+  }
+  const inputCoinType = coinTypeInstance.coinType
+  const encodedAddress = coinTypeInstance.decoder(address)
+  return resolver?.interface.encodeFunctionData(
+    'setAddr(bytes32,uint256,bytes)',
+    [namehash, inputCoinType, encodedAddress],
+  )
+}
+
+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,
+  resolver: PublicResolver,
+) => {
+  const calls: string[] = []
+
+  if (records.contentHash) {
+    const data = generateSingleRecordCall(
+      namehash,
+      resolver,
+      'contentHash',
+    )(records.contentHash)
+    data && calls.push(data)
+  }
+
+  if (records.texts && records.texts.length > 0) {
+    records.texts
+      .map(generateSingleRecordCall(namehash, resolver, 'text'))
+      .forEach((call) => calls.push(call))
+  }
+
+  if (records.coinTypes && records.coinTypes.length > 0) {
+    records.coinTypes
+      .map(generateSingleRecordCall(namehash, resolver, 'addr'))
+      .forEach((call) => calls.push(call))
+  }
+
+  return calls
+}

package/src/utils/registerHelpers.ts

@@ -0,0 +1,87 @@
+import { utils } from 'ethers'
+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 = () => {
+  const bytes = Buffer.allocUnsafe(32)
+  return '0x' + crypto.getRandomValues(bytes).toString('hex')
+}
+
+export const makeCommitment = ({
+  name,
+  owner,
+  duration,
+  resolver,
+  records,
+  reverseRecord,
+  fuses,
+}: {
+  name: string
+  owner: string
+  duration: number
+  resolver: PublicResolver
+  records?: RecordOptions
+  reverseRecord?: boolean
+  fuses?: FuseOptions
+}) => {
+  const label = labelhash(name.split('.')[0])
+  const hash = namehash(name)
+  const resolverAddress = resolver.address
+  const data = records ? generateRecordCallArray(hash, records, resolver) : []
+  const secret = randomSecret()
+  const fuseData = fuses ? generateFuseInput(fuses) : '0'
+
+  const commitment = _makeCommitment({
+    labelhash: label,
+    owner,
+    duration,
+    secret,
+    resolver: resolverAddress,
+    data,
+    reverseRecord: !!reverseRecord,
+    fuses: fuseData,
+  })
+
+  return {
+    secret,
+    commitment,
+  }
+}
+
+export const _makeCommitment = ({
+  labelhash,
+  owner,
+  duration,
+  secret,
+  resolver,
+  data,
+  reverseRecord,
+  fuses,
+}: {
+  labelhash: string
+  owner: string
+  duration: number
+  secret: string
+  resolver: string
+  data: string[]
+  reverseRecord: boolean
+  fuses: string
+}) => {
+  return utils.solidityKeccak256(
+    [
+      'bytes32',
+      'address',
+      'uint256',
+      'bytes32',
+      'address',
+      'bytes[]',
+      'bool',
+      'uint96',
+    ],
+    [labelhash, owner, duration, secret, resolver, data, reverseRecord, fuses],
+  )
+}

package/src/utils/singleCall.ts

@@ -0,0 +1,16 @@
+import { ethers } from 'ethers'
+
+export default async (
+  provider: ethers.providers.Provider,
+  ensData: any,
+  func: {
+    raw: (...args: any[]) => Promise<{ to: string; data: string }>
+    decode: (...args: any[]) => Promise<any>
+  },
+  ...data: any[]
+) =>
+  func
+    .raw(ensData, ...data)
+    .then((rawData) => provider.call(rawData))
+    .catch(() => null)
+    .then((ret) => func.decode(ensData, ret, ...data))