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_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

@@ -326,6 +326,44 @@ async fn prove_and_verify_keccak_tx() {
     .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] = 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.clone(), output.proof.clone())
+        .expect("proof verification should succeed");
+}
+
 /// Generates proof fixtures for the proof-flow integration test.
 /// To run manually: `cargo +nightly-2025-07-14 test -p starknet_os_flow_tests --features
 /// starknet_transaction_prover/stwo_proving --release generate_proof_fixtures -- --ignored`

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`.