viem 0.0.0-main.20230620T232415 → 0.0.0-main.20230621T010720

package/src/chains/formatters/optimism.ts

@@ -0,0 +1,88 @@
+import { defineBlock, formatTransaction } from '../../index.js'
+import type { FeeValuesEIP1559 } from '../../types/fee.js'
+import type { Hash, Hex } from '../../types/misc.js'
+import type {
+  Index,
+  Quantity,
+  RpcTransaction as RpcTransaction_,
+} from '../../types/rpc.js'
+import type {
+  Transaction as Transaction_,
+  TransactionBase,
+} from '../../types/transaction.js'
+import { hexToBigInt } from '../../utils/encoding/fromHex.js'
+import { defineTransaction } from '../../utils/formatters/transaction.js'
+
+type RpcTransaction = RpcTransaction_ & {
+  isSystemTx?: undefined
+  mint?: undefined
+  sourceHash?: undefined
+}
+
+type RpcDepositTransaction = TransactionBase<Quantity, Index> &
+  FeeValuesEIP1559<Quantity> & {
+    isSystemTx?: boolean
+    mint?: Hex
+    sourceHash: Hex
+    type: '0x7e'
+  }
+
+type Transaction = Transaction_ & {
+  isSystemTx?: undefined
+  mint?: undefined
+  sourceHash?: undefined
+}
+
+type DepositTransaction = TransactionBase &
+  FeeValuesEIP1559 & {
+    isSystemTx?: boolean
+    mint?: bigint
+    sourceHash: Hex
+    type: 'deposit'
+  }
+
+type OptimismOverrides = {
+  RpcBlock: {
+    transactions: Hash[] | OptimismOverrides['RpcTransaction'][]
+  }
+  RpcTransaction: RpcTransaction | RpcDepositTransaction
+  Transaction: Transaction | DepositTransaction
+}
+
+export const optimismFormatters = {
+  block: /*#__PURE__*/ defineBlock({
+    exclude: ['difficulty', 'gasLimit', 'mixHash', 'nonce', 'uncles'],
+    format(args: OptimismOverrides['RpcBlock']) {
+      const transactions = args.transactions?.map((transaction) => {
+        if (typeof transaction === 'string') return transaction
+        const formatted = formatTransaction(
+          transaction as RpcTransaction,
+        ) as OptimismOverrides['Transaction']
+        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[] | OptimismOverrides['Transaction'][]
+      return {
+        transactions,
+      }
+    },
+  }),
+  transaction: /*#__PURE__*/ defineTransaction({
+    format(args: OptimismOverrides['RpcTransaction']) {
+      const transaction = {} as OptimismOverrides['Transaction']
+      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
+    },
+  }),
+} as const

package/src/{chains.ts → chains/index.ts}

@@ -1,53 +1,9 @@
 import * as chains from '@wagmi/chains'
 
-import type { Address } from 'abitype'
+import { defineChain } from '../utils/chain.js'
+import { celoFormatters } from './formatters/celo.js'
+import { optimismFormatters } from './formatters/optimism.js'
 
-import type { Hex } from './types/misc.js'
-import type { Quantity } from './types/rpc.js'
-import { defineChain } from './utils/chain.js'
-import { defineBlock } from './utils/formatters/block.js'
-import { defineTransaction } from './utils/formatters/transaction.js'
-import { defineTransactionReceipt } from './utils/formatters/transactionReceipt.js'
-import { defineTransactionRequest } from './utils/formatters/transactionRequest.js'
-
-const celoFormatters = {
-  block: /*#__PURE__*/ defineBlock({
-    exclude: ['difficulty', 'gasLimit', 'mixHash', 'nonce', 'uncles'],
-    format: (block) => ({
-      randomness: block.randomness as {
-        committed: Hex
-        revealed: Hex
-      },
-    }),
-  }),
-  transaction: /*#__PURE__*/ defineTransaction({
-    format: (transaction) => ({
-      feeCurrency: transaction.feeCurrency as Address | null,
-      gatewayFee: transaction.gatewayFee
-        ? BigInt(transaction.gatewayFee as Quantity)
-        : null,
-      gatewayFeeRecipient: transaction.gatewayFeeRecipient as Address | null,
-    }),
-  }),
-  transactionReceipt: /*#__PURE__*/ defineTransactionReceipt({
-    format: (transaction) => ({
-      feeCurrency: transaction.feeCurrency as Address | null,
-      gatewayFee: transaction.gatewayFee
-        ? BigInt(transaction.gatewayFee as Quantity)
-        : null,
-      gatewayFeeRecipient: transaction.gatewayFeeRecipient as Address | null,
-    }),
-  }),
-  transactionRequest: /*#__PURE__*/ defineTransactionRequest({
-    format: (transactionRequest) => ({
-      feeCurrency: transactionRequest.feeCurrency as Address | undefined,
-      gatewayFee: transactionRequest.gatewayFee as Quantity | undefined,
-      gatewayFeeRecipient: transactionRequest.gatewayFeeRecipient as
-        | Address
-        | undefined,
-    }),
-  }),
-}
 export const arbitrum = /*#__PURE__*/ defineChain(chains.arbitrum)
 export const arbitrumGoerli = /*#__PURE__*/ defineChain(chains.arbitrumGoerli)
 export const aurora = /*#__PURE__*/ defineChain(chains.aurora)
@@ -61,16 +17,13 @@ export const bronosTestnet = /*#__PURE__*/ defineChain(chains.bronosTestnet)
 export const bsc = /*#__PURE__*/ defineChain(chains.bsc)
 export const bscTestnet = /*#__PURE__*/ defineChain(chains.bscTestnet)
 export const canto = /*#__PURE__*/ defineChain(chains.canto)
-export const celo = /*#__PURE__*/ defineChain({
-  ...chains.celo,
+export const celo = /*#__PURE__*/ defineChain(chains.celo, {
   formatters: celoFormatters,
 })
-export const celoAlfajores = /*#__PURE__*/ defineChain({
-  ...chains.celoAlfajores,
+export const celoAlfajores = /*#__PURE__*/ defineChain(chains.celoAlfajores, {
   formatters: celoFormatters,
 })
-export const celoCannoli = /*#__PURE__*/ defineChain({
-  ...chains.celoCannoli,
+export const celoCannoli = /*#__PURE__*/ defineChain(chains.celoCannoli, {
   formatters: celoFormatters,
 })
 export const cronos = /*#__PURE__*/ defineChain(chains.cronos)
@@ -111,8 +64,12 @@ export const moonbeam = /*#__PURE__*/ defineChain(chains.moonbeam)
 export const moonriver = /*#__PURE__*/ defineChain(chains.moonriver)
 export const nexi = /*#__PURE__*/ defineChain(chains.nexi)
 export const okc = /*#__PURE__*/ defineChain(chains.okc)
-export const optimism = /*#__PURE__*/ defineChain(chains.optimism)
-export const optimismGoerli = /*#__PURE__*/ defineChain(chains.optimismGoerli)
+export const optimism = /*#__PURE__*/ defineChain(chains.optimism, {
+  formatters: optimismFormatters,
+})
+export const optimismGoerli = /*#__PURE__*/ defineChain(chains.optimismGoerli, {
+  formatters: optimismFormatters,
+})
 export const polygon = /*#__PURE__*/ defineChain(chains.polygon)
 export const polygonMumbai = /*#__PURE__*/ defineChain(chains.polygonMumbai)
 export const polygonZkEvm = /*#__PURE__*/ defineChain(chains.polygonZkEvm)
@@ -174,4 +131,4 @@ export const zkSync = /*#__PURE__*/ defineChain(chains.zkSync)
 export const zkSyncTestnet = /*#__PURE__*/ defineChain(chains.zkSyncTestnet)
 export const zoraTestnet = /*#__PURE__*/ defineChain(chains.zoraTestnet)
 
-export type { Chain } from './types/chain.js'
+export type { Chain } from '../types/chain.js'

package/src/errors/version.ts

@@ -1 +1 @@
-export const version = '0.0.0-main.20230620T232415'
+export const version = '0.0.0-main.20230621T010720'

package/src/index.ts

@@ -476,6 +476,7 @@ export type {
   Formatter,
   Formatters,
 } from './types/formatter.js'
+export type { Serializers } from './types/serializer.js'
 export type {
   GetTypedDataDomain,
   GetTypedDataMessage,
@@ -507,7 +508,6 @@ export type {
 export { labelhash } from './utils/ens/labelhash.js'
 export { namehash } from './utils/ens/namehash.js'
 export {
-  type BlockFormatter,
   type FormattedBlock,
   defineBlock,
   formatBlock,
@@ -559,25 +559,18 @@ export {
   type EncodeFunctionResultParameters,
   encodeFunctionResult,
 } from './utils/abi/encodeFunctionResult.js'
-export type {
-  ExtractFormatter,
-  Formatted,
-} from './utils/formatters/format.js'
 export {
   type FormattedTransaction,
-  type TransactionFormatter,
   defineTransaction,
   formatTransaction,
   transactionType,
 } from './utils/formatters/transaction.js'
 export {
   type FormattedTransactionReceipt,
-  type TransactionReceiptFormatter,
   defineTransactionReceipt,
 } from './utils/formatters/transactionReceipt.js'
 export {
   type FormattedTransactionRequest,
-  type TransactionRequestFormatter,
   defineTransactionRequest,
   formatTransactionRequest,
 } from './utils/formatters/transactionRequest.js'

package/src/types/chain.ts

@@ -1,15 +1,18 @@
-import type { TransactionSerializable } from '../types/transaction.js'
-import type { SerializeTransactionFn } from '../utils/transaction/serializeTransaction.js'
-import type { Formatters } from './formatter.js'
-import type { IsUndefined } from './utils.js'
 import type { Chain as Chain_ } from '@wagmi/chains'
 import type { Address } from 'abitype'
 
-export type Chain<TFormatters extends Formatters = Formatters> = Chain_ & {
+import type { Formatters } from './formatter.js'
+import type { Serializers } from './serializer.js'
+import type { IsUndefined } from './utils.js'
+
+export type Chain<
+  TFormatters extends Formatters | undefined = Formatters | undefined,
+  TSerializers extends Serializers<TFormatters> | undefined =
+    | Serializers<TFormatters>
+    | undefined,
+> = Chain_ & {
   formatters?: TFormatters
-  serializers?: {
-    transaction?: SerializeTransactionFn<TransactionSerializable>
-  }
+  serializers?: TSerializers
 }
 
 export type ChainContract = {

package/src/types/fee.ts

@@ -20,6 +20,7 @@ export type FeeValuesLegacy<TQuantity = bigint> = {
 }
 
 export type FeeValuesEIP1559<TQuantity = bigint> = {
+  /** Base fee per gas. */
   gasPrice?: never
   /** Total fee per gas in wei (gasPrice/baseFeePerGas + maxPriorityFeePerGas). */
   maxFeePerGas: TQuantity

package/src/types/formatter.ts

@@ -1,23 +1,32 @@
-import type { Block } from './block.js'
-import type {
-  RpcBlock,
-  RpcTransaction,
-  RpcTransactionReceipt,
-  RpcTransactionRequest,
-} from './rpc.js'
-import type {
-  Transaction,
-  TransactionReceipt,
-  TransactionRequest,
-} from './transaction.js'
+import type { Chain } from './chain.js'
 
 export type Formatter<TSource = any, TTarget = any> = (
-  value: TSource & { [key: string]: unknown },
+  value: TSource,
 ) => TTarget
 
 export type Formatters = {
-  block?: Formatter<RpcBlock, Block>
-  transaction?: Formatter<RpcTransaction, Transaction>
-  transactionReceipt?: Formatter<RpcTransactionReceipt, TransactionReceipt>
-  transactionRequest?: Formatter<TransactionRequest, RpcTransactionRequest>
+  block?: Formatter
+  transaction?: Formatter
+  transactionReceipt?: Formatter
+  transactionRequest?: Formatter
 }
+
+export type ExtractFormatterParameters<
+  TChain extends Chain | undefined,
+  TType extends keyof Formatters,
+  TFallback,
+> = TChain extends Chain<infer _Formatters extends Formatters>
+  ? _Formatters[TType] extends Formatter
+    ? Parameters<_Formatters[TType]>[0]
+    : TFallback
+  : TFallback
+
+export type ExtractFormatterReturnType<
+  TChain extends Chain | undefined,
+  TType extends keyof Formatters,
+  TFallback,
+> = TChain extends Chain<infer _Formatters extends Formatters>
+  ? _Formatters[TType] extends Formatter
+    ? ReturnType<_Formatters[TType]>
+    : TFallback
+  : TFallback

package/src/types/serializer.ts

@@ -0,0 +1,19 @@
+import type {
+  TransactionSerializable,
+  TransactionSerializableGeneric,
+} from '../types/transaction.js'
+import type { SerializeTransactionFn } from '../utils/transaction/serializeTransaction.js'
+import type { Formatter, Formatters } from './formatter.js'
+
+export type Serializers<
+  TFormatters extends Formatters | undefined = undefined,
+> = {
+  transaction?: SerializeTransactionFn<
+    TFormatters extends Formatters
+      ? TFormatters['transactionRequest'] extends Formatter
+        ? TransactionSerializableGeneric &
+            Parameters<TFormatters['transactionRequest']>[0]
+        : TransactionSerializable
+      : TransactionSerializable
+  >
+}

package/src/types/transaction.ts

@@ -70,6 +70,8 @@ export type TransactionBase<TQuantity = bigint, TIndex = number> = {
   to: Address | null
   /** Index of this transaction in the block or `null` if pending */
   transactionIndex: TIndex | null
+  /** The type represented as hex. */
+  typeHex: Hex | null
   /** ECDSA recovery ID */
   v: TQuantity
   /** Value in wei sent with this transaction */

package/src/types/utils.ts

@@ -122,20 +122,20 @@ export type MaybeUndefined<
 > = TUndefinedish extends true ? T | undefined : T
 
 /**
- * @description Merges the intersection properties of T and U.
+ * @description Assigns the properties of U onto T.
  *
  * @example
- * MergeIntersectionProperties<{ a: string, b: number }, { a: number, c: boolean }>
- * => { a: number, b: number }
+ * Assign<{ a: string, b: number }, { a: undefined, c: boolean }>
+ * => { a: undefined, b: number, c: boolean }
  */
-export type MergeIntersectionProperties<T, U> = {
+export type Assign<T, U> = {
   [K in
     keyof T as K extends keyof U
       ? U[K] extends void
         ? never
         : K
       : K]: K extends keyof U ? U[K] : T[K]
-}
+} & U
 
 /**
  * @description Makes nullable properties from T optional.

package/src/utils/chain.ts

@@ -21,10 +21,17 @@ export function assertCurrentChain({
 }
 
 export function defineChain<
-  TFormatters extends Formatters = Formatters,
-  TChain extends Chain<TFormatters> = Chain<TFormatters>,
->(chain: TChain) {
-  return chain
+  TChain extends Chain,
+  TFormatters extends Formatters,
+>(
+  chain: TChain,
+  config?: Pick<Chain<TFormatters>, 'formatters' | 'serializers'>,
+) {
+  return {
+    ...chain,
+    formatters: config?.formatters,
+    serializers: config?.serializers,
+  }
 }
 
 export function getChainContractAddress({

package/src/utils/formatters/block.ts

@@ -1,26 +1,16 @@
 import type { Block } from '../../types/block.js'
 import type { Chain } from '../../types/chain.js'
-import type { Formatter, Formatters } from '../../types/formatter.js'
+import type { ExtractFormatterReturnType } from '../../types/formatter.js'
 import type { RpcBlock } from '../../types/rpc.js'
 
-import {
-  type ExtractFormatter,
-  type Formatted,
-  defineFormatter,
-} from './format.js'
+import { defineFormatter } from './formatter.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>
+  TChain extends Chain | undefined = Chain | undefined,
+> = ExtractFormatterReturnType<TChain, 'block', 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)
@@ -44,6 +34,4 @@ export function formatBlock(block: Partial<RpcBlock>) {
   } as Block
 }
 
-export const defineBlock = /*#__PURE__*/ defineFormatter({
-  format: formatBlock,
-})
+export const defineBlock = /*#__PURE__*/ defineFormatter(formatBlock)

package/src/utils/formatters/formatter.ts

@@ -0,0 +1,32 @@
+import type { Assign, Prettify } from '../../types/utils.js'
+
+export function defineFormatter<TParameters, TReturnType>(
+  format: (_: TParameters) => TReturnType,
+) {
+  return <
+    TOverrideParameters,
+    TOverrideReturnType,
+    TExclude extends (keyof TParameters)[] = [],
+  >({
+    exclude,
+    format: overrides,
+  }: {
+    exclude?: TExclude
+    format: (_: TOverrideParameters) => TOverrideReturnType
+  }) => {
+    return (args: TParameters & TOverrideParameters) => {
+      const formatted = format(args)
+      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
+      }
+    }
+  }
+}

package/src/utils/formatters/transaction.ts

@@ -1,27 +1,13 @@
 import type { Chain } from '../../types/chain.js'
-import type { Formatter, Formatters } from '../../types/formatter.js'
+import type { ExtractFormatterReturnType } from '../../types/formatter.js'
 import type { RpcTransaction } from '../../types/rpc.js'
 import type { Transaction } from '../../types/transaction.js'
 import { hexToNumber } from '../encoding/fromHex.js'
-
-import {
-  type ExtractFormatter,
-  type Formatted,
-  defineFormatter,
-} from './format.js'
-
-export type TransactionFormatter<TChain extends Chain | undefined = Chain> =
-  TChain extends Chain
-    ? ExtractFormatter<
-        TChain,
-        'transaction',
-        NonNullable<Formatters['transaction']>
-      >
-    : Formatters['transaction']
+import { defineFormatter } from './formatter.js'
 
 export type FormattedTransaction<
-  TFormatter extends Formatter | undefined = Formatter,
-> = Formatted<TFormatter, Transaction>
+  TChain extends Chain | undefined = Chain | undefined,
+> = ExtractFormatterReturnType<TChain, 'transaction', Transaction>
 
 export const transactionType = {
   '0x0': 'legacy',
@@ -51,6 +37,7 @@ export function formatTransaction(transaction: Partial<RpcTransaction>) {
       ? Number(transaction.transactionIndex)
       : null,
     type: transaction.type ? transactionType[transaction.type] : undefined,
+    typeHex: transaction.type ? transaction.type : undefined,
     value: transaction.value ? BigInt(transaction.value) : undefined,
     v: transaction.v ? BigInt(transaction.v) : undefined,
   }
@@ -67,6 +54,5 @@ export function formatTransaction(transaction: Partial<RpcTransaction>) {
   return transaction_ as Transaction
 }
 
-export const defineTransaction = /*#__PURE__*/ defineFormatter({
-  format: formatTransaction,
-})
+export const defineTransaction =
+  /*#__PURE__*/ defineFormatter(formatTransaction)

package/src/utils/formatters/transactionReceipt.ts

@@ -1,30 +1,16 @@
 import type { Chain } from '../../types/chain.js'
-import type { Formatter, Formatters } from '../../types/formatter.js'
+import type { ExtractFormatterReturnType } from '../../types/formatter.js'
 import type { RpcTransactionReceipt } from '../../types/rpc.js'
 import type { TransactionReceipt } from '../../types/transaction.js'
 import { hexToNumber } from '../encoding/fromHex.js'
 
-import {
-  type ExtractFormatter,
-  type Formatted,
-  defineFormatter,
-} from './format.js'
+import { defineFormatter } from './formatter.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>
+  TChain extends Chain | undefined = Chain | undefined,
+> = ExtractFormatterReturnType<TChain, 'transactionReceipt', TransactionReceipt>
 
 const statuses = {
   '0x0': 'reverted',
@@ -69,6 +55,6 @@ export function formatTransactionReceipt(
   } as TransactionReceipt
 }
 
-export const defineTransactionReceipt = /*#__PURE__*/ defineFormatter({
-  format: formatTransactionReceipt,
-})
+export const defineTransactionReceipt = /*#__PURE__*/ defineFormatter(
+  formatTransactionReceipt,
+)

package/src/utils/formatters/transactionRequest.ts

@@ -1,28 +1,13 @@
 import type { Chain } from '../../types/chain.js'
-import type { Formatter, Formatters } from '../../types/formatter.js'
+import type { ExtractFormatterParameters } from '../../types/formatter.js'
 import type { RpcTransactionRequest } from '../../types/rpc.js'
 import type { TransactionRequest } from '../../types/transaction.js'
 import { numberToHex } from '../encoding/toHex.js'
-
-import {
-  type ExtractFormatter,
-  type Formatted,
-  defineFormatter,
-} from './format.js'
-
-export type TransactionRequestFormatter<
-  TChain extends Chain | undefined = Chain,
-> = TChain extends Chain
-  ? ExtractFormatter<
-      TChain,
-      'transactionRequest',
-      NonNullable<Formatters['transactionRequest']>
-    >
-  : Formatters['transactionRequest']
+import { defineFormatter } from './formatter.js'
 
 export type FormattedTransactionRequest<
-  TFormatter extends Formatter | undefined = Formatter,
-> = Formatted<TFormatter, RpcTransactionRequest>
+  TChain extends Chain | undefined = Chain | undefined,
+> = ExtractFormatterParameters<TChain, 'transactionRequest', TransactionRequest>
 
 export function formatTransactionRequest(
   transactionRequest: Partial<TransactionRequest>,
@@ -56,6 +41,6 @@ export function formatTransactionRequest(
   } as RpcTransactionRequest
 }
 
-export const defineTransactionRequest = /*#__PURE__*/ defineFormatter({
-  format: formatTransactionRequest,
-})
+export const defineTransactionRequest = /*#__PURE__*/ defineFormatter(
+  formatTransactionRequest,
+)

package/src/utils/index.ts

@@ -118,32 +118,22 @@ export { size } from './data/size.js'
 export { slice, sliceBytes, sliceHex } from './data/slice.js'
 export { trim } from './data/trim.js'
 export {
-  type BlockFormatter,
   type FormattedBlock,
   defineBlock,
   formatBlock,
 } from './formatters/block.js'
-export {
-  type ExtractFormatter,
-  type Formatted,
-  defineFormatter,
-  format,
-} from './formatters/format.js'
 export {
   type FormattedTransaction,
-  type TransactionFormatter,
   defineTransaction,
   formatTransaction,
   transactionType,
 } from './formatters/transaction.js'
 export {
   type FormattedTransactionReceipt,
-  type TransactionReceiptFormatter,
   defineTransactionReceipt,
 } from './formatters/transactionReceipt.js'
 export {
   type FormattedTransactionRequest,
-  type TransactionRequestFormatter,
   defineTransactionRequest,
   formatTransactionRequest,
 } from './formatters/transactionRequest.js'
@@ -183,6 +173,7 @@ export { getCallError } from './errors/getCallError.js'
 export { getContractError } from './errors/getContractError.js'
 export { getEstimateGasError } from './errors/getEstimateGasError.js'
 export { getTransactionError } from './errors/getTransactionError.js'
+export { defineFormatter } from './formatters/formatter.js'
 export { getEventSelector } from './hash/getEventSelector.js'
 export { getFunctionSelector } from './hash/getFunctionSelector.js'
 export { isHash } from './hash/isHash.js'

package/src/wallet.ts

@@ -17,7 +17,6 @@ export {
 } from './actions/wallet/requestPermissions.js'
 export {
   sendTransaction,
-  type FormattedTransactionRequest,
   type SendTransactionParameters,
   type SendTransactionReturnType,
 } from './actions/wallet/sendTransaction.js'