viem 0.0.0-portable-types-20230523145621 → 0.0.0-tmm-sign-typed-data-types.20230619T221425

package/src/actions/public/getFilterChanges.ts

@@ -2,6 +2,10 @@ import type { Abi, AbiEvent, ExtractAbiEvent } from 'abitype'
 
 import type { PublicClient } from '../../clients/createPublicClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
+import {
+  DecodeLogDataMismatch,
+  DecodeLogTopicsMismatch,
+} from '../../errors/abi.js'
 import type { Chain } from '../../types/chain.js'
 import type { Filter, FilterType } from '../../types/filter.js'
 import type { Log } from '../../types/log.js'
@@ -13,21 +17,23 @@ export type GetFilterChangesParameters<
   TFilterType extends FilterType = FilterType,
   TAbi extends Abi | readonly unknown[] = Abi,
   TEventName extends string | undefined = string,
+  TStrict extends boolean | undefined = undefined,
 > = {
-  filter: Filter<TFilterType, TAbi, TEventName, any>
+  filter: Filter<TFilterType, TAbi, TEventName, any, TStrict>
 }
 
 export type GetFilterChangesReturnType<
   TFilterType extends FilterType = FilterType,
   TAbi extends Abi | readonly unknown[] = Abi,
   TEventName extends string | undefined = string,
+  TStrict extends boolean | undefined = undefined,
   _AbiEvent extends AbiEvent | undefined = TAbi extends Abi
     ? TEventName extends string
       ? ExtractAbiEvent<TAbi, TEventName>
       : undefined
     : undefined,
 > = TFilterType extends 'event'
-  ? Log<bigint, number, _AbiEvent, TAbi, TEventName>[]
+  ? Log<bigint, number, _AbiEvent, TStrict, TAbi, TEventName>[]
   : Hash[]
 
 /**
@@ -118,10 +124,15 @@ export async function getFilterChanges<
   TFilterType extends FilterType,
   TAbi extends Abi | readonly unknown[],
   TEventName extends string | undefined,
+  TStrict extends boolean | undefined = undefined,
 >(
   _client: PublicClient<TTransport, TChain>,
-  { filter }: GetFilterChangesParameters<TFilterType, TAbi, TEventName>,
+  {
+    filter,
+  }: GetFilterChangesParameters<TFilterType, TAbi, TEventName, TStrict>,
 ) {
+  const strict = 'strict' in filter && filter.strict
+
   const logs = await filter.request({
     method: 'eth_getFilterChanges',
     params: [filter.id],
@@ -136,17 +147,31 @@ export async function getFilterChanges<
                 abi: filter.abi,
                 data: log.data,
                 topics: log.topics as any,
+                strict,
               })
             : { eventName: undefined, args: undefined }
         return formatLog(log, { args, eventName })
-      } catch {
-        // Skip log if there is an error decoding (e.g. indexed/non-indexed params mismatch).
-        return
+      } catch (err) {
+        let eventName
+        let isUnnamed
+        if (
+          err instanceof DecodeLogDataMismatch ||
+          err instanceof DecodeLogTopicsMismatch
+        ) {
+          // If strict mode is on, and log data/topics do not match event definition, skip.
+          if ('strict' in filter && filter.strict) return
+          eventName = err.abiItem.name
+          isUnnamed = err.abiItem.inputs?.some((x) => !('name' in x && x.name))
+        }
+
+        // Set args undefined if there is an error decoding (e.g. indexed/non-indexed params mismatch).
+        return formatLog(log, { args: isUnnamed ? [] : {}, eventName })
       }
     })
     .filter(Boolean) as GetFilterChangesReturnType<
     TFilterType,
     TAbi,
-    TEventName
+    TEventName,
+    TStrict
   >
 }

package/src/actions/public/getFilterLogs.ts

@@ -2,6 +2,10 @@ import type { Abi, AbiEvent, ExtractAbiEvent } from 'abitype'
 
 import type { PublicClient } from '../../clients/createPublicClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
+import {
+  DecodeLogDataMismatch,
+  DecodeLogTopicsMismatch,
+} from '../../errors/abi.js'
 import type { Chain } from '../../types/chain.js'
 import type { Filter } from '../../types/filter.js'
 import type { Log } from '../../types/log.js'
@@ -11,18 +15,20 @@ import { formatLog } from '../../utils/formatters/log.js'
 export type GetFilterLogsParameters<
   TAbi extends Abi | readonly unknown[] = Abi,
   TEventName extends string | undefined = string,
+  TStrict extends boolean | undefined = undefined,
 > = {
-  filter: Filter<'event', TAbi, TEventName, any>
+  filter: Filter<'event', TAbi, TEventName, any, TStrict>
 }
 export type GetFilterLogsReturnType<
   TAbi extends Abi | readonly unknown[] = Abi,
   TEventName extends string | undefined = string,
+  TStrict extends boolean | undefined = undefined,
   _AbiEvent extends AbiEvent | undefined = TAbi extends Abi
     ? TEventName extends string
       ? ExtractAbiEvent<TAbi, TEventName>
       : undefined
     : undefined,
-> = Log<bigint, number, _AbiEvent, TAbi, TEventName>[]
+> = Log<bigint, number, _AbiEvent, TStrict, TAbi, TEventName>[]
 
 /**
  * Returns a list of event logs since the filter was created.
@@ -55,10 +61,13 @@ export async function getFilterLogs<
   TChain extends Chain | undefined,
   TAbi extends Abi | readonly unknown[],
   TEventName extends string | undefined,
+  TStrict extends boolean | undefined = undefined,
 >(
   _client: PublicClient<Transport, TChain>,
-  { filter }: GetFilterLogsParameters<TAbi, TEventName>,
-): Promise<GetFilterLogsReturnType<TAbi, TEventName>> {
+  { filter }: GetFilterLogsParameters<TAbi, TEventName, TStrict>,
+): Promise<GetFilterLogsReturnType<TAbi, TEventName, TStrict>> {
+  const strict = filter.strict ?? false
+
   const logs = await filter.request({
     method: 'eth_getFilterLogs',
     params: [filter.id],
@@ -72,13 +81,30 @@ export async function getFilterLogs<
                 abi: filter.abi,
                 data: log.data,
                 topics: log.topics as any,
+                strict,
               })
             : { eventName: undefined, args: undefined }
         return formatLog(log, { args, eventName })
-      } catch {
-        // Skip log if there is an error decoding (e.g. indexed/non-indexed params mismatch).
-        return
+      } catch (err) {
+        let eventName
+        let isUnnamed
+        if (
+          err instanceof DecodeLogDataMismatch ||
+          err instanceof DecodeLogTopicsMismatch
+        ) {
+          // If strict mode is on, and log data/topics do not match event definition, skip.
+          if ('strict' in filter && filter.strict) return
+          eventName = err.abiItem.name
+          isUnnamed = err.abiItem.inputs?.some((x) => !('name' in x && x.name))
+        }
+
+        // Set args to empty if there is an error decoding (e.g. indexed/non-indexed params mismatch).
+        return formatLog(log, { args: isUnnamed ? [] : {}, eventName })
       }
     })
-    .filter(Boolean) as unknown as GetFilterLogsReturnType<TAbi, TEventName>
+    .filter(Boolean) as unknown as GetFilterLogsReturnType<
+    TAbi,
+    TEventName,
+    TStrict
+  >
 }

package/src/actions/public/getGasPrice.ts

@@ -34,7 +34,7 @@ export async function getGasPrice<
     | PublicClient<Transport, TChain>
     | WalletClient<Transport, TChain, TAccount>,
 ): Promise<GetGasPriceReturnType> {
-  const gasPrice = await client.request({
+  const gasPrice = await (client as PublicClient).request({
     method: 'eth_gasPrice',
   })
   return BigInt(gasPrice)

package/src/actions/public/getLogs.ts

@@ -2,6 +2,10 @@ import type { AbiEvent, Address, Narrow } from 'abitype'
 
 import type { PublicClient } from '../../clients/createPublicClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
+import {
+  DecodeLogDataMismatch,
+  DecodeLogTopicsMismatch,
+} from '../../errors/abi.js'
 import type { BlockNumber, BlockTag } from '../../types/block.js'
 import type { Chain } from '../../types/chain.js'
 import type {
@@ -21,18 +25,25 @@ import { formatLog } from '../../utils/formatters/log.js'
 
 export type GetLogsParameters<
   TAbiEvent extends AbiEvent | undefined = undefined,
-  TEventName extends string | undefined = MaybeAbiEventName<TAbiEvent>,
+  TStrict extends boolean | undefined = undefined,
+  _EventName extends string | undefined = MaybeAbiEventName<TAbiEvent>,
 > = {
   /** Address or list of addresses from which logs originated */
   address?: Address | Address[]
 } & (
   | {
       event: Narrow<TAbiEvent>
-      args?: MaybeExtractEventArgsFromAbi<[TAbiEvent], TEventName>
+      args?: MaybeExtractEventArgsFromAbi<[TAbiEvent], _EventName>
+      /**
+       * Whether or not the logs must match the indexed/non-indexed arguments on `event`.
+       * @default false
+       */
+      strict?: TStrict
     }
   | {
       event?: never
       args?: never
+      strict?: never
     }
 ) &
   (
@@ -53,8 +64,9 @@ export type GetLogsParameters<
 
 export type GetLogsReturnType<
   TAbiEvent extends AbiEvent | undefined = undefined,
-  TEventName extends string | undefined = MaybeAbiEventName<TAbiEvent>,
-> = Log<bigint, number, TAbiEvent, [TAbiEvent], TEventName>[]
+  TStrict extends boolean | undefined = undefined,
+  _EventName extends string | undefined = MaybeAbiEventName<TAbiEvent>,
+> = Log<bigint, number, TAbiEvent, TStrict, [TAbiEvent], _EventName>[]
 
 /**
  * Returns a list of event logs matching the provided parameters.
@@ -81,6 +93,7 @@ export type GetLogsReturnType<
 export async function getLogs<
   TChain extends Chain | undefined,
   TAbiEvent extends AbiEvent | undefined,
+  TStrict extends boolean | undefined = undefined,
 >(
   client: PublicClient<Transport, TChain>,
   {
@@ -90,8 +103,11 @@ export async function getLogs<
     toBlock,
     event,
     args,
-  }: GetLogsParameters<TAbiEvent> = {},
-): Promise<GetLogsReturnType<TAbiEvent>> {
+    strict: strict_,
+  }: GetLogsParameters<TAbiEvent, TStrict> = {},
+): Promise<GetLogsReturnType<TAbiEvent, TStrict>> {
+  const strict = strict_ ?? false
+
   let topics: LogTopic[] = []
   if (event)
     topics = encodeEventTopics({
@@ -129,13 +145,26 @@ export async function getLogs<
               abi: [event] as [AbiEvent],
               data: log.data,
               topics: log.topics as any,
+              strict,
             })
           : { eventName: undefined, args: undefined }
         return formatLog(log, { args, eventName })
-      } catch {
-        // Skip log if there is an error decoding (e.g. indexed/non-indexed params mismatch).
-        return
+      } catch (err) {
+        let eventName
+        let isUnnamed
+        if (
+          err instanceof DecodeLogDataMismatch ||
+          err instanceof DecodeLogTopicsMismatch
+        ) {
+          // If strict mode is on, and log data/topics do not match event definition, skip.
+          if (strict) return
+          eventName = err.abiItem.name
+          isUnnamed = err.abiItem.inputs?.some((x) => !('name' in x && x.name))
+        }
+
+        // Set args to empty if there is an error decoding (e.g. indexed/non-indexed params mismatch).
+        return formatLog(log, { args: isUnnamed ? [] : {}, eventName })
       }
     })
-    .filter(Boolean) as unknown as GetLogsReturnType<TAbiEvent>
+    .filter(Boolean) as unknown as GetLogsReturnType<TAbiEvent, TStrict>
 }

package/src/actions/public/getTransactionCount.ts

@@ -58,7 +58,7 @@ export async function getTransactionCount<
     | WalletClient<Transport, TChain, TAccount>,
   { address, blockTag = 'latest', blockNumber }: GetTransactionCountParameters,
 ): Promise<GetTransactionCountReturnType> {
-  const count = await client.request({
+  const count = await (client as PublicClient).request({
     method: 'eth_getTransactionCount',
     params: [address, blockNumber ? numberToHex(blockNumber) : blockTag],
   })

package/src/actions/public/verifyMessage.ts

@@ -1,7 +1,7 @@
 import type { Chain } from '../../chains.js'
 import type { PublicClient } from '../../clients/createPublicClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
-import type { ByteArray, Hex } from '../../types/misc.js'
+import type { ByteArray, Hex, SignableMessage } from '../../types/misc.js'
 import { hashMessage } from '../../utils/index.js'
 import { type VerifyHashParameters, verifyHash } from './verifyHash.js'
 import type { Address } from 'abitype'
@@ -10,7 +10,7 @@ export type VerifyMessageParameters = Omit<VerifyHashParameters, 'hash'> & {
   /** The address that signed the original message. */
   address: Address
   /** The message to be verified. */
-  message: string
+  message: SignableMessage
   /** The signature that was generated by signing the message with the address's private key. */
   signature: Hex | ByteArray
 }

package/src/actions/public/verifyTypedData.ts

@@ -3,13 +3,16 @@ import type { PublicClient } from '../../clients/createPublicClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
 import type { TypedDataDefinition } from '../../types/typedData.js'
-import { hashTypedData } from '../../utils/index.js'
+import {
+  type HashTypedDataParameters,
+  hashTypedData,
+} from '../../utils/index.js'
 import { type VerifyHashParameters, verifyHash } from './verifyHash.js'
 import type { Address, TypedData } from 'abitype'
 
 export type VerifyTypedDataParameters<
-  TTypedData extends TypedData | { [key: string]: unknown } = TypedData,
-  TPrimaryType extends string = string,
+  TTypedData extends TypedData | Record<string, unknown> = TypedData,
+  TPrimaryType extends keyof TTypedData = keyof TTypedData,
 > = Omit<VerifyHashParameters, 'hash'> &
   TypedDataDefinition<TTypedData, TPrimaryType> & {
     /** The address to verify the typed data for. */
@@ -29,7 +32,11 @@ export type VerifyTypedDataReturnType = boolean
  * @param parameters - {@link VerifyTypedDataParameters}
  * @returns Whether or not the signature is valid. {@link VerifyTypedDataReturnType}
  */
-export async function verifyTypedData<TChain extends Chain | undefined,>(
+export async function verifyTypedData<
+  const TTypedData extends TypedData | Record<string, unknown>, // `Record<string, unknown>` allows for non-const asserted types
+  TPrimaryType extends keyof TTypedData,
+  TChain extends Chain | undefined,
+>(
   client: PublicClient<Transport, TChain>,
   {
     address,
@@ -39,9 +46,14 @@ export async function verifyTypedData<TChain extends Chain | undefined,>(
     types,
     domain,
     ...callRequest
-  }: VerifyTypedDataParameters,
+  }: VerifyTypedDataParameters<TTypedData, TPrimaryType>,
 ): Promise<VerifyTypedDataReturnType> {
-  const hash = hashTypedData({ message, primaryType, types, domain })
+  const hash = hashTypedData({
+    message,
+    primaryType,
+    types,
+    domain,
+  } as HashTypedDataParameters)
   return verifyHash(client, {
     address,
     hash,

package/src/actions/public/watchContractEvent.ts

@@ -26,17 +26,20 @@ import { uninstallFilter } from './uninstallFilter.js'
 export type OnLogsParameter<
   TAbi extends Abi | readonly unknown[] = readonly unknown[],
   TEventName extends string = string,
+  TStrict extends boolean | undefined = undefined,
 > = TAbi extends Abi
-  ? Log<bigint, number, ExtractAbiEvent<TAbi, TEventName>>[]
+  ? Log<bigint, number, ExtractAbiEvent<TAbi, TEventName>, TStrict>[]
   : Log[]
 export type OnLogsFn<
   TAbi extends Abi | readonly unknown[] = readonly unknown[],
   TEventName extends string = string,
-> = (logs: OnLogsParameter<TAbi, TEventName>) => void
+  TStrict extends boolean | undefined = undefined,
+> = (logs: OnLogsParameter<TAbi, TEventName, TStrict>) => void
 
 export type WatchContractEventParameters<
   TAbi extends Abi | readonly unknown[] = readonly unknown[],
   TEventName extends string = string,
+  TStrict extends boolean | undefined = undefined,
 > = {
   /** The address of the contract. */
   address?: Address | Address[]
@@ -50,9 +53,14 @@ export type WatchContractEventParameters<
   /** The callback to call when an error occurred when trying to get for a new block. */
   onError?: (error: Error) => void
   /** The callback to call when new event logs are received. */
-  onLogs: OnLogsFn<TAbi, TEventName>
+  onLogs: OnLogsFn<TAbi, TEventName, TStrict>
   /** Polling frequency (in ms). Defaults to Client's pollingInterval config. */
   pollingInterval?: number
+  /**
+   * Whether or not the logs must match the indexed/non-indexed arguments on `event`.
+   * @default false
+   */
+  strict?: TStrict
 }
 
 export type WatchContractEventReturnType = () => void
@@ -91,6 +99,7 @@ export function watchContractEvent<
   TChain extends Chain | undefined,
   TAbi extends Abi | readonly unknown[],
   TEventName extends string,
+  TStrict extends boolean | undefined = undefined,
 >(
   client: PublicClient<Transport, TChain>,
   {
@@ -102,7 +111,8 @@ export function watchContractEvent<
     onError,
     onLogs,
     pollingInterval = client.pollingInterval,
-  }: WatchContractEventParameters<TAbi, TEventName>,
+    strict: strict_,
+  }: WatchContractEventParameters<TAbi, TEventName, TStrict>,
 ): WatchContractEventReturnType {
   const observerId = stringify([
     'watchContractEvent',
@@ -113,6 +123,7 @@ export function watchContractEvent<
     eventName,
     pollingInterval,
   ])
+  const strict = strict_ ?? false
 
   return observe(observerId, { onLogs, onError }, (emit) => {
     let previousBlockNumber: bigint
@@ -128,6 +139,7 @@ export function watchContractEvent<
               address,
               args,
               eventName,
+              strict,
             } as unknown as CreateContractEventFilterParameters)) as Filter<
               'event',
               TAbi,

package/src/actions/public/watchEvent.ts

@@ -24,15 +24,18 @@ import { uninstallFilter } from './uninstallFilter.js'
 
 export type OnLogsParameter<
   TAbiEvent extends AbiEvent | undefined = undefined,
+  TStrict extends boolean | undefined = undefined,
   TEventName extends string | undefined = MaybeAbiEventName<TAbiEvent>,
-> = Log<bigint, number, TAbiEvent, [TAbiEvent], TEventName>[]
+> = Log<bigint, number, TAbiEvent, TStrict, [TAbiEvent], TEventName>[]
 export type OnLogsFn<
   TAbiEvent extends AbiEvent | undefined = undefined,
+  TStrict extends boolean | undefined = undefined,
   TEventName extends string | undefined = MaybeAbiEventName<TAbiEvent>,
-> = (logs: OnLogsParameter<TAbiEvent, TEventName>) => void
+> = (logs: OnLogsParameter<TAbiEvent, TStrict, TEventName>) => void
 
 export type WatchEventParameters<
   TAbiEvent extends AbiEvent | undefined = undefined,
+  TStrict extends boolean | undefined = undefined,
   TEventName extends string | undefined = MaybeAbiEventName<TAbiEvent>,
 > = {
   /** The address of the contract. */
@@ -45,17 +48,23 @@ export type WatchEventParameters<
   /** The callback to call when an error occurred when trying to get for a new block. */
   onError?: (error: Error) => void
   /** The callback to call when new event logs are received. */
-  onLogs: OnLogsFn<TAbiEvent, TEventName>
+  onLogs: OnLogsFn<TAbiEvent, TStrict, TEventName>
   /** Polling frequency (in ms). Defaults to Client's pollingInterval config. */
   pollingInterval?: number
 } & (
   | {
       event: TAbiEvent
       args?: MaybeExtractEventArgsFromAbi<[TAbiEvent], TEventName>
+      /**
+       * Whether or not the logs must match the indexed/non-indexed arguments on `event`.
+       * @default false
+       */
+      strict?: TStrict
     }
   | {
       event?: never
       args?: never
+      strict?: never
     }
 )
 
@@ -97,6 +106,7 @@ export function watchEvent<
   TChain extends Chain | undefined,
   TAbiEvent extends AbiEvent | undefined,
   TEventName extends string | undefined,
+  TStrict extends boolean | undefined = undefined,
 >(
   client: PublicClient<Transport, TChain>,
   {
@@ -107,7 +117,8 @@ export function watchEvent<
     onError,
     onLogs,
     pollingInterval = client.pollingInterval,
-  }: WatchEventParameters<TAbiEvent>,
+    strict: strict_,
+  }: WatchEventParameters<TAbiEvent, TStrict>,
 ): WatchEventReturnType {
   const observerId = stringify([
     'watchEvent',
@@ -118,6 +129,7 @@ export function watchEvent<
     event,
     pollingInterval,
   ])
+  const strict = strict_ ?? false
 
   return observe(observerId, { onLogs, onError }, (emit) => {
     let previousBlockNumber: bigint
@@ -132,6 +144,7 @@ export function watchEvent<
               address,
               args,
               event: event!,
+              strict,
             } as unknown as CreateEventFilterParameters)) as unknown as Filter<
               'event',
               [TAbiEvent],

package/src/actions/test/getAutomine.ts

@@ -30,6 +30,10 @@ export type GetAutomineReturnType = boolean
 export async function getAutomine<TChain extends Chain | undefined>(
   client: TestClient<TestClientMode, Transport, TChain>,
 ): Promise<GetAutomineReturnType> {
+  if (client.mode === 'ganache')
+    return await client.request({
+      method: 'eth_mining',
+    })
   return await client.request({
     method: `${client.mode}_getAutomine`,
   })

package/src/actions/test/mine.ts

@@ -37,8 +37,14 @@ export async function mine<TChain extends Chain | undefined>(
   client: TestClient<TestClientMode, Transport, TChain>,
   { blocks, interval }: MineParameters,
 ) {
-  await client.request({
-    method: `${client.mode}_mine`,
-    params: [numberToHex(blocks), numberToHex(interval || 0)],
-  })
+  if (client.mode === 'ganache')
+    await client.request({
+      method: 'evm_mine',
+      params: [{ blocks: numberToHex(blocks) }],
+    })
+  else
+    await client.request({
+      method: `${client.mode}_mine`,
+      params: [numberToHex(blocks), numberToHex(interval || 0)],
+    })
 }

package/src/actions/test/sendUnsignedTransaction.ts

@@ -4,11 +4,27 @@ 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 { formatTransactionRequest } from '../../utils/formatters/transactionRequest.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,
+  formatTransactionRequest,
+} from '../../utils/formatters/transactionRequest.js'
 
-export type SendUnsignedTransactionParameters = TransactionRequest
+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>>
 
 export type SendUnsignedTransactionReturnType = Hash
 
@@ -41,12 +57,45 @@ export async function sendUnsignedTransaction<
   TChain extends Chain | undefined,
 >(
   client: TestClient<TestClientMode, Transport, TChain>,
-  request: SendUnsignedTransactionParameters,
+  args: SendUnsignedTransactionParameters<TChain>,
 ): Promise<SendUnsignedTransactionReturnType> {
-  const request_ = formatTransactionRequest(request)
+  const {
+    accessList,
+    data,
+    from,
+    gas,
+    gasPrice,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    nonce,
+    to,
+    value,
+    ...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 hash = await client.request({
     method: 'eth_sendUnsignedTransaction',
-    params: [request_],
+    params: [request],
   })
   return hash
 }

package/src/actions/test/setAutomine.ts

@@ -28,8 +28,12 @@ export async function setAutomine<TChain extends Chain | undefined>(
   client: TestClient<TestClientMode, Transport, TChain>,
   enabled: boolean,
 ) {
-  await client.request({
-    method: 'evm_setAutomine',
-    params: [enabled],
-  })
+  if (client.mode === 'ganache') {
+    if (enabled) await client.request({ method: 'miner_start' })
+    else await client.request({ method: 'miner_stop' })
+  } else
+    await client.request({
+      method: 'evm_setAutomine',
+      params: [enabled],
+    })
 }

package/src/actions/test/setBalance.ts

@@ -42,8 +42,14 @@ export async function setBalance<TChain extends Chain | undefined>(
   client: TestClient<TestClientMode, Transport, TChain>,
   { address, value }: SetBalanceParameters,
 ) {
-  await client.request({
-    method: `${client.mode}_setBalance`,
-    params: [address, numberToHex(value)],
-  })
+  if (client.mode === 'ganache')
+    await client.request({
+      method: 'evm_setAccountBalance',
+      params: [address, numberToHex(value)],
+    })
+  else
+    await client.request({
+      method: `${client.mode}_setBalance`,
+      params: [address, numberToHex(value)],
+    })
 }