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