viem 1.6.4 → 1.6.5

package/chains/src/optimism/formatters.ts

@@ -0,0 +1,77 @@
+import {
+  type Hash,
+  type RpcTransaction,
+  formatTransaction,
+  hexToBigInt,
+} from 'viem'
+
+import type { ChainFormatters } from '../types.js'
+import {
+  defineBlock,
+  defineTransaction,
+  defineTransactionReceipt,
+} from '../utils.js'
+import type {
+  OptimismBlockOverrides,
+  OptimismRpcBlockOverrides,
+  OptimismRpcTransaction,
+  OptimismRpcTransactionReceiptOverrides,
+  OptimismTransaction,
+  OptimismTransactionReceiptOverrides,
+} from './types.js'
+
+export const formattersOptimism = {
+  block: /*#__PURE__*/ defineBlock({
+    format(
+      args: OptimismRpcBlockOverrides & {
+        transactions: Hash[] | OptimismRpcTransaction[]
+      },
+    ): OptimismBlockOverrides & {
+      transactions: Hash[] | OptimismTransaction[]
+    } {
+      const transactions = args.transactions?.map((transaction) => {
+        if (typeof transaction === 'string') return transaction
+        const formatted = formatTransaction(
+          transaction as RpcTransaction,
+        ) as OptimismTransaction
+        if (formatted.typeHex === '0x7e') {
+          formatted.isSystemTx = transaction.isSystemTx
+          formatted.mint = transaction.mint
+            ? hexToBigInt(transaction.mint)
+            : undefined
+          formatted.sourceHash = transaction.sourceHash
+          formatted.type = 'deposit'
+        }
+        return formatted
+      }) as Hash[] | OptimismTransaction[]
+      return {
+        transactions,
+        stateRoot: args.stateRoot,
+      }
+    },
+  }),
+  transaction: /*#__PURE__*/ defineTransaction({
+    format(args: OptimismRpcTransaction): OptimismTransaction {
+      const transaction = {} as OptimismTransaction
+      if (args.type === '0x7e') {
+        transaction.isSystemTx = args.isSystemTx
+        transaction.mint = args.mint ? hexToBigInt(args.mint) : undefined
+        transaction.sourceHash = args.sourceHash
+        transaction.type = 'deposit'
+      }
+      return transaction
+    },
+  }),
+  transactionReceipt: /*#__PURE__*/ defineTransactionReceipt({
+    format(
+      args: OptimismRpcTransactionReceiptOverrides,
+    ): OptimismTransactionReceiptOverrides {
+      return {
+        l1GasPrice: args.l1GasPrice ? hexToBigInt(args.l1GasPrice) : null,
+        l1GasUsed: args.l1GasUsed ? hexToBigInt(args.l1GasUsed) : null,
+        l1Fee: args.l1Fee ? hexToBigInt(args.l1Fee) : null,
+        l1FeeScalar: args.l1FeeScalar ? Number(args.l1FeeScalar) : null,
+      }
+    },
+  }),
+} as const satisfies ChainFormatters

package/chains/src/optimism/types.ts

@@ -0,0 +1,102 @@
+import type {
+  Block,
+  BlockTag,
+  FeeValuesEIP1559,
+  Hash,
+  Hex,
+  Index,
+  Quantity,
+  RpcBlock,
+  RpcTransaction as RpcTransaction_,
+  RpcTransactionReceipt,
+  Transaction as Transaction_,
+  TransactionBase,
+  TransactionReceipt,
+} from 'viem'
+
+export type OptimismBlockOverrides = {
+  stateRoot: Hash
+}
+export type OptimismBlock<
+  TIncludeTransactions extends boolean = boolean,
+  TBlockTag extends BlockTag = BlockTag,
+> = Block<
+  bigint,
+  TIncludeTransactions,
+  TBlockTag,
+  OptimismTransaction<TBlockTag extends 'pending' ? true : false>
+> &
+  OptimismBlockOverrides
+
+export type OptimismRpcBlockOverrides = {
+  stateRoot: Hash
+}
+export type OptimismRpcBlock<
+  TBlockTag extends BlockTag = BlockTag,
+  TIncludeTransactions extends boolean = boolean,
+> = RpcBlock<
+  TBlockTag,
+  TIncludeTransactions,
+  OptimismRpcTransaction<TBlockTag extends 'pending' ? true : false>
+> &
+  OptimismRpcBlockOverrides
+
+type RpcTransaction<TPending extends boolean = boolean> =
+  RpcTransaction_<TPending> & {
+    isSystemTx?: undefined
+    mint?: undefined
+    sourceHash?: undefined
+  }
+
+export type OptimismRpcDepositTransaction<TPending extends boolean = boolean> =
+  Omit<TransactionBase<Quantity, Index, TPending>, 'typeHex'> &
+    FeeValuesEIP1559<Quantity> & {
+      isSystemTx?: boolean
+      mint?: Hex
+      sourceHash: Hex
+      type: '0x7e'
+    }
+export type OptimismRpcTransaction<TPending extends boolean = boolean> =
+  | RpcTransaction<TPending>
+  | OptimismRpcDepositTransaction<TPending>
+
+export type OptimismRpcTransactionReceiptOverrides = {
+  l1GasPrice: Hex | null
+  l1GasUsed: Hex | null
+  l1Fee: Hex | null
+  l1FeeScalar: `${number}` | null
+}
+export type OptimismRpcTransactionReceipt = RpcTransactionReceipt &
+  OptimismRpcTransactionReceiptOverrides
+
+type Transaction<TPending extends boolean = boolean> = Transaction_<
+  bigint,
+  number,
+  TPending
+> & {
+  isSystemTx?: undefined
+  mint?: undefined
+  sourceHash?: undefined
+}
+
+export type OptimismDepositTransaction<TPending extends boolean = boolean> =
+  TransactionBase<bigint, number, TPending> &
+    FeeValuesEIP1559 & {
+      isSystemTx?: boolean
+      mint?: bigint
+      sourceHash: Hex
+      type: 'deposit'
+    }
+
+export type OptimismTransaction<TPending extends boolean = boolean> =
+  | Transaction<TPending>
+  | OptimismDepositTransaction<TPending>
+
+export type OptimismTransactionReceiptOverrides = {
+  l1GasPrice: bigint | null
+  l1GasUsed: bigint | null
+  l1Fee: bigint | null
+  l1FeeScalar: number | null
+}
+export type OptimismTransactionReceipt = TransactionReceipt &
+  OptimismTransactionReceiptOverrides

package/chains/src/types.ts

@@ -0,0 +1,164 @@
+import type { Address } from 'abitype'
+import type {
+  Account,
+  Client,
+  EstimateFeesPerGasReturnType,
+  FeeValuesType,
+  FormattedBlock,
+  PrepareRequestParameters,
+  SerializeTransactionFn,
+  TransactionSerializable,
+  TransactionSerializableGeneric,
+  Transport,
+} from 'viem'
+import type { Prettify } from 'viem/internal'
+
+export type Chain<
+  formatters extends ChainFormatters | undefined = ChainFormatters | undefined,
+> = import('@wagmi/chains').Chain & ChainConfig<formatters>
+
+export type ChainConfig<
+  formatters extends ChainFormatters | undefined = ChainFormatters | undefined,
+> = {
+  /**
+   * Modifies how chain data structures (ie. Blocks, Transactions, etc)
+   * are formatted & typed.
+   */
+  formatters?: formatters | undefined
+  /** Modifies how data (ie. Transactions) is serialized. */
+  serializers?: ChainSerializers<formatters> | undefined
+  /** Modifies how fees are derived. */
+  fees?: ChainFees<formatters> | undefined
+}
+
+export type ChainContract = {
+  address: Address
+  blockCreated?: number
+}
+
+export type ChainFees<
+  formatters extends ChainFormatters | undefined = ChainFormatters | undefined,
+> = {
+  /**
+   * The fee multiplier to use to account for fee fluctuations.
+   * Used in the [`estimateFeesPerGas` Action](/docs/actions/public/estimateFeesPerGas).
+   *
+   * @default 1.2
+   */
+  baseFeeMultiplier?:
+    | number
+    | ((args: ChainFeesFnParameters<formatters>) => Promise<number> | number)
+  /**
+   * The default `maxPriorityFeePerGas` to use when a priority
+   * fee is not defined upon sending a transaction.
+   *
+   * Overrides the return value in the [`estimateMaxPriorityFeePerGas` Action](/docs/actions/public/estimateMaxPriorityFeePerGas).
+   */
+  defaultPriorityFee?:
+    | bigint
+    | ((args: ChainFeesFnParameters<formatters>) => Promise<bigint> | bigint)
+  /**
+   * Allows customization of fee per gas values (e.g. `maxFeePerGas`/`maxPriorityFeePerGas`).
+   *
+   * Overrides the return value in the [`estimateFeesPerGas` Action](/docs/actions/public/estimateFeesPerGas).
+   */
+  estimateFeesPerGas?: (
+    args: ChainEstimateFeesPerGasFnParameters<formatters>,
+  ) => Promise<EstimateFeesPerGasReturnType> | bigint
+}
+
+export type ChainFormatters = {
+  /** Modifies how the Block structure is formatted & typed. */
+  block?: ChainFormatter<'block'>
+  /** Modifies how the Transaction structure is formatted & typed. */
+  transaction?: ChainFormatter<'transaction'>
+  /** Modifies how the TransactionReceipt structure is formatted & typed. */
+  transactionReceipt?: ChainFormatter<'transactionReceipt'>
+  /** Modifies how the TransactionRequest structure is formatted & typed. */
+  transactionRequest?: ChainFormatter<'transactionRequest'>
+}
+
+export type ChainFormatter<type extends string = string> = {
+  format: (args: any) => any
+  type: type
+}
+
+export type ChainSerializers<
+  formatters extends ChainFormatters | undefined = undefined,
+> = {
+  /** Modifies how Transactions are serialized. */
+  transaction?: SerializeTransactionFn<
+    formatters extends ChainFormatters
+      ? formatters['transactionRequest'] extends ChainFormatter
+        ? TransactionSerializableGeneric &
+            Parameters<formatters['transactionRequest']['format']>[0]
+        : TransactionSerializable
+      : TransactionSerializable
+  >
+}
+
+/////////////////////////////////////////////////////////////////////
+// Parameters
+
+export type ChainFeesFnParameters<
+  formatters extends ChainFormatters | undefined = ChainFormatters | undefined,
+> = {
+  /** The latest block. */
+  block: Prettify<FormattedBlock<{ formatters: formatters }>>
+  client: Client<Transport, Chain>
+  /**
+   * A transaction request. This value will be undefined if the caller
+   * is outside of a transaction request context (e.g. a direct call to
+   * the `estimateFeesPerGas` Action).
+   */
+  request?: PrepareRequestParameters<
+    Omit<Chain, 'formatters'> & { formatters: formatters },
+    Account | undefined,
+    undefined
+  >
+}
+
+export type ChainEstimateFeesPerGasFnParameters<
+  formatters extends ChainFormatters | undefined = ChainFormatters | undefined,
+> = {
+  /**
+   * A function to multiply the base fee based on the `baseFeeMultiplier` value.
+   */
+  multiply(x: bigint): bigint
+  /**
+   * The type of fees to return.
+   */
+  type: FeeValuesType
+} & ChainFeesFnParameters<formatters>
+
+/////////////////////////////////////////////////////////////////////
+// Utils
+
+export type ExtractChainFormatterExclude<
+  chain extends { formatters?: Chain['formatters'] } | undefined,
+  type extends keyof ChainFormatters,
+> = chain extends { formatters?: infer _Formatters extends ChainFormatters }
+  ? _Formatters[type] extends { exclude: infer Exclude }
+    ? Extract<Exclude, string[]>[number]
+    : ''
+  : ''
+
+export type ExtractChainFormatterParameters<
+  chain extends { formatters?: Chain['formatters'] } | undefined,
+  type extends keyof ChainFormatters,
+  fallback,
+> = chain extends { formatters?: infer _Formatters extends ChainFormatters }
+  ? _Formatters[type] extends ChainFormatter
+    ? Parameters<_Formatters[type]['format']>[0]
+    : fallback
+  : fallback
+
+export type ExtractChainFormatterReturnType<
+  chain extends { formatters?: Chain['formatters'] } | undefined,
+  type extends keyof ChainFormatters,
+  fallback,
+> = chain extends { formatters?: infer _Formatters extends ChainFormatters }
+  ? _Formatters[type] extends ChainFormatter
+    ? ReturnType<_Formatters[type]['format']>
+    : fallback
+  : fallback

package/chains/src/utils.test.ts

@@ -0,0 +1,14 @@
+import { expect, test } from 'vitest'
+
+import * as utils from './utils.js'
+
+test('exports', () => {
+  expect(Object.keys(utils)).toMatchInlineSnapshot(`
+    [
+      "formattersCelo",
+      "serializeTransactionCelo",
+      "serializersCelo",
+      "formattersOptimism",
+    ]
+  `)
+})

package/chains/src/utils.ts

@@ -0,0 +1,128 @@
+import {
+  formatBlock,
+  formatTransaction,
+  formatTransactionReceipt,
+  formatTransactionRequest,
+} from 'viem'
+import type { Assign, Prettify } from 'viem/internal'
+
+import type { Chain, ChainConfig, ChainFormatters } from './types.js'
+
+export function defineChain<
+  chain extends Chain,
+  formatters extends ChainFormatters,
+>(
+  chain: chain,
+  config: ChainConfig<formatters> = {},
+): Assign<chain, ChainConfig<formatters>> {
+  const {
+    fees = chain.fees,
+    formatters = chain.formatters,
+    serializers = chain.serializers,
+  } = config
+  return {
+    ...chain,
+    fees,
+    formatters,
+    serializers,
+  } as unknown as Assign<chain, ChainConfig<formatters>>
+}
+
+export function defineFormatter<TType extends string, TParameters, TReturnType>(
+  type: TType,
+  format: (_: TParameters) => TReturnType,
+) {
+  return <
+    TOverrideParameters,
+    TOverrideReturnType,
+    TExclude extends (keyof TParameters)[] = [],
+  >({
+    exclude,
+    format: overrides,
+  }: {
+    exclude?: TExclude
+    format: (_: TOverrideParameters) => TOverrideReturnType
+  }) => {
+    return {
+      exclude,
+      format: (args: Assign<TParameters, TOverrideParameters>) => {
+        const formatted = format(args as any)
+        if (exclude) {
+          for (const key of exclude) {
+            delete (formatted as any)[key]
+          }
+        }
+        return {
+          ...formatted,
+          ...overrides(args),
+        } as Prettify<Assign<TReturnType, TOverrideReturnType>> & {
+          [K in TExclude[number]]: never
+        }
+      },
+      type,
+    }
+  }
+}
+
+export const defineBlock = /*#__PURE__*/ defineFormatter('block', formatBlock)
+export const defineTransaction = /*#__PURE__*/ defineFormatter(
+  'transaction',
+  formatTransaction,
+)
+export const defineTransactionReceipt = /*#__PURE__*/ defineFormatter(
+  'transactionReceipt',
+  formatTransactionReceipt,
+)
+export const defineTransactionRequest = /*#__PURE__*/ defineFormatter(
+  'transactionRequest',
+  formatTransactionRequest,
+)
+
+///////////////////////////////////////////////////////////////
+// Exports
+
+export { formattersCelo } from './celo/formatters.js'
+export {
+  serializeTransactionCelo,
+  serializersCelo,
+} from './celo/serializers.js'
+export { parseTransactionCelo } from './celo/parsers.js'
+export type {
+  CeloBlock,
+  CeloBlockOverrides,
+  CeloRpcBlock,
+  CeloRpcBlockOverrides,
+  CeloRpcTransaction,
+  CeloRpcTransactionOverrides,
+  CeloRpcTransactionReceipt,
+  CeloRpcTransactionReceiptOverrides,
+  CeloRpcTransactionRequest,
+  CeloRpcTransactionRequestOverrides,
+  CeloTransaction,
+  CeloTransactionOverrides,
+  CeloTransactionReceipt,
+  CeloTransactionReceiptOverrides,
+  CeloTransactionRequest,
+  CeloTransactionRequestOverrides,
+  CeloTransactionSerializable,
+  CeloTransactionSerialized,
+  CeloTransactionType,
+  TransactionSerializableCIP42,
+  TransactionSerializedCIP42,
+} from './celo/types.js'
+
+export { formattersOptimism } from './optimism/formatters.js'
+export type {
+  OptimismBlock,
+  OptimismBlockOverrides,
+  OptimismDepositTransaction,
+  OptimismRpcBlock,
+  OptimismRpcBlockOverrides,
+  OptimismRpcDepositTransaction,
+  OptimismRpcTransaction,
+  OptimismRpcTransactionReceipt,
+  OptimismRpcTransactionReceiptOverrides,
+  OptimismTransaction,
+  OptimismTransactionReceipt,
+  OptimismTransactionReceiptOverrides,
+} from './optimism/types.js'

package/chains/tsconfig.base.json

@@ -0,0 +1,45 @@
+{
+  // This tsconfig file contains the shared config for the build (tsconfig.build.json) and type checking (tsconfig.json) config.
+  "include": [],
+  "compilerOptions": {
+    // Incremental builds
+    // NOTE: Enabling incremental builds speeds up `tsc`. Keep in mind though that it does not reliably bust the cache when the `tsconfig.json` file changes.
+    "incremental": true,
+
+    // Type checking
+    "strict": true,
+    "useDefineForClassFields": true, // Not enabled by default in `strict` mode unless we bump `target` to ES2022.
+    "noFallthroughCasesInSwitch": true, // Not enabled by default in `strict` mode.
+    "noImplicitReturns": true, // Not enabled by default in `strict` mode.
+    "useUnknownInCatchVariables": true, // TODO: This would normally be enabled in `strict` mode but would require some adjustments to the codebase.
+    "noImplicitOverride": true, // Not enabled by default in `strict` mode.
+    "noUnusedLocals": true, // Not enabled by default in `strict` mode.
+    "noUnusedParameters": true, // Not enabled by default in `strict` mode.
+    // TODO: The following options are also not enabled by default in `strict` mode and would be nice to have but would require some adjustments to the codebase.
+    // "exactOptionalPropertyTypes": true,
+    // "noUncheckedIndexedAccess": true,
+
+    // JavaScript support
+    "allowJs": false,
+    "checkJs": false,
+
+    // Interop constraints
+    "esModuleInterop": false,
+    "allowSyntheticDefaultImports": false,
+    "forceConsistentCasingInFileNames": true,
+    "verbatimModuleSyntax": true,
+    "importHelpers": true, // This is only used for build validation. Since we do not have `tslib` installed, this will fail if we accidentally make use of anything that'd require injection of helpers.
+
+    // Language and environment
+    "moduleResolution": "NodeNext",
+    "module": "ESNext",
+    "target": "ES2021", // Setting this to `ES2021` enables native support for `Node v16+`: https://github.com/microsoft/TypeScript/wiki/Node-Target-Mapping.
+    "lib": [
+      "ES2022", // By using ES2022 we get access to the `.cause` property on `Error` instances.
+      "DOM" // We are adding `DOM` here to get the `fetch`, etc. types. This should be removed once these types are available via DefinitelyTyped.
+    ],
+
+    // Skip type checking for node modules
+    "skipLibCheck": true
+  }
+}

package/chains/tsconfig.build.json

@@ -0,0 +1,15 @@
+{
+  // This file is used to compile the for cjs and esm (see package.json build scripts). It should exclude all test files.
+  "extends": "./tsconfig.base.json",
+  "include": ["src"],
+  "exclude": [
+    "src/**/*.test.ts",
+    "src/**/*.test-d.ts",
+    "src/**/*.bench.ts",
+    "src/_test"
+  ],
+  "compilerOptions": {
+    "sourceMap": true,
+    "rootDir": "./src"
+  }
+}

package/chains/tsconfig.json

@@ -0,0 +1,6 @@
+{
+  // This configuration is used for local development and type checking.
+  "extends": "./tsconfig.base.json",
+  "include": ["src"],
+  "exclude": []
+}