Struct ProofResult 

pub struct ProofResult {
    pub index: usize,
    pub accepted: bool,
    pub proof_id: Option<Uuid>,
    pub reward_points: Option<Points>,
    pub rejection_reason: Option<String>,
}

Result for an individual proof in a batch.

Fields

index: usize

Index in the original batch.

accepted: bool

Whether the proof was accepted.

proof_id: Option<Uuid>

Proof ID if accepted.

reward_points: Option<Points>

Reward points if accepted.

rejection_reason: Option<String>

Rejection reason if not accepted.

Implementations

impl ProofResult

pub fn accepted(index: usize, proof_id: Uuid, reward_points: Points) -> Self

Create a result for an accepted proof.

Example

use chie_shared::types::batch::ProofResult;
use uuid::Uuid;

let proof_id = Uuid::new_v4();
let result = ProofResult::accepted(0, proof_id, 1000);

assert!(result.accepted);
assert_eq!(result.index, 0);
assert_eq!(result.proof_id, Some(proof_id));
assert_eq!(result.reward_points, Some(1000));
assert_eq!(result.rejection_reason, None);

pub fn rejected(index: usize, reason: impl Into<String>) -> Self

Create a result for a rejected proof.

Example

use chie_shared::types::batch::ProofResult;

let result = ProofResult::rejected(2, "Invalid signature length");

assert!(!result.accepted);
assert_eq!(result.index, 2);
assert_eq!(result.proof_id, None);
assert_eq!(result.reward_points, None);
assert_eq!(result.rejection_reason, Some("Invalid signature length".to_string()));

Trait Implementations

impl Clone for ProofResult

fn clone(&self) -> ProofResult

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ProofResult

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ProofResult

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ProofResult

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.