blockworks-foundation
/
solana-with-rpc-optimizations
mirror of https://github.com/blockworks-foundation/solana-with-rpc-optimizations.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

feat: fix clippy for new error types

This commit is contained in:
Sam Kim 2022-01-04 09:19:36 -05:00 committed by Michael Vines
parent 0944abc0e2
commit 5b41d62f8a
11 changed files with 99 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
zk-token-sdk/src/errors.rs
View File

@ -1,19 +1,16 @@
//! Errors related to proving and verifying proofs.
use crate::{range_proof::errors::RangeProofError, sigma_proofs::errors::*};
use thiserror::Error;
use crate::{
range_proof::errors::RangeProofError,
sigma_proofs::errors::*,
};
// TODO: clean up errors for encryption
#[derive(Error, Clone, Debug, Eq, PartialEq)]
pub enum ProofError {
#[error("proof failed to verify")]
VerificationError,
Verification,
#[error("range proof failed to verify")]
RangeProofError,
RangeProof,
#[error("sigma proof failed to verify")]
SigmaProofError,
SigmaProof,
#[error(
"`zk_token_elgamal::pod::ElGamalCiphertext` contains invalid ElGamalCiphertext ciphertext"
)]
@ -28,29 +25,29 @@ pub enum TranscriptError {
impl From<RangeProofError> for ProofError {
fn from(_err: RangeProofError) -> Self {
Self::RangeProofError
Self::RangeProof
}
}
impl From<EqualityProofError> for ProofError {
fn from(_err: EqualityProofError) -> Self {
Self::SigmaProofError
Self::SigmaProof
}
}
impl From<FeeProofError> for ProofError {
fn from(_err: FeeProofError) -> Self {
Self::SigmaProofError
Self::SigmaProof
}
}
impl From<ZeroBalanceProofError> for ProofError {
fn from(_err: ZeroBalanceProofError) -> Self {
Self::SigmaProofError
Self::SigmaProof
}
}
impl From<ValidityProofError> for ProofError {
fn from(_err: ValidityProofError) -> Self {
Self::SigmaProofError
Self::SigmaProof
}
}

2
zk-token-sdk/src/instruction/transfer.rs
View File

@ -176,7 +176,7 @@ impl TransferData {
if let (Some(amount_lo), Some(amount_hi)) = (amount_lo, amount_hi) {
Ok((amount_lo as u64) + (TWO_32 * amount_hi as u64))
} else {
Err(ProofError::VerificationError)
Err(ProofError::Verification)
}
}
}

12
zk-token-sdk/src/range_proof/errors.rs
View File

@ -1,27 +1,27 @@
//! Errors related to proving and verifying range proofs.
use thiserror::Error;
use crate::errors::TranscriptError;
use thiserror::Error;
#[derive(Error, Clone, Debug, Eq, PartialEq)]
pub enum RangeProofError {
#[error("the required algebraic relation does not hold")]
AlgebraicRelationError,
AlgebraicRelation,
#[error("malformed proof")]
FormatError,
Format,
#[error("attempted to create a proof with a non-power-of-two bitsize or bitsize too big")]
InvalidBitsize,
#[error("insufficient generators for the proof")]
InvalidGeneratorsLength,
#[error("multiscalar multiplication failed")]
MultiscalarMulError,
MultiscalarMul,
#[error("transcript failed to produce a challenge")]
TranscriptError,
Transcript,
#[error("number of blinding factors do not match the number of values")]
WrongNumBlindingFactors,
}
impl From<TranscriptError> for RangeProofError {
fn from(_err: TranscriptError) -> Self {
Self::TranscriptError
Self::Transcript
}
}

23
zk-token-sdk/src/range_proof/inner_product.rs
View File

@ -1,5 +1,8 @@
use {
crate::{range_proof::{errors::RangeProofError, util}, transcript::TranscriptProtocol},
crate::{
range_proof::{errors::RangeProofError, util},
transcript::TranscriptProtocol,
},
core::iter,
curve25519_dalek::{
ristretto::{CompressedRistretto, RistrettoPoint},
@ -295,13 +298,13 @@ impl InnerProductProof {
let Ls = self
.L_vec
.iter()
.map(|p| p.decompress().ok_or(RangeProofError::FormatError))
.map(|p| p.decompress().ok_or(RangeProofError::Format))
.collect::<Result<Vec<_>, _>>()?;
let Rs = self
.R_vec
.iter()
.map(|p| p.decompress().ok_or(RangeProofError::FormatError))
.map(|p| p.decompress().ok_or(RangeProofError::Format))
.collect::<Result<Vec<_>, _>>()?;
let expect_P = RistrettoPoint::vartime_multiscalar_mul(
@ -320,7 +323,7 @@ impl InnerProductProof {
if expect_P == *P {
Ok(())
} else {
Err(RangeProofError::AlgebraicRelationError)
Err(RangeProofError::AlgebraicRelation)
}
}
@ -357,18 +360,18 @@ impl InnerProductProof {
pub fn from_bytes(slice: &[u8]) -> Result<InnerProductProof, RangeProofError> {
let b = slice.len();
if b % 32 != 0 {
return Err(RangeProofError::FormatError);
return Err(RangeProofError::Format);
}
let num_elements = b / 32;
if num_elements < 2 {
return Err(RangeProofError::FormatError);
return Err(RangeProofError::Format);
}
if (num_elements - 2) % 2 != 0 {
return Err(RangeProofError::FormatError);
return Err(RangeProofError::Format);
}
let lg_n = (num_elements - 2) / 2;
if lg_n >= 32 {
return Err(RangeProofError::FormatError);
return Err(RangeProofError::Format);
}
let mut L_vec: Vec<CompressedRistretto> = Vec::with_capacity(lg_n);
@ -381,9 +384,9 @@ impl InnerProductProof {
let pos = 2 * lg_n * 32;
let a = Scalar::from_canonical_bytes(util::read32(&slice[pos..]))
.ok_or(RangeProofError::FormatError)?;
.ok_or(RangeProofError::Format)?;
let b = Scalar::from_canonical_bytes(util::read32(&slice[pos + 32..]))
.ok_or(RangeProofError::FormatError)?;
.ok_or(RangeProofError::Format)?;
Ok(InnerProductProof { L_vec, R_vec, a, b })
}

39
zk-token-sdk/src/range_proof/mod.rs
View File

@ -8,7 +8,9 @@ use {
use {
crate::{
encryption::pedersen::PedersenBase,
range_proof::{errors::RangeProofError, generators::BulletproofGens, inner_product::InnerProductProof},
range_proof::{
errors::RangeProofError, generators::BulletproofGens, inner_product::InnerProductProof,
},
transcript::TranscriptProtocol,
},
core::iter,
@ -20,10 +22,10 @@ use {
merlin::Transcript,
};
pub mod errors;
pub mod generators;
pub mod inner_product;
pub mod util;
pub mod errors;
#[allow(non_snake_case)]
#[derive(Clone)]
@ -94,12 +96,13 @@ impl RangeProof {
// generate blinding factor for Pedersen commitment; `s_blinding` should not to be confused
// with blinding factors for the actual inner product vector
let s_blinding = Scalar::random(&mut OsRng);
let s_blinding = Scalar::random(&mut OsRng);
let S = RistrettoPoint::multiscalar_mul(
iter::once(&s_blinding).chain(s_L.iter()).chain(s_R.iter()),
iter::once(&H).chain(bp_gens.G(nm)).chain(bp_gens.H(nm)),
).compress();
)
.compress();
// add the Pedersen vector commitments to the transcript (send the commitments to the verifier)
transcript.append_point(b"A", &A);
@ -190,6 +193,9 @@ impl RangeProof {
let G_factors: Vec<Scalar> = iter::repeat(Scalar::one()).take(nm).collect();
let H_factors: Vec<Scalar> = util::exp_iter(y.invert()).take(nm).collect();
// generate challenge `c` for consistency with the verifier's transcript
transcript.challenge_scalar(b"c");
let ipp_proof = InnerProductProof::create(
&Q,
&G_factors,
@ -201,9 +207,7 @@ impl RangeProof {
transcript,
);
// generate challenge `c` for consistency with the verifier's transcript
transcript.challenge_scalar(b"c");
println!("{:?}", w);
RangeProof {
A,
S,
@ -288,6 +292,9 @@ impl RangeProof {
w * (self.t_x - a * b) + c * (delta(&bit_lengths, &y, &z) - self.t_x);
let value_commitment_scalars = util::exp_iter(z).take(m).map(|z_exp| c * zz * z_exp);
println!("here");
println!("{:?}", w);
let mega_check = RistrettoPoint::optional_multiscalar_mul(
iter::once(Scalar::one())
.chain(iter::once(x))
@ -312,12 +319,16 @@ impl RangeProof {
.chain(bp_gens.H(nm).map(|&x| Some(x)))
.chain(comms.iter().map(|V| V.decompress())),
)
.ok_or(RangeProofError::MultiscalarMulError)?;
.ok_or(RangeProofError::MultiscalarMul)?;
println!("here2");
println!("{:?}", mega_check.compress());
if mega_check.is_identity() {
Ok(())
} else {
Err(RangeProofError::AlgebraicRelationError)
println!("here3");
Err(RangeProofError::AlgebraicRelation)
}
}
@ -340,10 +351,10 @@ impl RangeProof {
// changed.
pub fn from_bytes(slice: &[u8]) -> Result<RangeProof, RangeProofError> {
if slice.len() % 32 != 0 {
return Err(RangeProofError::FormatError);
return Err(RangeProofError::Format);
}
if slice.len() < 7 * 32 {
return Err(RangeProofError::FormatError);
return Err(RangeProofError::Format);
}
let A = CompressedRistretto(util::read32(&slice[0..]));
@ -352,11 +363,11 @@ impl RangeProof {
let T_2 = CompressedRistretto(util::read32(&slice[3 * 32..]));
let t_x = Scalar::from_canonical_bytes(util::read32(&slice[4 * 32..]))
.ok_or(RangeProofError::FormatError)?;
.ok_or(RangeProofError::Format)?;
let t_x_blinding = Scalar::from_canonical_bytes(util::read32(&slice[5 * 32..]))
.ok_or(RangeProofError::FormatError)?;
.ok_or(RangeProofError::Format)?;
let e_blinding = Scalar::from_canonical_bytes(util::read32(&slice[6 * 32..]))
.ok_or(RangeProofError::FormatError)?;
.ok_or(RangeProofError::Format)?;
let ipp_proof = InnerProductProof::from_bytes(&slice[7 * 32..])?;

14
zk-token-sdk/src/sigma_proofs/equality_proof.rs
View File

@ -109,9 +109,9 @@ impl EqualityProof {
let ww = w * w;
// check that the required algebraic condition holds
let Y_0 = self.Y_0.decompress().ok_or(EqualityProofError::FormatError)?;
let Y_1 = self.Y_1.decompress().ok_or(EqualityProofError::FormatError)?;
let Y_2 = self.Y_2.decompress().ok_or(EqualityProofError::FormatError)?;
let Y_0 = self.Y_0.decompress().ok_or(EqualityProofError::Format)?;
let Y_1 = self.Y_1.decompress().ok_or(EqualityProofError::Format)?;
let Y_2 = self.Y_2.decompress().ok_or(EqualityProofError::Format)?;
let check = RistrettoPoint::vartime_multiscalar_mul(
vec![
@ -133,7 +133,7 @@ impl EqualityProof {
if check.is_identity() {
Ok(())
} else {
Err(EqualityProofError::AlgebraicRelationError)
Err(EqualityProofError::AlgebraicRelation)
}
}
@ -156,9 +156,9 @@ impl EqualityProof {
let Y_1 = CompressedRistretto::from_slice(Y_1);
let Y_2 = CompressedRistretto::from_slice(Y_2);
let z_s = Scalar::from_canonical_bytes(*z_s).ok_or(EqualityProofError::FormatError)?;
let z_x = Scalar::from_canonical_bytes(*z_x).ok_or(EqualityProofError::FormatError)?;
let z_r = Scalar::from_canonical_bytes(*z_r).ok_or(EqualityProofError::FormatError)?;
let z_s = Scalar::from_canonical_bytes(*z_s).ok_or(EqualityProofError::Format)?;
let z_x = Scalar::from_canonical_bytes(*z_x).ok_or(EqualityProofError::Format)?;
let z_r = Scalar::from_canonical_bytes(*z_r).ok_or(EqualityProofError::Format)?;
Ok(EqualityProof {
Y_0,

42
zk-token-sdk/src/sigma_proofs/errors.rs
View File

@ -1,75 +1,75 @@
//! Errors related to proving and verifying sigma proofs.
use thiserror::Error;
use crate::errors::TranscriptError;
use thiserror::Error;
#[derive(Error, Clone, Debug, Eq, PartialEq)]
pub enum EqualityProofError {
#[error("the required algebraic relation does not hold")]
AlgebraicRelationError,
AlgebraicRelation,
#[error("malformed proof")]
FormatError,
Format,
#[error("multiscalar multiplication failed")]
MultiscalarMulError,
MultiscalarMul,
#[error("transcript failed to produce a challenge")]
TranscriptError,
Transcript,
}
impl From<TranscriptError> for EqualityProofError {
fn from(_err: TranscriptError) -> Self {
Self::TranscriptError
Self::Transcript
}
}
#[derive(Error, Clone, Debug, Eq, PartialEq)]
pub enum ValidityProofError {
#[error("the required algebraic relation does not hold")]
AlgebraicRelationError,
AlgebraicRelation,
#[error("malformed proof")]
FormatError,
Format,
#[error("multiscalar multiplication failed")]
MultiscalarMulError,
MultiscalarMul,
#[error("transcript failed to produce a challenge")]
TranscriptError,
Transcript,
}
impl From<TranscriptError> for ValidityProofError {
fn from(_err: TranscriptError) -> Self {
Self::TranscriptError
Self::Transcript
}
}
#[derive(Error, Clone, Debug, Eq, PartialEq)]
pub enum ZeroBalanceProofError {
#[error("the required algebraic relation does not hold")]
AlgebraicRelationError,
AlgebraicRelation,
#[error("malformed proof")]
FormatError,
Format,
#[error("multiscalar multiplication failed")]
MultiscalarMulError,
MultiscalarMul,
#[error("transcript failed to produce a challenge")]
TranscriptError,
Transcript,
}
impl From<TranscriptError> for ZeroBalanceProofError {
fn from(_err: TranscriptError) -> Self {
Self::TranscriptError
Self::Transcript
}
}
#[derive(Error, Clone, Debug, Eq, PartialEq)]
pub enum FeeProofError {
#[error("the required algebraic relation does not hold")]
AlgebraicRelationError,
AlgebraicRelation,
#[error("malformed proof")]
FormatError,
Format,
#[error("multiscalar multiplication failed")]
MultiscalarMulError,
MultiscalarMul,
#[error("transcript failed to produce a challenge")]
TranscriptError,
Transcript,
}
impl From<TranscriptError> for FeeProofError {
fn from(_err: TranscriptError) -> Self {
Self::TranscriptError
Self::Transcript
}
}

8
zk-token-sdk/src/sigma_proofs/fee_proof.rs
View File

@ -202,19 +202,19 @@ impl FeeProof {
.fee_max_proof
.Y_max
.decompress()
.ok_or(FeeProofError::FormatError)?;
.ok_or(FeeProofError::Format)?;
let z_max = self.fee_max_proof.z_max;
let Y_delta_real = self
.fee_equality_proof
.Y_delta_real
.decompress()
.ok_or(FeeProofError::FormatError)?;
.ok_or(FeeProofError::Format)?;
let Y_delta_claimed = self
.fee_equality_proof
.Y_delta_claimed
.decompress()
.ok_or(FeeProofError::FormatError)?;
.ok_or(FeeProofError::Format)?;
let z_x = self.fee_equality_proof.z_x;
let z_delta_real = self.fee_equality_proof.z_delta_real;
let z_delta_claimed = self.fee_equality_proof.z_delta_claimed;
@ -262,7 +262,7 @@ impl FeeProof {
if check.is_identity() {
Ok(())
} else {
Err(FeeProofError::AlgebraicRelationError)
Err(FeeProofError::AlgebraicRelation)
}
}
}

12
zk-token-sdk/src/sigma_proofs/validity_proof.rs
View File

@ -103,9 +103,9 @@ impl ValidityProof {
let ww = w * w;
// check the required algebraic conditions
let Y_0 = self.Y_0.decompress().ok_or(ValidityProofError::FormatError)?;
let Y_1 = self.Y_1.decompress().ok_or(ValidityProofError::FormatError)?;
let Y_2 = self.Y_2.decompress().ok_or(ValidityProofError::FormatError)?;
let Y_0 = self.Y_0.decompress().ok_or(ValidityProofError::Format)?;
let Y_1 = self.Y_1.decompress().ok_or(ValidityProofError::Format)?;
let Y_2 = self.Y_2.decompress().ok_or(ValidityProofError::Format)?;
let P_dest = elgamal_pubkey_dest.get_point();
let P_auditor = elgamal_pubkey_auditor.get_point();
@ -133,7 +133,7 @@ impl ValidityProof {
if check.is_identity() {
Ok(())
} else {
Err(ValidityProofError::AlgebraicRelationError)
Err(ValidityProofError::AlgebraicRelation)
}
}
@ -155,8 +155,8 @@ impl ValidityProof {
let Y_1 = CompressedRistretto::from_slice(Y_1);
let Y_2 = CompressedRistretto::from_slice(Y_2);
let z_r = Scalar::from_canonical_bytes(*z_r).ok_or(ValidityProofError::FormatError)?;
let z_x = Scalar::from_canonical_bytes(*z_x).ok_or(ValidityProofError::FormatError)?;
let z_r = Scalar::from_canonical_bytes(*z_r).ok_or(ValidityProofError::Format)?;
let z_x = Scalar::from_canonical_bytes(*z_x).ok_or(ValidityProofError::Format)?;
Ok(ValidityProof {
Y_0,

8
zk-token-sdk/src/sigma_proofs/zero_balance_proof.rs
View File

@ -89,8 +89,8 @@ impl ZeroBalanceProof {
let w = transcript.challenge_scalar(b"w"); // w used for multiscalar multiplication verification
// decompress R or return verification error
let Y_P = self.Y_P.decompress().ok_or(ZeroBalanceProofError::FormatError)?;
let Y_D = self.Y_D.decompress().ok_or(ZeroBalanceProofError::FormatError)?;
let Y_P = self.Y_P.decompress().ok_or(ZeroBalanceProofError::Format)?;
let Y_D = self.Y_D.decompress().ok_or(ZeroBalanceProofError::Format)?;
let z = self.z;
// check the required algebraic relation
@ -102,7 +102,7 @@ impl ZeroBalanceProof {
if check.is_identity() {
Ok(())
} else {
Err(ZeroBalanceProofError::AlgebraicRelationError)
Err(ZeroBalanceProofError::AlgebraicRelation)
}
}
@ -121,7 +121,7 @@ impl ZeroBalanceProof {
let Y_P = CompressedRistretto::from_slice(Y_P);
let Y_D = CompressedRistretto::from_slice(Y_D);
let z = Scalar::from_canonical_bytes(*z).ok_or(ZeroBalanceProofError::FormatError)?;
let z = Scalar::from_canonical_bytes(*z).ok_or(ZeroBalanceProofError::Format)?;
Ok(ZeroBalanceProof { Y_P, Y_D, z })
}

7
zk-token-sdk/src/zk_token_elgamal/convert.rs
View File

@ -23,8 +23,7 @@ mod target_arch {
errors::ProofError,
range_proof::{errors::RangeProofError, RangeProof},
sigma_proofs::{
errors::*,
equality_proof::EqualityProof, validity_proof::ValidityProof,
equality_proof::EqualityProof, errors::*, validity_proof::ValidityProof,
zero_balance_proof::ZeroBalanceProof,
},
},
@ -192,7 +191,7 @@ mod target_arch {
fn try_from(proof: RangeProof) -> Result<Self, Self::Error> {
if proof.ipp_proof.serialized_size() != 448 {
return Err(RangeProofError::FormatError);
return Err(RangeProofError::Format);
}
let mut buf = [0_u8; 672];
@ -222,7 +221,7 @@ mod target_arch {
fn try_from(proof: RangeProof) -> Result<Self, Self::Error> {
if proof.ipp_proof.serialized_size() != 512 {
return Err(RangeProofError::FormatError);
return Err(RangeProofError::Format);
}
let mut buf = [0_u8; 736];