starknet_os_flow_tests: implement virtual OS output validation. (#11468)

Author: Yoni-Starkware

crates/starknet_os_flow_tests/src/lib.rs

@@ -6,3 +6,4 @@ pub(crate) mod test_manager;
 pub(crate) mod tests;
 pub(crate) mod utils;
 pub(crate) mod virtual_os_test;
+pub(crate) mod virtual_os_test_manager;

crates/starknet_os_flow_tests/src/virtual_os_test.rs

@@ -2,12 +2,12 @@ use blockifier_test_utils::cairo_versions::{CairoVersion, RunnableCairo1};
 use blockifier_test_utils::calldata::create_calldata;
 use blockifier_test_utils::contracts::FeatureContract;
 use rstest::rstest;
+use starknet_api::core::EthAddress;
+use starknet_api::transaction::{L2ToL1Payload, MessageToL1};
 use starknet_api::{calldata, invoke_tx_args};
-use starknet_os::runner::run_virtual_os;
 use starknet_types_core::felt::Felt;
 
 use crate::test_manager::TestBuilder;
-use crate::tests::NON_TRIVIAL_RESOURCE_BOUNDS;
 
 #[rstest]
 #[tokio::test]
@@ -18,12 +18,19 @@ async fn test_basic_happy_flow() {
         TestBuilder::create_standard_virtual([(test_contract, calldata![Felt::ONE, Felt::TWO])])
             .await;
 
-    let calldata = create_calldata(contract_address, "test_storage_read", &[Felt::ONE]);
-    test_builder.add_funded_account_invoke(
-        invoke_tx_args! { calldata, resource_bounds: *NON_TRIVIAL_RESOURCE_BOUNDS },
+    let to_address = Felt::from(85);
+    let payload = vec![Felt::from(12), Felt::from(34)];
+    let calldata = create_calldata(
+        contract_address,
+        "test_send_message_to_l1",
+        &[to_address, Felt::from(payload.len()), payload[0], payload[1]],
     );
+    test_builder.add_funded_account_invoke(invoke_tx_args! { calldata });
+    test_builder.messages_to_l1.push(MessageToL1 {
+        from_address: contract_address,
+        to_address: EthAddress::try_from(to_address).unwrap(),
+        payload: L2ToL1Payload(payload),
+    });
 
-    let test_runner = test_builder.build().await;
-    // TODO(Yoni): add running and verification logic to test_manager.rs.
-    run_virtual_os(test_runner.os_hints).unwrap();
+    test_builder.build().await.run_virtual_and_validate();
 }

crates/starknet_os_flow_tests/src/virtual_os_test_manager.rs

@@ -0,0 +1,56 @@
+use starknet_os::io::virtual_os_output::{VirtualOsOutput, VirtualOsRunnerOutput};
+use starknet_os::runner::run_virtual_os;
+use starknet_types_core::felt::Felt;
+
+use crate::initial_state::FlowTestState;
+use crate::test_manager::TestRunner;
+
+/// The output of running the virtual OS for testing.
+pub(crate) struct VirtualOsTestOutput {
+    /// The raw runner output from the virtual OS.
+    pub(crate) runner_output: VirtualOsRunnerOutput,
+    /// The expected values computed from the OS hints.
+    pub(crate) expected_virtual_os_output: VirtualOsOutput,
+    // TODO(Yoni): consider adding more data for sanity checks, such as the expected state diff.
+}
+
+impl VirtualOsTestOutput {
+    /// Validates the runner output against the expected values.
+    pub(crate) fn validate(&self) {
+        let virtual_os_output = VirtualOsOutput::from_raw_output(&self.runner_output.raw_output)
+            .expect("Parsing virtual OS output should not fail.");
+
+        assert_eq!(virtual_os_output, self.expected_virtual_os_output);
+    }
+}
+
+impl<S: FlowTestState> TestRunner<S> {
+    /// Runs the virtual OS and returns the test output.
+    pub(crate) fn run_virtual(self) -> VirtualOsTestOutput {
+        // Create expected values before running the virtual OS (os_hints is consumed).
+        let first_block = self.os_hints.os_input.os_block_inputs.first().unwrap();
+        // The virtual os does support state diff encryption.
+        let public_keys = None;
+        let config_hash =
+            self.os_hints.os_hints_config.chain_info.compute_os_config_hash(public_keys).unwrap();
+
+        let expected_virtual_os_output = VirtualOsOutput {
+            version: Felt::ZERO,
+            base_block_number: first_block.block_info.block_number,
+            base_block_hash: first_block.new_block_hash.0,
+            starknet_os_config_hash: config_hash,
+            messages_to_l1: self.messages_to_l1,
+        };
+
+        // Run the virtual OS.
+        let runner_output =
+            run_virtual_os(self.os_hints).expect("Running virtual OS should not fail.");
+
+        VirtualOsTestOutput { runner_output, expected_virtual_os_output }
+    }
+
+    /// Runs the virtual OS and validates the output against expected values.
+    pub(crate) fn run_virtual_and_validate(self) {
+        self.run_virtual().validate();
+    }
+}