Pending block and state improvements

crates/starknet-devnet-core/src/blocks/mod.rs

@@ -27,7 +27,6 @@ pub(crate) struct StarknetBlocks {
     pub(crate) hash_to_state_diff: HashMap<BlockHash, StateDiff>,
     pub(crate) hash_to_state: HashMap<BlockHash, StarknetState>,
     pub(crate) aborted_blocks: Vec<Felt>,
-    pub(crate) blocks_on_demand: bool,
 }
 
 impl HashIdentified for StarknetBlocks {
@@ -51,14 +50,13 @@ impl Default for StarknetBlocks {
             hash_to_state_diff: HashMap::new(),
             hash_to_state: HashMap::new(),
             aborted_blocks: Vec::new(),
-            blocks_on_demand: false,
         }
     }
 }
 
 impl StarknetBlocks {
-    pub fn new(starting_block_number: u64, blocks_on_demand: bool) -> Self {
-        let mut blocks = Self { blocks_on_demand, ..Self::default() };
+    pub fn new(starting_block_number: u64) -> Self {
+        let mut blocks = Self::default();
         blocks.pending_block.set_block_number(starting_block_number);
         blocks
     }
@@ -98,14 +96,7 @@ impl StarknetBlocks {
         match block_id {
             BlockId::Hash(hash) => self.get_by_hash(Felt::from(hash)),
             BlockId::Number(block_number) => self.get_by_num(&BlockNumber(*block_number)),
-            BlockId::Tag(BlockTag::Pending) => {
-                if !self.blocks_on_demand {
-                    // in normal mode, querying pending block should default to the latest
-                    self.get_by_latest_hash()
-                } else {
-                    Some(&self.pending_block)
-                }
-            }
+            BlockId::Tag(BlockTag::Pending) => Some(&self.pending_block),
             BlockId::Tag(BlockTag::Latest) => self.get_by_latest_hash(),
         }
     }
@@ -346,7 +337,7 @@ mod tests {
 
     #[test]
     fn block_number_from_block_id_should_return_correct_result() {
-        let mut blocks = StarknetBlocks::new(0, true);
+        let mut blocks = StarknetBlocks::new(0);
         let mut block_to_insert = StarknetBlock::create_pending_block();
         blocks.pending_block = block_to_insert.clone();
 

crates/starknet-devnet-core/src/starknet/add_declare_transaction.rs

@@ -59,7 +59,7 @@ pub fn add_declare_transaction(
         };
 
     let validate = !(Starknet::is_account_impersonated(
-        &mut starknet.state,
+        &mut starknet.pending_state,
         &starknet.cheats,
         sender_address,
     )?);
@@ -69,7 +69,12 @@ pub fn add_declare_transaction(
         blockifier::transaction::account_transaction::AccountTransaction::Declare(
             blockifier_declare_transaction,
         )
-        .execute(&mut starknet.state.state, &starknet.block_context, true, validate);
+        .execute(
+            &mut starknet.pending_state.state,
+            &starknet.block_context,
+            true,
+            validate,
+        );
 
     starknet.handle_transaction_result(
         transaction,
@@ -257,7 +262,7 @@ mod tests {
         // check if txn is with status accepted
         assert_eq!(tx.finality_status, TransactionFinalityStatus::AcceptedOnL2);
         assert_eq!(tx.execution_result.status(), TransactionExecutionStatus::Succeeded);
-        starknet.state.get_rpc_contract_class(&class_hash).unwrap();
+        starknet.pending_state.get_rpc_contract_class(&class_hash).unwrap();
     }
 
     #[test]
@@ -296,9 +301,9 @@ mod tests {
         let expected_compiled_class_hash = declare_txn.compiled_class_hash;
 
         // check if contract is not declared
-        assert!(!starknet.state.is_contract_declared(expected_class_hash));
+        assert!(!starknet.pending_state.is_contract_declared(expected_class_hash));
         assert_eq!(
-            starknet.state.get_compiled_class_hash(expected_class_hash.into()).unwrap(),
+            starknet.pending_state.get_compiled_class_hash(expected_class_hash.into()).unwrap(),
             CompiledClassHash(StarkHash::ZERO)
         );
         assert!(starknet.get_class(&BlockId::Tag(BlockTag::Latest), expected_class_hash).is_err());
@@ -314,9 +319,9 @@ mod tests {
         // check if txn is with status accepted
         assert_eq!(retrieved_txn.finality_status, TransactionFinalityStatus::AcceptedOnL2);
         assert_eq!(retrieved_txn.execution_result.status(), TransactionExecutionStatus::Succeeded);
-        assert!(starknet.state.is_contract_declared(expected_class_hash));
+        assert!(starknet.pending_state.is_contract_declared(expected_class_hash));
         assert_eq!(
-            starknet.state.get_compiled_class_hash(expected_class_hash.into()).unwrap(),
+            starknet.pending_state.get_compiled_class_hash(expected_class_hash.into()).unwrap(),
             expected_compiled_class_hash.into()
         );
     }
@@ -403,7 +408,7 @@ mod tests {
         assert_eq!(tx.finality_status, TransactionFinalityStatus::AcceptedOnL2);
         assert_eq!(tx.execution_result.status(), TransactionExecutionStatus::Succeeded);
         // check if contract is successfully declared
-        assert!(starknet.state.is_contract_declared(class_hash));
+        assert!(starknet.pending_state.is_contract_declared(class_hash));
         // check if pending block is reset
         assert!(starknet.pending_block().get_transactions().is_empty());
         // check if there is generated block
@@ -430,7 +435,7 @@ mod tests {
             BroadcastedDeclareTransaction::V1(ref v1) => {
                 let expected_class_hash = v1.contract_class.generate_hash().unwrap();
                 // check if contract is not declared
-                assert!(!starknet.state.is_contract_declared(expected_class_hash));
+                assert!(!starknet.pending_state.is_contract_declared(expected_class_hash));
             }
             _ => panic!("Wrong transaction type"),
         }
@@ -444,7 +449,7 @@ mod tests {
         assert_eq!(tx.execution_result.status(), TransactionExecutionStatus::Succeeded);
 
         // check if contract is declared
-        assert!(starknet.state.is_contract_declared(class_hash));
+        assert!(starknet.pending_state.is_contract_declared(class_hash));
     }
 
     /// Initializes starknet with 1 account - account without validations
@@ -458,10 +463,10 @@ mod tests {
 
         let eth_erc_20_contract =
             predeployed::create_erc20_at_address(ETH_ERC20_CONTRACT_ADDRESS).unwrap();
-        eth_erc_20_contract.deploy(&mut starknet.state).unwrap();
+        eth_erc_20_contract.deploy(&mut starknet.pending_state).unwrap();
 
         let strk_erc20_contract = create_erc20_at_address(STRK_ERC20_CONTRACT_ADDRESS).unwrap();
-        strk_erc20_contract.deploy(&mut starknet.state).unwrap();
+        strk_erc20_contract.deploy(&mut starknet.pending_state).unwrap();
 
         let acc = Account::new(
             Balance::from(acc_balance.unwrap_or(10000)),
@@ -474,7 +479,7 @@ mod tests {
         )
         .unwrap();
 
-        acc.deploy(&mut starknet.state).unwrap();
+        acc.deploy(&mut starknet.pending_state).unwrap();
 
         starknet.block_context = Starknet::init_block_context(
             nonzero!(1u128),

crates/starknet-devnet-core/src/starknet/add_deploy_account_transaction.rs

@@ -51,7 +51,7 @@ pub fn add_deploy_account_transaction(
         }
     };
 
-    if !starknet.state.is_contract_declared(class_hash) {
+    if !starknet.pending_state.is_contract_declared(class_hash) {
         return Err(Error::StateError(crate::error::StateError::NoneClassHash(class_hash)));
     }
     let transaction_hash = blockifier_deploy_account_transaction.tx_hash.0.into();
@@ -61,7 +61,7 @@ pub fn add_deploy_account_transaction(
         blockifier::transaction::account_transaction::AccountTransaction::DeployAccount(
             blockifier_deploy_account_transaction,
         )
-        .execute(&mut starknet.state.state, &starknet.block_context, true, true);
+        .execute(&mut starknet.pending_state.state, &starknet.block_context, true, true);
 
     starknet.handle_transaction_result(transaction, None, blockifier_execution_result)?;
     starknet.handle_dump_event(DumpEvent::AddDeployAccountTransaction(
@@ -268,7 +268,7 @@ mod tests {
 
         let account_balance_before_deployment = StarkFelt::from_u128(1000000);
         starknet
-            .state
+            .pending_state
             .set_storage_at(
                 fee_token_address,
                 balance_storage_var_address,
@@ -310,7 +310,7 @@ mod tests {
 
         let account_balance_before_deployment = StarkFelt::from_u128(1000000);
         starknet
-            .state
+            .pending_state
             .set_storage_at(
                 fee_token_address,
                 balance_storage_var_address,
@@ -331,8 +331,10 @@ mod tests {
             account_class_hash,
         );
 
-        let account_balance_after_deployment =
-            starknet.state.get_storage_at(fee_token_address, balance_storage_var_address).unwrap();
+        let account_balance_after_deployment = starknet
+            .pending_state
+            .get_storage_at(fee_token_address, balance_storage_var_address)
+            .unwrap();
 
         assert!(account_balance_before_deployment > account_balance_after_deployment);
     }
@@ -366,7 +368,7 @@ mod tests {
 
         let account_balance_before_deployment = StarkFelt::from_u128(1000000);
         starknet
-            .state
+            .pending_state
             .set_storage_at(
                 fee_token_address,
                 balance_storage_var_address,
@@ -397,16 +399,16 @@ mod tests {
         );
         let erc_20_contract =
             predeployed::create_erc20_at_address(ETH_ERC20_CONTRACT_ADDRESS).unwrap();
-        erc_20_contract.deploy(&mut starknet.state).unwrap();
+        erc_20_contract.deploy(&mut starknet.pending_state).unwrap();
 
         let strk_erc20_contract =
             predeployed::create_erc20_at_address(STRK_ERC20_CONTRACT_ADDRESS).unwrap();
-        strk_erc20_contract.deploy(&mut starknet.state).unwrap();
+        strk_erc20_contract.deploy(&mut starknet.pending_state).unwrap();
 
         let contract_class = Cairo0Json::raw_json_from_path(account_json_path).unwrap();
         let class_hash = contract_class.generate_hash().unwrap();
 
-        starknet.state.declare_contract_class(class_hash, contract_class.into()).unwrap();
+        starknet.pending_state.declare_contract_class(class_hash, contract_class.into()).unwrap();
         starknet.block_context = Starknet::init_block_context(
             nonzero!(1u128),
             nonzero!(1u128),

crates/starknet-devnet-core/src/starknet/add_invoke_transaction.rs

@@ -40,7 +40,7 @@ pub fn add_invoke_transaction(
     };
 
     let validate = !(Starknet::is_account_impersonated(
-        &mut starknet.state,
+        &mut starknet.pending_state,
         &starknet.cheats,
         &ContractAddress::from(blockifier_invoke_transaction.sender_address()),
     )?);
@@ -221,7 +221,8 @@ mod tests {
     fn invoke_transaction_v3_successful_execution() {
         let (mut starknet, account, contract_address, increase_balance_selector, _) = setup();
         let account_address = account.get_address();
-        let initial_balance = account.get_balance(&mut starknet.state, FeeToken::STRK).unwrap();
+        let initial_balance =
+            account.get_balance(&mut starknet.pending_state, FeeToken::STRK).unwrap();
 
         let invoke_transaction = test_invoke_transaction_v3(
             account_address,
@@ -230,7 +231,7 @@ mod tests {
             Felt::from(10),
             0,
             account
-                .get_balance(&mut starknet.state, crate::account::FeeToken::STRK)
+                .get_balance(&mut starknet.pending_state, crate::account::FeeToken::STRK)
                 .unwrap()
                 .to_string()
                 .parse::<u64>()
@@ -244,7 +245,8 @@ mod tests {
         assert_eq!(transaction.finality_status, TransactionFinalityStatus::AcceptedOnL2);
         assert_eq!(transaction.execution_result.status(), TransactionExecutionStatus::Succeeded);
         assert!(
-            account.get_balance(&mut starknet.state, FeeToken::STRK).unwrap() < initial_balance
+            account.get_balance(&mut starknet.pending_state, FeeToken::STRK).unwrap()
+                < initial_balance
         );
     }
 
@@ -301,7 +303,7 @@ mod tests {
 
         // check storage
         assert_eq!(
-            starknet.state.get_storage_at(blockifier_address, storage_key).unwrap(),
+            starknet.pending_state.get_storage_at(blockifier_address, storage_key).unwrap(),
             Felt::from(10).into()
         );
 
@@ -320,7 +322,7 @@ mod tests {
         assert_eq!(transaction.execution_result.status(), TransactionExecutionStatus::Succeeded);
         assert_eq!(transaction.finality_status, TransactionFinalityStatus::AcceptedOnL2);
         assert_eq!(
-            starknet.state.get_storage_at(blockifier_address, storage_key).unwrap(),
+            starknet.pending_state.get_storage_at(blockifier_address, storage_key).unwrap(),
             StarkFelt::from_u128(25)
         );
     }
@@ -384,7 +386,7 @@ mod tests {
 
         let account_address: starknet_api::core::ContractAddress =
             account.get_address().try_into().unwrap();
-        let initial_nonce = starknet.state.get_nonce_at(account_address).unwrap();
+        let initial_nonce = starknet.pending_state.get_nonce_at(account_address).unwrap();
         assert_eq!(initial_nonce, Nonce(StarkFelt::ZERO));
 
         let calldata = vec![
@@ -411,7 +413,7 @@ mod tests {
         assert_eq!(transaction.finality_status, TransactionFinalityStatus::AcceptedOnL2);
         assert_eq!(transaction.execution_result.status(), TransactionExecutionStatus::Reverted);
 
-        let nonce_after_reverted = starknet.state.get_nonce_at(account_address).unwrap();
+        let nonce_after_reverted = starknet.pending_state.get_nonce_at(account_address).unwrap();
         assert_eq!(nonce_after_reverted, Nonce(StarkFelt::ONE));
     }
 
@@ -423,11 +425,11 @@ mod tests {
         // deploy erc20 contracts
         let eth_erc_20_contract =
             predeployed::create_erc20_at_address(ETH_ERC20_CONTRACT_ADDRESS).unwrap();
-        eth_erc_20_contract.deploy(&mut starknet.state).unwrap();
+        eth_erc_20_contract.deploy(&mut starknet.pending_state).unwrap();
 
         let strk_erc_20_contract =
             predeployed::create_erc20_at_address(constants::STRK_ERC20_CONTRACT_ADDRESS).unwrap();
-        strk_erc_20_contract.deploy(&mut starknet.state).unwrap();
+        strk_erc_20_contract.deploy(&mut starknet.pending_state).unwrap();
 
         // deploy account contract
         let account_without_validations_contract_class = cairo_0_account_without_validations();
@@ -445,7 +447,7 @@ mod tests {
         )
         .unwrap();
 
-        account.deploy(&mut starknet.state).unwrap();
+        account.deploy(&mut starknet.pending_state).unwrap();
 
         // dummy contract
         let dummy_contract: Cairo0ContractClass = dummy_cairo_0_contract_class().into();
@@ -477,13 +479,13 @@ mod tests {
 
         // declare dummy contract
         starknet
-            .state
+            .pending_state
             .declare_contract_class(dummy_contract_class_hash, dummy_contract.into())
             .unwrap();
 
         // deploy dummy contract
         starknet
-            .state
+            .pending_state
             .predeploy_contract(dummy_contract_address, dummy_contract_class_hash)
             .unwrap();
         // change storage of dummy contract

crates/starknet-devnet-core/src/starknet/add_l1_handler_transaction.rs

@@ -24,7 +24,7 @@ pub fn add_l1_handler_transaction(
     let validate = true;
 
     let blockifier_execution_result = blockifier_transaction.execute(
-        &mut starknet.state.state,
+        &mut starknet.pending_state.state,
         &starknet.block_context,
         charge_fee,
         validate,
@@ -188,11 +188,11 @@ mod tests {
         // deploy erc20 contract
         let eth_erc_20_contract =
             predeployed::create_erc20_at_address(ETH_ERC20_CONTRACT_ADDRESS).unwrap();
-        eth_erc_20_contract.deploy(&mut starknet.state).unwrap();
+        eth_erc_20_contract.deploy(&mut starknet.pending_state).unwrap();
 
         let strk_erc_20_contract =
             predeployed::create_erc20_at_address(STRK_ERC20_CONTRACT_ADDRESS).unwrap();
-        strk_erc_20_contract.deploy(&mut starknet.state).unwrap();
+        strk_erc_20_contract.deploy(&mut starknet.pending_state).unwrap();
 
         // deploy account contract
         let account_without_validations_contract_class = cairo_0_account_without_validations();
@@ -210,7 +210,7 @@ mod tests {
         )
         .unwrap();
 
-        account.deploy(&mut starknet.state).unwrap();
+        account.deploy(&mut starknet.pending_state).unwrap();
 
         // dummy contract
         let dummy_contract: Cairo0ContractClass = dummy_cairo_l1l2_contract().into();
@@ -250,13 +250,13 @@ mod tests {
 
         // declare dummy contract
         starknet
-            .state
+            .pending_state
             .declare_contract_class(dummy_contract_class_hash, dummy_contract.into())
             .unwrap();
 
         // deploy dummy contract
         starknet
-            .state
+            .pending_state
             .predeploy_contract(dummy_contract_address, dummy_contract_class_hash)
             .unwrap();
         starknet.block_context = Starknet::init_block_context(