bsv-sdk 0.2.7

Pure Rust implementation of the BSV Blockchain SDK
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

//! CompoundMerklePathCertificate: certificate + merkle proof wrapper.
//!
//! A minimal wrapper combining a wallet::Certificate with a MerklePath.
//! Provides Deref to the inner Certificate for transparent field access.

use std::ops::Deref;

use crate::transaction::merkle_path::MerklePath;
use crate::wallet::interfaces::Certificate;

/// A certificate paired with its merkle path proof.
///
/// This is a minimal wrapper -- no additional methods beyond construction.
/// The MerklePath can be used to verify the certificate's inclusion in a block.
#[derive(Clone, Debug)]
#[cfg_attr(feature = "network", derive(serde::Serialize, serde::Deserialize))]
#[cfg_attr(feature = "network", serde(rename_all = "camelCase"))]
pub struct CompoundMerklePathCertificate {
    /// The underlying wallet Certificate.
    #[cfg_attr(feature = "network", serde(flatten))]
    pub certificate: Certificate,
    /// The merkle path proving inclusion of the certificate's transaction.
    #[cfg_attr(feature = "network", serde(skip, default = "default_merkle_path"))]
    pub merkle_path: MerklePath,
}

#[cfg(feature = "network")]
fn default_merkle_path() -> MerklePath {
    MerklePath {
        block_height: 0,
        path: vec![],
    }
}

impl Deref for CompoundMerklePathCertificate {
    type Target = Certificate;
    fn deref(&self) -> &Self::Target {
        &self.certificate
    }
}

impl CompoundMerklePathCertificate {
    /// Create a new CompoundMerklePathCertificate.
    pub fn new(certificate: Certificate, merkle_path: MerklePath) -> Self {
        CompoundMerklePathCertificate {
            certificate,
            merkle_path,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::primitives::public_key::PublicKey;
    use crate::wallet::interfaces::{CertificateType, SerialNumber};

    #[test]
    fn test_compound_certificate_deref() {
        // Create a minimal Certificate
        let cert = Certificate {
            cert_type: CertificateType([0u8; 32]),
            serial_number: SerialNumber([1u8; 32]),
            subject: PublicKey::from_string(
                "0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
            )
            .unwrap(),
            certifier: PublicKey::from_string(
                "0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
            )
            .unwrap(),
            revocation_outpoint: Some(format!("{}.0", "00".repeat(32))),
            fields: None,
            signature: None,
        };

        let merkle_path = MerklePath {
            block_height: 100,
            path: vec![],
        };

        let compound = CompoundMerklePathCertificate::new(cert.clone(), merkle_path);

        // Deref should provide access to Certificate fields
        assert_eq!(compound.cert_type.0, [0u8; 32]);
        assert_eq!(compound.serial_number.0, [1u8; 32]);
        assert_eq!(compound.merkle_path.block_height, 100);
    }
}