Skip to content
This repository was archived by the owner on Jul 22, 2024. It is now read-only.

Commit f88c756

Browse files
edg-ledg-l
committed
dont need a transactional state reader, simply clone the state reader
1 parent 26e8859 commit f88c756

File tree

8 files changed

+30
-142
lines changed

8 files changed

+30
-142
lines changed

‎cli/src/main.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -202,7 +202,7 @@ fn invoke_parser(
202202
)?;
203203
let mut transactional_state = cached_state.create_transactional();
204204
let _tx_info = internal_invoke.apply(&mut transactional_state, &BlockContext::default(), 0)?;
205-
cached_state.apply_state_update(&StateDiff::from_cached_state(transactional_state)?)?;
205+
cached_state.apply_state_update(&StateDiff::from_cached_state(transactional_state.cache())?)?;
206206

207207
let tx_hash = calculate_transaction_hash_common(
208208
TransactionHashPrefix::Invoke,

‎src/execution/execution_entry_point.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -175,7 +175,7 @@ impl ExecutionEntryPoint {
175175
) {
176176
Ok(call_info) => {
177177
state.apply_state_update(&StateDiff::from_cached_state(
178-
transactional_state,
178+
transactional_state.cache(),
179179
)?)?;
180180

181181
Ok(ExecutionResult {
@@ -187,7 +187,7 @@ impl ExecutionEntryPoint {
187187
Err(e) => {
188188
if !support_reverted {
189189
state.apply_state_update(&StateDiff::from_cached_state(
190-
transactional_state,
190+
transactional_state.cache(),
191191
)?)?;
192192

193193
return Err(e);

‎src/state/cached_state.rs

+2-111
Original file line numberDiff line numberDiff line change
@@ -105,10 +105,9 @@ impl<T: StateReader> CachedState<T> {
105105

106106
/// Creates a copy of this state with an empty cache for saving changes and applying them
107107
/// later.
108-
pub fn create_transactional(&self) -> TransactionalCachedState<T> {
109-
let state_reader = Arc::new(TransactionalCachedStateReader::new(self));
108+
pub fn create_transactional(&self) -> CachedState<T> {
110109
CachedState {
111-
state_reader,
110+
state_reader: self.state_reader.clone(),
112111
cache: self.cache.clone(),
113112
contract_classes: self.contract_classes.clone(),
114113
cache_hits: 0,
@@ -483,114 +482,6 @@ impl<T: StateReader> State for CachedState<T> {
483482
}
484483
}
485484

486-
/// A CachedState which has access to another, "parent" state, used for executing transactions
487-
/// without commiting changes to the parent.
488-
pub type TransactionalCachedState<'a, T> = CachedState<TransactionalCachedStateReader<'a, T>>;
489-
490-
/// State reader used for transactional states which allows to check the parent state's cache and
491-
/// state reader if a transactional cache miss happens.
492-
///
493-
/// In practice this will act as a way to access the parent state's cache and other fields,
494-
/// without referencing the whole parent state, so there's no need to adapt state-modifying
495-
/// functions in the case that a transactional state is needed.
496-
#[derive(Debug, MutGetters, Getters, PartialEq, Clone)]
497-
pub struct TransactionalCachedStateReader<'a, T: StateReader> {
498-
/// The parent state's state_reader
499-
#[get(get = "pub")]
500-
pub(crate) state_reader: Arc<T>,
501-
/// The parent state's cache
502-
#[get(get = "pub")]
503-
pub(crate) cache: &'a StateCache,
504-
/// The parent state's contract_classes
505-
#[get(get = "pub")]
506-
pub(crate) contract_classes: ContractClassCache,
507-
}
508-
509-
impl<'a, T: StateReader> TransactionalCachedStateReader<'a, T> {
510-
fn new(state: &'a CachedState<T>) -> Self {
511-
Self {
512-
state_reader: state.state_reader.clone(),
513-
cache: &state.cache,
514-
contract_classes: state.contract_classes.clone(),
515-
}
516-
}
517-
}
518-
519-
impl<'a, T: StateReader> StateReader for TransactionalCachedStateReader<'a, T> {
520-
/// Returns the class hash for a given contract address.
521-
/// Returns zero as default value if missing
522-
fn get_class_hash_at(&self, contract_address: &Address) -> Result<ClassHash, StateError> {
523-
self.cache
524-
.get_class_hash(contract_address)
525-
.map(|a| Ok(*a))
526-
.unwrap_or_else(|| self.state_reader.get_class_hash_at(contract_address))
527-
}
528-
529-
/// Returns the nonce for a given contract address.
530-
fn get_nonce_at(&self, contract_address: &Address) -> Result<Felt252, StateError> {
531-
if self.cache.get_nonce(contract_address).is_none() {
532-
return self.state_reader.get_nonce_at(contract_address);
533-
}
534-
self.cache
535-
.get_nonce(contract_address)
536-
.ok_or_else(|| StateError::NoneNonce(contract_address.clone()))
537-
.cloned()
538-
}
539-
540-
/// Returns storage data for a given storage entry.
541-
/// Returns zero as default value if missing
542-
fn get_storage_at(&self, storage_entry: &StorageEntry) -> Result<Felt252, StateError> {
543-
self.cache
544-
.get_storage(storage_entry)
545-
.map(|v| Ok(v.clone()))
546-
.unwrap_or_else(|| self.state_reader.get_storage_at(storage_entry))
547-
}
548-
549-
// TODO: check if that the proper way to store it (converting hash to address)
550-
/// Returned the compiled class hash for a given class hash.
551-
fn get_compiled_class_hash(&self, class_hash: &ClassHash) -> Result<ClassHash, StateError> {
552-
if self
553-
.cache
554-
.class_hash_to_compiled_class_hash
555-
.get(class_hash)
556-
.is_none()
557-
{
558-
return self.state_reader.get_compiled_class_hash(class_hash);
559-
}
560-
self.cache
561-
.class_hash_to_compiled_class_hash
562-
.get(class_hash)
563-
.ok_or_else(|| StateError::NoneCompiledClass(*class_hash))
564-
.cloned()
565-
}
566-
567-
/// Returns the contract class for a given class hash.
568-
fn get_contract_class(&self, class_hash: &ClassHash) -> Result<CompiledClass, StateError> {
569-
// This method can receive both compiled_class_hash & class_hash and return both casm and deprecated contract classes
570-
//, which can be on the cache or on the state_reader, different cases will be described below:
571-
if class_hash == UNINITIALIZED_CLASS_HASH {
572-
return Err(StateError::UninitiaizedClassHash);
573-
}
574-
575-
// I: FETCHING FROM CACHE
576-
if let Some(compiled_class) = self.contract_classes.get(class_hash) {
577-
return Ok(compiled_class.clone());
578-
}
579-
580-
// I: CASM CONTRACT CLASS : CLASS_HASH
581-
if let Some(compiled_class_hash) =
582-
self.cache.class_hash_to_compiled_class_hash.get(class_hash)
583-
{
584-
if let Some(casm_class) = self.contract_classes.get(compiled_class_hash) {
585-
return Ok(casm_class.clone());
586-
}
587-
}
588-
589-
// II: FETCHING FROM STATE_READER
590-
self.state_reader.get_contract_class(class_hash)
591-
}
592-
}
593-
594485
impl<T: StateReader> CachedState<T> {
595486
// Updates the cache's storage_initial_values according to those in storage_writes
596487
// If a key is present in the storage_writes but not in storage_initial_values,

‎src/state/mod.rs

+9-14
Original file line numberDiff line numberDiff line change
@@ -18,7 +18,7 @@ use crate::{
1818
utils::{Address, ClassHash},
1919
};
2020

21-
use self::{cached_state::CachedState, state_api::StateReader};
21+
use self::{cached_state::CachedState, state_api::StateReader, state_cache::StateCache};
2222

2323
#[derive(Clone, Debug, PartialEq, Eq)]
2424
pub struct BlockInfo {
@@ -125,18 +125,13 @@ impl StateDiff {
125125
}
126126
}
127127

128-
pub fn from_cached_state<T>(cached_state: CachedState<T>) -> Result<Self, StateError>
129-
where
130-
T: StateReader,
131-
{
132-
let state_cache = cached_state.cache().to_owned();
133-
134-
let substracted_maps = state_cache.storage_writes;
128+
pub fn from_cached_state(state_cache: &StateCache) -> Result<Self, StateError> {
129+
let substracted_maps = &state_cache.storage_writes;
135130
let storage_updates = to_state_diff_storage_mapping(substracted_maps);
136131

137-
let address_to_nonce = state_cache.nonce_writes;
138-
let class_hash_to_compiled_class = state_cache.compiled_class_hash_writes;
139-
let address_to_class_hash = state_cache.class_hash_writes;
132+
let address_to_nonce = state_cache.nonce_writes.clone();
133+
let class_hash_to_compiled_class = state_cache.compiled_class_hash_writes.clone();
134+
let address_to_class_hash = state_cache.class_hash_writes.clone();
140135

141136
Ok(StateDiff {
142137
address_to_class_hash,
@@ -248,7 +243,7 @@ mod test {
248243

249244
let cached_state = CachedState::new(Arc::new(state_reader), HashMap::new());
250245

251-
let diff = StateDiff::from_cached_state(cached_state).unwrap();
246+
let diff = StateDiff::from_cached_state(&cached_state.cache).unwrap();
252247

253248
assert_eq!(0, diff.storage_updates.len());
254249
}
@@ -319,7 +314,7 @@ mod test {
319314
let cached_state_original =
320315
CachedState::new(Arc::new(state_reader.clone()), HashMap::new());
321316

322-
let diff = StateDiff::from_cached_state(cached_state_original.clone()).unwrap();
317+
let diff = StateDiff::from_cached_state(cached_state_original.cache()).unwrap();
323318

324319
let cached_state = diff.to_cached_state(Arc::new(state_reader)).unwrap();
325320

@@ -367,7 +362,7 @@ mod test {
367362
let cached_state =
368363
CachedState::new_for_testing(Arc::new(state_reader), cache, HashMap::new());
369364

370-
let mut diff = StateDiff::from_cached_state(cached_state).unwrap();
365+
let mut diff = StateDiff::from_cached_state(cached_state.cache()).unwrap();
371366

372367
let diff_squashed = diff.squash(diff.clone());
373368

‎src/syscalls/deprecated_syscall_handler.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -1189,7 +1189,7 @@ mod tests {
11891189
.unwrap();
11901190

11911191
state
1192-
.apply_state_update(&StateDiff::from_cached_state(transactional).unwrap())
1192+
.apply_state_update(&StateDiff::from_cached_state(transactional.cache()).unwrap())
11931193
.unwrap();
11941194

11951195
let result_call_info = result.call_info.unwrap();

‎src/transaction/deploy_account.rs

+2-1
Original file line numberDiff line numberDiff line change
@@ -190,7 +190,8 @@ impl DeployAccount {
190190
.as_str(),
191191
);
192192
} else {
193-
state.apply_state_update(&StateDiff::from_cached_state(transactional_state)?)?;
193+
state
194+
.apply_state_update(&StateDiff::from_cached_state(transactional_state.cache())?)?;
194195
}
195196

196197
let mut tx_execution_context =

‎src/transaction/invoke_function.rs

+6-5
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,7 @@ use crate::{
1717
},
1818
services::api::contract_classes::deprecated_contract_class::EntryPointType,
1919
state::{
20-
cached_state::{CachedState, TransactionalCachedState},
20+
cached_state::CachedState,
2121
state_api::{State, StateReader},
2222
ExecutionResourcesManager, StateDiff,
2323
},
@@ -239,7 +239,7 @@ impl InvokeFunction {
239239
/// - remaining_gas: The amount of gas that the transaction disposes.
240240
pub fn apply<S: StateReader>(
241241
&self,
242-
state: &mut TransactionalCachedState<S>,
242+
state: &mut CachedState<S>,
243243
block_context: &BlockContext,
244244
remaining_gas: u128,
245245
) -> Result<TransactionExecutionInfo, TransactionError> {
@@ -334,7 +334,8 @@ impl InvokeFunction {
334334
.as_str(),
335335
);
336336
} else {
337-
state.apply_state_update(&StateDiff::from_cached_state(transactional_state)?)?;
337+
state
338+
.apply_state_update(&StateDiff::from_cached_state(transactional_state.cache())?)?;
338339
}
339340

340341
let mut tx_execution_context =
@@ -674,7 +675,7 @@ mod tests {
674675
.apply(&mut transactional, &BlockContext::default(), 0)
675676
.unwrap();
676677
state
677-
.apply_state_update(&StateDiff::from_cached_state(transactional).unwrap())
678+
.apply_state_update(&StateDiff::from_cached_state(transactional.cache()).unwrap())
678679
.unwrap();
679680

680681
assert_eq!(result.tx_type, Some(TransactionType::InvokeFunction));
@@ -882,7 +883,7 @@ mod tests {
882883
.apply(&mut transactional, &BlockContext::default(), 0)
883884
.unwrap();
884885
state
885-
.apply_state_update(&StateDiff::from_cached_state(transactional).unwrap())
886+
.apply_state_update(&StateDiff::from_cached_state(transactional.cache()).unwrap())
886887
.unwrap();
887888

888889
assert_eq!(result.tx_type, Some(TransactionType::InvokeFunction));

‎src/utils.rs

+7-7
Original file line numberDiff line numberDiff line change
@@ -135,17 +135,17 @@ pub fn string_to_hash(class_string: &String) -> ClassHash {
135135

136136
/// Converts CachedState storage mapping to StateDiff storage mapping.
137137
pub fn to_state_diff_storage_mapping(
138-
storage_writes: HashMap<StorageEntry, Felt252>,
138+
storage_writes: &HashMap<StorageEntry, Felt252>,
139139
) -> HashMap<Address, HashMap<Felt252, Felt252>> {
140140
let mut storage_updates: HashMap<Address, HashMap<Felt252, Felt252>> = HashMap::new();
141-
for ((address, key), value) in storage_writes.into_iter() {
141+
for ((address, key), value) in storage_writes.iter() {
142142
storage_updates
143-
.entry(address)
143+
.entry(address.clone())
144144
.and_modify(|updates_for_address: &mut HashMap<Felt252, Felt252>| {
145-
let key_fe = Felt252::from_bytes_be(&key);
145+
let key_fe = Felt252::from_bytes_be(key);
146146
updates_for_address.insert(key_fe, value.clone());
147147
})
148-
.or_insert_with(|| HashMap::from([(Felt252::from_bytes_be(&key), value)]));
148+
.or_insert_with(|| HashMap::from([(Felt252::from_bytes_be(key), value.clone())]));
149149
}
150150
storage_updates
151151
}
@@ -806,7 +806,7 @@ mod test {
806806
storage.insert((address1.clone(), key1), value1.clone());
807807
storage.insert((address2.clone(), key2), value2.clone());
808808

809-
let map = to_state_diff_storage_mapping(storage);
809+
let map = to_state_diff_storage_mapping(&storage);
810810

811811
let key1_fe = Felt252::from_bytes_be(key1.as_slice());
812812
let key2_fe = Felt252::from_bytes_be(key2.as_slice());
@@ -877,7 +877,7 @@ mod test {
877877
storage.insert((address1.clone(), key1), value1.clone());
878878
storage.insert((address2.clone(), key2), value2.clone());
879879

880-
let state_dff = to_state_diff_storage_mapping(storage);
880+
let state_dff = to_state_diff_storage_mapping(&storage);
881881
let cache_storage = to_cache_state_storage_mapping(&state_dff);
882882

883883
let mut expected_res = HashMap::new();

0 commit comments

Comments
 (0)