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    /// geth's `debug_getRawTransaction`  endpoint
268    #[serde(rename = "debug_getRawTransaction", with = "sequence")]
269    DebugGetRawTransaction(TxHash),
270
271    /// geth's `debug_traceTransaction`  endpoint
272    #[serde(rename = "debug_traceTransaction")]
273    DebugTraceTransaction(B256, #[serde(default)] GethDebugTracingOptions),
274
275    /// geth's `debug_traceCall`  endpoint
276    #[serde(rename = "debug_traceCall")]
277    DebugTraceCall(
278        WithOtherFields<TransactionRequest>,
279        #[serde(default)] Option<BlockId>,
280        #[serde(default)] GethDebugTracingCallOptions,
281    ),
282
283    /// geth's `debug_traceBlockByNumber` endpoint
284    #[serde(rename = "debug_traceBlockByNumber")]
285    DebugTraceBlockByNumber(
286        #[serde(deserialize_with = "lenient_block_number::lenient_block_number")] BlockNumber,
287        #[serde(default)] GethDebugTracingOptions,
288    ),
289
290    /// reth's `debug_codeByHash` endpoint
291    #[serde(rename = "debug_codeByHash")]
292    DebugCodeByHash(B256, #[serde(default)] Option<BlockId>),
293
294    /// Trace transaction endpoint for parity's `trace_transaction`
295    #[serde(rename = "trace_transaction", with = "sequence")]
296    TraceTransaction(B256),
297
298    /// Trace transaction endpoint for parity's `trace_block`
299    #[serde(
300        rename = "trace_block",
301        deserialize_with = "lenient_block_number::lenient_block_number_seq"
302    )]
303    TraceBlock(BlockNumber),
304
305    // Return filtered traces over blocks
306    #[serde(rename = "trace_filter", with = "sequence")]
307    TraceFilter(TraceFilter),
308
309    // Custom endpoints, they're not extracted to a separate type out of serde convenience
310    /// send transactions impersonating specific account and contract addresses.
311    #[serde(
312        rename = "anvil_impersonateAccount",
313        alias = "hardhat_impersonateAccount",
314        with = "sequence"
315    )]
316    ImpersonateAccount(Address),
317    /// Stops impersonating an account if previously set with `anvil_impersonateAccount`
318    #[serde(
319        rename = "anvil_stopImpersonatingAccount",
320        alias = "hardhat_stopImpersonatingAccount",
321        with = "sequence"
322    )]
323    StopImpersonatingAccount(Address),
324    /// Will make every account impersonated
325    #[serde(
326        rename = "anvil_autoImpersonateAccount",
327        alias = "hardhat_autoImpersonateAccount",
328        with = "sequence"
329    )]
330    AutoImpersonateAccount(bool),
331    /// Returns true if automatic mining is enabled, and false.
332    #[serde(rename = "anvil_getAutomine", alias = "hardhat_getAutomine", with = "empty_params")]
333    GetAutoMine(()),
334    /// Mines a series of blocks
335    #[serde(rename = "anvil_mine", alias = "hardhat_mine")]
336    Mine(
337        /// Number of blocks to mine, if not set `1` block is mined
338        #[serde(default, deserialize_with = "deserialize_number_opt")]
339        Option<U256>,
340        /// The time interval between each block in seconds, defaults to `1` seconds
341        /// The interval is applied only to blocks mined in the given method invocation, not to
342        /// blocks mined afterwards. Set this to `0` to instantly mine _all_ blocks
343        #[serde(default, deserialize_with = "deserialize_number_opt")]
344        Option<U256>,
345    ),
346
347    /// Enables or disables, based on the single boolean argument, the automatic mining of new
348    /// blocks with each new transaction submitted to the network.
349    #[serde(rename = "anvil_setAutomine", alias = "evm_setAutomine", with = "sequence")]
350    SetAutomine(bool),
351
352    /// Sets the mining behavior to interval with the given interval (seconds)
353    #[serde(rename = "anvil_setIntervalMining", alias = "evm_setIntervalMining", with = "sequence")]
354    SetIntervalMining(u64),
355
356    /// Gets the current mining behavior
357    #[serde(rename = "anvil_getIntervalMining", with = "empty_params")]
358    GetIntervalMining(()),
359
360    /// Removes transactions from the pool
361    #[serde(rename = "anvil_dropTransaction", alias = "hardhat_dropTransaction", with = "sequence")]
362    DropTransaction(B256),
363
364    /// Removes transactions from the pool
365    #[serde(
366        rename = "anvil_dropAllTransactions",
367        alias = "hardhat_dropAllTransactions",
368        with = "empty_params"
369    )]
370    DropAllTransactions(),
371
372    /// Reset the fork to a fresh forked state, and optionally update the fork config
373    #[serde(rename = "anvil_reset", alias = "hardhat_reset")]
374    Reset(#[serde(default)] Option<Params<Option<Forking>>>),
375
376    /// Sets the backend rpc url
377    #[serde(rename = "anvil_setRpcUrl", with = "sequence")]
378    SetRpcUrl(String),
379
380    /// Modifies the balance of an account.
381    #[serde(
382        rename = "anvil_setBalance",
383        alias = "hardhat_setBalance",
384        alias = "tenderly_setBalance"
385    )]
386    SetBalance(Address, #[serde(deserialize_with = "deserialize_number")] U256),
387
388    /// Increases the balance of an account.
389    #[serde(
390        rename = "anvil_addBalance",
391        alias = "hardhat_addBalance",
392        alias = "tenderly_addBalance"
393    )]
394    AddBalance(Address, #[serde(deserialize_with = "deserialize_number")] U256),
395
396    /// Modifies the ERC20 balance of an account.
397    #[serde(
398        rename = "anvil_dealERC20",
399        alias = "hardhat_dealERC20",
400        alias = "anvil_setERC20Balance"
401    )]
402    DealERC20(Address, Address, #[serde(deserialize_with = "deserialize_number")] U256),
403
404    /// Sets the ERC20 allowance for a spender
405    #[serde(rename = "anvil_setERC20Allowance")]
406    SetERC20Allowance(
407        Address,
408        Address,
409        Address,
410        #[serde(deserialize_with = "deserialize_number")] U256,
411    ),
412
413    /// Sets the code of a contract
414    #[serde(rename = "anvil_setCode", alias = "hardhat_setCode")]
415    SetCode(Address, Bytes),
416
417    /// Sets the nonce of an address
418    #[serde(rename = "anvil_setNonce", alias = "hardhat_setNonce", alias = "evm_setAccountNonce")]
419    SetNonce(Address, #[serde(deserialize_with = "deserialize_number")] U256),
420
421    /// Writes a single slot of the account's storage
422    #[serde(rename = "anvil_setStorageAt", alias = "hardhat_setStorageAt")]
423    SetStorageAt(
424        Address,
425        /// slot
426        U256,
427        /// value
428        B256,
429    ),
430
431    /// Sets the immutable data associated with a contract address
432    #[serde(rename = "anvil_setImmutableStorageAt")]
433    SetImmutableStorageAt(
434        Address,
435        /// immutable values (each as ABI-encoded bytes)
436        Vec<Bytes>,
437    ),
438
439    /// Sets the coinbase address
440    #[serde(rename = "anvil_setCoinbase", alias = "hardhat_setCoinbase", with = "sequence")]
441    SetCoinbase(Address),
442
443    /// Returns the client coinbase address.
444    #[serde(rename = "eth_coinbase", with = "empty_params")]
445    EthCoinbase(()),
446
447    /// Sets the chain id
448    #[serde(rename = "anvil_setChainId", with = "sequence")]
449    SetChainId(u64),
450
451    /// Enable or disable logging
452    #[serde(
453        rename = "anvil_setLoggingEnabled",
454        alias = "hardhat_setLoggingEnabled",
455        with = "sequence"
456    )]
457    SetLogging(bool),
458
459    /// Set the minimum gas price for the node
460    #[serde(
461        rename = "anvil_setMinGasPrice",
462        alias = "hardhat_setMinGasPrice",
463        deserialize_with = "deserialize_number_seq"
464    )]
465    SetMinGasPrice(U256),
466
467    /// Sets the base fee of the next block
468    #[serde(
469        rename = "anvil_setNextBlockBaseFeePerGas",
470        alias = "hardhat_setNextBlockBaseFeePerGas",
471        deserialize_with = "deserialize_number_seq"
472    )]
473    SetNextBlockBaseFeePerGas(U256),
474
475    /// Sets the specific timestamp
476    /// Accepts timestamp (Unix epoch) with millisecond precision and returns the number of seconds
477    /// between the given timestamp and the current time.
478    #[serde(
479        rename = "anvil_setTime",
480        alias = "evm_setTime",
481        deserialize_with = "deserialize_number_seq"
482    )]
483    EvmSetTime(U256),
484
485    /// Serializes the current state (including contracts code, contract's storage, accounts
486    /// properties, etc.) into a saveable data blob
487    #[serde(rename = "anvil_dumpState", alias = "hardhat_dumpState")]
488    DumpState(#[serde(default)] Option<Params<Option<bool>>>),
489
490    /// Adds state previously dumped with `DumpState` to the current chain
491    #[serde(rename = "anvil_loadState", alias = "hardhat_loadState", with = "sequence")]
492    LoadState(Bytes),
493
494    /// Retrieves the Anvil node configuration params
495    #[serde(rename = "anvil_nodeInfo", with = "empty_params")]
496    NodeInfo(()),
497
498    /// Retrieves the Anvil node metadata.
499    #[serde(rename = "anvil_metadata", alias = "hardhat_metadata", with = "empty_params")]
500    AnvilMetadata(()),
501
502    // Ganache compatible calls
503    /// Snapshot the state of the blockchain at the current block.
504    ///
505    /// Ref <https://github.com/trufflesuite/ganache/blob/ef1858d5d6f27e4baeb75cccd57fb3dc77a45ae8/src/chains/ethereum/ethereum/RPC-METHODS.md#evm_snapshot>
506    #[serde(rename = "anvil_snapshot", alias = "evm_snapshot", with = "empty_params")]
507    EvmSnapshot(()),
508
509    /// Revert the state of the blockchain to a previous snapshot.
510    /// Takes a single parameter, which is the snapshot id to revert to.
511    ///
512    /// Ref <https://github.com/trufflesuite/ganache/blob/ef1858d5d6f27e4baeb75cccd57fb3dc77a45ae8/src/chains/ethereum/ethereum/RPC-METHODS.md#evm_revert>
513    #[serde(
514        rename = "anvil_revert",
515        alias = "evm_revert",
516        deserialize_with = "deserialize_number_seq"
517    )]
518    EvmRevert(U256),
519
520    /// Jump forward in time by the given amount of time, in seconds.
521    #[serde(
522        rename = "anvil_increaseTime",
523        alias = "evm_increaseTime",
524        deserialize_with = "deserialize_number_seq"
525    )]
526    EvmIncreaseTime(U256),
527
528    /// Similar to `evm_increaseTime` but takes the exact timestamp that you want in the next block
529    #[serde(
530        rename = "anvil_setNextBlockTimestamp",
531        alias = "evm_setNextBlockTimestamp",
532        deserialize_with = "deserialize_number_seq"
533    )]
534    EvmSetNextBlockTimeStamp(U256),
535
536    /// Set the exact gas limit that you want in the next block
537    #[serde(
538        rename = "anvil_setBlockGasLimit",
539        alias = "evm_setBlockGasLimit",
540        deserialize_with = "deserialize_number_seq"
541    )]
542    EvmSetBlockGasLimit(U256),
543
544    /// Similar to `evm_increaseTime` but takes sets a block timestamp `interval`.
545    ///
546    /// The timestamp of the next block will be computed as `lastBlock_timestamp + interval`.
547    #[serde(rename = "anvil_setBlockTimestampInterval", with = "sequence")]
548    EvmSetBlockTimeStampInterval(u64),
549
550    /// Removes a `anvil_setBlockTimestampInterval` if it exists
551    #[serde(rename = "anvil_removeBlockTimestampInterval", with = "empty_params")]
552    EvmRemoveBlockTimeStampInterval(()),
553
554    /// Mine a single block
555    #[serde(rename = "evm_mine")]
556    EvmMine(#[serde(default)] Option<Params<Option<MineOptions>>>),
557
558    /// Mine a single block and return detailed data
559    ///
560    /// This behaves exactly as `EvmMine` but returns different output, for compatibility reasons
561    /// this is a separate call since `evm_mine` is not an anvil original.
562    #[serde(rename = "anvil_mine_detailed", alias = "evm_mine_detailed")]
563    EvmMineDetailed(#[serde(default)] Option<Params<Option<MineOptions>>>),
564
565    /// Execute a transaction regardless of signature status
566    #[serde(rename = "eth_sendUnsignedTransaction", with = "sequence")]
567    EthSendUnsignedTransaction(Box<WithOtherFields<TransactionRequest>>),
568
569    /// Turn on call traces for transactions that are returned to the user when they execute a
570    /// transaction (instead of just txhash/receipt)
571    #[serde(rename = "anvil_enableTraces", with = "empty_params")]
572    EnableTraces(()),
573
574    /// Returns the number of transactions currently pending for inclusion in the next block(s), as
575    /// well as the ones that are being scheduled for future execution only.
576    /// Ref: <https://geth.ethereum.org/docs/rpc/ns-txpool#txpool_status>
577    #[serde(rename = "txpool_status", with = "empty_params")]
578    TxPoolStatus(()),
579
580    /// Returns a summary of all the transactions currently pending for inclusion in the next
581    /// block(s), as well as the ones that are being scheduled for future execution only.
582    /// Ref: <https://geth.ethereum.org/docs/rpc/ns-txpool#txpool_inspect>
583    #[serde(rename = "txpool_inspect", with = "empty_params")]
584    TxPoolInspect(()),
585
586    /// Returns the details of all transactions currently pending for inclusion in the next
587    /// block(s), as well as the ones that are being scheduled for future execution only.
588    /// Ref: <https://geth.ethereum.org/docs/rpc/ns-txpool#txpool_content>
589    #[serde(rename = "txpool_content", with = "empty_params")]
590    TxPoolContent(()),
591
592    /// Otterscan's `ots_getApiLevel` endpoint
593    /// Otterscan currently requires this endpoint, even though it's not part of the ots_*
594    /// <https://github.com/otterscan/otterscan/blob/071d8c55202badf01804f6f8d53ef9311d4a9e47/src/useProvider.ts#L71>
595    /// Related upstream issue: <https://github.com/otterscan/otterscan/issues/1081>
596    #[serde(rename = "erigon_getHeaderByNumber")]
597    ErigonGetHeaderByNumber(
598        #[serde(deserialize_with = "lenient_block_number::lenient_block_number_seq")] BlockNumber,
599    ),
600
601    /// Otterscan's `ots_getApiLevel` endpoint
602    /// Used as a simple API versioning scheme for the ots_* namespace
603    #[serde(rename = "ots_getApiLevel", with = "empty_params")]
604    OtsGetApiLevel(()),
605
606    /// Otterscan's `ots_getInternalOperations` endpoint
607    /// Traces internal ETH transfers, contracts creation (CREATE/CREATE2) and self-destructs for a
608    /// certain transaction.
609    #[serde(rename = "ots_getInternalOperations", with = "sequence")]
610    OtsGetInternalOperations(B256),
611
612    /// Otterscan's `ots_hasCode` endpoint
613    /// Check if an ETH address contains code at a certain block number.
614    #[serde(rename = "ots_hasCode")]
615    OtsHasCode(
616        Address,
617        #[serde(deserialize_with = "lenient_block_number::lenient_block_number", default)]
618        BlockNumber,
619    ),
620
621    /// Otterscan's `ots_traceTransaction` endpoint
622    /// Trace a transaction and generate a trace call tree.
623    #[serde(rename = "ots_traceTransaction", with = "sequence")]
624    OtsTraceTransaction(B256),
625
626    /// Otterscan's `ots_getTransactionError` endpoint
627    /// Given a transaction hash, returns its raw revert reason.
628    #[serde(rename = "ots_getTransactionError", with = "sequence")]
629    OtsGetTransactionError(B256),
630
631    /// Otterscan's `ots_getBlockDetails` endpoint
632    /// Given a block number, return its data. Similar to the standard eth_getBlockByNumber/Hash
633    /// method, but can be optimized by excluding unnecessary data such as transactions and
634    /// logBloom
635    #[serde(rename = "ots_getBlockDetails")]
636    OtsGetBlockDetails(
637        #[serde(deserialize_with = "lenient_block_number::lenient_block_number_seq", default)]
638        BlockNumber,
639    ),
640
641    /// Otterscan's `ots_getBlockDetails` endpoint
642    /// Same as `ots_getBlockDetails`, but receiving a block hash instead of number
643    #[serde(rename = "ots_getBlockDetailsByHash", with = "sequence")]
644    OtsGetBlockDetailsByHash(B256),
645
646    /// Otterscan's `ots_getBlockTransactions` endpoint
647    /// Gets paginated transaction data for a certain block. Return data is similar to
648    /// eth_getBlockBy* + eth_getTransactionReceipt.
649    #[serde(rename = "ots_getBlockTransactions")]
650    OtsGetBlockTransactions(u64, usize, usize),
651
652    /// Otterscan's `ots_searchTransactionsBefore` endpoint
653    /// Address history navigation. searches backwards from certain point in time.
654    #[serde(rename = "ots_searchTransactionsBefore")]
655    OtsSearchTransactionsBefore(Address, u64, usize),
656
657    /// Otterscan's `ots_searchTransactionsAfter` endpoint
658    /// Address history navigation. searches forward from certain point in time.
659    #[serde(rename = "ots_searchTransactionsAfter")]
660    OtsSearchTransactionsAfter(Address, u64, usize),
661
662    /// Otterscan's `ots_getTransactionBySenderAndNonce` endpoint
663    /// Given a sender address and a nonce, returns the tx hash or null if not found. It returns
664    /// only the tx hash on success, you can use the standard eth_getTransactionByHash after that
665    /// to get the full transaction data.
666    #[serde(rename = "ots_getTransactionBySenderAndNonce")]
667    OtsGetTransactionBySenderAndNonce(
668        Address,
669        #[serde(deserialize_with = "deserialize_number")] U256,
670    ),
671
672    /// Otterscan's `ots_getTransactionBySenderAndNonce` endpoint
673    /// Given an ETH contract address, returns the tx hash and the direct address who created the
674    /// contract.
675    #[serde(rename = "ots_getContractCreator", with = "sequence")]
676    OtsGetContractCreator(Address),
677
678    /// Removes transactions from the pool by sender origin.
679    #[serde(rename = "anvil_removePoolTransactions", with = "sequence")]
680    RemovePoolTransactions(Address),
681
682    /// Reorg the chain
683    #[serde(rename = "anvil_reorg")]
684    Reorg(ReorgOptions),
685
686    /// Rollback the chain
687    #[serde(rename = "anvil_rollback", with = "sequence")]
688    Rollback(Option<u64>),
689
690    /// Wallet
691    #[serde(rename = "wallet_getCapabilities", with = "empty_params")]
692    WalletGetCapabilities(()),
693
694    /// Wallet send_tx
695    #[serde(
696        rename = "wallet_sendTransaction",
697        alias = "odyssey_sendTransaction",
698        with = "sequence"
699    )]
700    WalletSendTransaction(Box<WithOtherFields<TransactionRequest>>),
701
702    /// Add an address to the [`DelegationCapability`] of the wallet
703    ///
704    /// [`DelegationCapability`]: wallet::DelegationCapability
705    #[serde(rename = "anvil_addCapability", with = "sequence")]
706    AnvilAddCapability(Address),
707
708    /// Set the executor (sponsor) wallet
709    #[serde(rename = "anvil_setExecutor", with = "sequence")]
710    AnvilSetExecutor(String),
711}
712
713/// Represents ethereum JSON-RPC API
714#[derive(Clone, Debug, PartialEq, Eq, serde::Deserialize)]
715#[serde(tag = "method", content = "params")]
716pub enum EthPubSub {
717    /// Subscribe to an eth subscription
718    #[serde(rename = "eth_subscribe")]
719    EthSubscribe(SubscriptionKind, #[serde(default)] Box<SubscriptionParams>),
720
721    /// Unsubscribe from an eth subscription
722    #[serde(rename = "eth_unsubscribe", with = "sequence")]
723    EthUnSubscribe(SubscriptionId),
724}
725
726/// Container type for either a request or a pub sub
727#[derive(Clone, Debug, serde::Deserialize)]
728#[serde(untagged)]
729pub enum EthRpcCall {
730    Request(Box<EthRequest>),
731    PubSub(EthPubSub),
732}
733
734#[cfg(test)]
735mod tests {
736    use super::*;
737
738    #[test]
739    fn test_web3_client_version() {
740        let s = r#"{"method": "web3_clientVersion", "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_web3_sha3() {
747        let s = r#"{"method": "web3_sha3", "params":["0x68656c6c6f20776f726c64"]}"#;
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_accounts() {
754        let s = r#"{"method": "eth_accounts", "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_eth_network_id() {
761        let s = r#"{"method": "eth_networkId", "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_get_proof() {
768        let s = r#"{"method":"eth_getProof","params":["0x7F0d15C7FAae65896648C8273B6d7E43f58Fa842",["0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421"],"latest"]}"#;
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_chain_id() {
775        let s = r#"{"method": "eth_chainId", "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_net_listening() {
782        let s = r#"{"method": "net_listening", "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_eth_block_number() {
789        let s = r#"{"method": "eth_blockNumber", "params":[]}"#;
790        let value: serde_json::Value = serde_json::from_str(s).unwrap();
791        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
792    }
793
794    #[test]
795    fn test_eth_max_priority_fee() {
796        let s = r#"{"method": "eth_maxPriorityFeePerGas", "params":[]}"#;
797        let value: serde_json::Value = serde_json::from_str(s).unwrap();
798        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
799    }
800
801    #[test]
802    fn test_eth_syncing() {
803        let s = r#"{"method": "eth_syncing", "params":[]}"#;
804        let value: serde_json::Value = serde_json::from_str(s).unwrap();
805        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
806    }
807
808    #[test]
809    fn test_custom_impersonate_account() {
810        let s = r#"{"method": "anvil_impersonateAccount", "params":
811["0xd84de507f3fada7df80908082d3239466db55a71"]}"#;
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_stop_impersonate_account() {
818        let s = r#"{"method": "anvil_stopImpersonatingAccount",  "params":
819["0x364d6D0333432C3Ac016Ca832fb8594A8cE43Ca6"]}"#;
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_auto_impersonate_account() {
826        let s = r#"{"method": "anvil_autoImpersonateAccount",  "params": [true]}"#;
827        let value: serde_json::Value = serde_json::from_str(s).unwrap();
828        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
829    }
830
831    #[test]
832    fn test_custom_get_automine() {
833        let s = r#"{"method": "anvil_getAutomine", "params": []}"#;
834        let value: serde_json::Value = serde_json::from_str(s).unwrap();
835        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
836    }
837
838    #[test]
839    fn test_custom_mine() {
840        let s = r#"{"method": "anvil_mine", "params": []}"#;
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_none());
846                assert!(time.is_none());
847            }
848            _ => unreachable!(),
849        }
850        let s = r#"{"method": "anvil_mine", "params":
851["0xd84de507f3fada7df80908082d3239466db55a71"]}"#;
852        let value: serde_json::Value = serde_json::from_str(s).unwrap();
853        let req = serde_json::from_value::<EthRequest>(value).unwrap();
854        match req {
855            EthRequest::Mine(num, time) => {
856                assert!(num.is_some());
857                assert!(time.is_none());
858            }
859            _ => unreachable!(),
860        }
861        let s = r#"{"method": "anvil_mine", "params": ["0xd84de507f3fada7df80908082d3239466db55a71", "0xd84de507f3fada7df80908082d3239466db55a71"]}"#;
862        let value: serde_json::Value = serde_json::from_str(s).unwrap();
863        let req = serde_json::from_value::<EthRequest>(value).unwrap();
864        match req {
865            EthRequest::Mine(num, time) => {
866                assert!(num.is_some());
867                assert!(time.is_some());
868            }
869            _ => unreachable!(),
870        }
871    }
872
873    #[test]
874    fn test_custom_auto_mine() {
875        let s = r#"{"method": "anvil_setAutomine", "params": [false]}"#;
876        let value: serde_json::Value = serde_json::from_str(s).unwrap();
877        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
878        let s = r#"{"method": "evm_setAutomine", "params": [false]}"#;
879        let value: serde_json::Value = serde_json::from_str(s).unwrap();
880        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
881    }
882
883    #[test]
884    fn test_custom_interval_mining() {
885        let s = r#"{"method": "anvil_setIntervalMining", "params": [100]}"#;
886        let value: serde_json::Value = serde_json::from_str(s).unwrap();
887        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
888        let s = r#"{"method": "evm_setIntervalMining", "params": [100]}"#;
889        let value: serde_json::Value = serde_json::from_str(s).unwrap();
890        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
891    }
892
893    #[test]
894    fn test_custom_drop_tx() {
895        let s = r#"{"method": "anvil_dropTransaction", "params":
896["0x4a3b0fce2cb9707b0baa68640cf2fe858c8bb4121b2a8cb904ff369d38a560ff"]}"#;
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_reset() {
903        let s = r#"{"method": "anvil_reset", "params": [{"forking": {"jsonRpcUrl": "https://ethereumpublicnode.com",
904        "blockNumber": "18441649"
905      }
906    }]}"#;
907        let value: serde_json::Value = serde_json::from_str(s).unwrap();
908        let req = serde_json::from_value::<EthRequest>(value).unwrap();
909        match req {
910            EthRequest::Reset(forking) => {
911                let forking = forking.and_then(|f| f.params);
912                assert_eq!(
913                    forking,
914                    Some(Forking {
915                        json_rpc_url: Some("https://ethereumpublicnode.com".into()),
916                        block_number: Some(18441649)
917                    })
918                )
919            }
920            _ => unreachable!(),
921        }
922
923        let s = r#"{"method": "anvil_reset", "params": [ { "forking": {
924                "jsonRpcUrl": "https://eth-mainnet.alchemyapi.io/v2/<key>",
925                "blockNumber": 11095000
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: Some(11095000)
939                    })
940                )
941            }
942            _ => unreachable!(),
943        }
944
945        let s = r#"{"method": "anvil_reset", "params": [ { "forking": {
946                "jsonRpcUrl": "https://eth-mainnet.alchemyapi.io/v2/<key>"
947        }}]}"#;
948        let value: serde_json::Value = serde_json::from_str(s).unwrap();
949        let req = serde_json::from_value::<EthRequest>(value).unwrap();
950        match req {
951            EthRequest::Reset(forking) => {
952                let forking = forking.and_then(|f| f.params);
953                assert_eq!(
954                    forking,
955                    Some(Forking {
956                        json_rpc_url: Some(
957                            "https://eth-mainnet.alchemyapi.io/v2/<key>".to_string()
958                        ),
959                        block_number: None
960                    })
961                )
962            }
963            _ => unreachable!(),
964        }
965
966        let s = r#"{"method":"anvil_reset","params":[{"jsonRpcUrl": "http://localhost:8545", "blockNumber": 14000000}]}"#;
967        let value: serde_json::Value = serde_json::from_str(s).unwrap();
968        let req = serde_json::from_value::<EthRequest>(value).unwrap();
969        match req {
970            EthRequest::Reset(forking) => {
971                let forking = forking.and_then(|f| f.params);
972                assert_eq!(
973                    forking,
974                    Some(Forking {
975                        json_rpc_url: Some("http://localhost:8545".to_string()),
976                        block_number: Some(14000000)
977                    })
978                )
979            }
980            _ => unreachable!(),
981        }
982
983        let s = r#"{"method":"anvil_reset","params":[{ "blockNumber": 14000000}]}"#;
984        let value: serde_json::Value = serde_json::from_str(s).unwrap();
985        let req = serde_json::from_value::<EthRequest>(value).unwrap();
986        match req {
987            EthRequest::Reset(forking) => {
988                let forking = forking.and_then(|f| f.params);
989                assert_eq!(
990                    forking,
991                    Some(Forking { json_rpc_url: None, block_number: Some(14000000) })
992                )
993            }
994            _ => unreachable!(),
995        }
996
997        let s = r#"{"method":"anvil_reset","params":[{ "blockNumber": "14000000"}]}"#;
998        let value: serde_json::Value = serde_json::from_str(s).unwrap();
999        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1000        match req {
1001            EthRequest::Reset(forking) => {
1002                let forking = forking.and_then(|f| f.params);
1003                assert_eq!(
1004                    forking,
1005                    Some(Forking { json_rpc_url: None, block_number: Some(14000000) })
1006                )
1007            }
1008            _ => unreachable!(),
1009        }
1010
1011        let s = r#"{"method":"anvil_reset","params":[{"jsonRpcUrl": "http://localhost:8545"}]}"#;
1012        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1013        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1014        match req {
1015            EthRequest::Reset(forking) => {
1016                let forking = forking.and_then(|f| f.params);
1017                assert_eq!(
1018                    forking,
1019                    Some(Forking {
1020                        json_rpc_url: Some("http://localhost:8545".to_string()),
1021                        block_number: None
1022                    })
1023                )
1024            }
1025            _ => unreachable!(),
1026        }
1027
1028        let s = r#"{"method": "anvil_reset"}"#;
1029        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1030        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1031        match req {
1032            EthRequest::Reset(forking) => {
1033                assert!(forking.is_none())
1034            }
1035            _ => unreachable!(),
1036        }
1037    }
1038
1039    #[test]
1040    fn test_custom_set_balance() {
1041        let s = r#"{"method": "anvil_setBalance", "params":
1042["0xd84de507f3fada7df80908082d3239466db55a71", "0x0"]}"#;
1043        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1044        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1045
1046        let s = r#"{"method": "anvil_setBalance", "params":
1047["0xd84de507f3fada7df80908082d3239466db55a71", 1337]}"#;
1048        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1049        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1050    }
1051
1052    #[test]
1053    fn test_custom_set_code() {
1054        let s = r#"{"method": "anvil_setCode", "params":
1055["0xd84de507f3fada7df80908082d3239466db55a71", "0x0123456789abcdef"]}"#;
1056        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1057        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1058
1059        let s = r#"{"method": "anvil_setCode", "params":
1060["0xd84de507f3fada7df80908082d3239466db55a71", "0x"]}"#;
1061        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1062        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1063
1064        let s = r#"{"method": "anvil_setCode", "params":
1065["0xd84de507f3fada7df80908082d3239466db55a71", ""]}"#;
1066        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1067        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1068    }
1069
1070    #[test]
1071    fn test_custom_set_nonce() {
1072        let s = r#"{"method": "anvil_setNonce", "params":
1073["0xd84de507f3fada7df80908082d3239466db55a71", "0x0"]}"#;
1074        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1075        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1076        let s = r#"{"method":
1077"hardhat_setNonce", "params": ["0xd84de507f3fada7df80908082d3239466db55a71", "0x0"]}"#;
1078        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1079        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1080        let s = r#"{"method": "evm_setAccountNonce", "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    }
1085
1086    #[test]
1087    fn test_serde_custom_set_storage_at() {
1088        let s = r#"{"method": "anvil_setStorageAt", "params":
1089["0x295a70b2de5e3953354a6a8344e616ed314d7251", "0x0",
1090"0x0000000000000000000000000000000000000000000000000000000000003039"]}"#;
1091        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1092        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1093
1094        let s = r#"{"method": "hardhat_setStorageAt", "params":
1095["0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56",
1096"0xa6eef7e35abe7026729641147f7915573c7e97b47efa546f5f6e3230263bcb49",
1097"0x0000000000000000000000000000000000000000000000000000000000003039"]}"#;
1098        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1099        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1100    }
1101
1102    #[test]
1103    fn test_serde_custom_coinbase() {
1104        let s = r#"{"method": "anvil_setCoinbase", "params":
1105["0x295a70b2de5e3953354a6a8344e616ed314d7251"]}"#;
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_logging() {
1112        let s = r#"{"method": "anvil_setLoggingEnabled", "params": [false]}"#;
1113        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1114        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1115    }
1116
1117    #[test]
1118    fn test_serde_custom_min_gas_price() {
1119        let s = r#"{"method": "anvil_setMinGasPrice", "params": ["0x0"]}"#;
1120        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1121        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1122    }
1123
1124    #[test]
1125    fn test_serde_custom_next_block_base_fee() {
1126        let s = r#"{"method": "anvil_setNextBlockBaseFeePerGas", "params": ["0x0"]}"#;
1127        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1128        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1129    }
1130
1131    #[test]
1132    fn test_serde_set_time() {
1133        let s = r#"{"method": "anvil_setTime", "params": ["0x0"]}"#;
1134        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1135        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1136
1137        let s = r#"{"method": "anvil_increaseTime", "params": 1}"#;
1138        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1139        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1140    }
1141
1142    #[test]
1143    fn test_serde_custom_dump_state() {
1144        let s = r#"{"method": "anvil_dumpState", "params": [true]}"#;
1145        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1146        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1147
1148        let s = r#"{"method": "anvil_dumpState"}"#;
1149        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1150        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1151        match req {
1152            EthRequest::DumpState(param) => {
1153                assert!(param.is_none());
1154            }
1155            _ => unreachable!(),
1156        }
1157    }
1158
1159    #[test]
1160    fn test_serde_custom_load_state() {
1161        let s = r#"{"method": "anvil_loadState", "params": ["0x0001"] }"#;
1162        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1163        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1164    }
1165
1166    #[test]
1167    fn test_serde_custom_snapshot() {
1168        let s = r#"{"method": "anvil_snapshot", "params": [] }"#;
1169        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1170        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1171
1172        let s = r#"{"method": "evm_snapshot", "params": [] }"#;
1173        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1174        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1175    }
1176
1177    #[test]
1178    fn test_serde_custom_revert() {
1179        let s = r#"{"method": "anvil_revert", "params": ["0x0"]}"#;
1180        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1181        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1182    }
1183
1184    #[test]
1185    fn test_serde_custom_increase_time() {
1186        let s = r#"{"method": "anvil_increaseTime", "params": ["0x0"]}"#;
1187        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1188        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1189
1190        let s = r#"{"method": "anvil_increaseTime", "params": [1]}"#;
1191        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1192        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1193
1194        let s = r#"{"method": "anvil_increaseTime", "params": 1}"#;
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": "evm_increaseTime", "params": ["0x0"]}"#;
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": "evm_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": 1}"#;
1207        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1208        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1209    }
1210
1211    #[test]
1212    fn test_serde_custom_next_timestamp() {
1213        let s = r#"{"method": "anvil_setNextBlockTimestamp", "params": [100]}"#;
1214        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1215        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1216        let s = r#"{"method": "evm_setNextBlockTimestamp", "params": [100]}"#;
1217        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1218        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1219        let s = r#"{"method": "evm_setNextBlockTimestamp", "params": ["0x64e0f308"]}"#;
1220        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1221        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1222    }
1223
1224    #[test]
1225    fn test_serde_custom_timestamp_interval() {
1226        let s = r#"{"method": "anvil_setBlockTimestampInterval", "params": [100]}"#;
1227        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1228        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1229    }
1230
1231    #[test]
1232    fn test_serde_custom_remove_timestamp_interval() {
1233        let s = r#"{"method": "anvil_removeBlockTimestampInterval", "params": []}"#;
1234        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1235        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1236    }
1237
1238    #[test]
1239    fn test_serde_custom_evm_mine() {
1240        let s = r#"{"method": "evm_mine", "params": [100]}"#;
1241        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1242        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1243        let s = r#"{"method": "evm_mine", "params": [{
1244            "timestamp": 100,
1245            "blocks": 100
1246        }]}"#;
1247        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1248        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1249        match req {
1250            EthRequest::EvmMine(params) => {
1251                assert_eq!(
1252                    params.unwrap().params.unwrap_or_default(),
1253                    MineOptions::Options { timestamp: Some(100), blocks: Some(100) }
1254                )
1255            }
1256            _ => unreachable!(),
1257        }
1258
1259        let s = r#"{"method": "evm_mine"}"#;
1260        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1261        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1262
1263        match req {
1264            EthRequest::EvmMine(params) => {
1265                assert!(params.is_none())
1266            }
1267            _ => unreachable!(),
1268        }
1269
1270        let s = r#"{"method": "evm_mine", "params": []}"#;
1271        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1272        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1273    }
1274
1275    #[test]
1276    fn test_serde_custom_evm_mine_detailed() {
1277        let s = r#"{"method": "anvil_mine_detailed", "params": [100]}"#;
1278        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1279        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1280        let s = r#"{"method": "anvil_mine_detailed", "params": [{
1281            "timestamp": 100,
1282            "blocks": 100
1283        }]}"#;
1284        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1285        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1286        match req {
1287            EthRequest::EvmMineDetailed(params) => {
1288                assert_eq!(
1289                    params.unwrap().params.unwrap_or_default(),
1290                    MineOptions::Options { timestamp: Some(100), blocks: Some(100) }
1291                )
1292            }
1293            _ => unreachable!(),
1294        }
1295
1296        let s = r#"{"method": "evm_mine_detailed"}"#;
1297        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1298        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1299
1300        match req {
1301            EthRequest::EvmMineDetailed(params) => {
1302                assert!(params.is_none())
1303            }
1304            _ => unreachable!(),
1305        }
1306
1307        let s = r#"{"method": "anvil_mine_detailed", "params": []}"#;
1308        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1309        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1310    }
1311
1312    #[test]
1313    fn test_serde_custom_evm_mine_hex() {
1314        let s = r#"{"method": "evm_mine", "params": ["0x63b6ff08"]}"#;
1315        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1316        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1317        match req {
1318            EthRequest::EvmMine(params) => {
1319                assert_eq!(
1320                    params.unwrap().params.unwrap_or_default(),
1321                    MineOptions::Timestamp(Some(1672937224))
1322                )
1323            }
1324            _ => unreachable!(),
1325        }
1326
1327        let s = r#"{"method": "evm_mine", "params": [{"timestamp": "0x63b6ff08"}]}"#;
1328        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1329        let req = serde_json::from_value::<EthRequest>(value).unwrap();
1330        match req {
1331            EthRequest::EvmMine(params) => {
1332                assert_eq!(
1333                    params.unwrap().params.unwrap_or_default(),
1334                    MineOptions::Options { timestamp: Some(1672937224), blocks: None }
1335                )
1336            }
1337            _ => unreachable!(),
1338        }
1339    }
1340
1341    #[test]
1342    fn test_eth_uncle_count_by_block_hash() {
1343        let s = r#"{"jsonrpc":"2.0","method":"eth_getUncleCountByBlockHash","params":["0x4a3b0fce2cb9707b0baa68640cf2fe858c8bb4121b2a8cb904ff369d38a560ff"]}"#;
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_eth_block_tx_count_by_block_hash() {
1350        let s = r#"{"jsonrpc":"2.0","method":"eth_getBlockTransactionCountByHash","params":["0x4a3b0fce2cb9707b0baa68640cf2fe858c8bb4121b2a8cb904ff369d38a560ff"]}"#;
1351        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1352        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1353    }
1354
1355    #[test]
1356    fn test_eth_get_logs() {
1357        let s = r#"{"jsonrpc":"2.0","method":"eth_getLogs","params":[{"topics":["0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b"]}],"id":74}"#;
1358        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1359        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1360    }
1361
1362    #[test]
1363    fn test_eth_new_filter() {
1364        let s = r#"{"method": "eth_newFilter", "params": [{"topics":["0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b"]}],"id":73}"#;
1365        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1366        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1367    }
1368
1369    #[test]
1370    fn test_serde_eth_unsubscribe() {
1371        let s = r#"{"id": 1, "method": "eth_unsubscribe", "params":
1372["0x9cef478923ff08bf67fde6c64013158d"]}"#;
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_eth_subscribe() {
1379        let s = r#"{"id": 1, "method": "eth_subscribe", "params": ["newHeads"]}"#;
1380        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1381        let _req = serde_json::from_value::<EthPubSub>(value).unwrap();
1382
1383        let s = r#"{"id": 1, "method": "eth_subscribe", "params": ["logs", {"address":
1384"0x8320fe7702b96808f7bbc0d4a888ed1468216cfd", "topics":
1385["0xd78a0cb8bb633d06981248b816e7bd33c2a35a6089241d099fa519e361cab902"]}]}"#;
1386        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1387        let _req = serde_json::from_value::<EthPubSub>(value).unwrap();
1388
1389        let s = r#"{"id": 1, "method": "eth_subscribe", "params": ["newPendingTransactions"]}"#;
1390        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1391        let _req = serde_json::from_value::<EthPubSub>(value).unwrap();
1392
1393        let s = r#"{"id": 1, "method": "eth_subscribe", "params": ["syncing"]}"#;
1394        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1395        let _req = serde_json::from_value::<EthPubSub>(value).unwrap();
1396    }
1397
1398    #[test]
1399    fn test_serde_debug_raw_transaction() {
1400        let s = r#"{"jsonrpc":"2.0","method":"debug_getRawTransaction","params":["0x3ed3a89bc10115a321aee238c02de214009f8532a65368e5df5eaf732ee7167c"],"id":1}"#;
1401        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1402        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1403
1404        let s = r#"{"jsonrpc":"2.0","method":"eth_getRawTransactionByHash","params":["0x3ed3a89bc10115a321aee238c02de214009f8532a65368e5df5eaf732ee7167c"],"id":1}"#;
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#"{"jsonrpc":"2.0","method":"eth_getRawTransactionByBlockHashAndIndex","params":["0x3ed3a89bc10115a321aee238c02de214009f8532a65368e5df5eaf732ee7167c",1],"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_getRawTransactionByBlockNumberAndIndex","params":["0x3ed3a89b",0],"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
1417    #[test]
1418    fn test_serde_debug_trace_transaction() {
1419        let s = r#"{"method": "debug_traceTransaction", "params":
1420["0x4a3b0fce2cb9707b0baa68640cf2fe858c8bb4121b2a8cb904ff369d38a560ff"]}"#;
1421        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1422        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1423
1424        let s = r#"{"method": "debug_traceTransaction", "params":
1425["0x4a3b0fce2cb9707b0baa68640cf2fe858c8bb4121b2a8cb904ff369d38a560ff", {}]}"#;
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_traceTransaction", "params":
1430["0x4a3b0fce2cb9707b0baa68640cf2fe858c8bb4121b2a8cb904ff369d38a560ff", {"disableStorage":
1431true}]}"#;
1432        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1433        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1434    }
1435
1436    #[test]
1437    fn test_serde_debug_trace_call() {
1438        let s = r#"{"method": "debug_traceCall", "params": [{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}]}"#;
1439        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1440        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1441
1442        let s = r#"{"method": "debug_traceCall", "params": [{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}, { "blockNumber": "latest" }]}"#;
1443        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1444        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1445
1446        let s = r#"{"method": "debug_traceCall", "params": [{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}, { "blockNumber": "0x0" }]}"#;
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"}, { "blockHash": "0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3" }]}"#;
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" }, {"disableStorage": true}]}"#;
1455        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1456        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1457    }
1458
1459    #[test]
1460    fn test_serde_eth_storage() {
1461        let s = r#"{"method": "eth_getStorageAt", "params":
1462["0x295a70b2de5e3953354a6a8344e616ed314d7251", "0x0", "latest"]}"#;
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_eth_call() {
1469        let req = r#"{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}"#;
1470        let _req = serde_json::from_str::<TransactionRequest>(req).unwrap();
1471
1472        let s = r#"{"method": "eth_call", "params":[{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"},"latest"]}"#;
1473        let _req = serde_json::from_str::<EthRequest>(s).unwrap();
1474
1475        let s = r#"{"method": "eth_call", "params":[{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}]}"#;
1476        let _req = serde_json::from_str::<EthRequest>(s).unwrap();
1477
1478        let s = r#"{"method": "eth_call", "params":[{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}, { "blockNumber": "latest" }]}"#;
1479        let _req = serde_json::from_str::<EthRequest>(s).unwrap();
1480
1481        let s = r#"{"method": "eth_call", "params":[{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}, { "blockNumber": "0x0" }]}"#;
1482        let _req = serde_json::from_str::<EthRequest>(s).unwrap();
1483
1484        let s = r#"{"method": "eth_call", "params":[{"data":"0xcfae3217","from":"0xd84de507f3fada7df80908082d3239466db55a71","to":"0xcbe828fdc46e3b1c351ec90b1a5e7d9742c0398d"}, { "blockHash":"0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3" }]}"#;
1485        let _req = serde_json::from_str::<EthRequest>(s).unwrap();
1486    }
1487
1488    #[test]
1489    fn test_serde_eth_balance() {
1490        let s = r#"{"method": "eth_getBalance", "params":
1491["0x295a70b2de5e3953354a6a8344e616ed314d7251", "latest"]}"#;
1492        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1493
1494        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1495    }
1496
1497    #[test]
1498    fn test_serde_eth_block_by_number() {
1499        let s = r#"{"method": "eth_getBlockByNumber", "params": ["0x0", true]}"#;
1500        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1501        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1502        let s = r#"{"method": "eth_getBlockByNumber", "params": ["latest", true]}"#;
1503        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1504        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1505        let s = r#"{"method": "eth_getBlockByNumber", "params": ["earliest", true]}"#;
1506        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1507        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1508        let s = r#"{"method": "eth_getBlockByNumber", "params": ["pending", true]}"#;
1509        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1510        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1511
1512        // this case deviates from the spec, but we're supporting this for legacy reasons: <https://github.com/foundry-rs/foundry/issues/1868>
1513        let s = r#"{"method": "eth_getBlockByNumber", "params": [0, true]}"#;
1514        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1515        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1516    }
1517
1518    #[test]
1519    fn test_eth_sign() {
1520        let s = r#"{"method": "eth_sign", "params":
1521["0xd84de507f3fada7df80908082d3239466db55a71", "0x00"]}"#;
1522        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1523        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1524        let s = r#"{"method": "personal_sign", "params":
1525["0x00", "0xd84de507f3fada7df80908082d3239466db55a71"]}"#;
1526        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1527        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1528    }
1529
1530    #[test]
1531    fn test_eth_sign_typed_data() {
1532        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!"}}]}"#;
1533        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1534        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1535    }
1536
1537    #[test]
1538    fn test_remove_pool_transactions() {
1539        let s = r#"{"method": "anvil_removePoolTransactions",  "params":["0x364d6D0333432C3Ac016Ca832fb8594A8cE43Ca6"]}"#;
1540        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1541        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1542    }
1543
1544    #[test]
1545    fn test_serde_anvil_reorg() {
1546        // TransactionData::JSON
1547        let s = r#"
1548        {
1549            "method": "anvil_reorg",
1550            "params": [
1551                5,
1552                [
1553                    [
1554                        {
1555                            "from": "0x976EA74026E726554dB657fA54763abd0C3a0aa9",
1556                            "to": "0x1199bc69f16FDD6690DC40339EC445FaE1b6DD11",
1557                            "value": 100
1558                        },
1559                        1
1560                    ],
1561                    [
1562                        {
1563                            "from": "0x976EA74026E726554dB657fA54763abd0C3a0aa9",
1564                            "to": "0x1199bc69f16FDD6690DC40339EC445FaE1b6DD11",
1565                            "value": 200
1566                        },
1567                        2
1568                    ]
1569                ]
1570            ]
1571        }
1572        "#;
1573        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1574        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1575        // TransactionData::Raw
1576        let s = r#"
1577        {
1578            "method": "anvil_reorg",
1579            "params": [
1580                5,
1581                [
1582                    [
1583                        "0x19d55c67e1ba8f1bbdfed75f8ad524ebf087e4ecb848a2d19881d7a5e3d2c54e1732cb1b462da3b3fdb05bdf4c4d3c8e3c9fcebdc2ab5fa5d59a3f752888f27e1b",
1584                        1
1585                    ]
1586                ]
1587            ]
1588        }
1589        "#;
1590        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1591        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1592        // TransactionData::Raw and TransactionData::JSON
1593        let s = r#"
1594        {
1595            "method": "anvil_reorg",
1596            "params": [
1597                5,
1598                [
1599                    [
1600                        "0x19d55c67e1ba8f1bbdfed75f8ad524ebf087e4ecb848a2d19881d7a5e3d2c54e1732cb1b462da3b3fdb05bdf4c4d3c8e3c9fcebdc2ab5fa5d59a3f752888f27e1b",
1601                        1
1602                    ],
1603                    [
1604                        {
1605                            "from": "0x976EA74026E726554dB657fA54763abd0C3a0aa9",
1606                            "to": "0x1199bc69f16FDD6690DC40339EC445FaE1b6DD11",
1607                            "value": 200
1608                        },
1609                        2
1610                    ]
1611                ]
1612            ]
1613        }
1614        "#;
1615        let value: serde_json::Value = serde_json::from_str(s).unwrap();
1616        let _req = serde_json::from_value::<EthRequest>(value).unwrap();
1617    }
1618}
anvil_core/eth/mod.rs

anvil_core/eth/
mod.rs
