alloy_provider/ext/
anvil.rs

1//! This module extends the Ethereum JSON-RPC provider with the Anvil namespace's RPC methods.
2
3use crate::Provider;
4use alloy_network::Network;
5use alloy_primitives::{Address, Bytes, TxHash, B256, U128, U256, U64};
6use alloy_rpc_types_anvil::{Forking, Metadata, MineOptions, NodeInfo, ReorgOptions};
7use alloy_rpc_types_eth::Block;
8use alloy_transport::TransportResult;
9
10/// Anvil namespace rpc interface that gives access to several non-standard RPC methods.
11#[cfg_attr(target_family = "wasm", async_trait::async_trait(?Send))]
12#[cfg_attr(not(target_family = "wasm"), async_trait::async_trait)]
13pub trait AnvilApi<N: Network>: Send + Sync {
14    // Not implemented:
15    // - anvil_enable_traces: Not implemented in the Anvil RPC API.
16    // - anvil_set_block: Not implemented / wired correctly in the Anvil RPC API.
17
18    /// Send transactions impersonating specific account and contract addresses.
19    async fn anvil_impersonate_account(&self, address: Address) -> TransportResult<()>;
20
21    /// Stops impersonating an account if previously set with `anvil_impersonateAccount`.
22    async fn anvil_stop_impersonating_account(&self, address: Address) -> TransportResult<()>;
23
24    /// If set to true will make every account impersonated.
25    async fn anvil_auto_impersonate_account(&self, enabled: bool) -> TransportResult<()>;
26
27    /// Returns true if auto mining is enabled, and false.
28    async fn anvil_get_auto_mine(&self) -> TransportResult<bool>;
29
30    /// Enables or disables, based on the single boolean argument, the automatic mining of new
31    /// blocks with each new transaction submitted to the network.
32    async fn anvil_set_auto_mine(&self, enable_automine: bool) -> TransportResult<()>;
33
34    /// Mines a series of blocks.
35    async fn anvil_mine(
36        &self,
37        num_blocks: Option<u64>,
38        interval: Option<u64>,
39    ) -> TransportResult<()>;
40
41    /// Sets the mining behavior to interval with the given interval (seconds).
42    async fn anvil_set_interval_mining(&self, secs: u64) -> TransportResult<()>;
43
44    /// Removes transactions from the pool.
45    async fn anvil_drop_transaction(&self, tx_hash: TxHash) -> TransportResult<Option<TxHash>>;
46
47    /// Removes all transactions from the pool.
48    async fn anvil_drop_all_transactions(&self) -> TransportResult<()>;
49
50    /// Reset the fork to a fresh forked state, and optionally update the fork config.
51    ///
52    /// If `forking` is `None` then this will disable forking entirely.
53    async fn anvil_reset(&self, forking: Option<Forking>) -> TransportResult<()>;
54
55    /// Sets the chain ID.
56    async fn anvil_set_chain_id(&self, chain_id: u64) -> TransportResult<()>;
57
58    /// Modifies the balance of an account.
59    async fn anvil_set_balance(&self, address: Address, balance: U256) -> TransportResult<()>;
60
61    /// Sets the code of a contract.
62    async fn anvil_set_code(&self, address: Address, code: Bytes) -> TransportResult<()>;
63
64    /// Sets the nonce of an address.
65    async fn anvil_set_nonce(&self, address: Address, nonce: u64) -> TransportResult<()>;
66
67    /// Writes a single slot of the account's storage.
68    async fn anvil_set_storage_at(
69        &self,
70        address: Address,
71        slot: U256,
72        val: B256,
73    ) -> TransportResult<bool>;
74
75    /// Enable or disable logging.
76    async fn anvil_set_logging(&self, enable: bool) -> TransportResult<()>;
77
78    /// Set the minimum gas price for the node.
79    async fn anvil_set_min_gas_price(&self, gas: u128) -> TransportResult<()>;
80
81    /// Sets the base fee of the next block.
82    async fn anvil_set_next_block_base_fee_per_gas(&self, basefee: u128) -> TransportResult<()>;
83
84    /// Sets the coinbase address.
85    async fn anvil_set_coinbase(&self, address: Address) -> TransportResult<()>;
86
87    /// Create a buffer that represents all state on the chain, which can be loaded to separate
88    /// process by calling `anvil_loadState`
89    async fn anvil_dump_state(&self) -> TransportResult<Bytes>;
90
91    /// Append chain state buffer to current chain. Will overwrite any conflicting addresses or
92    /// storage.
93    async fn anvil_load_state(&self, buf: Bytes) -> TransportResult<bool>;
94
95    /// Retrieves the Anvil node configuration params.
96    async fn anvil_node_info(&self) -> TransportResult<NodeInfo>;
97
98    /// Retrieves metadata about the Anvil instance.
99    async fn anvil_metadata(&self) -> TransportResult<Metadata>;
100
101    /// Removes all transactions from the pool for a specific address.
102    async fn anvil_remove_pool_transactions(&self, address: Address) -> TransportResult<()>;
103
104    /// Snapshot the state of the blockchain at the current block.
105    async fn anvil_snapshot(&self) -> TransportResult<U256>;
106
107    /// Revert the state of the blockchain to a previous snapshot.
108    /// Takes a single parameter, which is the snapshot id to revert to.
109    async fn anvil_revert(&self, id: U256) -> TransportResult<bool>;
110
111    /// Jump forward in time by the given amount of time, in seconds.
112    async fn anvil_increase_time(&self, seconds: u64) -> TransportResult<i64>;
113
114    /// Similar to `evm_increaseTime` but takes the exact timestamp that you want in the next block.
115    async fn anvil_set_next_block_timestamp(&self, timestamp: u64) -> TransportResult<()>;
116
117    /// Sets the specific timestamp and returns the number of seconds between the given timestamp
118    /// and the current time.
119    async fn anvil_set_time(&self, timestamp: u64) -> TransportResult<u64>;
120
121    /// Set the next block gas limit.
122    async fn anvil_set_block_gas_limit(&self, gas_limit: u64) -> TransportResult<bool>;
123
124    /// Sets an interval for the block timestamp.
125    async fn anvil_set_block_timestamp_interval(&self, seconds: u64) -> TransportResult<()>;
126
127    /// Unsets the interval for the block timestamp.
128    async fn anvil_remove_block_timestamp_interval(&self) -> TransportResult<bool>;
129
130    /// Mine blocks, instantly.
131    /// This will mine the blocks regardless of the configured mining mode.
132    async fn evm_mine(&self, opts: Option<MineOptions>) -> TransportResult<String>;
133
134    /// Mine blocks, instantly and return the mined blocks.
135    /// This will mine the blocks regardless of the configured mining mode.
136    async fn anvil_mine_detailed(&self, opts: Option<MineOptions>) -> TransportResult<Vec<Block>>;
137
138    /// Sets the backend rpc url.
139    async fn anvil_set_rpc_url(&self, url: String) -> TransportResult<()>;
140
141    /// Reorg the chain
142    async fn anvil_reorg(&self, options: ReorgOptions) -> TransportResult<()>;
143
144    /// Rollback the chain  
145    async fn anvil_rollback(&self, depth: Option<u64>) -> TransportResult<()>;
146
147    /// Execute a transaction regardless of signature status.
148    async fn eth_send_unsigned_transaction(
149        &self,
150        request: N::TransactionRequest,
151    ) -> TransportResult<TxHash>;
152
153    /// Sets impersonated transaction
154    async fn anvil_send_impersonated_transaction(
155        &self,
156        request: N::TransactionRequest,
157    ) -> TransportResult<TxHash>;
158}
159
160#[cfg_attr(target_family = "wasm", async_trait::async_trait(?Send))]
161#[cfg_attr(not(target_family = "wasm"), async_trait::async_trait)]
162impl<N, P> AnvilApi<N> for P
163where
164    N: Network,
165    P: Provider<N>,
166{
167    async fn anvil_impersonate_account(&self, address: Address) -> TransportResult<()> {
168        self.client().request("anvil_impersonateAccount", (address,)).await
169    }
170
171    async fn anvil_stop_impersonating_account(&self, address: Address) -> TransportResult<()> {
172        self.client().request("anvil_stopImpersonatingAccount", (address,)).await
173    }
174
175    async fn anvil_auto_impersonate_account(&self, enabled: bool) -> TransportResult<()> {
176        self.client().request("anvil_autoImpersonateAccount", (enabled,)).await
177    }
178
179    async fn anvil_get_auto_mine(&self) -> TransportResult<bool> {
180        self.client().request_noparams("anvil_getAutomine").await
181    }
182
183    async fn anvil_set_auto_mine(&self, enabled: bool) -> TransportResult<()> {
184        self.client().request("anvil_setAutomine", (enabled,)).await
185    }
186
187    async fn anvil_mine(
188        &self,
189        num_blocks: Option<u64>,
190        interval: Option<u64>,
191    ) -> TransportResult<()> {
192        self.client()
193            .request("anvil_mine", (num_blocks.map(U64::from), interval.map(U64::from)))
194            .await
195    }
196
197    async fn anvil_set_interval_mining(&self, secs: u64) -> TransportResult<()> {
198        self.client().request("anvil_setIntervalMining", (secs,)).await
199    }
200
201    async fn anvil_drop_transaction(&self, tx_hash: TxHash) -> TransportResult<Option<TxHash>> {
202        self.client().request("anvil_dropTransaction", (tx_hash,)).await
203    }
204
205    async fn anvil_drop_all_transactions(&self) -> TransportResult<()> {
206        self.client().request_noparams("anvil_dropAllTransactions").await
207    }
208
209    async fn anvil_reset(&self, forking: Option<Forking>) -> TransportResult<()> {
210        self.client().request("anvil_reset", (forking,)).await
211    }
212
213    async fn anvil_set_chain_id(&self, chain_id: u64) -> TransportResult<()> {
214        self.client().request("anvil_setChainId", (chain_id,)).await
215    }
216
217    async fn anvil_set_balance(&self, address: Address, balance: U256) -> TransportResult<()> {
218        self.client().request("anvil_setBalance", (address, balance)).await
219    }
220
221    async fn anvil_set_code(&self, address: Address, code: Bytes) -> TransportResult<()> {
222        self.client().request("anvil_setCode", (address, code)).await
223    }
224
225    async fn anvil_set_nonce(&self, address: Address, nonce: u64) -> TransportResult<()> {
226        self.client().request("anvil_setNonce", (address, U64::from(nonce))).await
227    }
228
229    async fn anvil_set_storage_at(
230        &self,
231        address: Address,
232        slot: U256,
233        val: B256,
234    ) -> TransportResult<bool> {
235        self.client().request("anvil_setStorageAt", (address, slot, val)).await
236    }
237
238    async fn anvil_set_logging(&self, enable: bool) -> TransportResult<()> {
239        self.client().request("anvil_setLoggingEnabled", (enable,)).await
240    }
241
242    async fn anvil_set_min_gas_price(&self, gas: u128) -> TransportResult<()> {
243        self.client().request("anvil_setMinGasPrice", (U128::from(gas),)).await
244    }
245
246    async fn anvil_set_next_block_base_fee_per_gas(&self, basefee: u128) -> TransportResult<()> {
247        self.client().request("anvil_setNextBlockBaseFeePerGas", (U128::from(basefee),)).await
248    }
249
250    async fn anvil_set_coinbase(&self, address: Address) -> TransportResult<()> {
251        self.client().request("anvil_setCoinbase", (address,)).await
252    }
253
254    async fn anvil_dump_state(&self) -> TransportResult<Bytes> {
255        self.client().request_noparams("anvil_dumpState").await
256    }
257
258    async fn anvil_load_state(&self, buf: Bytes) -> TransportResult<bool> {
259        self.client().request("anvil_loadState", (buf,)).await
260    }
261
262    async fn anvil_node_info(&self) -> TransportResult<NodeInfo> {
263        self.client().request_noparams("anvil_nodeInfo").await
264    }
265
266    async fn anvil_metadata(&self) -> TransportResult<Metadata> {
267        self.client().request_noparams("anvil_metadata").await
268    }
269
270    async fn anvil_remove_pool_transactions(&self, address: Address) -> TransportResult<()> {
271        self.client().request("anvil_removePoolTransactions", (address,)).await
272    }
273
274    async fn anvil_snapshot(&self) -> TransportResult<U256> {
275        self.client().request_noparams("evm_snapshot").await
276    }
277
278    async fn anvil_revert(&self, id: U256) -> TransportResult<bool> {
279        self.client().request("evm_revert", (id,)).await
280    }
281
282    async fn anvil_increase_time(&self, seconds: u64) -> TransportResult<i64> {
283        self.client().request("evm_increaseTime", (U64::from(seconds),)).await
284    }
285
286    async fn anvil_set_next_block_timestamp(&self, seconds: u64) -> TransportResult<()> {
287        self.client().request("evm_setNextBlockTimestamp", (seconds,)).await
288    }
289
290    async fn anvil_set_time(&self, timestamp: u64) -> TransportResult<u64> {
291        self.client().request("evm_setTime", (timestamp,)).await
292    }
293
294    async fn anvil_set_block_gas_limit(&self, gas_limit: u64) -> TransportResult<bool> {
295        self.client().request("evm_setBlockGasLimit", (U64::from(gas_limit),)).await
296    }
297
298    async fn anvil_set_block_timestamp_interval(&self, seconds: u64) -> TransportResult<()> {
299        self.client().request("anvil_setBlockTimestampInterval", (seconds,)).await
300    }
301
302    async fn anvil_remove_block_timestamp_interval(&self) -> TransportResult<bool> {
303        self.client().request_noparams("anvil_removeBlockTimestampInterval").await
304    }
305
306    async fn evm_mine(&self, opts: Option<MineOptions>) -> TransportResult<String> {
307        self.client().request("evm_mine", (opts,)).await
308    }
309
310    async fn anvil_mine_detailed(&self, opts: Option<MineOptions>) -> TransportResult<Vec<Block>> {
311        self.client().request("evm_mine_detailed", (opts,)).await
312    }
313
314    async fn anvil_set_rpc_url(&self, url: String) -> TransportResult<()> {
315        self.client().request("anvil_setRpcUrl", (url,)).await
316    }
317
318    async fn anvil_reorg(&self, options: ReorgOptions) -> TransportResult<()> {
319        self.client().request("anvil_reorg", options).await
320    }
321
322    async fn anvil_rollback(&self, depth: Option<u64>) -> TransportResult<()> {
323        self.client().request("anvil_rollback", (depth,)).await
324    }
325
326    async fn eth_send_unsigned_transaction(
327        &self,
328        request: N::TransactionRequest,
329    ) -> TransportResult<TxHash> {
330        self.client().request("eth_sendUnsignedTransaction", (request,)).await
331    }
332    async fn anvil_send_impersonated_transaction(
333        &self,
334        request: N::TransactionRequest,
335    ) -> TransportResult<TxHash> {
336        self.client().request("eth_sendTransaction", (request,)).await
337    }
338}
339
340#[cfg(test)]
341mod tests {
342    use super::*;
343    use crate::{
344        fillers::{ChainIdFiller, GasFiller},
345        ProviderBuilder,
346    };
347    use alloy_eips::BlockNumberOrTag;
348    use alloy_network::TransactionBuilder;
349    use alloy_primitives::B256;
350    use alloy_rpc_types_eth::TransactionRequest;
351
352    // use alloy_node_bindings::Anvil; (to be used in `test_anvil_reset`)
353
354    #[tokio::test]
355    async fn test_anvil_impersonate_account_stop_impersonating_account() {
356        let provider = ProviderBuilder::new()
357            .disable_recommended_fillers()
358            .with_simple_nonce_management()
359            .filler(GasFiller)
360            .filler(ChainIdFiller::default())
361            .connect_anvil();
362
363        let impersonate = Address::random();
364        let to = Address::random();
365        let val = U256::from(1337);
366        let funding = U256::from(1e18 as u64);
367
368        provider.anvil_set_balance(impersonate, funding).await.unwrap();
369
370        let balance = provider.get_balance(impersonate).await.unwrap();
371        assert_eq!(balance, funding);
372
373        let tx = TransactionRequest::default().with_from(impersonate).with_to(to).with_value(val);
374
375        let res = provider.send_transaction(tx.clone()).await;
376        res.unwrap_err();
377
378        provider.anvil_impersonate_account(impersonate).await.unwrap();
379        assert!(provider.get_accounts().await.unwrap().contains(&impersonate));
380
381        let res = provider.send_transaction(tx.clone()).await.unwrap().get_receipt().await.unwrap();
382        assert_eq!(res.from, impersonate);
383
384        let nonce = provider.get_transaction_count(impersonate).await.unwrap();
385        assert_eq!(nonce, 1);
386
387        let balance = provider.get_balance(to).await.unwrap();
388        assert_eq!(balance, val);
389
390        provider.anvil_stop_impersonating_account(impersonate).await.unwrap();
391        let res = provider.send_transaction(tx).await;
392        res.unwrap_err();
393    }
394
395    #[tokio::test]
396    async fn test_anvil_auto_impersonate_account() {
397        let provider = ProviderBuilder::new()
398            .disable_recommended_fillers()
399            .with_simple_nonce_management()
400            .filler(GasFiller)
401            .filler(ChainIdFiller::default())
402            .connect_anvil();
403
404        let impersonate = Address::random();
405        let to = Address::random();
406        let val = U256::from(1337);
407        let funding = U256::from(1e18 as u64);
408
409        provider.anvil_set_balance(impersonate, funding).await.unwrap();
410
411        let balance = provider.get_balance(impersonate).await.unwrap();
412        assert_eq!(balance, funding);
413
414        let tx = TransactionRequest::default().with_from(impersonate).with_to(to).with_value(val);
415
416        let res = provider.send_transaction(tx.clone()).await;
417        res.unwrap_err();
418
419        provider.anvil_auto_impersonate_account(true).await.unwrap();
420
421        let res = provider.send_transaction(tx.clone()).await.unwrap().get_receipt().await.unwrap();
422        assert_eq!(res.from, impersonate);
423
424        let nonce = provider.get_transaction_count(impersonate).await.unwrap();
425        assert_eq!(nonce, 1);
426
427        let balance = provider.get_balance(to).await.unwrap();
428        assert_eq!(balance, val);
429
430        provider.anvil_auto_impersonate_account(false).await.unwrap();
431        let res = provider.send_transaction(tx).await;
432        res.unwrap_err();
433
434        provider.anvil_impersonate_account(impersonate).await.unwrap();
435        assert!(provider.get_accounts().await.unwrap().contains(&impersonate));
436    }
437
438    #[tokio::test]
439    async fn test_anvil_get_auto_mine_set_auto_mine() {
440        let provider = ProviderBuilder::new().connect_anvil();
441
442        provider.anvil_set_auto_mine(false).await.unwrap();
443
444        let enabled = provider.anvil_get_auto_mine().await.unwrap();
445        assert!(!enabled);
446
447        provider.anvil_set_auto_mine(true).await.unwrap();
448
449        let enabled = provider.anvil_get_auto_mine().await.unwrap();
450        assert!(enabled);
451    }
452
453    #[tokio::test]
454    async fn test_anvil_mine() {
455        let provider = ProviderBuilder::new().connect_anvil();
456
457        let start_num = provider.get_block_number().await.unwrap();
458
459        provider.anvil_mine(Some(10), None).await.unwrap();
460
461        let num = provider.get_block_number().await.unwrap();
462
463        assert_eq!(num, start_num + 10);
464    }
465
466    #[tokio::test]
467    async fn test_anvil_set_interval_mining() {
468        let provider = ProviderBuilder::new().connect_anvil();
469
470        provider.anvil_set_interval_mining(1).await.unwrap();
471
472        let start_num = provider.get_block_number().await.unwrap();
473
474        tokio::time::sleep(tokio::time::Duration::from_millis(1500)).await;
475
476        let num = provider.get_block_number().await.unwrap();
477
478        assert_eq!(num, start_num + 1);
479    }
480
481    #[tokio::test]
482    async fn test_anvil_drop_transaction() {
483        let provider = ProviderBuilder::new().connect_anvil_with_wallet();
484
485        provider.anvil_set_auto_mine(false).await.unwrap();
486
487        let alice = provider.get_accounts().await.unwrap()[0];
488        let bob = provider.get_accounts().await.unwrap()[1];
489        let chain_id = provider.get_chain_id().await.unwrap();
490
491        let tx = TransactionRequest::default()
492            .with_from(alice)
493            .with_to(bob)
494            .with_nonce(0)
495            .with_chain_id(chain_id)
496            .with_value(U256::from(100))
497            .with_gas_limit(21_000)
498            .with_max_priority_fee_per_gas(1_000_000_000)
499            .with_max_fee_per_gas(20_000_000_000);
500
501        let tx_hash =
502            provider.send_transaction(tx).await.unwrap().register().await.unwrap().tx_hash;
503
504        let res = provider.anvil_drop_transaction(tx_hash).await.unwrap();
505
506        assert_eq!(res, Some(tx_hash));
507    }
508
509    #[tokio::test]
510    async fn test_anvil_drop_all_transactions() {
511        let provider = ProviderBuilder::new().connect_anvil_with_wallet();
512
513        provider.anvil_set_auto_mine(false).await.unwrap();
514
515        let alice = provider.get_accounts().await.unwrap()[0];
516        let bob = provider.get_accounts().await.unwrap()[1];
517        let chain_id = provider.get_chain_id().await.unwrap();
518
519        let tx = TransactionRequest::default()
520            .with_from(alice)
521            .with_to(bob)
522            .with_nonce(0)
523            .with_chain_id(chain_id)
524            .with_value(U256::from(100))
525            .with_gas_limit(21_000)
526            .with_max_priority_fee_per_gas(1_000_000_000)
527            .with_max_fee_per_gas(20_000_000_000);
528
529        provider.send_transaction(tx.clone()).await.unwrap().register().await.unwrap();
530
531        let tx = tx.clone().with_nonce(1);
532
533        provider.send_transaction(tx).await.unwrap().register().await.unwrap();
534
535        provider.anvil_drop_all_transactions().await.unwrap();
536    }
537
538    // TODO: Fix this test, `chain_id` is not being set correctly.
539    // #[tokio::test]
540    // async fn test_anvil_reset() {
541    //     let fork1 = Anvil::default().chain_id(777).spawn();
542    //     let fork2 = Anvil::default().chain_id(888).spawn();
543
544    //     let provider = ProviderBuilder::new()
545    //         .connect_anvil_with_config(|config| config.fork(fork1.endpoint_url().to_string()));
546
547    //     let chain_id = provider.get_chain_id().await.unwrap();
548    //     assert_eq!(chain_id, 777);
549
550    //     provider
551    //         .anvil_reset(Some(Forking {
552    //             json_rpc_url: Some(fork2.endpoint_url().to_string()),
553    //             block_number: Some(0),
554    //         }))
555    //         .await
556    //         .unwrap();
557
558    //     let chain_id = provider.get_chain_id().await.unwrap();
559    //     assert_eq!(chain_id, 888);
560    // }
561
562    #[tokio::test]
563    async fn test_anvil_set_chain_id() {
564        let provider = ProviderBuilder::new().connect_anvil();
565
566        let chain_id = 1337;
567        provider.anvil_set_chain_id(chain_id).await.unwrap();
568
569        let new_chain_id = provider.get_chain_id().await.unwrap();
570        assert_eq!(new_chain_id, chain_id);
571    }
572
573    #[tokio::test]
574    async fn test_anvil_set_balance() {
575        let provider = ProviderBuilder::new().connect_anvil();
576
577        let address = Address::random();
578        let balance = U256::from(1337);
579        provider.anvil_set_balance(address, balance).await.unwrap();
580
581        let new_balance = provider.get_balance(address).await.unwrap();
582        assert_eq!(new_balance, balance);
583    }
584
585    #[tokio::test]
586    async fn test_anvil_set_code() {
587        let provider = ProviderBuilder::new().connect_anvil();
588
589        let address = Address::random();
590        provider.anvil_set_code(address, Bytes::from("0xbeef")).await.unwrap();
591
592        let code = provider.get_code_at(address).await.unwrap();
593        assert_eq!(code, Bytes::from("0xbeef"));
594    }
595
596    #[tokio::test]
597    async fn test_anvil_set_nonce() {
598        let provider = ProviderBuilder::new().connect_anvil();
599
600        let address = Address::random();
601        let nonce = 1337;
602        provider.anvil_set_nonce(address, nonce).await.unwrap();
603
604        let new_nonce = provider.get_transaction_count(address).await.unwrap();
605        assert_eq!(new_nonce, nonce);
606    }
607
608    #[tokio::test]
609    async fn test_anvil_set_storage_at() {
610        let provider = ProviderBuilder::new().connect_anvil();
611
612        let address = Address::random();
613        let slot = U256::from(1337);
614        let val = B256::from(U256::from(1337));
615        provider.anvil_set_storage_at(address, slot, val).await.unwrap();
616
617        let storage = provider.get_storage_at(address, slot).await.unwrap();
618        assert_eq!(B256::from(storage), val);
619    }
620
621    #[tokio::test]
622    async fn test_anvil_set_logging() {
623        let provider = ProviderBuilder::new().connect_anvil();
624
625        provider.anvil_set_logging(true).await.unwrap();
626    }
627
628    #[tokio::test]
629    async fn test_anvil_set_min_gas_price() {
630        let provider = ProviderBuilder::new().connect_anvil();
631
632        let gas = U256::from(1337);
633
634        if let Err(e) = provider.anvil_set_min_gas_price(gas.try_into().unwrap()).await {
635            assert_eq!(
636                e.to_string(),
637                "server returned an error response: error code -32602: anvil_setMinGasPrice is not supported when EIP-1559 is active"
638            );
639        }
640    }
641
642    #[tokio::test]
643    async fn test_anvil_set_next_block_base_fee_per_gas() {
644        let provider = ProviderBuilder::new().connect_anvil();
645
646        let basefee = 1337;
647        provider.anvil_set_next_block_base_fee_per_gas(basefee).await.unwrap();
648
649        provider.evm_mine(None).await.unwrap();
650
651        let block = provider.get_block_by_number(BlockNumberOrTag::Latest).await.unwrap().unwrap();
652
653        assert_eq!(block.header.base_fee_per_gas, Some(basefee as u64));
654    }
655
656    #[tokio::test]
657    async fn test_anvil_set_coinbase() {
658        let provider = ProviderBuilder::new().connect_anvil();
659
660        let coinbase = Address::random();
661        provider.anvil_set_coinbase(coinbase).await.unwrap();
662
663        provider.evm_mine(None).await.unwrap();
664
665        let block = provider.get_block_by_number(BlockNumberOrTag::Latest).await.unwrap().unwrap();
666        assert_eq!(block.header.beneficiary, coinbase);
667    }
668
669    #[tokio::test]
670    async fn test_anvil_dump_state_load_state() {
671        let provider = ProviderBuilder::new().connect_anvil();
672
673        let state = provider.anvil_dump_state().await.unwrap();
674
675        assert!(!state.is_empty());
676
677        let res = provider.anvil_load_state(state).await.unwrap();
678
679        assert!(res);
680    }
681
682    #[tokio::test]
683    async fn test_anvil_node_info() {
684        let provider = ProviderBuilder::new().connect_anvil();
685
686        let latest_block =
687            provider.get_block_by_number(BlockNumberOrTag::Latest).await.unwrap().unwrap();
688
689        provider.evm_mine(None).await.unwrap();
690
691        let node_info = provider.anvil_node_info().await.unwrap();
692
693        assert_eq!(node_info.current_block_number, latest_block.header.number + 1);
694    }
695
696    #[tokio::test]
697    async fn test_anvil_metadata() {
698        let provider = ProviderBuilder::new().connect_anvil();
699
700        let client_version = provider.get_client_version().await.unwrap();
701        let chain_id = provider.get_chain_id().await.unwrap();
702
703        let metadata = provider.anvil_metadata().await.unwrap();
704
705        assert_eq!(metadata.client_version, client_version);
706        assert_eq!(metadata.chain_id, chain_id);
707    }
708
709    #[tokio::test]
710    async fn test_anvil_remove_pool_transactions() {
711        let provider = ProviderBuilder::new().connect_anvil_with_wallet();
712
713        provider.anvil_set_auto_mine(false).await.unwrap();
714
715        let alice = provider.get_accounts().await.unwrap()[0];
716        let bob = provider.get_accounts().await.unwrap()[1];
717        let chain_id = provider.get_chain_id().await.unwrap();
718
719        let tx = TransactionRequest::default()
720            .with_from(alice)
721            .with_to(bob)
722            .with_nonce(0)
723            .with_chain_id(chain_id)
724            .with_value(U256::from(100))
725            .with_gas_limit(21_000)
726            .with_max_priority_fee_per_gas(1_000_000_000)
727            .with_max_fee_per_gas(20_000_000_000);
728
729        provider.send_transaction(tx.clone()).await.unwrap().register().await.unwrap();
730
731        let tx = tx.clone().with_nonce(1);
732
733        provider.send_transaction(tx).await.unwrap().register().await.unwrap();
734
735        provider.anvil_remove_pool_transactions(alice).await.unwrap();
736    }
737
738    #[tokio::test]
739    async fn test_anvil_snapshot_revert() {
740        let provider = ProviderBuilder::new().connect_anvil();
741
742        let snapshot_id = provider.anvil_snapshot().await.unwrap();
743
744        let alice = provider.get_accounts().await.unwrap()[0];
745        let bob = provider.get_accounts().await.unwrap()[1];
746        let chain_id = provider.get_chain_id().await.unwrap();
747
748        let tx = TransactionRequest::default()
749            .with_from(alice)
750            .with_to(bob)
751            .with_nonce(0)
752            .with_chain_id(chain_id)
753            .with_value(U256::from(100))
754            .with_gas_limit(21_000)
755            .with_max_priority_fee_per_gas(1_000_000_000)
756            .with_max_fee_per_gas(20_000_000_000);
757
758        provider.send_transaction(tx.clone()).await.unwrap().get_receipt().await.unwrap();
759
760        let tx = tx.clone().with_nonce(1);
761
762        provider.send_transaction(tx).await.unwrap().get_receipt().await.unwrap();
763
764        let tx_count = provider.get_transaction_count(alice).await.unwrap();
765        assert_eq!(tx_count, 2);
766
767        let res = provider.anvil_revert(snapshot_id).await.unwrap();
768        assert!(res);
769
770        let tx_count = provider.get_transaction_count(alice).await.unwrap();
771        assert_eq!(tx_count, 0);
772    }
773
774    #[tokio::test]
775    async fn test_anvil_increase_time() {
776        let provider = ProviderBuilder::new().connect_anvil();
777
778        let timestamp = provider
779            .get_block_by_number(BlockNumberOrTag::Latest)
780            .await
781            .unwrap()
782            .unwrap()
783            .header
784            .timestamp;
785
786        let seconds = provider.anvil_increase_time(1337).await.unwrap();
787
788        assert_eq!(timestamp as i64 + seconds, timestamp as i64 + 1337_i64);
789    }
790
791    #[tokio::test]
792    async fn test_anvil_set_next_block_timestamp() {
793        let provider = ProviderBuilder::new().connect_anvil();
794
795        let timestamp = provider
796            .get_block_by_number(BlockNumberOrTag::Latest)
797            .await
798            .unwrap()
799            .unwrap()
800            .header
801            .timestamp;
802
803        provider.anvil_set_next_block_timestamp(timestamp + 1337).await.unwrap();
804
805        provider.evm_mine(None).await.unwrap();
806
807        let latest_block =
808            provider.get_block_by_number(BlockNumberOrTag::Latest).await.unwrap().unwrap();
809        assert_eq!(latest_block.header.timestamp, timestamp + 1337);
810    }
811
812    #[tokio::test]
813    async fn test_anvil_set_time() {
814        let provider = ProviderBuilder::new().connect_anvil();
815
816        provider.anvil_set_time(0).await.unwrap();
817
818        let seconds = provider.anvil_set_time(1001).await.unwrap();
819
820        assert_eq!(seconds, 1);
821    }
822
823    #[tokio::test]
824    async fn test_anvil_set_block_gas_limit() {
825        let provider = ProviderBuilder::new().connect_anvil();
826
827        let block_gas_limit = 1337;
828        assert!(provider.anvil_set_block_gas_limit(block_gas_limit).await.unwrap());
829
830        provider.evm_mine(None).await.unwrap();
831
832        let latest_block =
833            provider.get_block_by_number(BlockNumberOrTag::Latest).await.unwrap().unwrap();
834        assert_eq!(block_gas_limit, latest_block.header.gas_limit);
835    }
836
837    #[tokio::test]
838    async fn test_anvil_block_timestamp_interval() {
839        let provider = ProviderBuilder::new().connect_anvil();
840
841        provider.anvil_set_block_timestamp_interval(1).await.unwrap();
842
843        let start_timestamp = provider
844            .get_block_by_number(BlockNumberOrTag::Latest)
845            .await
846            .unwrap()
847            .unwrap()
848            .header
849            .timestamp;
850
851        tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
852
853        provider.evm_mine(None).await.unwrap();
854
855        let latest_block =
856            provider.get_block_by_number(BlockNumberOrTag::Latest).await.unwrap().unwrap();
857
858        assert_eq!(latest_block.header.timestamp, start_timestamp + 1);
859
860        provider.anvil_remove_block_timestamp_interval().await.unwrap();
861
862        provider.evm_mine(None).await.unwrap();
863
864        let start_timestamp = provider
865            .get_block_by_number(BlockNumberOrTag::Latest)
866            .await
867            .unwrap()
868            .unwrap()
869            .header
870            .timestamp;
871
872        tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
873
874        let latest_block =
875            provider.get_block_by_number(BlockNumberOrTag::Latest).await.unwrap().unwrap();
876
877        assert_eq!(latest_block.header.timestamp, start_timestamp);
878    }
879
880    #[tokio::test]
881    async fn test_evm_mine_single_block() {
882        let provider = ProviderBuilder::new().connect_anvil();
883
884        let start_num = provider.get_block_number().await.unwrap();
885
886        for (idx, _) in std::iter::repeat_n((), 10).enumerate() {
887            provider.evm_mine(None).await.unwrap();
888            let num = provider.get_block_number().await.unwrap();
889            assert_eq!(num, start_num + idx as u64 + 1);
890        }
891
892        let num = provider.get_block_number().await.unwrap();
893        assert_eq!(num, start_num + 10);
894    }
895
896    // TODO: Fix this test, only a single block is being mined regardless of the `blocks` parameter.
897    // #[tokio::test]
898    // async fn test_evm_mine_with_configuration() {
899    //     let provider = ProviderBuilder::new().connect_anvil();
900
901    //     let start_num = provider.get_block_number().await.unwrap();
902
903    //     provider
904    //         .evm_mine(Some(MineOptions::Options { timestamp: Some(100), blocks: Some(10) }))
905    //         .await
906    //         .unwrap();
907
908    //     let num = provider.get_block_number().await.unwrap();
909    //     assert_eq!(num, start_num + 10);
910    // }
911
912    #[tokio::test]
913    async fn test_anvil_mine_detailed_single_block() {
914        let provider = ProviderBuilder::new().connect_anvil();
915
916        let start_num = provider.get_block_number().await.unwrap();
917
918        for (idx, _) in std::iter::repeat_n((), 10).enumerate() {
919            provider.anvil_mine_detailed(None).await.unwrap();
920            let num = provider.get_block_number().await.unwrap();
921            assert_eq!(num, start_num + idx as u64 + 1);
922        }
923
924        let num = provider.get_block_number().await.unwrap();
925        assert_eq!(num, start_num + 10);
926    }
927
928    // TODO: Fix this test, only a single block is being mined regardless of the `blocks` parameter.
929    // #[tokio::test]
930    // async fn test_anvil_mine_detailed_with_configuration() {
931    //     let provider = ProviderBuilder::new().connect_anvil();
932
933    //     let start_num = provider.get_block_number().await.unwrap();
934
935    //     let blocks = provider
936    //         .anvil_mine_detailed(Some(MineOptions::Options {
937    //             timestamp: Some(100),
938    //             blocks: Some(10),
939    //         }))
940    //         .await
941    //         .unwrap();
942
943    //     let num = provider.get_block_number().await.unwrap();
944    //     assert_eq!(num, start_num + 10);
945
946    //     for (idx, block) in blocks.iter().enumerate() {
947    //         assert_eq!(block.header.number, Some(start_num + idx as u64 + 1));
948    //     }
949    // }
950
951    #[tokio::test]
952    async fn test_anvil_set_rpc_url() {
953        let provider = ProviderBuilder::new().connect_anvil();
954
955        let url = "https://example.com".to_string();
956        provider.anvil_set_rpc_url(url.clone()).await.unwrap();
957    }
958
959    #[tokio::test]
960    async fn test_anvil_reorg() {
961        let provider = ProviderBuilder::new().connect_anvil();
962
963        // Mine two blocks
964        provider.anvil_mine(Some(2), None).await.unwrap();
965
966        let reorged_block = provider.get_block_by_number(2.into()).await.unwrap().unwrap();
967        provider.anvil_reorg(ReorgOptions { depth: 1, tx_block_pairs: Vec::new() }).await.unwrap();
968
969        let new_block = provider.get_block_by_number(2.into()).await.unwrap().unwrap();
970
971        assert_eq!(reorged_block.header.number, new_block.header.number);
972        assert_ne!(reorged_block.header.hash, new_block.header.hash);
973    }
974
975    #[tokio::test]
976    #[ignore]
977    async fn test_anvil_rollback() {
978        let provider = ProviderBuilder::new().connect_anvil();
979
980        // Mine two blocks
981        provider.anvil_mine(Some(2), None).await.unwrap();
982
983        let target_height = provider.get_block_by_number(1.into()).await.unwrap().unwrap();
984
985        provider.anvil_rollback(Some(1)).await.unwrap();
986
987        let new_head =
988            provider.get_block_by_number(BlockNumberOrTag::Latest).await.unwrap().unwrap();
989
990        assert_eq!(target_height, new_head);
991    }
992
993    #[tokio::test]
994    async fn test_eth_send_unsigned_transaction() {
995        let provider = ProviderBuilder::new().connect_anvil();
996
997        let alice = Address::random();
998        let bob = Address::random();
999        let chain_id = provider.get_chain_id().await.unwrap();
1000
1001        provider.anvil_set_balance(alice, U256::from(1e18 as u64)).await.unwrap();
1002
1003        let tx = TransactionRequest::default()
1004            .with_from(alice)
1005            .with_to(bob)
1006            .with_nonce(0)
1007            .with_chain_id(chain_id)
1008            .with_value(U256::from(100))
1009            .with_gas_limit(21_000)
1010            .with_max_priority_fee_per_gas(1_000_000_000)
1011            .with_max_fee_per_gas(20_000_000_000);
1012
1013        let tx_hash = provider.eth_send_unsigned_transaction(tx).await.unwrap();
1014
1015        provider.evm_mine(None).await.unwrap();
1016
1017        let res = provider.get_transaction_receipt(tx_hash).await.unwrap().unwrap();
1018        assert_eq!(res.from, alice);
1019        assert_eq!(res.to, Some(bob));
1020    }
1021}
alloy_provider/ext/anvil.rs

alloy_provider/ext/
anvil.rs
