ed255/pod2
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

chore: minor error handling improvements (#325)

Browse source 
* Minor error handling improvements

* Fix error
This commit is contained in:
Ahmad Afuni 2025-07-05 20:06:44 +10:00 • committed by GitHub
parent 901ba6442c
commit 2c41a6c554
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
7 changed files with 62 additions and 58 deletions
Download patch file Download diff file Expand all files Collapse all files

9
src/backends/plonky2/mock/mainpod.rs
View file

@ -312,12 +312,11 @@ impl Pod for MockMainPod {
.deref(
&self.statements[..input_statement_offset + i],
&self.merkle_proofs_containers,
)
.unwrap()
.check_and_log(&self.params, &s.clone().try_into().unwrap())
)?
.check_and_log(&self.params, &s.clone().try_into()?)
.map_err(|e| e.into())
})
.collect::<Result<Vec<_>, middleware::Error>>()
.unwrap();
.collect::<Result<Vec<_>>>()?;
if !statement_check.iter().all(|b| *b) {
return Err(Error::statement_not_check());
}

12
src/backends/plonky2/primitives/ec/curve.rs
View file

@ -316,8 +316,10 @@ pub(super) fn add_homog_offset<const D: usize, F: ECFieldExt<D>>(
}
const GROUP_ORDER_STR: &str = "1067993516717146951041484916571792702745057740581727230159139685185762082554198619328292418486241";
pub static GROUP_ORDER: LazyLock<BigUint> =
LazyLock::new(|| BigUint::from_str_radix(GROUP_ORDER_STR, 10).unwrap());
pub static GROUP_ORDER: LazyLock<BigUint> = LazyLock::new(|| {
BigUint::from_str_radix(GROUP_ORDER_STR, 10)
.expect("The input should be a valid decimal string.")
});
static FIELD_NUM_SQUARES: LazyLock<BigUint> =
LazyLock::new(|| (ECField::order() - BigUint::one()) >> 1);
@ -605,10 +607,8 @@ impl CircuitBuilderElliptic for CircuitBuilder<GoldilocksField, 2> {
let outputs = ECAddHomogOffset::apply(self, &inputs);
// plonky2 expects all gate constraints to be satisfied by the zero vector.
// So our elliptic curve addition gate computes [x,z-b,u,t-b], and we have to add the b here.
let x = FieldTarget::new(outputs[0..5].try_into().unwrap());
let z = FieldTarget::new(outputs[5..10].try_into().unwrap());
let u = FieldTarget::new(outputs[10..15].try_into().unwrap());
let t = FieldTarget::new(outputs[15..20].try_into().unwrap());
let [x, z, u, t] =
array::from_fn(|j| FieldTarget::new(array::from_fn(|i| outputs[5 * j + i])));
let b1 = self.constant(Point::B1);
let z = self.nnf_add_scalar_times_generator_power(b1, 1, &z);
let t = self.nnf_add_scalar_times_generator_power(b1, 1, &t);

4
src/backends/plonky2/primitives/ec/field.rs
View file

@ -1,4 +1,4 @@
use std::marker::PhantomData;
use std::{array, marker::PhantomData};
use num::BigUint;
use plonky2::{
@ -217,7 +217,7 @@ impl<const DEG: usize, NNF: OEF<DEG> + FieldExtension<DEG, BaseField = F>>
inputs.extend_from_slice(&x.components);
inputs.extend_from_slice(&y.components);
let outputs = NNFMulSimple::<DEG, NNF>::apply(self, &inputs);
OEFTarget::new(outputs.try_into().unwrap())
OEFTarget::new(array::from_fn(|i| outputs[i]))
}
fn nnf_div(&mut self, x: &OEFTarget<DEG, NNF>, y: &OEFTarget<DEG, NNF>) -> OEFTarget<DEG, NNF> {
let one = self.nnf_one();

8
src/backends/plonky2/primitives/ec/gates/curve.rs
View file

@ -1,3 +1,5 @@
use std::array;
use plonky2::field::goldilocks_field::GoldilocksField;
use crate::backends::plonky2::primitives::ec::{
@ -39,10 +41,8 @@ impl SimpleGate for ECAddHomogOffset {
Self::F: plonky2::field::extension::Extendable<D>,
{
let mut ans = Vec::with_capacity(20);
let x1 = QuinticTensor::from_base(wires[0..5].try_into().unwrap());
let u1 = QuinticTensor::from_base(wires[5..10].try_into().unwrap());
let x2 = QuinticTensor::from_base(wires[10..15].try_into().unwrap());
let u2 = QuinticTensor::from_base(wires[15..20].try_into().unwrap());
let [x1, u1, x2, u2] =
array::from_fn(|j| QuinticTensor::from_base(array::from_fn(|i| wires[5 * j + i])));
let out = add_homog_offset(x1, u1, x2, u2);
for v in out {
ans.extend(v.to_base());

4
src/backends/plonky2/primitives/merkletree/mod.rs
View file

@ -528,7 +528,7 @@ impl Intermediate {
h
}
fn hash(&self) -> Hash {
self.hash.unwrap()
self.hash.expect("Hash has not been computed.")
}
}
@ -554,7 +554,7 @@ impl Leaf {
h
}
fn hash(&self) -> Hash {
self.hash.unwrap()
self.hash.expect("Hash has not been computed.")
}
}

36
src/frontend/custom.rs
View file

@ -178,23 +178,25 @@ impl CustomPredicateBatchBuilder {
let args = stb
.args
.iter()
.map(|a| match a {
BuilderArg::Literal(v) => StatementTmplArg::Literal(v.clone()),
BuilderArg::Key(pod_id_wc, key_str) => StatementTmplArg::AnchoredKey(
resolve_wildcard(args, priv_args, pod_id_wc),
Key::from(key_str),
),
BuilderArg::WildcardLiteral(v) => {
StatementTmplArg::Wildcard(resolve_wildcard(args, priv_args, v))
}
.map(|a| {
Ok::<_, Error>(match a {
BuilderArg::Literal(v) => StatementTmplArg::Literal(v.clone()),
BuilderArg::Key(pod_id_wc, key_str) => StatementTmplArg::AnchoredKey(
resolve_wildcard(args, priv_args, pod_id_wc)?,
Key::from(key_str),
),
BuilderArg::WildcardLiteral(v) => {
StatementTmplArg::Wildcard(resolve_wildcard(args, priv_args, v)?)
}
})
})
.collect();
StatementTmpl {
.collect::<Result<_>>()?;
Ok(StatementTmpl {
pred: stb.predicate.clone(),
args,
}
})
})
.collect();
.collect::<Result<_>>()?;
let custom_predicate = CustomPredicate::new(
&self.params,
name.into(),
@ -215,12 +217,16 @@ impl CustomPredicateBatchBuilder {
}
}
fn resolve_wildcard(args: &[&str], priv_args: &[&str], s: &str) -> Wildcard {
fn resolve_wildcard(args: &[&str], priv_args: &[&str], s: &str) -> Result<Wildcard> {
args.iter()
.chain(priv_args.iter())
.enumerate()
.find_map(|(i, name)| (s == *name).then_some(Wildcard::new(s.to_string(), i)))
.unwrap()
.ok_or(Error::custom(format!(
"Wildcard {} not amongst args {:?}",
s,
[args.to_vec(), priv_args.to_vec()].concat()
)))
}
#[cfg(test)]

47
src/frontend/mod.rs
View file

@ -200,45 +200,44 @@ impl MainPodBuilder {
/// - {Dict,Array,Set}Contains/NotContains becomes Contains/NotContains.
/// - GtEqFromEntries/GtFromEntries/GtToNotEqual becomes
/// LtEqFromEntries/LtFromEntries/LtToNotEqual.
fn lower_op(op: Operation) -> Operation {
fn lower_op(op: Operation) -> Result<Operation> {
use NativeOperation::*;
use OperationType::*;
let op_type = op.0.clone();
match op.0 {
Native(DictContainsFromEntries) => {
let [dict, key, value] = op.1.try_into().unwrap(); // TODO: Error handling
Native(DictContainsFromEntries) => <[_; 3]>::try_from(op.1).map(|[dict, key, value]| {
Operation(Native(ContainsFromEntries), vec![dict, key, value], op.2)
}
Native(DictNotContainsFromEntries) => {
let [dict, key] = op.1.try_into().unwrap(); // TODO: Error handling
}),
Native(DictNotContainsFromEntries) => <[_; 2]>::try_from(op.1).map(|[dict, key]| {
Operation(Native(NotContainsFromEntries), vec![dict, key], op.2)
}
Native(SetContainsFromEntries) => {
let [set, value] = op.1.try_into().unwrap(); // TODO: Error handling
}),
Native(SetContainsFromEntries) => <[_; 2]>::try_from(op.1).map(|[set, value]| {
Operation(
Native(ContainsFromEntries),
vec![set, value.clone(), value],
op.2,
)
}
Native(SetNotContainsFromEntries) => {
let [set, value] = op.1.try_into().unwrap(); // TODO: Error handling
}),
Native(SetNotContainsFromEntries) => <[_; 2]>::try_from(op.1).map(|[set, value]| {
Operation(Native(NotContainsFromEntries), vec![set, value], op.2)
}
}),
Native(ArrayContainsFromEntries) => {
let [array, index, value] = op.1.try_into().unwrap(); // TODO: Error handling
Operation(Native(ContainsFromEntries), vec![array, index, value], op.2)
<[_; 3]>::try_from(op.1).map(|[array, index, value]| {
Operation(Native(ContainsFromEntries), vec![array, index, value], op.2)
})
}
Native(GtEqFromEntries) => {
let [entry1, entry2] = op.1.try_into().unwrap(); // TODO: Error handling
Native(GtEqFromEntries) => <[_; 2]>::try_from(op.1).map(|[entry1, entry2]| {
Operation(Native(LtEqFromEntries), vec![entry2, entry1], op.2)
}
Native(GtFromEntries) => {
let [entry1, entry2] = op.1.try_into().unwrap(); // TODO: Error handling
}),
Native(GtFromEntries) => <[_; 2]>::try_from(op.1).map(|[entry1, entry2]| {
Operation(Native(LtFromEntries), vec![entry2, entry1], op.2)
}
Native(GtToNotEqual) => Operation(Native(LtToNotEqual), op.1, op.2),
_ => op,
}),
Native(GtToNotEqual) => Ok(Operation(Native(LtToNotEqual), op.1, op.2)),
_ => Ok(op),
}
.map_err(|_| {
Error::op_invalid_args(format!("Invalid arg count in operation {:?}", op_type))
})
}
/// Fills in auxiliary data if necessary/possible.
@ -494,7 +493,7 @@ impl MainPodBuilder {
}
fn op(&mut self, public: bool, op: Operation) -> Result<Statement> {
let op = Self::fill_in_aux(Self::lower_op(op))?;
let op = Self::fill_in_aux(Self::lower_op(op)?)?;
let st = self.op_statement(op.clone())?;
self.insert(public, (st, op));