bsv-rs 0.3.5

BSV blockchain SDK for Rust - primitives, script, transactions, and more
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

//! # Messages Module
//!
//! Peer-to-peer signed and encrypted messaging for BSV.
//!
//! This module implements:
//! - **BRC-77**: Signed messages with optional recipient-specific verification
//! - **BRC-78**: Encrypted messages using ECDH key derivation
//!
//! ## Quick Start
//!
//! ### Signed Messages (BRC-77)
//!
//! ```rust
//! use bsv_rs::primitives::PrivateKey;
//! use bsv_rs::messages::{sign, verify};
//!
//! let sender = PrivateKey::random();
//! let recipient = PrivateKey::random();
//!
//! // Sign for a specific recipient
//! let message = b"Hello, BSV!";
//! let signature = sign(message, &sender, Some(&recipient.public_key())).unwrap();
//!
//! // Verify with recipient's private key
//! let valid = verify(message, &signature, Some(&recipient)).unwrap();
//! assert!(valid);
//!
//! // Sign for anyone to verify
//! let sig_anyone = sign(message, &sender, None).unwrap();
//! let valid_anyone = verify(message, &sig_anyone, None).unwrap();
//! assert!(valid_anyone);
//! ```
//!
//! ### Encrypted Messages (BRC-78)
//!
//! ```rust
//! use bsv_rs::primitives::PrivateKey;
//! use bsv_rs::messages::{encrypt, decrypt};
//!
//! let sender = PrivateKey::random();
//! let recipient = PrivateKey::random();
//!
//! // Encrypt a message
//! let plaintext = b"Secret message";
//! let ciphertext = encrypt(plaintext, &sender, &recipient.public_key()).unwrap();
//!
//! // Decrypt with recipient's private key
//! let decrypted = decrypt(&ciphertext, &recipient).unwrap();
//! assert_eq!(plaintext.to_vec(), decrypted);
//! ```
//!
//! ## Wire Formats
//!
//! ### Signed Message Format
//! ```text
//! [version: 4 bytes] [sender_pubkey: 33 bytes] [recipient: 1 or 33 bytes] [keyID: 32 bytes] [signature: DER]
//! ```
//! - Version: `0x42423301`
//! - Recipient: `0x00` for anyone, or 33-byte compressed public key
//!
//! ### Encrypted Message Format
//! ```text
//! [version: 4 bytes] [sender_pubkey: 33 bytes] [recipient_pubkey: 33 bytes] [keyID: 32 bytes] [ciphertext]
//! ```
//! - Version: `0x42421033`
//! - Ciphertext includes 32-byte IV and 16-byte GCM tag

mod encrypted;
mod signed;

pub use encrypted::{decrypt, encrypt};
pub use signed::{sign, verify};

/// Version bytes for signed messages (BRC-77): 0x42423301
pub const SIGNED_VERSION: [u8; 4] = [0x42, 0x42, 0x33, 0x01];

/// Version bytes for encrypted messages (BRC-78): 0x42421033
pub const ENCRYPTED_VERSION: [u8; 4] = [0x42, 0x42, 0x10, 0x33];

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

    #[test]
    fn test_sign_verify_roundtrip() {
        let sender = PrivateKey::random();
        let recipient = PrivateKey::random();
        let message = b"Test message for signing";

        // Sign for specific recipient
        let signature = sign(message, &sender, Some(&recipient.public_key())).unwrap();

        // Verify with correct recipient
        let valid = verify(message, &signature, Some(&recipient)).unwrap();
        assert!(valid);
    }

    #[test]
    fn test_sign_verify_anyone() {
        let sender = PrivateKey::random();
        let message = b"Anyone can verify this";

        // Sign for anyone
        let signature = sign(message, &sender, None).unwrap();

        // Verify without recipient
        let valid = verify(message, &signature, None).unwrap();
        assert!(valid);
    }

    #[test]
    fn test_encrypt_decrypt_roundtrip() {
        let sender = PrivateKey::random();
        let recipient = PrivateKey::random();
        let plaintext = b"Secret message content";

        // Encrypt
        let ciphertext = encrypt(plaintext, &sender, &recipient.public_key()).unwrap();

        // Decrypt
        let decrypted = decrypt(&ciphertext, &recipient).unwrap();
        assert_eq!(plaintext.to_vec(), decrypted);
    }

    #[test]
    fn test_version_bytes() {
        assert_eq!(SIGNED_VERSION, [0x42, 0x42, 0x33, 0x01]);
        assert_eq!(ENCRYPTED_VERSION, [0x42, 0x42, 0x10, 0x33]);
    }
}