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

anvil_core/eth/
mod.rs
