feat: InteractionBuilder (#143)

.github/workflows/recursion.yml

@@ -0,0 +1,36 @@
+name: STARK Recursion Tests
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+    paths:
+      - "stark-backend/**"
+      - "vm/**"
+      - "compiler/**"
+      - "recursion/**"
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.sha }}
+  cancel-in-progress: true
+
+env:
+  CARGO_TERM_COLOR: always
+  AXIOM_FAST_TEST: "1"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+        with:
+          cache-on-failure: true
+
+      - name: Run recursion crate tests
+        working-directory: recursion
+        run: |
+          cargo test --profile=fast

.github/workflows/unit.yml

@@ -31,4 +31,4 @@ jobs:
 
       - name: Run unit tests
         run: |
-          cargo test --workspace --exclude afs_stark_backend --exclude stark_vm --exclude afs_compiler
+          cargo test --workspace --exclude afs-stark-backend --exclude stark-vm --exclude afs-compiler --exclude afs-recursion

bin/afs/src/commands/keygen/mod.rs

@@ -17,7 +17,7 @@ use crate::RANGE_CHECK_BITS;
 
 /// `afs keygen` command
 /// Uses information from config.toml to generate partial proving and verifying keys and
-/// saves them to the specified `output-folder` as *.partial.pk and *.partial.vk.
+/// saves them to the specified `output-folder` as *.pk and *.vk.
 #[derive(Debug, Parser)]
 pub struct KeygenCommand<SC: StarkGenericConfig, E: StarkEngine<SC>> {
     #[arg(
@@ -91,18 +91,18 @@ where
 
         page_controller.set_up_keygen_builder(&mut keygen_builder, &ops_sender);
 
-        let partial_pk = keygen_builder.generate_partial_pk();
-        let partial_vk = partial_pk.partial_vk();
+        let pk = keygen_builder.generate_pk();
+        let vk = pk.vk();
         let (total_preprocessed, total_partitioned_main, total_after_challenge) =
-            partial_vk.total_air_width();
+            vk.total_air_width();
         let air_width = total_preprocessed + total_partitioned_main + total_after_challenge;
         info!("Keygen: total air width: {}", air_width);
         println!("Keygen: total air width: {}", air_width);
 
-        let encoded_pk: Vec<u8> = bincode::serialize(&partial_pk)?;
-        let encoded_vk: Vec<u8> = bincode::serialize(&partial_vk)?;
-        let pk_path = output_folder.clone() + "/" + &prefix.clone() + ".partial.pk";
-        let vk_path = output_folder.clone() + "/" + &prefix.clone() + ".partial.vk";
+        let encoded_pk: Vec<u8> = bincode::serialize(&pk)?;
+        let encoded_vk: Vec<u8> = bincode::serialize(&vk)?;
+        let pk_path = output_folder.clone() + "/" + &prefix.clone() + ".pk";
+        let vk_path = output_folder.clone() + "/" + &prefix.clone() + ".vk";
         let _ = fs::create_dir_all(&output_folder);
         write_bytes(&encoded_pk, pk_path).unwrap();
         write_bytes(&encoded_vk, vk_path).unwrap();

bin/afs/src/commands/prove/mod.rs

@@ -6,7 +6,7 @@ use afs_chips::{
 };
 use afs_stark_backend::{
     config::{Com, PcsProof, PcsProverData},
-    keygen::types::MultiStarkPartialProvingKey,
+    keygen::types::MultiStarkProvingKey,
     prover::trace::{ProverTraceData, TraceCommitmentBuilder},
 };
 use afs_test_utils::{
@@ -208,14 +208,12 @@ where
         let ops_sender_trace = ops_sender.generate_trace(&zk_ops, config.page.max_rw_ops);
         trace_span.exit();
 
-        let encoded_pk =
-            read_from_path(keys_folder.clone() + "/" + &prefix + ".partial.pk").unwrap();
-        let partial_pk: MultiStarkPartialProvingKey<SC> =
-            bincode::deserialize(&encoded_pk).unwrap();
+        let encoded_pk = read_from_path(keys_folder.clone() + "/" + &prefix + ".pk").unwrap();
+        let pk: MultiStarkProvingKey<SC> = bincode::deserialize(&encoded_pk).unwrap();
 
         let proof = page_controller.prove(
             engine,
-            &partial_pk,
+            &pk,
             &mut trace_builder,
             init_page_pdata,
             final_page_pdata,

bin/afs/src/commands/verify/mod.rs

@@ -6,7 +6,7 @@ use std::{
 };
 
 use afs_chips::{execution_air::ExecutionAir, page_rw_checker::page_controller::PageController};
-use afs_stark_backend::{keygen::types::MultiStarkPartialVerifyingKey, prover::types::Proof};
+use afs_stark_backend::{keygen::types::MultiStarkVerifyingKey, prover::types::Proof};
 use afs_test_utils::{
     engine::StarkEngine,
     page_config::{PageConfig, PageMode},
@@ -106,10 +106,8 @@ where
         let idx_decomp = RANGE_CHECK_BITS;
         println!("Verifying proof file: {}", proof_file);
 
-        let encoded_vk =
-            read_from_path(keys_folder.clone() + "/" + &prefix + ".partial.vk").unwrap();
-        let partial_vk: MultiStarkPartialVerifyingKey<SC> =
-            bincode::deserialize(&encoded_vk).unwrap();
+        let encoded_vk = read_from_path(keys_folder.clone() + "/" + &prefix + ".vk").unwrap();
+        let vk: MultiStarkVerifyingKey<SC> = bincode::deserialize(&encoded_vk).unwrap();
 
         let encoded_proof = read_from_path(proof_file.clone()).unwrap();
         let proof: Proof<SC> = bincode::deserialize(&encoded_proof).unwrap();
@@ -123,7 +121,7 @@ where
             idx_decomp,
         );
         let ops_sender = ExecutionAir::new(ops_bus_index, idx_len, data_len);
-        let result = page_controller.verify(engine, partial_vk, proof, &ops_sender);
+        let result = page_controller.verify(engine, vk, proof, &ops_sender);
         if result.is_err() {
             println!("Verification Unsuccessful");
         } else {

bin/olap/src/commands/keygen/filter.rs

@@ -61,19 +61,19 @@ where
         page_controller.set_up_keygen_builder(&mut keygen_builder, page_width, idx_len);
 
         // Write the partial pk and vk to disk
-        let partial_pk = keygen_builder.generate_partial_pk();
-        let partial_vk = partial_pk.partial_vk();
+        let pk = keygen_builder.generate_pk();
+        let vk = pk.vk();
         let (total_preprocessed, total_partitioned_main, total_after_challenge) =
-            partial_vk.total_air_width();
+            vk.total_air_width();
         let air_width = total_preprocessed + total_partitioned_main + total_after_challenge;
         info!("Keygen: total air width: {}", air_width);
         println!("Keygen: total air width: {}", air_width);
 
-        let encoded_pk: Vec<u8> = bincode::serialize(&partial_pk)?;
-        let encoded_vk: Vec<u8> = bincode::serialize(&partial_vk)?;
+        let encoded_pk: Vec<u8> = bincode::serialize(&pk)?;
+        let encoded_vk: Vec<u8> = bincode::serialize(&vk)?;
         let prefix = config.generate_filename();
-        let pk_path = keys_folder.clone() + "/" + &prefix.clone() + ".partial.pk";
-        let vk_path = keys_folder.clone() + "/" + &prefix.clone() + ".partial.vk";
+        let pk_path = keys_folder.clone() + "/" + &prefix.clone() + ".pk";
+        let vk_path = keys_folder.clone() + "/" + &prefix.clone() + ".vk";
         let _ = fs::create_dir_all(keys_folder);
         write_bytes(&encoded_pk, pk_path.clone()).unwrap();
         write_bytes(&encoded_vk, vk_path.clone()).unwrap();

bin/olap/src/commands/keygen/inner_join.rs

@@ -50,12 +50,12 @@ where
         );
         let mut keygen_builder = engine.keygen_builder();
         inner_join_controller.set_up_keygen_builder(&mut keygen_builder);
-        let partial_pk = keygen_builder.generate_partial_pk();
-        let partial_vk = partial_pk.partial_vk();
+        let pk = keygen_builder.generate_pk();
+        let vk = pk.vk();
 
         let prefix = config.generate_filename();
-        let encoded_pk: Vec<u8> = bincode::serialize(&partial_pk)?;
-        let encoded_vk: Vec<u8> = bincode::serialize(&partial_vk)?;
+        let encoded_pk: Vec<u8> = bincode::serialize(&pk)?;
+        let encoded_vk: Vec<u8> = bincode::serialize(&vk)?;
         let pk_path = keys_folder.clone() + "/" + &prefix.clone() + ".partial.pk";
         let vk_path = keys_folder.clone() + "/" + &prefix.clone() + ".partial.vk";
         let _ = fs::create_dir_all(&keys_folder);

bin/olap/src/commands/prove/filter.rs

@@ -3,7 +3,7 @@ use std::{fs, marker::PhantomData, sync::Arc};
 use afs_chips::single_page_index_scan::page_controller::PageController;
 use afs_stark_backend::{
     config::{Com, PcsProof, PcsProverData},
-    keygen::types::MultiStarkPartialProvingKey,
+    keygen::types::MultiStarkProvingKey,
     prover::trace::{ProverTraceData, TraceCommitmentBuilder},
 };
 use afs_test_utils::{engine::StarkEngine, page_config::PageConfig};
@@ -139,13 +139,12 @@ where
         let prefix = config.generate_filename();
         let encoded_pk =
             read_from_path(keys_folder.clone() + "/" + &prefix + ".partial.pk").unwrap();
-        let partial_pk: MultiStarkPartialProvingKey<SC> =
-            bincode::deserialize(&encoded_pk).unwrap();
+        let pk: MultiStarkProvingKey<SC> = bincode::deserialize(&encoded_pk).unwrap();
 
         // Prove
         let proof = page_controller.prove(
             engine,
-            &partial_pk,
+            &pk,
             &mut trace_builder,
             input_prover_data,
             output_prover_data,

bin/olap/src/commands/prove/inner_join.rs

@@ -3,7 +3,7 @@ use std::{fs, marker::PhantomData};
 use afs_chips::inner_join::controller::FKInnerJoinController;
 use afs_stark_backend::{
     config::{Com, PcsProof, PcsProverData},
-    keygen::types::MultiStarkPartialProvingKey,
+    keygen::types::MultiStarkProvingKey,
     prover::trace::{ProverTraceData, TraceCommitmentBuilder},
 };
 use afs_test_utils::{engine::StarkEngine, page_config::PageConfig};
@@ -66,8 +66,7 @@ where
         let prefix = config.generate_filename();
         let encoded_pk =
             read_from_path(keys_folder.clone() + "/" + &prefix + ".partial.pk").unwrap();
-        let partial_pk: MultiStarkPartialProvingKey<SC> =
-            bincode::deserialize(&encoded_pk).unwrap();
+        let pk: MultiStarkProvingKey<SC> = bincode::deserialize(&encoded_pk).unwrap();
 
         // Get the trace data from file
         let table_id_full = inner_join_op.table_id_left.to_string();
@@ -91,8 +90,7 @@ where
         );
 
         // Generate a proof and write to file
-        let proof =
-            inner_join_controller.prove(engine, &partial_pk, &mut trace_builder, prover_trace_data);
+        let proof = inner_join_controller.prove(engine, &pk, &mut trace_builder, prover_trace_data);
         let encoded_proof = bincode::serialize(&proof).unwrap();
         let proof_path = cache_folder.clone() + "/" + &table_id_full + ".proof.bin";
         let _ = fs::create_dir_all(&cache_folder);

bin/olap/src/commands/verify/filter.rs

@@ -2,7 +2,7 @@ use std::marker::PhantomData;
 
 use afs_chips::single_page_index_scan::page_controller::PageController;
 use afs_stark_backend::{
-    config::PcsProverData, keygen::types::MultiStarkPartialVerifyingKey, prover::types::Proof,
+    config::PcsProverData, keygen::types::MultiStarkVerifyingKey, prover::types::Proof,
 };
 use afs_test_utils::{engine::StarkEngine, page_config::PageConfig};
 use bin_common::utils::io::read_from_path;
@@ -70,10 +70,8 @@ where
 
         // Load from disk and deserialize partial verifying key
         let prefix = config.generate_filename();
-        let encoded_vk =
-            read_from_path(keys_folder.clone() + "/" + &prefix + ".partial.vk").unwrap();
-        let partial_vk: MultiStarkPartialVerifyingKey<SC> =
-            bincode::deserialize(&encoded_vk).unwrap();
+        let encoded_vk = read_from_path(keys_folder.clone() + "/" + &prefix + ".vk").unwrap();
+        let vk: MultiStarkVerifyingKey<SC> = bincode::deserialize(&encoded_vk).unwrap();
 
         // Get proof from disk
         let filter_info = format!(
@@ -88,9 +86,7 @@ where
         let proof: Proof<SC> = bincode::deserialize(&encoded_proof).unwrap();
 
         // Verify proof
-        page_controller
-            .verify(engine, partial_vk, proof, value)
-            .unwrap();
+        page_controller.verify(engine, vk, proof, value).unwrap();
 
         if !common.silent {
             println!("Proof verified in {:?}", start.elapsed());

bin/olap/src/commands/verify/inner_join.rs

@@ -2,7 +2,7 @@ use std::marker::PhantomData;
 
 use afs_chips::inner_join::controller::FKInnerJoinController;
 use afs_stark_backend::{
-    config::PcsProverData, keygen::types::MultiStarkPartialProvingKey, prover::types::Proof,
+    config::PcsProverData, keygen::types::MultiStarkProvingKey, prover::types::Proof,
 };
 use afs_test_utils::{engine::StarkEngine, page_config::PageConfig};
 use bin_common::utils::io::read_from_path;
@@ -53,11 +53,9 @@ where
         );
 
         let prefix = config.generate_filename();
-        let encoded_pk =
-            read_from_path(keys_folder.clone() + "/" + &prefix + ".partial.pk").unwrap();
-        let partial_pk: MultiStarkPartialProvingKey<SC> =
-            bincode::deserialize(&encoded_pk).unwrap();
-        let partial_vk = partial_pk.partial_vk();
+        let encoded_pk = read_from_path(keys_folder.clone() + "/" + &prefix + ".pk").unwrap();
+        let pk: MultiStarkProvingKey<SC> = bincode::deserialize(&encoded_pk).unwrap();
+        let vk = pk.vk();
 
         // Get proof from disk
         let table_id_full = inner_join_op.table_id_left.to_string();
@@ -67,9 +65,7 @@ where
         let proof: Proof<SC> = bincode::deserialize(&encoded_proof).unwrap();
 
         // Verify proof
-        inner_join_controller
-            .verify(engine, partial_vk, proof)
-            .unwrap();
+        inner_join_controller.verify(engine, vk, proof).unwrap();
 
         Ok(())
     }