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

anvil_core/eth/
mod.rs
