whisky 1.0.25

The Cardano Rust SDK, inspired by MeshJS
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

use crate::*;
use uplc::tx::SlotConfig;

use super::{TxBuilder, TxEvaluation};

impl TxBuilder {
    /// ## Transaction building method
    ///  
    /// Complete the transaction building process with fetching missing information & tx evaluation
    ///
    /// ### Arguments
    ///
    /// * `customized_tx` - An optional customized transaction body
    ///
    /// ### Returns
    ///
    /// * `Self` - The TxBuilder instance
    pub async fn complete(
        &mut self,
        customized_tx: Option<TxBuilderBody>,
    ) -> Result<&mut Self, WError> {
        self.complete_sync(customized_tx)?;
        match &self.evaluator {
            Some(evaluator) => {
                let network = match &self.tx_builder_body.network {
                    Some(builder_network) => builder_network,
                    None => &Network::Mainnet,
                };
                let inputs_for_evaluation: Vec<_> =
                    self.inputs_for_evaluation.values().cloned().collect();
                let tx_evaluation_result = evaluator
                    .evaluate_tx(
                        &self.serializer.tx_hex(),
                        &inputs_for_evaluation,
                        &self.chained_txs.clone(),
                        network,
                        &SlotConfig::default(), // TODO: accept slot config as argument for evaluator
                    )
                    .await;
                match tx_evaluation_result {
                    Ok(actions) => self.update_redeemer(actions),
                    Err(err) => {
                        return Err(WError::new(
                            "TxBuilder - complete",
                            &format!(
                        "Error evaluating transaction - tx_hex: [ {} ] , Error message: [ {:?} ]",
                        self.tx_hex(),
                        err
                    ),
                        ))
                    }
                }
            }
            None => self,
        };
        self.complete_sync(None)
    }

    /// ## Transaction building method
    ///
    /// Complete the transaction building process synchronously
    ///
    /// ### Arguments
    ///
    /// * `customized_tx` - An optional customized transaction body
    ///
    /// ### Returns
    ///
    /// * `Self` - The TxBuilder instance
    pub fn complete_sync(
        &mut self,
        customized_tx: Option<TxBuilderBody>,
    ) -> Result<&mut Self, WError> {
        if customized_tx.is_some() {
            self.tx_builder_body = customized_tx.unwrap();
        } else {
            self.queue_all_last_item();
            if !self.extra_inputs.is_empty() {
                self.add_utxos_from(self.extra_inputs.clone(), self.selection_threshold)?;
            }
        }

        self.tx_builder_body.mints.sort_by(|a, b| {
            let a_mint = match a {
                MintItem::ScriptMint(a_script_mint) => &a_script_mint.mint,
                MintItem::SimpleScriptMint(a_simple_script_mint) => &a_simple_script_mint.mint,
            };
            let b_mint = match b {
                MintItem::ScriptMint(b_script_mint) => &b_script_mint.mint,
                MintItem::SimpleScriptMint(b_simple_script_mint) => &b_simple_script_mint.mint,
            };
            a_mint.policy_id.cmp(&b_mint.policy_id)
        });

        self.tx_builder_body.inputs.sort_by(|a, b| {
            let tx_in_data_a: &TxInParameter = match a {
                TxIn::PubKeyTxIn(pub_key_tx_in) => &pub_key_tx_in.tx_in,
                TxIn::SimpleScriptTxIn(simple_script_tx_in) => &simple_script_tx_in.tx_in,
                TxIn::ScriptTxIn(script_tx_in) => &script_tx_in.tx_in,
            };

            let tx_in_data_b: &TxInParameter = match b {
                TxIn::PubKeyTxIn(pub_key_tx_in) => &pub_key_tx_in.tx_in,
                TxIn::SimpleScriptTxIn(simple_script_tx_in) => &simple_script_tx_in.tx_in,
                TxIn::ScriptTxIn(script_tx_in) => &script_tx_in.tx_in,
            };

            tx_in_data_a
                .tx_hash
                .cmp(&tx_in_data_b.tx_hash)
                .then_with(|| tx_in_data_a.tx_index.cmp(&tx_in_data_b.tx_index))
        });
        self.serializer
            .set_protocol_params(self.protocol_params.clone().unwrap_or_default());
        self.serializer
            .set_tx_builder_body(self.tx_builder_body.clone());
        let tx_hex = self.serializer.serialize_tx_body()?;
        self.serializer.set_tx_hex(tx_hex);
        self.serializer.reset_builder();
        Ok(self)
    }

    /// ## Transaction building method
    ///
    /// Complete the signing process
    ///
    /// ### Returns
    ///
    /// * `String` - The signed transaction in hex
    pub fn complete_signing(&mut self) -> Result<String, WError> {
        self.serializer.complete_signing()
    }

    /// ## Transaction building method
    ///
    /// Obtain the transaction hex
    ///
    /// ### Returns
    ///
    /// * tx_hex - The current transaction hex from build
    pub fn tx_hex(&mut self) -> String {
        self.serializer.tx_hex()
    }
}