Skip to content

test: show that an SDK can verify it's own proofs using verify-stark #2829

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
nyunyunyunyu wants to merge 1 commit into
base: develop-v2.0.0-rc.2
Choose a base branch
from
+89 −33
Open

test: show that an SDK can verify it's own proofs using verify-stark #2829

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
122 changes: 89 additions & 33 deletions crates/sdk/src/tests.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -8,8 +8,8 @@ use openvm_deferral_circuit::DeferralFn;
use openvm_stark_backend::{codec::Encode, StarkEngine, SystemParams};
use openvm_stark_sdk::{
config::{
app_params_with_100_bits_security, hook_params_with_100_bits_security,
internal_params_with_100_bits_security,
app_params_with_100_bits_security, baby_bear_poseidon2::Digest,
hook_params_with_100_bits_security, internal_params_with_100_bits_security,
},
utils::setup_tracing,
};
Expand Down Expand Up @@ -65,7 +65,11 @@ fn generate_fib_vm_stark_proof(fib_sdk: &Sdk) -> Result<(VmStarkProof, Verificat
}

/// Builds a DeferralProver from a base SDK.
fn make_deferral_prover(sdk: &Sdk, agg_params: &AggregationSystemParams) -> DeferralProver {
fn make_deferral_prover(
sdk: &Sdk,
agg_params: &AggregationSystemParams,
child_def_hook_commit: Option<Digest>,
) -> DeferralProver {
let agg_prover = sdk.agg_prover();
let ir_vk = agg_prover.internal_recursive_prover.get_vk();
let ir_pcs_data = agg_prover
Expand All @@ -82,7 +86,7 @@ fn make_deferral_prover(sdk: &Sdk, agg_params: &AggregationSystemParams) -> Defe
def_circuit_params,
memory_dimensions,
num_user_pvs,
None,
child_def_hook_commit,
0,
);
let verify_stark_prover = VerifyCircuitProver::new(deferred_verify_prover);
Expand All @@ -96,11 +100,12 @@ fn make_deferral_prover(sdk: &Sdk, agg_params: &AggregationSystemParams) -> Defe
/// Builds a deferral-enabled riscv32 SDK whose App VM inventory includes the
/// deferral periphery chips (DeferralPoseidon2Chip, count chip, etc.).
fn make_deferral_enabled_sdk(
fib_sdk: &Sdk,
base_sdk: &Sdk,
app_params: SystemParams,
agg_params: AggregationSystemParams,
child_def_hook_commit: Option<Digest>,
) -> Result<Sdk> {
let deferral_prover = make_deferral_prover(fib_sdk, &agg_params);
let deferral_prover = make_deferral_prover(base_sdk, &agg_params, child_def_hook_commit);
let deferral_ext =
deferral_prover.make_extension(vec![Arc::new(DeferralFn::new(verify_stark_deferral_fn))]);

Expand All @@ -115,40 +120,47 @@ fn make_deferral_enabled_sdk(
.build()?)
}

/// Builds a deferral-enabled verify-stark SDK from a fibonacci SDK and proof.
///
/// Returns the SDK, the verify-stark stdin, and the deferral input.
fn make_deferral_sdk(
fib_sdk: &Sdk,
fib_proof: VmStarkProof,
fib_baseline: VerificationBaseline,
app_params: SystemParams,
agg_params: AggregationSystemParams,
) -> Result<(Sdk, StdIn, DeferralInput)> {
let fib_vk = VmStarkVerifyingKey {
mvk: fib_sdk.agg_vk().as_ref().clone(),
baseline: fib_baseline,
fn make_verify_stark_inputs(
child_sdk: &Sdk,
child_proof: &VmStarkProof,
child_baseline: VerificationBaseline,
) -> Result<(StdIn, DeferralInput)> {
let child_vk = VmStarkVerifyingKey {
mvk: child_sdk.agg_vk().as_ref().clone(),
baseline: child_baseline,
};

let raw_results = get_raw_deferral_results(&fib_vk, from_ref(&fib_proof))?;
let raw_results = get_raw_deferral_results(&child_vk, from_ref(child_proof))?;
assert_eq!(raw_results.len(), 1);
let input_commit: [u8; 32] = raw_results[0].input.clone().try_into().unwrap();
let output_raw = &raw_results[0].output_raw;
let app_exe_commit: [u8; 32] = output_raw[..32].try_into().unwrap();
let app_vm_commit: [u8; 32] = output_raw[32..64].try_into().unwrap();
let user_public_values = output_raw[64..].to_vec();
let deferral_state = get_deferral_state(&fib_vk, from_ref(&fib_proof), 0)?;
let deferral_state = get_deferral_state(&child_vk, from_ref(child_proof), 0)?;

let vs_sdk = make_deferral_enabled_sdk(fib_sdk, app_params, agg_params)?;
let mut stdin = StdIn::default();
stdin.write(&app_exe_commit);
stdin.write(&app_vm_commit);
stdin.write(&user_public_values);
stdin.write(&input_commit);
stdin.deferrals = vec![deferral_state];

let mut vs_stdin = StdIn::default();
vs_stdin.write(&app_exe_commit);
vs_stdin.write(&app_vm_commit);
vs_stdin.write(&user_public_values);
vs_stdin.write(&input_commit);
vs_stdin.deferrals = vec![deferral_state];
Ok((stdin, DeferralInput::from_inputs(from_ref(child_proof))))
}

let def_input = DeferralInput::from_inputs(&[fib_proof]);
/// Builds a deferral-enabled verify-stark SDK from a fibonacci SDK and proof.
///
/// Returns the SDK, the verify-stark stdin, and the deferral input.
fn make_deferral_sdk(
fib_sdk: &Sdk,
fib_proof: VmStarkProof,
fib_baseline: VerificationBaseline,
app_params: SystemParams,
agg_params: AggregationSystemParams,
) -> Result<(Sdk, StdIn, DeferralInput)> {
let (vs_stdin, def_input) = make_verify_stark_inputs(fib_sdk, &fib_proof, fib_baseline)?;
let vs_sdk = make_deferral_enabled_sdk(fib_sdk, app_params, agg_params, None)?;

Ok((vs_sdk, vs_stdin, def_input))
}
Expand Down Expand Up @@ -215,16 +227,21 @@ fn test_verify_stark_with_deferral_child() -> Result<()> {
setup_tracing();
let (fib_sdk, app_params, agg_params) = make_fib_sdk();
let (fib_proof, fib_baseline) = generate_fib_vm_stark_proof(&fib_sdk)?;
let (vs_sdk, vs_stdin, def_input) =
make_deferral_sdk(&fib_sdk, fib_proof, fib_baseline, app_params, agg_params)?;
let (vs_sdk, vs_stdin, def_input) = make_deferral_sdk(
&fib_sdk,
fib_proof,
fib_baseline,
app_params.clone(),
agg_params.clone(),
)?;

let vs_elf = Elf::decode(
include_bytes!("../programs/examples/verify-stark.elf"),
MEM_SIZE as u32,
)?;
let vs_exe = vs_sdk.convert_to_exe(vs_elf)?;

let (vs_proof, _) = vs_sdk.prove(vs_exe, vs_stdin, &[def_input])?;
let (vs_proof, vs_baseline) = vs_sdk.prove(vs_exe, vs_stdin, &[def_input])?;
assert!(
vs_proof.deferral_merkle_proofs.is_some(),
"deferral-enabled verify-stark child proof must carry deferral merkle proofs",
Expand Down Expand Up @@ -262,14 +279,53 @@ fn test_verify_stark_with_deferral_child() -> Result<()> {
let engine = E::new(vk.inner.params.clone());
engine.verify(&vk, &nested_def_proof)?;

let (vs2_stdin, vs2_def_input) = make_verify_stark_inputs(&vs_sdk, &vs_proof, vs_baseline)?;
let vs2_sdk = make_deferral_enabled_sdk(
&vs_sdk,
app_params,
agg_params,
Some(expected_def_hook_commit),
)?;
let vs2_agg_prover = vs2_sdk.agg_prover();
assert_eq!(
vs_agg_prover.internal_recursive_prover.get_vk_commit(true),
vs2_agg_prover.internal_recursive_prover.get_vk_commit(true)
);
assert_eq!(vs2_sdk.def_hook_commit(), Some(expected_def_hook_commit));

let vs2_elf = Elf::decode(
include_bytes!("../programs/examples/verify-stark.elf"),
MEM_SIZE as u32,
)?;
let vs2_exe = vs2_sdk.convert_to_exe(vs2_elf)?;
let (vs2_proof, vs2_baseline) = vs2_sdk.prove(vs2_exe, vs2_stdin, &[vs2_def_input])?;
assert!(
vs2_proof.deferral_merkle_proofs.is_some(),
"fixed-point verify-stark SDK proof must carry deferral merkle proofs",
);

let (vs2_again_stdin, vs2_again_def_input) =
make_verify_stark_inputs(&vs2_sdk, &vs2_proof, vs2_baseline)?;
let vs2_again_elf = Elf::decode(
include_bytes!("../programs/examples/verify-stark.elf"),
MEM_SIZE as u32,
)?;
let vs2_again_exe = vs2_sdk.convert_to_exe(vs2_again_elf)?;
let (vs2_again_proof, _) =
vs2_sdk.prove(vs2_again_exe, vs2_again_stdin, &[vs2_again_def_input])?;
assert!(
vs2_again_proof.deferral_merkle_proofs.is_some(),
"fixed-point verify-stark SDK must accept its own prior proof as a deferral input",
);

Ok(())
}

#[test]
fn test_deferrals_enabled_without_usage() -> Result<()> {
setup_tracing();
let (fib_sdk, app_params, agg_params) = make_fib_sdk();
let sdk = make_deferral_enabled_sdk(&fib_sdk, app_params, agg_params)?;
let sdk = make_deferral_enabled_sdk(&fib_sdk, app_params, agg_params, None)?;

let elf = Elf::decode(
include_bytes!("../programs/examples/fibonacci.elf"),
Expand Down
Loading