whisky_js/wasm/utils/
address.rs

1use crate::*;
2use serde_json::{from_str, Value};
3use whisky_csl::csl;
4
5#[wasm_bindgen]
6pub fn deserialize_bech32_address(bech32_addr: &str) -> WasmDeserializedAddress {
7    let csl_address =
8        csl::BaseAddress::from_address(&csl::Address::from_bech32(bech32_addr).unwrap());
9    match csl_address {
10        Some(address) => {
11            let csl_key_hash = address
12                .payment_cred()
13                .to_keyhash()
14                .map(|key_hash| key_hash.to_hex());
15
16            let csl_script_hash = address
17                .payment_cred()
18                .to_scripthash()
19                .map(|script_hash| script_hash.to_hex());
20
21            let csl_stake_key_hash = address
22                .stake_cred()
23                .to_keyhash()
24                .map(|stake_key_hash| stake_key_hash.to_hex());
25
26            let csl_stake_key_script_hash = address
27                .stake_cred()
28                .to_scripthash()
29                .map(|stake_key_script_hash| stake_key_script_hash.to_hex());
30
31            WasmDeserializedAddress::new(
32                &csl_key_hash.unwrap_or("".to_string()),
33                &csl_script_hash.unwrap_or("".to_string()),
34                &csl_stake_key_hash.unwrap_or("".to_string()),
35                &csl_stake_key_script_hash.unwrap_or("".to_string()),
36            )
37        }
38        None => {
39            let csl_enterprize_address = csl::EnterpriseAddress::from_address(
40                &csl::Address::from_bech32(bech32_addr).unwrap(),
41            )
42            .unwrap();
43
44            let csl_key_hash = csl_enterprize_address
45                .payment_cred()
46                .to_keyhash()
47                .map(|key_hash| key_hash.to_hex());
48
49            let csl_script_hash = csl_enterprize_address
50                .payment_cred()
51                .to_scripthash()
52                .map(|script_hash| script_hash.to_hex());
53
54            WasmDeserializedAddress::new(
55                &csl_key_hash.unwrap_or("".to_string()),
56                &csl_script_hash.unwrap_or("".to_string()),
57                "",
58                "",
59            )
60        }
61    }
62}
63
64#[wasm_bindgen]
65pub fn parse_plutus_address_obj_to_bech32(plutus_data_address_obj: &str, network_id: u8) -> String {
66    let plutus_data_address: Value =
67        from_str(plutus_data_address_obj).expect("Invalid json string");
68    let plutus_data_key_obj = plutus_data_address.get("fields").unwrap();
69    let plutus_data_key_list = plutus_data_key_obj.as_array().unwrap();
70
71    let plutus_data_payment_key_obj = &plutus_data_key_list[0];
72    let plutus_data_stake_key_obj = &plutus_data_key_list[1];
73
74    let payment_key_hash = plutus_data_payment_key_obj["fields"][0]["bytes"]
75        .as_str()
76        .unwrap();
77
78    let csl_payment_credential =
79        if plutus_data_payment_key_obj["constructor"].as_u64().unwrap() == 0 {
80            csl::Credential::from_keyhash(&csl::Ed25519KeyHash::from_hex(payment_key_hash).unwrap())
81        } else {
82            csl::Credential::from_scripthash(&csl::ScriptHash::from_hex(payment_key_hash).unwrap())
83        };
84
85    if plutus_data_stake_key_obj["constructor"].as_u64().unwrap() == 0 {
86        let stake_key_hash = plutus_data_stake_key_obj["fields"][0]["fields"][0]["fields"][0]
87            ["bytes"]
88            .as_str()
89            .unwrap();
90        if plutus_data_stake_key_obj["fields"][0]["fields"][0]["constructor"]
91            .as_u64()
92            .unwrap()
93            == 0
94        {
95            csl::BaseAddress::new(
96                network_id,
97                &csl_payment_credential,
98                &csl::Credential::from_keyhash(
99                    &csl::Ed25519KeyHash::from_hex(stake_key_hash).unwrap(),
100                ),
101            )
102            .to_address()
103            .to_bech32(None)
104            .unwrap()
105        } else {
106            csl::BaseAddress::new(
107                network_id,
108                &csl_payment_credential,
109                &csl::Credential::from_scripthash(
110                    &csl::ScriptHash::from_hex(stake_key_hash).unwrap(),
111                ),
112            )
113            .to_address()
114            .to_bech32(None)
115            .unwrap()
116        }
117    } else {
118        csl::EnterpriseAddress::new(network_id, &csl_payment_credential)
119            .to_address()
120            .to_bech32(None)
121            .unwrap()
122    }
123}