cml-chain 6.2.0

Multiplatform SDK for main Cardano blockchain functionality
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
149
150
151
152
153
154
155
156
157

// This file was code-generated using an experimental CDDL to rust tool:
// https://github.com/dcSpark/cddl-codegen

pub mod cbor_encodings;
pub mod serialization;

use super::TransactionIndex;
use crate::auxdata::AuxiliaryData;
use crate::crypto::{
    BlockBodyHash, BlockHeaderHash, Ed25519Signature, KESSignature, KESVkey, VRFCert, VRFVkey, Vkey,
};
use crate::transaction::{TransactionBody, TransactionWitnessSet};
use cbor_encodings::{
    BlockEncoding, HeaderBodyEncoding, HeaderEncoding, OperationalCertEncoding,
    ProtocolVersionEncoding,
};
use cml_core::ordered_hash_map::OrderedHashMap;
use std::collections::BTreeMap;

#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, schemars::JsonSchema)]
pub struct Block {
    pub header: Header,
    pub transaction_bodies: Vec<TransactionBody>,
    pub transaction_witness_sets: Vec<TransactionWitnessSet>,
    pub auxiliary_data_set: OrderedHashMap<TransactionIndex, AuxiliaryData>,
    pub invalid_transactions: Vec<TransactionIndex>,
    #[serde(skip)]
    pub encodings: Option<BlockEncoding>,
}

impl Block {
    pub fn new(
        header: Header,
        transaction_bodies: Vec<TransactionBody>,
        transaction_witness_sets: Vec<TransactionWitnessSet>,
        auxiliary_data_set: OrderedHashMap<TransactionIndex, AuxiliaryData>,
        invalid_transactions: Vec<TransactionIndex>,
    ) -> Self {
        Self {
            header,
            transaction_bodies,
            transaction_witness_sets,
            auxiliary_data_set,
            invalid_transactions,
            encodings: None,
        }
    }
}

#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, schemars::JsonSchema)]
pub struct Header {
    pub header_body: HeaderBody,
    pub body_signature: KESSignature,
    #[serde(skip)]
    pub encodings: Option<HeaderEncoding>,
}

impl Header {
    pub fn new(header_body: HeaderBody, body_signature: KESSignature) -> Self {
        Self {
            header_body,
            body_signature,
            encodings: None,
        }
    }
}

#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, schemars::JsonSchema)]
pub struct HeaderBody {
    pub block_number: u64,
    pub slot: u64,
    pub prev_hash: Option<BlockHeaderHash>,
    pub issuer_vkey: Vkey,
    pub vrf_vkey: VRFVkey,
    pub vrf_result: VRFCert,
    pub block_body_size: u64,
    pub block_body_hash: BlockBodyHash,
    pub operational_cert: OperationalCert,
    pub protocol_version: ProtocolVersion,
    #[serde(skip)]
    pub encodings: Option<HeaderBodyEncoding>,
}

impl HeaderBody {
    #[allow(clippy::too_many_arguments)]
    pub fn new(
        block_number: u64,
        slot: u64,
        prev_hash: Option<BlockHeaderHash>,
        issuer_vkey: Vkey,
        vrf_vkey: VRFVkey,
        vrf_result: VRFCert,
        block_body_size: u64,
        block_body_hash: BlockBodyHash,
        operational_cert: OperationalCert,
        protocol_version: ProtocolVersion,
    ) -> Self {
        Self {
            block_number,
            slot,
            prev_hash,
            issuer_vkey,
            vrf_vkey,
            vrf_result,
            block_body_size,
            block_body_hash,
            operational_cert,
            protocol_version,
            encodings: None,
        }
    }
}

#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, schemars::JsonSchema)]
pub struct OperationalCert {
    pub hot_vkey: KESVkey,
    pub sequence_number: u64,
    pub kes_period: u64,
    pub sigma: Ed25519Signature,
    #[serde(skip)]
    pub encodings: Option<OperationalCertEncoding>,
}

impl OperationalCert {
    pub fn new(
        hot_vkey: KESVkey,
        sequence_number: u64,
        kes_period: u64,
        sigma: Ed25519Signature,
    ) -> Self {
        Self {
            hot_vkey,
            sequence_number,
            kes_period,
            sigma,
            encodings: None,
        }
    }
}

#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, schemars::JsonSchema)]
pub struct ProtocolVersion {
    pub major: u64,
    pub minor: u64,
    #[serde(skip)]
    pub encodings: Option<ProtocolVersionEncoding>,
}

impl ProtocolVersion {
    pub fn new(major: u64, minor: u64) -> Self {
        Self {
            major,
            minor,
            encodings: None,
        }
    }
}