Initial commit

Cargo.toml

@@ -0,0 +1,5 @@
+[workspace]
+
+members = [
+    "parser",
+]

README.md

@@ -0,0 +1,82 @@
+# Usage
+
+```bash
+source ~/cairo_venv/bin/activate
+
+
+# generate proof
+cairo-run --program_input ./parser/test/bootloader_inputs.json \
+    --program ./parser/test/bootloader_compiled.json \
+    --air_private_input ./parser/test/air-private-input.json \
+    --air_public_input ./parser/test/air-public-input.json \
+    --trace_file ./parser/test/trace.bin \
+    --memory_file ./parser/test/memory.bin \
+    --layout recursive \
+    --min_steps 128 \
+    --proof_mode \
+    --print_info
+(cd ../sandstorm-mirror && cargo +nightly build -r -F parallel,asm) && ../sandstorm-mirror/target/release/sandstorm --program ./parser/test/bootloader_compiled.json \
+    --air-public-input ./parser/test/air-public-input.json \
+    prove --air-private-input ./parser/test/air-private-input.json \
+          --output ./parser/test/bootloader-proof.bin
+
+# generate recursive proof
+cairo-compile cairo/test_recurse.cairo --proof_mode --output cairo/test_recurse.json
+cairo-run --layout recursive \
+    --program cairo/test_recurse.json \
+    --trace_file cairo/trace.bin \
+    --memory_file cairo/memory.bin \
+    --min_steps 128 \
+    --proof_mode \
+    --print_info
+(cd ../sandstorm-mirror && cargo +nightly build -r -F parallel,asm) && ../sandstorm-mirror/target/release/sandstorm --program ./cairo/test_recurse.json \
+    --air-public-input ./cairo/air-public-input.json \
+    prove --air-private-input ./cairo/air-private-input.json \
+          --output ./recursive-proof.bin
+```
+
+
+
+# Test cairo verifier
+
+```bash
+source ~/cairo_venv/bin/activate
+cd parser
+cargo +nightly run
+cd ..
+cairo-compile cairo/test_recurse.cairo --proof_mode --output cairo/test_recurse.json
+cairo-run --layout starknet --program cairo/test_recurse.json --trace_file cairo/trace.bin --memory_file cairo/memory.bin --min_steps 128 --proof_mode
+```
+
+# Generate proof
+
+```bash
+cairo-run --program_input ./parser/test/bootloader_inputs.json --program ./parser/test/bootloader_compiled.json --air_private_input ./parser/test/air-private-input.json --air_public_input ./parser/test/air-public-input.json --trace_file ./parser/test/trace.bin --memory_file ./parser/test/memory.bin --layout recursive --min_steps 128 --proof_mode --print_info
+
+(cd ../sandstorm-mirror && cargo +nightly build -r -F parallel,asm) && ../sandstorm-mirror/target/release/sandstorm --program ./parser/test/bootloader_compiled.json \
+    --air-public-input ./parser/test/air-public-input.json \
+    prove --air-private-input ./parser/test/air-private-input.json \
+          --output ./parser/test/bootloader-proof.bin
+
+
+cairo-run --layout recursive --program cairo/test_recurse.json --air_private_input ./cairo/air-private-input.json --air_public_input ./cairo/air-public-input.json --trace_file cairo/trace.bin --memory_file cairo/memory.bin --min_steps 128 --proof_mode  --print_info
+```
+
+
+
+
+
+
+```
+cairo-compile cairo/test_recurse.cairo \
+    --proof_mode \
+    --output cairo/test_recurse.json \
+    --cairo_path ../cairo-lang-parser/src
+
+cairo-run --layout starknet 
+    --program cairo/test_recurse.json 
+    --trace_file cairo/trace.bin 
+    --memory_file cairo/memory.bin 
+    --min_steps 128 
+    --proof_mode
+```

cairo/ministark.cairo

@@ -0,0 +1,126 @@
+
+%builtins range_check
+
+from starkware.cairo.common.alloc import alloc
+
+from starkware.cairo.common.bool import FALSE
+from starkware.cairo.common.math import assert_le
+from starkware.cairo.common.math_cmp import is_le
+
+struct Vec {
+    n_elements: felt,
+    elements: felt*,
+}
+
+struct CubicFelt {
+    c0: felt,
+    c1: felt,
+    c2: felt,
+}
+
+struct CubicVec {
+    n_elements: felt,
+    elements: CubicFelt*,
+}
+
+struct Digest {
+    element_0: felt,
+    element_1: felt,
+    element_2: felt,
+    element_3: felt,
+    element_4: felt,
+    element_5: felt,
+    element_6: felt,
+    element_7: felt,
+}
+
+struct ProofOptions {
+    num_queries: felt,
+    lde_blowup_factor: felt,
+    grinding_factor: felt,
+    fri_folding_factor: felt,
+    fri_max_remainder_size: felt,
+}
+
+struct MerkleProofs {
+    n_proofs: felt,
+    n_digests: felt, // number of digests per proof
+    digests: Digest*,
+}
+
+struct FriProofLayer {
+    values: Vec,
+    proofs: MerkleProofs,
+    commitment: Digest,
+}
+
+struct FriProof {
+    layers: FriProofLayer*,
+    remainder: Vec,
+    remainder_commitment: Digest,
+}
+
+struct Queries {
+    base_trace_values: Vec, // Fp
+    extension_trace_values: CubicVec, // Fq
+    composition_trace_values: CubicVec, // Fq
+    base_trace_proofs: MerkleProofs,
+    extension_trace_proofs: MerkleProofs,
+    composition_trace_proofs: MerkleProofs,
+}
+
+struct PublicMemory {
+    length: felt,
+    memory: felt*, // (usize + 1, Fp)
+}
+
+// ExecutionInfo
+struct PublicInputs {
+    initial_ap: felt,
+    initial_pc: felt,
+    final_ap: felt,
+    final_pc: felt,
+    range_check_min: felt,
+    range_check_max: felt,
+    public_memory: PublicMemory,
+    public_memory_padding_address: felt,
+    public_memory_padding_value: felt,
+}
+
+struct Proof {
+    options: ProofOptions,
+    trace_len: felt,
+    base_trace_commitment: Digest,
+    extension_trace_commitment: Digest, // optional
+    composition_trace_commitment: Digest,
+    fri_proof: FriProof,
+    pow_nonce: felt,
+    trace_queries: Queries,
+    public_inputs: PublicInputs,
+    execution_trace_ood_evals: CubicVec, // Fq
+    composition_trace_ood_evals: CubicVec, // Fq
+}
+
+func num_fri_layers{range_check_ptr}(proof_options: ProofOptions, domain_size) -> felt {
+    assert_le(proof_options.fri_folding_factor, proof_options.fri_max_remainder_size);
+    return __num_fri_layers(domain_size, proof_options.fri_folding_factor, proof_options.fri_max_remainder_size, 0);
+}
+
+func __num_fri_layers{range_check_ptr}(domain_size, folding_factor, max_remainder_size, num_layers) -> felt {
+    let is_domain_size_too_small = is_le(domain_size, max_remainder_size);
+    if (is_domain_size_too_small != FALSE) {
+        return num_layers;
+    }
+    assert_le(domain_size / folding_factor, domain_size - 1);
+    return __num_fri_layers(domain_size / folding_factor, folding_factor, max_remainder_size, num_layers + 1);
+}
+
+func remainder_size{range_check_ptr}(proof_options: ProofOptions, domain_size) -> felt {
+    assert_le(proof_options.fri_folding_factor, proof_options.fri_max_remainder_size);
+    let is_domain_size_too_small = is_le(domain_size, proof_options.fri_max_remainder_size);
+    if (is_domain_size_too_small != FALSE) {
+        return domain_size;
+    }
+    assert_le(domain_size / proof_options.fri_folding_factor, domain_size - 1);
+    return remainder_size(proof_options, domain_size / proof_options.fri_folding_factor);
+}

cairo/test_recurse.cairo

@@ -0,0 +1,47 @@
+%builtins pedersen range_check bitwise
+
+// from starkware.cairo.cairo_verifier.objects import CairoVerifierOutput
+from starkware.cairo.common.alloc import alloc
+from starkware.cairo.common.cairo_builtins import BitwiseBuiltin, HashBuiltin
+from starkware.cairo.stark_verifier.air.layouts.starknet.verify import verify_proof
+from starkware.cairo.stark_verifier.core.stark import StarkProof
+
+// source ~/cairo_venv/bin/activate
+// cairo-compile cairo/test_recurse.cairo --proof_mode --output cairo/test_recurse.json
+// cairo-run --layout starknet --program cairo/test_recurse.json --trace_file cairo/trace.bin --memory_file cairo/memory.bin --min_steps 128 --proof_mode
+
+const SECURITY_BITS = 18;
+
+// Main function for the Cairo verifier.
+//
+// Hint arguments:
+// program_input - Contains the inputs for the Cairo verifier.
+//
+// Outputs the program hash and the hash of the output.
+func main{pedersen_ptr: HashBuiltin*, range_check_ptr, bitwise_ptr: BitwiseBuiltin*}() {
+    alloc_locals;
+
+    let proof_mem: StarkProof* = alloc();
+    local proof: StarkProof* = proof_mem;
+    %{
+        import json
+        import subprocess
+
+        # ministark_parser = subprocess.run(["parser/target/debug/sandstorm_parser", "example/test_parser.proof", 'proof'], capture_output=True)
+        # ministark = ministark_parser.stdout
+        # ministark_json = json.loads(ministark)
+        ministark_file = open("parser/output.json")
+        ministark_json = json.load(ministark_file)
+        ministark_file.close()
+
+        # Note the following:
+        # - Addresses are stored as `Relocatable` values in the Cairo VM.
+        # - The "+" operator is overloaded to perform pointer arithmetics.
+        # - Felts are hex encoded starting with "0x". The virtual addresses are encoded as decimals.
+        segments.write_arg(ids.proof.address_, [(int(x, 16) if x.startswith('0x') else ids.proof.address_ + int(x)) for x in ministark_json])
+    %}
+
+    verify_proof(proof=proof, security_bits=SECURITY_BITS);
+
+    return ();
+}

parser/Cargo.toml

@@ -0,0 +1,29 @@
+[package]
+name = "sandstorm_parser"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+sandstorm-binary = { path = "../../sandstorm-mirror/binary" }
+sandstorm-layouts = { path = "../../sandstorm-mirror/layouts" }
+sandstorm-crypto = { path = "../../sandstorm-mirror/crypto" }
+sandstorm = { path = "../../sandstorm-mirror" }
+ministark-gpu = { version = "0.1", path = "../../ministark-mirror/gpu" }
+ministark = { path = "../../ministark-mirror" }
+ark-poly = { git = "https://github.com/andrewmilson/algebra", branch = "vec-allocator" }
+ark-std = "0.4"
+ark-ff = "0.4"
+ark-serialize = "0.4"
+structopt = "0.3"
+serde_json = "1.0"
+num-traits = "0.2"
+pollster = "0.2"
+num-bigint = { version = "0.4" }
+rayon = { version = "1.5", optional = true }
+serde = { version = "1.0.136", features = ["derive"] }
+clap = { version = "4.0.18", features = ["derive"] }
+sha2 = "0.10"
+ruint = { version = "1.7", features = [ "serde", "num-bigint" ] }
+sha3 = "0.10"
+blake2 = "0.10"
+digest = "0.10"