@ensdomains/ensjs 3.0.0-alpha.4 → 3.0.0-alpha.41

package/src/static.ts

@@ -0,0 +1,94 @@
+import type { StaticJsonRpcProvider } from '@ethersproject/providers/lib/url-json-rpc-provider'
+import { gql, GraphQLClient } from 'graphql-request'
+import { parse, print, visit } from 'graphql/language'
+import traverse from 'traverse'
+import ContractManager from './contracts/index'
+import { SupportedNetworkId } from './contracts/types'
+import { ENS, FunctionSubtype, graphURIEndpoints } from './index'
+
+import type Factories from './contracts/factories'
+import type FunctionTypes from './functions/types'
+import { requestMiddleware, responseMiddleware } from './GqlManager'
+
+type Options = ConstructorParameters<typeof ENS>[0] & {
+  functions: Partial<FunctionTypes>
+  contracts: Partial<Factories>
+}
+
+class StaticENS extends ENS {
+  private functions: Partial<FunctionTypes>
+
+  private contractsObject: Partial<Factories>
+
+  gqlInstance: {
+    client: GraphQLClient | { request: () => Promise<null> }
+    setUrl: () => Promise<void>
+    gql: typeof gql | ((query: TemplateStringsArray) => string)
+  } = {
+    client: { request: () => Promise.resolve(null) },
+    setUrl: () => Promise.resolve(),
+    gql: (query: TemplateStringsArray) => query.join(),
+  }
+
+  constructor(
+    provider: StaticJsonRpcProvider,
+    { functions, contracts, ...options }: Options,
+  ) {
+    super(options)
+    this.functions = functions
+    this.contractsObject = contracts
+    this.setStaticProvider(provider)
+  }
+
+  public setStaticProvider = (provider: StaticJsonRpcProvider) => {
+    this.provider = provider
+    const network = provider.network.chainId
+    if (this.options && this.options.graphURI) {
+      this.graphURI = this.options.graphURI
+    } else {
+      this.graphURI = graphURIEndpoints[network]
+    }
+    if (this.graphURI) {
+      const client = new GraphQLClient(this.graphURI, {
+        requestMiddleware: requestMiddleware(visit, parse, print),
+        responseMiddleware: responseMiddleware(traverse),
+      })
+      this.gqlInstance = {
+        client,
+        setUrl: () => Promise.resolve(),
+        gql,
+      }
+    }
+    this.contracts = new ContractManager(
+      provider,
+      this.getContractAddress(String(network) as SupportedNetworkId),
+      (name) =>
+        Promise.resolve(this.contractsObject[name as keyof Factories] as any),
+    )
+  }
+
+  public override setProvider = async (
+    provider: StaticJsonRpcProvider,
+  ): Promise<void> => {
+    this.setStaticProvider(provider)
+  }
+
+  protected override getModule = async () => this.functions
+
+  // eslint-disable-next-line class-methods-use-this
+  protected override getFunction = (
+    subFunc: FunctionSubtype | undefined,
+    _writeable: boolean | undefined,
+    exportName: string,
+    mod: any,
+    path: string,
+  ) => {
+    const base = mod[exportName === 'default' ? path : exportName]
+    if (subFunc === 'raw' || subFunc === 'decode') {
+      return base[subFunc]
+    }
+    return base
+  }
+}
+
+export default StaticENS

package/src/utils/ccip.ts

@@ -0,0 +1,149 @@
+import { BigNumber } from '@ethersproject/bignumber/lib/bignumber'
+import {
+  arrayify,
+  BytesLike,
+  hexConcat,
+  hexDataSlice,
+} from '@ethersproject/bytes'
+import type { BaseProvider, TransactionRequest } from '@ethersproject/providers'
+import { toUtf8String } from '@ethersproject/strings/lib/utf8'
+import type { Transaction } from '@ethersproject/transactions'
+
+function bytesPad(value: Uint8Array): Uint8Array {
+  if (value.length % 32 === 0) {
+    return value
+  }
+
+  const result = new Uint8Array(Math.ceil(value.length / 32) * 32)
+  result.set(value)
+  return result
+}
+
+function numPad(value: number): Uint8Array {
+  const result = arrayify(value)
+  if (result.length > 32) {
+    throw new Error('internal; should not happen')
+  }
+
+  const padded = new Uint8Array(32)
+  padded.set(result, 32 - result.length)
+  return padded
+}
+
+// ABI Encodes a series of (bytes, bytes, ...)
+function encodeBytes(datas: Array<BytesLike>) {
+  const result: Array<Uint8Array> = []
+
+  let byteCount = 0
+
+  // Add place-holders for pointers as we add items
+  for (let i = 0; i < datas.length; i += 1) {
+    result.push(new Uint8Array(0))
+    byteCount += 32
+  }
+
+  for (let i = 0; i < datas.length; i += 1) {
+    const data = arrayify(datas[i])
+
+    // Update the bytes offset
+    result[i] = numPad(byteCount)
+
+    // The length and padded value of data
+    result.push(numPad(data.length))
+    result.push(bytesPad(data))
+    byteCount += 32 + Math.ceil(data.length / 32) * 32
+  }
+
+  return hexConcat(result)
+}
+
+function _parseBytes(result: string, start: number): null | string {
+  if (result === '0x') {
+    return null
+  }
+
+  const offset = BigNumber.from(
+    hexDataSlice(result, start, start + 32),
+  ).toNumber()
+  const length = BigNumber.from(
+    hexDataSlice(result, offset, offset + 32),
+  ).toNumber()
+
+  return hexDataSlice(result, offset + 32, offset + 32 + length)
+}
+
+function _parseString(result: string, start: number): null | string {
+  try {
+    const bytes = _parseBytes(result, start)
+    if (bytes == null) return null
+    return toUtf8String(bytes)
+  } catch (error) {}
+  return null
+}
+
+const ccipLookup = async (
+  provider: BaseProvider,
+  transaction: TransactionRequest,
+  result: string,
+) => {
+  const txSender = transaction.to!
+  try {
+    const data = hexDataSlice(result, 4)
+
+    // Check the sender of the OffchainLookup matches the transaction
+    const sender = hexDataSlice(data, 0, 32)
+    if (!BigNumber.from(sender).eq(txSender)) {
+      throw new Error('CCIP Read sender did not match')
+    }
+
+    // Read the URLs from the response
+    const urls: Array<string> = []
+    const urlsOffset = BigNumber.from(hexDataSlice(data, 32, 64)).toNumber()
+    const urlsLength = BigNumber.from(
+      hexDataSlice(data, urlsOffset, urlsOffset + 32),
+    ).toNumber()
+    const urlsData = hexDataSlice(data, urlsOffset + 32)
+    for (let u = 0; u < urlsLength; u += 1) {
+      const url = _parseString(urlsData, u * 32)
+      if (url == null) {
+        throw new Error('CCIP Read contained corrupt URL string')
+      }
+      urls.push(url)
+    }
+
+    // Get the CCIP calldata to forward
+    const calldata = _parseBytes(data, 64)
+
+    // Get the callbackSelector (bytes4)
+    if (!BigNumber.from(hexDataSlice(data, 100, 128)).isZero()) {
+      throw new Error('CCIP Read callback selected included junk')
+    }
+    const callbackSelector = hexDataSlice(data, 96, 100)
+
+    // Get the extra data to send back to the contract as context
+    const extraData = _parseBytes(data, 128)
+
+    const ccipResult = await provider.ccipReadFetch(
+      <Transaction>transaction,
+      calldata!,
+      urls,
+    )
+    if (ccipResult == null) {
+      throw new Error('CCIP Read disabled or provided no URLs')
+    }
+
+    const tx = {
+      to: sender,
+      data: hexConcat([
+        callbackSelector,
+        encodeBytes([ccipResult, extraData!]),
+      ]),
+    }
+
+    return await provider._call(tx, 'latest', 1)
+  } catch (error) {
+    console.error(error)
+  }
+}
+
+export default ccipLookup

package/src/utils/consts.ts

@@ -0,0 +1 @@
+export const EMPTY_ADDRESS = '0x0000000000000000000000000000000000000000'

package/src/utils/contentHash.ts

@@ -1,5 +1,5 @@
 import contentHash from '@ensdomains/content-hash'
-import { utils } from 'ethers'
+import { isHexString } from '@ethersproject/bytes'
 
 export type DecodedContentHash = {
   protocolType?: any
@@ -19,20 +19,23 @@ const supportedCodecs = [
 
 function matchProtocol(text: string) {
   return (
-    text.match(/^(ipfs|sia|ipns|bzz|onion|onion3|arweave):\/\/(.*)/) ||
+    text.match(/^(ipfs|sia|ipns|bzz|onion|onion3|arweave|ar):\/\/(.*)/) ||
     text.match(/\/(ipfs)\/(.*)/) ||
     text.match(/\/(ipns)\/(.*)/)
   )
 }
 
 export function decodeContenthash(encoded: any) {
-  let decoded, protocolType, error
+  let decoded
+  let protocolType
+  let error
   if (!encoded || encoded === '0x') {
     return {}
   }
   if (encoded.error) {
     return { protocolType: null, decoded: encoded.error }
-  } else if (encoded === false) {
+  }
+  if (encoded === false) {
     return { protocolType: null, decoded: 'invalid value' }
   }
   if (encoded) {
@@ -52,7 +55,7 @@ export function decodeContenthash(encoded: any) {
       } else if (codec === 'skynet-ns') {
         protocolType = 'sia'
       } else if (codec === 'arweave-ns') {
-        protocolType = 'arweave'
+        protocolType = 'ar'
       } else {
         decoded = encoded
       }
@@ -73,19 +76,19 @@ export function validateContent(encoded: any) {
 export function isValidContenthash(encoded: any) {
   try {
     const codec = contentHash.getCodec(encoded)
-    return utils.isHexString(encoded) && supportedCodecs.includes(codec)
+    return isHexString(encoded) && supportedCodecs.includes(codec)
   } catch (e) {
     console.log(e)
   }
 }
 
 export function getProtocolType(encoded: any) {
-  let protocolType, decoded
+  let protocolType
+  let decoded
   try {
-    let matched = matchProtocol(encoded)
+    const matched = matchProtocol(encoded)
     if (matched) {
-      protocolType = matched[1]
-      decoded = matched[2]
+      ;[, protocolType, decoded] = matched
     }
     return {
       protocolType,
@@ -101,38 +104,37 @@ export function encodeContenthash(text: string) {
   let contentType
   let encoded: string | boolean = false
   let error
-  if (!!text) {
-    let matched = matchProtocol(text)
+  if (text) {
+    const matched = matchProtocol(text)
     if (matched) {
-      contentType = matched[1]
-      content = matched[2]
+      ;[, contentType, content] = matched
     }
     try {
       if (contentType === 'ipfs') {
         if (content.length >= 4) {
-          encoded = '0x' + contentHash.encode('ipfs-ns', content)
+          encoded = `0x${contentHash.encode('ipfs-ns', content)}`
         }
       } else if (contentType === 'ipns') {
-        encoded = '0x' + contentHash.encode('ipns-ns', content)
+        encoded = `0x${contentHash.encode('ipns-ns', content)}`
       } else if (contentType === 'bzz') {
         if (content.length >= 4) {
-          encoded = '0x' + contentHash.fromSwarm(content)
+          encoded = `0x${contentHash.fromSwarm(content)}`
         }
       } else if (contentType === 'onion') {
-        if (content.length == 16) {
-          encoded = '0x' + contentHash.encode('onion', content)
+        if (content.length === 16) {
+          encoded = `0x${contentHash.encode('onion', content)}`
         }
       } else if (contentType === 'onion3') {
-        if (content.length == 56) {
-          encoded = '0x' + contentHash.encode('onion3', content)
+        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)
+        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 if (contentType === 'arweave' || contentType === 'ar') {
+        if (content.length === 43) {
+          encoded = `0x${contentHash.encode('arweave-ns', content)}`
         }
       } else {
         console.warn('Unsupported protocol or invalid value', {
@@ -144,7 +146,7 @@ export function encodeContenthash(text: string) {
       const errorMessage = 'Error encoding content hash'
       console.warn(errorMessage, { text, encoded })
       error = errorMessage
-      //throw 'Error encoding content hash'
+      // throw 'Error encoding content hash'
     }
   }
   return { encoded, error }

package/src/utils/createReverseNode.ts

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

package/src/utils/fuses.ts

@@ -1,3 +1,5 @@
+import { BigNumber, BigNumberish } from '@ethersproject/bignumber/lib/bignumber'
+
 const CANNOT_UNWRAP = 1
 const CANNOT_BURN_FUSES = 2
 const CANNOT_TRANSFER = 4
@@ -7,7 +9,7 @@ const CANNOT_CREATE_SUBDOMAIN = 32
 const PARENT_CANNOT_CONTROL = 64
 const CAN_DO_EVERYTHING = 0
 
-export const testable = {
+export const fuseEnum = {
   CANNOT_UNWRAP,
   CANNOT_BURN_FUSES,
   CANNOT_TRANSFER,
@@ -15,9 +17,144 @@ export const testable = {
   CANNOT_SET_TTL,
   CANNOT_CREATE_SUBDOMAIN,
   PARENT_CANNOT_CONTROL,
-}
+} as const
+
+export type FuseOptions = { -readonly [K in keyof typeof fuseEnum]?: boolean }
+
+export const unnamedFuses = [
+  128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144,
+  524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, 67108864,
+  134217728, 268435456, 536870912, 1073741824, 2147483648, 4294967296,
+] as const
 
-export default {
-  ...testable,
+const fullFuseEnum = {
+  ...fuseEnum,
   CAN_DO_EVERYTHING,
 }
+
+export type FuseObj = typeof fuseEnum
+export type CurrentFuses = { [f in keyof FuseObj]: boolean } & {
+  CAN_DO_EVERYTHING: boolean
+}
+export type UnnamedFuseType = typeof unnamedFuses
+export type Fuse = keyof FuseObj
+export type UnnamedFuseValues = UnnamedFuseType[number]
+
+// We need this type so that the following type isn't infinite. This type limits the max length of the fuse array to 7.
+export type FuseArrayPossibilities =
+  | [Fuse]
+  | [Fuse, Fuse]
+  | [Fuse, Fuse, Fuse]
+  | [Fuse, Fuse, Fuse, Fuse]
+  | [Fuse, Fuse, Fuse, Fuse, Fuse]
+  | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse]
+  | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse, Fuse]
+
+/**
+ * This type creates a type error if there are any duplicate fuses.
+ * It effectively works like a reduce function, starting with 0 included types, adding a type each time, and then checking for duplicates.
+ *
+ * @template A The array to check for duplicates.
+ * @template B The union of all checked existing types.
+ */
+// CLAUSE A: This extension unwraps the type as a fuse tuple.
+type FusesWithoutDuplicates<A, B = never> = A extends FuseArrayPossibilities
+  ? // CLAUSE A > TRUE: CLAUSE B: Pick out the first item in the current array, separating the current item from the rest.
+    A extends [infer Head, ...infer Tail]
+    ? // CLAUSE B > TRUE: CLAUSE C: Check if the current item is a duplicate based on the input union.
+      Head extends B
+      ? // CLAUSE C > TRUE: Duplicate found, return an empty array to throw a type error.
+        []
+      : // CLAUSE C > FALSE: Return a new array to continue the recursion, adds the current item type to the union.
+        [Head, ...FusesWithoutDuplicates<Tail, Head | B>]
+    : // CLAUSE B > FALSE: Return the input array as there is no more array elements to check.
+      A
+  : // CLAUSE A > FALSE: Return an empty array as it isn't a fuse tuple.
+    []
+
+export type NamedFusesToBurn = FusesWithoutDuplicates<FuseArrayPossibilities>
+
+export type FusePropsNamedArray = {
+  namedFusesToBurn: NamedFusesToBurn
+}
+
+export type FusePropsUnnamedArray = {
+  unnamedFusesToBurn: UnnamedFuseValues[]
+}
+
+export type FusePropsNumber = {
+  fuseNumberToBurn: number
+}
+
+export type FuseProps =
+  | (Partial<FusePropsNamedArray> & FusePropsUnnamedArray)
+  | (FusePropsNamedArray & Partial<FusePropsUnnamedArray>)
+  | FusePropsNumber
+
+export const validateFuses = (fuses: FuseProps) => {
+  const isNumber = 'fuseNumberToBurn' in fuses
+  const hasNamedArray = 'namedFusesToBurn' in fuses
+  const hasUnnamedArray = 'unnamedFusesToBurn' in fuses
+
+  let encodedFuses: number = 0
+
+  if (isNumber) {
+    if (fuses.fuseNumberToBurn > 2 ** 32 || fuses.fuseNumberToBurn < 1) {
+      throw new Error(
+        `Fuse number must be limited to uint32, ${
+          fuses.fuseNumberToBurn
+        } was too ${fuses.fuseNumberToBurn < 1 ? 'low' : 'high'}.`,
+      )
+    } else if (fuses.fuseNumberToBurn % 1 !== 0) {
+      throw new Error(
+        `Fuse number must be an integer, ${fuses.fuseNumberToBurn} was not.`,
+      )
+    }
+    encodedFuses = fuses.fuseNumberToBurn
+  } else {
+    if (!hasNamedArray && !hasUnnamedArray) {
+      throw new Error('Please provide fuses to burn')
+    }
+    if (hasNamedArray) {
+      for (const fuse of fuses.namedFusesToBurn!) {
+        if (!(fuse in fuseEnum)) {
+          throw new Error(`${fuse} is not a valid named fuse.`)
+        }
+        encodedFuses |= fuseEnum[fuse]
+      }
+    }
+    if (hasUnnamedArray) {
+      for (const fuse of fuses.unnamedFusesToBurn!) {
+        if (!unnamedFuses.includes(fuse)) {
+          throw new Error(
+            `${fuse} is not a valid unnamed fuse. If you are trying to burn a named fuse, use the namedFusesToBurn property.`,
+          )
+        }
+        encodedFuses |= fuse
+      }
+    }
+  }
+
+  return encodedFuses
+}
+
+export const decodeFuses = (fuses: BigNumberish) => {
+  const bnFuses = BigNumber.from(fuses)
+
+  const fuseObj = Object.fromEntries(
+    Object.keys(fuseEnum).map((fuse) => [
+      fuse,
+      bnFuses.and(fuseEnum[fuse as keyof typeof fuseEnum]).gt(0),
+    ]),
+  )
+
+  if (bnFuses.eq(0)) {
+    fuseObj.CAN_DO_EVERYTHING = true
+  } else {
+    fuseObj.CAN_DO_EVERYTHING = false
+  }
+
+  return fuseObj as CurrentFuses
+}
+
+export default fullFuseEnum

package/src/utils/generateFuseInput.ts

@@ -1,18 +1,13 @@
-import { ethers } from 'ethers'
-import { FuseOptions } from '../@types/FuseOptions'
-import fuses from './fuses'
+import { BigNumber } from '@ethersproject/bignumber/lib/bignumber'
+import fuses, { FuseOptions } 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 fuseKeys = Object.keys(fuseOptions).filter(
+    (opt) => fuseOptions[opt as keyof FuseOptions] === true,
+  )
+
   const bigNumberFuses = fuseKeys.reduce((prev, curr) => {
     return prev.or(fuses[curr as keyof typeof fuses])
-  }, ethers.BigNumber.from(0))
+  }, BigNumber.from(0))
   return bigNumberFuses.toHexString()
 }

package/src/utils/labels.ts

@@ -1,6 +1,8 @@
-import { solidityKeccak256 } from 'ethers/lib/utils'
+import { keccak256 as solidityKeccak256 } from '@ethersproject/solidity'
 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/normalise.ts

@@ -1,5 +1,8 @@
-import { concat, hexlify, keccak256, toUtf8Bytes } from 'ethers/lib/utils'
+import { concat, hexlify } from '@ethersproject/bytes'
+import { keccak256 } from '@ethersproject/keccak256'
+import { toUtf8Bytes } from '@ethersproject/strings/lib/utf8'
 import uts46 from 'idna-uts46-hx/uts46bundle.js'
+import { decodeLabelhash, isEncodedLabelhash } from './labels'
 
 const zeros = new Uint8Array(32)
 zeros.fill(0)
@@ -7,16 +10,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]))
+    for (let i = labels.length - 1; i >= 0; i -= 1) {
+      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 {