whisky-csl 1.0.23

Wrapper around the cardano-serialization-lib for easier transaction building, heavily inspired by cardano-cli APIs
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

use cardano_serialization_lib::{self as csl};
use whisky_common::{DeserializedAddress, WError};

pub fn script_to_address(
    network_id: u8,
    script_hash: &str,
    stake_hash: Option<(&str, bool)>,
) -> String {
    match stake_hash {
        Some((stake, is_script)) => {
            let stake_cred = if is_script {
                csl::Credential::from_scripthash(&csl::ScriptHash::from_hex(stake).unwrap())
            } else {
                csl::Credential::from_keyhash(&csl::Ed25519KeyHash::from_hex(stake).unwrap())
            };

            csl::BaseAddress::new(
                network_id,
                &csl::Credential::from_scripthash(&csl::ScriptHash::from_hex(script_hash).unwrap()),
                &stake_cred,
            )
            .to_address()
            .to_bech32(None)
            .unwrap()
        }

        None => csl::EnterpriseAddress::new(
            network_id,
            &csl::Credential::from_scripthash(&csl::ScriptHash::from_hex(script_hash).unwrap()),
        )
        .to_address()
        .to_bech32(None)
        .unwrap(),
    }
}

pub fn serialize_address_obj(
    address_obj: DeserializedAddress,
    network_id: u8,
) -> Result<String, WError> {
    let payment_cred = match (
        address_obj.pub_key_hash.as_str(),
        address_obj.script_hash.as_str(),
    ) {
        (pub_key_hash, "") => {
            csl::Credential::from_keyhash(&csl::Ed25519KeyHash::from_hex(pub_key_hash).unwrap())
        }
        ("", script_hash) => {
            csl::Credential::from_scripthash(&csl::ScriptHash::from_hex(script_hash).unwrap())
        }
        _ => Err(WError::new(
            "serialze_address_obj",
            &format!(
                "Must provide exactly one of pub_key_hash or script_hash, pub_key_hash: {}, script_hash: {}",
                address_obj.pub_key_hash, address_obj.script_hash
            ),
        ))?,
    };

    let stake_cred_opt = match (
        address_obj.stake_key_hash.as_str(),
        address_obj.stake_key_script_hash.as_str(),
    ) {
        ("", "") => None,
        (stake_key_hash, "") => Some(csl::Credential::from_keyhash(
            &csl::Ed25519KeyHash::from_hex(stake_key_hash).unwrap(),
        )),
        ("", stake_key_script_hash) => Some(csl::Credential::from_scripthash(
            &csl::ScriptHash::from_hex(stake_key_script_hash).unwrap(),
        )),
        _ => Err(WError::new(
            "serialze_address_obj",
            &format!(
                "Invalid address object, stake_key_hash: {}, stake_key_script_hash: {}",
                address_obj.stake_key_hash, address_obj.stake_key_script_hash
            ),
        ))?,
    };

    match stake_cred_opt {
        Some(stake_cred) => {
            let base_address = csl::BaseAddress::new(network_id, &payment_cred, &stake_cred)
                .to_address()
                .to_bech32(None)
                .unwrap();
            Ok(base_address)
        }
        None => {
            let enterprise_address = csl::EnterpriseAddress::new(network_id, &payment_cred)
                .to_address()
                .to_bech32(None)
                .unwrap();
            Ok(enterprise_address)
        }
    }
}

pub fn deserialize_address(bech32_addr: &str) -> DeserializedAddress {
    let csl_address =
        csl::BaseAddress::from_address(&csl::Address::from_bech32(bech32_addr).unwrap());
    match csl_address {
        Some(address) => {
            let csl_key_hash = address
                .payment_cred()
                .to_keyhash()
                .map(|key_hash| key_hash.to_hex());

            let csl_script_hash = address
                .payment_cred()
                .to_scripthash()
                .map(|script_hash| script_hash.to_hex());

            let csl_stake_key_hash = address
                .stake_cred()
                .to_keyhash()
                .map(|stake_key_hash| stake_key_hash.to_hex());

            let csl_stake_key_script_hash = address
                .stake_cred()
                .to_scripthash()
                .map(|stake_key_script_hash| stake_key_script_hash.to_hex());

            DeserializedAddress::new(
                &csl_key_hash.unwrap_or("".to_string()),
                &csl_script_hash.unwrap_or("".to_string()),
                &csl_stake_key_hash.unwrap_or("".to_string()),
                &csl_stake_key_script_hash.unwrap_or("".to_string()),
            )
        }
        None => {
            let csl_enterprize_address = csl::EnterpriseAddress::from_address(
                &csl::Address::from_bech32(bech32_addr).unwrap(),
            )
            .unwrap();

            let csl_key_hash = csl_enterprize_address
                .payment_cred()
                .to_keyhash()
                .map(|key_hash| key_hash.to_hex());

            let csl_script_hash = csl_enterprize_address
                .payment_cred()
                .to_scripthash()
                .map(|script_hash| script_hash.to_hex());

            DeserializedAddress::new(
                &csl_key_hash.unwrap_or("".to_string()),
                &csl_script_hash.unwrap_or("".to_string()),
                "",
                "",
            )
        }
    }
}