Zei: Confidential Assets

```
// Copyright 2019 Stichting Organism
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//! Zei Errors
//! Errors related to proving and verifying proofs.
use failure::Fail;
/// Represents an error in Zei
#[derive(Eq, PartialEq, Debug, Fail, Clone)]
pub enum ZeiError {
/// This error occurs when a proof failed to verify.
#[fail(display = "Proof verification failed.")]
VerificationError,
/// This error occurs when transaction has too many outputs.
#[fail(display = "Can't have more than 32 Outputs.")]
OutputOverflowError,
/// This error occurs when transaction not spending all the coins.
#[fail(display = "Can't leave coins behind.")]
CoinsLeftBehind,
/// Bulletproofs Errors
#[fail(display = "Internal error during proof creation: {}", _0)]
ProofError(ProofError),
#[fail(display = "Decryption failed.")]
LockboxDecrypt
}
/// Represents an error in proof creation, verification, or parsing.
#[derive(Fail, Clone, Debug, Eq, PartialEq)]
pub enum ProofError {
/// This error occurs when a proof failed to verify.
#[fail(display = "Proof verification failed.")]
VerificationError,
/// This error occurs when the proof encoding is malformed.
#[fail(display = "Proof data could not be parsed.")]
FormatError,
/// This error occurs during proving if the number of blinding
/// factors does not match the number of values.
#[fail(display = "Wrong number of blinding factors supplied.")]
WrongNumBlindingFactors,
/// This error occurs when attempting to create a proof with
/// bitsize other than \\(8\\), \\(16\\), \\(32\\), or \\(64\\).
#[fail(display = "Invalid bitsize, must have n = 8,16,32,64.")]
InvalidBitsize,
/// This error occurs when attempting to create an aggregated
/// proof with non-power-of-two aggregation size.
#[fail(display = "Invalid aggregation size, m must be a power of 2.")]
InvalidAggregation,
/// This error occurs when there are insufficient generators for the proof.
#[fail(display = "Invalid generators size, too few generators for proof")]
InvalidGeneratorsLength,
/// This error results from an internal error during proving.
///
/// The single-party prover is implemented by performing
/// multiparty computation with ourselves. However, because the
/// MPC protocol is not exposed by the single-party API, we
/// consider its errors to be internal errors.
#[fail(display = "Internal error during proof creation: {}", _0)]
ProvingError(MPCError)
}
impl From<ProofError> for ZeiError {
fn from(e: ProofError) -> ZeiError {
ZeiError::ProofError(e)
}
}
impl From<MPCError> for ZeiError {
fn from(e: MPCError) -> ZeiError {
match e {
MPCError::InvalidBitsize => ZeiError::from(ProofError::InvalidBitsize),
MPCError::InvalidAggregation => ZeiError::from(ProofError::InvalidAggregation),
MPCError::InvalidGeneratorsLength => ZeiError::from(ProofError::InvalidGeneratorsLength),
_ => ZeiError::from(ProofError::ProvingError(e)),
}
}
}
impl From<MPCError> for ProofError {
fn from(e: MPCError) -> ProofError {
match e {
MPCError::InvalidBitsize => ProofError::InvalidBitsize,
MPCError::InvalidAggregation => ProofError::InvalidAggregation,
MPCError::InvalidGeneratorsLength => ProofError::InvalidGeneratorsLength,
_ => ProofError::ProvingError(e),
}
}
}
/// Represents an error during the multiparty computation protocol for
/// proof aggregation.
///
/// This is a separate type from the `ProofError` to allow a layered
/// API: although the MPC protocol is used internally for single-party
/// proving, its API should not expose the complexity of the MPC
/// protocol.
#[derive(Fail, Clone, Debug, Eq, PartialEq)]
pub enum MPCError {
/// This error occurs when the dealer gives a zero challenge,
/// which would annihilate the blinding factors.
#[fail(display = "Dealer gave a malicious challenge value.")]
MaliciousDealer,
/// This error occurs when attempting to create a proof with
/// bitsize other than \\(8\\), \\(16\\), \\(32\\), or \\(64\\).
#[fail(display = "Invalid bitsize, must have n = 8,16,32,64")]
InvalidBitsize,
/// This error occurs when attempting to create an aggregated
/// proof with non-power-of-two aggregation size.
#[fail(display = "Invalid aggregation size, m must be a power of 2")]
InvalidAggregation,
/// This error occurs when there are insufficient generators for the proof.
#[fail(display = "Invalid generators size, too few generators for proof")]
InvalidGeneratorsLength,
/// This error occurs when the dealer is given the wrong number of
/// value commitments.
#[fail(display = "Wrong number of value commitments")]
WrongNumBitCommitments,
/// This error occurs when the dealer is given the wrong number of
/// polynomial commitments.
#[fail(display = "Wrong number of value commitments")]
WrongNumPolyCommitments,
/// This error occurs when the dealer is given the wrong number of
/// proof shares.
#[fail(display = "Wrong number of proof shares")]
WrongNumProofShares,
/// This error occurs when one or more parties submit malformed
/// proof shares.
#[fail(display = "Malformed proof shares from parties {:?}", bad_shares)]
MalformedProofShares {
/// A vector with the indexes of the parties whose shares were malformed.
bad_shares: Vec<usize>,
},
}
```