whisky_pallas/wrapper/transaction_body/
required_signers.rs

1use std::str::FromStr;
2
3use pallas::{
4    codec::utils::NonEmptySet,
5    crypto::hash::Hash,
6    ledger::primitives::{conway::RequiredSigners as PallasRequiredSigners, Fragment},
7};
8use whisky_common::WError;
9
10#[derive(Debug, Clone)]
11pub struct RequiredSigners {
12    pub inner: PallasRequiredSigners,
13}
14
15impl RequiredSigners {
16    pub fn new(signers: Vec<String>) -> Result<Self, WError> {
17        let hashes: Result<Vec<_>, _> = signers
18            .iter()
19            .map(|signer| {
20                Hash::<28>::from_str(signer).map_err(|e| {
21                    WError::new(
22                        "RequiredSigners::new",
23                        &format!("Invalid signer hash: {}", e),
24                    )
25                })
26            })
27            .collect();
28
29        let hashes = hashes?;
30        let required_signers = NonEmptySet::from_vec(hashes).ok_or_else(|| {
31            WError::new(
32                "RequiredSigners::new",
33                "required signers has to be non empty",
34            )
35        })?;
36
37        Ok(Self {
38            inner: required_signers,
39        })
40    }
41
42    pub fn encode(&self) -> Result<String, WError> {
43        let encoded = self.inner.encode_fragment().map_err(|e| {
44            WError::new(
45                "RequiredSigners::encode",
46                &format!("Fragment encode error: {}", e),
47            )
48        })?;
49        Ok(hex::encode(encoded))
50    }
51
52    pub fn decode_bytes(bytes: &[u8]) -> Result<Self, WError> {
53        let inner = PallasRequiredSigners::decode_fragment(&bytes).map_err(|e| {
54            WError::new(
55                "RequiredSigners::decode_bytes",
56                &format!("Fragment decode error: {}", e.to_string()),
57            )
58        })?;
59        Ok(Self { inner })
60    }
61}