anvil_polkadot/substrate_node/service/
backend.rs

1use crate::substrate_node::service::{
2    Backend,
3    storage::{CodeInfo, ReviveAccountInfo, SystemAccountInfo, well_known_keys},
4};
5use alloy_primitives::{Address, Bytes};
6use codec::{Decode, Encode};
7use lru::LruCache;
8use parking_lot::Mutex;
9use polkadot_sdk::{
10    parachains_common::{AccountId, Hash, opaque::Block},
11    sc_client_api::{Backend as BackendT, StateBackend, TrieCacheContext},
12    sc_client_db::BlockchainDb,
13    sp_blockchain,
14    sp_core::{H160, H256},
15    sp_io::hashing::blake2_256,
16    sp_runtime::FixedU128,
17    sp_state_machine::{StorageKey, StorageValue},
18};
19use std::{collections::HashMap, num::NonZeroUsize, sync::Arc};
20use substrate_runtime::Balance;
21
22const DEFAULT_LRU_CAP: NonZeroUsize = NonZeroUsize::new(256).expect("256 is non-zero");
23
24#[derive(Debug, thiserror::Error)]
25pub enum BackendError {
26    #[error("Inner client error: {0}")]
27    Client(#[from] sp_blockchain::Error),
28    #[error("Could not find total issuance in the state")]
29    MissingTotalIssuance,
30    #[error("Could not find chain id in the state")]
31    MissingChainId,
32    #[error("Could not find aura authorities in the state")]
33    MissingAuraAuthorities,
34    #[error("Could not find timestamp in the state")]
35    MissingTimestamp,
36    #[error("Could not find the next fee multiplier in the state")]
37    MissingNextFeeMultiplier,
38    #[error("Could not find block number in the state")]
39    MissingBlockNumber,
40    #[error("Unable to decode total issuance {0}")]
41    DecodeTotalIssuance(codec::Error),
42    #[error("Unable to decode chain id {0}")]
43    DecodeChainId(codec::Error),
44    #[error("Unable to decode balance {0}")]
45    DecodeBalance(codec::Error),
46    #[error("Unable to decode revive account info {0}")]
47    DecodeReviveAccountInfo(codec::Error),
48    #[error("Unable to decode system account info {0}")]
49    DecodeSystemAccountInfo(codec::Error),
50    #[error("Unable to decode revive code info {0}")]
51    DecodeCodeInfo(codec::Error),
52    #[error("Unable to decode timestamp: {0}")]
53    DecodeTimestamp(codec::Error),
54    #[error("Unable to decode blockNumber: {0}")]
55    DecodeBlockNumber(codec::Error),
56    #[error("Unable to decode aura authorities: {0}")]
57    DecodeAuraAuthorities(codec::Error),
58    #[error("Unable to decode the next fee multiplier: {0}")]
59    DecodeNextFeeMultiplier(codec::Error),
60}
61
62type Result<T> = std::result::Result<T, BackendError>;
63
64pub struct BackendWithOverlay {
65    backend: Arc<Backend>,
66    overrides: Arc<Mutex<StorageOverrides>>,
67}
68
69impl BackendWithOverlay {
70    pub fn new(backend: Arc<Backend>, overrides: Arc<Mutex<StorageOverrides>>) -> Self {
71        Self { backend, overrides }
72    }
73
74    pub fn blockchain(&self) -> &BlockchainDb<Block> {
75        self.backend.blockchain()
76    }
77
78    pub fn read_timestamp(&self, hash: Hash) -> Result<u64> {
79        let key = well_known_keys::TIMESTAMP;
80
81        let value =
82            self.read_top_state(hash, key.to_vec())?.ok_or(BackendError::MissingTimestamp)?;
83        u64::decode(&mut &value[..]).map_err(BackendError::DecodeTimestamp)
84    }
85
86    pub fn read_block_number(&self, hash: Hash) -> Result<u32> {
87        let key = well_known_keys::BLOCK_NUMBER_KEY;
88        let value =
89            self.read_top_state(hash, key.to_vec())?.ok_or(BackendError::MissingBlockNumber)?;
90        u32::decode(&mut &value[..]).map_err(BackendError::DecodeBlockNumber)
91    }
92
93    pub fn read_chain_id(&self, hash: Hash) -> Result<u64> {
94        let key = well_known_keys::CHAIN_ID;
95
96        let value = self.read_top_state(hash, key.to_vec())?.ok_or(BackendError::MissingChainId)?;
97        u64::decode(&mut &value[..]).map_err(BackendError::DecodeChainId)
98    }
99
100    pub fn read_aura_authority(&self, hash: Hash) -> Result<AccountId> {
101        let key = well_known_keys::AURA_AUTHORITIES;
102
103        let value =
104            self.read_top_state(hash, key.to_vec())?.ok_or(BackendError::MissingAuraAuthorities)?;
105        let authorities = <Vec<[u8; 32]>>::decode(&mut &value[..])
106            .map_err(BackendError::DecodeAuraAuthorities)?;
107        // Read the first authority, since that's what we modify via RPC, or at genesis,
108        // and instruct the runtime to pick via the consensus data provider, whenever it
109        // needs the block author.
110        let authority = *authorities.first().ok_or(BackendError::MissingAuraAuthorities)?;
111        Ok(authority.into())
112    }
113
114    pub fn read_total_issuance(&self, hash: Hash) -> Result<Balance> {
115        let key = well_known_keys::TOTAL_ISSUANCE;
116
117        let value =
118            self.read_top_state(hash, key.to_vec())?.ok_or(BackendError::MissingTotalIssuance)?;
119        Balance::decode(&mut &value[..]).map_err(BackendError::DecodeTotalIssuance)
120    }
121
122    pub fn read_system_account_info(
123        &self,
124        hash: Hash,
125        account_id: AccountId,
126    ) -> Result<Option<SystemAccountInfo>> {
127        let key = well_known_keys::system_account_info(account_id);
128
129        self.read_top_state(hash, key)?
130            .map(|value| {
131                SystemAccountInfo::decode(&mut &value[..])
132                    .map_err(BackendError::DecodeSystemAccountInfo)
133            })
134            .transpose()
135    }
136
137    pub fn read_revive_account_info(
138        &self,
139        hash: Hash,
140        address: Address,
141    ) -> Result<Option<ReviveAccountInfo>> {
142        let key = well_known_keys::revive_account_info(H160::from_slice(address.as_slice()));
143
144        self.read_top_state(hash, key)?
145            .map(|value| {
146                ReviveAccountInfo::decode(&mut &value[..])
147                    .map_err(BackendError::DecodeReviveAccountInfo)
148            })
149            .transpose()
150    }
151
152    pub fn read_code_info(&self, hash: Hash, code_hash: H256) -> Result<Option<CodeInfo>> {
153        let key = well_known_keys::code_info(code_hash);
154
155        self.read_top_state(hash, key)?
156            .map(|value| CodeInfo::decode(&mut &value[..]).map_err(BackendError::DecodeCodeInfo))
157            .transpose()
158    }
159
160    pub fn inject_system_account_info(
161        &self,
162        at: Hash,
163        account_id: AccountId,
164        value: SystemAccountInfo,
165    ) {
166        let mut overrides = self.overrides.lock();
167        overrides.set_system_account_info(at, account_id, value);
168    }
169
170    pub fn inject_timestamp(&self, at: Hash, timestamp: u64) {
171        let mut overrides = self.overrides.lock();
172        overrides.set_timestamp(at, timestamp);
173    }
174
175    pub fn inject_chain_id(&self, at: Hash, chain_id: u64) {
176        let mut overrides = self.overrides.lock();
177        overrides.set_chain_id(at, chain_id);
178    }
179
180    pub fn inject_aura_authority(&self, at: Hash, aura_authority: AccountId) {
181        let mut overrides = self.overrides.lock();
182        overrides.set_coinbase(at, aura_authority);
183    }
184
185    pub fn inject_next_fee_multiplier(&self, at: Hash, next_fee_multiplier: FixedU128) {
186        let mut overrides = self.overrides.lock();
187        overrides.set_next_fee_multiplier(at, next_fee_multiplier);
188    }
189
190    pub fn inject_total_issuance(&self, at: Hash, value: Balance) {
191        let mut overrides = self.overrides.lock();
192        overrides.set_total_issuance(at, value);
193    }
194
195    pub fn inject_revive_account_info(&self, at: Hash, address: Address, info: ReviveAccountInfo) {
196        let mut overrides = self.overrides.lock();
197        overrides.set_revive_account_info(at, address, info);
198    }
199
200    pub fn inject_pristine_code(&self, at: Hash, code_hash: H256, code: Option<Bytes>) {
201        let mut overrides = self.overrides.lock();
202        overrides.set_pristine_code(at, code_hash, code);
203    }
204
205    pub fn inject_code_info(&self, at: Hash, code_hash: H256, code_info: Option<CodeInfo>) {
206        let mut overrides = self.overrides.lock();
207        overrides.set_code_info(at, code_hash, code_info);
208    }
209
210    pub fn inject_immutable_data(&self, at: Hash, address: Address, data: Vec<u8>) {
211        let mut overrides = self.overrides.lock();
212        overrides.set_immutable_data(at, address, data);
213    }
214
215    pub fn inject_child_storage(
216        &self,
217        at: Hash,
218        child_key: StorageKey,
219        key: StorageKey,
220        value: StorageValue,
221    ) {
222        let mut overrides = self.overrides.lock();
223        overrides.set_child_storage(at, child_key, key, value);
224    }
225
226    fn read_top_state(&self, hash: Hash, key: StorageKey) -> Result<Option<StorageValue>> {
227        let maybe_overridden_val = {
228            let mut guard = self.overrides.lock();
229
230            guard.per_block.get(&hash).and_then(|overrides| overrides.top.get(&key).cloned())
231        };
232
233        if let Some(overridden_val) = maybe_overridden_val {
234            return Ok(overridden_val);
235        }
236
237        let state = self.backend.state_at(hash, TrieCacheContext::Trusted)?;
238        Ok(state
239            .storage(key.as_slice())
240            .map_err(|e| sp_blockchain::Error::from_state(Box::new(e)))?)
241    }
242}
243
244pub type Storage = HashMap<StorageKey, Option<StorageValue>>;
245
246#[derive(Default, Clone)]
247pub struct BlockOverrides {
248    pub top: Storage,
249    pub children: HashMap<StorageKey, Storage>,
250}
251
252pub struct StorageOverrides {
253    // We keep N most recently used block state overrides because we may later get RPC calls which
254    // query the state of past blocks. When state is mutated by the `set_*` RPCs, it gets committed
255    // to the state DB only in the next block.
256    per_block: LruCache<Hash, BlockOverrides>,
257}
258
259impl StorageOverrides {
260    pub fn new(lru_capacity: Option<usize>) -> Self {
261        Self {
262            per_block: LruCache::new(
263                lru_capacity.and_then(NonZeroUsize::new).unwrap_or(DEFAULT_LRU_CAP),
264            ),
265        }
266    }
267
268    pub fn get(&mut self, block: &Hash) -> Option<BlockOverrides> {
269        self.per_block.get(block).cloned()
270    }
271
272    fn set_chain_id(&mut self, latest_block: Hash, id: u64) {
273        let mut changeset = BlockOverrides::default();
274        changeset.top.insert(well_known_keys::CHAIN_ID.to_vec(), Some(id.encode()));
275
276        self.add(latest_block, changeset);
277    }
278
279    fn set_coinbase(&mut self, latest_block: Hash, aura_authority: AccountId) {
280        let mut changeset = BlockOverrides::default();
281        changeset.top.insert(
282            well_known_keys::AURA_AUTHORITIES.to_vec(),
283            Some(vec![aura_authority].encode()),
284        );
285
286        self.add(latest_block, changeset);
287    }
288
289    fn set_timestamp(&mut self, latest_block: Hash, timestamp: u64) {
290        let mut changeset = BlockOverrides::default();
291        changeset.top.insert(well_known_keys::TIMESTAMP.to_vec(), Some(timestamp.encode()));
292
293        self.add(latest_block, changeset);
294    }
295
296    fn set_next_fee_multiplier(&mut self, latest_block: Hash, next_fee_multiplier: FixedU128) {
297        let mut changeset = BlockOverrides::default();
298        changeset.top.insert(
299            well_known_keys::NEXT_FEE_MULTIPLIER.to_vec(),
300            Some(next_fee_multiplier.encode()),
301        );
302
303        self.add(latest_block, changeset);
304    }
305
306    fn set_system_account_info(
307        &mut self,
308        latest_block: Hash,
309        account_id: AccountId,
310        info: SystemAccountInfo,
311    ) {
312        let mut changeset = BlockOverrides::default();
313        changeset.top.insert(well_known_keys::system_account_info(account_id), Some(info.encode()));
314
315        self.add(latest_block, changeset);
316    }
317
318    fn set_total_issuance(&mut self, latest_block: Hash, value: Balance) {
319        let mut changeset = BlockOverrides::default();
320        changeset.top.insert(well_known_keys::TOTAL_ISSUANCE.to_vec(), Some(value.encode()));
321
322        self.add(latest_block, changeset);
323    }
324
325    fn set_revive_account_info(
326        &mut self,
327        latest_block: Hash,
328        address: Address,
329        info: ReviveAccountInfo,
330    ) {
331        let mut changeset = BlockOverrides::default();
332        changeset.top.insert(
333            well_known_keys::revive_account_info(H160::from_slice(address.as_slice())),
334            Some(info.encode()),
335        );
336
337        self.add(latest_block, changeset);
338    }
339
340    fn set_pristine_code(&mut self, latest_block: Hash, code_hash: H256, code: Option<Bytes>) {
341        let mut changeset = BlockOverrides::default();
342
343        changeset
344            .top
345            .insert(well_known_keys::pristine_code(code_hash), code.map(|code| code.0.encode()));
346
347        self.add(latest_block, changeset);
348    }
349
350    fn set_code_info(&mut self, latest_block: Hash, code_hash: H256, code_info: Option<CodeInfo>) {
351        let mut changeset = BlockOverrides::default();
352
353        changeset.top.insert(
354            well_known_keys::code_info(code_hash),
355            code_info.map(|code_info| code_info.encode()),
356        );
357
358        self.add(latest_block, changeset);
359    }
360
361    fn set_immutable_data(&mut self, latest_block: Hash, address: Address, data: Vec<u8>) {
362        let mut changeset = BlockOverrides::default();
363
364        // SCALE-encode as BoundedVec<u8>: compact_length prefix followed by raw bytes
365        let mut encoded = codec::Compact(data.len() as u32).encode();
366        encoded.extend_from_slice(&data);
367
368        changeset.top.insert(
369            well_known_keys::immutable_data_of(H160::from_slice(address.as_slice())),
370            Some(encoded),
371        );
372
373        self.add(latest_block, changeset);
374    }
375
376    fn set_child_storage(
377        &mut self,
378        latest_block: Hash,
379        child_key: StorageKey,
380        key: StorageKey,
381        value: StorageValue,
382    ) {
383        let mut changeset = BlockOverrides::default();
384
385        let mut child_map = Storage::with_capacity(1);
386        child_map.insert(blake2_256(key.as_slice()).to_vec(), Some(value));
387
388        changeset.children.insert(child_key, child_map);
389
390        self.add(latest_block, changeset);
391    }
392
393    fn add(&mut self, latest_block: Hash, changeset: BlockOverrides) {
394        if let Some(per_block) = self.per_block.get_mut(&latest_block) {
395            per_block.top.extend(changeset.top);
396
397            for (child_key, child_map) in changeset.children {
398                per_block.children.entry(child_key).or_default().extend(child_map);
399            }
400        } else {
401            self.per_block.put(latest_block, changeset);
402        }
403    }
404}
anvil_polkadot/substrate_node/service/backend.rs

anvil_polkadot/substrate_node/service/
backend.rs
