starknet_os_flow_tests: add multicall prove test; drop balance_of test

- Add `multi_call(Array<Call>)` to `account_with_dummy_validate.cairo`
  with a TODO above `__execute__` to eventually replace its single-call
  shape with the multicall-style entry point.
- Add `prove_and_verify_multicall_tx` in `crates/starknet_os_flow_tests/
  src/virtual_os_test.rs`: a single virtual-OS tx forwards through
  `__execute__` to the new `multi_call`, currently dispatching
  `test_keccak` and `test_ec_op`. Inner calls are appended via a local
  `serialize_call(name, args)` helper that bumps the leading `num_calls`
  counter in `multi_call_args`, so each call site is one line. Marked
  `#[ignore]`; doc carries a TODO to extend coverage.
- Remove `test_prove_balance_of_transaction` from `crates/
  starknet_transaction_prover/src/proving/virtual_snos_prover_test.rs`
  — the remaining `test_prove_transfer_transaction` already covers the
  same `VirtualSnosProver::prove_transaction` Sepolia path.
- Run the new test in the prover CI workflow alongside
  `virtual_snos_prover_test`. Also widen the workflow's path triggers
  to include `apollo_starknet_os_program/**` (compiles the OS program
  the prover runs), `blockifier_test_utils/**` (account/contract test
  sources), and `starknet_os_flow_tests/**`. Path triggers are not
  transitive, so these had to be listed explicitly.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: Yoni-Starkware

.github/workflows/starknet_transaction_prover_ci.yml

@@ -12,11 +12,14 @@ on:
       - ".github/workflows/starknet_transaction_prover_ci.yml"
       - "Cargo.lock"
       - "Cargo.toml"
+      - "crates/apollo_starknet_os_program/**"
       - "crates/blockifier/**"
       - "crates/blockifier_reexecution/**"
+      - "crates/blockifier_test_utils/**"
       - "crates/proving_utils/**"
       - "crates/starknet_committer/**"
       - "crates/starknet_os/**"
+      - "crates/starknet_os_flow_tests/**"
       - "crates/starknet_patricia/**"
       - "crates/starknet_transaction_prover/**"
       - "scripts/build_starknet_transaction_prover.sh"
@@ -110,6 +113,10 @@ jobs:
         working-directory: crates/starknet_transaction_prover
         run: cargo test --release -p starknet_transaction_prover --features stwo_proving virtual_snos_prover_test -- --ignored --test-threads=1
 
+      - name: Run virtual OS multicall proving test
+        working-directory: crates/starknet_transaction_prover
+        run: cargo test --release -p starknet_os_flow_tests --features starknet_transaction_prover/stwo_proving prove_and_verify_multicall_tx -- --ignored --test-threads=1
+
   # Test that the starknet_transaction_prover Docker image builds successfully.
   docker-build:
     runs-on: namespace-profile-medium-ubuntu-24-04-amd64

crates/blockifier/src/bouncer_test.rs

@@ -804,11 +804,11 @@ fn class_hash_migration_data_from_state(
 
     if should_migrate {
         expect![[r#"
-            108525874
+            110673392
         "#]]
         .assert_debug_eq(&migration_sierra_gas.0);
         expect![[r#"
-            266554526
+            271891610
         "#]]
         .assert_debug_eq(&migration_proving_gas.0);
     } else {

crates/blockifier/src/execution/stack_trace_regression/test_contract_ctor_frame_stack_trace_cairo1_casm.txt

@@ -2,7 +2,7 @@ Transaction execution has failed:
 0: Error in the called contract (contract address: 0x00000000000000000000000000000000000000000000000000000000c0020000, class hash: 0x0000000000000000000000000000000000000000000000000000000080020000, selector: 0x015d40a3d6ca2ac30f4031e42be28da9b056fef9bb7357ac5e85627ee876e5ad):
 Error at pc=0:539:
 1: Error in the called contract (contract address: 0x00000000000000000000000000000000000000000000000000000000c0020000, class hash: 0x0000000000000000000000000000000000000000000000000000000080020000, selector: 0x02730079d734ee55315f4f141eaed376bddd8c2133523d223a344c5604e0f7f8):
-Error at pc=0:781:
+Error at pc=0:950:
 2: Error in the contract class constructor (contract address: 0x0103ee82605273496eed8d9141c5b3ad967baa08be63aa5bc49ffae5eae454cc, class hash: 0x0000000000000000000000000000000000000000000000000000000080040000, selector: 0x028ffe4ff0f226a9107253e17a904099aa4f63a02a5621de0576e5aa71bc5194):
 Execution failed. Failure reason:
 Error in contract (contract address: 0x0103ee82605273496eed8d9141c5b3ad967baa08be63aa5bc49ffae5eae454cc, class hash: 0x0000000000000000000000000000000000000000000000000000000080040000, selector: 0x028ffe4ff0f226a9107253e17a904099aa4f63a02a5621de0576e5aa71bc5194):

crates/blockifier_test_utils/resources/feature_contracts/cairo1/account_with_dummy_validate.cairo

@@ -1,6 +1,7 @@
 #[starknet::contract(account)]
 mod Account {
     use array::{ArrayTrait, SpanTrait};
+    use starknet::account::Call;
     use starknet::{ClassHash, ContractAddress, call_contract_syscall};
     use starknet::info::SyscallResultTrait;
     use starknet::syscalls;
@@ -34,6 +35,9 @@ mod Account {
         starknet::VALIDATED
     }
 
+    // TODO(Yoni): replace this single-call `__execute__` with the multicall-shaped
+    // `multi_call` below, so this account can execute INVOKE transactions whose
+    // calldata is `Array<Call>` natively (matching the standard account ABI).
     #[external(v0)]
     #[raw_output]
     fn __execute__(
@@ -52,6 +56,32 @@ mod Account {
         ).unwrap_syscall()
     }
 
+    /// Executes a sequence of calls and returns their concatenated return values.
+    /// The intended invocation in tests is via `__execute__`, with `__execute__`
+    /// forwarding `(self_address, "multi_call", serialized calls)` to this entry point.
+    #[external(v0)]
+    fn multi_call(
+        self: @ContractState, mut calls: Array<Call>
+    ) -> Array<Span<felt252>> {
+        let mut result = ArrayTrait::new();
+        loop {
+            match calls.pop_front() {
+                Option::Some(call) => {
+                    let res = call_contract_syscall(
+                        address: call.to,
+                        entry_point_selector: call.selector,
+                        calldata: call.calldata,
+                    ).unwrap_syscall();
+                    result.append(res);
+                },
+                Option::None => {
+                    break;
+                },
+            };
+        };
+        result
+    }
+
     #[external(v0)]
     fn deploy_contract(
         self: @ContractState,

crates/starknet_os_flow_tests/src/virtual_os_test.rs

@@ -276,9 +276,9 @@ async fn test_reverted_tx_os_error() {
 /// Reproduces a privacy-prove failure when proving a virtual OS run that uses the keccak builtin.
 ///
 /// Scenario:
-/// - Invoke `test_contract::test_keccak`, which uses both `keccak::keccak_u256s_le_inputs`
-///   (keccak BUILTIN) and `syscalls::keccak_syscall` with invalid input length (keccak SYSCALL
-///   failure path).
+/// - Invoke `test_contract::test_keccak`, which uses both `keccak::keccak_u256s_le_inputs` (keccak
+///   BUILTIN) and `syscalls::keccak_syscall` with invalid input length (keccak SYSCALL failure
+///   path).
 /// - Run through the virtual OS (succeeds), then prove via `privacy-prove` and verify.
 ///
 /// Observed result: OS execution succeeds; proving panics in
@@ -288,10 +288,10 @@ async fn test_reverted_tx_os_error() {
 /// at `simple_bootloader/execute_task.cairo:209`.
 ///
 /// Likely cause: `privacy_prove::consts::CAIRO_RUN_CONFIG` selects `LayoutName::stwo_no_ecop`,
-/// which has `keccak: None` (`cairo-vm-3.2.0/src/types/instance_definitions/builtins_instance_def.rs`).
-/// The bootloader simulates keccak via `simple_bootloader_simulate_keccak`, but the simulation
-/// does not appear to cover relocating an inner task PIE whose keccak builtin segment is
-/// non-empty.
+/// which has `keccak: None`
+/// (`cairo-vm-3.2.0/src/types/instance_definitions/builtins_instance_def.rs`). The bootloader
+/// simulates keccak via `simple_bootloader_simulate_keccak`, but the simulation does not appear to
+/// cover relocating an inner task PIE whose keccak builtin segment is non-empty.
 ///
 /// Isolation experiment: commenting out the `keccak::keccak_u256s_le_inputs` call in
 /// `test_contract::test_keccak` (leaving only the keccak SYSCALL failure path) makes this test
@@ -318,12 +318,48 @@ async fn prove_and_verify_keccak_tx() {
 
     let proof_facts = output.proof_facts.clone();
     let proof = output.proof.clone();
-    tokio::task::spawn_blocking(move || {
-        starknet_proof_verifier::verify_proof(proof_facts, proof)
-    })
-    .await
-    .expect("proof verification task panicked")
-    .expect("proof verification should succeed");
+    tokio::task::spawn_blocking(move || starknet_proof_verifier::verify_proof(proof_facts, proof))
+        .await
+        .expect("proof verification task panicked")
+        .expect("proof verification should succeed");
+}
+
+/// Proves and verifies a virtual OS run of a single transaction that performs a
+/// multicall through the account contract. The inner calls can be extended over
+/// time to grow syscall/builtin coverage.
+#[tokio::test(flavor = "multi_thread")]
+#[ignore]
+async fn prove_and_verify_multicall_tx() {
+    let test_contract = FeatureContract::TestContract(CairoVersion::Cairo1(RunnableCairo1::Casm));
+
+    let (mut test_builder, [contract_address]) =
+        TestBuilder::create_standard_virtual([(test_contract, calldata![Felt::ONE, Felt::TWO])])
+            .await;
+
+    // Appends a single `Call` entry to `multi_call_args` as
+    // `[to, selector, calldata_len, *calldata]` and bumps the leading `num_calls`
+    // counter. All inner calls in this test target the same test contract.
+    let mut multi_call_args: Vec<Felt> = vec![Felt::ZERO];
+    let mut serialize_call = |func_name: &str, args: &[Felt]| {
+        multi_call_args[0] += Felt::ONE;
+        multi_call_args.push(*contract_address.0.key());
+        multi_call_args.push(selector_from_name(func_name).0);
+        multi_call_args.push(Felt::from(args.len()));
+        multi_call_args.extend_from_slice(args);
+    };
+
+    // TODO(Yoni): add more inner calls (e.g. sha256, secp256k1, send_message_to_l1).
+    serialize_call("test_keccak", &[]);
+    serialize_call("test_ec_op", &[]);
+
+    // The dummy account's `__execute__(contract_address, selector, calldata)` forwards
+    // to its own `multi_call` entry point.
+    let calldata = create_calldata(*FUNDED_ACCOUNT_ADDRESS, "multi_call", &multi_call_args);
+    test_builder.add_funded_account_invoke(invoke_tx_args! { calldata });
+
+    let output = test_builder.build().await.run_virtual().prove().await;
+    starknet_proof_verifier::verify_proof(output.proof_facts, output.proof)
+        .expect("proof verification should succeed");
 }
 
 /// Generates proof fixtures for the proof-flow integration test.

crates/starknet_transaction_prover/src/proving/virtual_snos_prover_test.rs

@@ -44,44 +44,6 @@ use crate::test_utils::{
     STRK_TOKEN_ADDRESS_SEPOLIA,
 };
 
-/// Integration test for the full prover pipeline with a `balanceOf` transaction.
-/// Runs on a Sepolia environment; in live/recording mode requires a Sepolia RPC node via
-/// `NODE_URL`.
-#[rstest]
-#[tokio::test(flavor = "multi_thread")]
-#[ignore]
-async fn test_prove_balance_of_transaction() {
-    let test_mode = resolve_test_mode("test_prove_balance_of_transaction").await;
-
-    // Creates an RPC invoke transaction that calls `balanceOf` on the STRK token.
-    let strk_token = ContractAddress::try_from(STRK_TOKEN_ADDRESS_SEPOLIA).unwrap();
-    let account = ContractAddress::try_from(DUMMY_ACCOUNT_ADDRESS).unwrap();
-
-    // Calldata matches dummy account's __execute__(contract_address, selector, calldata).
-    let calldata = create_calldata(strk_token, "balanceOf", &[account.into()]);
-    let rpc_tx = build_client_side_rpc_invoke(account, calldata);
-
-    let factory = runner_factory(&test_mode.rpc_url());
-    let prover = VirtualSnosProver::from_runner(factory);
-
-    // Run the full prover pipeline: OS execution → proof generation.
-    let result = prover.prove_transaction(BlockId::Latest, rpc_tx).await;
-
-    // Finalize recording before asserting so records are saved even on failure.
-    test_mode.finalize();
-
-    // Verify execution and proving succeeded.
-    let output = result.expect("prove_transaction should succeed");
-
-    // Verify the proof against the proof facts.
-    let proof_facts = output.proof_facts.clone();
-    let proof = output.proof.clone();
-    tokio::task::spawn_blocking(move || verify_proof(proof_facts, proof))
-        .await
-        .expect("proof verification task panicked")
-        .expect("proof verification should succeed");
-}
-
 /// Integration test for the full prover pipeline with a STRK `transfer` transaction.
 /// Runs on a Sepolia environment; in live/recording mode requires a Sepolia RPC node via
 /// `NODE_URL`.