neptune-consensus 0.14.0

Consensus logic and proof abstractions for Neptune Cash.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use std::fmt::Display;
use std::str::FromStr;

use clap::error::ErrorKind;
use clap::Parser;
use get_size2::GetSize;
use serde::Deserialize;
use serde::Serialize;

use crate::transaction::transaction_proof::TransactionProofType;

/// represents which type of proof a given device is capable of generating
///
/// see also:
/// * [TransactionProofType]
/// * [TransactionProof](crate::transaction::transaction_proof::TransactionProof)
#[derive(Parser, Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default, GetSize)]
pub enum TxProvingCapability {
    // Enumeration here must match that used in TransactionProofType.
    #[default]
    PrimitiveWitness = 0,
    LockScript = 1,
    ProofCollection = 2,
    SingleProof = 3,
}

impl From<TxProvingCapability> for TransactionProofType {
    fn from(c: TxProvingCapability) -> Self {
        match c {
            TxProvingCapability::PrimitiveWitness => Self::PrimitiveWitness,
            TxProvingCapability::LockScript => unimplemented!(),
            TxProvingCapability::ProofCollection => Self::ProofCollection,
            TxProvingCapability::SingleProof => Self::SingleProof,
        }
    }
}

impl TxProvingCapability {
    pub fn can_prove(&self, proof_type: TransactionProofType) -> bool {
        let self_val = *self as u8;
        self_val >= proof_type as u8
    }
}

impl Display for TxProvingCapability {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "{}",
            match self {
                TxProvingCapability::PrimitiveWitness => "primitive witness",
                TxProvingCapability::LockScript => "lock script",
                TxProvingCapability::ProofCollection => "proof collection",
                TxProvingCapability::SingleProof => "single proof",
            }
        )
    }
}

impl FromStr for TxProvingCapability {
    type Err = clap::Error;
    // This implementation exists to allow CLI arguments to be converted to an
    // instance of this type.

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            // PrimitiveWitness is not covered here, as it's only used
            // internally, and cannot be set on the client.
            "lockscript" => Ok(TxProvingCapability::LockScript),
            "proofcollection" => Ok(TxProvingCapability::ProofCollection),
            "singleproof" => Ok(TxProvingCapability::SingleProof),
            _ => Err(clap::Error::raw(
                ErrorKind::InvalidValue,
                "Invalid machine proving power",
            )),
        }
    }
}

#[cfg(feature = "mock-rpc")]
impl rand::distr::Distribution<TxProvingCapability> for rand::distr::StandardUniform {
    fn sample<R: rand::Rng + ?Sized>(&self, rng: &mut R) -> TxProvingCapability {
        match rng.random_range(0..4) {
            0 => TxProvingCapability::PrimitiveWitness,
            1 => TxProvingCapability::LockScript,
            2 => TxProvingCapability::ProofCollection,
            3 => TxProvingCapability::SingleProof,
            _ => unreachable!(),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn can_prove_simple() {
        assert!(
            TxProvingCapability::PrimitiveWitness.can_prove(TransactionProofType::PrimitiveWitness)
        );
        assert!(
            !TxProvingCapability::PrimitiveWitness.can_prove(TransactionProofType::ProofCollection)
        );
        assert!(!TxProvingCapability::PrimitiveWitness.can_prove(TransactionProofType::SingleProof));

        assert!(TxProvingCapability::LockScript.can_prove(TransactionProofType::PrimitiveWitness));
        assert!(!TxProvingCapability::LockScript.can_prove(TransactionProofType::ProofCollection));
        assert!(!TxProvingCapability::LockScript.can_prove(TransactionProofType::SingleProof));

        assert!(
            TxProvingCapability::ProofCollection.can_prove(TransactionProofType::PrimitiveWitness)
        );
        assert!(
            TxProvingCapability::ProofCollection.can_prove(TransactionProofType::ProofCollection)
        );
        assert!(!TxProvingCapability::ProofCollection.can_prove(TransactionProofType::SingleProof));

        assert!(TxProvingCapability::SingleProof.can_prove(TransactionProofType::PrimitiveWitness));
        assert!(TxProvingCapability::SingleProof.can_prove(TransactionProofType::ProofCollection));
        assert!(TxProvingCapability::SingleProof.can_prove(TransactionProofType::SingleProof));
    }
}