viem 1.0.6 → 1.1.0

package/src/actions/test/sendUnsignedTransaction.ts

@@ -4,27 +4,17 @@ import type {
 } from '../../clients/createTestClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import type { Chain } from '../../types/chain.js'
-import type { Formatter } from '../../types/formatter.js'
 import type { Hash } from '../../types/misc.js'
 import type { TransactionRequest } from '../../types/transaction.js'
-import type { MergeIntersectionProperties } from '../../types/utils.js'
 import { extract } from '../../utils/formatters/extract.js'
-import { type Formatted, format } from '../../utils/formatters/format.js'
 import {
-  type TransactionRequestFormatter,
+  type FormattedTransactionRequest,
   formatTransactionRequest,
 } from '../../utils/formatters/transactionRequest.js'
 
-type FormattedTransactionRequest<
-  TFormatter extends Formatter | undefined = Formatter,
-> = MergeIntersectionProperties<
-  Formatted<TFormatter, TransactionRequest, true>,
-  TransactionRequest
->
-
 export type SendUnsignedTransactionParameters<
   TChain extends Chain | undefined = Chain | undefined,
-> = FormattedTransactionRequest<TransactionRequestFormatter<TChain>>
+> = FormattedTransactionRequest<TChain>
 
 export type SendUnsignedTransactionReturnType = Hash
 
@@ -73,26 +63,22 @@ export async function sendUnsignedTransaction<
     ...rest
   } = args
 
-  const formatter = client.chain?.formatters?.transactionRequest
-  const request = format(
-    {
-      accessList,
-      data,
-      from,
-      gas,
-      gasPrice,
-      maxFeePerGas,
-      maxPriorityFeePerGas,
-      nonce,
-      to,
-      value,
-      // Pick out extra data that might exist on the chain's transaction request type.
-      ...extract(rest, { formatter }),
-    } as TransactionRequest,
-    {
-      formatter: formatter || formatTransactionRequest,
-    },
-  )
+  const format =
+    client.chain?.formatters?.transactionRequest || formatTransactionRequest
+  const request = format({
+    // Pick out extra data that might exist on the chain's transaction request type.
+    ...extract(rest, { formatter: format }),
+    accessList,
+    data,
+    from,
+    gas,
+    gasPrice,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    nonce,
+    to,
+    value,
+  } as TransactionRequest)
   const hash = await client.request({
     method: 'eth_sendUnsignedTransaction',
     params: [request],

package/src/actions/wallet/sendTransaction.ts

@@ -6,37 +6,27 @@ import { AccountNotFoundError } from '../../errors/account.js'
 import type { BaseError } from '../../errors/base.js'
 import type { GetAccountParameter } from '../../types/account.js'
 import type { Chain, GetChain } from '../../types/chain.js'
-import type { Formatter } from '../../types/formatter.js'
 import type { Hash } from '../../types/misc.js'
 import type {
   TransactionRequest,
   TransactionSerializable,
 } from '../../types/transaction.js'
-import type { MergeIntersectionProperties } from '../../types/utils.js'
 import { assertCurrentChain } from '../../utils/chain.js'
 import { getTransactionError } from '../../utils/errors/getTransactionError.js'
 import { extract } from '../../utils/formatters/extract.js'
-import { type Formatted, format } from '../../utils/formatters/format.js'
 import {
-  type TransactionRequestFormatter,
+  type FormattedTransactionRequest,
   formatTransactionRequest,
 } from '../../utils/formatters/transactionRequest.js'
 import { assertRequest } from '../../utils/transaction/assertRequest.js'
 import { prepareRequest } from '../../utils/transaction/prepareRequest.js'
 import { getChainId } from '../public/getChainId.js'
 
-export type FormattedTransactionRequest<
-  TFormatter extends Formatter | undefined = Formatter,
-> = MergeIntersectionProperties<
-  Omit<Formatted<TFormatter, TransactionRequest, true>, 'from'>,
-  TransactionRequest
->
-
 export type SendTransactionParameters<
   TChain extends Chain | undefined = Chain | undefined,
   TAccount extends Account | undefined = Account | undefined,
   TChainOverride extends Chain | undefined = Chain,
-> = FormattedTransactionRequest<TransactionRequestFormatter<TChainOverride>> &
+> = Omit<FormattedTransactionRequest<TChainOverride>, 'from'> &
   GetAccountParameter<TAccount> &
   GetChain<TChain, TChainOverride>
 
@@ -146,36 +136,37 @@ export async function sendTransaction<
       })
 
       if (!chainId) chainId = await getChainId(client)
-      const signedRequest = (await account.signTransaction({
-        ...request,
-        chainId,
-      } as TransactionSerializable)) as Hash
+
+      const serializer = chain?.serializers?.transaction
+      const signedRequest = (await account.signTransaction(
+        {
+          ...request,
+          chainId,
+        } as TransactionSerializable,
+        { serializer },
+      )) as Hash
       return await client.request({
         method: 'eth_sendRawTransaction',
         params: [signedRequest],
       })
     }
 
-    const formatter = chain?.formatters?.transactionRequest
-    const request = format(
-      {
-        accessList,
-        data,
-        from: account.address,
-        gas,
-        gasPrice,
-        maxFeePerGas,
-        maxPriorityFeePerGas,
-        nonce,
-        to,
-        value,
-        // Pick out extra data that might exist on the chain's transaction request type.
-        ...extract(rest, { formatter }),
-      } as TransactionRequest,
-      {
-        formatter: formatter || formatTransactionRequest,
-      },
-    )
+    const format =
+      chain?.formatters?.transactionRequest || formatTransactionRequest
+    const request = format({
+      // Pick out extra data that might exist on the chain's transaction request type.
+      ...extract(rest, { formatter: format }),
+      accessList,
+      data,
+      from: account.address,
+      gas,
+      gasPrice,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      nonce,
+      to,
+      value,
+    } as TransactionRequest)
     return await client.request({
       method: 'eth_sendTransaction',
       params: [request],

package/src/chains/formatters/celo.ts

@@ -0,0 +1,102 @@
+import type { Address } from 'abitype'
+
+import type { Hash, Hex } from '../../types/misc.js'
+import type { RpcTransaction } from '../../types/rpc.js'
+import type { Transaction } from '../../types/transaction.js'
+import { hexToBigInt } from '../../utils/encoding/fromHex.js'
+import { numberToHex } from '../../utils/encoding/toHex.js'
+import { defineBlock } from '../../utils/formatters/block.js'
+import {
+  defineTransaction,
+  formatTransaction,
+} from '../../utils/formatters/transaction.js'
+import { defineTransactionReceipt } from '../../utils/formatters/transactionReceipt.js'
+import { defineTransactionRequest } from '../../utils/formatters/transactionRequest.js'
+
+export type CeloOverrides = {
+  RpcBlock: {
+    randomness: {
+      committed: Hex
+      revealed: Hex
+    }
+    transactions:
+      | Hash[]
+      | (RpcTransaction & {
+          feeCurrency: Address | null
+          gatewayFee: Hex | null
+          gatewayFeeRecipient: Address | null
+        })[]
+  }
+  RpcTransaction: {
+    feeCurrency: Address | null
+    gatewayFee: Hex | null
+    gatewayFeeRecipient: Address | null
+  }
+  RpcTransactionReceipt: {
+    feeCurrency: Address | null
+    gatewayFee: Hex | null
+    gatewayFeeRecipient: Address | null
+  }
+  TransactionRequest: {
+    feeCurrency?: Address
+    gatewayFee?: bigint
+    gatewayFeeRecipient?: Address
+  }
+  Transaction: {
+    feeCurrency: Address | null
+    gatewayFee: bigint | null
+    gatewayFeeRecipient: Address | null
+  }
+}
+export const celoFormatters = {
+  block: /*#__PURE__*/ defineBlock({
+    exclude: ['difficulty', 'gasLimit', 'mixHash', 'nonce', 'uncles'],
+    format(args: CeloOverrides['RpcBlock']) {
+      const transactions = args.transactions?.map((transaction) => {
+        if (typeof transaction === 'string') return transaction
+        return {
+          ...formatTransaction(transaction),
+          feeCurrency: transaction.feeCurrency,
+          gatewayFee: transaction.gatewayFee
+            ? hexToBigInt(transaction.gatewayFee)
+            : null,
+          gatewayFeeRecipient: transaction.gatewayFeeRecipient,
+        }
+      }) as Hash[] | (Transaction & CeloOverrides['Transaction'])[]
+      return {
+        randomness: args.randomness,
+        transactions,
+      }
+    },
+  }),
+  transaction: /*#__PURE__*/ defineTransaction({
+    format(args: CeloOverrides['RpcTransaction']) {
+      return {
+        feeCurrency: args.feeCurrency,
+        gatewayFee: args.gatewayFee ? hexToBigInt(args.gatewayFee) : null,
+        gatewayFeeRecipient: args.gatewayFeeRecipient,
+      }
+    },
+  }),
+  transactionReceipt: /*#__PURE__*/ defineTransactionReceipt({
+    format(args: CeloOverrides['RpcTransactionReceipt']) {
+      return {
+        feeCurrency: args.feeCurrency,
+        gatewayFee: args.gatewayFee ? hexToBigInt(args.gatewayFee) : null,
+        gatewayFeeRecipient: args.gatewayFeeRecipient,
+      }
+    },
+  }),
+  transactionRequest: /*#__PURE__*/ defineTransactionRequest({
+    format(args: CeloOverrides['TransactionRequest']) {
+      return {
+        feeCurrency: args.feeCurrency,
+        gatewayFee:
+          typeof args.gatewayFee !== 'undefined'
+            ? numberToHex(args.gatewayFee)
+            : undefined,
+        gatewayFeeRecipient: args.gatewayFeeRecipient,
+      }
+    },
+  }),
+} as const

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 = '1.0.6'
+export const version = '1.1.0'

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'
@@ -701,7 +694,11 @@ export { parseGwei } from './utils/unit/parseGwei.js'
 export { parseTransaction } from './utils/transaction/parseTransaction.js'
 export { parseUnits } from './utils/unit/parseUnits.js'
 export { prepareRequest } from './utils/transaction/prepareRequest.js'
-export { serializeTransaction } from './utils/transaction/serializeTransaction.js'
+export { serializeAccessList } from './utils/transaction/serializeAccessList.js'
+export {
+  serializeTransaction,
+  type SerializeTransactionFn,
+} from './utils/transaction/serializeTransaction.js'
 export { size } from './utils/data/size.js'
 export { slice, sliceBytes, sliceHex } from './utils/data/slice.js'
 export { stringify } from './utils/stringify.js'

package/src/types/chain.ts

@@ -2,10 +2,17 @@ import type { Chain as Chain_ } from '@wagmi/chains'
 import type { Address } from 'abitype'
 
 import type { Formatters } from './formatter.js'
+import type { Serializers } from './serializer.js'
 import type { IsUndefined } from './utils.js'
 
-export type Chain<TFormatters extends Formatters = Formatters> = Chain_ & {
+export type Chain<
+  TFormatters extends Formatters | undefined = Formatters | undefined,
+  TSerializers extends Serializers<TFormatters> | undefined =
+    | Serializers<TFormatters>
+    | undefined,
+> = Chain_ & {
   formatters?: TFormatters
+  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/rpc.ts

@@ -12,7 +12,7 @@ import type {
 export type Index = `0x${string}`
 export type Quantity = `0x${string}`
 export type Status = '0x0' | '0x1'
-export type TransactionType = '0x0' | '0x1' | '0x2'
+export type TransactionType = '0x0' | '0x1' | '0x2' | (string & {})
 
 export type RpcBlock = Block<Quantity, RpcTransaction>
 export type RpcBlockNumber = BlockNumber<Quantity>

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
+  >
+}