Debugging of pythn bindings. Last mile. (astraly-labs#7)

* added get_balance method to env
added missing python bindings
added sync get_block_events method (turned out subscriptions are pointless)

* Added get_all_events to cheating provider and to python bindings
Added some debugging info

* more methods needed:
- get_deployed_address
- get_token

* fix ekubo core compiled contract data

* small fix

* Added some bullet point not to forget.

Author: baitcode

Cargo.lock

@@ -30,7 +30,6 @@ The Starkbiter workspace has five crates:
 
 ## WIP
 
-- [ ] non-blocking event polling
 - [x] bin docs
 - [x] core docs
 - [x] main readme
@@ -39,17 +38,24 @@ The Starkbiter workspace has five crates:
     - [ ] usage
     - [x] index
 - [ ] benchmarks
-- [ ] python bindings
+- [x] python bindings
 - [x] more test cases
-- [ ] coverage report
 - [x] support for replaying mainnet transactions mixing them with simulated ones.
 - [x] github workflows revival
-- [ ] contribute to cainome and remove fork dep
-- [ ] contribute to starknet-rs and remove fork dep + Fix generic Runtime error with more specific errors from within Provider
-- [ ] contribute to starknet-devnet and remove fork dep
 - [x] test that toml config parameters for forking work
 - [x] contract execution logging and traces from Devnet
-- [ ] test for simultaneous connection usage by different contracts.
+- [x] test for simultaneous connection usage by different contracts.
+- [ ] contribute to cainome and remove fork dep
+- [ ] contribute to starknet-rs and remove fork dep + Fix generic Runtime error with more specific errors from within Provider
+- [ ] Contribute to starknet-devnet and remove fork dep
+- [ ] Coverage report
+- [ ] Python binding add validation (last minute changes were dirty)
+- [ ] Type conversions. need to replace Into with From
+- [ ] Type conversions. remove Clone where possible
+- [ ] Environment. Move handler processing logic in separate files.
+- [ ] Make explicit naming for methods that only work with local data and ones that work against remote state
+- [ ] Add API to preload state and save it to file. (like EKUBO core contract storage)
+- [ ] Test approach to set local nonce before adding transaction to bypass validation (less remote calls)
 
 
 ## Book

README.md

@@ -18,10 +18,9 @@ pub static ERC20_CONTRACT_SIERRA: &str =
 
 pub static ARGENT_V040_SIERRA: &str = include_str!("../contracts/ArgentAccount.0.4.0.class.json");
 
-pub static SWAPPER_CONTRACT_SIERRA: &str =
-    include_str!("../contracts/contracts_Swapper.contract_class.json");
+pub static EKUBO_CORE_CONTRACT_SIERRA: &str = include_str!("../contracts/EkuboCore.class.json");
 
-pub static EKUBO_CORE_CONTRACT_SIERRA: &str =
+pub static SWAPPER_CONTRACT_SIERRA: &str =
     include_str!("../contracts/contracts_Swapper.contract_class.json");
 
 pub static EKUBO_ROUTER_LITE_CONTRACT_SIERRA: &str =

bindings/src/lib.rs

@@ -24,9 +24,9 @@ use crate::tokens::TokenId;
 pub struct EventFilter {
     /// Matched events emitted by this address
     pub from_address: Felt,
-    /// Matches events with those keys: [selector, key1, key2]
+    /// Matches events against keys list: vec![vec![selector, key1, key2]]
     /// selector is a keccak hash from event name.
-    pub keys: Vec<Felt>,
+    pub keys: Vec<Vec<Felt>>,
 }
 
 /// Instructions that can be sent to the [`Environment`] via the [`Socket`].
@@ -398,6 +398,13 @@ pub enum CheatInstruction {
         /// The token symbol or identifier.
         token: TokenId, // need to create classifier
     },
+    /// Fetches token balance for an account.
+    GetBalance {
+        /// The address to check.
+        address: Felt,
+        /// The token symbol or identifier.
+        token: TokenId, // need to create classifier
+    },
     /// Starts impersonation. Skips transaction validation if sent on behalf of
     /// an account with impersonated address.
     Impersonate {
@@ -447,6 +454,21 @@ pub enum CheatInstruction {
         /// Set to true to recalculate the nonce for the transactions
         override_nonce: bool,
     },
+
+    /// Fetches all events from block in one go. Only scans local blocks
+    GetAllEvents {
+        /// Block id of a the block to fetch events from. If `None`, fetches all
+        /// events since fork start.
+        from_block: Option<core_types::BlockId>,
+        /// Block id to fetch events till. If `None`, fetches all events from
+        /// from_block
+        to_block: Option<core_types::BlockId>,
+        /// The address that emitted events to filter events by. If `None`,
+        /// fetches all events.
+        address: Option<Felt>,
+        /// The keys to filter events by. If `None`, fetches all events.
+        keys: Option<Vec<Vec<Felt>>>,
+    },
 }
 
 /// Return values of applying cheatcodes.
@@ -456,12 +478,14 @@ pub enum CheatcodesOutcome {
     DeclareContract(Felt),
     /// Returns the contract address of the created account.
     CreateAccount(Felt),
-    /// Indicates a block was created.
-    CreateBlock,
+    /// Indicates a block was created. Returns latest block hash.
+    CreateBlock(Felt),
     /// Returns the tx_hash of L1 message transaction.
     L1Message(Felt),
     /// Indicates a balance was added.
     TopUpBalance,
+    /// Returns amount of token owned.
+    GetBalance(BigUint),
     /// Indicates the address was impersonated.
     Impersonate,
     /// Indicates the impersonation was stopped.
@@ -478,4 +502,7 @@ pub enum CheatcodesOutcome {
     /// Returns numbers of transactions from the origin block that were (added,
     /// ignored, failed)
     ReplayBlockWithTxs(usize, usize, usize),
+
+    /// Returns all events matching the filter.
+    GetAllEvents(Vec<core_types::EmittedEvent>),
 }

core/src/environment/instruction.rs

@@ -61,6 +61,7 @@ use starknet_devnet_types::{
     traits::HashProducer,
 };
 use tokio::sync::broadcast::channel;
+use tracing::debug;
 
 use super::*;
 use crate::tokens::get_token_data;
@@ -1412,7 +1413,17 @@ async fn process_instructions(
 
                     event_broadcaster.send(converted).unwrap_or_default();
 
-                    let outcome = Ok(Outcome::Cheat(instruction::CheatcodesOutcome::CreateBlock));
+                    let latest_block = starknet.get_latest_block().unwrap();
+
+                    trace!(
+                        "Environment. Created latest block: {:?}, {:?}",
+                        latest_block.block_hash(),
+                        latest_block.block_number(),
+                    );
+
+                    let outcome = Ok(Outcome::Cheat(instruction::CheatcodesOutcome::CreateBlock(
+                        latest_block.block_hash(),
+                    )));
                     if let Err(e) = sender.send(outcome) {
                         error!("Failed to send CreateBlock outcome: {:?}", e);
                         stop = true;
@@ -1771,29 +1782,27 @@ async fn process_instructions(
                         {
                             trace!(
                                 "Skipping transaction with reverted execution result: {:?}",
-                                tx
+                                tx.receipt.transaction_hash()
                             );
                             continue;
                         };
 
                         if let Some(filters) = filters {
                             let has_events = tx.receipt.events().iter().any(|e| {
                                 filters.iter().any(|f| {
-                                    let res = e.from_address == f.from_address && e.keys == f.keys;
-                                    if res {
-                                        trace!(
-                                            "Hash: {:?}, Event: {:?}, Filter: {:?}",
-                                            tx.receipt.transaction_hash(),
-                                            e,
-                                            f
-                                        );
+                                    if e.from_address != f.from_address {
+                                        return false;
+                                    }
+
+                                    if !f.keys.iter().any(|keys| e.keys == *keys) {
+                                        return false;
                                     }
-                                    res
+
+                                    true
                                 })
                             });
 
                             if !has_events {
-                                trace!("No events that match filter. Ignoring the transaction.");
                                 ignored_tx += 1;
                                 continue;
                             }
@@ -1905,7 +1914,6 @@ async fn process_instructions(
                                     .map(|res| res.0)
                             }
                             _ => {
-                                trace!("TX: {:?}", tx);
                                 ignored_tx += 1;
                                 Ok(core_types::Felt::ZERO)
                             }
@@ -1915,16 +1923,18 @@ async fn process_instructions(
                             error!("Failed to add transaction: {:?}", e);
                             failed_tx += 1;
                         } else {
-                            info!(
-                                "Transaction processed: {} of {}. Ignored: {}",
-                                added_tx,
-                                txs.len(),
-                                ignored_tx
-                            );
                             added_tx += 1;
                         }
                     }
 
+                    debug!(
+                        "Transaction processed: {} of {}. Ignored: {}. Failed: {}",
+                        added_tx,
+                        txs.len(),
+                        ignored_tx,
+                        failed_tx
+                    );
+
                     let outcome = Ok(Outcome::Cheat(
                         instruction::CheatcodesOutcome::ReplayBlockWithTxs(
                             added_tx, ignored_tx, failed_tx,
@@ -1936,6 +1946,101 @@ async fn process_instructions(
                         stop = true;
                     }
                 }
+                instruction::CheatInstruction::GetBalance { address, token } => {
+                    trace!(
+                        "Environment. Received GetBalance instruction: address: {:?}, token: {:?}",
+                        address,
+                        token
+                    );
+
+                    let state = starknet.get_state();
+
+                    let address = ContractAddress::new(*address);
+                    if let Err(e) = address {
+                        let outcome = Err(StarkbiterCoreError::InternalError(e.to_string()));
+                        if let Err(e) = sender.send(outcome) {
+                            error!("Failed to send GetBalance outcome: {:?}", e);
+                            stop = true;
+                        }
+
+                        continue;
+                    }
+
+                    let token_data = get_token_data(&starknet_config.chain_id, token);
+                    if let Err(e) = token_data {
+                        let outcome = Err(StarkbiterCoreError::InternalError(e.to_string()));
+                        if let Err(e) = sender.send(outcome) {
+                            error!("Failed to send GetBalance outcome: {:?}", e);
+                            stop = true;
+                        }
+
+                        continue;
+                    }
+
+                    let result = utils::read_tokens_in_erc20_contract(
+                        state,
+                        token_data.unwrap().l2_token_address,
+                        address.unwrap().into(),
+                    );
+
+                    if let Err(e) = result {
+                        if let Err(e) = sender.send(Err(*e)) {
+                            error!("Failed to send GetBalance outcome: {:?}", e);
+                            stop = true;
+                        }
+
+                        continue;
+                    }
+
+                    let outcome = Ok(Outcome::Cheat(instruction::CheatcodesOutcome::GetBalance(
+                        result.unwrap(),
+                    )));
+                    if let Err(e) = sender.send(outcome) {
+                        error!("Failed to send GetBalance outcome: {:?}", e);
+                        stop = true;
+                    }
+                }
+                instruction::CheatInstruction::GetAllEvents {
+                    from_block,
+                    to_block,
+                    address,
+                    keys,
+                } => {
+                    trace!("Environment. Received GetAllEvents instruction");
+
+                    let maybe_contract_address =
+                        address.map(|addr| ContractAddress::new(addr).unwrap());
+
+                    let events = starknet.get_unlimited_events(
+                        *from_block,
+                        *to_block,
+                        maybe_contract_address,
+                        keys.clone(),
+                    );
+
+                    if let Err(e) = events {
+                        if let Err(e) = sender.send(Err(StarkbiterCoreError::DevnetError(e))) {
+                            error!("Failed to send GetAllEvents outcome: {:?}", e);
+                            stop = true;
+                        }
+                        continue;
+                    }
+
+                    let converted = events
+                        .unwrap()
+                        .iter()
+                        .map(core_types::EmittedEvent::from)
+                        .collect();
+
+                    let outcome = Ok(Outcome::Cheat(
+                        instruction::CheatcodesOutcome::GetAllEvents(converted),
+                    ));
+
+                    if let Err(e) = sender.send(outcome) {
+                        error!("Failed to send GetAllEvents outcome: {:?}", e);
+                        stop = true;
+                    }
+                }
             },
             Instruction::System(ref system_instruction) => match system_instruction {
                 instruction::SystemInstruction::Stop => {