Merge branch 'starkware-libs:main' into main

Author: FrancoGiachetta

Cargo.lock

@@ -49,6 +49,7 @@ members = [
   "crates/apollo_rpc_execution",
   "crates/apollo_signature_manager",
   "crates/apollo_signature_manager_types",
+  "crates/apollo_staking",
   "crates/apollo_starknet_client",
   "crates/apollo_starknet_os_program",
   "crates/apollo_state_reader",
@@ -136,6 +137,7 @@ apollo_rpc.path = "crates/apollo_rpc"
 apollo_rpc_execution.path = "crates/apollo_rpc_execution"
 apollo_signature_manager.path = "crates/apollo_signature_manager"
 apollo_signature_manager_types.path = "crates/apollo_signature_manager_types"
+apollo_staking.path = "crates/apollo_staking"
 apollo_starknet_client.path = "crates/apollo_starknet_client"
 apollo_starknet_os_program = { path = "crates/apollo_starknet_os_program", version = "0.0.0" }
 apollo_state_reader.path = "crates/apollo_state_reader"

Cargo.toml

@@ -41,6 +41,7 @@ const AllowedScopes = ['apollo_batcher',
     'apollo_rpc_execution',
     'apollo_signature_manager',
     'apollo_signature_manager_types',
+    'apollo_staking',
     'apollo_starknet_client',
     'apollo_starknet_os_program',
     'apollo_state_reader',

commitlint.config.js

@@ -9,6 +9,7 @@ use apollo_storage::header::HeaderStorageReader;
 use apollo_storage::state::StateStorageReader;
 use apollo_storage::test_utils::get_test_storage;
 use apollo_storage::{StorageError, StorageReader, StorageWriter};
+use apollo_test_utils::{get_rng, GetTestInstance};
 use assert_matches::assert_matches;
 use async_stream::stream;
 use async_trait::async_trait;
@@ -26,10 +27,10 @@ use starknet_api::block::{
     BlockNumber,
     BlockSignature,
 };
-use starknet_api::core::{ClassHash, SequencerPublicKey};
+use starknet_api::core::{ClassHash, CompiledClassHash, SequencerPublicKey};
 use starknet_api::crypto::utils::PublicKey;
 use starknet_api::felt;
-use starknet_api::state::StateDiff;
+use starknet_api::state::{SierraContractClass, StateDiff, StateNumber};
 use tokio::sync::{Mutex, RwLock};
 use tokio::time::sleep;
 use tracing::{debug, error};
@@ -192,6 +193,11 @@ async fn sync_happy_flow() {
     const MAX_TIME_TO_SYNC_MS: u64 = 800;
     let _ = simple_logger::init_with_env();
 
+    let class_hash_1 = ClassHash(felt!("0x1"));
+    let compiled_class_hash_1 = CompiledClassHash(felt!("0x101"));
+    let class_hash_2 = ClassHash(felt!("0x2"));
+    let compiled_class_hash_2 = CompiledClassHash(felt!("0x102"));
+
     // Mock having N_BLOCKS chain in central.
     let mut central_mock = MockCentralSourceTrait::new();
     central_mock.expect_get_latest_block().returning(|| {
@@ -232,17 +238,70 @@ async fn sync_happy_flow() {
                 if block_number.0 >= N_BLOCKS {
                     yield Err(CentralError::BlockNotFound { block_number })
                 }
+
+                // Add declared classes to specific blocks to test compiled class hash mapping
+                let state_diff = match block_number.0 {
+                    1 => StateDiff {
+                        declared_classes: IndexMap::from([
+                            (class_hash_1, (compiled_class_hash_1, SierraContractClass::default())),
+                        ]),
+                        ..Default::default()
+                    },
+                    3 => StateDiff {
+                        declared_classes: IndexMap::from([
+                            (class_hash_2, (compiled_class_hash_2, SierraContractClass::default())),
+                        ]),
+                        ..Default::default()
+                    },
+                    _ => StateDiff::default(),
+                };
+
                 yield Ok((
                     block_number,
                     create_block_hash(block_number, false),
-                    StateDiff::default(),
+                    state_diff,
                     IndexMap::new(),
                 ));
             }
         }
         .boxed();
         state_stream
     });
+
+    // Add compiled classes stream mock
+    central_mock.expect_stream_compiled_classes().returning(move |initial, up_to| {
+        let compiled_classes_stream: CompiledClassesStream<'_> = stream! {
+            for block_number in initial.iter_up_to(up_to) {
+                if block_number.0 >= N_BLOCKS {
+                    yield Err(CentralError::BlockNotFound { block_number });
+                }
+
+                // Return compiled classes for blocks that declared them
+                match block_number.0 {
+                    1 => {
+                        let mut rng = get_rng();
+                        yield Ok((
+                            class_hash_1,
+                            compiled_class_hash_1,
+                            CasmContractClass::get_test_instance(&mut rng),
+                        ));
+                    },
+                    3 => {
+                        let mut rng = get_rng();
+                        yield Ok((
+                            class_hash_2,
+                            compiled_class_hash_2,
+                            CasmContractClass::get_test_instance(&mut rng),
+                        ));
+                    },
+                    _ => {}
+                }
+            }
+        }
+        .boxed();
+        compiled_classes_stream
+    });
+
     central_mock.expect_get_block_hash().returning(|bn| Ok(Some(create_block_hash(bn, false))));
 
     // TODO(dvir): find a better way to do this.
@@ -304,6 +363,31 @@ async fn sync_happy_flow() {
                 return CheckStoragePredicateResult::Error;
             }
 
+            // Verify compiled class hash mappings are stored correctly
+            let txn = reader.begin_ro_txn().unwrap();
+            let state_reader = txn.get_state_reader().unwrap();
+
+            // Check mappings - return InProgress if not ready, otherwise assert equality
+            let state_number_1 = StateNumber::unchecked_right_after_block(BlockNumber(1));
+            let state_number_2 = StateNumber::unchecked_right_after_block(BlockNumber(3));
+            // Arbitrary state number after the last block.
+            let state_number_final = StateNumber::unchecked_right_after_block(BlockNumber(4));
+
+            let hash_1 =
+                state_reader.get_compiled_class_hash_at(state_number_1, &class_hash_1).unwrap();
+            let hash_2 =
+                state_reader.get_compiled_class_hash_at(state_number_2, &class_hash_2).unwrap();
+            let hash_final =
+                state_reader.get_compiled_class_hash_at(state_number_final, &class_hash_1).unwrap();
+
+            if hash_1.is_none() || hash_2.is_none() || hash_final.is_none() {
+                return CheckStoragePredicateResult::InProgress;
+            }
+
+            assert_eq!(hash_1, Some(compiled_class_hash_1));
+            assert_eq!(hash_2, Some(compiled_class_hash_2));
+            // Ensure class hash 1 remains unchanged after later declarations.
+            assert_eq!(hash_final, Some(compiled_class_hash_1));
             CheckStoragePredicateResult::Passed
         });
 

crates/apollo_central_sync/src/sources/central_sync_test.rs

@@ -15,9 +15,6 @@ pub mod validate_proposal;
 #[allow(missing_docs)]
 pub mod cende;
 
-#[allow(missing_docs)]
-pub mod committee_manager;
-
 /// Fee market logic.
 pub mod fee_market;
 

crates/apollo_consensus_orchestrator/src/lib.rs

@@ -1,6 +1,5 @@
 use std::sync::Arc;
 
-use apollo_consensus::types::Round;
 use apollo_l1_gas_price_types::{
     EthToStrkOracleClientTrait,
     L1GasPriceProviderClient,
@@ -18,11 +17,8 @@ use apollo_state_sync_types::errors::StateSyncError;
 use blockifier::abi::constants::STORED_BLOCK_HASH_BUFFER;
 use futures::channel::mpsc;
 use futures::SinkExt;
-#[cfg(test)]
-use mockall::automock;
 use num_rational::Ratio;
 use starknet_api::block::{
-    BlockHash,
     BlockHashAndNumber,
     BlockNumber,
     BlockTimestamp,
@@ -230,29 +226,3 @@ pub(crate) fn truncate_to_executed_txs(
 
     executed_content
 }
-
-#[cfg_attr(test, automock)]
-pub trait BlockRandomGenerator: Send + Sync {
-    fn generate(
-        &self,
-        height: BlockNumber,
-        round: Round,
-        block_hash: Option<BlockHash>,
-        range: u128,
-    ) -> u128;
-}
-
-#[allow(dead_code)]
-pub struct BlockPseudorandomGenerator;
-
-impl BlockRandomGenerator for BlockPseudorandomGenerator {
-    fn generate(
-        &self,
-        _height: BlockNumber,
-        _round: Round,
-        _block_hash: Option<BlockHash>,
-        _range: u128,
-    ) -> u128 {
-        todo!()
-    }
-}

crates/apollo_consensus_orchestrator/src/utils.rs

@@ -29,18 +29,8 @@
       "external_secret": null,
       "anti_affinity": false,
       "ports": {
-        "Batcher": 55000,
-        "ClassManager": 55001,
         "ConsensusManager": 53080,
-        "Gateway": 55002,
-        "L1EndpointMonitor": 55005,
-        "L1GasPriceProvider": 55003,
-        "L1Provider": 55004,
-        "Mempool": 55006,
         "MempoolP2p": 53200,
-        "SierraCompiler": 55007,
-        "SignatureManager": 55009,
-        "StateSync": 55008,
         "HttpServer": 8080,
         "MonitoringEndpoint": 8082
       }

crates/apollo_deployments/resources/deployments/testing/deployment_config_consolidated.json

@@ -270,6 +270,38 @@
         "MonitoringEndpoint": 8082
       }
     },
+    {
+      "name": "SignatureManager",
+      "controller": "StatefulSet",
+      "config_paths": [
+        "base_app_config.json",
+        "deployments/testing/deployment_config_override.json",
+        "deployments/testing/distributed.json",
+        "services/distributed/signature_manager.json"
+      ],
+      "ingress": null,
+      "k8s_service_config": null,
+      "autoscale": false,
+      "replicas": 1,
+      "storage": null,
+      "toleration": null,
+      "resources": {
+        "requests": {
+          "cpu": 1,
+          "memory": 2
+        },
+        "limits": {
+          "cpu": 4,
+          "memory": 8
+        }
+      },
+      "external_secret": null,
+      "anti_affinity": false,
+      "ports": {
+        "SignatureManager": 55009,
+        "MonitoringEndpoint": 8082
+      }
+    },
     {
       "name": "StateSync",
       "controller": "StatefulSet",