anvil_core/eth/
mod.rs

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

anvil_core/eth/
mod.rs
