@ensdomains/ensjs 2.0.0 → 3.0.0-alpha.1

package/src/tests/unwrapName.test.ts

@@ -0,0 +1,67 @@
+import { ethers, utils } from 'ethers'
+import { ENS } from '..'
+import setup from './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()
+})
+
+describe('unwrapName', () => {
+  beforeEach(async () => {
+    await revert()
+  })
+  it('should return a .eth unwrap name transaction and succeed', async () => {
+    const wrapNameTx = await ENSInstance.wrapName(
+      'parthtejpal.eth',
+      accounts[0],
+    )
+    await wrapNameTx.wait()
+
+    const tx = await ENSInstance.unwrapName(
+      'parthtejpal.eth',
+      accounts[0],
+      accounts[0],
+    )
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const baseRegistrar = await ENSInstance.contracts!.getBaseRegistrar()!
+    const result = await baseRegistrar.ownerOf(
+      utils.solidityKeccak256(['string'], ['parthtejpal']),
+    )
+    expect(result).toBe(accounts[0])
+  })
+  it('should return a regular unwrap name transaction and succeed', async () => {
+    const wrapNameTx = await ENSInstance.wrapName(
+      'parthtejpal.eth',
+      accounts[0],
+    )
+    await wrapNameTx.wait()
+    const createSubnameTx = await ENSInstance.createSubname({
+      contract: 'nameWrapper',
+      name: 'test.parthtejpal.eth',
+      owner: accounts[0],
+      shouldWrap: true,
+      options: { addressOrIndex: 0 },
+    })
+    await createSubnameTx.wait()
+
+    const tx = await ENSInstance.unwrapName('test.parthtejpal.eth', accounts[0])
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const registry = await ENSInstance.contracts!.getRegistry()!
+    const result = await registry.owner(utils.namehash('test.parthtejpal.eth'))
+    expect(result).toBe(accounts[0])
+  })
+})

package/src/tests/withProvider.test.ts

@@ -0,0 +1,28 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import setup from './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('jefflau.eth')
+    expect(addr).toBeTruthy()
+
+    try {
+      await ENSInstance.withProvider(providerFake).getOwner('jefflau.eth')
+      expect(false).toBeTruthy()
+    } catch {
+      expect(true).toBeTruthy()
+    }
+  })
+})

package/src/tests/wrapName.test.ts

@@ -0,0 +1,67 @@
+import { BigNumber, ethers, utils } from 'ethers'
+import { ENS } from '..'
+import { hexEncodeName } from '../utils/hexEncodedName'
+import setup from './setup'
+
+let ENSInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
+let createSnapshot: Awaited<ReturnType<typeof setup>>['createSnapshot']
+let provider: ethers.providers.JsonRpcProvider
+let accounts: string[]
+
+beforeAll(async () => {
+  ;({ ENSInstance, revert, createSnapshot, provider } = await setup())
+  accounts = await provider.listAccounts()
+})
+
+afterAll(async () => {
+  await revert()
+})
+
+describe('wrapName', () => {
+  beforeEach(async () => {
+    await revert()
+  })
+  it('should return a wrap name transaction and succeed', async () => {
+    const tx = await ENSInstance.wrapName('parthtejpal.eth', accounts[0])
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
+    const [result] = await nameWrapper.getFuses(
+      utils.namehash('parthtejpal.eth'),
+    )
+    expect((result as BigNumber).toHexString()).toBe('0x40')
+  })
+  it('should allow initial fuses', async () => {
+    const tx = await ENSInstance.wrapName('parthtejpal.eth', accounts[0], {
+      cannotUnwrap: true,
+      cannotSetTtl: true,
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
+    const [result] = await nameWrapper.getFuses(
+      utils.namehash('parthtejpal.eth'),
+    )
+    expect((result as BigNumber).toHexString()).toBe('0x51')
+  })
+  it('should allow an initial resolver address', async () => {
+    const tx = await ENSInstance.wrapName(
+      'parthtejpal.eth',
+      accounts[0],
+      undefined,
+      '0x42D63ae25990889E35F215bC95884039Ba354115',
+    )
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const universalResolver =
+      await ENSInstance.contracts!.getUniversalResolver()!
+    const [result] = await universalResolver.findResolver(
+      hexEncodeName('parthtejpal.eth'),
+    )
+    expect(result).toBe('0x42D63ae25990889E35F215bC95884039Ba354115')
+  })
+})

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,119 @@
+import { solidityKeccak256 } from 'ethers/lib/utils'
+import { truncateFormat } from './format'
+
+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 `${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 localStorage
+    ? JSON.parse(localStorage.getItem('ensjs:labels') as string) || {}
+    : {}
+}
+
+function _saveLabel(hash: string, label: any) {
+  if (!localStorage) 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 (!localStorage) 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 { ethers } from 'ethers'
+
+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)

package/src/utils/normalise.ts

@@ -0,0 +1,4 @@
+import uts46 from 'idna-uts46-hx/uts46bundle.js'
+
+export const normalise = (name: string) =>
+  name ? uts46.toUnicode(name, { useStd3ASCII: true }) : name

package/src/utils/recordHelpers.ts

@@ -0,0 +1,72 @@
+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 const generateRecordCallArray = (
+  namehash: string,
+  records: RecordOptions,
+  resolver: PublicResolver,
+) => {
+  const calls: string[] = []
+
+  if (records.contentHash) {
+    const contentHash =
+      records.contentHash === '' ? '' : encodeContenthash(records.contentHash)
+    const data = (resolver?.interface.encodeFunctionData as any)(
+      'setContenthash',
+      [namehash, 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)
+    })
+  }
+
+  if (records.coinTypes && records.coinTypes.length > 0) {
+    records.coinTypes.forEach(({ key, value }: RecordItem) => {
+      const data = generateSetAddr(namehash, key, value, resolver!)
+      data && calls.push(data)
+    })
+  }
+
+  return calls
+}

package/src/utils/registerHelpers.ts

@@ -0,0 +1,88 @@
+import { utils } from 'ethers'
+import type { FuseOptions } from '../@types/FuseOptions'
+import type { PublicResolver } from '../generated'
+import generateFuseInput from './generateFuseInput'
+import { labelhash } from './labels'
+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 namehash = utils.namehash(name)
+  const resolverAddress = resolver.address
+  const data = records
+    ? generateRecordCallArray(namehash, 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))