tx3-cardano 0.1.0

Cardano compiler for tx3-lang protocols
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

pub use pallas::codec::utils::Int;
pub use pallas::ledger::primitives::{BigInt, BoundedBytes, Constr, MaybeIndefArray, PlutusData};
use tx3_lang::ir;

pub trait IntoData {
    fn into_data(&self) -> PlutusData;
}

pub trait TryIntoData {
    fn try_into_data(&self) -> Result<PlutusData, super::Error>;
}

macro_rules! constr {
    ($index:expr, $($field:expr),*) => {
        {
            let fields = vec![$($field.into_data()),*];
            $crate::compile::plutus_data::constr($index as u64, fields)
        }
    };
}

pub fn constr(index: u64, fields: Vec<PlutusData>) -> PlutusData {
    PlutusData::Constr(Constr {
        tag: 121 + index,
        any_constructor: None,
        fields: MaybeIndefArray::Def(fields),
    })
}

impl IntoData for () {
    fn into_data(&self) -> PlutusData {
        constr!(0,)
    }
}

impl IntoData for PlutusData {
    fn into_data(&self) -> PlutusData {
        self.clone()
    }
}

impl IntoData for bool {
    fn into_data(&self) -> PlutusData {
        PlutusData::BoundedBytes(BoundedBytes::from(vec![*self as u8]))
    }
}

impl IntoData for &str {
    fn into_data(&self) -> PlutusData {
        PlutusData::BoundedBytes(BoundedBytes::from(self.as_bytes().to_vec()))
    }
}

impl IntoData for &[u8] {
    fn into_data(&self) -> PlutusData {
        PlutusData::BoundedBytes(BoundedBytes::from(self.to_vec()))
    }
}

impl<const N: usize> IntoData for [u8; N] {
    fn into_data(&self) -> PlutusData {
        PlutusData::BoundedBytes(BoundedBytes::from(self.to_vec()))
    }
}

impl IntoData for Vec<u8> {
    fn into_data(&self) -> PlutusData {
        PlutusData::BoundedBytes(BoundedBytes::from(self.clone()))
    }
}

impl IntoData for u64 {
    fn into_data(&self) -> PlutusData {
        PlutusData::BigInt(BigInt::Int(Int::from(*self as i64)))
    }
}

impl IntoData for i64 {
    fn into_data(&self) -> PlutusData {
        PlutusData::BigInt(BigInt::Int(Int::from(*self)))
    }
}

impl IntoData for i128 {
    fn into_data(&self) -> PlutusData {
        let int = Int::try_from(*self).unwrap();
        PlutusData::BigInt(BigInt::Int(int))
    }
}

impl TryIntoData for ir::StructExpr {
    fn try_into_data(&self) -> Result<PlutusData, super::Error> {
        let fields = self
            .fields
            .iter()
            .map(TryIntoData::try_into_data)
            .collect::<Result<Vec<_>, _>>()?;

        Ok(constr(self.constructor as u64, fields))
    }
}

impl<T> IntoData for Option<T>
where
    T: IntoData,
{
    fn into_data(&self) -> PlutusData {
        match self {
            Some(value) => value.into_data(),
            None => ().into_data(),
        }
    }
}

impl<T> TryIntoData for Option<T>
where
    T: TryIntoData,
{
    fn try_into_data(&self) -> Result<PlutusData, super::Error> {
        match self {
            Some(value) => value.try_into_data(),
            None => Ok(().into_data()),
        }
    }
}

impl TryIntoData for ir::Expression {
    fn try_into_data(&self) -> Result<PlutusData, super::Error> {
        match self {
            ir::Expression::None => Ok(().into_data()),
            ir::Expression::Struct(x) => x.try_into_data(),
            ir::Expression::Bytes(x) => Ok(x.into_data()),
            ir::Expression::Number(x) => Ok(x.into_data()),
            ir::Expression::Bool(x) => Ok(x.into_data()),
            ir::Expression::String(x) => Ok(x.as_bytes().into_data()),
            ir::Expression::Address(x) => Ok(x.into_data()),
            ir::Expression::Hash(x) => Ok(x.into_data()),
            x => Err(super::Error::CoerceError(
                format!("{:?}", x),
                "PlutusData".to_string(),
            )),
        }
    }
}