whisky-common 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

use super::TxTester;

impl TxTester {
    /// ## Testing methods for mints
    ///
    /// Checks if a specific token is minted in the transaction.
    pub fn token_minted(&mut self, policy_id: &str, asset_name: &str, quantity: i128) -> &mut Self {
        let is_token_minted = self.token_minted_logic(policy_id, asset_name, quantity);

        if !is_token_minted {
            self.add_trace(
                "token_minted",
                &format!(
                    "Token with policy_id: {}, asset_name: {}, quantity: {} not found in mints.",
                    policy_id, asset_name, quantity
                ),
            );
        }

        self
    }

    /// ## Testing methods for mints
    ///
    /// Checks if a specific token is minted in the transaction and that it is the only mint.
    pub fn only_token_minted(
        &mut self,
        policy_id: &str,
        asset_name: &str,
        quantity: i128,
    ) -> &mut Self {
        let is_token_minted = self.token_minted_logic(policy_id, asset_name, quantity);
        let is_only_one_mint = self.tx_body.mints.len() == 1;

        if !is_token_minted {
            self.add_trace(
                "only_token_minted",
                &format!(
                    "Token with policy_id: {}, asset_name: {}, quantity: {} not found in mints",
                    policy_id, asset_name, quantity
                ),
            );
        }
        if !is_only_one_mint {
            self.add_trace(
                "only_token_minted",
                &format!(
                    "Expected only one mint, but found {} mints.",
                    self.tx_body.mints.len()
                ),
            );
        }
        self
    }

    /// ## Testing methods for mints
    ///
    /// Checks if a specific token is minted in the transaction, ensuring that it is the only mint for the given policy ID.
    pub fn policy_only_minted_token(
        &mut self,
        policy_id: &str,
        asset_name: &str,
        quantity: i128,
    ) -> &mut Self {
        let filtered_mints: Vec<_> = self
            .tx_body
            .mints
            .iter()
            .filter(|token| {
                let mint_param = token.get_mint_parameter();
                mint_param.policy_id == policy_id
            })
            .collect();

        let is_token_minted = self.token_minted_logic(policy_id, asset_name, quantity);
        let is_only_one_mint = filtered_mints.len() == 1;
        if !is_only_one_mint {
            self.add_trace(
                "policy_only_minted_token",
                &format!(
                    "Expected only one mint for policy_id: {}, but found {} mints.",
                    policy_id,
                    filtered_mints.len()
                ),
            );
        }
        if !is_token_minted {
            self.add_trace(
                "policy_only_minted_token",
                &format!(
                    "Token with policy_id: {}, asset_name: {}, quantity: {} not found in mints.",
                    policy_id, asset_name, quantity
                ),
            );
        }
        self
    }

    /// ## Testing methods for mints
    ///
    /// Checks if a specific policy ID is burned in the transaction, ensuring that it is the only minting (i.e. burning item).
    pub fn check_policy_only_burn(&self, policy_id: &str) -> bool {
        let filtered_mints: Vec<_> = self
            .tx_body
            .mints
            .iter()
            .filter(|token| {
                let mint_param = token.get_mint_parameter();
                mint_param.policy_id == policy_id && mint_param.amount > 0
            })
            .collect();
        filtered_mints.len() == 0
    }

    pub fn token_minted_logic(&self, policy_id: &str, asset_name: &str, quantity: i128) -> bool {
        self.tx_body.mints.iter().any(|token| {
            let mint_param = token.get_mint_parameter();
            mint_param.policy_id == policy_id
                && mint_param.asset_name == asset_name
                && mint_param.amount == quantity
        })
    }
}