qp-plonky2 1.4.1

Recursive SNARKs based on PLONK and FRI
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

//! FRI proof types.
//!
//! Re-exports base types from core and provides prover-specific Target types.

#[cfg(not(feature = "std"))]
use alloc::vec::Vec;

// Re-export all FRI proof types from core
pub use qp_plonky2_core::fri_proof::{
    combine_final_poly_chunks, eval_final_polys_at_point, CompressedFriProof,
    CompressedFriQueryRounds, FriBatchMaskProof, FriBatchMaskQuery, FriFinalPolys,
    FriInitialTreeProof, FriProof, FriQueryRound, FriQueryStep,
};
// Re-export FriChallenges from core
pub use qp_plonky2_core::FriChallenges;

use crate::gadgets::polynomial::PolynomialCoeffsExtTarget;
use crate::hash::hash_types::MerkleCapTarget;
use crate::hash::merkle_proofs::MerkleProofTarget;
use crate::iop::ext_target::ExtensionTarget;
use crate::iop::target::Target;
use crate::plonk::plonk_common::salt_size;

/// Target version of FriQueryStep for circuit building.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct FriQueryStepTarget<const D: usize> {
    pub evals: Vec<ExtensionTarget<D>>,
    pub merkle_proof: MerkleProofTarget,
}

/// Target version of FriInitialTreeProof for circuit building.
///
/// In PolyFri mode these leaves are the public logical openings that the verifier authenticates;
/// any prover-private split representation must be collapsed before it reaches this target.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct FriInitialTreeProofTarget {
    pub evals_proofs: Vec<(Vec<Target>, MerkleProofTarget)>,
}

impl FriInitialTreeProofTarget {
    pub(crate) fn unsalted_eval(
        &self,
        oracle_index: usize,
        poly_index: usize,
        salted: bool,
    ) -> Target {
        self.unsalted_evals(oracle_index, salted)[poly_index]
    }

    fn unsalted_evals(&self, oracle_index: usize, salted: bool) -> &[Target] {
        let evals = &self.evals_proofs[oracle_index].0;
        &evals[..evals.len() - salt_size(salted)]
    }
}

/// Target version of FriQueryRound for circuit building.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct FriQueryRoundTarget<const D: usize> {
    pub initial_trees_proof: FriInitialTreeProofTarget,
    pub steps: Vec<FriQueryStepTarget<D>>,
}

/// Target version of an authenticated batch-mask query opening.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct FriBatchMaskQueryTarget<const D: usize> {
    pub values: Vec<ExtensionTarget<D>>,
    pub merkle_proof: MerkleProofTarget,
}

/// Target version of the transcript-visible batch-mask proof.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct FriBatchMaskProofTarget<const D: usize> {
    pub cap: MerkleCapTarget,
    pub query_openings: Vec<FriBatchMaskQueryTarget<D>>,
}

/// Target version of the disclosed final polynomial chunks.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct FriFinalPolysTarget<const D: usize> {
    pub chunks: Vec<PolynomialCoeffsExtTarget<D>>,
}

/// Target version of FriProof for circuit building.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct FriProofTarget<const D: usize> {
    pub commit_phase_merkle_caps: Vec<MerkleCapTarget>,
    pub batch_mask_proof: Option<FriBatchMaskProofTarget<D>>,
    pub query_round_proofs: Vec<FriQueryRoundTarget<D>>,
    pub final_polys: FriFinalPolysTarget<D>,
    pub pow_witness: Target,
}

/// Target version of FriChallenges for circuit building.
#[derive(Debug)]
pub struct FriChallengesTarget<const D: usize> {
    pub fri_alpha: ExtensionTarget<D>,
    pub fri_betas: Vec<ExtensionTarget<D>>,
    pub fri_pow_response: Target,
    pub fri_query_indices: Vec<Target>,
}