viem 2.21.60 → 2.22.1

package/actions/public/simulate.ts

@@ -0,0 +1,290 @@
+import type { Abi, AbiStateMutability, Address, Narrow } from 'abitype'
+import * as BlockOverrides from 'ox/BlockOverrides'
+
+import {
+  type ParseAccountErrorType,
+  parseAccount,
+} from '../../accounts/utils/parseAccount.js'
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import { AbiDecodingZeroDataError } from '../../errors/abi.js'
+import type { BaseError } from '../../errors/base.js'
+import { RawContractError } from '../../errors/contract.js'
+import { UnknownNodeError } from '../../errors/node.js'
+import type { ErrorType } from '../../errors/utils.js'
+import type { Account } from '../../types/account.js'
+import type { Block, BlockTag } from '../../types/block.js'
+import type { Call, Calls } from '../../types/calls.js'
+import type { Chain } from '../../types/chain.js'
+import type { Log } from '../../types/log.js'
+import type { Hex } from '../../types/misc.js'
+import type { MulticallResults } from '../../types/multicall.js'
+import type { StateOverride } from '../../types/stateOverride.js'
+import type { TransactionRequest } from '../../types/transaction.js'
+import type { ExactPartial, UnionOmit } from '../../types/utils.js'
+import {
+  type DecodeFunctionResultErrorType,
+  decodeFunctionResult,
+} from '../../utils/abi/decodeFunctionResult.js'
+import {
+  type EncodeFunctionDataErrorType,
+  encodeFunctionData,
+} from '../../utils/abi/encodeFunctionData.js'
+import {
+  type NumberToHexErrorType,
+  numberToHex,
+} from '../../utils/encoding/toHex.js'
+import { getContractError } from '../../utils/errors/getContractError.js'
+import {
+  type GetNodeErrorReturnType,
+  getNodeError,
+} from '../../utils/errors/getNodeError.js'
+import {
+  type FormatBlockErrorType,
+  formatBlock,
+} from '../../utils/formatters/block.js'
+import { formatLog } from '../../utils/formatters/log.js'
+import {
+  type FormatTransactionRequestErrorType,
+  formatTransactionRequest,
+} from '../../utils/formatters/transactionRequest.js'
+import {
+  type SerializeStateOverrideErrorType,
+  serializeStateOverride,
+} from '../../utils/stateOverride.js'
+import {
+  type AssertRequestErrorType,
+  assertRequest,
+} from '../../utils/transaction/assertRequest.js'
+
+type CallExtraProperties = ExactPartial<
+  UnionOmit<
+    TransactionRequest,
+    'blobs' | 'data' | 'kzg' | 'to' | 'sidecars' | 'value'
+  >
+> & {
+  /** Account attached to the call (msg.sender). */
+  account?: Account | Address | undefined
+}
+
+export type SimulateParameters<
+  calls extends readonly unknown[] = readonly unknown[],
+> = {
+  /** Blocks to simulate. */
+  blocks: readonly {
+    /** Block overrides. */
+    blockOverrides?: BlockOverrides.BlockOverrides | undefined
+    /** Calls to execute. */
+    calls: Calls<Narrow<calls>, CallExtraProperties>
+    /** State overrides. */
+    stateOverrides?: StateOverride | undefined
+  }[]
+  /** Whether to return the full transactions. */
+  returnFullTransactions?: boolean
+  /** Whether to trace transfers. */
+  traceTransfers?: boolean
+  /** Whether to enable validation mode. */
+  validation?: boolean
+} & (
+  | {
+      /** The balance of the account at a block number. */
+      blockNumber?: bigint | undefined
+      blockTag?: undefined
+    }
+  | {
+      blockNumber?: undefined
+      /**
+       * The balance of the account at a block tag.
+       * @default 'latest'
+       */
+      blockTag?: BlockTag | undefined
+    }
+)
+
+export type SimulateReturnType<
+  calls extends readonly unknown[] = readonly unknown[],
+> = readonly (Block & {
+  calls: MulticallResults<
+    Narrow<calls>,
+    true,
+    {
+      extraProperties: {
+        data: Hex
+        gasUsed: bigint
+        logs?: Log[] | undefined
+      }
+      error: Error
+      mutability: AbiStateMutability
+    }
+  >
+})[]
+
+export type SimulateErrorType =
+  | AssertRequestErrorType
+  | DecodeFunctionResultErrorType
+  | EncodeFunctionDataErrorType
+  | FormatBlockErrorType
+  | FormatTransactionRequestErrorType
+  | GetNodeErrorReturnType
+  | ParseAccountErrorType
+  | SerializeStateOverrideErrorType
+  | NumberToHexErrorType
+  | ErrorType
+
+/**
+ * Simulates a set of calls on block(s) with optional block and state overrides.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http, parseEther } from 'viem'
+ * import { simulate } from 'viem/actions'
+ * import { mainnet } from 'viem/chains'
+ *
+ * const client = createClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ *
+ * const result = await simulate(client, {
+ *   blocks: [{
+ *     blockOverrides: {
+ *       number: 69420n,
+ *     },
+ *     calls: [{
+ *       {
+ *         account: '0x5a0b54d5dc17e482fe8b0bdca5320161b95fb929',
+ *         data: '0xdeadbeef',
+ *         to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *       },
+ *       {
+ *         account: '0x5a0b54d5dc17e482fe8b0bdca5320161b95fb929',
+ *         to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *         value: parseEther('1'),
+ *       },
+ *     }],
+ *     stateOverrides: [{
+ *       address: '0x5a0b54d5dc17e482fe8b0bdca5320161b95fb929',
+ *       balance: parseEther('10'),
+ *     }],
+ *   }]
+ * })
+ * ```
+ *
+ * @param client - Client to use.
+ * @param parameters - {@link SimulateParameters}
+ * @returns Simulated blocks. {@link SimulateReturnType}
+ */
+export async function simulate<
+  chain extends Chain | undefined,
+  const calls extends readonly unknown[],
+>(
+  client: Client<Transport, chain>,
+  parameters: SimulateParameters<calls>,
+): Promise<SimulateReturnType<calls>> {
+  const {
+    blockNumber,
+    blockTag = 'latest',
+    blocks,
+    returnFullTransactions,
+    traceTransfers,
+    validation,
+  } = parameters
+
+  try {
+    const blockStateCalls = []
+    for (const block of blocks) {
+      const blockOverrides = block.blockOverrides
+        ? BlockOverrides.toRpc(block.blockOverrides)
+        : undefined
+      const calls = block.calls.map((call_) => {
+        const call = call_ as Call<unknown, CallExtraProperties>
+        const account = call.account ? parseAccount(call.account) : undefined
+        const request = {
+          ...call,
+          data: call.abi ? encodeFunctionData(call) : call.data,
+          from: call.from ?? account?.address,
+        } as const
+        assertRequest(request)
+        return formatTransactionRequest(request)
+      })
+      const stateOverrides = block.stateOverrides
+        ? serializeStateOverride(block.stateOverrides)
+        : undefined
+
+      blockStateCalls.push({
+        blockOverrides,
+        calls,
+        stateOverrides,
+      })
+    }
+
+    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : undefined
+    const block = blockNumberHex || blockTag
+
+    const result = await client.request({
+      method: 'eth_simulateV1',
+      params: [
+        { blockStateCalls, returnFullTransactions, traceTransfers, validation },
+        block,
+      ],
+    })
+
+    return result.map((block, i) => ({
+      ...formatBlock(block),
+      calls: block.calls.map((call, j) => {
+        const { abi, args, functionName, to } = blocks[i].calls[j] as Call<
+          unknown,
+          CallExtraProperties
+        >
+
+        const data = call.error?.data ?? call.returnData
+        const gasUsed = BigInt(call.gasUsed)
+        const logs = call.logs?.map((log) => formatLog(log))
+        const status = call.status === '0x1' ? 'success' : 'failure'
+
+        const result = abi
+          ? decodeFunctionResult({
+              abi,
+              data,
+              functionName,
+            })
+          : null
+
+        const error = (() => {
+          if (status === 'success') return undefined
+
+          let error = undefined
+          if (call.error?.data === '0x') error = new AbiDecodingZeroDataError()
+          else if (call.error) error = new RawContractError(call.error)
+
+          if (!error) return undefined
+          return getContractError(error, {
+            abi: (abi ?? []) as Abi,
+            address: to,
+            args,
+            functionName: functionName ?? '<unknown>',
+          })
+        })()
+
+        return {
+          data,
+          gasUsed,
+          logs,
+          status,
+          ...(status === 'success'
+            ? {
+                result,
+              }
+            : {
+                error,
+              }),
+        }
+      }),
+    })) as unknown as SimulateReturnType<calls>
+  } catch (e) {
+    const cause = e as BaseError
+    const error = getNodeError(cause, {})
+    if (error instanceof UnknownNodeError) throw cause
+    throw error
+  }
+}

package/chains/definitions/mainnet.ts

@@ -6,7 +6,7 @@ export const mainnet = /*#__PURE__*/ defineChain({
   nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
   rpcUrls: {
     default: {
-      http: ['https://cloudflare-eth.com'],
+      http: ['https://eth.merkle.io'],
     },
   },
   blockExplorers: {

package/clients/decorators/public.ts

@@ -180,6 +180,11 @@ import {
   type ReadContractReturnType,
   readContract,
 } from '../../actions/public/readContract.js'
+import {
+  type SimulateParameters,
+  type SimulateReturnType,
+  simulate,
+} from '../../actions/public/simulate.js'
 import {
   type SimulateContractParameters,
   type SimulateContractReturnType,
@@ -1520,6 +1525,51 @@ export type PublicActions<
   sendRawTransaction: (
     args: SendRawTransactionParameters,
   ) => Promise<SendRawTransactionReturnType>
+  /**
+   * Simulates a set of calls on block(s) with optional block and state overrides.
+   *
+   * @example
+   * ```ts
+   * import { createPublicClient, http, parseEther } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createPublicClient({
+   *   chain: mainnet,
+   *   transport: http(),
+   * })
+   *
+   * const result = await client.simulate({
+   *   blocks: [{
+   *     blockOverrides: {
+   *       number: 69420n,
+   *     },
+   *     calls: [{
+   *       {
+   *         account: '0x5a0b54d5dc17e482fe8b0bdca5320161b95fb929',
+   *         data: '0xdeadbeef',
+   *         to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+   *       },
+   *       {
+   *         account: '0x5a0b54d5dc17e482fe8b0bdca5320161b95fb929',
+   *         to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+   *         value: parseEther('1'),
+   *       },
+   *     }],
+   *     stateOverrides: [{
+   *       address: '0x5a0b54d5dc17e482fe8b0bdca5320161b95fb929',
+   *       balance: parseEther('10'),
+   *     }],
+   *   }]
+   * })
+   * ```
+   *
+   * @param client - Client to use.
+   * @param parameters - {@link SimulateParameters}
+   * @returns Simulated blocks. {@link SimulateReturnType}
+   */
+  simulate: <const calls extends readonly unknown[]>(
+    args: SimulateParameters<calls>,
+  ) => Promise<SimulateReturnType<calls>>
   /**
    * Simulates/validates a contract interaction. This is useful for retrieving **return data** and **revert reasons** of contract write functions.
    *
@@ -1908,6 +1958,7 @@ export function publicActions<
       prepareTransactionRequest(client as any, args as any) as any,
     readContract: (args) => readContract(client, args),
     sendRawTransaction: (args) => sendRawTransaction(client, args),
+    simulate: (args) => simulate(client, args),
     simulateContract: (args) => simulateContract(client, args),
     verifyMessage: (args) => verifyMessage(client, args),
     verifySiweMessage: (args) => verifySiweMessage(client, args),

package/errors/version.ts

@@ -1 +1 @@
-export const version = '2.21.60'
+export const version = '2.22.1'

package/experimental/erc7821/actions/execute.ts

@@ -40,10 +40,10 @@ import {
 import { supportsExecutionMode } from './supportsExecutionMode.js'
 
 export type ExecuteParameters<
+  calls extends readonly unknown[] = readonly unknown[],
   chain extends Chain | undefined = Chain | undefined,
   account extends Account | undefined = Account | undefined,
   chainOverride extends Chain | undefined = Chain | undefined,
-  calls extends readonly unknown[] = readonly unknown[],
   _derivedChain extends Chain | undefined = DeriveChain<chain, chainOverride>,
 > = UnionEvaluate<
   UnionPick<
@@ -149,7 +149,7 @@ export async function execute<
   chainOverride extends Chain | undefined = undefined,
 >(
   client: Client<Transport, chain, account>,
-  parameters: ExecuteParameters<chain, account, chainOverride, calls>,
+  parameters: ExecuteParameters<calls, chain, account, chainOverride>,
 ): Promise<ExecuteReturnType> {
   const { address, authorizationList, opData } = parameters
 

package/experimental/erc7821/decorators/erc7821.ts

@@ -89,7 +89,7 @@ export type Erc7821Actions<
     const calls extends readonly unknown[],
     chainOverride extends Chain | undefined = undefined,
   >(
-    parameters: ExecuteParameters<chain, account, chainOverride, calls>,
+    parameters: ExecuteParameters<calls, chain, account, chainOverride>,
   ) => Promise<ExecuteReturnType>
   /**
    * Checks if the contract supports the ERC-7821 execution mode.

package/index.ts

@@ -36,6 +36,10 @@ export {
   parseAbiParameter,
   parseAbiParameters,
 } from 'abitype'
+export type {
+  BlockOverrides,
+  Rpc as RpcBlockOverrides,
+} from 'ox/BlockOverrides'
 
 export {
   getContract,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "viem",
   "description": "TypeScript Interface for Ethereum",
-  "version": "2.21.60",
+  "version": "2.22.1",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",
@@ -177,7 +177,7 @@
     "@scure/bip39": "1.5.0",
     "abitype": "1.0.7",
     "isows": "1.0.6",
-    "ox": "0.4.4",
+    "ox": "0.6.0",
     "webauthn-p256": "0.0.10",
     "ws": "8.18.0"
   },

package/types/calls.ts

@@ -3,31 +3,40 @@ import type { Hex } from './misc.js'
 import type { GetMulticallContractParameters } from './multicall.js'
 import type { OneOf, Prettify } from './utils.js'
 
-export type Call<call = unknown> = OneOf<
-  | {
+export type Call<
+  call = unknown,
+  extraProperties extends Record<string, unknown> = {},
+> = OneOf<
+  | (extraProperties & {
       data?: Hex | undefined
       to: Address
       value?: bigint | undefined
-    }
-  | (Omit<
-      GetMulticallContractParameters<call, AbiStateMutability>,
-      'address'
-    > & {
-      to: Address
-      value?: bigint | undefined
     })
+  | (extraProperties &
+      (Omit<
+        GetMulticallContractParameters<call, AbiStateMutability>,
+        'address'
+      > & {
+        to: Address
+        value?: bigint | undefined
+      }))
 >
 
 export type Calls<
   calls extends readonly unknown[],
+  extraProperties extends Record<string, unknown> = {},
   ///
   result extends readonly any[] = [],
 > = calls extends readonly [] // no calls, return empty
   ? readonly []
   : calls extends readonly [infer call] // one call left before returning `result`
-    ? readonly [...result, Prettify<Call<call>>]
+    ? readonly [...result, Prettify<Call<call, extraProperties>>]
     : calls extends readonly [infer call, ...infer rest] // grab first call and recurse through `rest`
-      ? Calls<[...rest], [...result, Prettify<Call<call>>]>
+      ? Calls<
+          [...rest],
+          extraProperties,
+          [...result, Prettify<Call<call, extraProperties>>]
+        >
       : readonly unknown[] extends calls
         ? calls
         : // If `calls` is *some* array but we couldn't assign `unknown[]` to it, then it must hold some known/homogenous type!

package/types/eip1193.ts

@@ -1,5 +1,6 @@
 import type { Address } from 'abitype'
 
+import type * as BlockOverrides from 'ox/BlockOverrides'
 import type {
   RpcEstimateUserOperationGasReturnType,
   RpcGetUserOperationByHashReturnType,
@@ -1124,6 +1125,43 @@ export type PublicRpcSchema = [
     Parameters: [signedTransaction: Hex]
     ReturnType: Hash
   },
+  /**
+   * @description Simulates execution of a set of calls with optional block and state overrides.
+   * @example
+   * provider.request({ method: 'eth_simulateV1', params: [{ blockStateCalls: [{ calls: [{ from: '0x...', to: '0x...', value: '0x...', data: '0x...' }] }] }, 'latest'] })
+   * // => { ... }
+   */
+  {
+    Method: 'eth_simulateV1'
+    Parameters: [
+      {
+        blockStateCalls: readonly {
+          blockOverrides?: BlockOverrides.Rpc | undefined
+          calls?: readonly ExactPartial<TransactionRequest>[] | undefined
+          stateOverrides?: RpcStateOverride | undefined
+        }[]
+        returnFullTransactions?: boolean | undefined
+        traceTransfers?: boolean | undefined
+        validation?: boolean | undefined
+      },
+      BlockNumber | BlockTag,
+    ]
+    ReturnType: readonly (Block & {
+      calls: readonly {
+        error?:
+          | {
+              data?: Hex | undefined
+              code: number
+              message: string
+            }
+          | undefined
+        logs?: readonly Log[] | undefined
+        gasUsed: Hex
+        returnData: Hex
+        status: Hex
+      }[]
+    })[]
+  },
   /**
    * @description Destroys a filter based on filter ID
    * @link https://eips.ethereum.org/EIPS/eip-1474

package/types/multicall.ts

@@ -68,9 +68,10 @@ export type MulticallResults<
   contracts extends readonly unknown[] = readonly ContractFunctionParameters[],
   allowFailure extends boolean = true,
   options extends {
-    error?: Error
+    error?: Error | undefined
+    extraProperties?: Record<string, unknown> | undefined
     mutability: AbiStateMutability
-  } = { error: Error; mutability: AbiStateMutability },
+  } = { error: Error; extraProperties: {}; mutability: AbiStateMutability },
   ///
   result extends any[] = [],
 > = contracts extends readonly [] // no contracts, return empty
@@ -81,7 +82,8 @@ export type MulticallResults<
         MulticallResponse<
           GetMulticallContractReturnType<contract, options['mutability']>,
           options['error'],
-          allowFailure
+          allowFailure,
+          options['extraProperties']
         >,
       ]
     : contracts extends readonly [infer contract, ...infer rest] // grab first contract and recurse through `rest`
@@ -94,12 +96,18 @@ export type MulticallResults<
             MulticallResponse<
               GetMulticallContractReturnType<contract, options['mutability']>,
               options['error'],
-              allowFailure
+              allowFailure,
+              options['extraProperties']
             >,
           ]
         >
       : readonly unknown[] extends contracts
-        ? MulticallResponse<unknown, options['error'], allowFailure>[]
+        ? MulticallResponse<
+            unknown,
+            options['error'],
+            allowFailure,
+            options['extraProperties']
+          >[]
         : // If `contracts` is *some* array but we couldn't assign `unknown[]` to it, then it must hold some known/homogenous type!
           // use this to infer the param types in the case of Array.map() argument
           contracts extends readonly (infer contract extends
@@ -107,23 +115,34 @@ export type MulticallResults<
           ? MulticallResponse<
               GetMulticallContractReturnType<contract, options['mutability']>,
               options['error'],
-              allowFailure
+              allowFailure,
+              options['extraProperties']
             >[]
           : // Fallback
-            MulticallResponse<unknown, options['error'], allowFailure>[]
+            MulticallResponse<
+              unknown,
+              options['error'],
+              allowFailure,
+              options['extraProperties']
+            >[]
 
 export type MulticallResponse<
   result = unknown,
   error = unknown,
   allowFailure extends boolean = true,
+  extraProperties extends Record<string, unknown> | undefined = {},
 > = allowFailure extends true
   ?
-      | { error?: undefined; result: result; status: 'success' }
-      | {
+      | (extraProperties & {
+          error?: undefined
+          result: result
+          status: 'success'
+        })
+      | (extraProperties & {
           error: unknown extends error ? Error : error
           result?: undefined
           status: 'failure'
-        }
+        })
   : result
 
 // infer contract parameters from `unknown`