1pub mod cbor_encodings;
5pub mod serialization;
6pub mod utils;
7
8#[cfg(not(feature = "used_from_wasm"))]
9use noop_proc_macro::wasm_bindgen;
10#[cfg(feature = "used_from_wasm")]
11use wasm_bindgen::prelude::wasm_bindgen;
12
13use crate::allegra::AllegraCertificate;
14use crate::shelley::{ProtocolVersionStruct, ShelleyHeader};
15use cbor_encodings::{
16 AlonzoBlockEncoding, AlonzoFormatAuxDataEncoding, AlonzoProtocolParamUpdateEncoding,
17 AlonzoTransactionBodyEncoding, AlonzoTransactionEncoding, AlonzoTransactionWitnessSetEncoding,
18 AlonzoUpdateEncoding,
19};
20use cml_chain::assets::{Coin, Mint};
21use cml_chain::auxdata::{Metadata, ShelleyFormatAuxData, ShelleyMAFormatAuxData};
22use cml_chain::crypto::{
23 AuxiliaryDataHash, BootstrapWitness, GenesisHash, Nonce, ScriptDataHash, Vkeywitness,
24};
25use cml_chain::plutus::{CostModels, ExUnitPrices, ExUnits, PlutusData, PlutusV1Script};
26use cml_chain::transaction::{AlonzoFormatTxOut, NativeScript, TransactionInput};
27use cml_chain::TransactionIndex;
28use cml_chain::{Epoch, NetworkId, Rational, RequiredSigners, UnitInterval, Withdrawals};
29use cml_core::ordered_hash_map::OrderedHashMap;
30use std::collections::BTreeMap;
31
32use self::cbor_encodings::AlonzoRedeemerEncoding;
33
34#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, schemars::JsonSchema)]
35pub enum AlonzoAuxiliaryData {
36 Shelley(ShelleyFormatAuxData),
37 ShelleyMA(ShelleyMAFormatAuxData),
38 Alonzo(AlonzoFormatAuxData),
39}
40
41impl AlonzoAuxiliaryData {
42 pub fn new_shelley(shelley: ShelleyFormatAuxData) -> Self {
43 Self::Shelley(shelley)
44 }
45
46 pub fn new_shelley_ma(shelley_ma: ShelleyMAFormatAuxData) -> Self {
47 Self::ShelleyMA(shelley_ma)
48 }
49
50 pub fn new_alonzo(alonzo: AlonzoFormatAuxData) -> Self {
51 Self::Alonzo(alonzo)
52 }
53}
54
55#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, schemars::JsonSchema)]
56pub struct AlonzoBlock {
57 pub header: ShelleyHeader,
58 pub transaction_bodies: Vec<AlonzoTransactionBody>,
59 pub transaction_witness_sets: Vec<AlonzoTransactionWitnessSet>,
60 pub auxiliary_data_set: OrderedHashMap<TransactionIndex, AlonzoAuxiliaryData>,
61 pub invalid_transactions: Vec<TransactionIndex>,
62 #[serde(skip)]
63 pub encodings: Option<AlonzoBlockEncoding>,
64}
65
66impl AlonzoBlock {
67 pub fn new(
68 header: ShelleyHeader,
69 transaction_bodies: Vec<AlonzoTransactionBody>,
70 transaction_witness_sets: Vec<AlonzoTransactionWitnessSet>,
71 auxiliary_data_set: OrderedHashMap<TransactionIndex, AlonzoAuxiliaryData>,
72 invalid_transactions: Vec<TransactionIndex>,
73 ) -> Self {
74 Self {
75 header,
76 transaction_bodies,
77 transaction_witness_sets,
78 auxiliary_data_set,
79 invalid_transactions,
80 encodings: None,
81 }
82 }
83}
84
85pub type AlonzoCostModels = CostModels;
86
87#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, schemars::JsonSchema)]
88pub struct AlonzoFormatAuxData {
89 pub metadata: Option<Metadata>,
90 pub native_scripts: Option<Vec<NativeScript>>,
91 pub plutus_v1_scripts: Option<Vec<PlutusV1Script>>,
92 #[serde(skip)]
93 pub encodings: Option<AlonzoFormatAuxDataEncoding>,
94}
95
96impl AlonzoFormatAuxData {
97 pub fn new() -> Self {
98 Self {
99 metadata: None,
100 native_scripts: None,
101 plutus_v1_scripts: None,
102 encodings: None,
103 }
104 }
105}
106
107impl Default for AlonzoFormatAuxData {
108 fn default() -> Self {
109 Self::new()
110 }
111}
112
113pub type AlonzoProposedProtocolParameterUpdates =
114 OrderedHashMap<GenesisHash, AlonzoProtocolParamUpdate>;
115
116#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, schemars::JsonSchema)]
117pub struct AlonzoProtocolParamUpdate {
118 pub minfee_a: Option<u64>,
119 pub minfee_b: Option<u64>,
120 pub max_block_body_size: Option<u64>,
121 pub max_transaction_size: Option<u64>,
122 pub max_block_header_size: Option<u64>,
123 pub key_deposit: Option<Coin>,
124 pub pool_deposit: Option<Coin>,
125 pub maximum_epoch: Option<Epoch>,
126 pub n_opt: Option<u64>,
127 pub pool_pledge_influence: Option<Rational>,
128 pub expansion_rate: Option<UnitInterval>,
129 pub treasury_growth_rate: Option<UnitInterval>,
130 pub decentralization_constant: Option<UnitInterval>,
131 pub extra_entropy: Option<Nonce>,
132 pub protocol_version: Option<ProtocolVersionStruct>,
133 pub min_pool_cost: Option<Coin>,
134 pub ada_per_utxo_byte: Option<Coin>,
135 pub cost_models_for_script_languages: Option<AlonzoCostModels>,
136 pub execution_costs: Option<ExUnitPrices>,
137 pub max_tx_ex_units: Option<ExUnits>,
138 pub max_block_ex_units: Option<ExUnits>,
139 pub max_value_size: Option<u64>,
140 pub collateral_percentage: Option<u64>,
141 pub max_collateral_inputs: Option<u64>,
142 #[serde(skip)]
143 pub encodings: Option<AlonzoProtocolParamUpdateEncoding>,
144}
145
146impl AlonzoProtocolParamUpdate {
147 pub fn new() -> Self {
148 Self {
149 minfee_a: None,
150 minfee_b: None,
151 max_block_body_size: None,
152 max_transaction_size: None,
153 max_block_header_size: None,
154 key_deposit: None,
155 pool_deposit: None,
156 maximum_epoch: None,
157 n_opt: None,
158 pool_pledge_influence: None,
159 expansion_rate: None,
160 treasury_growth_rate: None,
161 decentralization_constant: None,
162 extra_entropy: None,
163 protocol_version: None,
164 min_pool_cost: None,
165 ada_per_utxo_byte: None,
166 cost_models_for_script_languages: None,
167 execution_costs: None,
168 max_tx_ex_units: None,
169 max_block_ex_units: None,
170 max_value_size: None,
171 collateral_percentage: None,
172 max_collateral_inputs: None,
173 encodings: None,
174 }
175 }
176}
177
178impl Default for AlonzoProtocolParamUpdate {
179 fn default() -> Self {
180 Self::new()
181 }
182}
183
184#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, schemars::JsonSchema)]
185pub struct AlonzoRedeemer {
186 pub tag: AlonzoRedeemerTag,
187 pub index: u64,
188 pub data: PlutusData,
189 pub ex_units: ExUnits,
190 #[serde(skip)]
191 pub encodings: Option<AlonzoRedeemerEncoding>,
192}
193
194impl AlonzoRedeemer {
195 pub fn new(tag: AlonzoRedeemerTag, index: u64, data: PlutusData, ex_units: ExUnits) -> Self {
196 Self {
197 tag,
198 index,
199 data,
200 ex_units,
201 encodings: None,
202 }
203 }
204}
205
206#[derive(
207 Copy,
208 Eq,
209 PartialEq,
210 Ord,
211 PartialOrd,
212 Clone,
213 Debug,
214 serde::Deserialize,
215 serde::Serialize,
216 schemars::JsonSchema,
217)]
218#[wasm_bindgen]
219pub enum AlonzoRedeemerTag {
220 Spend,
221 Mint,
222 Cert,
223 Reward,
224}
225
226#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, schemars::JsonSchema)]
227pub struct AlonzoTransaction {
228 pub body: AlonzoTransactionBody,
229 pub witness_set: AlonzoTransactionWitnessSet,
230 pub is_valid: bool,
231 pub auxiliary_data: Option<AlonzoAuxiliaryData>,
232 #[serde(skip)]
233 pub encodings: Option<AlonzoTransactionEncoding>,
234}
235
236impl AlonzoTransaction {
237 pub fn new(
238 body: AlonzoTransactionBody,
239 witness_set: AlonzoTransactionWitnessSet,
240 is_valid: bool,
241 auxiliary_data: Option<AlonzoAuxiliaryData>,
242 ) -> Self {
243 Self {
244 body,
245 witness_set,
246 is_valid,
247 auxiliary_data,
248 encodings: None,
249 }
250 }
251}
252
253#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, schemars::JsonSchema)]
254pub struct AlonzoTransactionBody {
255 pub inputs: Vec<TransactionInput>,
256 pub outputs: Vec<AlonzoFormatTxOut>,
257 pub fee: Coin,
258 pub ttl: Option<u64>,
259 pub certs: Option<Vec<AllegraCertificate>>,
260 pub withdrawals: Option<Withdrawals>,
261 pub update: Option<AlonzoUpdate>,
262 pub auxiliary_data_hash: Option<AuxiliaryDataHash>,
263 pub validity_interval_start: Option<u64>,
264 pub mint: Option<Mint>,
265 pub script_data_hash: Option<ScriptDataHash>,
266 pub collateral_inputs: Option<Vec<TransactionInput>>,
267 pub required_signers: Option<RequiredSigners>,
268 pub network_id: Option<NetworkId>,
269 #[serde(skip)]
270 pub encodings: Option<AlonzoTransactionBodyEncoding>,
271}
272
273impl AlonzoTransactionBody {
274 pub fn new(inputs: Vec<TransactionInput>, outputs: Vec<AlonzoFormatTxOut>, fee: Coin) -> Self {
275 Self {
276 inputs,
277 outputs,
278 fee,
279 ttl: None,
280 certs: None,
281 withdrawals: None,
282 update: None,
283 auxiliary_data_hash: None,
284 validity_interval_start: None,
285 mint: None,
286 script_data_hash: None,
287 collateral_inputs: None,
288 required_signers: None,
289 network_id: None,
290 encodings: None,
291 }
292 }
293}
294
295#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, schemars::JsonSchema)]
296pub struct AlonzoTransactionWitnessSet {
297 pub vkeywitnesses: Option<Vec<Vkeywitness>>,
298 pub native_scripts: Option<Vec<NativeScript>>,
299 pub bootstrap_witnesses: Option<Vec<BootstrapWitness>>,
300 pub plutus_v1_scripts: Option<Vec<PlutusV1Script>>,
301 pub plutus_datums: Option<Vec<PlutusData>>,
302 pub redeemers: Option<Vec<AlonzoRedeemer>>,
303 #[serde(skip)]
304 pub encodings: Option<AlonzoTransactionWitnessSetEncoding>,
305}
306
307impl AlonzoTransactionWitnessSet {
308 pub fn new() -> Self {
309 Self {
310 vkeywitnesses: None,
311 native_scripts: None,
312 bootstrap_witnesses: None,
313 plutus_v1_scripts: None,
314 plutus_datums: None,
315 redeemers: None,
316 encodings: None,
317 }
318 }
319}
320
321impl Default for AlonzoTransactionWitnessSet {
322 fn default() -> Self {
323 Self::new()
324 }
325}
326
327#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, schemars::JsonSchema)]
328pub struct AlonzoUpdate {
329 pub proposed_protocol_parameter_updates: AlonzoProposedProtocolParameterUpdates,
330 pub epoch: Epoch,
331 #[serde(skip)]
332 pub encodings: Option<AlonzoUpdateEncoding>,
333}
334
335impl AlonzoUpdate {
336 pub fn new(
337 proposed_protocol_parameter_updates: AlonzoProposedProtocolParameterUpdates,
338 epoch: Epoch,
339 ) -> Self {
340 Self {
341 proposed_protocol_parameter_updates,
342 epoch,
343 encodings: None,
344 }
345 }
346}