clvm_tools_rs 0.4.0

tools for working with chialisp language; compiler, repl, python and wasm bindings
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

use num::BigInt;

use pyo3::types::{PyAny, PyBytes, PyList, PyTuple};
use pyo3::{prelude::*, IntoPyObjectExt};

use std::borrow::Borrow;
use std::ffi::CString;
use std::rc::Rc;

use crate::classic::clvm::__type_compatibility__::bi_zero;
use crate::compiler::runtypes::RunFailure;
use crate::compiler::sexp::SExp;
use crate::compiler::srcloc::Srcloc;

pub fn map_err_to_pyerr<PA>(srcloc: Srcloc, r: PyResult<PA>) -> Result<PA, RunFailure> {
    r.map_err(|e| RunFailure::RunErr(srcloc, format!("{e}")))
}

pub fn python_value_to_clvm(val: Bound<'_, PyAny>) -> Result<Rc<SExp>, RunFailure> {
    let srcloc = Srcloc::start("*python*");
    val.downcast::<PyList>()
        .ok()
        .map(|l| {
            if l.is_empty() {
                Ok(Rc::new(SExp::Nil(srcloc.clone())))
            } else {
                let mut result = SExp::Nil(srcloc.clone());
                for i_rev in 0..l.len() {
                    let i = l.len() - i_rev - 1;
                    let any_of_elt = map_err_to_pyerr(srcloc.clone(), l.get_item(i))?;
                    result = SExp::Cons(
                        srcloc.clone(),
                        python_value_to_clvm(any_of_elt)?,
                        Rc::new(result),
                    );
                }
                Ok(Rc::new(result))
            }
        })
        .map(Some)
        .unwrap_or_else(|| {
            val.downcast::<PyTuple>()
                .map(|t| {
                    if t.len() != 2 {
                        Err(RunFailure::RunErr(
                            srcloc.clone(),
                            "tuple must have len 2".to_string(),
                        ))
                    } else {
                        let any_of_e0 = map_err_to_pyerr(srcloc.clone(), t.get_item(0))?;
                        let any_of_e1 = map_err_to_pyerr(srcloc.clone(), t.get_item(1))?;
                        Ok(Rc::new(SExp::Cons(
                            srcloc.clone(),
                            python_value_to_clvm(any_of_e0)?,
                            python_value_to_clvm(any_of_e1)?,
                        )))
                    }
                })
                .ok()
        })
        .map(Some)
        .unwrap_or_else(|| {
            val.downcast::<PyBytes>()
                .map(|b| Ok(Rc::new(SExp::Atom(srcloc.clone(), b.as_bytes().to_vec()))))
                .ok()
        })
        .map(Some)
        .unwrap_or_else(|| {
            let stringified = format!("{val}");
            stringified
                .parse::<BigInt>()
                .map(|i| {
                    if i == bi_zero() {
                        Ok(Rc::new(SExp::Nil(srcloc.clone())))
                    } else {
                        Ok(Rc::new(SExp::Integer(srcloc.clone(), i)))
                    }
                })
                .ok()
        })
        .unwrap_or_else(|| {
            Err(RunFailure::RunErr(
                srcloc.clone(),
                "no way to convert python value to clvm".to_string(),
            ))
        })
}

pub fn clvm_value_to_python(py: Python, val: Rc<SExp>) -> PyResult<Py<PyAny>> {
    val.proper_list()
        .map(|lst| {
            let mut vallist = Vec::new();
            for i in lst {
                vallist.push(clvm_value_to_python(py, Rc::new(i.clone()))?);
            }
            PyList::new(py, &vallist)?.into_py_any(py)
        })
        .unwrap_or_else(|| match val.borrow() {
            SExp::Cons(_, a, b) => PyTuple::new(
                py,
                vec![
                    clvm_value_to_python(py, a.clone())?,
                    clvm_value_to_python(py, b.clone())?,
                ],
            )?
            .into_py_any(py),
            SExp::Integer(_, i) => {
                let int_val: Py<PyAny> = map_err_to_pyerr(
                    val.loc(),
                    py.eval(&CString::new(format!("int({i})")).unwrap(), None, None)
                        .map(|x| x.into_py_any(py))?,
                )
                .unwrap();
                Ok(int_val)
            }
            SExp::Atom(_, v) => PyBytes::new(py, v).into_py_any(py),
            SExp::QuotedString(_, _, v) => PyBytes::new(py, v).into_py_any(py),
            SExp::Nil(_) => {
                let emptybytes: Vec<u8> = vec![];
                PyList::new(py, &emptybytes)?.into_py_any(py)
            }
        })
}