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

anvil_core/eth/
mod.rs
