@ensdomains/ensjs 3.0.0-alpha.6 → 3.0.0-alpha.61

package/src/static.ts

@@ -0,0 +1,94 @@
+import type { StaticJsonRpcProvider } from '@ethersproject/providers'
+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'
+import {
+  arrayify,
+  BytesLike,
+  hexConcat,
+  hexDataSlice,
+} from '@ethersproject/bytes'
+import type { BaseProvider, TransactionRequest } from '@ethersproject/providers'
+import { toUtf8String } from '@ethersproject/strings'
+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: txSender,
+      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,4 @@
+export const EMPTY_ADDRESS = '0x0000000000000000000000000000000000000000'
+export const MAX_INT_64 = BigInt('18446744073709551615')
+export const MAX_DATE_INT = 8640000000000000
+export const MINIMUM_DOT_ETH_CHARS = 3

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`