) -> Result<Vec<Fr>> {
pub labeling_proofs: Vec<(usize, LabelingProof)>,
self,
for parent in drg_parents.into_iter() {
params: &<Bls12 as JubjubEngine>::Params,
pub fn synthesize<CS: ConstraintSystem<Bls12>>(
今朝PoRCompound，只把Merkle树的路径信息作为果真输入。
整个PoREP的电路的果真输入由StackedCompound的generate_public_inputs函数实现，详细实此刻storage-proofs/src/porep/stacked/circuit/proof.rs文件中。
大抵的逻辑是，先处理惩罚挑战节点的Column信息，再别离处理惩罚base和exp依赖节点的Column信息：
comm_r_last: Option<H::Domain>,
fn generate_public_inputs(
num::AllocatedNum::alloc(cs.namespace(|| format!(“label_node_{}”, layer)), || {
StackedCircuit就是PoREP的整体电路。StackedCircuit界说在storage-proofs/src/porep/stacked/circuit/proof.rs中。
cs.namespace(|| format!(“encoding_proof_{}”, layers)),
pub comm_r_last_proof: InclusionPath<Bls12, H, typenum::U8>,
inputs.extend(PoRCompound::<H, typenum::U2>::generate_public_inputs(
)?;
从StackedCircuit讲起。
) -> Result<(), SynthesisError> {
cs.namespace(|| “column_proof_all_inclusion”),
public_params.layer_challenges.layers(),
&comm_d_num,
pub struct Proof<H: Hasher, G: Hasher> {
let leaf_num = inclusion_path.alloc_value(cs.namespace(|| “leaf”))?;
7. Column hash证明电路
comm_d_proof.synthesize(
leaf: num::AllocatedNum<Bls12>,
Proof的synthesize函数构建如上的证明。
labeling_proofs – Labeling计较证明
// drg parents
inputs.extend(generate_inclusion_inputs(challenge)?);
雷同于原始数据的Merkle树证明电路证明，证明comm_r_last_data_leaf在comm_r_last的Merkle树上。只是这棵树是八叉树。
commit 14870d715f1f6019aba3f72772659e38184378bf
encoding_proof.synthesize(
comm_r_last_proof – Encoding功效的Merkle树证明
整个PoREP电路的代码框架如下图所示：
5. Encoding证明电路pub_params: &<StackedDrg<H, G> as ProofScheme>::PublicParams,
&por_params,
&self.params,
Encoding计较就是将最后一层的节点数据和原始数据举办Encoding。Encoding的计较方法就是大数加法，详细的计较storage-proofs/src/gadgets/encode.rs文件中。
params,
总结：
for (i, parent) in drg_parents.into_iter().enumerate() {
self,
&comm_r_last_num,
root: num::AllocatedNum<Bls12>,
// c_x
let value = Root::from_allocated::<CS>(leaf);
Labeling计较的证明电路就是证明某个节点凭据SDR算法正确计较。
public_params: <StackedDrg<‘a, H, G> as ProofScheme<‘a>>::PublicParams,
parent.synthesize(cs.namespace(|| format!(“drg_parent_{}”, i)), params, comm_c)?;
comm_r: Option<H::Domain>,
个中comm_d_leaf是电路中的变量。comm_d_proof是InclusionPath布局，界说在storage-proofs/src/porep/stacked/circuit/params.rs中。InclusionPath电路的焦点逻辑在synthesize函数中：
&comm_d_leaf,
)?;
inclusion_path: InclusionPath<Bls12, H, typenum::U8>,
cs: CS,
.ok_or_else(|| SynthesisError::AssignmentMissing)
let comm_d = pub_in.tau.as_ref().expect(“missing tau”).comm_d;
replica_id,
Sector巨细为32G的环境下，挑战个数为144个。也就是说，整个挑战节点证明电路由144个小电路构成。
Author: Rod Vagg <[email protected]>
params,
)?;
也就是说，证明电路由15个ColumnProof子电路构成。ColumnProof界说在storage-proofs/src/porep/stacked/circuit/column_proof.rs中。
proof.synthesize(
inputs.extend(generate_inclusion_inputs(challenge)?);
cs.namespace(|| format!(“labeling_proof_{}”, layer)),
Proof的布局较量清晰，别离包罗了：
// drg parents
&labeled_node,
k,
inclusion_path.synthesize(
}
graph.expanded_parents(challenge, &mut exp_parents);
replica_id – Sector复制id
整个电路的搭建，从StackedCircuit的synthesize接口函数开始。
params,
Column hash的证明电路是由ReplicaColumnProof布局的synthesize实现，详细界说在storage-proofs/src/porep/stacked/circuit/params.rs中。
}
let raw = replica_column_proof.c_x.get_node_at_layer(layer);
column.hash计较出Column对应的hash功效。查抄这个功效是否与leaf_num相等。同时查察这个leaf_num是否在comm_c的Merkle树上。
&replica_id_bits,
comm_c.clone(),
replica_id,
params – JubjubEngine的相关参数，
exp_encoded_node: &num::AllocatedNum<Bls12>,
k: Option<usize>,
}
fn synthesize<CS: ConstraintSystem<Bls12>>(self, cs: &mut CS) -> Result<(), SynthesisError> {
let InclusionPath { auth_path, .. } = self;
let root = Root::from_allocated::<CS>(root);
let c_i = column.hash(cs.namespace(|| “column_hash”), params)?;
leaf_num,
3. 原始数据的Merkle树证明电路
inputs.extend(generate_inclusion_inputs(parent as usize)?);
个中
let labeled_node =
proofs: Vec<Proof<H, G>>,
let comm_r = pub_in.tau.as_ref().expect(“missing tau”).comm_r;
}
pub struct ColumnProof<H: Hasher> {
原始数据的Merkle树证明电路证明comm_d_leaf的节点，在以comm_d为树根的Merkle树上。
pub_in: &<StackedDrg<H, G> as ProofScheme>::PublicInputs,
// TODO: currently allocating the leaf twice, inclusion path should take the already allocated leaf.
encoding_proof – Encoding的功效证明
for (i, proof) in proofs.into_iter().enumerate() {
挑战对应的一系列comm_c的存在性证明
comm_r_last_proof.synthesize(
Ok(())
let mut drg_parents = vec![0; graph.base_graph().degree()];
replica_id: &[Boolean],
let key = Self::create_label(
impl<‘a, H: Hasher, G: Hasher> Circuit<Bls12> for StackedCircuit<‘a, Bls12, H, G> {
// exp parents
// exp parents
2. 挑战节点证明电路
let LabelingProof { node, parents } = self;
graph.base_graph().parents(challenge, &mut drg_parents)?;
column: Column,
PoREP电路相关的逻辑在storage-proofs/src/porep/stacked/circuit/目次中。Rust-fil-proofs代码更新较量快，本文顶用的代码的最后一个commit信息如下：
}
comm_r – comm_r_last和comm_c的hash功效
comm_r_last.clone(),
可以发明，所有证明Retrieval的电路，都是通过PoRCircuit实现。也就是说，今朝的PoR是通过Merkle树实现的。PoRCircuit电路界说在storage-proofs/src/gadgets/por.rs。PoRCircuit的电路就是团结叶子节点和路径信息，查察最后“计较”出来的树根和提供的树根是否一致。详细相关逻辑，，小同伴可以自行查察。
)?);
constraint::equal(&mut cs, || “enforce column_hash = leaf”, &c_i, &leaf_num);
}
comm_d.clone(),
cs.namespace(|| “comm_d_inclusion”),
params,
到今朝为止，整个电路的全貌已经呈现：
comm_r_last – encoding之后的数据的八叉树的树根
comm_d: Option<G::Domain>,
6. Encoding功效的Merkle树证明
comm_d & comm_r
replica_column_proof.synthesize(cs.namespace(|| “replica_column_proof”), params, comm_c)?;
})?;
)?;
comm_d_leaf.clone(),
挑战对应的comm_r_last的存在性证明
parents,
// c_x
}
)?;
comm_d – 原始数据的二叉树的树根
}
params,
comm_r_last_data_leaf,
cs.namespace(|| “comm_r_last_data_inclusion”),
个中k为parition的编号。对付32G的Sector，总共有9个Paritition。
pub fn synthesize<CS: ConstraintSystem<Bls12>>(
replica_id: Option<H::Domain>,
&mut cs.namespace(|| format!(“challenge_{}”, i)),
proof.synthesize(
4. Labeling计较证明
整个synthesize函数，将电路支解成两部门：1/ 树根校验电路 2/ 挑战的节点信息证明电路。个中树根校验电路较量简朴易懂。申请replica_id_bits， comm_d，comm_r，comm_r_last以及comm_c变量，并验证comm_c和comm_r_last是否可以正确计较出comm_r。
cs.namespace(|| “create_label”),
feat(filecoin-proofs): expose filecoin_proofs::pad_reader
public_params – StackedDrg（深度鲁棒图）相关的参数，包罗图自己的参数以及挑战的个数。
&pub_inputs,
replica_column_proof – column hash的计较证明
comm_c: Option<H::Domain>,
proofs – 挑战对应的证明电路
params,
for parent in exp_parents.into_iter() {
node,
for (i, parent) in exp_parents.into_iter().enumerate() {
inputs.extend(generate_inclusion_inputs(parent as usize)?);
}
for (layer, proof) in labeling_proofs.into_iter() {
constraint::equal(&mut cs, || “equality_key”, &exp_encoded_node, &key);
comm_d_proof – 原始数据的Merkle树证明
挑战对应comm_d的存在性证明
pub comm_d_proof: InclusionPath<Bls12, G, typenum::U2>,
整个Encoding证明电路由EncodingProof的synthesize函数实现。简朴的说，Encoding的电路验证进程首先计较Labeling，然后对comm_d_leaf举办Encoding计较，判定功效是否和comm_r_last_data_leaf一致。
每个挑战节点的小电路，由Proof布局暗示（storage-proofs/src/porep/stacked/circuit/params.rs）。
Date: Fri Mar 20 22:30:18 2020 +1100
let mut exp_parents = vec![0; graph.expansion_degree()];
}
c_x.synthesize(cs.namespace(|| “c_x”), params, comm_c)?;
pub struct StackedCircuit<‘a, E: JubjubEngine, H: ‘static + Hasher, G: ‘static + Hasher> {
&comm_c_num,
params: &<Bls12 as JubjubEngine>::Params,
mut cs: CS,
replica_id,
params: &’a E::Params,
1. StackedCircuit
&comm_r_last_data_leaf,
只要SDR算法稳定，大抵的电路逻辑不会有大的变革。对SDR算法不熟悉对小同伴，可以看看： raw.map(Into::into)
}
相应的电路生成逻辑在ColumnProof的synthesize函数中：
在某一层上的某个节点的Labeling的功效数据通过replica_column_proof.c_x.get_node_at_layer(layer)可以获取。Labeling的计较电路由LabelingProof布局的synthesize函数实现：
郑重声明：本文版权归原作者所有，转载文章仅为传播更多信息之目的，如作者信息标记有误，请第一时间联系我们修改或删除，多谢。
