Skip to content

Commit 3269296

Browse files
kariykariy
committed
fix
1 parent f1c567a commit 3269296

File tree

8 files changed

+97
-92
lines changed

8 files changed

+97
-92
lines changed

‎crates/core/src/service/block_producer.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -694,7 +694,7 @@ where
694694

695695
// TODO: don't use the previous block env, we should create on based on the current state of
696696
// the l1 (to determine the proper gas prices)
697-
let latest_num = dbg!(provider.latest_number()?);
697+
let latest_num = provider.latest_number()?;
698698
let mut block_env = provider.block_env_at(BlockHashOrNumber::Num(latest_num))?.unwrap();
699699
backend.update_block_env(&mut block_env);
700700

‎crates/node/src/lib.rs‎

Lines changed: 0 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -172,9 +172,7 @@ where
172172
chain_spec: config.chain.clone(),
173173
});
174174

175-
println!("initializing genesis");
176175
backend.init_genesis(config.forking.is_some()).context("failed to initialize genesis")?;
177-
println!("genesis initialized");
178176

179177
// --- build block producer
180178

@@ -308,8 +306,6 @@ where
308306
None
309307
};
310308

311-
println!("node built");
312-
313309
Ok(Node {
314310
provider,
315311
pool,
@@ -423,7 +419,6 @@ impl Node<ForkProviderFactory> {
423419

424420
block.header.l1_da_mode = forked_block.l1_da_mode;
425421

426-
println!("ohayo");
427422
Self::build_with_provider(provider_factory, config)
428423
}
429424
}

‎crates/rpc/rpc-server/tests/dev.rs‎

Lines changed: 57 additions & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -8,24 +8,33 @@ use katana_utils::TestNode;
88
async fn test_next_block_timestamp_in_past() {
99
let sequencer = TestNode::new().await;
1010
let backend = sequencer.backend();
11-
let provider = backend.storage.provider();
1211

1312
// Create a jsonrpsee client for the DevApi
1413
let client = sequencer.rpc_http_client();
1514

16-
let block_num = provider.latest_number().unwrap();
17-
let mut block_env = provider.block_env_at(block_num.into()).unwrap().unwrap();
18-
backend.update_block_env(&mut block_env);
15+
let block1 = {
16+
let provider = backend.storage.provider();
1917

20-
let block1 = backend.mine_empty_block(&block_env).unwrap().block_number;
21-
let block1_timestamp = provider.block(block1.into()).unwrap().unwrap().header.timestamp;
22-
client.set_next_block_timestamp(block1_timestamp - 1000).await.unwrap();
18+
let block_num = provider.latest_number().unwrap();
19+
let mut block_env = provider.block_env_at(block_num.into()).unwrap().unwrap();
20+
backend.update_block_env(&mut block_env);
21+
backend.mine_empty_block(&block_env).unwrap().block_number
22+
};
23+
24+
let block2 = {
25+
let provider = backend.storage.provider();
2326

24-
let block_num = provider.latest_number().unwrap();
25-
let mut block_env = provider.block_env_at(block_num.into()).unwrap().unwrap();
26-
backend.update_block_env(&mut block_env);
27+
let block1_timestamp = provider.block(block1.into()).unwrap().unwrap().header.timestamp;
28+
client.set_next_block_timestamp(block1_timestamp - 1000).await.unwrap();
2729

28-
let block2 = backend.mine_empty_block(&block_env).unwrap().block_number;
30+
let block_num = provider.latest_number().unwrap();
31+
let mut block_env = provider.block_env_at(block_num.into()).unwrap().unwrap();
32+
backend.update_block_env(&mut block_env);
33+
backend.mine_empty_block(&block_env).unwrap().block_number
34+
};
35+
36+
let provider = backend.storage.provider();
37+
let block1_timestamp = provider.block(block1.into()).unwrap().unwrap().header.timestamp;
2938
let block2_timestamp = provider.block(block2.into()).unwrap().unwrap().header.timestamp;
3039

3140
assert_eq!(block2_timestamp, block1_timestamp - 1000, "timestamp should be updated");
@@ -35,25 +44,32 @@ async fn test_next_block_timestamp_in_past() {
3544
async fn test_set_next_block_timestamp_in_future() {
3645
let sequencer = TestNode::new().await;
3746
let backend = sequencer.backend();
38-
let provider = backend.storage.provider();
39-
4047
// Create a jsonrpsee client for the DevApi
4148
let client = sequencer.rpc_http_client();
4249

43-
let block_num = provider.latest_number().unwrap();
44-
let mut block_env = provider.block_env_at(block_num.into()).unwrap().unwrap();
45-
backend.update_block_env(&mut block_env);
46-
let block1 = backend.mine_empty_block(&block_env).unwrap().block_number;
50+
let block1 = {
51+
let provider = backend.storage.provider();
4752

48-
let block1_timestamp = provider.block(block1.into()).unwrap().unwrap().header.timestamp;
53+
let block_num = provider.latest_number().unwrap();
54+
let mut block_env = provider.block_env_at(block_num.into()).unwrap().unwrap();
55+
backend.update_block_env(&mut block_env);
56+
backend.mine_empty_block(&block_env).unwrap().block_number
57+
};
4958

50-
client.set_next_block_timestamp(block1_timestamp + 1000).await.unwrap();
59+
let block2 = {
60+
let provider = backend.storage.provider();
5161

52-
let block_num = provider.latest_number().unwrap();
53-
let mut block_env = provider.block_env_at(block_num.into()).unwrap().unwrap();
54-
backend.update_block_env(&mut block_env);
55-
let block2 = backend.mine_empty_block(&block_env).unwrap().block_number;
62+
let block1_timestamp = provider.block(block1.into()).unwrap().unwrap().header.timestamp;
63+
client.set_next_block_timestamp(block1_timestamp + 1000).await.unwrap();
5664

65+
let block_num = provider.latest_number().unwrap();
66+
let mut block_env = provider.block_env_at(block_num.into()).unwrap().unwrap();
67+
backend.update_block_env(&mut block_env);
68+
backend.mine_empty_block(&block_env).unwrap().block_number
69+
};
70+
71+
let provider = backend.storage.provider();
72+
let block1_timestamp = provider.block(block1.into()).unwrap().unwrap().header.timestamp;
5773
let block2_timestamp = provider.block(block2.into()).unwrap().unwrap().header.timestamp;
5874

5975
assert_eq!(block2_timestamp, block1_timestamp + 1000, "timestamp should be updated");
@@ -63,25 +79,31 @@ async fn test_set_next_block_timestamp_in_future() {
6379
async fn test_increase_next_block_timestamp() {
6480
let sequencer = TestNode::new().await;
6581
let backend = sequencer.backend();
66-
let provider = backend.storage.provider();
67-
6882
// Create a jsonrpsee client for the DevApi
6983
let client = sequencer.rpc_http_client();
7084

71-
let block_num = provider.latest_number().unwrap();
72-
let mut block_env = provider.block_env_at(block_num.into()).unwrap().unwrap();
73-
backend.update_block_env(&mut block_env);
74-
let block1 = backend.mine_empty_block(&block_env).unwrap().block_number;
85+
let block1 = {
86+
let provider = backend.storage.provider();
7587

76-
let block1_timestamp = provider.block(block1.into()).unwrap().unwrap().header.timestamp;
88+
let block_num = provider.latest_number().unwrap();
89+
let mut block_env = provider.block_env_at(block_num.into()).unwrap().unwrap();
90+
backend.update_block_env(&mut block_env);
91+
backend.mine_empty_block(&block_env).unwrap().block_number
92+
};
93+
94+
let block2 = {
95+
let provider = backend.storage.provider();
7796

78-
client.increase_next_block_timestamp(1000).await.unwrap();
97+
client.increase_next_block_timestamp(1000).await.unwrap();
7998

80-
let block_num = provider.latest_number().unwrap();
81-
let mut block_env = provider.block_env_at(block_num.into()).unwrap().unwrap();
82-
backend.update_block_env(&mut block_env);
83-
let block2 = backend.mine_empty_block(&block_env).unwrap().block_number;
99+
let block_num = provider.latest_number().unwrap();
100+
let mut block_env = provider.block_env_at(block_num.into()).unwrap().unwrap();
101+
backend.update_block_env(&mut block_env);
102+
backend.mine_empty_block(&block_env).unwrap().block_number
103+
};
84104

105+
let provider = backend.storage.provider();
106+
let block1_timestamp = provider.block(block1.into()).unwrap().unwrap().header.timestamp;
85107
let block2_timestamp = provider.block(block2.into()).unwrap().unwrap().header.timestamp;
86108

87109
// Depending on the current time and the machine we run on, we may have 1 sec difference

‎crates/rpc/rpc-server/tests/forking.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -73,7 +73,7 @@ async fn setup_test_inner(no_mining: bool) -> (ForkTestNode, StarknetClient, Loc
7373
let block_num = (FORK_BLOCK_NUMBER + 1) + i; // plus 1 because fork genesis is FORK_BLOCK_NUMBER + 1
7474

7575
let block_id = BlockIdOrTag::Number(block_num);
76-
let block = provider.get_block_with_tx_hashes(dbg!(block_id)).await.unwrap();
76+
let block = provider.get_block_with_tx_hashes(block_id).await.unwrap();
7777
let block_hash = match block {
7878
GetBlockWithTxHashesResponse::Block(b) => {
7979
assert_eq!(b.transactions.len(), 1);

‎crates/storage/provider/provider/src/lib.rs‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -118,7 +118,6 @@ impl ProviderFactory for ForkProviderFactory {
118118
}
119119

120120
fn provider_mut(&self) -> Self::ProviderMut {
121-
dbg!("creating provider_mut");
122121
ForkedProvider::new(
123122
self.local_factory.provider_mut(),
124123
ForkedDb::new(self.backend.clone(), self.block_id, self.fork_factory.clone()),

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

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -291,7 +291,7 @@ impl<Tx1: DbTx> BlockProvider for ForkedProvider<Tx1> {
291291
return Ok(Some(value));
292292
}
293293

294-
if dbg!(self.fork_db.fetch_historical_blocks(id)?) {
294+
if self.fork_db.fetch_historical_blocks(id)? {
295295
let value = self.fork_db.db.provider().block(id)?.unwrap();
296296
Ok(Some(value))
297297
} else {
@@ -342,7 +342,7 @@ impl<Tx1: DbTx> BlockStatusProvider for ForkedProvider<Tx1> {
342342
return Ok(Some(value));
343343
}
344344

345-
if dbg!(self.fork_db.fetch_historical_blocks(id)?) {
345+
if self.fork_db.fetch_historical_blocks(id)? {
346346
let value = self.fork_db.db.provider().block_status(id)?.unwrap();
347347
Ok(Some(value))
348348
} else {

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

Lines changed: 34 additions & 45 deletions
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,7 @@ use katana_rpc_types::ContractStorageKeys;
1919
use super::db::{self};
2020
use super::ForkedProvider;
2121
use crate::providers::fork::ForkedDb;
22-
use crate::{ProviderFactory, ProviderResult};
22+
use crate::{MutableProvider, ProviderFactory, ProviderResult};
2323

2424
impl<Tx1: DbTx> StateFactoryProvider for ForkedProvider<Tx1> {
2525
fn latest(&self) -> ProviderResult<Box<dyn StateProvider>> {
@@ -88,11 +88,9 @@ impl<Tx1: DbTx> ContractClassProvider for LatestStateProvider<Tx1> {
8888
} else if let Some(class) =
8989
self.fork_provider.backend.get_class_at(hash, self.fork_provider.block_id)?
9090
{
91-
self.fork_provider
92-
.db
93-
.provider_mut()
94-
.tx()
95-
.put::<tables::Classes>(hash, class.clone().into())?;
91+
let provider_mut = self.fork_provider.db.provider_mut();
92+
provider_mut.tx().put::<tables::Classes>(hash, class.clone().into())?;
93+
provider_mut.commit()?;
9694

9795
Ok(Some(class))
9896
} else {
@@ -109,11 +107,9 @@ impl<Tx1: DbTx> ContractClassProvider for LatestStateProvider<Tx1> {
109107
} else if let Some(compiled_hash) =
110108
self.fork_provider.backend.get_compiled_class_hash(hash, self.fork_provider.block_id)?
111109
{
112-
self.fork_provider
113-
.db
114-
.provider_mut()
115-
.tx()
116-
.put::<tables::CompiledClassHashes>(hash, compiled_hash)?;
110+
let provider_mut = self.fork_provider.db.provider_mut();
111+
provider_mut.tx().put::<tables::CompiledClassHashes>(hash, compiled_hash)?;
112+
provider_mut.commit()?;
117113

118114
Ok(Some(compiled_hash))
119115
} else {
@@ -136,7 +132,10 @@ impl<Tx1: DbTx> StateProvider for LatestStateProvider<Tx1> {
136132
.ok_or(ProviderError::MissingContractClassHash { address })?;
137133

138134
let entry = GenericContractInfo { nonce, class_hash };
139-
self.fork_provider.db.provider().tx().put::<tables::ContractInfo>(address, entry)?;
135+
136+
let provider_mut = self.fork_provider.db.provider_mut();
137+
provider_mut.tx().put::<tables::ContractInfo>(address, entry)?;
138+
provider_mut.commit()?;
140139

141140
Ok(Some(nonce))
142141
} else {
@@ -160,11 +159,10 @@ impl<Tx1: DbTx> StateProvider for LatestStateProvider<Tx1> {
160159
.ok_or(ProviderError::MissingContractNonce { address })?;
161160

162161
let entry = GenericContractInfo { class_hash, nonce };
163-
self.fork_provider
164-
.db
165-
.provider_mut()
166-
.tx()
167-
.put::<tables::ContractInfo>(address, entry)?;
162+
163+
let provider_mut = self.fork_provider.db.provider_mut();
164+
provider_mut.tx().put::<tables::ContractInfo>(address, entry)?;
165+
provider_mut.commit()?;
168166

169167
Ok(Some(class_hash))
170168
} else {
@@ -183,7 +181,11 @@ impl<Tx1: DbTx> StateProvider for LatestStateProvider<Tx1> {
183181
self.fork_provider.backend.get_storage(address, key, self.fork_provider.block_id)?
184182
{
185183
let entry = StorageEntry { key, value };
186-
self.fork_provider.db.provider().tx().put::<tables::ContractStorage>(address, entry)?;
184+
185+
let provider_mut = self.fork_provider.db.provider_mut();
186+
provider_mut.tx().put::<tables::ContractStorage>(address, entry)?;
187+
provider_mut.commit()?;
188+
187189
Ok(Some(value))
188190
} else {
189191
Ok(None)
@@ -370,11 +372,9 @@ impl<Tx1: DbTx> ContractClassProvider for HistoricalStateProvider<Tx1> {
370372
if let Some(compiled_hash) =
371373
self.fork_provider.backend.get_compiled_class_hash(hash, self.local_provider.block())?
372374
{
373-
self.fork_provider
374-
.db
375-
.provider_mut()
376-
.tx()
377-
.put::<tables::CompiledClassHashes>(hash, compiled_hash)?;
375+
let provider_mut = self.fork_provider.db.provider_mut();
376+
provider_mut.tx().put::<tables::CompiledClassHashes>(hash, compiled_hash)?;
377+
provider_mut.commit()?;
378378

379379
Ok(Some(compiled_hash))
380380
} else {
@@ -399,11 +399,9 @@ impl<Tx1: DbTx> StateProvider for HistoricalStateProvider<Tx1> {
399399
let block = self.local_provider.block();
400400
let entry = ContractNonceChange { contract_address: address, nonce };
401401

402-
self.fork_provider
403-
.db
404-
.provider_mut()
405-
.tx()
406-
.put::<tables::NonceChangeHistory>(block, entry)?;
402+
let provider_mut = self.fork_provider.db.provider_mut();
403+
provider_mut.tx().put::<tables::NonceChangeHistory>(block, entry)?;
404+
provider_mut.commit()?;
407405

408406
Ok(res)
409407
} else {
@@ -431,11 +429,9 @@ impl<Tx1: DbTx> StateProvider for HistoricalStateProvider<Tx1> {
431429
// `ClassChangeHistory` entry on the state update level instead.
432430
let entry = ContractClassChange::deployed(address, hash);
433431

434-
self.fork_provider
435-
.db
436-
.provider_mut()
437-
.tx()
438-
.put::<tables::ClassChangeHistory>(block, entry)?;
432+
let provider_mut = self.fork_provider.db.provider_mut();
433+
provider_mut.tx().put::<tables::ClassChangeHistory>(block, entry)?;
434+
provider_mut.commit()?;
439435

440436
Ok(res)
441437
} else {
@@ -467,19 +463,12 @@ impl<Tx1: DbTx> StateProvider for HistoricalStateProvider<Tx1> {
467463
let mut block_list = block_list.unwrap_or_default();
468464
block_list.insert(block);
469465

470-
self.fork_provider
471-
.db
472-
.provider_mut()
473-
.tx()
474-
.put::<tables::StorageChangeSet>(key.clone(), block_list)?;
475-
476-
let change_entry = ContractStorageEntry { key, value };
466+
let change_entry = ContractStorageEntry { key: key.clone(), value };
477467

478-
self.fork_provider
479-
.db
480-
.provider_mut()
481-
.tx()
482-
.put::<tables::StorageChangeHistory>(block, change_entry)?;
468+
let provider_mut = self.fork_provider.db.provider_mut();
469+
provider_mut.tx().put::<tables::StorageChangeSet>(key, block_list)?;
470+
provider_mut.tx().put::<tables::StorageChangeHistory>(block, change_entry)?;
471+
provider_mut.commit()?;
483472

484473
Ok(res)
485474
} else {

‎crates/utils/src/tx_waiter.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -218,7 +218,7 @@ impl Future for TxWaiter<'_> {
218218
Err(StarknetClientError::Starknet(StarknetApiError::TxnHashNotFound)) => {}
219219

220220
Err(e) => {
221-
return Poll::Ready(Err(TxWaitingError::Client(dbg!(e))));
221+
return Poll::Ready(Err(TxWaitingError::Client(e)));
222222
}
223223
},
224224

@@ -239,7 +239,7 @@ impl Future for TxWaiter<'_> {
239239
Poll::Ready(res) => match res {
240240
Err(StarknetClientError::Starknet(StarknetApiError::TxnHashNotFound)) => {}
241241
Err(e) => {
242-
return Poll::Ready(Err(TxWaitingError::Client(dbg!(e))));
242+
return Poll::Ready(Err(TxWaitingError::Client(e)));
243243
}
244244

245245
Ok(res) => {

0 commit comments

Comments
 (0)