bip352 0.1.0-alpha.3

Implementation of BIP 352 Silent Payments
Documentation 
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
124
125
126
127

use bitcoin::hashes::{sha256t::Tag, Hash, HashEngine};
use bitcoin::secp256k1;
use bitcoin::secp256k1::scalar::OutOfRangeError;
use bitcoin::secp256k1::{PublicKey, Scalar, Secp256k1, SecretKey, Signing, Verification};

use crate::{LabelHash, LabelTag, ScanSecretKey, SpendPublicKey};

/// Reserved label for change.
const CHANGE_LABEL_INDEX: u32 = 0;

#[derive(Copy, Clone, Hash, Debug, Ord, PartialEq, PartialOrd, Eq)]
pub enum Label {
    Change,
    Index(LabelIndex),
}

impl Label {
    /// Tweak label with a secret scan key.
    pub fn tweak(&self, scan_key: &ScanSecretKey) -> Result<LabelTweak, OutOfRangeError> {
        match self {
            Label::Change => LabelTweak::change(scan_key),
            Label::Index(i) => LabelTweak::from_index(scan_key, *i),
        }
    }
}

/// Index <i>m</i> of a label, guaranteed to be greater than 0 (which is reserved
/// for change).
#[derive(Copy, Clone, Debug, Hash, Ord, PartialEq, PartialOrd, Eq)]
pub struct LabelIndex(u32);

impl TryFrom<u32> for LabelIndex {
    type Error = LabelZeroError;

    fn try_from(value: u32) -> Result<Self, Self::Error> {
        if value == CHANGE_LABEL_INDEX {
            Err(LabelZeroError)
        } else {
            Ok(Self(value))
        }
    }
}

impl TryFrom<&u32> for LabelIndex {
    type Error = LabelZeroError;

    fn try_from(value: &u32) -> Result<Self, Self::Error> {
        if *value == CHANGE_LABEL_INDEX {
            Err(LabelZeroError)
        } else {
            Ok(Self(*value))
        }
    }
}

impl From<LabelIndex> for u32 {
    fn from(val: LabelIndex) -> Self {
        val.0
    }
}

/// Error caused by attempting to use 0 as label (which is reserved for change).
#[derive(Debug)]
pub struct LabelZeroError;

/// Label used to differentiate various purposes of Silent Payment address,
/// generated for a particular scan key (i. e. it is valid only for that
/// scan key for which it was derived).
pub struct LabelTweak {
    tweak: Scalar,
    label: Label,
}

impl LabelTweak {
    /// Creates label for secret scan key and index.
    pub fn from_index(
        scan_key: &ScanSecretKey,
        index: LabelIndex,
    ) -> Result<LabelTweak, OutOfRangeError> {
        Self::label_tweak(scan_key, index.into()).map(|tweak| LabelTweak {
            tweak,
            label: Label::Index(index),
        })
    }

    /// Creates label for change.
    pub fn change(scan_key: &ScanSecretKey) -> Result<LabelTweak, OutOfRangeError> {
        Self::label_tweak(scan_key, CHANGE_LABEL_INDEX).map(|tweak| LabelTweak {
            tweak,
            label: Label::Change,
        })
    }

    /// Calculates tweak of the given label <i>m</i>  using
    /// <i>hash<sub>BIP0352/Label</sub>(ser<sub>256</sub>(b<sub>scan</sub>) || ser<sub>32</sub>(m))·G</i>
    /// for secret key <i>b<sub>scan</sub></i>. The result can be then added to public <i>B<sub>scan</sub></i>
    /// to form <i>B<sub>m</sub></i>, the spending part of Silent Payment address.
    fn label_tweak(b_scan: &ScanSecretKey, m: u32) -> Result<Scalar, OutOfRangeError> {
        let mut engine = LabelTag::engine();
        engine.input(&b_scan.to_secret_key().secret_bytes());
        engine.input(&m.to_be_bytes());
        Scalar::from_be_bytes(LabelHash::from_engine(engine).to_byte_array())
    }

    /// Applies label to public spend key.
    pub fn apply_to_key<C: Verification>(
        &self,
        spend_key: &SpendPublicKey,
        secp: &Secp256k1<C>,
    ) -> Result<SpendPublicKey, secp256k1::Error> {
        spend_key.add_tweak(&self.tweak, secp)
    }

    pub fn to_public_key<C: Signing>(&self, secp: &Secp256k1<C>) -> PublicKey {
        SecretKey::from_slice(&self.tweak.to_be_bytes())
            .expect("tweak is on curve, so should be the secret key")
            .public_key(secp)
    }

    pub(crate) fn to_scalar(&self) -> Scalar {
        self.tweak
    }

    pub fn label(&self) -> Label {
        self.label
    }
}