viem 0.2.11 → 0.2.13

package/src/utils/errors/getNodeError.ts

@@ -0,0 +1,76 @@
+import type { SendTransactionParameters } from '../../actions/index.js'
+import type { BaseError } from '../../errors/index.js'
+import {
+  ExecutionRevertedError,
+  FeeCapTooHighError,
+  FeeCapTooLowError,
+  InsufficientFundsError,
+  IntrinsicGasTooHighError,
+  IntrinsicGasTooLowError,
+  InvalidInputRpcError,
+  NonceMaxValueError,
+  NonceTooHighError,
+  NonceTooLowError,
+  RpcError,
+  TipAboveFeeCapError,
+  TransactionRejectedRpcError,
+  TransactionTypeNotSupportedError,
+  UnknownNodeError,
+} from '../../errors/index.js'
+
+export function containsNodeError(err: BaseError) {
+  return (
+    err instanceof TransactionRejectedRpcError ||
+    err instanceof InvalidInputRpcError ||
+    (err instanceof RpcError && err.code === ExecutionRevertedError.code)
+  )
+}
+
+export function getNodeError(
+  err: BaseError,
+  args: Partial<SendTransactionParameters<any>>,
+) {
+  const message = err.details.toLowerCase()
+  if (FeeCapTooHighError.nodeMessage.test(message))
+    return new FeeCapTooHighError({
+      cause: err,
+      maxFeePerGas: args?.maxFeePerGas,
+    })
+  else if (FeeCapTooLowError.nodeMessage.test(message))
+    return new FeeCapTooLowError({
+      cause: err,
+      maxFeePerGas: args?.maxFeePerGas,
+    })
+  else if (NonceTooHighError.nodeMessage.test(message))
+    return new NonceTooHighError({ cause: err, nonce: args?.nonce })
+  else if (NonceTooLowError.nodeMessage.test(message))
+    return new NonceTooLowError({ cause: err, nonce: args?.nonce })
+  else if (NonceMaxValueError.nodeMessage.test(message))
+    return new NonceMaxValueError({ cause: err, nonce: args?.nonce })
+  else if (InsufficientFundsError.nodeMessage.test(message))
+    return new InsufficientFundsError({ cause: err })
+  else if (IntrinsicGasTooHighError.nodeMessage.test(message))
+    return new IntrinsicGasTooHighError({ cause: err, gas: args?.gas })
+  else if (IntrinsicGasTooLowError.nodeMessage.test(message))
+    return new IntrinsicGasTooLowError({ cause: err, gas: args?.gas })
+  else if (TransactionTypeNotSupportedError.nodeMessage.test(message))
+    return new TransactionTypeNotSupportedError({ cause: err })
+  else if (TipAboveFeeCapError.nodeMessage.test(message))
+    return new TipAboveFeeCapError({
+      cause: err,
+      maxFeePerGas: args?.maxFeePerGas,
+      maxPriorityFeePerGas: args?.maxPriorityFeePerGas,
+    })
+  else if (
+    message.match(ExecutionRevertedError.nodeMessage) ||
+    ('code' in (err.cause as BaseError) &&
+      (err.cause as { code: number })?.code === ExecutionRevertedError.code)
+  )
+    return new ExecutionRevertedError({
+      cause: err,
+      message: (err.cause as BaseError).details,
+    })
+  return new UnknownNodeError({
+    cause: (err.cause as BaseError).cause as BaseError,
+  })
+}

package/src/utils/errors/getTransactionError.ts

@@ -0,0 +1,24 @@
+import type { BaseError } from '../../errors/index.js'
+import { TransactionExecutionError } from '../../errors/index.js'
+import type { Account, Chain } from '../../types/index.js'
+import type { SendTransactionParameters } from '../../wallet.js'
+import { containsNodeError, getNodeError } from './getNodeError.js'
+
+export function getTransactionError(
+  err: BaseError,
+  {
+    docsPath,
+    ...args
+  }: Omit<SendTransactionParameters, 'account' | 'chain'> & {
+    account: Account
+    chain?: Chain
+    docsPath?: string
+  },
+) {
+  let cause = err
+  if (containsNodeError(err)) cause = getNodeError(err, args)
+  return new TransactionExecutionError(cause, {
+    docsPath,
+    ...args,
+  })
+}

package/src/utils/errors/index.ts

@@ -0,0 +1,9 @@
+export { getCallError } from './getCallError.js'
+
+export { getContractError } from './getContractError.js'
+
+export { getEstimateGasError } from './getEstimateGasError.js'
+
+export { containsNodeError, getNodeError } from './getNodeError.js'
+
+export { getTransactionError } from './getTransactionError.js'

package/src/utils/formatters/block.ts

@@ -0,0 +1,46 @@
+import type {
+  Chain,
+  Block,
+  Formatter,
+  Formatters,
+  RpcBlock,
+} from '../../types/index.js'
+import { defineFormatter } from './format.js'
+import type { ExtractFormatter, Formatted } from './format.js'
+import { formatTransaction } from './transaction.js'
+
+export type BlockFormatter<TChain extends Chain | undefined = Chain> =
+  TChain extends Chain
+    ? ExtractFormatter<TChain, 'block', NonNullable<Formatters['block']>>
+    : Formatters['block']
+
+export type FormattedBlock<
+  TFormatter extends Formatter | undefined = Formatter,
+> = Formatted<TFormatter, Block>
+
+export function formatBlock(block: Partial<RpcBlock>) {
+  // TODO: Properly format transactions with a custom formatter
+  const transactions = block.transactions?.map((transaction) => {
+    if (typeof transaction === 'string') return transaction
+    return formatTransaction(transaction)
+  })
+  return {
+    ...block,
+    baseFeePerGas: block.baseFeePerGas ? BigInt(block.baseFeePerGas) : null,
+    difficulty: block.difficulty ? BigInt(block.difficulty) : undefined,
+    gasLimit: block.gasLimit ? BigInt(block.gasLimit) : undefined,
+    gasUsed: block.gasUsed ? BigInt(block.gasUsed) : undefined,
+    hash: block.hash ? block.hash : null,
+    logsBloom: block.logsBloom ? block.logsBloom : null,
+    nonce: block.nonce ? block.nonce : null,
+    number: block.number ? BigInt(block.number) : null,
+    size: block.size ? BigInt(block.size) : undefined,
+    timestamp: block.timestamp ? BigInt(block.timestamp) : undefined,
+    transactions,
+    totalDifficulty: block.totalDifficulty
+      ? BigInt(block.totalDifficulty)
+      : null,
+  } as Block
+}
+
+export const defineBlock = defineFormatter({ format: formatBlock })

package/src/utils/formatters/extract.ts

@@ -0,0 +1,18 @@
+import type { Formatter } from '../../types/index.js'
+
+/**
+ * @description Picks out the keys from `value` that exist in the formatter.
+ */
+export function extract(
+  value: Record<string, unknown>,
+  { formatter }: { formatter?: Formatter },
+) {
+  if (!formatter) return {}
+  const keys = Object.keys(formatter({}))
+  return keys.reduce((data, key) => {
+    if (value?.hasOwnProperty(key)) {
+      ;(data as any)[key] = value[key]
+    }
+    return data
+  }, {})
+}

package/src/utils/formatters/feeHistory.ts

@@ -0,0 +1,12 @@
+import type { FeeHistory, RpcFeeHistory } from '../../types/index.js'
+
+export function formatFeeHistory(feeHistory: RpcFeeHistory): FeeHistory {
+  return {
+    baseFeePerGas: feeHistory.baseFeePerGas.map((value) => BigInt(value)),
+    gasUsedRatio: feeHistory.gasUsedRatio,
+    oldestBlock: BigInt(feeHistory.oldestBlock),
+    reward: feeHistory.reward?.map((reward) =>
+      reward.map((value) => BigInt(value)),
+    ),
+  }
+}

package/src/utils/formatters/format.ts

@@ -0,0 +1,97 @@
+import type { Chain, Formatter, OptionalNullable } from '../../types/index.js'
+
+export type ExtractFormatter<
+  TChain extends Chain,
+  TKey extends keyof NonNullable<TChain['formatters']>,
+  TFallbackFormatter extends Formatter = Formatter,
+> = NonNullable<TChain['formatters']>[TKey] extends NonNullable<unknown>
+  ? NonNullable<TChain['formatters']>[TKey]
+  : TFallbackFormatter
+
+export type FormatOptions<TSource, TTarget> = {
+  formatter: Formatter<TSource, TTarget>
+}
+
+/**
+ * Creates a type that is the result of applying `TFormatter` to `TSource`.
+ *
+ * @example
+ * Formatted<() => { a: undefined, b: bigint }, { a: bigint }>
+ * => { a: undefined, b: bigint }
+ *
+ * @example
+ * Formatted<() => {}, { a: bigint }>
+ * => { a: bigint }
+ *
+ * @example
+ * Formatted<() => { a: bigint | undefined, b: bigint }, { a: bigint, b: bigint }, true>
+ * => { a?: bigint | undefined, b: bigint }
+ */
+export type Formatted<
+  TFormatter,
+  TFallback,
+  TAllowOptional = false,
+  TUseParameters = false,
+> = TFormatter extends Formatter
+  ? // If Formatter attributes exist, attach them; otherwise attach the Target type (e.g. Block).
+    ReturnType<TFormatter> extends Record<string, never>
+    ? TFallback
+    : TAllowOptional extends true
+    ? OptionalNullable<
+        TUseParameters extends true
+          ? Parameters<TFormatter>[0]
+          : ReturnType<TFormatter>
+      >
+    : TUseParameters extends true
+    ? Parameters<TFormatter>[0]
+    : ReturnType<TFormatter>
+  : never
+
+/**
+ * @description Formats a data object using the given replacer and an optional formatter.
+ */
+export function format<
+  TFormatter,
+  TSource extends Record<string, any>,
+  TTarget,
+>(data: TSource, { formatter }: FormatOptions<TSource, TTarget>) {
+  return formatter(data) as Formatted<TFormatter, TTarget>
+}
+
+export function defineFormatter<
+  TSource extends Record<string, unknown>,
+  TFormatted,
+>({
+  format,
+}: {
+  format: (data: TSource) => TFormatted
+}) {
+  return <
+      TFormat extends Formatter<
+        TSource,
+        Partial<TFormatted> & { [key: string]: unknown }
+      >,
+      TExclude extends (keyof TSource)[] = [],
+    >({
+      exclude,
+      format: formatOverride,
+    }: {
+      exclude?: TExclude
+      format?: TFormat
+    }) =>
+    (data: TSource & { [key: string]: unknown }) => {
+      const formatted = format(data)
+      if (exclude) {
+        for (const key of exclude) {
+          delete (formatted as any)[key]
+        }
+      }
+      return {
+        ...formatted,
+        ...formatOverride?.(data),
+      } as TFormatted &
+        ReturnType<TFormat> & {
+          [K in TExclude[number]]: never
+        }
+    }
+}

package/src/utils/formatters/index.ts

@@ -0,0 +1,37 @@
+export type { BlockFormatter, FormattedBlock } from './block.js'
+export { defineBlock, formatBlock } from './block.js'
+
+export { extract } from './extract.js'
+
+export { formatFeeHistory } from './feeHistory.js'
+
+export type { ExtractFormatter, FormatOptions, Formatted } from './format.js'
+export { defineFormatter, format } from './format.js'
+
+export type {
+  FormattedTransaction,
+  TransactionFormatter,
+} from './transaction.js'
+export {
+  defineTransaction,
+  formatTransaction,
+  transactionType,
+} from './transaction.js'
+
+export type {
+  FormattedTransactionReceipt,
+  TransactionReceiptFormatter,
+} from './transactionReceipt.js'
+export {
+  defineTransactionReceipt,
+  formatTransactionReceipt,
+} from './transactionReceipt.js'
+
+export type {
+  FormattedTransactionRequest,
+  TransactionRequestFormatter,
+} from './transactionRequest.js'
+export {
+  defineTransactionRequest,
+  formatTransactionRequest,
+} from './transactionRequest.js'

package/src/utils/formatters/log.ts

@@ -0,0 +1,18 @@
+import type { Log, RpcLog } from '../../types/index.js'
+
+export function formatLog(
+  log: Partial<RpcLog>,
+  { args, eventName }: { args?: unknown; eventName?: string } = {},
+) {
+  return {
+    ...log,
+    blockHash: log.blockHash ? log.blockHash : null,
+    blockNumber: log.blockNumber ? BigInt(log.blockNumber) : null,
+    logIndex: log.logIndex ? BigInt(log.logIndex) : null,
+    transactionHash: log.transactionHash ? log.transactionHash : null,
+    transactionIndex: log.transactionIndex
+      ? BigInt(log.transactionIndex)
+      : null,
+    ...(eventName ? { args, eventName } : {}),
+  } as Log
+}

package/src/utils/formatters/transaction.ts

@@ -0,0 +1,69 @@
+import type {
+  Chain,
+  Formatter,
+  Formatters,
+  RpcTransaction,
+  Transaction,
+} from '../../types/index.js'
+import { hexToNumber } from '../encoding/index.js'
+import { defineFormatter } from './format.js'
+import type { ExtractFormatter, Formatted } from './format.js'
+
+export type TransactionFormatter<TChain extends Chain | undefined = Chain> =
+  TChain extends Chain
+    ? ExtractFormatter<
+        TChain,
+        'transaction',
+        NonNullable<Formatters['transaction']>
+      >
+    : Formatters['transaction']
+
+export type FormattedTransaction<
+  TFormatter extends Formatter | undefined = Formatter,
+> = Formatted<TFormatter, Transaction>
+
+export const transactionType = {
+  '0x0': 'legacy',
+  '0x1': 'eip2930',
+  '0x2': 'eip1559',
+} as const
+
+export function formatTransaction(transaction: Partial<RpcTransaction>) {
+  const transaction_ = {
+    ...transaction,
+    blockHash: transaction.blockHash ? transaction.blockHash : null,
+    blockNumber: transaction.blockNumber
+      ? BigInt(transaction.blockNumber)
+      : null,
+    chainId: transaction.chainId ? hexToNumber(transaction.chainId) : undefined,
+    gas: transaction.gas ? BigInt(transaction.gas) : undefined,
+    gasPrice: transaction.gasPrice ? BigInt(transaction.gasPrice) : undefined,
+    maxFeePerGas: transaction.maxFeePerGas
+      ? BigInt(transaction.maxFeePerGas)
+      : undefined,
+    maxPriorityFeePerGas: transaction.maxPriorityFeePerGas
+      ? BigInt(transaction.maxPriorityFeePerGas)
+      : undefined,
+    nonce: transaction.nonce ? hexToNumber(transaction.nonce) : undefined,
+    to: transaction.to ? transaction.to : null,
+    transactionIndex: transaction.transactionIndex
+      ? Number(transaction.transactionIndex)
+      : null,
+    type: transaction.type ? transactionType[transaction.type] : undefined,
+    value: transaction.value ? BigInt(transaction.value) : undefined,
+    v: transaction.v ? BigInt(transaction.v) : undefined,
+  }
+
+  if (transaction_.type === 'legacy') {
+    delete transaction_['accessList']
+    delete transaction_['maxFeePerGas']
+    delete transaction_['maxPriorityFeePerGas']
+  }
+  if (transaction_.type === 'eip2930') {
+    delete transaction_['maxFeePerGas']
+    delete transaction_['maxPriorityFeePerGas']
+  }
+  return transaction_ as Transaction
+}
+
+export const defineTransaction = defineFormatter({ format: formatTransaction })

package/src/utils/formatters/transactionReceipt.ts

@@ -0,0 +1,71 @@
+import type {
+  Chain,
+  Formatter,
+  Formatters,
+  RpcTransactionReceipt,
+  TransactionReceipt,
+} from '../../types/index.js'
+import { hexToNumber } from '../encoding/index.js'
+import { defineFormatter } from './format.js'
+import type { ExtractFormatter, Formatted } from './format.js'
+import { formatLog } from './log.js'
+import { transactionType } from './transaction.js'
+
+export type TransactionReceiptFormatter<
+  TChain extends Chain | undefined = Chain,
+> = TChain extends Chain
+  ? ExtractFormatter<
+      TChain,
+      'transactionReceipt',
+      NonNullable<Formatters['transactionReceipt']>
+    >
+  : Formatters['transactionReceipt']
+
+export type FormattedTransactionReceipt<
+  TFormatter extends Formatter | undefined = Formatter,
+> = Formatted<TFormatter, TransactionReceipt>
+
+const statuses = {
+  '0x0': 'reverted',
+  '0x1': 'success',
+} as const
+
+export function formatTransactionReceipt(
+  transactionReceipt: Partial<RpcTransactionReceipt>,
+) {
+  return {
+    ...transactionReceipt,
+    blockNumber: transactionReceipt.blockNumber
+      ? BigInt(transactionReceipt.blockNumber)
+      : null,
+    contractAddress: transactionReceipt.contractAddress
+      ? transactionReceipt.contractAddress
+      : null,
+    cumulativeGasUsed: transactionReceipt.cumulativeGasUsed
+      ? BigInt(transactionReceipt.cumulativeGasUsed)
+      : null,
+    effectiveGasPrice: transactionReceipt.effectiveGasPrice
+      ? BigInt(transactionReceipt.effectiveGasPrice)
+      : null,
+    gasUsed: transactionReceipt.gasUsed
+      ? BigInt(transactionReceipt.gasUsed)
+      : null,
+    logs: transactionReceipt.logs
+      ? transactionReceipt.logs.map((log) => formatLog(log))
+      : null,
+    to: transactionReceipt.to ? transactionReceipt.to : null,
+    transactionIndex: transactionReceipt.transactionIndex
+      ? hexToNumber(transactionReceipt.transactionIndex)
+      : null,
+    status: transactionReceipt.status
+      ? statuses[transactionReceipt.status]
+      : null,
+    type: transactionReceipt.type
+      ? transactionType[transactionReceipt.type]
+      : null,
+  } as TransactionReceipt
+}
+
+export const defineTransactionReceipt = defineFormatter({
+  format: formatTransactionReceipt,
+})

package/src/utils/formatters/transactionRequest.ts

@@ -0,0 +1,60 @@
+import type {
+  Chain,
+  Formatter,
+  Formatters,
+  RpcTransactionRequest,
+  TransactionRequest,
+} from '../../types/index.js'
+import { defineFormatter } from './format.js'
+import type { ExtractFormatter, Formatted } from './format.js'
+import { numberToHex } from '../encoding/index.js'
+
+export type TransactionRequestFormatter<
+  TChain extends Chain | undefined = Chain,
+> = TChain extends Chain
+  ? ExtractFormatter<
+      TChain,
+      'transactionRequest',
+      NonNullable<Formatters['transactionRequest']>
+    >
+  : Formatters['transactionRequest']
+
+export type FormattedTransactionRequest<
+  TFormatter extends Formatter | undefined = Formatter,
+> = Formatted<TFormatter, RpcTransactionRequest>
+
+export function formatTransactionRequest(
+  transactionRequest: Partial<TransactionRequest>,
+) {
+  return {
+    ...transactionRequest,
+    gas:
+      typeof transactionRequest.gas !== 'undefined'
+        ? numberToHex(transactionRequest.gas)
+        : undefined,
+    gasPrice:
+      typeof transactionRequest.gasPrice !== 'undefined'
+        ? numberToHex(transactionRequest.gasPrice)
+        : undefined,
+    maxFeePerGas:
+      typeof transactionRequest.maxFeePerGas !== 'undefined'
+        ? numberToHex(transactionRequest.maxFeePerGas)
+        : undefined,
+    maxPriorityFeePerGas:
+      typeof transactionRequest.maxPriorityFeePerGas !== 'undefined'
+        ? numberToHex(transactionRequest.maxPriorityFeePerGas)
+        : undefined,
+    nonce:
+      typeof transactionRequest.nonce !== 'undefined'
+        ? numberToHex(transactionRequest.nonce)
+        : undefined,
+    value:
+      typeof transactionRequest.value !== 'undefined'
+        ? numberToHex(transactionRequest.value)
+        : undefined,
+  } as RpcTransactionRequest
+}
+
+export const defineTransactionRequest = defineFormatter({
+  format: formatTransactionRequest,
+})

package/src/utils/hash/getEventSelector.ts

@@ -0,0 +1,4 @@
+import type { EventDefinition } from '../../types/index.js'
+import { hashFunction } from './hashFunction.js'
+
+export const getEventSelector = (event: EventDefinition) => hashFunction(event)

package/src/utils/hash/getFunctionSelector.ts

@@ -0,0 +1,4 @@
+import { slice } from '../data/index.js'
+import { hashFunction } from './hashFunction.js'
+
+export const getFunctionSelector = (fn: string) => slice(hashFunction(fn), 0, 4)

package/src/utils/hash/hashFunction.ts

@@ -0,0 +1,15 @@
+import { toBytes } from '../encoding/index.js'
+import {
+  extractFunctionName,
+  extractFunctionParams,
+} from '../contract/index.js'
+import { keccak256 } from './keccak256.js'
+
+const hash = (value: string) => keccak256(toBytes(value))
+
+export function hashFunction(def: string) {
+  const name = extractFunctionName(def)
+  const params = extractFunctionParams(def)
+  if (!params || params.length === 0) return hash(def.replace(/ /g, ''))
+  return hash(`${name}(${params.map(({ type }) => type).join(',')})`)
+}

package/src/utils/hash/index.ts

@@ -0,0 +1,7 @@
+export { getEventSelector } from './getEventSelector.js'
+
+export { getFunctionSelector } from './getFunctionSelector.js'
+
+export { isHash } from './isHash.js'
+
+export { keccak256 } from './keccak256.js'

package/src/utils/hash/isHash.ts

@@ -0,0 +1,6 @@
+import type { Hex } from '../../types/index.js'
+import { isHex, size } from '../data/index.js'
+
+export function isHash(hash: string): hash is Hex {
+  return isHex(hash) && size(hash) === 32
+}

package/src/utils/hash/keccak256.ts

@@ -0,0 +1,21 @@
+import { keccak_256 } from '@noble/hashes/sha3'
+
+import type { ByteArray, Hex } from '../../types/index.js'
+import { isHex } from '../data/index.js'
+import { toBytes, toHex } from '../encoding/index.js'
+
+type To = 'hex' | 'bytes'
+
+export type Keccak256Hash<TTo extends To> =
+  | (TTo extends 'bytes' ? ByteArray : never)
+  | (TTo extends 'hex' ? Hex : never)
+
+export function keccak256<TTo extends To = 'hex'>(
+  value: Hex | ByteArray,
+  to_?: TTo,
+): Keccak256Hash<TTo> {
+  const to = to_ || 'hex'
+  const bytes = keccak_256(isHex(value) ? toBytes(value) : value)
+  if (to === 'bytes') return bytes as Keccak256Hash<TTo>
+  return toHex(bytes) as Keccak256Hash<TTo>
+}