anvil_core/eth/
mod.rs

1use crate::{eth::subscription::SubscriptionId, types::ReorgOptions};
2use alloy_primitives::{
3    Address, B64, B256, Bytes, TxHash, U256,
4    map::{HashMap, HashSet},
5};
6use alloy_rpc_types::{
7    BlockId, BlockNumberOrTag as BlockNumber, BlockOverrides, Filter, Index,
8    anvil::{Forking, MineOptions},
9    pubsub::{Params as SubscriptionParams, SubscriptionKind},
10    request::TransactionRequest,
11    simulate::SimulatePayload,
12    state::StateOverride,
13    trace::{
14        filter::TraceFilter,
15        geth::{GethDebugTracingCallOptions, GethDebugTracingOptions},
16        parity::TraceType,
17    },
18};
19use alloy_serde::WithOtherFields;
20use foundry_common::serde_helpers::{
21    deserialize_number, deserialize_number_opt, deserialize_number_seq,
22};
23
24pub mod block;
25pub mod subscription;
26pub mod transaction;
27pub mod wallet;
28
29pub mod serde_helpers;
30use self::serde_helpers::*;
31
32/// Wrapper type that ensures the type is named `params`
33#[derive(Clone, Debug, PartialEq, Eq, serde::Deserialize)]
34pub struct Params<T: Default> {
35    #[serde(default)]
36    pub params: T,
37}
38
39/// Represents ethereum JSON-RPC API
40#[derive(Clone, Debug, serde::Deserialize)]
41#[serde(tag = "method", content = "params")]
42#[allow(clippy::large_enum_variant)]
43pub enum EthRequest {
44    #[serde(rename = "web3_clientVersion", with = "empty_params")]
45    Web3ClientVersion(()),
46
47    #[serde(rename = "web3_sha3", with = "sequence")]
48    Web3Sha3(Bytes),
49
50    /// Returns the current Ethereum protocol version.
51    #[serde(rename = "eth_protocolVersion", with = "empty_params")]
52    EthProtocolVersion(()),
53
54    #[serde(rename = "eth_chainId", with = "empty_params")]
55    EthChainId(()),
56
57    #[serde(rename = "eth_networkId", alias = "net_version", with = "empty_params")]
58    EthNetworkId(()),
59
60    #[serde(rename = "net_listening", with = "empty_params")]
61    NetListening(()),
62
63    /// Returns the number of hashes per second with which the node is mining.
64    #[serde(rename = "eth_hashrate", with = "empty_params")]
65    EthHashrate(()),
66
67    #[serde(rename = "eth_gasPrice", with = "empty_params")]
68    EthGasPrice(()),
69
70    #[serde(rename = "eth_maxPriorityFeePerGas", with = "empty_params")]
71    EthMaxPriorityFeePerGas(()),
72
73    #[serde(rename = "eth_blobBaseFee", with = "empty_params")]
74    EthBlobBaseFee(()),
75
76    #[serde(rename = "eth_accounts", alias = "eth_requestAccounts", with = "empty_params")]
77    EthAccounts(()),
78
79    #[serde(rename = "eth_blockNumber", with = "empty_params")]
80    EthBlockNumber(()),
81
82    /// Returns the client coinbase address.
83    #[serde(rename = "eth_coinbase", with = "empty_params")]
84    EthCoinbase(()),
85
86    #[serde(rename = "eth_getBalance")]
87    EthGetBalance(Address, Option<BlockId>),
88
89    #[serde(rename = "eth_getAccount")]
90    EthGetAccount(Address, Option<BlockId>),
91
92    #[serde(rename = "eth_getAccountInfo")]
93    EthGetAccountInfo(Address, Option<BlockId>),
94
95    #[serde(rename = "eth_getStorageAt")]
96    EthGetStorageAt(Address, U256, Option<BlockId>),
97
98    /// Returns storage values for multiple accounts and slots in a single call.
99    #[serde(rename = "eth_getStorageValues")]
100    EthGetStorageValues(HashMap<Address, Vec<B256>>, Option<BlockId>),
101
102    #[serde(rename = "eth_getBlockByHash")]
103    EthGetBlockByHash(B256, bool),
104
105    #[serde(rename = "eth_getBlockByNumber")]
106    EthGetBlockByNumber(
107        #[serde(deserialize_with = "lenient_block_number::lenient_block_number")] BlockNumber,
108        bool,
109    ),
110
111    #[serde(rename = "eth_getTransactionCount")]
112    EthGetTransactionCount(Address, Option<BlockId>),
113
114    #[serde(rename = "eth_getBlockTransactionCountByHash", with = "sequence")]
115    EthGetTransactionCountByHash(B256),
116
117    #[serde(
118        rename = "eth_getBlockTransactionCountByNumber",
119        deserialize_with = "lenient_block_number::lenient_block_number_seq"
120    )]
121    EthGetTransactionCountByNumber(BlockNumber),
122
123    #[serde(rename = "eth_getUncleCountByBlockHash", with = "sequence")]
124    EthGetUnclesCountByHash(B256),
125
126    #[serde(
127        rename = "eth_getUncleCountByBlockNumber",
128        deserialize_with = "lenient_block_number::lenient_block_number_seq"
129    )]
130    EthGetUnclesCountByNumber(BlockNumber),
131
132    #[serde(rename = "eth_getCode")]
133    EthGetCodeAt(Address, Option<BlockId>),
134
135    /// Returns the account and storage values of the specified account including the Merkle-proof.
136    /// This call can be used to verify that the data you are pulling from is not tampered with.
137    #[serde(rename = "eth_getProof")]
138    EthGetProof(Address, Vec<B256>, Option<BlockId>),
139
140    /// The sign method calculates an Ethereum specific signature with:
141    #[serde(rename = "eth_sign")]
142    EthSign(Address, Bytes),
143
144    /// The sign method calculates an Ethereum specific signature, equivalent to eth_sign:
145    /// <https://docs.metamask.io/wallet/reference/personal_sign/>
146    #[serde(rename = "personal_sign")]
147    PersonalSign(Bytes, Address),
148
149    #[serde(rename = "eth_signTransaction", with = "sequence")]
150    EthSignTransaction(Box<WithOtherFields<TransactionRequest>>),
151
152    /// Signs data via [EIP-712](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-712.md).
153    #[serde(rename = "eth_signTypedData")]
154    EthSignTypedData(Address, serde_json::Value),
155
156    /// Signs data via [EIP-712](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-712.md).
157    #[serde(rename = "eth_signTypedData_v3")]
158    EthSignTypedDataV3(Address, serde_json::Value),
159
160    /// 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.
161    #[serde(rename = "eth_signTypedData_v4")]
162    EthSignTypedDataV4(Address, alloy_dyn_abi::TypedData),
163
164    #[serde(rename = "eth_sendTransaction", with = "sequence")]
165    EthSendTransaction(Box<WithOtherFields<TransactionRequest>>),
166
167    #[serde(rename = "eth_sendTransactionSync", with = "sequence")]
168    EthSendTransactionSync(Box<WithOtherFields<TransactionRequest>>),
169
170    #[serde(rename = "eth_sendRawTransaction", with = "sequence")]
171    EthSendRawTransaction(Bytes),
172
173    #[serde(rename = "eth_sendRawTransactionSync", with = "sequence")]
174    EthSendRawTransactionSync(Bytes),
175
176    #[serde(rename = "eth_call")]
177    EthCall(
178        WithOtherFields<TransactionRequest>,
179        #[serde(default)] Option<BlockId>,
180        #[serde(default)] Option<StateOverride>,
181        #[serde(default)] Option<Box<BlockOverrides>>,
182    ),
183
184    #[serde(rename = "eth_simulateV1")]
185    EthSimulateV1(SimulatePayload, #[serde(default)] Option<BlockId>),
186
187    #[serde(rename = "eth_createAccessList")]
188    EthCreateAccessList(WithOtherFields<TransactionRequest>, #[serde(default)] Option<BlockId>),
189
190    #[serde(rename = "eth_estimateGas")]
191    EthEstimateGas(
192        WithOtherFields<TransactionRequest>,
193        #[serde(default)] Option<BlockId>,
194        #[serde(default)] Option<StateOverride>,
195        #[serde(default)] Option<Box<BlockOverrides>>,
196    ),
197
198    #[serde(rename = "eth_fillTransaction", with = "sequence")]
199    EthFillTransaction(WithOtherFields<TransactionRequest>),
200
201    #[serde(rename = "eth_getTransactionByHash", with = "sequence")]
202    EthGetTransactionByHash(TxHash),
203
204    /// Returns the blob for a given blob versioned hash.
205    #[serde(rename = "anvil_getBlobByHash", with = "sequence")]
206    GetBlobByHash(B256),
207
208    /// Returns the blobs for a given transaction hash.
209    #[serde(rename = "anvil_getBlobsByTransactionHash", with = "sequence")]
210    GetBlobByTransactionHash(TxHash),
211
212    /// Returns the genesis time for the chain
213    #[serde(rename = "anvil_getGenesisTime", with = "empty_params")]
214    GetGenesisTime(()),
215
216    #[serde(rename = "eth_getTransactionByBlockHashAndIndex")]
217    EthGetTransactionByBlockHashAndIndex(B256, Index),
218
219    #[serde(rename = "eth_getTransactionByBlockNumberAndIndex")]
220    EthGetTransactionByBlockNumberAndIndex(BlockNumber, Index),
221
222    #[serde(rename = "eth_getRawTransactionByHash", with = "sequence")]
223    EthGetRawTransactionByHash(TxHash),
224
225    #[serde(rename = "eth_getRawTransactionByBlockHashAndIndex")]
226    EthGetRawTransactionByBlockHashAndIndex(B256, Index),
227
228    #[serde(rename = "eth_getRawTransactionByBlockNumberAndIndex")]
229    EthGetRawTransactionByBlockNumberAndIndex(BlockNumber, Index),
230
231    #[serde(rename = "eth_getTransactionReceipt", with = "sequence")]
232    EthGetTransactionReceipt(B256),
233
234    #[serde(rename = "eth_getBlockReceipts", with = "sequence")]
235    EthGetBlockReceipts(BlockId),
236
237    #[serde(rename = "eth_getUncleByBlockHashAndIndex")]
238    EthGetUncleByBlockHashAndIndex(B256, Index),
239
240    #[serde(rename = "eth_getUncleByBlockNumberAndIndex")]
241    EthGetUncleByBlockNumberAndIndex(
242        #[serde(deserialize_with = "lenient_block_number::lenient_block_number")] BlockNumber,
243        Index,
244    ),
245
246    #[serde(rename = "eth_getLogs", with = "sequence")]
247    EthGetLogs(Filter),
248
249    /// Creates a filter object, based on filter options, to notify when the state changes (logs).
250    #[serde(rename = "eth_newFilter", with = "sequence")]
251    EthNewFilter(Filter),
252
253    /// Polling method for a filter, which returns an array of logs which occurred since last poll.
254    #[serde(rename = "eth_getFilterChanges", with = "sequence")]
255    EthGetFilterChanges(String),
256
257    /// Creates a filter in the node, to notify when a new block arrives.
258    /// To check if the state has changed, call `eth_getFilterChanges`.
259    #[serde(rename = "eth_newBlockFilter", with = "empty_params")]
260    EthNewBlockFilter(()),
261
262    /// Creates a filter in the node, to notify when new pending transactions arrive.
263    /// To check if the state has changed, call `eth_getFilterChanges`.
264    #[serde(rename = "eth_newPendingTransactionFilter", with = "empty_params")]
265    EthNewPendingTransactionFilter(()),
266
267    /// Returns an array of all logs matching filter with given id.
268    #[serde(rename = "eth_getFilterLogs", with = "sequence")]
269    EthGetFilterLogs(String),
270
271    /// Removes the filter, returns true if the filter was installed
272    #[serde(rename = "eth_uninstallFilter", with = "sequence")]
273    EthUninstallFilter(String),
274
275    #[serde(rename = "eth_getWork", with = "empty_params")]
276    EthGetWork(()),
277
278    #[serde(rename = "eth_submitWork")]
279    EthSubmitWork(B64, B256, B256),
280
281    #[serde(rename = "eth_submitHashrate")]
282    EthSubmitHashRate(U256, B256),
283
284    #[serde(rename = "eth_feeHistory")]
285    EthFeeHistory(
286        #[serde(deserialize_with = "deserialize_number")] U256,
287        BlockNumber,
288        #[serde(default)] Vec<f64>,
289    ),
290
291    #[serde(rename = "eth_syncing", with = "empty_params")]
292    EthSyncing(()),
293
294    #[serde(rename = "eth_config", with = "empty_params")]
295    EthConfig(()),
296
297    /// geth's `debug_getRawTransaction`  endpoint
298    #[serde(rename = "debug_getRawTransaction", with = "sequence")]
299    DebugGetRawTransaction(TxHash),
300
301    /// geth's `debug_traceTransaction`  endpoint
302    #[serde(rename = "debug_traceTransaction")]
303    DebugTraceTransaction(B256, #[serde(default)] GethDebugTracingOptions),
304
305    /// geth's `debug_traceCall`  endpoint
306    #[serde(rename = "debug_traceCall")]
307    DebugTraceCall(
308        WithOtherFields<TransactionRequest>,
309        #[serde(default)] Option<BlockId>,
310        #[serde(default)] GethDebugTracingCallOptions,
311    ),
312
313    /// reth's `debug_codeByHash` endpoint
314    #[serde(rename = "debug_codeByHash")]
315    DebugCodeByHash(B256, #[serde(default)] Option<BlockId>),
316
317    /// reth's `debug_dbGet` endpoint
318    #[serde(rename = "debug_dbGet")]
319    DebugDbGet(String),
320
321    /// Trace transaction endpoint for parity's `trace_transaction`
322    #[serde(rename = "trace_transaction", with = "sequence")]
323    TraceTransaction(B256),
324
325    /// Trace transaction endpoint for parity's `trace_block`
326    #[serde(
327        rename = "trace_block",
328        deserialize_with = "lenient_block_number::lenient_block_number_seq"
329    )]
330    TraceBlock(BlockNumber),
331
332    // Return filtered traces over blocks
333    #[serde(rename = "trace_filter", with = "sequence")]
334    TraceFilter(TraceFilter),
335
336    /// Trace transaction endpoint for parity's `trace_replayBlockTransactions`
337    #[serde(rename = "trace_replayBlockTransactions")]
338    TraceReplayBlockTransactions(
339        #[serde(deserialize_with = "lenient_block_number::lenient_block_number")] BlockNumber,
340        HashSet<TraceType>,
341    ),
342
343    // Custom endpoints, they're not extracted to a separate type out of serde convenience
344    /// send transactions impersonating specific account and contract addresses.
345    #[serde(
346        rename = "anvil_impersonateAccount",
347        alias = "hardhat_impersonateAccount",
348        with = "sequence"
349    )]
350    ImpersonateAccount(Address),
351    /// Stops impersonating an account if previously set with `anvil_impersonateAccount`
352    #[serde(
353        rename = "anvil_stopImpersonatingAccount",
354        alias = "hardhat_stopImpersonatingAccount",
355        with = "sequence"
356    )]
357    StopImpersonatingAccount(Address),
358    /// Will make every account impersonated
359    #[serde(
360        rename = "anvil_autoImpersonateAccount",
361        alias = "hardhat_autoImpersonateAccount",
362        with = "sequence"
363    )]
364    AutoImpersonateAccount(bool),
365
366    /// Registers a signature/address pair for faking `ecrecover` results
367    #[serde(rename = "anvil_impersonateSignature", with = "sequence")]
368    ImpersonateSignature(Bytes, Address),
369
370    /// Returns true if automatic mining is enabled, and false.
371    #[serde(rename = "anvil_getAutomine", alias = "hardhat_getAutomine", with = "empty_params")]
372    GetAutoMine(()),
373    /// Mines a series of blocks
374    #[serde(rename = "anvil_mine", alias = "hardhat_mine")]
375    Mine(
376        /// Number of blocks to mine, if not set `1` block is mined
377        #[serde(default, deserialize_with = "deserialize_number_opt")]
378        Option<U256>,
379        /// The time interval between each block in seconds, defaults to `1` seconds
380        /// The interval is applied only to blocks mined in the given method invocation, not to
381        /// blocks mined afterwards. Set this to `0` to instantly mine _all_ blocks
382        #[serde(default, deserialize_with = "deserialize_number_opt")]
383        Option<U256>,
384    ),
385
386    /// Enables or disables, based on the single boolean argument, the automatic mining of new
387    /// blocks with each new transaction submitted to the network.
388    #[serde(rename = "anvil_setAutomine", alias = "evm_setAutomine", with = "sequence")]
389    SetAutomine(bool),
390
391    /// Sets the mining behavior to interval with the given interval (seconds)
392    #[serde(rename = "anvil_setIntervalMining", alias = "evm_setIntervalMining", with = "sequence")]
393    SetIntervalMining(u64),
394
395    /// Gets the current mining behavior
396    #[serde(rename = "anvil_getIntervalMining", with = "empty_params")]
397    GetIntervalMining(()),
398
399    /// Removes transactions from the pool
400    #[serde(rename = "anvil_dropTransaction", alias = "hardhat_dropTransaction", with = "sequence")]
401    DropTransaction(B256),
402
403    /// Removes transactions from the pool
404    #[serde(
405        rename = "anvil_dropAllTransactions",
406        alias = "hardhat_dropAllTransactions",
407        with = "empty_params"
408    )]
409    DropAllTransactions(),
410
411    /// Reset the fork to a fresh forked state, and optionally update the fork config
412    #[serde(rename = "anvil_reset", alias = "hardhat_reset")]
413    Reset(#[serde(default)] Option<Params<Option<Forking>>>),
414
415    /// Sets the backend rpc url
416    #[serde(rename = "anvil_setRpcUrl", with = "sequence")]
417    SetRpcUrl(String),
418
419    /// Modifies the balance of an account.
420    #[serde(
421        rename = "anvil_setBalance",
422        alias = "hardhat_setBalance",
423        alias = "tenderly_setBalance"
424    )]
425    SetBalance(Address, #[serde(deserialize_with = "deserialize_number")] U256),
426
427    /// Increases the balance of an account.
428    #[serde(
429        rename = "anvil_addBalance",
430        alias = "hardhat_addBalance",
431        alias = "tenderly_addBalance"
432    )]
433    AddBalance(Address, #[serde(deserialize_with = "deserialize_number")] U256),
434
435    /// Modifies the ERC20 balance of an account.
436    #[serde(
437        rename = "anvil_dealERC20",
438        alias = "hardhat_dealERC20",
439        alias = "anvil_setERC20Balance"
440    )]
441    DealERC20(Address, Address, #[serde(deserialize_with = "deserialize_number")] U256),
442
443    /// Sets the ERC20 allowance for a spender
444    #[serde(rename = "anvil_setERC20Allowance")]
445    SetERC20Allowance(
446        Address,
447        Address,
448        Address,
449        #[serde(deserialize_with = "deserialize_number")] U256,
450    ),
451
452    /// Sets the code of a contract
453    #[serde(rename = "anvil_setCode", alias = "hardhat_setCode")]
454    SetCode(Address, Bytes),
455
456    /// Sets the nonce of an address
457    #[serde(rename = "anvil_setNonce", alias = "hardhat_setNonce", alias = "evm_setAccountNonce")]
458    SetNonce(Address, #[serde(deserialize_with = "deserialize_number")] U256),
459
460    /// Writes a single slot of the account's storage
461    #[serde(rename = "anvil_setStorageAt", alias = "hardhat_setStorageAt")]
462    SetStorageAt(
463        Address,
464        /// slot
465        U256,
466        /// value
467        B256,
468    ),
469
470    /// Sets the coinbase address
471    #[serde(rename = "anvil_setCoinbase", alias = "hardhat_setCoinbase", with = "sequence")]
472    SetCoinbase(Address),
473
474    /// Sets the chain id
475    #[serde(rename = "anvil_setChainId", with = "sequence")]
476    SetChainId(u64),
477
478    /// Enable or disable logging
479    #[serde(
480        rename = "anvil_setLoggingEnabled",
481        alias = "hardhat_setLoggingEnabled",
482        with = "sequence"
483    )]
484    SetLogging(bool),
485
486    /// Set the minimum gas price for the node
487    #[serde(
488        rename = "anvil_setMinGasPrice",
489        alias = "hardhat_setMinGasPrice",
490        deserialize_with = "deserialize_number_seq"
491    )]
492    SetMinGasPrice(U256),
493
494    /// Sets the base fee of the next block
495    #[serde(
496        rename = "anvil_setNextBlockBaseFeePerGas",
497        alias = "hardhat_setNextBlockBaseFeePerGas",
498        deserialize_with = "deserialize_number_seq"
499    )]
500    SetNextBlockBaseFeePerGas(U256),
501
502    /// Sets the specific timestamp
503    /// Accepts timestamp (Unix epoch) with millisecond precision and returns the number of seconds
504    /// between the given timestamp and the current time.
505    #[serde(
506        rename = "anvil_setTime",
507        alias = "evm_setTime",
508        deserialize_with = "deserialize_number_seq"
509    )]
510    EvmSetTime(U256),
511
512    /// Serializes the current state (including contracts code, contract's storage, accounts
513    /// properties, etc.) into a saveable data blob
514    #[serde(rename = "anvil_dumpState", alias = "hardhat_dumpState")]
515    DumpState(#[serde(default)] Option<Params<Option<bool>>>),
516
517    /// Adds state previously dumped with `DumpState` to the current chain
518    #[serde(rename = "anvil_loadState", alias = "hardhat_loadState", with = "sequence")]
519    LoadState(Bytes),
520
521    /// Retrieves the Anvil node configuration params
522    #[serde(rename = "anvil_nodeInfo", with = "empty_params")]
523    NodeInfo(()),
524
525    /// Retrieves the Anvil node metadata.
526    #[serde(rename = "anvil_metadata", alias = "hardhat_metadata", with = "empty_params")]
527    AnvilMetadata(()),
528
529    // Ganache compatible calls
530    /// Snapshot the state of the blockchain at the current block.
531    ///
532    /// Ref <https://github.com/trufflesuite/ganache/blob/ef1858d5d6f27e4baeb75cccd57fb3dc77a45ae8/src/chains/ethereum/ethereum/RPC-METHODS.md#evm_snapshot>
533    #[serde(rename = "anvil_snapshot", alias = "evm_snapshot", with = "empty_params")]
534    EvmSnapshot(()),
535
536    /// Revert the state of the blockchain to a previous snapshot.
537    /// Takes a single parameter, which is the snapshot id to revert to.
538    ///
539    /// Ref <https://github.com/trufflesuite/ganache/blob/ef1858d5d6f27e4baeb75cccd57fb3dc77a45ae8/src/chains/ethereum/ethereum/RPC-METHODS.md#evm_revert>
540    #[serde(
541        rename = "anvil_revert",
542        alias = "evm_revert",
543        deserialize_with = "deserialize_number_seq"
544    )]
545    EvmRevert(U256),
546
547    /// Jump forward in time by the given amount of time, in seconds.
548    #[serde(
549        rename = "anvil_increaseTime",
550        alias = "evm_increaseTime",
551        deserialize_with = "deserialize_number_seq"
552    )]
553    EvmIncreaseTime(U256),
554
555    /// Similar to `evm_increaseTime` but takes the exact timestamp that you want in the next block
556    #[serde(
557        rename = "anvil_setNextBlockTimestamp",
558        alias = "evm_setNextBlockTimestamp",
559        deserialize_with = "deserialize_number_seq"
560    )]
561    EvmSetNextBlockTimeStamp(U256),
562
563    /// Set the exact gas limit that you want in the next block
564    #[serde(
565        rename = "anvil_setBlockGasLimit",
566        alias = "evm_setBlockGasLimit",
567        deserialize_with = "deserialize_number_seq"
568    )]
569    EvmSetBlockGasLimit(U256),
570
571    /// Similar to `evm_increaseTime` but takes sets a block timestamp `interval`.
572    ///
573    /// The timestamp of the next block will be computed as `lastBlock_timestamp + interval`.
574    #[serde(rename = "anvil_setBlockTimestampInterval", with = "sequence")]
575    EvmSetBlockTimeStampInterval(u64),
576
577    /// Removes a `anvil_setBlockTimestampInterval` if it exists
578    #[serde(rename = "anvil_removeBlockTimestampInterval", with = "empty_params")]
579    EvmRemoveBlockTimeStampInterval(()),
580
581    /// Mine a single block
582    #[serde(rename = "evm_mine")]
583    EvmMine(#[serde(default)] Option<Params<Option<MineOptions>>>),
584
585    /// Mine a single block and return detailed data
586    ///
587    /// This behaves exactly as `EvmMine` but returns different output, for compatibility reasons
588    /// this is a separate call since `evm_mine` is not an anvil original.
589    #[serde(rename = "anvil_mine_detailed", alias = "evm_mine_detailed")]
590    EvmMineDetailed(#[serde(default)] Option<Params<Option<MineOptions>>>),
591
592    /// Execute a transaction regardless of signature status
593    #[serde(rename = "eth_sendUnsignedTransaction", with = "sequence")]
594    EthSendUnsignedTransaction(Box<WithOtherFields<TransactionRequest>>),
595
596    /// Returns the number of transactions currently pending for inclusion in the next block(s), as
597    /// well as the ones that are being scheduled for future execution only.
598    /// Ref: <https://geth.ethereum.org/docs/rpc/ns-txpool#txpool_status>
599    #[serde(rename = "txpool_status", with = "empty_params")]
600    TxPoolStatus(()),
601
602    /// Returns a summary of all the transactions currently pending for inclusion in the next
603    /// block(s), as well as the ones that are being scheduled for future execution only.
604    /// Ref: <https://geth.ethereum.org/docs/rpc/ns-txpool#txpool_inspect>
605    #[serde(rename = "txpool_inspect", with = "empty_params")]
606    TxPoolInspect(()),
607
608    /// Returns the details of all transactions currently pending for inclusion in the next
609    /// block(s), as well as the ones that are being scheduled for future execution only.
610    /// Ref: <https://geth.ethereum.org/docs/rpc/ns-txpool#txpool_content>
611    #[serde(rename = "txpool_content", with = "empty_params")]
612    TxPoolContent(()),
613
614    /// Otterscan's `ots_getApiLevel` endpoint
615    /// Otterscan currently requires this endpoint, even though it's not part of the ots_*
616    /// <https://github.com/otterscan/otterscan/blob/071d8c55202badf01804f6f8d53ef9311d4a9e47/src/useProvider.ts#L71>
617    /// Related upstream issue: <https://github.com/otterscan/otterscan/issues/1081>
618    #[serde(rename = "erigon_getHeaderByNumber")]
619    ErigonGetHeaderByNumber(
620        #[serde(deserialize_with = "lenient_block_number::lenient_block_number_seq")] BlockNumber,
621    ),
622
623    /// Otterscan's `ots_getApiLevel` endpoint
624    /// Used as a simple API versioning scheme for the ots_* namespace
625    #[serde(rename = "ots_getApiLevel", with = "empty_params")]
626    OtsGetApiLevel(()),
627
628    /// Otterscan's `ots_getInternalOperations` endpoint
629    /// Traces internal ETH transfers, contracts creation (CREATE/CREATE2) and self-destructs for a
630    /// certain transaction.
631    #[serde(rename = "ots_getInternalOperations", with = "sequence")]
632    OtsGetInternalOperations(B256),
633
634    /// Otterscan's `ots_hasCode` endpoint
635    /// Check if an ETH address contains code at a certain block number.
636    #[serde(rename = "ots_hasCode")]
637    OtsHasCode(
638        Address,
639        #[serde(deserialize_with = "lenient_block_number::lenient_block_number", default)]
640        BlockNumber,
641    ),
642
643    /// Otterscan's `ots_traceTransaction` endpoint
644    /// Trace a transaction and generate a trace call tree.
645    #[serde(rename = "ots_traceTransaction", with = "sequence")]
646    OtsTraceTransaction(B256),
647
648    /// Otterscan's `ots_getTransactionError` endpoint
649    /// Given a transaction hash, returns its raw revert reason.
650    #[serde(rename = "ots_getTransactionError", with = "sequence")]
651    OtsGetTransactionError(B256),
652
653    /// Otterscan's `ots_getBlockDetails` endpoint
654    /// Given a block number, return its data. Similar to the standard eth_getBlockByNumber/Hash
655    /// method, but can be optimized by excluding unnecessary data such as transactions and
656    /// logBloom
657    #[serde(rename = "ots_getBlockDetails")]
658    OtsGetBlockDetails(
659        #[serde(deserialize_with = "lenient_block_number::lenient_block_number_seq", default)]
660        BlockNumber,
661    ),
662
663    /// Otterscan's `ots_getBlockDetails` endpoint
664    /// Same as `ots_getBlockDetails`, but receiving a block hash instead of number
665    #[serde(rename = "ots_getBlockDetailsByHash", with = "sequence")]
666    OtsGetBlockDetailsByHash(B256),
667
668    /// Otterscan's `ots_getBlockTransactions` endpoint
669    /// Gets paginated transaction data for a certain block. Return data is similar to
670    /// eth_getBlockBy* + eth_getTransactionReceipt.
671    #[serde(rename = "ots_getBlockTransactions")]
672    OtsGetBlockTransactions(u64, usize, usize),
673
674    /// Otterscan's `ots_searchTransactionsBefore` endpoint
675    /// Address history navigation. searches backwards from certain point in time.
676    #[serde(rename = "ots_searchTransactionsBefore")]
677    OtsSearchTransactionsBefore(Address, u64, usize),
678
679    /// Otterscan's `ots_searchTransactionsAfter` endpoint
680    /// Address history navigation. searches forward from certain point in time.
681    #[serde(rename = "ots_searchTransactionsAfter")]
682    OtsSearchTransactionsAfter(Address, u64, usize),
683
684    /// Otterscan's `ots_getTransactionBySenderAndNonce` endpoint
685    /// Given a sender address and a nonce, returns the tx hash or null if not found. It returns
686    /// only the tx hash on success, you can use the standard eth_getTransactionByHash after that
687    /// to get the full transaction data.
688    #[serde(rename = "ots_getTransactionBySenderAndNonce")]
689    OtsGetTransactionBySenderAndNonce(
690        Address,
691        #[serde(deserialize_with = "deserialize_number")] U256,
692    ),
693
694    /// Returns the transaction by sender and nonce
695    /// Returns the full transaction data.
696    #[serde(rename = "eth_getTransactionBySenderAndNonce")]
697    EthGetTransactionBySenderAndNonce(
698        Address,
699        #[serde(deserialize_with = "deserialize_number")] U256,
700    ),
701
702    /// Otterscan's `ots_getTransactionBySenderAndNonce` endpoint
703    /// Given an ETH contract address, returns the tx hash and the direct address who created the
704    /// contract.
705    #[serde(rename = "ots_getContractCreator", with = "sequence")]
706    OtsGetContractCreator(Address),
707
708    /// Removes transactions from the pool by sender origin.
709    #[serde(rename = "anvil_removePoolTransactions", with = "sequence")]
710    RemovePoolTransactions(Address),
711
712    /// Reorg the chain
713    #[serde(rename = "anvil_reorg")]
714    Reorg(ReorgOptions),
715
716    /// Rollback the chain
717    #[serde(rename = "anvil_rollback", with = "sequence")]
718    Rollback(Option<u64>),
719}
720
721/// Represents ethereum JSON-RPC API
722#[derive(Clone, Debug, PartialEq, Eq, serde::Deserialize)]
723#[serde(tag = "method", content = "params")]
724pub enum EthPubSub {
725    /// Subscribe to an eth subscription
726    #[serde(rename = "eth_subscribe")]
727    EthSubscribe(SubscriptionKind, #[serde(default)] Box<SubscriptionParams>),
728
729    /// Unsubscribe from an eth subscription
730    #[serde(rename = "eth_unsubscribe", with = "sequence")]
731    EthUnSubscribe(SubscriptionId),
732}
733
734/// Container type for either a request or a pub sub
735#[derive(Clone, Debug, serde::Deserialize)]
736#[serde(untagged)]
737pub enum EthRpcCall {
738    Request(Box<EthRequest>),
739    PubSub(EthPubSub),
740}
741
742#[cfg(test)]
743mod tests {
744    use super::*;
745
746    #[test]
747    fn test_web3_client_version() {
748        let s = r#"{"method": "web3_clientVersion", "params":[]}"#;
749        let value: serde_json::Value = serde_json::from_str(s).unwrap();
750        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
751    }
752
753    #[test]
754    fn test_web3_sha3() {
755        let s = r#"{"method": "web3_sha3", "params":["0x68656c6c6f20776f726c64"]}"#;
756        let value: serde_json::Value = serde_json::from_str(s).unwrap();
757        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
758    }
759
760    #[test]
761    fn test_eth_accounts() {
762        let s = r#"{"method": "eth_accounts", "params":[]}"#;
763        let value: serde_json::Value = serde_json::from_str(s).unwrap();
764        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
765    }
766
767    #[test]
768    fn test_eth_network_id() {
769        let s = r#"{"method": "eth_networkId", "params":[]}"#;
770        let value: serde_json::Value = serde_json::from_str(s).unwrap();
771        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
772    }
773
774    #[test]
775    fn test_eth_get_proof() {
776        let s = r#"{"method":"eth_getProof","params":["0x7F0d15C7FAae65896648C8273B6d7E43f58Fa842",["0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421"],"latest"]}"#;
777        let value: serde_json::Value = serde_json::from_str(s).unwrap();
778        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
779    }
780
781    #[test]
782    fn test_eth_chain_id() {
783        let s = r#"{"method": "eth_chainId", "params":[]}"#;
784        let value: serde_json::Value = serde_json::from_str(s).unwrap();
785        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
786    }
787
788    #[test]
789    fn test_net_listening() {
790        let s = r#"{"method": "net_listening", "params":[]}"#;
791        let value: serde_json::Value = serde_json::from_str(s).unwrap();
792        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
793    }
794
795    #[test]
796    fn test_eth_block_number() {
797        let s = r#"{"method": "eth_blockNumber", "params":[]}"#;
798        let value: serde_json::Value = serde_json::from_str(s).unwrap();
799        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
800    }
801
802    #[test]
803    fn test_eth_max_priority_fee() {
804        let s = r#"{"method": "eth_maxPriorityFeePerGas", "params":[]}"#;
805        let value: serde_json::Value = serde_json::from_str(s).unwrap();
806        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
807    }
808
809    #[test]
810    fn test_eth_syncing() {
811        let s = r#"{"method": "eth_syncing", "params":[]}"#;
812        let value: serde_json::Value = serde_json::from_str(s).unwrap();
813        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
814    }
815
816    #[test]
817    fn test_custom_impersonate_account() {
818        let s = r#"{"method": "anvil_impersonateAccount", "params":
819["0xd84de507f3fada7df80908082d3239466db55a71"]}"#;
820        let value: serde_json::Value = serde_json::from_str(s).unwrap();
821        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
822    }
823
824    #[test]
825    fn test_custom_stop_impersonate_account() {
826        let s = r#"{"method": "anvil_stopImpersonatingAccount",  "params":
827["0x364d6D0333432C3Ac016Ca832fb8594A8cE43Ca6"]}"#;
828        let value: serde_json::Value = serde_json::from_str(s).unwrap();
829        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
830    }
831
832    #[test]
833    fn test_custom_auto_impersonate_account() {
834        let s = r#"{"method": "anvil_autoImpersonateAccount",  "params": [true]}"#;
835        let value: serde_json::Value = serde_json::from_str(s).unwrap();
836        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
837    }
838
839    #[test]
840    fn test_custom_get_automine() {
841        let s = r#"{"method": "anvil_getAutomine", "params": []}"#;
842        let value: serde_json::Value = serde_json::from_str(s).unwrap();
843        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
844    }
845
846    #[test]
847    fn test_custom_mine() {
848        let s = r#"{"method": "anvil_mine", "params": []}"#;
849        let value: serde_json::Value = serde_json::from_str(s).unwrap();
850        let req = serde_json::from_value::<EthRequest>(value).unwrap();
851        match req {
852            EthRequest::Mine(num, time) => {
853                assert!(num.is_none());
854                assert!(time.is_none());
855            }
856            _ => unreachable!(),
857        }
858        let s = r#"{"method": "anvil_mine", "params":
859["0xd84de507f3fada7df80908082d3239466db55a71"]}"#;
860        let value: serde_json::Value = serde_json::from_str(s).unwrap();
861        let req = serde_json::from_value::<EthRequest>(value).unwrap();
862        match req {
863            EthRequest::Mine(num, time) => {
864                assert!(num.is_some());
865                assert!(time.is_none());
866            }
867            _ => unreachable!(),
868        }
869        let s = r#"{"method": "anvil_mine", "params": ["0xd84de507f3fada7df80908082d3239466db55a71", "0xd84de507f3fada7df80908082d3239466db55a71"]}"#;
870        let value: serde_json::Value = serde_json::from_str(s).unwrap();
871        let req = serde_json::from_value::<EthRequest>(value).unwrap();
872        match req {
873            EthRequest::Mine(num, time) => {
874                assert!(num.is_some());
875                assert!(time.is_some());
876            }
877            _ => unreachable!(),
878        }
879    }
880
881    #[test]
882    fn test_custom_auto_mine() {
883        let s = r#"{"method": "anvil_setAutomine", "params": [false]}"#;
884        let value: serde_json::Value = serde_json::from_str(s).unwrap();
885        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
886        let s = r#"{"method": "evm_setAutomine", "params": [false]}"#;
887        let value: serde_json::Value = serde_json::from_str(s).unwrap();
888        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
889    }
890
891    #[test]
892    fn test_custom_interval_mining() {
893        let s = r#"{"method": "anvil_setIntervalMining", "params": [100]}"#;
894        let value: serde_json::Value = serde_json::from_str(s).unwrap();
895        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
896        let s = r#"{"method": "evm_setIntervalMining", "params": [100]}"#;
897        let value: serde_json::Value = serde_json::from_str(s).unwrap();
898        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
899    }
900
901    #[test]
902    fn test_custom_drop_tx() {
903        let s = r#"{"method": "anvil_dropTransaction", "params":
904["0x4a3b0fce2cb9707b0baa68640cf2fe858c8bb4121b2a8cb904ff369d38a560ff"]}"#;
905        let value: serde_json::Value = serde_json::from_str(s).unwrap();
906        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
907    }
908
909    #[test]
910    fn test_custom_reset() {
911        let s = r#"{"method": "anvil_reset", "params": [{"forking": {"jsonRpcUrl": "https://ethereumpublicnode.com",
912        "blockNumber": "18441649"
913      }
914    }]}"#;
915        let value: serde_json::Value = serde_json::from_str(s).unwrap();
916        let req = serde_json::from_value::<EthRequest>(value).unwrap();
917        match req {
918            EthRequest::Reset(forking) => {
919                let forking = forking.and_then(|f| f.params);
920                assert_eq!(
921                    forking,
922                    Some(Forking {
923                        json_rpc_url: Some("https://ethereumpublicnode.com".into()),
924                        block_number: Some(18441649)
925                    })
926                )
927            }
928            _ => unreachable!(),
929        }
930
931        let s = r#"{"method": "anvil_reset", "params": [ { "forking": {
932                "jsonRpcUrl": "https://eth-mainnet.alchemyapi.io/v2/<key>",
933                "blockNumber": 11095000
934        }}]}"#;
935        let value: serde_json::Value = serde_json::from_str(s).unwrap();
936        let req = serde_json::from_value::<EthRequest>(value).unwrap();
937        match req {
938            EthRequest::Reset(forking) => {
939                let forking = forking.and_then(|f| f.params);
940                assert_eq!(
941                    forking,
942                    Some(Forking {
943                        json_rpc_url: Some(
944                            "https://eth-mainnet.alchemyapi.io/v2/<key>".to_string()
945                        ),
946                        block_number: Some(11095000)
947                    })
948                )
949            }
950            _ => unreachable!(),
951        }
952
953        let s = r#"{"method": "anvil_reset", "params": [ { "forking": {
954                "jsonRpcUrl": "https://eth-mainnet.alchemyapi.io/v2/<key>"
955        }}]}"#;
956        let value: serde_json::Value = serde_json::from_str(s).unwrap();
957        let req = serde_json::from_value::<EthRequest>(value).unwrap();
958        match req {
959            EthRequest::Reset(forking) => {
960                let forking = forking.and_then(|f| f.params);
961                assert_eq!(
962                    forking,
963                    Some(Forking {
964                        json_rpc_url: Some(
965                            "https://eth-mainnet.alchemyapi.io/v2/<key>".to_string()
966                        ),
967                        block_number: None
968                    })
969                )
970            }
971            _ => unreachable!(),
972        }
973
974        let s = r#"{"method":"anvil_reset","params":[{"jsonRpcUrl": "http://localhost:8545", "blockNumber": 14000000}]}"#;
975        let value: serde_json::Value = serde_json::from_str(s).unwrap();
976        let req = serde_json::from_value::<EthRequest>(value).unwrap();
977        match req {
978            EthRequest::Reset(forking) => {
979                let forking = forking.and_then(|f| f.params);
980                assert_eq!(
981                    forking,
982                    Some(Forking {
983                        json_rpc_url: Some("http://localhost:8545".to_string()),
984                        block_number: Some(14000000)
985                    })
986                )
987            }
988            _ => unreachable!(),
989        }
990
991        let s = r#"{"method":"anvil_reset","params":[{ "blockNumber": 14000000}]}"#;
992        let value: serde_json::Value = serde_json::from_str(s).unwrap();
993        let req = serde_json::from_value::<EthRequest>(value).unwrap();
994        match req {
995            EthRequest::Reset(forking) => {
996                let forking = forking.and_then(|f| f.params);
997                assert_eq!(
998                    forking,
999                    Some(Forking { json_rpc_url: None, block_number: Some(14000000) })
1000                )
1001            }
1002            _ => unreachable!(),
1003        }
1004
1005        let s = r#"{"method":"anvil_reset","params":[{ "blockNumber": "14000000"}]}"#;
1006        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1007        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1008        match req {
1009            EthRequest::Reset(forking) => {
1010                let forking = forking.and_then(|f| f.params);
1011                assert_eq!(
1012                    forking,
1013                    Some(Forking { json_rpc_url: None, block_number: Some(14000000) })
1014                )
1015            }
1016            _ => unreachable!(),
1017        }
1018
1019        let s = r#"{"method":"anvil_reset","params":[{"jsonRpcUrl": "http://localhost:8545"}]}"#;
1020        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1021        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1022        match req {
1023            EthRequest::Reset(forking) => {
1024                let forking = forking.and_then(|f| f.params);
1025                assert_eq!(
1026                    forking,
1027                    Some(Forking {
1028                        json_rpc_url: Some("http://localhost:8545".to_string()),
1029                        block_number: None
1030                    })
1031                )
1032            }
1033            _ => unreachable!(),
1034        }
1035
1036        let s = r#"{"method": "anvil_reset"}"#;
1037        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1038        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1039        match req {
1040            EthRequest::Reset(forking) => {
1041                assert!(forking.is_none())
1042            }
1043            _ => unreachable!(),
1044        }
1045    }
1046
1047    #[test]
1048    fn test_custom_set_balance() {
1049        let s = r#"{"method": "anvil_setBalance", "params":
1050["0xd84de507f3fada7df80908082d3239466db55a71", "0x0"]}"#;
1051        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1052        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1053
1054        let s = r#"{"method": "anvil_setBalance", "params":
1055["0xd84de507f3fada7df80908082d3239466db55a71", 1337]}"#;
1056        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1057        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1058    }
1059
1060    #[test]
1061    fn test_custom_set_code() {
1062        let s = r#"{"method": "anvil_setCode", "params":
1063["0xd84de507f3fada7df80908082d3239466db55a71", "0x0123456789abcdef"]}"#;
1064        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1065        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1066
1067        let s = r#"{"method": "anvil_setCode", "params":
1068["0xd84de507f3fada7df80908082d3239466db55a71", "0x"]}"#;
1069        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1070        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1071
1072        let s = r#"{"method": "anvil_setCode", "params":
1073["0xd84de507f3fada7df80908082d3239466db55a71", ""]}"#;
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_set_nonce() {
1080        let s = r#"{"method": "anvil_setNonce", "params":
1081["0xd84de507f3fada7df80908082d3239466db55a71", "0x0"]}"#;
1082        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1083        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1084        let s = r#"{"method":
1085"hardhat_setNonce", "params": ["0xd84de507f3fada7df80908082d3239466db55a71", "0x0"]}"#;
1086        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1087        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1088        let s = r#"{"method": "evm_setAccountNonce", "params":
1089["0xd84de507f3fada7df80908082d3239466db55a71", "0x0"]}"#;
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_serde_custom_set_storage_at() {
1096        let s = r#"{"method": "anvil_setStorageAt", "params":
1097["0x295a70b2de5e3953354a6a8344e616ed314d7251", "0x0",
1098"0x0000000000000000000000000000000000000000000000000000000000003039"]}"#;
1099        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1100        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1101
1102        let s = r#"{"method": "hardhat_setStorageAt", "params":
1103["0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56",
1104"0xa6eef7e35abe7026729641147f7915573c7e97b47efa546f5f6e3230263bcb49",
1105"0x0000000000000000000000000000000000000000000000000000000000003039"]}"#;
1106        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1107        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1108    }
1109
1110    #[test]
1111    fn test_serde_custom_coinbase() {
1112        let s = r#"{"method": "anvil_setCoinbase", "params":
1113["0x295a70b2de5e3953354a6a8344e616ed314d7251"]}"#;
1114        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1115        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1116    }
1117
1118    #[test]
1119    fn test_serde_custom_logging() {
1120        let s = r#"{"method": "anvil_setLoggingEnabled", "params": [false]}"#;
1121        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1122        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1123    }
1124
1125    #[test]
1126    fn test_serde_custom_min_gas_price() {
1127        let s = r#"{"method": "anvil_setMinGasPrice", "params": ["0x0"]}"#;
1128        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1129        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1130    }
1131
1132    #[test]
1133    fn test_serde_custom_next_block_base_fee() {
1134        let s = r#"{"method": "anvil_setNextBlockBaseFeePerGas", "params": ["0x0"]}"#;
1135        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1136        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1137    }
1138
1139    #[test]
1140    fn test_serde_set_time() {
1141        let s = r#"{"method": "anvil_setTime", "params": ["0x0"]}"#;
1142        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1143        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1144
1145        let s = r#"{"method": "anvil_increaseTime", "params": 1}"#;
1146        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1147        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1148    }
1149
1150    #[test]
1151    fn test_serde_custom_dump_state() {
1152        let s = r#"{"method": "anvil_dumpState", "params": [true]}"#;
1153        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1154        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1155
1156        let s = r#"{"method": "anvil_dumpState"}"#;
1157        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1158        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1159        match req {
1160            EthRequest::DumpState(param) => {
1161                assert!(param.is_none());
1162            }
1163            _ => unreachable!(),
1164        }
1165    }
1166
1167    #[test]
1168    fn test_serde_custom_load_state() {
1169        let s = r#"{"method": "anvil_loadState", "params": ["0x0001"] }"#;
1170        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1171        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1172    }
1173
1174    #[test]
1175    fn test_serde_custom_snapshot() {
1176        let s = r#"{"method": "anvil_snapshot", "params": [] }"#;
1177        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1178        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1179
1180        let s = r#"{"method": "evm_snapshot", "params": [] }"#;
1181        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1182        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1183    }
1184
1185    #[test]
1186    fn test_serde_custom_revert() {
1187        let s = r#"{"method": "anvil_revert", "params": ["0x0"]}"#;
1188        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1189        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1190    }
1191
1192    #[test]
1193    fn test_serde_custom_increase_time() {
1194        let s = r#"{"method": "anvil_increaseTime", "params": ["0x0"]}"#;
1195        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1196        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1197
1198        let s = r#"{"method": "anvil_increaseTime", "params": [1]}"#;
1199        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1200        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1201
1202        let s = r#"{"method": "anvil_increaseTime", "params": 1}"#;
1203        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1204        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1205
1206        let s = r#"{"method": "evm_increaseTime", "params": ["0x0"]}"#;
1207        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1208        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1209
1210        let s = r#"{"method": "evm_increaseTime", "params": [1]}"#;
1211        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1212        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1213
1214        let s = r#"{"method": "evm_increaseTime", "params": 1}"#;
1215        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1216        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1217    }
1218
1219    #[test]
1220    fn test_serde_custom_next_timestamp() {
1221        let s = r#"{"method": "anvil_setNextBlockTimestamp", "params": [100]}"#;
1222        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1223        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1224        let s = r#"{"method": "evm_setNextBlockTimestamp", "params": [100]}"#;
1225        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1226        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1227        let s = r#"{"method": "evm_setNextBlockTimestamp", "params": ["0x64e0f308"]}"#;
1228        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1229        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1230    }
1231
1232    #[test]
1233    fn test_serde_custom_timestamp_interval() {
1234        let s = r#"{"method": "anvil_setBlockTimestampInterval", "params": [100]}"#;
1235        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1236        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1237    }
1238
1239    #[test]
1240    fn test_serde_custom_remove_timestamp_interval() {
1241        let s = r#"{"method": "anvil_removeBlockTimestampInterval", "params": []}"#;
1242        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1243        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1244    }
1245
1246    #[test]
1247    fn test_serde_custom_evm_mine() {
1248        let s = r#"{"method": "evm_mine", "params": [100]}"#;
1249        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1250        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1251        let s = r#"{"method": "evm_mine", "params": [{
1252            "timestamp": 100,
1253            "blocks": 100
1254        }]}"#;
1255        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1256        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1257        match req {
1258            EthRequest::EvmMine(params) => {
1259                assert_eq!(
1260                    params.unwrap().params.unwrap_or_default(),
1261                    MineOptions::Options { timestamp: Some(100), blocks: Some(100) }
1262                )
1263            }
1264            _ => unreachable!(),
1265        }
1266
1267        let s = r#"{"method": "evm_mine"}"#;
1268        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1269        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1270
1271        match req {
1272            EthRequest::EvmMine(params) => {
1273                assert!(params.is_none())
1274            }
1275            _ => unreachable!(),
1276        }
1277
1278        let s = r#"{"method": "evm_mine", "params": []}"#;
1279        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1280        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1281    }
1282
1283    #[test]
1284    fn test_serde_custom_evm_mine_detailed() {
1285        let s = r#"{"method": "anvil_mine_detailed", "params": [100]}"#;
1286        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1287        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1288        let s = r#"{"method": "anvil_mine_detailed", "params": [{
1289            "timestamp": 100,
1290            "blocks": 100
1291        }]}"#;
1292        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1293        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1294        match req {
1295            EthRequest::EvmMineDetailed(params) => {
1296                assert_eq!(
1297                    params.unwrap().params.unwrap_or_default(),
1298                    MineOptions::Options { timestamp: Some(100), blocks: Some(100) }
1299                )
1300            }
1301            _ => unreachable!(),
1302        }
1303
1304        let s = r#"{"method": "evm_mine_detailed"}"#;
1305        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1306        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1307
1308        match req {
1309            EthRequest::EvmMineDetailed(params) => {
1310                assert!(params.is_none())
1311            }
1312            _ => unreachable!(),
1313        }
1314
1315        let s = r#"{"method": "anvil_mine_detailed", "params": []}"#;
1316        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1317        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1318    }
1319
1320    #[test]
1321    fn test_serde_custom_evm_mine_hex() {
1322        let s = r#"{"method": "evm_mine", "params": ["0x63b6ff08"]}"#;
1323        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1324        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1325        match req {
1326            EthRequest::EvmMine(params) => {
1327                assert_eq!(
1328                    params.unwrap().params.unwrap_or_default(),
1329                    MineOptions::Timestamp(Some(1672937224))
1330                )
1331            }
1332            _ => unreachable!(),
1333        }
1334
1335        let s = r#"{"method": "evm_mine", "params": [{"timestamp": "0x63b6ff08"}]}"#;
1336        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1337        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1338        match req {
1339            EthRequest::EvmMine(params) => {
1340                assert_eq!(
1341                    params.unwrap().params.unwrap_or_default(),
1342                    MineOptions::Options { timestamp: Some(1672937224), blocks: None }
1343                )
1344            }
1345            _ => unreachable!(),
1346        }
1347    }
1348
1349    #[test]
1350    fn test_eth_uncle_count_by_block_hash() {
1351        let s = r#"{"jsonrpc":"2.0","method":"eth_getUncleCountByBlockHash","params":["0x4a3b0fce2cb9707b0baa68640cf2fe858c8bb4121b2a8cb904ff369d38a560ff"]}"#;
1352        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1353        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1354    }
1355
1356    #[test]
1357    fn test_eth_block_tx_count_by_block_hash() {
1358        let s = r#"{"jsonrpc":"2.0","method":"eth_getBlockTransactionCountByHash","params":["0x4a3b0fce2cb9707b0baa68640cf2fe858c8bb4121b2a8cb904ff369d38a560ff"]}"#;
1359        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1360        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1361    }
1362
1363    #[test]
1364    fn test_eth_get_logs() {
1365        let s = r#"{"jsonrpc":"2.0","method":"eth_getLogs","params":[{"topics":["0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b"]}],"id":74}"#;
1366        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1367        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1368    }
1369
1370    #[test]
1371    fn test_eth_new_filter() {
1372        let s = r#"{"method": "eth_newFilter", "params": [{"topics":["0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b"]}],"id":73}"#;
1373        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1374        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1375    }
1376
1377    #[test]
1378    fn test_serde_eth_unsubscribe() {
1379        let s = r#"{"id": 1, "method": "eth_unsubscribe", "params":
1380["0x9cef478923ff08bf67fde6c64013158d"]}"#;
1381        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1382        let _req = serde_json::from_value::<EthPubSub>(value).unwrap();
1383    }
1384
1385    #[test]
1386    fn test_serde_eth_subscribe() {
1387        let s = r#"{"id": 1, "method": "eth_subscribe", "params": ["newHeads"]}"#;
1388        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1389        let _req = serde_json::from_value::<EthPubSub>(value).unwrap();
1390
1391        let s = r#"{"id": 1, "method": "eth_subscribe", "params": ["logs", {"address":
1392"0x8320fe7702b96808f7bbc0d4a888ed1468216cfd", "topics":
1393["0xd78a0cb8bb633d06981248b816e7bd33c2a35a6089241d099fa519e361cab902"]}]}"#;
1394        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1395        let _req = serde_json::from_value::<EthPubSub>(value).unwrap();
1396
1397        let s = r#"{"id": 1, "method": "eth_subscribe", "params": ["newPendingTransactions"]}"#;
1398        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1399        let _req = serde_json::from_value::<EthPubSub>(value).unwrap();
1400
1401        let s = r#"{"id": 1, "method": "eth_subscribe", "params": ["syncing"]}"#;
1402        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1403        let _req = serde_json::from_value::<EthPubSub>(value).unwrap();
1404    }
1405
1406    #[test]
1407    fn test_serde_debug_raw_transaction() {
1408        let s = r#"{"jsonrpc":"2.0","method":"debug_getRawTransaction","params":["0x3ed3a89bc10115a321aee238c02de214009f8532a65368e5df5eaf732ee7167c"],"id":1}"#;
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#"{"jsonrpc":"2.0","method":"eth_getRawTransactionByHash","params":["0x3ed3a89bc10115a321aee238c02de214009f8532a65368e5df5eaf732ee7167c"],"id":1}"#;
1413        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1414        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1415
1416        let s = r#"{"jsonrpc":"2.0","method":"eth_getRawTransactionByBlockHashAndIndex","params":["0x3ed3a89bc10115a321aee238c02de214009f8532a65368e5df5eaf732ee7167c",1],"id":1}"#;
1417        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1418        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1419
1420        let s = r#"{"jsonrpc":"2.0","method":"eth_getRawTransactionByBlockNumberAndIndex","params":["0x3ed3a89b",0],"id":1}"#;
1421        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1422        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1423    }
1424
1425    #[test]
1426    fn test_serde_debug_trace_transaction() {
1427        let s = r#"{"method": "debug_traceTransaction", "params":
1428["0x4a3b0fce2cb9707b0baa68640cf2fe858c8bb4121b2a8cb904ff369d38a560ff"]}"#;
1429        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1430        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1431
1432        let s = r#"{"method": "debug_traceTransaction", "params":
1433["0x4a3b0fce2cb9707b0baa68640cf2fe858c8bb4121b2a8cb904ff369d38a560ff", {}]}"#;
1434        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1435        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1436
1437        let s = r#"{"method": "debug_traceTransaction", "params":
1438["0x4a3b0fce2cb9707b0baa68640cf2fe858c8bb4121b2a8cb904ff369d38a560ff", {"disableStorage":
1439true}]}"#;
1440        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1441        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1442    }
1443
1444    #[test]
1445    fn test_serde_debug_trace_call() {
1446        let s = r#"{"method": "debug_traceCall", "params": [{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}]}"#;
1447        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1448        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1449
1450        let s = r#"{"method": "debug_traceCall", "params": [{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}, { "blockNumber": "latest" }]}"#;
1451        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1452        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1453
1454        let s = r#"{"method": "debug_traceCall", "params": [{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}, { "blockNumber": "0x0" }]}"#;
1455        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1456        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1457
1458        let s = r#"{"method": "debug_traceCall", "params": [{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}, { "blockHash": "0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3" }]}"#;
1459        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1460        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1461
1462        let s = r#"{"method": "debug_traceCall", "params": [{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}, { "blockNumber": "0x0" }, {"disableStorage": true}]}"#;
1463        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1464        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1465    }
1466
1467    #[test]
1468    fn test_serde_eth_storage() {
1469        let s = r#"{"method": "eth_getStorageAt", "params":
1470["0x295a70b2de5e3953354a6a8344e616ed314d7251", "0x0", "latest"]}"#;
1471        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1472        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1473    }
1474
1475    #[test]
1476    fn test_eth_call() {
1477        let req = r#"{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}"#;
1478        let _req = serde_json::from_str::<TransactionRequest>(req).unwrap();
1479
1480        let s = r#"{"method": "eth_call", "params":[{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"},"latest"]}"#;
1481        let _req = serde_json::from_str::<EthRequest>(s).unwrap();
1482
1483        let s = r#"{"method": "eth_call", "params":[{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}]}"#;
1484        let _req = serde_json::from_str::<EthRequest>(s).unwrap();
1485
1486        let s = r#"{"method": "eth_call", "params":[{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}, { "blockNumber": "latest" }]}"#;
1487        let _req = serde_json::from_str::<EthRequest>(s).unwrap();
1488
1489        let s = r#"{"method": "eth_call", "params":[{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}, { "blockNumber": "0x0" }]}"#;
1490        let _req = serde_json::from_str::<EthRequest>(s).unwrap();
1491
1492        let s = r#"{"method": "eth_call", "params":[{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}, { "blockHash":"0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3" }]}"#;
1493        let _req = serde_json::from_str::<EthRequest>(s).unwrap();
1494    }
1495
1496    #[test]
1497    fn test_serde_eth_balance() {
1498        let s = r#"{"method": "eth_getBalance", "params":
1499["0x295a70b2de5e3953354a6a8344e616ed314d7251", "latest"]}"#;
1500        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1501
1502        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1503    }
1504
1505    #[test]
1506    fn test_serde_eth_block_by_number() {
1507        let s = r#"{"method": "eth_getBlockByNumber", "params": ["0x0", true]}"#;
1508        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1509        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1510        let s = r#"{"method": "eth_getBlockByNumber", "params": ["latest", true]}"#;
1511        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1512        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1513        let s = r#"{"method": "eth_getBlockByNumber", "params": ["earliest", true]}"#;
1514        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1515        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1516        let s = r#"{"method": "eth_getBlockByNumber", "params": ["pending", true]}"#;
1517        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1518        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1519
1520        // this case deviates from the spec, but we're supporting this for legacy reasons: <https://github.com/foundry-rs/foundry/issues/1868>
1521        let s = r#"{"method": "eth_getBlockByNumber", "params": [0, true]}"#;
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_eth_sign() {
1528        let s = r#"{"method": "eth_sign", "params":
1529["0xd84de507f3fada7df80908082d3239466db55a71", "0x00"]}"#;
1530        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1531        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1532        let s = r#"{"method": "personal_sign", "params":
1533["0x00", "0xd84de507f3fada7df80908082d3239466db55a71"]}"#;
1534        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1535        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1536    }
1537
1538    #[test]
1539    fn test_eth_sign_typed_data() {
1540        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!"}}]}"#;
1541        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1542        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1543    }
1544
1545    #[test]
1546    fn test_remove_pool_transactions() {
1547        let s = r#"{"method": "anvil_removePoolTransactions",  "params":["0x364d6D0333432C3Ac016Ca832fb8594A8cE43Ca6"]}"#;
1548        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1549        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1550    }
1551
1552    #[test]
1553    fn test_serde_anvil_reorg() {
1554        // TransactionData::JSON
1555        let s = r#"
1556        {
1557            "method": "anvil_reorg",
1558            "params": [
1559                5,
1560                [
1561                    [
1562                        {
1563                            "from": "0x976EA74026E726554dB657fA54763abd0C3a0aa9",
1564                            "to": "0x1199bc69f16FDD6690DC40339EC445FaE1b6DD11",
1565                            "value": 100
1566                        },
1567                        1
1568                    ],
1569                    [
1570                        {
1571                            "from": "0x976EA74026E726554dB657fA54763abd0C3a0aa9",
1572                            "to": "0x1199bc69f16FDD6690DC40339EC445FaE1b6DD11",
1573                            "value": 200
1574                        },
1575                        2
1576                    ]
1577                ]
1578            ]
1579        }
1580        "#;
1581        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1582        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1583        // TransactionData::Raw
1584        let s = r#"
1585        {
1586            "method": "anvil_reorg",
1587            "params": [
1588                5,
1589                [
1590                    [
1591                        "0x19d55c67e1ba8f1bbdfed75f8ad524ebf087e4ecb848a2d19881d7a5e3d2c54e1732cb1b462da3b3fdb05bdf4c4d3c8e3c9fcebdc2ab5fa5d59a3f752888f27e1b",
1592                        1
1593                    ]
1594                ]
1595            ]
1596        }
1597        "#;
1598        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1599        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1600        // TransactionData::Raw and TransactionData::JSON
1601        let s = r#"
1602        {
1603            "method": "anvil_reorg",
1604            "params": [
1605                5,
1606                [
1607                    [
1608                        "0x19d55c67e1ba8f1bbdfed75f8ad524ebf087e4ecb848a2d19881d7a5e3d2c54e1732cb1b462da3b3fdb05bdf4c4d3c8e3c9fcebdc2ab5fa5d59a3f752888f27e1b",
1609                        1
1610                    ],
1611                    [
1612                        {
1613                            "from": "0x976EA74026E726554dB657fA54763abd0C3a0aa9",
1614                            "to": "0x1199bc69f16FDD6690DC40339EC445FaE1b6DD11",
1615                            "value": 200
1616                        },
1617                        2
1618                    ]
1619                ]
1620            ]
1621        }
1622        "#;
1623        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1624        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1625    }
1626}
anvil_core/eth/mod.rs

anvil_core/eth/
mod.rs
