openvm-org
diff --git a/‎Cargo.toml
Lines changed: 1 addition & 0 deletions b/‎Cargo.toml
Lines changed: 1 addition & 0 deletions
diff --git a/‎config.toml
Lines changed: 1 addition & 1 deletion b/‎config.toml
Lines changed: 1 addition & 1 deletion
diff --git a/‎vm/Cargo.toml
Lines changed: 5 additions & 0 deletions b/‎vm/Cargo.toml
Lines changed: 5 additions & 0 deletions
diff --git a/‎vm/bin/Cargo.toml
Lines changed: 58 additions & 0 deletions b/‎vm/bin/Cargo.toml
Lines changed: 58 additions & 0 deletions
diff --git a/‎vm/bin/resources/config.toml
Lines changed: 4 additions & 0 deletions b/‎vm/bin/resources/config.toml
Lines changed: 4 additions & 0 deletions
diff --git a/‎vm/bin/resources/fibonacci.asm
Lines changed: 52 additions & 0 deletions b/‎vm/bin/resources/fibonacci.asm
Lines changed: 52 additions & 0 deletions
diff --git a/‎vm/bin/src/asm/mod.rs
Lines changed: 51 additions & 0 deletions b/‎vm/bin/src/asm/mod.rs
Lines changed: 51 additions & 0 deletions
diff --git a/‎vm/bin/src/cli/mod.rs
Lines changed: 50 additions & 0 deletions b/‎vm/bin/src/cli/mod.rs
Lines changed: 50 additions & 0 deletions
diff --git a/‎vm/bin/src/commands/keygen.rs
Lines changed: 78 additions & 0 deletions b/‎vm/bin/src/commands/keygen.rs
Lines changed: 78 additions & 0 deletions
diff --git a/‎vm/bin/src/commands/mod.rs
Lines changed: 25 additions & 0 deletions b/‎vm/bin/src/commands/mod.rs
Lines changed: 25 additions & 0 deletions
@@ -8,6 +8,7 @@ members = [
     "bin/afs",
     "logical-interface",
     "vm",
+    "vm/bin",
 ]
 resolver = "2"
 
 
@@ -4,4 +4,4 @@ data_bytes = 1024
 bits_per_fe = 16
 height = 1048576
 mode = "ReadWrite" # options: "ReadOnly", "ReadWrite"
-max_rw_ops = 65536
+max_rw_ops = 65536
@@ -29,6 +29,11 @@ itertools = "0.13.0"
 getset = "0.1.2"
 derive-new = "0.5.1"
 
+serde = "1.0.203"
+serde_derive = "1.0.203"
+toml = "0.8.14"
+enum-utils = "0.1.1"
+
 [dev-dependencies]
 p3-uni-stark = { workspace = true }
 p3-baby-bear = { workspace = true }
 
@@ -0,0 +1,58 @@
+[package]
+name = "cli"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+description = "CLI for the STARK VM"
+
+[dependencies]
+p3-air = { workspace = true }
+p3-baby-bear = { workspace = true, optional = true }
+p3-commit = { workspace = true }
+p3-field = { workspace = true }
+p3-keccak = { workspace = true }
+p3-keccak-air = { workspace = true }
+p3-matrix = { workspace = true }
+p3-maybe-rayon = { workspace = true }
+p3-symmetric = { workspace = true }
+p3-util = { workspace = true }
+p3-uni-stark = { workspace = true }
+rand = "0.8"
+
+afs-chips = { path = "../../chips" }
+afs-stark-backend = { path = "../../stark-backend" }
+afs-derive = { path = "../../derive" }
+afs-test-utils = { path = "../../test-utils" }
+stark-vm = { path = "../" }
+parking_lot = "0.12.2"
+tracing = "0.1.40"
+itertools = "0.13.0"
+getset = "0.1.2"
+derive-new = "0.5.1"
+
+clap = { version = "4.5.4", features = ["derive"] }
+color-eyre = "0.6.3"
+bincode = "1.3.3"
+logical-interface = { path = "../../logical-interface" }
+serde = "1.0.203"
+serde_derive = "1.0.203"
+toml = "0.8.14"
+
+[dev-dependencies]
+p3-uni-stark = { workspace = true }
+p3-baby-bear = { workspace = true }
+p3-challenger = { workspace = true }
+p3-dft = { workspace = true }
+p3-fri = { workspace = true }
+p3-goldilocks = { workspace = true }
+p3-keccak = { workspace = true }
+p3-merkle-tree = { workspace = true }
+p3-poseidon2 = { workspace = true }
+p3-symmetric = { workspace = true }
+tracing-subscriber = { version = "0.3.17", features = ["std", "env-filter"] }
+tracing-forest = { version = "0.1.6", features = ["ansi", "smallvec"] }
+test-case = "3.3.1"
+
+[features]
+default = ["test-traits"]
+test-traits = ["p3-baby-bear"]
@@ -0,0 +1,4 @@
+[vm]
+field_arithmetic_enabled = true
+limb_bits = 8
+decomp = 4
@@ -0,0 +1,52 @@
+# (-0 indicates unused value)
+
+# initialize register 0 as n = 9
+STOREW 9 0 0 0 1
+# output will be stored in register 1
+
+# initialize register 2 as 1, will be used as index
+STOREW 1 0 2 0 1
+
+
+# initialize register 3 as 1 (utility)
+STOREW 1 0 3 0 1
+
+
+# initialize [0]_2 as 0 and [1]_2 as 1 (initial values)
+STOREW 0 0 0 0 2
+
+
+
+STOREW 1 0 1 0 2
+
+
+# once index = n, terminate (pc += 7)
+BEQ 2 0 7 1 1
+
+
+# increment index
+FADD 2 2 3 1 1
+
+
+# load [index - 2]_2, [index - 1]_2 into registers 4, 5
+LOADW 4 -2 2 1 2
+
+
+
+LOADW 5 -1 2 1 2
+
+
+# calculate new value in register 6
+FADD 6 4 5 1 1
+
+
+# store new value in [index]_2
+STOREW 6 0 2 1 2
+
+
+# jump to beginning of loop
+JAL 7 -6 -0 1 -0
+
+
+# terminate
+TERMINATE -0 -0 -0 -0 -0
@@ -0,0 +1,51 @@
+use std::fs::File;
+
+use std::io::{BufRead, BufReader};
+use std::path::Path;
+
+use color_eyre::eyre::{Report, Result};
+use p3_field::PrimeField64;
+use stark_vm::cpu::trace::Instruction;
+
+pub fn parse_asm_file<F: PrimeField64>(path: &Path) -> Result<Vec<Instruction<F>>> {
+    let file = File::open(path)?;
+    let reader = BufReader::new(file);
+
+    let mut result = vec![];
+    for line in reader.lines() {
+        if let Some(instruction) = instruction_from_line::<F>(&line?)? {
+            result.push(instruction);
+        }
+    }
+
+    Ok(result)
+}
+
+fn instruction_from_line<F: PrimeField64>(line: &str) -> Result<Option<Instruction<F>>> {
+    let parts: Vec<&str> = line.split_whitespace().collect();
+    if parts.is_empty() {
+        return Ok(None);
+    }
+    if parts[0].starts_with('#') {
+        return Ok(None);
+    }
+    if parts.len() != 6 {
+        return Err(Report::msg(
+            "Instruction should have opcode followed by 5 arguments",
+        ));
+    }
+    let opcode = parts[0]
+        .parse()
+        .map_err(|_| Report::msg("Invalid opcode"))?;
+    let mut ints = vec![];
+    for part in parts.iter().skip(1) {
+        ints.push(
+            part.parse::<isize>()
+                .map_err(|_| Report::msg("Opcode argument should be int"))?,
+        );
+    }
+
+    Ok(Some(Instruction::from_isize(
+        opcode, ints[0], ints[1], ints[2], ints[3], ints[4],
+    )))
+}
@@ -0,0 +1,50 @@
+use crate::commands::keygen::KeygenCommand;
+use crate::commands::{keygen, prove, verify};
+use clap::Parser;
+use clap::Subcommand;
+use stark_vm::vm::config::VmConfig;
+
+#[derive(Debug, Parser)]
+#[command(author, version, about = "VM STARK CLI")]
+#[command(propagate_version = true)]
+pub struct Cli {
+    #[command(subcommand)]
+    pub command: CliCommand,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum CliCommand {
+    #[command(name = "keygen", about = "Generate partial proving and verifying keys")]
+    /// Generate partial proving and verifying keys
+    Keygen(keygen::KeygenCommand),
+
+    #[command(name = "prove", about = "Generates a multi-STARK proof")]
+    /// Generates a multi-STARK proof
+    Prove(prove::ProveCommand),
+
+    #[command(name = "verify", about = "Verifies a multi-STARK proof")]
+    /// Verifies a multi-STARK proof
+    Verify(verify::VerifyCommand),
+}
+
+impl Cli {
+    pub fn run(config: VmConfig) -> Self {
+        let cli = Self::parse();
+        match &cli.command {
+            CliCommand::Keygen(keygen) => {
+                let cmd = KeygenCommand {
+                    output_folder: keygen.output_folder.clone(),
+                    asm_file_path: keygen.asm_file_path.clone(),
+                };
+                cmd.execute(config).unwrap();
+            }
+            CliCommand::Prove(prove) => {
+                prove.execute(config).unwrap();
+            }
+            CliCommand::Verify(verify) => {
+                verify.execute(config).unwrap();
+            }
+        }
+        cli
+    }
+}
@@ -0,0 +1,78 @@
+use std::{
+    fs::{self},
+    path::Path,
+    time::Instant,
+};
+
+use afs_test_utils::{
+    config::{self},
+    engine::StarkEngine,
+};
+use clap::Parser;
+use color_eyre::eyre::Result;
+use itertools::Itertools;
+use p3_matrix::Matrix;
+use stark_vm::vm::{config::VmConfig, VirtualMachine};
+
+use crate::asm::parse_asm_file;
+
+use super::write_bytes;
+
+/// `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.
+#[derive(Debug, Parser)]
+pub struct KeygenCommand {
+    #[arg(
+        long = "asm-file",
+        short = 'f',
+        help = "The .asm file input",
+        required = true
+    )]
+    pub asm_file_path: String,
+    #[arg(
+        long = "output-folder",
+        short = 'o',
+        help = "The folder to output the keys to",
+        required = false,
+        default_value = "keys"
+    )]
+    pub output_folder: String,
+}
+
+impl KeygenCommand {
+    /// Execute the `keygen` command
+    pub fn execute(self, config: VmConfig) -> Result<()> {
+        let start = Instant::now();
+        self.execute_helper(config)?;
+        let duration = start.elapsed();
+        println!("Generated keys in {:?}", duration);
+        Ok(())
+    }
+
+    fn execute_helper(self, config: VmConfig) -> Result<()> {
+        let instructions = parse_asm_file(Path::new(&self.asm_file_path.clone()))?;
+        let vm = VirtualMachine::new(config, instructions);
+        let engine = config::baby_bear_poseidon2::default_engine(vm.max_log_degree());
+        let mut keygen_builder = engine.keygen_builder();
+
+        let chips = vm.chips();
+        let traces = vm.traces();
+
+        for (chip, trace) in chips.into_iter().zip_eq(traces) {
+            keygen_builder.add_air(chip, trace.height(), 0);
+        }
+
+        let partial_pk = keygen_builder.generate_partial_pk();
+        let partial_vk = partial_pk.partial_vk();
+        let encoded_pk: Vec<u8> = bincode::serialize(&partial_pk)?;
+        let encoded_vk: Vec<u8> = bincode::serialize(&partial_vk)?;
+        fs::create_dir_all(Path::new(&self.output_folder))?;
+        let pk_path = Path::new(&self.output_folder).join("partial.pk");
+        let vk_path = Path::new(&self.output_folder).join("partial.vk");
+        fs::create_dir_all(self.output_folder)?;
+        write_bytes(&encoded_pk, &pk_path)?;
+        write_bytes(&encoded_vk, &vk_path)?;
+        Ok(())
+    }
+}
@@ -0,0 +1,25 @@
+use color_eyre::eyre::Result;
+use std::{
+    fs::File,
+    io::{BufReader, BufWriter, Read, Write},
+    path::Path,
+};
+
+pub mod keygen;
+pub mod prove;
+pub mod verify;
+
+fn read_from_path(path: &Path) -> Result<Vec<u8>> {
+    let file = File::open(path)?;
+    let mut reader = BufReader::new(file);
+    let mut buf = vec![];
+    reader.read_to_end(&mut buf)?;
+    Ok(buf)
+}
+
+fn write_bytes(bytes: &[u8], path: &Path) -> Result<()> {
+    let file = File::create(path)?;
+    let mut writer = BufWriter::new(file);
+    writer.write_all(bytes)?;
+    Ok(())
+}
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,7 @@ members = [`
`8`	`8`	`"bin/afs",`
`9`	`9`	`"logical-interface",`
`10`	`10`	`"vm",`
	`11`	`+ "vm/bin",`
`11`	`12`	`]`
`12`	`13`	`resolver = "2"`
`13`	`14`