Skip to content

Commit f15d6d7

Browse files
kariykariy
committed
merge fix
1 parent 01eb014 commit f15d6d7

File tree

3 files changed

+46
-39
lines changed

3 files changed

+46
-39
lines changed

‎crates/node/src/lib.rs‎

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -475,8 +475,9 @@ where
475475
// let disk_metrics = Box::new(DiskReporter::new(self.db.path())?) as Box<dyn Report>;
476476
// let reports: Vec<Box<dyn Report>> = vec![db_metrics, disk_metrics];
477477

478-
// let exporter = PrometheusRecorder::current().expect("qed; should exist at this point");
479-
// let server = MetricsServer::new(exporter).with_process_metrics().with_reports(reports);
478+
// let exporter = PrometheusRecorder::current().expect("qed; should exist at this
479+
// point"); let server =
480+
// MetricsServer::new(exporter).with_process_metrics().with_reports(reports);
480481

481482
// let addr = cfg.socket_addr();
482483
// self.task_manager.task_spawner().build_task().spawn(server.start(addr));

‎crates/storage/provider/provider/src/providers/fork/state.rs‎

Lines changed: 41 additions & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -177,18 +177,18 @@ impl<Tx1: DbTx, Tx2: DbTxMut> StateProvider for LatestStateProvider<Tx1, Tx2> {
177177

178178
impl<Tx1: DbTx, Tx2: DbTxMut> StateProofProvider for LatestStateProvider<Tx1, Tx2> {
179179
fn class_multiproof(&self, classes: Vec<ClassHash>) -> ProviderResult<katana_trie::MultiProof> {
180-
let fork_point = self.fork_db.block_id;
180+
let fork_point = self.fork_provider.block_id;
181181
let latest_block_number = match self.local_provider.latest_number() {
182182
Ok(num) => num,
183183
// return the fork block number if local db return this error. this can only happen whne
184184
// the ForkedProvider is constructed without inserting any locally produced
185185
// blocks.
186-
Err(ProviderError::MissingLatestBlockNumber) => self.fork_db.block_id,
186+
Err(ProviderError::MissingLatestBlockNumber) => self.fork_provider.block_id,
187187
Err(err) => return Err(err),
188188
};
189189

190190
if latest_block_number == fork_point {
191-
let result = self.fork_db.backend.get_classes_proofs(classes, fork_point)?;
191+
let result = self.fork_provider.backend.get_classes_proofs(classes, fork_point)?;
192192
let proofs = result.expect("proofs should exist for block");
193193

194194
Ok(proofs.classes_proof.nodes.into())
@@ -201,18 +201,18 @@ impl<Tx1: DbTx, Tx2: DbTxMut> StateProofProvider for LatestStateProvider<Tx1, Tx
201201
&self,
202202
addresses: Vec<ContractAddress>,
203203
) -> ProviderResult<katana_trie::MultiProof> {
204-
let fork_point = self.local_fork_db.block_id;
205-
let latest_block_number = match self.db.latest_number() {
204+
let fork_point = self.fork_provider.block_id;
205+
let latest_block_number = match self.local_provider.latest_number() {
206206
Ok(num) => num,
207207
// return the fork block number if local db return this error. this can only happen whne
208208
// the ForkedProvider is constructed without inserting any locally produced
209209
// blocks.
210-
Err(ProviderError::MissingLatestBlockNumber) => self.fork_db.block_id,
210+
Err(ProviderError::MissingLatestBlockNumber) => self.fork_provider.block_id,
211211
Err(err) => return Err(err),
212212
};
213213

214214
if latest_block_number == fork_point {
215-
let result = self.fork_db.backend.get_contracts_proofs(addresses, fork_point)?;
215+
let result = self.fork_provider.backend.get_contracts_proofs(addresses, fork_point)?;
216216
let proofs = result.expect("proofs should exist for block");
217217

218218
Ok(proofs.classes_proof.nodes.into())
@@ -226,19 +226,19 @@ impl<Tx1: DbTx, Tx2: DbTxMut> StateProofProvider for LatestStateProvider<Tx1, Tx
226226
address: ContractAddress,
227227
storage_keys: Vec<StorageKey>,
228228
) -> ProviderResult<katana_trie::MultiProof> {
229-
let fork_point = self.fork_db.block_id;
230-
let latest_block_number = match self.db.latest_number() {
229+
let fork_point = self.fork_provider.block_id;
230+
let latest_block_number = match self.local_provider.latest_number() {
231231
Ok(num) => num,
232232
// return the fork block number if local db return this error. this can only happen whne
233233
// the ForkedProvider is constructed without inserting any locally produced
234234
// blocks.
235-
Err(ProviderError::MissingLatestBlockNumber) => self.fork_db.block_id,
235+
Err(ProviderError::MissingLatestBlockNumber) => self.fork_provider.block_id,
236236
Err(err) => return Err(err),
237237
};
238238

239239
if latest_block_number == fork_point {
240240
let key = vec![ContractStorageKeys { address, keys: storage_keys }];
241-
let result = self.fork_db.backend.get_storages_proofs(key, fork_point)?;
241+
let result = self.fork_provider.backend.get_storages_proofs(key, fork_point)?;
242242

243243
let mut proofs = result.expect("proofs should exist for block");
244244
let proofs = proofs.contracts_storage_proofs.nodes.pop().unwrap();
@@ -252,18 +252,18 @@ impl<Tx1: DbTx, Tx2: DbTxMut> StateProofProvider for LatestStateProvider<Tx1, Tx
252252

253253
impl<Tx1: DbTx, Tx2: DbTxMut> StateRootProvider for LatestStateProvider<Tx1, Tx2> {
254254
fn classes_root(&self) -> ProviderResult<Felt> {
255-
let fork_point = self.fork_db.block_id;
256-
let latest_block_number = match self.db.latest_number() {
255+
let fork_point = self.fork_provider.block_id;
256+
let latest_block_number = match self.local_provider.latest_number() {
257257
Ok(num) => num,
258258
// return the fork block number if local db return this error. this can only happen whne
259259
// the ForkedProvider is constructed without inserting any locally produced
260260
// blocks.
261-
Err(ProviderError::MissingLatestBlockNumber) => self.fork_db.block_id,
261+
Err(ProviderError::MissingLatestBlockNumber) => self.fork_provider.block_id,
262262
Err(err) => return Err(err),
263263
};
264264

265265
if latest_block_number == fork_point {
266-
let result = self.fork_db.backend.get_global_roots(fork_point)?;
266+
let result = self.fork_provider.backend.get_global_roots(fork_point)?;
267267
let roots = result.expect("proofs should exist for block");
268268

269269
Ok(roots.global_roots.classes_tree_root)
@@ -273,18 +273,18 @@ impl<Tx1: DbTx, Tx2: DbTxMut> StateRootProvider for LatestStateProvider<Tx1, Tx2
273273
}
274274

275275
fn contracts_root(&self) -> ProviderResult<Felt> {
276-
let fork_point = self.fork_db.block_id;
277-
let latest_block_number = match self.db.latest_number() {
276+
let fork_point = self.fork_provider.block_id;
277+
let latest_block_number = match self.local_provider.latest_number() {
278278
Ok(num) => num,
279279
// return the fork block number if local db return this error. this can only happen whne
280280
// the ForkedProvider is constructed without inserting any locally produced
281281
// blocks.
282-
Err(ProviderError::MissingLatestBlockNumber) => self.fork_db.block_id,
282+
Err(ProviderError::MissingLatestBlockNumber) => self.fork_provider.block_id,
283283
Err(err) => return Err(err),
284284
};
285285

286286
if latest_block_number == fork_point {
287-
let result = self.fork_db.backend.get_global_roots(fork_point)?;
287+
let result = self.fork_provider.backend.get_global_roots(fork_point)?;
288288
let roots = result.expect("proofs should exist for block");
289289

290290
Ok(roots.global_roots.contracts_tree_root)
@@ -294,18 +294,18 @@ impl<Tx1: DbTx, Tx2: DbTxMut> StateRootProvider for LatestStateProvider<Tx1, Tx2
294294
}
295295

296296
fn storage_root(&self, contract: ContractAddress) -> ProviderResult<Option<Felt>> {
297-
let fork_point = self.fork_db.block_id;
298-
let latest_block_number = match self.db.latest_number() {
297+
let fork_point = self.fork_provider.block_id;
298+
let latest_block_number = match self.local_provider.latest_number() {
299299
Ok(num) => num,
300300
// return the fork block number if local db return this error. this can only happen whne
301301
// the ForkedProvider is constructed without inserting any locally produced
302302
// blocks.
303-
Err(ProviderError::MissingLatestBlockNumber) => self.fork_db.block_id,
303+
Err(ProviderError::MissingLatestBlockNumber) => self.fork_provider.block_id,
304304
Err(err) => return Err(err),
305305
};
306306

307307
if latest_block_number == fork_point {
308-
let result = self.fork_db.backend.get_storage_root(contract, fork_point)?;
308+
let result = self.fork_provider.backend.get_storage_root(contract, fork_point)?;
309309
let root = result.expect("proofs should exist for block");
310310
Ok(Some(root))
311311
} else {
@@ -450,11 +450,12 @@ impl<Tx1: DbTx, Tx2: DbTxMut> StateProvider for HistoricalStateProvider<Tx1, Tx2
450450
impl<Tx1: DbTx, Tx2: DbTxMut> StateProofProvider for HistoricalStateProvider<Tx1, Tx2> {
451451
fn class_multiproof(&self, classes: Vec<ClassHash>) -> ProviderResult<katana_trie::MultiProof> {
452452
// we don't have a way to construct state proofs for locally generated state yet
453-
if self.provider.block() > self.fork_db.block_id {
453+
if self.local_provider.block() > self.fork_provider.block_id {
454454
return Err(ProviderError::StateProofNotSupported);
455455
}
456456

457-
let result = self.fork_db.backend.get_classes_proofs(classes, self.provider.block())?;
457+
let result =
458+
self.fork_provider.backend.get_classes_proofs(classes, self.local_provider.block())?;
458459
let proofs = result.expect("block should exist");
459460

460461
Ok(proofs.classes_proof.nodes.into())
@@ -465,11 +466,14 @@ impl<Tx1: DbTx, Tx2: DbTxMut> StateProofProvider for HistoricalStateProvider<Tx1
465466
addresses: Vec<ContractAddress>,
466467
) -> ProviderResult<katana_trie::MultiProof> {
467468
// we don't have a way to construct state proofs for locally generated state yet
468-
if self.provider.block() > self.fork_db.block_id {
469+
if self.local_provider.block() > self.fork_provider.block_id {
469470
return Err(ProviderError::StateProofNotSupported);
470471
}
471472

472-
let result = self.fork_db.backend.get_contracts_proofs(addresses, self.provider.block())?;
473+
let result = self
474+
.fork_provider
475+
.backend
476+
.get_contracts_proofs(addresses, self.local_provider.block())?;
473477
let proofs = result.expect("block should exist");
474478

475479
Ok(proofs.classes_proof.nodes.into())
@@ -481,12 +485,13 @@ impl<Tx1: DbTx, Tx2: DbTxMut> StateProofProvider for HistoricalStateProvider<Tx1
481485
storage_keys: Vec<StorageKey>,
482486
) -> ProviderResult<katana_trie::MultiProof> {
483487
// we don't have a way to construct state proofs for locally generated state yet
484-
if self.provider.block() > self.fork_db.block_id {
488+
if self.local_provider.block() > self.fork_provider.block_id {
485489
return Err(ProviderError::StateProofNotSupported);
486490
}
487491

488492
let key = vec![ContractStorageKeys { address, keys: storage_keys }];
489-
let result = self.fork_db.backend.get_storages_proofs(key, self.provider.block())?;
493+
let result =
494+
self.fork_provider.backend.get_storages_proofs(key, self.local_provider.block())?;
490495

491496
let mut proofs = result.expect("block should exist");
492497
let proofs = proofs.contracts_storage_proofs.nodes.pop().unwrap();
@@ -521,33 +526,34 @@ impl<Tx1: DbTx, Tx2: DbTxMut> StateRootProvider for HistoricalStateProvider<Tx1,
521526

522527
fn classes_root(&self) -> ProviderResult<Felt> {
523528
// note: we are not computing the state trie correctly for block post-fork
524-
if self.provider.block() > self.fork_db.block_id {
529+
if self.local_provider.block() > self.fork_provider.block_id {
525530
return Ok(Felt::ZERO);
526531
}
527532

528-
let result = self.fork_db.backend.get_global_roots(self.provider.block())?;
533+
let result = self.fork_provider.backend.get_global_roots(self.local_provider.block())?;
529534
let roots = result.expect("block should exist");
530535
Ok(roots.global_roots.classes_tree_root)
531536
}
532537

533538
fn contracts_root(&self) -> ProviderResult<Felt> {
534539
// note: we are not computing the state trie correctly for block post-fork
535-
if self.provider.block() > self.fork_db.block_id {
540+
if self.local_provider.block() > self.fork_provider.block_id {
536541
return Ok(Felt::ZERO);
537542
}
538543

539-
let result = self.fork_db.backend.get_global_roots(self.provider.block())?;
544+
let result = self.fork_provider.backend.get_global_roots(self.local_provider.block())?;
540545
let roots = result.expect("block should exist");
541546
Ok(roots.global_roots.contracts_tree_root)
542547
}
543548

544549
fn storage_root(&self, contract: ContractAddress) -> ProviderResult<Option<Felt>> {
545550
// note: we are not computing the state trie correctly for block post-fork
546-
if self.provider.block() > self.fork_db.block_id {
551+
if self.local_provider.block() > self.fork_provider.block_id {
547552
return Ok(None);
548553
}
549554

550-
let result = self.fork_db.backend.get_storage_root(contract, self.provider.block())?;
555+
let result =
556+
self.fork_provider.backend.get_storage_root(contract, self.local_provider.block())?;
551557
Ok(result)
552558
}
553559
}

‎crates/sync/stage/src/trie.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,10 +1,10 @@
11
use futures::future::BoxFuture;
22
use katana_primitives::block::BlockNumber;
33
use katana_primitives::Felt;
4+
use katana_provider::api::block::HeaderProvider;
45
use katana_provider::api::state_update::StateUpdateProvider;
56
use katana_provider::api::trie::TrieWriter;
6-
use katana_provider::ProviderFactory;
7-
use katana_provider::{api::block::HeaderProvider, MutableProvider};
7+
use katana_provider::{MutableProvider, ProviderFactory};
88
use starknet::macros::short_string;
99
use starknet_types_core::hash::{Poseidon, StarkHash};
1010
use tracing::{debug, debug_span, error};

0 commit comments

Comments
 (0)