anvil_core/eth/
mod.rs

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

anvil_core/eth/
mod.rs
