anvil_zksync_api_server/impls/
anvil.rs

1use anvil_zksync_api_decl::AnvilNamespaceServer;
2use anvil_zksync_common::sh_warn;
3use anvil_zksync_core::node::InMemoryNode;
4use anvil_zksync_types::api::{DetailedTransaction, ResetRequest};
5use anvil_zksync_types::Numeric;
6use jsonrpsee::core::{async_trait, RpcResult};
7use zksync_types::api::Block;
8use zksync_types::web3::Bytes;
9use zksync_types::{Address, H256, U256, U64};
10
11use crate::error::{rpc_unsupported, RpcErrorAdapter};
12
13pub struct AnvilNamespace {
14    node: InMemoryNode,
15}
16
17impl AnvilNamespace {
18    pub fn new(node: InMemoryNode) -> Self {
19        Self { node }
20    }
21}
22
23#[async_trait]
24impl AnvilNamespaceServer for AnvilNamespace {
25    async fn dump_state(&self, preserve_historical_states: Option<bool>) -> RpcResult<Bytes> {
26        self.node
27            .dump_state(preserve_historical_states.unwrap_or(false))
28            .await
29            .map_err(RpcErrorAdapter::into)
30    }
31
32    async fn load_state(&self, bytes: Bytes) -> RpcResult<bool> {
33        self.node
34            .load_state(bytes)
35            .await
36            .map_err(RpcErrorAdapter::into)
37    }
38
39    async fn mine_detailed(&self) -> RpcResult<Block<DetailedTransaction>> {
40        self.node
41            .mine_detailed()
42            .await
43            .map_err(RpcErrorAdapter::into)
44    }
45
46    async fn set_rpc_url(&self, url: String) -> RpcResult<()> {
47        self.node
48            .set_rpc_url(url)
49            .await
50            .map_err(RpcErrorAdapter::into)
51    }
52
53    async fn set_next_block_base_fee_per_gas(&self, base_fee: U256) -> RpcResult<()> {
54        self.node
55            .set_next_block_base_fee_per_gas(base_fee)
56            .await
57            .map_err(RpcErrorAdapter::into)
58    }
59
60    async fn drop_transaction(&self, hash: H256) -> RpcResult<Option<H256>> {
61        self.node
62            .drop_transaction(hash)
63            .map_err(RpcErrorAdapter::into)
64    }
65
66    async fn drop_all_transactions(&self) -> RpcResult<()> {
67        self.node
68            .drop_all_transactions()
69            .map_err(RpcErrorAdapter::into)
70    }
71
72    async fn remove_pool_transactions(&self, address: Address) -> RpcResult<()> {
73        self.node
74            .remove_pool_transactions(address)
75            .map_err(RpcErrorAdapter::into)
76    }
77
78    async fn get_auto_mine(&self) -> RpcResult<bool> {
79        self.node
80            .get_immediate_sealing()
81            .map_err(RpcErrorAdapter::into)
82    }
83
84    async fn set_auto_mine(&self, enable: bool) -> RpcResult<()> {
85        self.node
86            .set_immediate_sealing(enable)
87            .await
88            .map_err(RpcErrorAdapter::into)
89    }
90
91    async fn set_interval_mining(&self, seconds: u64) -> RpcResult<()> {
92        self.node
93            .set_interval_sealing(seconds)
94            .await
95            .map_err(RpcErrorAdapter::into)
96    }
97
98    async fn set_block_timestamp_interval(&self, seconds: u64) -> RpcResult<()> {
99        self.node
100            .set_block_timestamp_interval(seconds)
101            .await
102            .map_err(RpcErrorAdapter::into)
103    }
104
105    async fn remove_block_timestamp_interval(&self) -> RpcResult<bool> {
106        self.node
107            .remove_block_timestamp_interval()
108            .await
109            .map_err(RpcErrorAdapter::into)
110    }
111
112    async fn set_min_gas_price(&self, _gas: U256) -> RpcResult<()> {
113        sh_warn!("Setting minimum gas price is unsupported as ZKsync is a post-EIP1559 chain");
114        rpc_unsupported("set_min_gas_price")
115    }
116
117    async fn set_logging_enabled(&self, enable: bool) -> RpcResult<()> {
118        self.node
119            .set_logging_enabled(enable)
120            .map_err(RpcErrorAdapter::into)
121    }
122
123    async fn snapshot(&self) -> RpcResult<U64> {
124        self.node.snapshot().await.map_err(RpcErrorAdapter::into)
125    }
126
127    async fn revert(&self, id: U64) -> RpcResult<bool> {
128        self.node
129            .revert_snapshot(id)
130            .await
131            .map_err(RpcErrorAdapter::into)
132    }
133
134    async fn set_time(&self, timestamp: Numeric) -> RpcResult<i128> {
135        self.node
136            .set_time(timestamp.into())
137            .await
138            .map_err(RpcErrorAdapter::into)
139    }
140
141    async fn increase_time(&self, seconds: Numeric) -> RpcResult<u64> {
142        self.node
143            .increase_time(seconds.into())
144            .await
145            .map_err(RpcErrorAdapter::into)
146    }
147
148    async fn set_next_block_timestamp(&self, timestamp: Numeric) -> RpcResult<()> {
149        self.node
150            .set_next_block_timestamp(timestamp.into())
151            .await
152            .map_err(RpcErrorAdapter::into)
153    }
154
155    async fn auto_impersonate_account(&self, enabled: bool) -> RpcResult<()> {
156        self.node.auto_impersonate_account(enabled);
157        Ok(())
158    }
159
160    async fn set_balance(&self, address: Address, balance: U256) -> RpcResult<bool> {
161        self.node
162            .set_balance(address, balance)
163            .await
164            .map_err(RpcErrorAdapter::into)
165    }
166
167    async fn set_nonce(&self, address: Address, nonce: U256) -> RpcResult<bool> {
168        self.node
169            .set_nonce(address, nonce)
170            .await
171            .map_err(RpcErrorAdapter::into)
172    }
173
174    async fn anvil_mine(&self, num_blocks: Option<U64>, interval: Option<U64>) -> RpcResult<()> {
175        self.node
176            .mine_blocks(num_blocks, interval)
177            .await
178            .map_err(RpcErrorAdapter::into)
179    }
180
181    async fn reset_network(&self, reset_spec: Option<ResetRequest>) -> RpcResult<bool> {
182        self.node
183            .reset_network(reset_spec)
184            .await
185            .map_err(RpcErrorAdapter::into)
186    }
187
188    async fn impersonate_account(&self, address: Address) -> RpcResult<()> {
189        self.node
190            .impersonate_account(address)
191            .map(|_| ())
192            .map_err(RpcErrorAdapter::into)
193    }
194
195    async fn stop_impersonating_account(&self, address: Address) -> RpcResult<()> {
196        self.node
197            .stop_impersonating_account(address)
198            .map(|_| ())
199            .map_err(RpcErrorAdapter::into)
200    }
201
202    async fn set_code(&self, address: Address, code: String) -> RpcResult<()> {
203        self.node
204            .set_code(address, code)
205            .await
206            .map_err(RpcErrorAdapter::into)
207    }
208
209    async fn set_storage_at(&self, address: Address, slot: U256, value: U256) -> RpcResult<bool> {
210        self.node
211            .set_storage_at(address, slot, value)
212            .await
213            .map_err(RpcErrorAdapter::into)
214    }
215
216    async fn set_chain_id(&self, id: u32) -> RpcResult<()> {
217        self.node
218            .set_chain_id(id)
219            .await
220            .map_err(RpcErrorAdapter::into)
221    }
222}
anvil_zksync_api_server/impls/anvil.rs

anvil_zksync_api_server/impls/
anvil.rs
