anvil_core/eth/
mod.rs

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

anvil_core/eth/
mod.rs
