viem 0.0.0-portable-types-20230522163654 → 0.0.0-refactor-generics-20230831161903

package/src/actions/wallet/watchAsset.ts

@@ -1,5 +1,5 @@
 import type { Account } from '../../accounts/types.js'
-import type { WalletClient } from '../../clients/createWalletClient.js'
+import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import type { Chain } from '../../types/chain.js'
 import type { WatchAssetParams } from '../../types/eip1193.js'
@@ -39,7 +39,7 @@ export async function watchAsset<
   TChain extends Chain | undefined,
   TAccount extends Account | undefined = undefined,
 >(
-  client: WalletClient<Transport, TChain, TAccount>,
+  client: Client<Transport, TChain, TAccount>,
   params: WatchAssetParameters,
 ): Promise<WatchAssetReturnType> {
   const added = await client.request({

package/src/actions/wallet/writeContract.ts

@@ -1,16 +1,19 @@
 import type { Abi } from 'abitype'
 
 import type { Account } from '../../accounts/types.js'
-import type { WalletClient } from '../../clients/createWalletClient.js'
+import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
-import type { Chain, GetChain } from '../../types/chain.js'
+import type { GetAccountParameter } from '../../types/account.js'
+import type { Chain } from '../../types/chain.js'
+import type { GetChain } from '../../types/chain.js'
 import type { ContractFunctionConfig, GetValue } from '../../types/contract.js'
 import type { Hex } from '../../types/misc.js'
+import type { UnionOmit } from '../../types/utils.js'
 import {
   type EncodeFunctionDataParameters,
   encodeFunctionData,
 } from '../../utils/abi/encodeFunctionData.js'
-
+import type { FormattedTransactionRequest } from '../../utils/formatters/transactionRequest.js'
 import {
   type SendTransactionParameters,
   type SendTransactionReturnType,
@@ -21,15 +24,28 @@ export type WriteContractParameters<
   TAbi extends Abi | readonly unknown[] = Abi,
   TFunctionName extends string = string,
   TChain extends Chain | undefined = Chain,
-  TAccount extends Account | undefined = undefined,
-  TChainOverride extends Chain | undefined = undefined,
+  TAccount extends Account | undefined = Account | undefined,
+  TChainOverride extends Chain | undefined = Chain | undefined,
 > = ContractFunctionConfig<TAbi, TFunctionName, 'payable' | 'nonpayable'> &
-  Omit<
-    SendTransactionParameters<TChain, TAccount, TChainOverride>,
-    'chain' | 'to' | 'data' | 'value'
-  > &
+  GetAccountParameter<TAccount> &
   GetChain<TChain, TChainOverride> &
-  GetValue<TAbi, TFunctionName, SendTransactionParameters<TChain>['value']> & {
+  UnionOmit<
+    FormattedTransactionRequest<
+      TChainOverride extends Chain ? TChainOverride : TChain
+    >,
+    'from' | 'to' | 'data' | 'value'
+  > &
+  GetValue<
+    TAbi,
+    TFunctionName,
+    SendTransactionParameters<
+      TChain,
+      TAccount,
+      TChainOverride
+    > extends SendTransactionParameters
+      ? SendTransactionParameters<TChain, TAccount, TChainOverride>['value']
+      : SendTransactionParameters['value']
+  > & {
     /** Data to append to the end of the calldata. Useful for adding a ["domain" tag](https://opensea.notion.site/opensea/Seaport-Order-Attributions-ec2d69bf455041a5baa490941aad307f). */
     dataSuffix?: Hex
   }
@@ -42,15 +58,15 @@ export type WriteContractReturnType = SendTransactionReturnType
  * - Docs: https://viem.sh/docs/contract/writeContract.html
  * - Examples: https://stackblitz.com/github/wagmi-dev/viem/tree/main/examples/contracts/writing-to-contracts
  *
- * A "write" function on a Solidity contract modifies the state of the blockchain. These types of functions require gas to be executed, and hence a [Transaction](https://viem.sh/docs/glossary/terms) is needed to be broadcast in order to change the state.
+ * A "write" function on a Solidity contract modifies the state of the blockchain. These types of functions require gas to be executed, and hence a [Transaction](https://viem.sh/docs/glossary/terms.html) is needed to be broadcast in order to change the state.
  *
- * Internally, uses a [Wallet Client](https://viem.sh/docs/clients/wallet) to call the [`sendTransaction` action](https://viem.sh/docs/actions/wallet/sendTransaction) with [ABI-encoded `data`](https://viem.sh/docs/contract/encodeFunctionData).
+ * Internally, uses a [Wallet Client](https://viem.sh/docs/clients/wallet.html) to call the [`sendTransaction` action](https://viem.sh/docs/actions/wallet/sendTransaction.html) with [ABI-encoded `data`](https://viem.sh/docs/contract/encodeFunctionData.html).
  *
  * __Warning: The `write` internally sends a transaction – it does not validate if the contract write will succeed (the contract may throw an error). It is highly recommended to [simulate the contract write with `contract.simulate`](https://viem.sh/docs/contract/writeContract.html#usage) before you execute it.__
  *
  * @param client - Client to use
  * @param parameters - {@link WriteContractParameters}
- * @returns A [Transaction Hash](https://viem.sh/docs/glossary/terms#hash). {@link WriteContractReturnType}
+ * @returns A [Transaction Hash](https://viem.sh/docs/glossary/terms.html#hash). {@link WriteContractReturnType}
  *
  * @example
  * import { createWalletClient, custom, parseAbi } from 'viem'
@@ -89,11 +105,11 @@ export type WriteContractReturnType = SendTransactionReturnType
 export async function writeContract<
   TChain extends Chain | undefined,
   TAccount extends Account | undefined,
-  TAbi extends Abi | readonly unknown[],
+  const TAbi extends Abi | readonly unknown[],
   TFunctionName extends string,
-  TChainOverride extends Chain | undefined = undefined,
+  TChainOverride extends Chain | undefined,
 >(
-  client: WalletClient<Transport, TChain, TAccount>,
+  client: Client<Transport, TChain, TAccount>,
   {
     abi,
     address,

package/src/chains/celo/formatters.ts

@@ -0,0 +1,84 @@
+import { type ChainFormatters } from '../../types/chain.js'
+import type { Hash } from '../../types/misc.js'
+import type { RpcTransaction } from '../../types/rpc.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'
+import type {
+  CeloBlockOverrides,
+  CeloRpcTransaction,
+  CeloRpcTransactionReceiptOverrides,
+  CeloRpcTransactionRequest,
+  CeloTransaction,
+  CeloTransactionReceiptOverrides,
+  CeloTransactionRequest,
+} from './types.js'
+
+export const formattersCelo = {
+  block: /*#__PURE__*/ defineBlock({
+    exclude: ['difficulty', 'gasLimit', 'mixHash', 'nonce', 'uncles'],
+    format(
+      args: CeloBlockOverrides & {
+        transactions: Hash[] | CeloRpcTransaction[]
+      },
+    ): CeloBlockOverrides & {
+      transactions: Hash[] | CeloTransaction[]
+    } {
+      const transactions = args.transactions?.map((transaction) => {
+        if (typeof transaction === 'string') return transaction
+        return {
+          ...formatTransaction(transaction as RpcTransaction),
+          feeCurrency: transaction.feeCurrency,
+          gatewayFee: transaction.gatewayFee
+            ? hexToBigInt(transaction.gatewayFee)
+            : null,
+          gatewayFeeRecipient: transaction.gatewayFeeRecipient,
+        }
+      }) as Hash[] | CeloTransaction[]
+      return {
+        randomness: args.randomness,
+        transactions,
+      }
+    },
+  }),
+  transaction: /*#__PURE__*/ defineTransaction({
+    format(args: CeloRpcTransaction): CeloTransaction {
+      return {
+        feeCurrency: args.feeCurrency,
+        gatewayFee: args.gatewayFee ? hexToBigInt(args.gatewayFee) : null,
+        gatewayFeeRecipient: args.gatewayFeeRecipient,
+      } as CeloTransaction
+    },
+  }),
+  transactionReceipt: /*#__PURE__*/ defineTransactionReceipt({
+    format(
+      args: CeloRpcTransactionReceiptOverrides,
+    ): CeloTransactionReceiptOverrides {
+      return {
+        feeCurrency: args.feeCurrency,
+        gatewayFee: args.gatewayFee ? hexToBigInt(args.gatewayFee) : null,
+        gatewayFeeRecipient: args.gatewayFeeRecipient,
+      }
+    },
+  }),
+  transactionRequest: /*#__PURE__*/ defineTransactionRequest({
+    format(args: CeloTransactionRequest): CeloRpcTransactionRequest {
+      const request = {
+        feeCurrency: args.feeCurrency,
+        gatewayFee:
+          typeof args.gatewayFee !== 'undefined'
+            ? numberToHex(args.gatewayFee)
+            : undefined,
+        gatewayFeeRecipient: args.gatewayFeeRecipient,
+      } as CeloRpcTransactionRequest
+      if (args.type === 'cip42') request.type = '0x7c'
+      return request
+    },
+  }),
+} as const satisfies ChainFormatters

package/src/chains/celo/parsers.ts

@@ -0,0 +1,123 @@
+import { InvalidSerializedTransactionError } from '../../errors/transaction.js'
+import type { Hex } from '../../types/misc.js'
+import { isHex } from '../../utils/data/isHex.js'
+import { sliceHex } from '../../utils/data/slice.js'
+import { hexToBigInt, hexToNumber } from '../../utils/encoding/fromHex.js'
+import type { RecursiveArray } from '../../utils/encoding/toRlp.js'
+import type { GetSerializedTransactionType } from '../../utils/transaction/getSerializedTransactionType.js'
+import {
+  type ParseTransactionReturnType,
+  parseAccessList,
+  parseTransaction,
+  toTransactionArray,
+} from '../../utils/transaction/parseTransaction.js'
+import { assertTransactionCIP42 } from './serializers.js'
+import type {
+  CeloTransactionSerialized,
+  CeloTransactionType,
+  TransactionSerializableCIP42,
+  TransactionSerializedCIP42,
+} from './types.js'
+
+export type ParseTransactionCeloReturnType<
+  TSerialized extends CeloTransactionSerialized = CeloTransactionSerialized,
+  TType extends CeloTransactionType = GetSerializedTransactionType<TSerialized>,
+> = TSerialized extends TransactionSerializedCIP42
+  ? TransactionSerializableCIP42
+  : ParseTransactionReturnType<TSerialized, TType>
+
+export function parseTransactionCelo<
+  TSerialized extends CeloTransactionSerialized,
+>(
+  serializedTransaction: TSerialized,
+): ParseTransactionCeloReturnType<TSerialized> {
+  const serializedType = sliceHex(serializedTransaction, 0, 1)
+
+  if (serializedType === '0x7c')
+    return parseTransactionCIP42(
+      serializedTransaction as TransactionSerializedCIP42,
+    ) as ParseTransactionCeloReturnType<TSerialized>
+
+  return parseTransaction(
+    serializedTransaction,
+  ) as ParseTransactionCeloReturnType<TSerialized>
+}
+
+function parseTransactionCIP42(
+  serializedTransaction: TransactionSerializedCIP42,
+): TransactionSerializableCIP42 {
+  const transactionArray = toTransactionArray(serializedTransaction)
+
+  const [
+    chainId,
+    nonce,
+    maxPriorityFeePerGas,
+    maxFeePerGas,
+    gas,
+    feeCurrency,
+    gatewayFeeRecipient,
+    gatewayFee,
+    to,
+    value,
+    data,
+    accessList,
+    v,
+    r,
+    s,
+  ] = transactionArray
+
+  if (transactionArray.length !== 15 && transactionArray.length !== 12) {
+    throw new InvalidSerializedTransactionError({
+      attributes: {
+        chainId,
+        nonce,
+        maxPriorityFeePerGas,
+        maxFeePerGas,
+        gas,
+        feeCurrency,
+        to,
+        gatewayFeeRecipient,
+        gatewayFee,
+        value,
+        data,
+        accessList,
+        ...(transactionArray.length > 12
+          ? {
+              v,
+              r,
+              s,
+            }
+          : {}),
+      },
+      serializedTransaction,
+      type: 'cip42',
+    })
+  }
+
+  const transaction: Partial<TransactionSerializableCIP42> = {
+    chainId: hexToNumber(chainId as Hex),
+    type: 'cip42',
+  }
+
+  if (isHex(to) && to !== '0x') transaction.to = to
+  if (isHex(gas) && gas !== '0x') transaction.gas = hexToBigInt(gas)
+  if (isHex(data) && data !== '0x') transaction.data = data
+  if (isHex(nonce) && nonce !== '0x') transaction.nonce = hexToNumber(nonce)
+  if (isHex(value) && value !== '0x') transaction.value = hexToBigInt(value)
+  if (isHex(feeCurrency) && feeCurrency !== '0x')
+    transaction.feeCurrency = feeCurrency
+  if (isHex(gatewayFeeRecipient) && gatewayFeeRecipient !== '0x')
+    transaction.gatewayFeeRecipient = gatewayFeeRecipient
+  if (isHex(gatewayFee) && gatewayFee !== '0x')
+    transaction.gatewayFee = hexToBigInt(gatewayFee)
+  if (isHex(maxFeePerGas) && maxFeePerGas !== '0x')
+    transaction.maxFeePerGas = hexToBigInt(maxFeePerGas)
+  if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== '0x')
+    transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas)
+  if (accessList.length !== 0 && accessList !== '0x')
+    transaction.accessList = parseAccessList(accessList as RecursiveArray<Hex>)
+
+  assertTransactionCIP42(transaction as TransactionSerializableCIP42)
+
+  return transaction as TransactionSerializableCIP42
+}

package/src/chains/celo/serializers.ts

@@ -0,0 +1,169 @@
+import { InvalidAddressError } from '../../errors/address.js'
+import { BaseError } from '../../errors/base.js'
+import { InvalidChainIdError } from '../../errors/chain.js'
+import { FeeCapTooHighError, TipAboveFeeCapError } from '../../errors/node.js'
+import type { ChainSerializers } from '../../types/chain.js'
+import type { Signature } from '../../types/misc.js'
+import type { TransactionSerializable } from '../../types/transaction.js'
+import { isAddress } from '../../utils/address/isAddress.js'
+import { concatHex } from '../../utils/data/concat.js'
+import { trim } from '../../utils/data/trim.js'
+import { toHex } from '../../utils/encoding/toHex.js'
+import { toRlp } from '../../utils/encoding/toRlp.js'
+import { serializeAccessList } from '../../utils/transaction/serializeAccessList.js'
+import {
+  type SerializeTransactionFn,
+  serializeTransaction,
+} from '../../utils/transaction/serializeTransaction.js'
+import type {
+  CeloTransactionSerializable,
+  TransactionSerializableCIP42,
+  TransactionSerializedCIP42,
+} from './types.js'
+
+export const serializeTransactionCelo: SerializeTransactionFn<
+  CeloTransactionSerializable
+> = (tx, signature) => {
+  // Handle CIP-42 transactions
+  if (isCIP42(tx))
+    return serializeTransactionCIP42(
+      tx as TransactionSerializableCIP42,
+      signature,
+    )
+
+  // Handle other transaction types
+  return serializeTransaction(tx as TransactionSerializable, signature)
+}
+
+export const serializersCelo = {
+  transaction: serializeTransactionCelo,
+} as const satisfies ChainSerializers
+
+//////////////////////////////////////////////////////////////////////////////
+// Serializers
+
+export type SerializeTransactionCIP42ReturnType = TransactionSerializedCIP42
+
+// There shall be a typed transaction with the code 0x7c that has the following format:
+// 0x7c || rlp([chain_id, nonce, max_priority_fee_per_gas, max_fee_per_gas, gas_limit, feecurrency, gatewayFeeRecipient, gatewayfee, destination, amount, data, access_list, signature_y_parity, signature_r, signature_s]).
+// This will be in addition to the type 0x02 transaction as specified in EIP-1559.
+function serializeTransactionCIP42(
+  transaction: TransactionSerializableCIP42,
+  signature?: Signature,
+): SerializeTransactionCIP42ReturnType {
+  assertTransactionCIP42(transaction)
+  const {
+    chainId,
+    gas,
+    nonce,
+    to,
+    value,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    accessList,
+    feeCurrency,
+    gatewayFeeRecipient,
+    gatewayFee,
+    data,
+  } = transaction
+
+  const serializedTransaction = [
+    toHex(chainId),
+    nonce ? toHex(nonce) : '0x',
+    maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : '0x',
+    maxFeePerGas ? toHex(maxFeePerGas) : '0x',
+    gas ? toHex(gas) : '0x',
+    feeCurrency ?? '0x',
+    gatewayFeeRecipient ?? '0x',
+    gatewayFee ? toHex(gatewayFee) : '0x',
+    to ?? '0x',
+    value ? toHex(value) : '0x',
+    data ?? '0x',
+    serializeAccessList(accessList),
+  ]
+
+  if (signature) {
+    serializedTransaction.push(
+      signature.v === 27n ? '0x' : toHex(1), // yParity
+      trim(signature.r),
+      trim(signature.s),
+    )
+  }
+
+  return concatHex([
+    '0x7c',
+    toRlp(serializedTransaction),
+  ]) as SerializeTransactionCIP42ReturnType
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// Utilities
+
+// process as CIP42 if any of these fields are present. realistically gatewayfee is not used but is part of spec
+function isCIP42(transaction: CeloTransactionSerializable) {
+  if (
+    'maxFeePerGas' in transaction &&
+    'maxPriorityFeePerGas' in transaction &&
+    ('feeCurrency' in transaction ||
+      'gatewayFee' in transaction ||
+      'gatewayFeeRecipient' in transaction)
+  )
+    return true
+  return false
+}
+
+// maxFeePerGas must be less than 2^256 - 1: however writing like that caused exceptions to be raised
+const MAX_MAX_FEE_PER_GAS =
+  115792089237316195423570985008687907853269984665640564039457584007913129639935n
+
+export function assertTransactionCIP42(
+  transaction: TransactionSerializableCIP42,
+) {
+  const {
+    chainId,
+    maxPriorityFeePerGas,
+    gasPrice,
+    maxFeePerGas,
+    to,
+    feeCurrency,
+    gatewayFee,
+    gatewayFeeRecipient,
+  } = transaction
+  if (chainId <= 0) throw new InvalidChainIdError({ chainId })
+  if (to && !isAddress(to)) throw new InvalidAddressError({ address: to })
+  if (gasPrice)
+    throw new BaseError(
+      '`gasPrice` is not a valid CIP-42 Transaction attribute.',
+    )
+
+  if (maxFeePerGas && maxFeePerGas > MAX_MAX_FEE_PER_GAS)
+    throw new FeeCapTooHighError({ maxFeePerGas })
+
+  if (
+    maxPriorityFeePerGas &&
+    maxFeePerGas &&
+    maxPriorityFeePerGas > maxFeePerGas
+  )
+    throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas })
+
+  if (
+    (gatewayFee && !gatewayFeeRecipient) ||
+    (gatewayFeeRecipient && !gatewayFee)
+  ) {
+    throw new BaseError(
+      '`gatewayFee` and `gatewayFeeRecipient` must be provided together.',
+    )
+  }
+
+  if (feeCurrency && !feeCurrency?.startsWith('0x')) {
+    throw new BaseError(
+      '`feeCurrency` MUST be a token address for CIP-42 transactions.',
+    )
+  }
+
+  if (!feeCurrency && !gatewayFeeRecipient) {
+    throw new BaseError(
+      'Either `feeCurrency` or `gatewayFeeRecipient` must be provided for CIP-42 transactions.',
+    )
+  }
+}

package/src/chains/celo/types.ts

@@ -0,0 +1,199 @@
+import type { Address } from 'abitype'
+
+import type { Block, BlockTag } from '../../types/block.js'
+import type { FeeValuesEIP1559 } from '../../types/fee.js'
+import type { Hex } from '../../types/misc.js'
+import type {
+  Index,
+  Quantity,
+  RpcBlock,
+  RpcTransaction as RpcTransaction_,
+  RpcTransactionReceipt,
+  RpcTransactionRequest as RpcTransactionRequest_,
+  TransactionType,
+} from '../../types/rpc.js'
+import type {
+  AccessList,
+  Transaction as Transaction_,
+  TransactionBase,
+  TransactionReceipt,
+  TransactionRequest as TransactionRequest_,
+  TransactionRequestBase,
+  TransactionSerializable,
+  TransactionSerializableBase,
+  TransactionSerialized,
+} from '../../types/transaction.js'
+import type { NeverBy } from '../../types/utils.js'
+import type { OptimismRpcTransaction } from '../optimism/types.js'
+
+type CeloBlockExclude =
+  | 'difficulty'
+  | 'gasLimit'
+  | 'mixHash'
+  | 'nonce'
+  | 'uncles'
+
+export type CeloBlockOverrides = {
+  randomness: {
+    committed: Hex
+    revealed: Hex
+  }
+}
+export type CeloBlock<
+  TIncludeTransactions extends boolean = boolean,
+  TBlockTag extends BlockTag = BlockTag,
+> = NeverBy<
+  Block<
+    bigint,
+    TIncludeTransactions,
+    TBlockTag,
+    CeloTransaction<TBlockTag extends 'pending' ? true : false>
+  >,
+  CeloBlockExclude
+> &
+  CeloBlockOverrides
+
+export type CeloRpcBlockOverrides = {
+  randomness: {
+    committed: Hex
+    revealed: Hex
+  }
+}
+export type CeloRpcBlock<
+  TBlockTag extends BlockTag = BlockTag,
+  TIncludeTransactions extends boolean = boolean,
+> = NeverBy<
+  RpcBlock<
+    TBlockTag,
+    TIncludeTransactions,
+    OptimismRpcTransaction<TBlockTag extends 'pending' ? true : false>
+  >,
+  CeloBlockExclude
+> &
+  CeloRpcBlockOverrides
+
+export type CeloRpcTransaction<TPending extends boolean = boolean> =
+  | RpcTransaction<TPending>
+  | RpcTransactionCIP42<TPending>
+
+export type CeloRpcTransactionReceiptOverrides = {
+  feeCurrency: Address | null
+  gatewayFee: Hex | null
+  gatewayFeeRecipient: Address | null
+}
+export type CeloRpcTransactionReceipt = RpcTransactionReceipt &
+  CeloRpcTransactionReceiptOverrides
+
+export type CeloRpcTransactionRequest =
+  | RpcTransactionRequest
+  | RpcTransactionRequestCIP42
+
+export type CeloTransaction<TPending extends boolean = boolean> =
+  | Transaction<TPending>
+  | TransactionCIP42<TPending>
+
+export type CeloTransactionReceiptOverrides = {
+  feeCurrency: Address | null
+  gatewayFee: bigint | null
+  gatewayFeeRecipient: Address | null
+}
+export type CeloTransactionReceipt = TransactionReceipt &
+  CeloTransactionReceiptOverrides
+
+export type CeloTransactionRequest =
+  | TransactionRequest
+  | TransactionRequestCIP42
+
+export type CeloTransactionSerializable =
+  | TransactionSerializableCIP42
+  | TransactionSerializable
+
+export type CeloTransactionSerialized<
+  TType extends CeloTransactionType = 'legacy',
+> = TransactionSerialized<TType> | TransactionSerializedCIP42
+
+export type CeloTransactionType = TransactionType | 'cip42'
+
+type RpcTransaction<TPending extends boolean = boolean> =
+  RpcTransaction_<TPending> & {
+    feeCurrency: Address | null
+    gatewayFee: Hex | null
+    gatewayFeeRecipient: Address | null
+  }
+
+type RpcTransactionRequest = RpcTransactionRequest_ & {
+  feeCurrency?: Address
+  gatewayFee?: Hex
+  gatewayFeeRecipient?: Address
+}
+
+export type RpcTransactionCIP42<TPending extends boolean = boolean> =
+  TransactionBase<Quantity, Index, TPending> &
+    FeeValuesEIP1559<Quantity> & {
+      feeCurrency: Address | null
+      gatewayFee: Hex | null
+      gatewayFeeRecipient: Address | null
+      type: '0x7c'
+    }
+
+export type RpcTransactionRequestCIP42 = TransactionRequestBase<
+  Quantity,
+  Index
+> &
+  Partial<FeeValuesEIP1559<Quantity>> & {
+    accessList?: AccessList
+    feeCurrency?: Address
+    gatewayFee?: Hex
+    gatewayFeeRecipient?: Address
+    type?: '0x7c'
+  }
+
+type Transaction<TPending extends boolean = boolean> = Transaction_<
+  bigint,
+  number,
+  TPending
+> & {
+  feeCurrency: Address | null
+  gatewayFee: bigint | null
+  gatewayFeeRecipient: Address | null
+}
+
+export type TransactionCIP42<TPending extends boolean = boolean> =
+  TransactionBase<bigint, number, TPending> &
+    FeeValuesEIP1559 & {
+      feeCurrency: Address | null
+      gatewayFee: bigint | null
+      gatewayFeeRecipient: Address | null
+      type: 'cip42'
+    }
+
+type TransactionRequest = TransactionRequest_ & {
+  feeCurrency?: Address
+  gatewayFee?: bigint
+  gatewayFeeRecipient?: Address
+}
+
+export type TransactionRequestCIP42 = TransactionRequestBase &
+  Partial<FeeValuesEIP1559> & {
+    accessList?: AccessList
+    feeCurrency?: Address
+    gatewayFee?: bigint
+    gatewayFeeRecipient?: Address
+    type?: 'cip42'
+  }
+
+export type TransactionSerializableCIP42<
+  TQuantity = bigint,
+  TIndex = number,
+> = TransactionSerializableBase<TQuantity, TIndex> &
+  FeeValuesEIP1559<TQuantity> & {
+    accessList?: AccessList
+    gasPrice?: never
+    feeCurrency?: Address
+    gatewayFeeRecipient?: Address
+    gatewayFee?: TQuantity
+    chainId: number
+    type?: 'cip42'
+  }
+
+export type TransactionSerializedCIP42 = `0x7c${string}`