tx3-tir 0.17.0

Artifacts for the Tx3 Transaction Intermediate Representation (TIR)
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

use crate::{
    encoding::{AnyTir, TirVersion},
    model::v1beta0,
    Visitor,
};
use serde::{de::DeserializeOwned, Serialize};

#[derive(Debug, thiserror::Error)]
pub enum Error {
    #[error("unsupported TIR version: {0}")]
    UnsupportedTirVersion(TirVersion),

    #[error("error coercing {0} into {1}")]
    CoerceError(String, String),

    #[error("format error {0}")]
    FormatError(String),

    #[error("missing expression: {0}")]
    MissingExpression(String),

    #[error("consistency error: {0}")]
    ConsistencyError(String),
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct CompiledTx {
    pub payload: Vec<u8>,
    pub hash: Vec<u8>,
    pub fee: u64,
    pub ex_units: u64,
}

pub trait Compiler: Serialize + DeserializeOwned {
    type CompilerOp;
    type Expression;

    fn compile(&mut self, tir: &AnyTir) -> Result<CompiledTx, Error>;
    fn reduce_op(&self, op: Self::CompilerOp) -> Result<Self::Expression, crate::reduce::Error>;
}

impl<C> Visitor for C
where
    C: Compiler<Expression = v1beta0::Expression, CompilerOp = v1beta0::CompilerOp>,
{
    fn reduce(
        &mut self,
        expr: v1beta0::Expression,
    ) -> Result<v1beta0::Expression, crate::reduce::Error> {
        match expr {
            v1beta0::Expression::EvalCompiler(op) => Ok(self.reduce_op(*op)?),
            _ => Ok(expr),
        }
    }
}