Skip to main content

anvil_core/eth/
mod.rs

1use crate::{eth::subscription::SubscriptionId, types::ReorgOptions};
2use alloy_primitives::{
3    Address, B64, B256, Bytes, TxHash, U64, U256,
4    map::{HashMap, HashSet},
5};
6use alloy_rpc_types::{
7    BlockId, BlockNumberOrTag as BlockNumber, BlockOverrides, Bundle, Filter, Index, StateContext,
8    anvil::{Forking, MineOptions},
9    erc4337::TransactionConditional,
10    pubsub::{Params as SubscriptionParams, SubscriptionKind},
11    request::TransactionRequest,
12    simulate::SimulatePayload,
13    state::StateOverride,
14    trace::{
15        filter::TraceFilter,
16        geth::{GethDebugTracingCallOptions, GethDebugTracingOptions},
17        parity::TraceType,
18    },
19};
20use alloy_rpc_types_mev::EthCallBundle;
21use alloy_serde::WithOtherFields;
22use foundry_common::serde_helpers::{
23    deserialize_number, deserialize_number_opt, deserialize_number_seq, deserialize_u64_seq,
24    deserialize_u64_seq_opt,
25};
26
27pub mod block;
28pub mod subscription;
29pub mod transaction;
30pub mod wallet;
31
32pub mod serde_helpers;
33use self::serde_helpers::*;
34
35/// Wrapper type that ensures the type is named `params`
36#[derive(Clone, Debug, PartialEq, Eq, serde::Deserialize)]
37pub struct Params<T> {
38    #[serde(default)]
39    pub params: T,
40}
41
42/// Represents ethereum JSON-RPC API
43#[derive(Clone, Debug, serde::Deserialize)]
44#[serde(tag = "method", content = "params")]
45#[allow(clippy::large_enum_variant)]
46pub enum EthRequest {
47    #[serde(rename = "web3_clientVersion", with = "empty_params")]
48    Web3ClientVersion(()),
49
50    #[serde(rename = "web3_sha3", with = "sequence")]
51    Web3Sha3(Bytes),
52
53    /// Returns the current Ethereum protocol version.
54    #[serde(rename = "eth_protocolVersion", with = "empty_params")]
55    EthProtocolVersion(()),
56
57    #[serde(rename = "eth_chainId", with = "empty_params")]
58    EthChainId(()),
59
60    #[serde(rename = "eth_networkId", alias = "net_version", with = "empty_params")]
61    EthNetworkId(()),
62
63    #[serde(rename = "net_listening", with = "empty_params")]
64    NetListening(()),
65
66    /// Returns the number of hashes per second with which the node is mining.
67    #[serde(rename = "eth_hashrate", with = "empty_params")]
68    EthHashrate(()),
69
70    #[serde(rename = "eth_gasPrice", with = "empty_params")]
71    EthGasPrice(()),
72
73    #[serde(rename = "eth_baseFee", with = "empty_params")]
74    EthBaseFee(()),
75
76    #[serde(rename = "eth_maxPriorityFeePerGas", with = "empty_params")]
77    EthMaxPriorityFeePerGas(()),
78
79    #[serde(rename = "eth_blobBaseFee", with = "empty_params")]
80    EthBlobBaseFee(()),
81
82    #[serde(rename = "eth_accounts", alias = "eth_requestAccounts", with = "empty_params")]
83    EthAccounts(()),
84
85    #[serde(rename = "eth_blockNumber", with = "empty_params")]
86    EthBlockNumber(()),
87
88    /// Returns the client coinbase address.
89    #[serde(rename = "eth_coinbase", with = "empty_params")]
90    EthCoinbase(()),
91
92    #[serde(rename = "eth_getBalance")]
93    EthGetBalance(Address, Option<BlockId>),
94
95    #[serde(rename = "eth_getAccount")]
96    EthGetAccount(Address, Option<BlockId>),
97
98    #[serde(rename = "eth_getAccountInfo")]
99    EthGetAccountInfo(Address, Option<BlockId>),
100
101    #[serde(rename = "eth_getStorageAt")]
102    EthGetStorageAt(Address, U256, Option<BlockId>),
103
104    /// Returns storage values for multiple accounts and slots in a single call.
105    #[serde(rename = "eth_getStorageValues")]
106    EthGetStorageValues(HashMap<Address, Vec<B256>>, Option<BlockId>),
107
108    #[serde(rename = "eth_getBlockByHash")]
109    EthGetBlockByHash(B256, bool),
110
111    #[serde(rename = "eth_getHeaderByHash", with = "sequence")]
112    EthGetHeaderByHash(B256),
113
114    #[serde(rename = "eth_getBlockByNumber")]
115    EthGetBlockByNumber(
116        #[serde(deserialize_with = "lenient_block_number::lenient_block_number")] BlockNumber,
117        bool,
118    ),
119
120    #[serde(
121        rename = "eth_getHeaderByNumber",
122        deserialize_with = "lenient_block_number::lenient_block_number_seq"
123    )]
124    EthGetHeaderByNumber(BlockNumber),
125
126    #[serde(rename = "eth_getBlockAccessList", with = "sequence")]
127    EthGetBlockAccessList(BlockId),
128
129    #[serde(rename = "eth_getBlockAccessListByBlockHash", with = "sequence")]
130    EthGetBlockAccessListByBlockHash(B256),
131
132    #[serde(
133        rename = "eth_getBlockAccessListByBlockNumber",
134        deserialize_with = "lenient_block_number::lenient_block_number_seq"
135    )]
136    EthGetBlockAccessListByBlockNumber(BlockNumber),
137
138    #[serde(rename = "eth_getBlockAccessListRaw", with = "sequence")]
139    EthGetBlockAccessListRaw(BlockId),
140
141    #[serde(rename = "eth_getTransactionCount")]
142    EthGetTransactionCount(Address, Option<BlockId>),
143
144    #[serde(rename = "eth_getBlockTransactionCountByHash", with = "sequence")]
145    EthGetTransactionCountByHash(B256),
146
147    #[serde(
148        rename = "eth_getBlockTransactionCountByNumber",
149        deserialize_with = "lenient_block_number::lenient_block_number_seq"
150    )]
151    EthGetTransactionCountByNumber(BlockNumber),
152
153    #[serde(rename = "eth_getUncleCountByBlockHash", with = "sequence")]
154    EthGetUnclesCountByHash(B256),
155
156    #[serde(
157        rename = "eth_getUncleCountByBlockNumber",
158        deserialize_with = "lenient_block_number::lenient_block_number_seq"
159    )]
160    EthGetUnclesCountByNumber(BlockNumber),
161
162    #[serde(rename = "eth_getCode")]
163    EthGetCodeAt(Address, Option<BlockId>),
164
165    /// Returns the account and storage values of the specified account including the Merkle-proof.
166    /// This call can be used to verify that the data you are pulling from is not tampered with.
167    #[serde(rename = "eth_getProof")]
168    EthGetProof(Address, Vec<B256>, Option<BlockId>),
169
170    /// The sign method calculates an Ethereum specific signature with:
171    #[serde(rename = "eth_sign")]
172    EthSign(Address, Bytes),
173
174    /// The sign method calculates an Ethereum specific signature, equivalent to eth_sign:
175    /// <https://docs.metamask.io/wallet/reference/personal_sign/>
176    #[serde(rename = "personal_sign")]
177    PersonalSign(Bytes, Address),
178
179    #[serde(rename = "eth_signTransaction", with = "sequence")]
180    EthSignTransaction(Box<WithOtherFields<TransactionRequest>>),
181
182    /// Signs data via [EIP-712](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-712.md).
183    #[serde(rename = "eth_signTypedData")]
184    EthSignTypedData(Address, serde_json::Value),
185
186    /// Signs data via [EIP-712](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-712.md).
187    #[serde(rename = "eth_signTypedData_v3")]
188    EthSignTypedDataV3(Address, serde_json::Value),
189
190    /// Signs data via [EIP-712](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-712.md), and includes full support of arrays and recursive data structures.
191    #[serde(rename = "eth_signTypedData_v4")]
192    EthSignTypedDataV4(Address, alloy_dyn_abi::TypedData),
193
194    #[serde(rename = "eth_sendTransaction", with = "sequence")]
195    EthSendTransaction(Box<WithOtherFields<TransactionRequest>>),
196
197    #[serde(rename = "eth_resend")]
198    EthResend(Box<WithOtherFields<TransactionRequest>>, Option<U256>, Option<U64>),
199
200    #[serde(rename = "eth_sendTransactionSync", with = "sequence")]
201    EthSendTransactionSync(Box<WithOtherFields<TransactionRequest>>),
202
203    #[serde(rename = "eth_sendRawTransaction", with = "sequence")]
204    EthSendRawTransaction(Bytes),
205
206    #[serde(rename = "eth_sendRawTransactionSync")]
207    EthSendRawTransactionSync(Bytes, #[serde(default)] Option<u64>),
208
209    #[serde(rename = "eth_sendRawTransactionConditional")]
210    EthSendRawTransactionConditional(Bytes, TransactionConditional),
211
212    /// Signs a raw Tempo transaction as the node's fee payer (sponsor) without broadcasting it.
213    #[serde(rename = "eth_signRawTransaction", with = "sequence")]
214    EthSignRawTransaction(Bytes),
215
216    #[serde(rename = "anvil_classifyTransaction", with = "sequence")]
217    AnvilClassifyTransaction(Bytes),
218
219    #[serde(rename = "eth_call")]
220    EthCall(
221        WithOtherFields<TransactionRequest>,
222        #[serde(default)] Option<BlockId>,
223        #[serde(default)] Option<StateOverride>,
224        #[serde(default)] Option<Box<BlockOverrides>>,
225    ),
226
227    #[serde(rename = "eth_callMany")]
228    EthCallMany(
229        Vec<Bundle<WithOtherFields<TransactionRequest>>>,
230        #[serde(default)] Option<StateContext>,
231        #[serde(default)] Option<StateOverride>,
232    ),
233
234    #[serde(rename = "eth_callBundle", with = "sequence")]
235    EthCallBundle(EthCallBundle),
236
237    #[serde(rename = "eth_simulateV1")]
238    EthSimulateV1(
239        SimulatePayload<WithOtherFields<TransactionRequest>>,
240        #[serde(default)] Option<BlockId>,
241    ),
242
243    #[serde(rename = "eth_createAccessList")]
244    EthCreateAccessList(
245        WithOtherFields<TransactionRequest>,
246        #[serde(default)] Option<BlockId>,
247        #[serde(default)] Option<StateOverride>,
248    ),
249
250    #[serde(rename = "eth_estimateGas")]
251    EthEstimateGas(
252        WithOtherFields<TransactionRequest>,
253        #[serde(default)] Option<BlockId>,
254        #[serde(default)] Option<StateOverride>,
255        #[serde(default)] Option<Box<BlockOverrides>>,
256    ),
257
258    #[serde(rename = "eth_fillTransaction", with = "sequence")]
259    EthFillTransaction(WithOtherFields<TransactionRequest>),
260
261    #[serde(rename = "eth_getTransactionByHash", with = "sequence")]
262    EthGetTransactionByHash(TxHash),
263
264    #[serde(rename = "eth_pendingTransactions", with = "empty_params")]
265    EthPendingTransactions(()),
266
267    /// Returns the blob for a given blob versioned hash.
268    #[serde(rename = "anvil_getBlobByHash", with = "sequence")]
269    GetBlobByHash(B256),
270
271    /// Returns the blobs for a given transaction hash.
272    #[serde(rename = "anvil_getBlobsByTransactionHash", with = "sequence")]
273    GetBlobByTransactionHash(TxHash),
274
275    /// Returns the genesis time for the chain
276    #[serde(rename = "anvil_getGenesisTime", with = "empty_params")]
277    GetGenesisTime(()),
278
279    /// Returns the UNIX wall time in milliseconds when the current head was installed.
280    #[serde(rename = "anvil_getLastBlockWallTime", with = "empty_params")]
281    GetLastBlockWallTime(()),
282
283    #[serde(rename = "eth_getTransactionByBlockHashAndIndex")]
284    EthGetTransactionByBlockHashAndIndex(B256, Index),
285
286    #[serde(rename = "eth_getTransactionByBlockNumberAndIndex")]
287    EthGetTransactionByBlockNumberAndIndex(BlockNumber, Index),
288
289    #[serde(rename = "eth_getRawTransactionByHash", with = "sequence")]
290    EthGetRawTransactionByHash(TxHash),
291
292    #[serde(rename = "eth_getRawTransactionByBlockHashAndIndex")]
293    EthGetRawTransactionByBlockHashAndIndex(B256, Index),
294
295    #[serde(rename = "eth_getRawTransactionByBlockNumberAndIndex")]
296    EthGetRawTransactionByBlockNumberAndIndex(BlockNumber, Index),
297
298    #[serde(rename = "eth_getTransactionReceipt", with = "sequence")]
299    EthGetTransactionReceipt(B256),
300
301    #[serde(rename = "eth_getBlockReceipts", with = "sequence")]
302    EthGetBlockReceipts(BlockId),
303
304    #[serde(rename = "eth_getUncleByBlockHashAndIndex")]
305    EthGetUncleByBlockHashAndIndex(B256, Index),
306
307    #[serde(rename = "eth_getUncleByBlockNumberAndIndex")]
308    EthGetUncleByBlockNumberAndIndex(
309        #[serde(deserialize_with = "lenient_block_number::lenient_block_number")] BlockNumber,
310        Index,
311    ),
312
313    #[serde(rename = "eth_getLogs", with = "sequence")]
314    EthGetLogs(Filter),
315
316    /// Creates a filter object, based on filter options, to notify when the state changes (logs).
317    #[serde(rename = "eth_newFilter", with = "sequence")]
318    EthNewFilter(Filter),
319
320    /// Polling method for a filter, which returns an array of logs which occurred since last poll.
321    #[serde(rename = "eth_getFilterChanges", with = "sequence")]
322    EthGetFilterChanges(String),
323
324    /// Creates a filter in the node, to notify when a new block arrives.
325    /// To check if the state has changed, call `eth_getFilterChanges`.
326    #[serde(rename = "eth_newBlockFilter", with = "empty_params")]
327    EthNewBlockFilter(()),
328
329    /// Creates a filter in the node, to notify when new pending transactions arrive.
330    /// To check if the state has changed, call `eth_getFilterChanges`.
331    #[serde(rename = "eth_newPendingTransactionFilter", with = "optional_sequence")]
332    EthNewPendingTransactionFilter(Option<bool>),
333
334    /// Returns an array of all logs matching filter with given id.
335    #[serde(rename = "eth_getFilterLogs", with = "sequence")]
336    EthGetFilterLogs(String),
337
338    /// Removes the filter, returns true if the filter was installed
339    #[serde(rename = "eth_uninstallFilter", with = "sequence")]
340    EthUninstallFilter(String),
341
342    #[serde(rename = "eth_getWork", with = "empty_params")]
343    EthGetWork(()),
344
345    #[serde(rename = "eth_submitWork")]
346    EthSubmitWork(B64, B256, B256),
347
348    #[serde(rename = "eth_submitHashrate")]
349    EthSubmitHashRate(U256, B256),
350
351    #[serde(rename = "eth_feeHistory")]
352    EthFeeHistory(
353        #[serde(deserialize_with = "deserialize_number")] U256,
354        BlockNumber,
355        #[serde(default)] Vec<f64>,
356    ),
357
358    #[serde(rename = "eth_syncing", with = "empty_params")]
359    EthSyncing(()),
360
361    #[serde(rename = "eth_config", with = "empty_params")]
362    EthConfig(()),
363
364    /// geth's `debug_getRawTransaction`  endpoint
365    #[serde(rename = "debug_getRawTransaction", with = "sequence")]
366    DebugGetRawTransaction(TxHash),
367
368    /// reth's `debug_getRawReceipts` endpoint.
369    #[serde(rename = "debug_getRawReceipts", with = "sequence")]
370    DebugGetRawReceipts(BlockId),
371
372    /// reth's `debug_getRawTransactions` endpoint.
373    #[serde(rename = "debug_getRawTransactions", with = "sequence")]
374    DebugGetRawTransactions(BlockId),
375
376    /// geth's `debug_getRawHeader` endpoint.
377    #[serde(rename = "debug_getRawHeader", with = "sequence")]
378    DebugGetRawHeader(BlockId),
379
380    /// geth's `debug_getRawBlock` endpoint.
381    #[serde(rename = "debug_getRawBlock", with = "sequence")]
382    DebugGetRawBlock(BlockId),
383
384    /// geth's `debug_clearTxpool` endpoint
385    #[serde(rename = "debug_clearTxpool", with = "empty_params")]
386    DebugClearTxpool(()),
387
388    /// geth's `debug_traceTransaction`  endpoint
389    #[serde(rename = "debug_traceTransaction")]
390    DebugTraceTransaction(B256, #[serde(default)] GethDebugTracingOptions),
391
392    /// geth's `debug_traceCall`  endpoint
393    #[serde(rename = "debug_traceCall")]
394    DebugTraceCall(
395        WithOtherFields<TransactionRequest>,
396        #[serde(default)] Option<BlockId>,
397        #[serde(default)] GethDebugTracingCallOptions,
398    ),
399
400    /// reth's `debug_codeByHash` endpoint
401    #[serde(rename = "debug_codeByHash")]
402    DebugCodeByHash(B256, #[serde(default)] Option<BlockId>),
403
404    /// reth's `debug_dbGet` endpoint
405    #[serde(rename = "debug_dbGet")]
406    DebugDbGet(String),
407
408    /// reth's `debug_getModifiedAccountsByNumber` endpoint.
409    #[serde(rename = "debug_getModifiedAccountsByNumber")]
410    DebugGetModifiedAccountsByNumber(u64, u64),
411
412    /// reth's `debug_freeOSMemory` endpoint.
413    #[serde(rename = "debug_freeOSMemory", with = "empty_params")]
414    DebugFreeOsMemory(()),
415
416    /// reth's `debug_accountInfoAt` endpoint.
417    #[serde(rename = "debug_accountInfoAt")]
418    DebugAccountInfoAt(BlockId, Index, Address),
419
420    /// reth's `debug_executionWitness` endpoint.
421    #[serde(rename = "debug_executionWitness", with = "sequence")]
422    DebugExecutionWitness(BlockNumber),
423
424    /// geth's `debug_traceBlock` endpoint.
425    #[serde(rename = "debug_traceBlock")]
426    DebugTraceBlock(Bytes, #[serde(default)] GethDebugTracingOptions),
427
428    /// geth's `debug_traceBlockByHash` endpoint
429    #[serde(rename = "debug_traceBlockByHash")]
430    DebugTraceBlockByHash(B256, #[serde(default)] GethDebugTracingOptions),
431
432    /// geth's `debug_traceBlockByNumber` endpoint
433    #[serde(rename = "debug_traceBlockByNumber")]
434    DebugTraceBlockByNumber(BlockNumber, #[serde(default)] GethDebugTracingOptions),
435
436    /// Trace call endpoint for parity's `trace_call`.
437    #[serde(rename = "trace_call")]
438    TraceCall(
439        WithOtherFields<TransactionRequest>,
440        #[serde(default)] HashSet<TraceType>,
441        #[serde(default)] Option<BlockId>,
442    ),
443
444    /// Trace transaction endpoint for parity's `trace_transaction`
445    #[serde(rename = "trace_transaction", with = "sequence")]
446    TraceTransaction(B256),
447
448    /// Trace transaction endpoint for parity's `trace_block`
449    #[serde(
450        rename = "trace_block",
451        deserialize_with = "lenient_block_number::lenient_block_number_seq"
452    )]
453    TraceBlock(BlockNumber),
454
455    // Return filtered traces over blocks
456    #[serde(rename = "trace_filter", with = "sequence")]
457    TraceFilter(TraceFilter),
458
459    /// Trace get endpoint for parity's `trace_get`.
460    #[serde(rename = "trace_get")]
461    TraceGet(B256, Vec<Index>),
462
463    /// Trace transaction endpoint for parity's `trace_replayBlockTransactions`
464    #[serde(rename = "trace_replayBlockTransactions")]
465    TraceReplayBlockTransactions(
466        #[serde(deserialize_with = "lenient_block_number::lenient_block_number")] BlockNumber,
467        HashSet<TraceType>,
468    ),
469
470    /// Trace transaction endpoint for parity's `trace_replayTransaction`.
471    #[serde(rename = "trace_replayTransaction")]
472    TraceReplayTransaction(B256, HashSet<TraceType>),
473
474    /// Opcode gas trace endpoint for reth's `trace_transactionOpcodeGas`.
475    #[serde(rename = "trace_transactionOpcodeGas", with = "sequence")]
476    TraceTransactionOpcodeGas(B256),
477
478    /// Opcode gas trace endpoint for reth's `trace_blockOpcodeGas`.
479    #[serde(rename = "trace_blockOpcodeGas", with = "sequence")]
480    TraceBlockOpcodeGas(BlockId),
481
482    /// Trace raw transaction endpoint for parity's `trace_rawTransaction`.
483    #[serde(rename = "trace_rawTransaction")]
484    TraceRawTransaction(Bytes, HashSet<TraceType>, #[serde(default)] Option<BlockId>),
485
486    /// Trace call list endpoint for parity's `trace_callMany`.
487    #[serde(rename = "trace_callMany")]
488    TraceCallMany(
489        Vec<(WithOtherFields<TransactionRequest>, HashSet<TraceType>)>,
490        #[serde(default)] Option<BlockId>,
491    ),
492
493    // Custom endpoints, they're not extracted to a separate type out of serde convenience
494    /// send transactions impersonating specific account and contract addresses.
495    #[serde(
496        rename = "anvil_impersonateAccount",
497        alias = "hardhat_impersonateAccount",
498        with = "sequence"
499    )]
500    ImpersonateAccount(Address),
501    /// Stops impersonating an account if previously set with `anvil_impersonateAccount`
502    #[serde(
503        rename = "anvil_stopImpersonatingAccount",
504        alias = "hardhat_stopImpersonatingAccount",
505        with = "sequence"
506    )]
507    StopImpersonatingAccount(Address),
508    /// Will make every account impersonated
509    #[serde(
510        rename = "anvil_autoImpersonateAccount",
511        alias = "hardhat_autoImpersonateAccount",
512        with = "sequence"
513    )]
514    AutoImpersonateAccount(bool),
515
516    /// Registers a signature/address pair for faking `ecrecover` results
517    #[serde(rename = "anvil_impersonateSignature", with = "sequence")]
518    ImpersonateSignature(Bytes, Address),
519
520    /// Returns true if automatic mining is enabled, and false.
521    #[serde(rename = "anvil_getAutomine", alias = "hardhat_getAutomine", with = "empty_params")]
522    GetAutoMine(()),
523    /// Mines a series of blocks
524    #[serde(rename = "anvil_mine", alias = "hardhat_mine")]
525    Mine(
526        /// Number of blocks to mine, if not set `1` block is mined
527        #[serde(default, deserialize_with = "deserialize_number_opt")]
528        Option<U256>,
529        /// The time interval between each block in seconds, defaults to `1` seconds
530        /// The interval is applied only to blocks mined in the given method invocation, not to
531        /// blocks mined afterwards. Set this to `0` to instantly mine _all_ blocks
532        #[serde(default, deserialize_with = "deserialize_number_opt")]
533        Option<U256>,
534    ),
535
536    /// Enables or disables, based on the single boolean argument, the automatic mining of new
537    /// blocks with each new transaction submitted to the network.
538    #[serde(rename = "anvil_setAutomine", alias = "evm_setAutomine", with = "sequence")]
539    SetAutomine(bool),
540
541    /// Sets the mining behavior to interval with the given interval (seconds)
542    #[serde(
543        rename = "anvil_setIntervalMining",
544        alias = "evm_setIntervalMining",
545        deserialize_with = "deserialize_u64_seq"
546    )]
547    SetIntervalMining(u64),
548
549    /// Gets the current mining behavior
550    #[serde(rename = "anvil_getIntervalMining", with = "empty_params")]
551    GetIntervalMining(()),
552
553    /// Removes transactions from the pool
554    #[serde(rename = "anvil_dropTransaction", alias = "hardhat_dropTransaction", with = "sequence")]
555    DropTransaction(B256),
556
557    /// Removes transactions from the pool
558    #[serde(
559        rename = "anvil_dropAllTransactions",
560        alias = "hardhat_dropAllTransactions",
561        with = "empty_params"
562    )]
563    DropAllTransactions(),
564
565    /// Reset the fork to a fresh forked state, and optionally update the fork config
566    #[serde(rename = "anvil_reset", alias = "hardhat_reset")]
567    Reset(#[serde(default)] Option<Params<Option<Forking>>>),
568
569    /// Sets the backend rpc url
570    #[serde(rename = "anvil_setRpcUrl", with = "sequence")]
571    SetRpcUrl(String),
572
573    /// Modifies the balance of an account.
574    #[serde(
575        rename = "anvil_setBalance",
576        alias = "hardhat_setBalance",
577        alias = "tenderly_setBalance"
578    )]
579    SetBalance(Address, #[serde(deserialize_with = "deserialize_number")] U256),
580
581    /// Increases the balance of an account.
582    #[serde(
583        rename = "anvil_addBalance",
584        alias = "hardhat_addBalance",
585        alias = "tenderly_addBalance"
586    )]
587    AddBalance(Address, #[serde(deserialize_with = "deserialize_number")] U256),
588
589    /// Modifies the ERC20 balance of an account.
590    #[serde(
591        rename = "anvil_dealERC20",
592        alias = "hardhat_dealERC20",
593        alias = "anvil_setERC20Balance"
594    )]
595    DealERC20(Address, Address, #[serde(deserialize_with = "deserialize_number")] U256),
596
597    /// Modifies the TIP-20 balance of an account.
598    #[serde(rename = "anvil_dealTIP20")]
599    DealTIP20(Address, Address, #[serde(deserialize_with = "deserialize_number")] U256),
600
601    /// Sets the ERC20 allowance for a spender
602    #[serde(rename = "anvil_setERC20Allowance")]
603    SetERC20Allowance(
604        Address,
605        Address,
606        Address,
607        #[serde(deserialize_with = "deserialize_number")] U256,
608    ),
609
610    /// Sets the code of a contract
611    #[serde(rename = "anvil_setCode", alias = "hardhat_setCode")]
612    SetCode(Address, Bytes),
613
614    /// Sets the nonce of an address
615    #[serde(rename = "anvil_setNonce", alias = "hardhat_setNonce", alias = "evm_setAccountNonce")]
616    SetNonce(Address, #[serde(deserialize_with = "deserialize_number")] U256),
617
618    /// Writes a single slot of the account's storage
619    #[serde(rename = "anvil_setStorageAt", alias = "hardhat_setStorageAt")]
620    SetStorageAt(
621        Address,
622        /// slot
623        U256,
624        /// value
625        B256,
626    ),
627
628    /// Sets the coinbase address
629    #[serde(rename = "anvil_setCoinbase", alias = "hardhat_setCoinbase", with = "sequence")]
630    SetCoinbase(Address),
631
632    /// Sets the `prevrandao` value of the next block
633    #[serde(rename = "anvil_setNextBlockPrevRandao", with = "sequence")]
634    SetNextBlockPrevRandao(B256),
635
636    /// Sets the chain id
637    #[serde(rename = "anvil_setChainId", deserialize_with = "deserialize_u64_seq")]
638    SetChainId(u64),
639
640    /// Enable or disable logging
641    #[serde(
642        rename = "anvil_setLoggingEnabled",
643        alias = "hardhat_setLoggingEnabled",
644        with = "sequence"
645    )]
646    SetLogging(bool),
647
648    /// Set the minimum gas price for the node
649    #[serde(
650        rename = "anvil_setMinGasPrice",
651        alias = "hardhat_setMinGasPrice",
652        deserialize_with = "deserialize_number_seq"
653    )]
654    SetMinGasPrice(U256),
655
656    /// Sets the base fee of the next block
657    #[serde(
658        rename = "anvil_setNextBlockBaseFeePerGas",
659        alias = "hardhat_setNextBlockBaseFeePerGas",
660        deserialize_with = "deserialize_number_seq"
661    )]
662    SetNextBlockBaseFeePerGas(U256),
663
664    /// Sets the specific timestamp
665    /// Accepts timestamp (Unix epoch) with millisecond precision and returns the number of seconds
666    /// between the given timestamp and the current time.
667    #[serde(
668        rename = "anvil_setTime",
669        alias = "evm_setTime",
670        deserialize_with = "deserialize_number_seq"
671    )]
672    EvmSetTime(U256),
673
674    /// Serializes the current state (including contracts code, contract's storage, accounts
675    /// properties, etc.) into a saveable data blob
676    #[serde(rename = "anvil_dumpState", alias = "hardhat_dumpState")]
677    DumpState(#[serde(default)] Option<Params<Option<bool>>>),
678
679    /// Adds state previously dumped with `DumpState` to the current chain
680    #[serde(rename = "anvil_loadState", alias = "hardhat_loadState", with = "sequence")]
681    LoadState(Bytes),
682
683    /// Retrieves the Anvil node configuration params
684    #[serde(rename = "anvil_nodeInfo", with = "empty_params")]
685    NodeInfo(()),
686
687    /// Retrieves the Anvil node metadata.
688    #[serde(rename = "anvil_metadata", alias = "hardhat_metadata", with = "empty_params")]
689    AnvilMetadata(()),
690
691    // Ganache compatible calls
692    /// Snapshot the state of the blockchain at the current block.
693    ///
694    /// Ref <https://github.com/trufflesuite/ganache/blob/ef1858d5d6f27e4baeb75cccd57fb3dc77a45ae8/src/chains/ethereum/ethereum/RPC-METHODS.md#evm_snapshot>
695    #[serde(rename = "anvil_snapshot", alias = "evm_snapshot", with = "empty_params")]
696    EvmSnapshot(()),
697
698    /// Revert the state of the blockchain to a previous snapshot.
699    /// Takes a single parameter, which is the snapshot id to revert to.
700    ///
701    /// Ref <https://github.com/trufflesuite/ganache/blob/ef1858d5d6f27e4baeb75cccd57fb3dc77a45ae8/src/chains/ethereum/ethereum/RPC-METHODS.md#evm_revert>
702    #[serde(
703        rename = "anvil_revert",
704        alias = "evm_revert",
705        deserialize_with = "deserialize_number_seq"
706    )]
707    EvmRevert(U256),
708
709    /// Jump forward in time by the given amount of time, in seconds.
710    #[serde(
711        rename = "anvil_increaseTime",
712        alias = "evm_increaseTime",
713        deserialize_with = "deserialize_number_seq"
714    )]
715    EvmIncreaseTime(U256),
716
717    /// Similar to `evm_increaseTime` but takes the exact timestamp that you want in the next block
718    #[serde(
719        rename = "anvil_setNextBlockTimestamp",
720        alias = "evm_setNextBlockTimestamp",
721        deserialize_with = "deserialize_number_seq"
722    )]
723    EvmSetNextBlockTimeStamp(U256),
724
725    /// Set the exact gas limit that you want in the next block
726    #[serde(
727        rename = "anvil_setBlockGasLimit",
728        alias = "evm_setBlockGasLimit",
729        deserialize_with = "deserialize_number_seq"
730    )]
731    EvmSetBlockGasLimit(U256),
732
733    /// Similar to `evm_increaseTime` but takes sets a block timestamp `interval`.
734    ///
735    /// The timestamp of the next block will be computed as `lastBlock_timestamp + interval`.
736    #[serde(rename = "anvil_setBlockTimestampInterval", deserialize_with = "deserialize_u64_seq")]
737    EvmSetBlockTimeStampInterval(u64),
738
739    /// Removes a `anvil_setBlockTimestampInterval` if it exists
740    #[serde(rename = "anvil_removeBlockTimestampInterval", with = "empty_params")]
741    EvmRemoveBlockTimeStampInterval(()),
742
743    /// Mine a single block
744    #[serde(rename = "evm_mine")]
745    EvmMine(#[serde(default)] Option<Params<Option<MineOptions>>>),
746
747    /// Mine a single block and return detailed data
748    ///
749    /// This behaves exactly as `EvmMine` but returns different output, for compatibility reasons
750    /// this is a separate call since `evm_mine` is not an anvil original.
751    #[serde(rename = "anvil_mine_detailed", alias = "evm_mine_detailed")]
752    EvmMineDetailed(#[serde(default)] Option<Params<Option<MineOptions>>>),
753
754    /// Execute a transaction regardless of signature status
755    #[serde(rename = "eth_sendUnsignedTransaction", with = "sequence")]
756    EthSendUnsignedTransaction(Box<WithOtherFields<TransactionRequest>>),
757
758    /// Returns the number of transactions currently pending for inclusion in the next block(s), as
759    /// well as the ones that are being scheduled for future execution only.
760    /// Ref: <https://geth.ethereum.org/docs/rpc/ns-txpool#txpool_status>
761    #[serde(rename = "txpool_status", with = "empty_params")]
762    TxPoolStatus(()),
763
764    /// Returns a summary of all the transactions currently pending for inclusion in the next
765    /// block(s), as well as the ones that are being scheduled for future execution only.
766    /// Ref: <https://geth.ethereum.org/docs/rpc/ns-txpool#txpool_inspect>
767    #[serde(rename = "txpool_inspect", with = "empty_params")]
768    TxPoolInspect(()),
769
770    /// Returns the details of all transactions currently pending for inclusion in the next
771    /// block(s), as well as the ones that are being scheduled for future execution only.
772    /// Ref: <https://geth.ethereum.org/docs/rpc/ns-txpool#txpool_content>
773    #[serde(rename = "txpool_content", with = "empty_params")]
774    TxPoolContent(()),
775
776    /// Returns the details of all transactions currently pending for inclusion in the next
777    /// block(s), as well as the ones that are being scheduled for future execution only, filtered
778    /// by sender.
779    /// Ref: <https://geth.ethereum.org/docs/rpc/ns-txpool#txpool_contentFrom>
780    #[serde(rename = "txpool_contentFrom", with = "sequence")]
781    TxPoolContentFrom(Address),
782
783    /// Otterscan's `ots_getApiLevel` endpoint
784    /// Otterscan currently requires this endpoint, even though it's not part of the ots_*
785    /// <https://github.com/otterscan/otterscan/blob/071d8c55202badf01804f6f8d53ef9311d4a9e47/src/useProvider.ts#L71>
786    /// Related upstream issue: <https://github.com/otterscan/otterscan/issues/1081>
787    #[serde(rename = "erigon_getHeaderByNumber")]
788    ErigonGetHeaderByNumber(
789        #[serde(deserialize_with = "lenient_block_number::lenient_block_number_seq")] BlockNumber,
790    ),
791
792    /// Otterscan's `ots_getApiLevel` endpoint
793    /// Used as a simple API versioning scheme for the ots_* namespace
794    #[serde(rename = "ots_getApiLevel", with = "empty_params")]
795    OtsGetApiLevel(()),
796
797    /// Otterscan's `ots_getInternalOperations` endpoint
798    /// Traces internal ETH transfers, contracts creation (CREATE/CREATE2) and self-destructs for a
799    /// certain transaction.
800    #[serde(rename = "ots_getInternalOperations", with = "sequence")]
801    OtsGetInternalOperations(B256),
802
803    /// Otterscan's `ots_hasCode` endpoint
804    /// Check if an ETH address contains code at a certain block number.
805    #[serde(rename = "ots_hasCode")]
806    OtsHasCode(
807        Address,
808        #[serde(deserialize_with = "lenient_block_number::lenient_block_number", default)]
809        BlockNumber,
810    ),
811
812    /// Otterscan's `ots_traceTransaction` endpoint
813    /// Trace a transaction and generate a trace call tree.
814    #[serde(rename = "ots_traceTransaction", with = "sequence")]
815    OtsTraceTransaction(B256),
816
817    /// Otterscan's `ots_getTransactionError` endpoint
818    /// Given a transaction hash, returns its raw revert reason.
819    #[serde(rename = "ots_getTransactionError", with = "sequence")]
820    OtsGetTransactionError(B256),
821
822    /// Otterscan's `ots_getBlockDetails` endpoint
823    /// Given a block number, return its data. Similar to the standard eth_getBlockByNumber/Hash
824    /// method, but can be optimized by excluding unnecessary data such as transactions and
825    /// logBloom
826    #[serde(rename = "ots_getBlockDetails")]
827    OtsGetBlockDetails(
828        #[serde(deserialize_with = "lenient_block_number::lenient_block_number_seq", default)]
829        BlockNumber,
830    ),
831
832    /// Otterscan's `ots_getBlockDetails` endpoint
833    /// Same as `ots_getBlockDetails`, but receiving a block hash instead of number
834    #[serde(rename = "ots_getBlockDetailsByHash", with = "sequence")]
835    OtsGetBlockDetailsByHash(B256),
836
837    /// Otterscan's `ots_getBlockTransactions` endpoint
838    /// Gets paginated transaction data for a certain block. Return data is similar to
839    /// eth_getBlockBy* + eth_getTransactionReceipt.
840    #[serde(rename = "ots_getBlockTransactions")]
841    OtsGetBlockTransactions(u64, usize, usize),
842
843    /// Otterscan's `ots_searchTransactionsBefore` endpoint
844    /// Address history navigation. searches backwards from certain point in time.
845    #[serde(rename = "ots_searchTransactionsBefore")]
846    OtsSearchTransactionsBefore(Address, u64, usize),
847
848    /// Otterscan's `ots_searchTransactionsAfter` endpoint
849    /// Address history navigation. searches forward from certain point in time.
850    #[serde(rename = "ots_searchTransactionsAfter")]
851    OtsSearchTransactionsAfter(Address, u64, usize),
852
853    /// Otterscan's `ots_getTransactionBySenderAndNonce` endpoint
854    /// Given a sender address and a nonce, returns the tx hash or null if not found. It returns
855    /// only the tx hash on success, you can use the standard eth_getTransactionByHash after that
856    /// to get the full transaction data.
857    #[serde(rename = "ots_getTransactionBySenderAndNonce")]
858    OtsGetTransactionBySenderAndNonce(
859        Address,
860        #[serde(deserialize_with = "deserialize_number")] U256,
861    ),
862
863    /// Returns the transaction by sender and nonce
864    /// Returns the full transaction data.
865    #[serde(rename = "eth_getTransactionBySenderAndNonce")]
866    EthGetTransactionBySenderAndNonce(
867        Address,
868        #[serde(deserialize_with = "deserialize_number")] U256,
869    ),
870
871    /// Otterscan's `ots_getTransactionBySenderAndNonce` endpoint
872    /// Given an ETH contract address, returns the tx hash and the direct address who created the
873    /// contract.
874    #[serde(rename = "ots_getContractCreator", with = "sequence")]
875    OtsGetContractCreator(Address),
876
877    /// Removes transactions from the pool by sender origin.
878    #[serde(rename = "anvil_removePoolTransactions", with = "sequence")]
879    RemovePoolTransactions(Address),
880
881    /// Reorg the chain
882    #[serde(rename = "anvil_reorg")]
883    Reorg(ReorgOptions),
884
885    /// Rollback the chain
886    #[serde(rename = "anvil_rollback", deserialize_with = "deserialize_u64_seq_opt")]
887    Rollback(Option<u64>),
888
889    /// Sets the fee token for a user (Tempo-only)
890    #[serde(rename = "anvil_setFeeToken")]
891    SetFeeToken(Address, Address),
892
893    /// Sets the fee token for a validator (Tempo-only)
894    #[serde(rename = "anvil_setValidatorFeeToken")]
895    SetValidatorFeeToken(Address, Address),
896
897    /// Mints FeeAMM liquidity for a token pair (Tempo-only)
898    #[serde(rename = "anvil_setFeeAmmLiquidity")]
899    SetFeeAmmLiquidity(
900        /// user_token
901        Address,
902        /// validator_token
903        Address,
904        /// amount
905        #[serde(deserialize_with = "deserialize_number")]
906        U256,
907    ),
908}
909
910/// Represents ethereum JSON-RPC API
911#[derive(Clone, Debug, PartialEq, Eq, serde::Deserialize)]
912#[serde(tag = "method", content = "params")]
913pub enum EthPubSub {
914    /// Subscribe to an eth subscription
915    #[serde(rename = "eth_subscribe")]
916    EthSubscribe(SubscriptionKind, #[serde(default)] Box<SubscriptionParams>),
917
918    /// Unsubscribe from an eth subscription
919    #[serde(rename = "eth_unsubscribe", with = "sequence")]
920    EthUnSubscribe(SubscriptionId),
921}
922
923/// Container type for either a request or a pub sub
924#[derive(Clone, Debug)]
925pub enum EthRpcCall {
926    Request(Box<EthRequest>),
927    PubSub(EthPubSub),
928}
929
930impl<'de> serde::Deserialize<'de> for EthRpcCall {
931    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
932    where
933        D: serde::Deserializer<'de>,
934    {
935        let value = serde_json::Value::deserialize(deserializer)?;
936        match value.get("method").and_then(serde_json::Value::as_str) {
937            Some("eth_subscribe" | "eth_unsubscribe") => serde_json::from_value(value)
938                .map(Self::PubSub)
939                .map_err(<D::Error as serde::de::Error>::custom),
940            _ => serde_json::from_value(value)
941                .map(Box::new)
942                .map(Self::Request)
943                .map_err(<D::Error as serde::de::Error>::custom),
944        }
945    }
946}
947
948#[cfg(test)]
949mod tests {
950    use super::*;
951
952    #[test]
953    fn test_web3_client_version() {
954        let s = r#"{"method": "web3_clientVersion", "params":[]}"#;
955        let value: serde_json::Value = serde_json::from_str(s).unwrap();
956        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
957    }
958
959    #[test]
960    fn test_web3_sha3() {
961        let s = r#"{"method": "web3_sha3", "params":["0x68656c6c6f20776f726c64"]}"#;
962        let value: serde_json::Value = serde_json::from_str(s).unwrap();
963        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
964    }
965
966    #[test]
967    fn unknown_rpc_call_preserves_method_error() {
968        let err = serde_json::from_str::<EthRpcCall>(r#"{"method":"no_such_method","params":[]}"#)
969            .unwrap_err();
970
971        assert!(err.to_string().contains("unknown variant"));
972    }
973
974    #[test]
975    fn test_eth_accounts() {
976        let s = r#"{"method": "eth_accounts", "params":[]}"#;
977        let value: serde_json::Value = serde_json::from_str(s).unwrap();
978        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
979    }
980
981    #[test]
982    fn test_eth_network_id() {
983        let s = r#"{"method": "eth_networkId", "params":[]}"#;
984        let value: serde_json::Value = serde_json::from_str(s).unwrap();
985        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
986    }
987
988    #[test]
989    fn test_eth_get_proof() {
990        let s = r#"{"method":"eth_getProof","params":["0x7F0d15C7FAae65896648C8273B6d7E43f58Fa842",["0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421"],"latest"]}"#;
991        let value: serde_json::Value = serde_json::from_str(s).unwrap();
992        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
993    }
994
995    #[test]
996    fn test_eth_chain_id() {
997        let s = r#"{"method": "eth_chainId", "params":[]}"#;
998        let value: serde_json::Value = serde_json::from_str(s).unwrap();
999        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1000    }
1001
1002    #[test]
1003    fn test_net_listening() {
1004        let s = r#"{"method": "net_listening", "params":[]}"#;
1005        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1006        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1007    }
1008
1009    #[test]
1010    fn test_eth_block_number() {
1011        let s = r#"{"method": "eth_blockNumber", "params":[]}"#;
1012        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1013        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1014    }
1015
1016    #[test]
1017    fn test_eth_pending_transactions() {
1018        let s = r#"{"method": "eth_pendingTransactions", "params":[]}"#;
1019        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1020        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1021    }
1022
1023    #[test]
1024    fn test_eth_create_access_list_with_state_override() {
1025        let s = r#"{"method":"eth_createAccessList","params":[{"to":"0x0000000000000000000000000000000000000001"},"latest",{"0x0000000000000000000000000000000000000001":{"code":"0x60005400"}}]}"#;
1026        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1027        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1028    }
1029
1030    #[test]
1031    fn test_eth_get_header_by_hash() {
1032        let s = r#"{"method": "eth_getHeaderByHash", "params":["0x12e65af7b09d4e08ec0a7786ee606b1b6b710d3f9c39f73d7e065527e0e839d3"]}"#;
1033        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1034        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1035    }
1036
1037    #[test]
1038    fn test_txpool_content_from() {
1039        let address = "0x7F0d15C7FAae65896648C8273B6d7E43f58Fa842";
1040        let s = format!(r#"{{"method": "txpool_contentFrom", "params":["{address}"]}}"#);
1041        let value: serde_json::Value = serde_json::from_str(&s).unwrap();
1042        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1043        match req {
1044            EthRequest::TxPoolContentFrom(from) => {
1045                assert_eq!(from, address.parse::<Address>().unwrap());
1046            }
1047            _ => unreachable!(),
1048        }
1049    }
1050
1051    #[test]
1052    fn test_eth_get_header_by_number() {
1053        let s = r#"{"method": "eth_getHeaderByNumber", "params":["latest"]}"#;
1054        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1055        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1056    }
1057
1058    #[test]
1059    fn test_eth_max_priority_fee() {
1060        let s = r#"{"method": "eth_maxPriorityFeePerGas", "params":[]}"#;
1061        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1062        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1063    }
1064
1065    #[test]
1066    fn test_eth_send_raw_transaction_sync() {
1067        let s = r#"{"method": "eth_sendRawTransactionSync", "params":["0xdeadbeef"]}"#;
1068        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1069        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1070        match req {
1071            EthRequest::EthSendRawTransactionSync(tx, timeout) => {
1072                assert_eq!(tx, Bytes::from_static(&[0xde, 0xad, 0xbe, 0xef]));
1073                assert_eq!(timeout, None);
1074            }
1075            _ => unreachable!(),
1076        }
1077
1078        let s = r#"{"method": "eth_sendRawTransactionSync", "params":["0xdeadbeef", null]}"#;
1079        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1080        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1081        match req {
1082            EthRequest::EthSendRawTransactionSync(tx, timeout) => {
1083                assert_eq!(tx, Bytes::from_static(&[0xde, 0xad, 0xbe, 0xef]));
1084                assert_eq!(timeout, None);
1085            }
1086            _ => unreachable!(),
1087        }
1088
1089        let s = r#"{"method": "eth_sendRawTransactionSync", "params":["0xdeadbeef", 1]}"#;
1090        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1091        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1092        match req {
1093            EthRequest::EthSendRawTransactionSync(tx, timeout) => {
1094                assert_eq!(tx, Bytes::from_static(&[0xde, 0xad, 0xbe, 0xef]));
1095                assert_eq!(timeout, Some(1));
1096            }
1097            _ => unreachable!(),
1098        }
1099    }
1100
1101    #[test]
1102    fn test_eth_base_fee() {
1103        let s = r#"{"method": "eth_baseFee", "params":[]}"#;
1104        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1105        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1106    }
1107
1108    #[test]
1109    fn test_eth_syncing() {
1110        let s = r#"{"method": "eth_syncing", "params":[]}"#;
1111        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1112        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1113    }
1114
1115    #[test]
1116    fn test_custom_impersonate_account() {
1117        let s = r#"{"method": "anvil_impersonateAccount", "params":
1118["0xd84de507f3fada7df80908082d3239466db55a71"]}"#;
1119        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1120        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1121    }
1122
1123    #[test]
1124    fn test_custom_stop_impersonate_account() {
1125        let s = r#"{"method": "anvil_stopImpersonatingAccount",  "params":
1126["0x364d6D0333432C3Ac016Ca832fb8594A8cE43Ca6"]}"#;
1127        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1128        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1129    }
1130
1131    #[test]
1132    fn test_custom_auto_impersonate_account() {
1133        let s = r#"{"method": "anvil_autoImpersonateAccount",  "params": [true]}"#;
1134        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1135        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1136    }
1137
1138    #[test]
1139    fn test_custom_get_automine() {
1140        let s = r#"{"method": "anvil_getAutomine", "params": []}"#;
1141        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1142        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1143    }
1144
1145    #[test]
1146    fn test_custom_get_last_block_wall_time() {
1147        let s = r#"{"method": "anvil_getLastBlockWallTime", "params": []}"#;
1148        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1149        assert!(matches!(
1150            serde_json::from_value::<EthRequest>(value).unwrap(),
1151            EthRequest::GetLastBlockWallTime(())
1152        ));
1153    }
1154
1155    #[test]
1156    fn test_custom_mine() {
1157        let s = r#"{"method": "anvil_mine", "params": []}"#;
1158        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1159        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1160        match req {
1161            EthRequest::Mine(num, time) => {
1162                assert!(num.is_none());
1163                assert!(time.is_none());
1164            }
1165            _ => unreachable!(),
1166        }
1167        let s = r#"{"method": "anvil_mine", "params":
1168["0xd84de507f3fada7df80908082d3239466db55a71"]}"#;
1169        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1170        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1171        match req {
1172            EthRequest::Mine(num, time) => {
1173                assert!(num.is_some());
1174                assert!(time.is_none());
1175            }
1176            _ => unreachable!(),
1177        }
1178        let s = r#"{"method": "anvil_mine", "params": ["0xd84de507f3fada7df80908082d3239466db55a71", "0xd84de507f3fada7df80908082d3239466db55a71"]}"#;
1179        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1180        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1181        match req {
1182            EthRequest::Mine(num, time) => {
1183                assert!(num.is_some());
1184                assert!(time.is_some());
1185            }
1186            _ => unreachable!(),
1187        }
1188    }
1189
1190    #[test]
1191    fn test_custom_auto_mine() {
1192        let s = r#"{"method": "anvil_setAutomine", "params": [false]}"#;
1193        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1194        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1195        let s = r#"{"method": "evm_setAutomine", "params": [false]}"#;
1196        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1197        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1198    }
1199
1200    #[test]
1201    fn test_custom_interval_mining() {
1202        let s = r#"{"method": "anvil_setIntervalMining", "params": [100]}"#;
1203        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1204        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1205        let s = r#"{"method": "evm_setIntervalMining", "params": [100]}"#;
1206        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1207        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1208    }
1209
1210    #[test]
1211    fn test_numeric_params_accept_hex_and_decimal_strings() {
1212        // Standard JSON-RPC clients (web3.js / ethers / viem) encode numeric params as hex
1213        // strings. These methods keep their internal `u64` types, but use a U64-aware
1214        // deserializer for RPC params.
1215        let parse = |s: &str| {
1216            let value: serde_json::Value = serde_json::from_str(s).unwrap();
1217            serde_json::from_value::<EthRequest>(value)
1218        };
1219
1220        match parse(r#"{"method": "anvil_setIntervalMining", "params": [100]}"#).unwrap() {
1221            EthRequest::SetIntervalMining(interval) => assert_eq!(interval, 100),
1222            req => panic!("unexpected request: {req:?}"),
1223        }
1224        match parse(r#"{"method": "anvil_setIntervalMining", "params": 100}"#).unwrap() {
1225            EthRequest::SetIntervalMining(interval) => assert_eq!(interval, 100),
1226            req => panic!("unexpected request: {req:?}"),
1227        }
1228        match parse(r#"{"method": "anvil_setIntervalMining", "params": ["0x64"]}"#).unwrap() {
1229            EthRequest::SetIntervalMining(interval) => assert_eq!(interval, 100),
1230            req => panic!("unexpected request: {req:?}"),
1231        }
1232        match parse(r#"{"method": "anvil_setIntervalMining", "params": "0x64"}"#).unwrap() {
1233            EthRequest::SetIntervalMining(interval) => assert_eq!(interval, 100),
1234            req => panic!("unexpected request: {req:?}"),
1235        }
1236        match parse(r#"{"method": "anvil_setIntervalMining", "params": ["100"]}"#).unwrap() {
1237            EthRequest::SetIntervalMining(interval) => assert_eq!(interval, 100),
1238            req => panic!("unexpected request: {req:?}"),
1239        }
1240        match parse(r#"{"method": "anvil_setIntervalMining", "params": "100"}"#).unwrap() {
1241            EthRequest::SetIntervalMining(interval) => assert_eq!(interval, 100),
1242            req => panic!("unexpected request: {req:?}"),
1243        }
1244        match parse(r#"{"method": "anvil_setChainId", "params": ["0x539"]}"#).unwrap() {
1245            EthRequest::SetChainId(chain_id) => assert_eq!(chain_id, 1337),
1246            req => panic!("unexpected request: {req:?}"),
1247        }
1248        match parse(r#"{"method": "anvil_setBlockTimestampInterval", "params": ["0xa"]}"#).unwrap()
1249        {
1250            EthRequest::EvmSetBlockTimeStampInterval(interval) => assert_eq!(interval, 10),
1251            req => panic!("unexpected request: {req:?}"),
1252        }
1253        match parse(r#"{"method": "anvil_rollback", "params": ["0x5"]}"#).unwrap() {
1254            EthRequest::Rollback(depth) => assert_eq!(depth, Some(5)),
1255            req => panic!("unexpected request: {req:?}"),
1256        }
1257        match parse(r#"{"method": "anvil_rollback", "params": []}"#).unwrap() {
1258            EthRequest::Rollback(depth) => assert_eq!(depth, None),
1259            req => panic!("unexpected request: {req:?}"),
1260        }
1261        match parse(r#"{"method": "anvil_rollback", "params": [null]}"#).unwrap() {
1262            EthRequest::Rollback(depth) => assert_eq!(depth, None),
1263            req => panic!("unexpected request: {req:?}"),
1264        }
1265
1266        assert!(
1267            parse(r#"{"method": "anvil_setIntervalMining", "params": ["0x10000000000000000"]}"#)
1268                .is_err()
1269        );
1270    }
1271
1272    #[test]
1273    fn test_custom_drop_tx() {
1274        let s = r#"{"method": "anvil_dropTransaction", "params":
1275["0x4a3b0fce2cb9707b0baa68640cf2fe858c8bb4121b2a8cb904ff369d38a560ff"]}"#;
1276        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1277        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1278    }
1279
1280    #[test]
1281    fn test_custom_reset() {
1282        let s = r#"{"method": "anvil_reset", "params": [{"forking": {"jsonRpcUrl": "https://ethereumpublicnode.com",
1283        "blockNumber": "18441649"
1284      }
1285    }]}"#;
1286        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1287        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1288        match req {
1289            EthRequest::Reset(forking) => {
1290                let forking = forking.and_then(|f| f.params);
1291                assert_eq!(
1292                    forking,
1293                    Some(Forking {
1294                        json_rpc_url: Some("https://ethereumpublicnode.com".into()),
1295                        block_number: Some(18441649)
1296                    })
1297                )
1298            }
1299            _ => unreachable!(),
1300        }
1301
1302        let s = r#"{"method": "anvil_reset", "params": [ { "forking": {
1303                "jsonRpcUrl": "https://eth-mainnet.alchemyapi.io/v2/<key>",
1304                "blockNumber": 11095000
1305        }}]}"#;
1306        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1307        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1308        match req {
1309            EthRequest::Reset(forking) => {
1310                let forking = forking.and_then(|f| f.params);
1311                assert_eq!(
1312                    forking,
1313                    Some(Forking {
1314                        json_rpc_url: Some(
1315                            "https://eth-mainnet.alchemyapi.io/v2/<key>".to_string()
1316                        ),
1317                        block_number: Some(11095000)
1318                    })
1319                )
1320            }
1321            _ => unreachable!(),
1322        }
1323
1324        let s = r#"{"method": "anvil_reset", "params": [ { "forking": {
1325                "jsonRpcUrl": "https://eth-mainnet.alchemyapi.io/v2/<key>"
1326        }}]}"#;
1327        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1328        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1329        match req {
1330            EthRequest::Reset(forking) => {
1331                let forking = forking.and_then(|f| f.params);
1332                assert_eq!(
1333                    forking,
1334                    Some(Forking {
1335                        json_rpc_url: Some(
1336                            "https://eth-mainnet.alchemyapi.io/v2/<key>".to_string()
1337                        ),
1338                        block_number: None
1339                    })
1340                )
1341            }
1342            _ => unreachable!(),
1343        }
1344
1345        let s = r#"{"method":"anvil_reset","params":[{"jsonRpcUrl": "http://localhost:8545", "blockNumber": 14000000}]}"#;
1346        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1347        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1348        match req {
1349            EthRequest::Reset(forking) => {
1350                let forking = forking.and_then(|f| f.params);
1351                assert_eq!(
1352                    forking,
1353                    Some(Forking {
1354                        json_rpc_url: Some("http://localhost:8545".to_string()),
1355                        block_number: Some(14000000)
1356                    })
1357                )
1358            }
1359            _ => unreachable!(),
1360        }
1361
1362        let s = r#"{"method":"anvil_reset","params":[{ "blockNumber": 14000000}]}"#;
1363        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1364        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1365        match req {
1366            EthRequest::Reset(forking) => {
1367                let forking = forking.and_then(|f| f.params);
1368                assert_eq!(
1369                    forking,
1370                    Some(Forking { json_rpc_url: None, block_number: Some(14000000) })
1371                )
1372            }
1373            _ => unreachable!(),
1374        }
1375
1376        let s = r#"{"method":"anvil_reset","params":[{ "blockNumber": "14000000"}]}"#;
1377        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1378        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1379        match req {
1380            EthRequest::Reset(forking) => {
1381                let forking = forking.and_then(|f| f.params);
1382                assert_eq!(
1383                    forking,
1384                    Some(Forking { json_rpc_url: None, block_number: Some(14000000) })
1385                )
1386            }
1387            _ => unreachable!(),
1388        }
1389
1390        let s = r#"{"method":"anvil_reset","params":[{"jsonRpcUrl": "http://localhost:8545"}]}"#;
1391        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1392        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1393        match req {
1394            EthRequest::Reset(forking) => {
1395                let forking = forking.and_then(|f| f.params);
1396                assert_eq!(
1397                    forking,
1398                    Some(Forking {
1399                        json_rpc_url: Some("http://localhost:8545".to_string()),
1400                        block_number: None
1401                    })
1402                )
1403            }
1404            _ => unreachable!(),
1405        }
1406
1407        let s = r#"{"method": "anvil_reset"}"#;
1408        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1409        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1410        match req {
1411            EthRequest::Reset(forking) => {
1412                assert!(forking.is_none())
1413            }
1414            _ => unreachable!(),
1415        }
1416    }
1417
1418    #[test]
1419    fn test_custom_set_balance() {
1420        let s = r#"{"method": "anvil_setBalance", "params":
1421["0xd84de507f3fada7df80908082d3239466db55a71", "0x0"]}"#;
1422        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1423        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1424
1425        let s = r#"{"method": "anvil_setBalance", "params":
1426["0xd84de507f3fada7df80908082d3239466db55a71", 1337]}"#;
1427        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1428        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1429    }
1430
1431    #[test]
1432    fn test_simulate_preserves_transaction_extension_fields() {
1433        let value = serde_json::json!({
1434            "method": "eth_simulateV1",
1435            "params": [{
1436                "blockStateCalls": [{
1437                    "calls": [{
1438                        "to": "0x0000000000000000000000000000000000000001",
1439                        "tempoExtension": "preserved"
1440                    }]
1441                }]
1442            }]
1443        });
1444
1445        let request = serde_json::from_value::<EthRequest>(value).unwrap();
1446        let EthRequest::EthSimulateV1(payload, _) = request else { panic!() };
1447        let transaction = &payload.block_state_calls[0].calls[0];
1448
1449        assert_eq!(transaction.other["tempoExtension"], serde_json::json!("preserved"));
1450    }
1451
1452    #[test]
1453    fn test_custom_set_code() {
1454        let s = r#"{"method": "anvil_setCode", "params":
1455["0xd84de507f3fada7df80908082d3239466db55a71", "0x0123456789abcdef"]}"#;
1456        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1457        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1458
1459        let s = r#"{"method": "anvil_setCode", "params":
1460["0xd84de507f3fada7df80908082d3239466db55a71", "0x"]}"#;
1461        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1462        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1463
1464        let s = r#"{"method": "anvil_setCode", "params":
1465["0xd84de507f3fada7df80908082d3239466db55a71", ""]}"#;
1466        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1467        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1468    }
1469
1470    #[test]
1471    fn test_custom_set_nonce() {
1472        let s = r#"{"method": "anvil_setNonce", "params":
1473["0xd84de507f3fada7df80908082d3239466db55a71", "0x0"]}"#;
1474        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1475        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1476        let s = r#"{"method":
1477"hardhat_setNonce", "params": ["0xd84de507f3fada7df80908082d3239466db55a71", "0x0"]}"#;
1478        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1479        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1480        let s = r#"{"method": "evm_setAccountNonce", "params":
1481["0xd84de507f3fada7df80908082d3239466db55a71", "0x0"]}"#;
1482        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1483        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1484    }
1485
1486    #[test]
1487    fn test_serde_custom_set_storage_at() {
1488        let s = r#"{"method": "anvil_setStorageAt", "params":
1489["0x295a70b2de5e3953354a6a8344e616ed314d7251", "0x0",
1490"0x0000000000000000000000000000000000000000000000000000000000003039"]}"#;
1491        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1492        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1493
1494        let s = r#"{"method": "hardhat_setStorageAt", "params":
1495["0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56",
1496"0xa6eef7e35abe7026729641147f7915573c7e97b47efa546f5f6e3230263bcb49",
1497"0x0000000000000000000000000000000000000000000000000000000000003039"]}"#;
1498        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1499        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1500    }
1501
1502    #[test]
1503    fn test_serde_custom_coinbase() {
1504        let s = r#"{"method": "anvil_setCoinbase", "params":
1505["0x295a70b2de5e3953354a6a8344e616ed314d7251"]}"#;
1506        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1507        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1508    }
1509
1510    #[test]
1511    fn test_serde_custom_set_next_block_prevrandao() {
1512        let s = r#"{"method": "anvil_setNextBlockPrevRandao", "params": ["0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"]}"#;
1513        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1514        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1515    }
1516
1517    #[test]
1518    fn test_serde_custom_logging() {
1519        let s = r#"{"method": "anvil_setLoggingEnabled", "params": [false]}"#;
1520        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1521        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1522    }
1523
1524    #[test]
1525    fn test_serde_custom_min_gas_price() {
1526        let s = r#"{"method": "anvil_setMinGasPrice", "params": ["0x0"]}"#;
1527        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1528        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1529    }
1530
1531    #[test]
1532    fn test_serde_custom_next_block_base_fee() {
1533        let s = r#"{"method": "anvil_setNextBlockBaseFeePerGas", "params": ["0x0"]}"#;
1534        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1535        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1536    }
1537
1538    #[test]
1539    fn test_serde_set_time() {
1540        let s = r#"{"method": "anvil_setTime", "params": ["0x0"]}"#;
1541        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1542        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1543
1544        let s = r#"{"method": "anvil_increaseTime", "params": 1}"#;
1545        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1546        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1547    }
1548
1549    #[test]
1550    fn test_serde_custom_dump_state() {
1551        let s = r#"{"method": "anvil_dumpState", "params": [true]}"#;
1552        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1553        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1554
1555        let s = r#"{"method": "anvil_dumpState"}"#;
1556        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1557        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1558        match req {
1559            EthRequest::DumpState(param) => {
1560                assert!(param.is_none());
1561            }
1562            _ => unreachable!(),
1563        }
1564    }
1565
1566    #[test]
1567    fn test_serde_custom_load_state() {
1568        let s = r#"{"method": "anvil_loadState", "params": ["0x0001"] }"#;
1569        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1570        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1571    }
1572
1573    #[test]
1574    fn test_serde_custom_snapshot() {
1575        let s = r#"{"method": "anvil_snapshot", "params": [] }"#;
1576        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1577        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1578
1579        let s = r#"{"method": "evm_snapshot", "params": [] }"#;
1580        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1581        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1582    }
1583
1584    #[test]
1585    fn test_serde_custom_revert() {
1586        let s = r#"{"method": "anvil_revert", "params": ["0x0"]}"#;
1587        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1588        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1589    }
1590
1591    #[test]
1592    fn test_serde_custom_increase_time() {
1593        let s = r#"{"method": "anvil_increaseTime", "params": ["0x0"]}"#;
1594        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1595        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1596
1597        let s = r#"{"method": "anvil_increaseTime", "params": [1]}"#;
1598        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1599        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1600
1601        let s = r#"{"method": "anvil_increaseTime", "params": 1}"#;
1602        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1603        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1604
1605        let s = r#"{"method": "evm_increaseTime", "params": ["0x0"]}"#;
1606        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1607        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1608
1609        let s = r#"{"method": "evm_increaseTime", "params": [1]}"#;
1610        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1611        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1612
1613        let s = r#"{"method": "evm_increaseTime", "params": 1}"#;
1614        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1615        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1616    }
1617
1618    #[test]
1619    fn test_serde_custom_next_timestamp() {
1620        let s = r#"{"method": "anvil_setNextBlockTimestamp", "params": [100]}"#;
1621        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1622        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1623        let s = r#"{"method": "evm_setNextBlockTimestamp", "params": [100]}"#;
1624        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1625        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1626        let s = r#"{"method": "evm_setNextBlockTimestamp", "params": ["0x64e0f308"]}"#;
1627        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1628        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1629    }
1630
1631    #[test]
1632    fn test_serde_custom_timestamp_interval() {
1633        let s = r#"{"method": "anvil_setBlockTimestampInterval", "params": [100]}"#;
1634        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1635        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1636    }
1637
1638    #[test]
1639    fn test_serde_custom_remove_timestamp_interval() {
1640        let s = r#"{"method": "anvil_removeBlockTimestampInterval", "params": []}"#;
1641        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1642        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1643    }
1644
1645    #[test]
1646    fn test_serde_custom_evm_mine() {
1647        let s = r#"{"method": "evm_mine", "params": [100]}"#;
1648        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1649        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1650        let s = r#"{"method": "evm_mine", "params": [{
1651            "timestamp": 100,
1652            "blocks": 100
1653        }]}"#;
1654        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1655        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1656        match req {
1657            EthRequest::EvmMine(params) => {
1658                assert_eq!(
1659                    params.unwrap().params.unwrap_or_default(),
1660                    MineOptions::Options { timestamp: Some(100), blocks: Some(100) }
1661                )
1662            }
1663            _ => unreachable!(),
1664        }
1665
1666        let s = r#"{"method": "evm_mine"}"#;
1667        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1668        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1669
1670        match req {
1671            EthRequest::EvmMine(params) => {
1672                assert!(params.is_none())
1673            }
1674            _ => unreachable!(),
1675        }
1676
1677        let s = r#"{"method": "evm_mine", "params": []}"#;
1678        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1679        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1680    }
1681
1682    #[test]
1683    fn test_serde_custom_evm_mine_detailed() {
1684        let s = r#"{"method": "anvil_mine_detailed", "params": [100]}"#;
1685        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1686        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1687        let s = r#"{"method": "anvil_mine_detailed", "params": [{
1688            "timestamp": 100,
1689            "blocks": 100
1690        }]}"#;
1691        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1692        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1693        match req {
1694            EthRequest::EvmMineDetailed(params) => {
1695                assert_eq!(
1696                    params.unwrap().params.unwrap_or_default(),
1697                    MineOptions::Options { timestamp: Some(100), blocks: Some(100) }
1698                )
1699            }
1700            _ => unreachable!(),
1701        }
1702
1703        let s = r#"{"method": "evm_mine_detailed"}"#;
1704        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1705        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1706
1707        match req {
1708            EthRequest::EvmMineDetailed(params) => {
1709                assert!(params.is_none())
1710            }
1711            _ => unreachable!(),
1712        }
1713
1714        let s = r#"{"method": "anvil_mine_detailed", "params": []}"#;
1715        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1716        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1717    }
1718
1719    #[test]
1720    fn test_serde_custom_evm_mine_hex() {
1721        let s = r#"{"method": "evm_mine", "params": ["0x63b6ff08"]}"#;
1722        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1723        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1724        match req {
1725            EthRequest::EvmMine(params) => {
1726                assert_eq!(
1727                    params.unwrap().params.unwrap_or_default(),
1728                    MineOptions::Timestamp(Some(1672937224))
1729                )
1730            }
1731            _ => unreachable!(),
1732        }
1733
1734        let s = r#"{"method": "evm_mine", "params": [{"timestamp": "0x63b6ff08"}]}"#;
1735        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1736        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1737        match req {
1738            EthRequest::EvmMine(params) => {
1739                assert_eq!(
1740                    params.unwrap().params.unwrap_or_default(),
1741                    MineOptions::Options { timestamp: Some(1672937224), blocks: None }
1742                )
1743            }
1744            _ => unreachable!(),
1745        }
1746    }
1747
1748    #[test]
1749    fn test_eth_uncle_count_by_block_hash() {
1750        let s = r#"{"jsonrpc":"2.0","method":"eth_getUncleCountByBlockHash","params":["0x4a3b0fce2cb9707b0baa68640cf2fe858c8bb4121b2a8cb904ff369d38a560ff"]}"#;
1751        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1752        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1753    }
1754
1755    #[test]
1756    fn test_eth_block_tx_count_by_block_hash() {
1757        let s = r#"{"jsonrpc":"2.0","method":"eth_getBlockTransactionCountByHash","params":["0x4a3b0fce2cb9707b0baa68640cf2fe858c8bb4121b2a8cb904ff369d38a560ff"]}"#;
1758        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1759        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1760    }
1761
1762    #[test]
1763    fn test_eth_get_logs() {
1764        let s = r#"{"jsonrpc":"2.0","method":"eth_getLogs","params":[{"topics":["0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b"]}],"id":74}"#;
1765        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1766        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1767    }
1768
1769    #[test]
1770    fn test_eth_new_filter() {
1771        let s = r#"{"method": "eth_newFilter", "params": [{"topics":["0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b"]}],"id":73}"#;
1772        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1773        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1774    }
1775
1776    #[test]
1777    fn test_serde_raw_transaction_conditional() {
1778        let s = r#"{"method": "eth_sendRawTransactionConditional", "params":
1779["0x4a3b0fce2cb9707b0baa68640cf2fe858c8bb4121b2a8cb904ff369d38a560ff", {"knownAccounts":{}}]}"#;
1780        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1781        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1782    }
1783
1784    #[test]
1785    fn test_eth_new_pending_transaction_filter() {
1786        let s = r#"{"method": "eth_newPendingTransactionFilter", "params":[],"id":73}"#;
1787        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1788        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1789        assert!(matches!(req, EthRequest::EthNewPendingTransactionFilter(None)));
1790
1791        let s = r#"{"method": "eth_newPendingTransactionFilter", "params":[null],"id":73}"#;
1792        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1793        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1794        assert!(matches!(req, EthRequest::EthNewPendingTransactionFilter(None)));
1795
1796        let s = r#"{"method": "eth_newPendingTransactionFilter", "params":[false],"id":73}"#;
1797        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1798        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1799        assert!(matches!(req, EthRequest::EthNewPendingTransactionFilter(Some(false))));
1800
1801        let s = r#"{"method": "eth_newPendingTransactionFilter", "params":[true],"id":73}"#;
1802        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1803        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1804        assert!(matches!(req, EthRequest::EthNewPendingTransactionFilter(Some(true))));
1805    }
1806
1807    #[test]
1808    fn test_serde_eth_unsubscribe() {
1809        let s = r#"{"id": 1, "method": "eth_unsubscribe", "params":
1810["0x9cef478923ff08bf67fde6c64013158d"]}"#;
1811        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1812        let _req = serde_json::from_value::<EthPubSub>(value).unwrap();
1813    }
1814
1815    #[test]
1816    fn test_serde_eth_subscribe() {
1817        let s = r#"{"id": 1, "method": "eth_subscribe", "params": ["newHeads"]}"#;
1818        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1819        let _req = serde_json::from_value::<EthPubSub>(value).unwrap();
1820        assert!(matches!(serde_json::from_str(s).unwrap(), EthRpcCall::PubSub(_)));
1821
1822        let s = r#"{"id": 1, "method": "eth_subscribe", "params": ["logs", {"address":
1823"0x8320fe7702b96808f7bbc0d4a888ed1468216cfd", "topics":
1824["0xd78a0cb8bb633d06981248b816e7bd33c2a35a6089241d099fa519e361cab902"]}]}"#;
1825        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1826        let _req = serde_json::from_value::<EthPubSub>(value).unwrap();
1827
1828        let s = r#"{"id": 1, "method": "eth_subscribe", "params": ["newPendingTransactions"]}"#;
1829        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1830        let _req = serde_json::from_value::<EthPubSub>(value).unwrap();
1831
1832        let s = r#"{"id": 1, "method": "eth_subscribe", "params": ["syncing"]}"#;
1833        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1834        let _req = serde_json::from_value::<EthPubSub>(value).unwrap();
1835    }
1836
1837    #[test]
1838    fn test_serde_debug_raw_transaction() {
1839        let s = r#"{"jsonrpc":"2.0","method":"debug_getRawTransaction","params":["0x3ed3a89bc10115a321aee238c02de214009f8532a65368e5df5eaf732ee7167c"],"id":1}"#;
1840        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1841        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1842
1843        let s = r#"{"jsonrpc":"2.0","method":"eth_getRawTransactionByHash","params":["0x3ed3a89bc10115a321aee238c02de214009f8532a65368e5df5eaf732ee7167c"],"id":1}"#;
1844        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1845        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1846
1847        let s = r#"{"jsonrpc":"2.0","method":"eth_getRawTransactionByBlockHashAndIndex","params":["0x3ed3a89bc10115a321aee238c02de214009f8532a65368e5df5eaf732ee7167c",1],"id":1}"#;
1848        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1849        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1850
1851        let s = r#"{"jsonrpc":"2.0","method":"eth_getRawTransactionByBlockNumberAndIndex","params":["0x3ed3a89b",0],"id":1}"#;
1852        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1853        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1854    }
1855
1856    #[test]
1857    fn test_serde_debug_raw_receipts() {
1858        let s = r#"{"jsonrpc":"2.0","method":"debug_getRawReceipts","params":["latest"],"id":1}"#;
1859        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1860        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1861
1862        let s = r#"{"jsonrpc":"2.0","method":"debug_getRawReceipts","params":["0x3ed3a89bc10115a321aee238c02de214009f8532a65368e5df5eaf732ee7167c"],"id":1}"#;
1863        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1864        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1865    }
1866
1867    #[test]
1868    fn test_serde_debug_raw_transactions() {
1869        let s =
1870            r#"{"jsonrpc":"2.0","method":"debug_getRawTransactions","params":["latest"],"id":1}"#;
1871        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1872        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1873
1874        let s = r#"{"jsonrpc":"2.0","method":"debug_getRawTransactions","params":["0x3ed3a89bc10115a321aee238c02de214009f8532a65368e5df5eaf732ee7167c"],"id":1}"#;
1875        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1876        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1877    }
1878
1879    #[test]
1880    fn test_serde_debug_raw_header() {
1881        let s = r#"{"jsonrpc":"2.0","method":"debug_getRawHeader","params":["latest"],"id":1}"#;
1882        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1883        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1884
1885        let s = r#"{"jsonrpc":"2.0","method":"debug_getRawHeader","params":["0x3ed3a89bc10115a321aee238c02de214009f8532a65368e5df5eaf732ee7167c"],"id":1}"#;
1886        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1887        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1888    }
1889
1890    #[test]
1891    fn test_serde_debug_raw_block() {
1892        let s = r#"{"jsonrpc":"2.0","method":"debug_getRawBlock","params":["latest"],"id":1}"#;
1893        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1894        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1895
1896        let s = r#"{"jsonrpc":"2.0","method":"debug_getRawBlock","params":["0x3ed3a89bc10115a321aee238c02de214009f8532a65368e5df5eaf732ee7167c"],"id":1}"#;
1897        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1898        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1899    }
1900
1901    #[test]
1902    fn test_serde_debug_clear_txpool() {
1903        let s = r#"{"jsonrpc":"2.0","method":"debug_clearTxpool","params":[],"id":1}"#;
1904        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1905        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1906    }
1907
1908    #[test]
1909    fn test_serde_debug_trace_transaction() {
1910        let s = r#"{"method": "debug_traceTransaction", "params":
1911["0x4a3b0fce2cb9707b0baa68640cf2fe858c8bb4121b2a8cb904ff369d38a560ff"]}"#;
1912        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1913        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1914
1915        let s = r#"{"method": "debug_traceTransaction", "params":
1916["0x4a3b0fce2cb9707b0baa68640cf2fe858c8bb4121b2a8cb904ff369d38a560ff", {}]}"#;
1917        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1918        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1919
1920        let s = r#"{"method": "debug_traceTransaction", "params":
1921["0x4a3b0fce2cb9707b0baa68640cf2fe858c8bb4121b2a8cb904ff369d38a560ff", {"disableStorage":
1922true}]}"#;
1923        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1924        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1925    }
1926
1927    #[test]
1928    fn test_serde_debug_account_info_at() {
1929        let s = r#"{"method": "debug_accountInfoAt", "params": ["0x1", "0x0", "0xd84de507f3fada7df80908082d3239466db55a71"]}"#;
1930        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1931        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1932
1933        let s = r#"{"method": "debug_accountInfoAt", "params": [{"blockHash": "0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3"}, 0, "0xd84de507f3fada7df80908082d3239466db55a71"]}"#;
1934        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1935        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1936    }
1937
1938    #[test]
1939    fn test_serde_debug_execution_witness() {
1940        let s = r#"{"method": "debug_executionWitness", "params": ["0x1"]}"#;
1941        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1942        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1943
1944        let s = r#"{"method": "debug_executionWitness", "params": ["latest"]}"#;
1945        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1946        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1947    }
1948
1949    #[test]
1950    fn test_serde_trace_transaction_opcode_gas() {
1951        let s = r#"{"method": "trace_transactionOpcodeGas", "params": ["0x4a3b0fce2cb9707b0baa68640cf2fe858c8bb4121b2a8cb904ff369d38a560ff"]}"#;
1952        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1953        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1954    }
1955
1956    #[test]
1957    fn test_serde_trace_replay_transaction() {
1958        let s = r#"{"method":"trace_replayTransaction","params":["0x4a3b0fce2cb9707b0baa68640cf2fe858c8bb4121b2a8cb904ff369d38a560ff",["trace","stateDiff"]]}"#;
1959        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1960        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1961    }
1962
1963    #[test]
1964    fn test_serde_trace_block_opcode_gas() {
1965        let s = r#"{"method": "trace_blockOpcodeGas", "params": ["0x1"]}"#;
1966        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1967        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1968
1969        let s = r#"{"method": "trace_blockOpcodeGas", "params": [{"blockHash": "0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3"}]}"#;
1970        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1971        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1972    }
1973
1974    #[test]
1975    fn test_serde_trace_raw_transaction() {
1976        let s = r#"{"method": "trace_rawTransaction", "params": ["0x02f866827a690a65648252089470997970c51812dc3a010c7d01b50e0d17dc79c88203e980c001a0e4de88aefcf87ccb04466e60de66a83192e46aa26177d5ea35efbfd43fd0ecdca00e3148e0e8e0b9a6f9b329efd6e30c4a461920f3a27497be3dbefaba996601da", ["trace"]]}"#;
1977        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1978        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1979
1980        let s = r#"{"method": "trace_rawTransaction", "params": ["0x02f866827a690a65648252089470997970c51812dc3a010c7d01b50e0d17dc79c88203e980c001a0e4de88aefcf87ccb04466e60de66a83192e46aa26177d5ea35efbfd43fd0ecdca00e3148e0e8e0b9a6f9b329efd6e30c4a461920f3a27497be3dbefaba996601da", ["trace", "stateDiff", "vmTrace"], "latest"]}"#;
1981        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1982        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1983    }
1984
1985    #[test]
1986    fn test_serde_debug_trace_call() {
1987        let s = r#"{"method": "debug_traceCall", "params": [{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}]}"#;
1988        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1989        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1990
1991        let s = r#"{"method": "debug_traceCall", "params": [{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}, { "blockNumber": "latest" }]}"#;
1992        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1993        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1994
1995        let s = r#"{"method": "debug_traceCall", "params": [{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}, { "blockNumber": "0x0" }]}"#;
1996        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1997        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1998
1999        let s = r#"{"method": "debug_traceCall", "params": [{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}, { "blockHash": "0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3" }]}"#;
2000        let value: serde_json::Value = serde_json::from_str(s).unwrap();
2001        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
2002
2003        let s = r#"{"method": "debug_traceCall", "params": [{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}, { "blockNumber": "0x0" }, {"disableStorage": true}]}"#;
2004        let value: serde_json::Value = serde_json::from_str(s).unwrap();
2005        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
2006
2007        let s = r#"{"method": "debug_traceCall", "params": [{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}, { "blockNumber": "0x1" }, {"txIndex": "0x0"}]}"#;
2008        let value: serde_json::Value = serde_json::from_str(s).unwrap();
2009        let req = serde_json::from_value::<EthRequest>(value).unwrap();
2010        match req {
2011            EthRequest::DebugTraceCall(_, _, opts) => assert_eq!(opts.tx_index, Some(0)),
2012            _ => panic!("expected debug_traceCall"),
2013        }
2014    }
2015
2016    #[test]
2017    fn test_serde_debug_get_modified_accounts_by_number() {
2018        let s = r#"{"method": "debug_getModifiedAccountsByNumber", "params": [0, 1]}"#;
2019        let value: serde_json::Value = serde_json::from_str(s).unwrap();
2020        match serde_json::from_value::<EthRequest>(value).unwrap() {
2021            EthRequest::DebugGetModifiedAccountsByNumber(0, 1) => {}
2022            req => panic!("unexpected request: {req:?}"),
2023        }
2024    }
2025
2026    #[test]
2027    fn test_serde_debug_free_os_memory() {
2028        let s = r#"{"method": "debug_freeOSMemory", "params": []}"#;
2029        let value: serde_json::Value = serde_json::from_str(s).unwrap();
2030        match serde_json::from_value::<EthRequest>(value).unwrap() {
2031            EthRequest::DebugFreeOsMemory(()) => {}
2032            req => panic!("unexpected request: {req:?}"),
2033        }
2034    }
2035
2036    #[test]
2037    fn test_serde_trace_call() {
2038        let s = r#"{"method": "trace_call", "params": [{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}, ["trace", "stateDiff"], "latest"]}"#;
2039        let value: serde_json::Value = serde_json::from_str(s).unwrap();
2040        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
2041
2042        let s = r#"{"method": "trace_call", "params": [{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}]}"#;
2043        let value: serde_json::Value = serde_json::from_str(s).unwrap();
2044        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
2045    }
2046
2047    #[test]
2048    fn test_serde_trace_call_many() {
2049        let s = r#"{"method": "trace_callMany", "params": [[[{"from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d","value":"0x1"}, ["trace"]], [{"from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d","value":"0x2"}, ["trace", "stateDiff"]]]]}"#;
2050        let value: serde_json::Value = serde_json::from_str(s).unwrap();
2051        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
2052
2053        let s = r#"{"method": "trace_callMany", "params": [[[{"from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}, ["trace"]]], "latest"]}"#;
2054        let value: serde_json::Value = serde_json::from_str(s).unwrap();
2055        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
2056    }
2057
2058    #[test]
2059    fn test_serde_trace_get() {
2060        let s = r#"{"method": "trace_get", "params": ["0x4a3b0fce2cb9707b0baa68640cf2fe858c8bb4121b2a8cb904ff369d38a560ff", [0]]}"#;
2061        let value: serde_json::Value = serde_json::from_str(s).unwrap();
2062        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
2063    }
2064
2065    #[test]
2066    fn test_serde_debug_trace_block() {
2067        let s = r#"{"method":"debug_traceBlock","params":["0xc0",{"tracer":"callTracer"}]}"#;
2068        let value: serde_json::Value = serde_json::from_str(s).unwrap();
2069        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
2070    }
2071
2072    #[test]
2073    fn test_serde_eth_storage() {
2074        let s = r#"{"method": "eth_getStorageAt", "params":
2075["0x295a70b2de5e3953354a6a8344e616ed314d7251", "0x0", "latest"]}"#;
2076        let value: serde_json::Value = serde_json::from_str(s).unwrap();
2077        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
2078    }
2079
2080    #[test]
2081    fn test_eth_call() {
2082        let req = r#"{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}"#;
2083        let _req = serde_json::from_str::<TransactionRequest>(req).unwrap();
2084
2085        let s = r#"{"method": "eth_call", "params":[{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"},"latest"]}"#;
2086        let _req = serde_json::from_str::<EthRequest>(s).unwrap();
2087
2088        let s = r#"{"method": "eth_call", "params":[{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}]}"#;
2089        let _req = serde_json::from_str::<EthRequest>(s).unwrap();
2090
2091        let s = r#"{"method": "eth_call", "params":[{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}, { "blockNumber": "latest" }]}"#;
2092        let _req = serde_json::from_str::<EthRequest>(s).unwrap();
2093
2094        let s = r#"{"method": "eth_call", "params":[{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}, { "blockNumber": "0x0" }]}"#;
2095        let _req = serde_json::from_str::<EthRequest>(s).unwrap();
2096
2097        let s = r#"{"method": "eth_call", "params":[{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}, { "blockHash":"0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3" }]}"#;
2098        let _req = serde_json::from_str::<EthRequest>(s).unwrap();
2099    }
2100
2101    #[test]
2102    fn test_eth_call_many() {
2103        let s = r#"{"method":"eth_callMany","params":[[{"transactions":[{"from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d","data":"0xcfae3217"}]}],{"blockNumber":"latest"},{"0x0000000000000000000000000000000000000001":{"balance":"0x1"}}]}"#;
2104        let _req = serde_json::from_str::<EthRequest>(s).unwrap();
2105    }
2106
2107    #[test]
2108    fn test_eth_call_bundle() {
2109        let s = r#"{"method":"eth_callBundle","params":[{"txs":["0x1234"],"blockNumber":"0x1","stateBlockNumber":"latest"}]}"#;
2110        let _req = serde_json::from_str::<EthRequest>(s).unwrap();
2111    }
2112
2113    #[test]
2114    fn test_serde_eth_balance() {
2115        let s = r#"{"method": "eth_getBalance", "params":
2116["0x295a70b2de5e3953354a6a8344e616ed314d7251", "latest"]}"#;
2117        let value: serde_json::Value = serde_json::from_str(s).unwrap();
2118
2119        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
2120    }
2121
2122    #[test]
2123    fn test_serde_eth_block_by_number() {
2124        let s = r#"{"method": "eth_getBlockByNumber", "params": ["0x0", true]}"#;
2125        let value: serde_json::Value = serde_json::from_str(s).unwrap();
2126        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
2127        let s = r#"{"method": "eth_getBlockByNumber", "params": ["latest", true]}"#;
2128        let value: serde_json::Value = serde_json::from_str(s).unwrap();
2129        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
2130        let s = r#"{"method": "eth_getBlockByNumber", "params": ["earliest", true]}"#;
2131        let value: serde_json::Value = serde_json::from_str(s).unwrap();
2132        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
2133        let s = r#"{"method": "eth_getBlockByNumber", "params": ["pending", true]}"#;
2134        let value: serde_json::Value = serde_json::from_str(s).unwrap();
2135        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
2136
2137        // this case deviates from the spec, but we're supporting this for legacy reasons: <https://github.com/foundry-rs/foundry/issues/1868>
2138        let s = r#"{"method": "eth_getBlockByNumber", "params": [0, true]}"#;
2139        let value: serde_json::Value = serde_json::from_str(s).unwrap();
2140        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
2141    }
2142
2143    #[test]
2144    fn test_eth_sign() {
2145        let s = r#"{"method": "eth_sign", "params":
2146["0xd84de507f3fada7df80908082d3239466db55a71", "0x00"]}"#;
2147        let value: serde_json::Value = serde_json::from_str(s).unwrap();
2148        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
2149        let s = r#"{"method": "personal_sign", "params":
2150["0x00", "0xd84de507f3fada7df80908082d3239466db55a71"]}"#;
2151        let value: serde_json::Value = serde_json::from_str(s).unwrap();
2152        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
2153    }
2154
2155    #[test]
2156    fn test_eth_sign_typed_data() {
2157        let s = r#"{"method":"eth_signTypedData_v4","params":["0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826", {"types":{"EIP712Domain":[{"name":"name","type":"string"},{"name":"version","type":"string"},{"name":"chainId","type":"uint256"},{"name":"verifyingContract","type":"address"}],"Person":[{"name":"name","type":"string"},{"name":"wallet","type":"address"}],"Mail":[{"name":"from","type":"Person"},{"name":"to","type":"Person"},{"name":"contents","type":"string"}]},"primaryType":"Mail","domain":{"name":"Ether Mail","version":"1","chainId":1,"verifyingContract":"0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC"},"message":{"from":{"name":"Cow","wallet":"0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826"},"to":{"name":"Bob","wallet":"0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB"},"contents":"Hello, Bob!"}}]}"#;
2158        let value: serde_json::Value = serde_json::from_str(s).unwrap();
2159        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
2160    }
2161
2162    #[test]
2163    fn test_remove_pool_transactions() {
2164        let s = r#"{"method": "anvil_removePoolTransactions",  "params":["0x364d6D0333432C3Ac016Ca832fb8594A8cE43Ca6"]}"#;
2165        let value: serde_json::Value = serde_json::from_str(s).unwrap();
2166        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
2167    }
2168
2169    #[test]
2170    fn test_serde_anvil_reorg() {
2171        // TransactionData::JSON
2172        let s = r#"
2173        {
2174            "method": "anvil_reorg",
2175            "params": [
2176                5,
2177                [
2178                    [
2179                        {
2180                            "from": "0x976EA74026E726554dB657fA54763abd0C3a0aa9",
2181                            "to": "0x1199bc69f16FDD6690DC40339EC445FaE1b6DD11",
2182                            "value": 100
2183                        },
2184                        1
2185                    ],
2186                    [
2187                        {
2188                            "from": "0x976EA74026E726554dB657fA54763abd0C3a0aa9",
2189                            "to": "0x1199bc69f16FDD6690DC40339EC445FaE1b6DD11",
2190                            "value": 200
2191                        },
2192                        2
2193                    ]
2194                ]
2195            ]
2196        }
2197        "#;
2198        let value: serde_json::Value = serde_json::from_str(s).unwrap();
2199        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
2200        // TransactionData::Raw
2201        let s = r#"
2202        {
2203            "method": "anvil_reorg",
2204            "params": [
2205                5,
2206                [
2207                    [
2208                        "0x19d55c67e1ba8f1bbdfed75f8ad524ebf087e4ecb848a2d19881d7a5e3d2c54e1732cb1b462da3b3fdb05bdf4c4d3c8e3c9fcebdc2ab5fa5d59a3f752888f27e1b",
2209                        1
2210                    ]
2211                ]
2212            ]
2213        }
2214        "#;
2215        let value: serde_json::Value = serde_json::from_str(s).unwrap();
2216        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
2217        // TransactionData::Raw and TransactionData::JSON
2218        let s = r#"
2219        {
2220            "method": "anvil_reorg",
2221            "params": [
2222                5,
2223                [
2224                    [
2225                        "0x19d55c67e1ba8f1bbdfed75f8ad524ebf087e4ecb848a2d19881d7a5e3d2c54e1732cb1b462da3b3fdb05bdf4c4d3c8e3c9fcebdc2ab5fa5d59a3f752888f27e1b",
2226                        1
2227                    ],
2228                    [
2229                        {
2230                            "from": "0x976EA74026E726554dB657fA54763abd0C3a0aa9",
2231                            "to": "0x1199bc69f16FDD6690DC40339EC445FaE1b6DD11",
2232                            "value": 200
2233                        },
2234                        2
2235                    ]
2236                ]
2237            ]
2238        }
2239        "#;
2240        let value: serde_json::Value = serde_json::from_str(s).unwrap();
2241        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
2242    }
2243}