whisky_pallas/utils/
aiken.rs

1use pallas_primitives::PlutusScript;
2use uplc::{Fragment, PlutusData};
3use whisky_common::{BuilderDataType, WError};
4
5use crate::utils::encode_json_str_to_plutus_datum;
6
7pub fn apply_double_cbor_encoding(script: &str) -> Result<String, WError> {
8    let bytes: Vec<u8> = hex::decode(script).map_err(|e| {
9        WError::new(
10            "apply_double_cbor_encoding - invalid script bytes",
11            &format!("Hex decode error: {}", e.to_string()),
12        )
13    })?;
14
15    let single_encoded_script =
16        PlutusScript::<3>::decode_fragment(&bytes.clone()).map_err(|e| {
17            WError::new(
18                "apply_double_cbor_encoding - invalid script bytes",
19                &format!("PlutusScript decode error: {}", e.to_string()),
20            )
21        })?;
22
23    let encoded_bytes = single_encoded_script.encode_fragment().map_err(|e| {
24        WError::new(
25            "apply_double_cbor_encoding - invalid script bytes",
26            &format!("PlutusScript encode error: {}", e.to_string()),
27        )
28    })?;
29
30    Ok(hex::encode(encoded_bytes))
31}
32
33pub fn apply_params_to_script(
34    plutus_script: &str,
35    params_to_apply: &[&str],
36    param_type: BuilderDataType,
37) -> Result<String, WError> {
38    let double_encoded_script = apply_double_cbor_encoding(plutus_script)?;
39    let plutus_script =
40        PlutusScript::<3>::decode_fragment(&hex::decode(&double_encoded_script).map_err(|e| {
41            WError::new(
42                "apply_params_to_script - invalid script bytes",
43                &format!("Hex decode error: {}", e.to_string()),
44            )
45        })?)
46        .map_err(|e| {
47            WError::new(
48                "apply_params_to_script - invalid script bytes",
49                &format!("PlutusScript decode error: {}", e.to_string()),
50            )
51        })?;
52
53    let mut plutus_list: Vec<PlutusData> = vec![];
54    for param in params_to_apply {
55        match param_type {
56            BuilderDataType::JSON => {
57                let plutus_data = encode_json_str_to_plutus_datum(param).map_err(|e| {
58                    WError::new(
59                        "apply_params_to_script - invalid parameter",
60                        &format!("JSON to PlutusData error: {}", e.to_string()),
61                    )
62                })?;
63                plutus_list.push(plutus_data);
64            }
65            BuilderDataType::CBOR => {
66                let plutus_data =
67                    PlutusData::decode_fragment(&hex::decode(param).map_err(|e| {
68                        WError::new(
69                            "apply_params_to_script - invalid parameter",
70                            &format!("Hex decode error: {}", e.to_string()),
71                        )
72                    })?)
73                    .map_err(|e| {
74                        WError::new(
75                            "apply_params_to_script - invalid parameter",
76                            &format!("PlutusData decode error: {}", e.to_string()),
77                        )
78                    })?;
79                plutus_list.push(plutus_data);
80            }
81        }
82    }
83
84    let bytes = uplc::tx::apply_params_to_script(
85        &plutus_list.encode_fragment().map_err(|e| {
86            WError::new(
87                "apply_params_to_script - invalid parameters",
88                &format!("PlutusData encode error: {}", e.to_string()),
89            )
90        })?,
91        &plutus_script.encode_fragment().map_err(|e| {
92            WError::new(
93                "apply_params_to_script - invalid script bytes",
94                &format!("PlutusScript encode error: {}", e.to_string()),
95            )
96        })?,
97    )
98    .map_err(|e| {
99        WError::new(
100            "apply_params_to_script - applying parameters to script failed",
101            &format!("Apply params error: {}", e.to_string()),
102        )
103    })?;
104
105    Ok(hex::encode(bytes))
106}