anvil_core/eth/
mod.rs

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

anvil_core/eth/
mod.rs
