blvm-sdk 0.1.1

Bitcoin Commons software developer kit, governance infrastructure and composition framework for Bitcoin
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

//! # Governance Key Management
//!
//! Key generation and management for governance operations.

use rand::rngs::OsRng;
use secp256k1::{PublicKey as Secp256k1PublicKey, Secp256k1, SecretKey};
use std::fmt;

use crate::governance::error::{GovernanceError, GovernanceResult};

/// A governance keypair for signing governance messages
#[derive(Debug, Clone)]
pub struct GovernanceKeypair {
    pub secret_key: SecretKey,
    pub public_key: Secp256k1PublicKey,
}

/// A public key for governance operations
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct PublicKey {
    pub inner: Secp256k1PublicKey,
}

impl GovernanceKeypair {
    /// Generate a new random keypair
    pub fn generate() -> GovernanceResult<Self> {
        let secp = Secp256k1::new();
        let mut rng = OsRng;

        let secret_key = SecretKey::new(&mut rng);
        let public_key = secret_key.public_key(&secp);

        Ok(Self {
            secret_key,
            public_key,
        })
    }

    /// Create a keypair from a secret key
    pub fn from_secret_key(secret_bytes: &[u8]) -> GovernanceResult<Self> {
        let secp = Secp256k1::new();

        let secret_key = SecretKey::from_slice(secret_bytes)
            .map_err(|e| GovernanceError::InvalidKey(format!("Invalid secret key: {e}")))?;

        let public_key = secret_key.public_key(&secp);

        Ok(Self {
            secret_key,
            public_key,
        })
    }

    /// Get the public key
    pub fn public_key(&self) -> PublicKey {
        PublicKey {
            inner: self.public_key,
        }
    }

    /// Get the secret key bytes
    pub fn secret_key_bytes(&self) -> [u8; 32] {
        self.secret_key.secret_bytes()
    }

    /// Get the public key bytes
    pub fn public_key_bytes(&self) -> [u8; 33] {
        self.public_key.serialize()
    }
}

impl PublicKey {
    /// Create a public key from bytes
    pub fn from_bytes(bytes: &[u8]) -> GovernanceResult<Self> {
        let public_key = Secp256k1PublicKey::from_slice(bytes)
            .map_err(|e| GovernanceError::InvalidKey(format!("Invalid public key: {e}")))?;

        Ok(Self { inner: public_key })
    }

    /// Get the public key bytes
    pub fn to_bytes(&self) -> [u8; 33] {
        self.inner.serialize()
    }

    /// Get the compressed public key bytes
    pub fn to_compressed_bytes(&self) -> [u8; 33] {
        self.inner.serialize()
    }

    /// Get the uncompressed public key bytes
    pub fn to_uncompressed_bytes(&self) -> [u8; 65] {
        self.inner.serialize_uncompressed()
    }
}

impl fmt::Display for PublicKey {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", hex::encode(self.to_bytes()))
    }
}

impl fmt::Display for GovernanceKeypair {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "GovernanceKeypair(pubkey: {})", self.public_key())
    }
}

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

    #[test]
    fn test_keypair_generation() {
        let keypair = GovernanceKeypair::generate().unwrap();
        let public_key = keypair.public_key();

        // Verify the public key can be serialized and deserialized
        let bytes = public_key.to_bytes();
        let reconstructed = PublicKey::from_bytes(&bytes).unwrap();
        assert_eq!(public_key, reconstructed);
    }

    #[test]
    fn test_keypair_from_secret_key() {
        let keypair1 = GovernanceKeypair::generate().unwrap();
        let secret_bytes = keypair1.secret_key_bytes();

        let keypair2 = GovernanceKeypair::from_secret_key(&secret_bytes).unwrap();

        // Both keypairs should have the same public key
        assert_eq!(keypair1.public_key(), keypair2.public_key());
    }

    #[test]
    fn test_invalid_secret_key() {
        let invalid_bytes = [0u8; 31]; // Too short
        let result = GovernanceKeypair::from_secret_key(&invalid_bytes);
        assert!(result.is_err());
    }

    #[test]
    fn test_invalid_public_key() {
        let invalid_bytes = [0u8; 32]; // Wrong length for public key
        let result = PublicKey::from_bytes(&invalid_bytes);
        assert!(result.is_err());
    }
}