clvmr 0.18.0

Implementation of `clvm` for Chia Network's cryptocurrency
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

use crate::allocator::{Allocator, NodePtr, SExp};
use crate::chia_dialect::ClvmFlags;
use crate::cost::Cost;
use crate::error::{EvalErr, Result};
use crate::op_utils::{first, get_args, nilp, rest};
use crate::reduction::{Reduction, Response};

const FIRST_COST: Cost = 30;
const IF_COST: Cost = 33;
// Cons cost lowered from 245. It only allocates a pair, which is small
const CONS_COST: Cost = 50;
// Rest cost lowered from 77 since it doesn't allocate anything and it should be
// the same as first
const REST_COST: Cost = 30;
const LISTP_COST: Cost = 19;
const EQ_BASE_COST: Cost = 117;
const EQ_COST_PER_BYTE: Cost = 1;

pub fn op_if(a: &mut Allocator, input: NodePtr, _max_cost: Cost, _flags: ClvmFlags) -> Response {
    let [cond, affirmative, negative] = get_args::<3>(a, input, "i")?;
    let chosen_node = if nilp(a, cond) { negative } else { affirmative };
    Ok(Reduction(IF_COST, chosen_node))
}

pub fn op_cons(a: &mut Allocator, input: NodePtr, _max_cost: Cost, _flags: ClvmFlags) -> Response {
    let [n1, n2] = get_args::<2>(a, input, "c")?;
    let r = a.new_pair(n1, n2)?;
    Ok(Reduction(CONS_COST, r))
}

pub fn op_first(a: &mut Allocator, input: NodePtr, _max_cost: Cost, _flags: ClvmFlags) -> Response {
    let [n] = get_args::<1>(a, input, "f")?;
    Ok(Reduction(FIRST_COST, first(a, n)?))
}

pub fn op_rest(a: &mut Allocator, input: NodePtr, _max_cost: Cost, _flags: ClvmFlags) -> Response {
    let [n] = get_args::<1>(a, input, "r")?;
    Ok(Reduction(REST_COST, rest(a, n)?))
}

pub fn op_listp(a: &mut Allocator, input: NodePtr, _max_cost: Cost, _flags: ClvmFlags) -> Response {
    let [n] = get_args::<1>(a, input, "l")?;
    match a.sexp(n) {
        SExp::Pair(_, _) => Ok(Reduction(LISTP_COST, a.one())),
        _ => Ok(Reduction(LISTP_COST, a.nil())),
    }
}

pub fn op_raise(a: &mut Allocator, input: NodePtr, _max_cost: Cost, _flags: ClvmFlags) -> Response {
    // if given a single argument we should raise the single argument rather
    // than the full list of arguments. brun also used to behave this way.
    // if the single argument here is a pair then don't throw it unwrapped
    // as it'd potentially look the same as a throw of multiple arguments.
    let throw_value = if let Ok([value]) = get_args::<1>(a, input, "") {
        match a.sexp(value) {
            SExp::Atom => value,
            _ => input,
        }
    } else {
        input
    };

    Err(EvalErr::Raise(throw_value))
}

fn ensure_atom(a: &Allocator, n: NodePtr, op: &str) -> Result<()> {
    if let SExp::Atom = a.sexp(n) {
        Ok(())
    } else {
        Err(EvalErr::InvalidOpArg(n, format!("{op} used on list")))?
    }
}

pub fn op_eq(a: &mut Allocator, input: NodePtr, _max_cost: Cost, _flags: ClvmFlags) -> Response {
    let [s0, s1] = get_args::<2>(a, input, "=")?;
    ensure_atom(a, s0, "=")?;
    ensure_atom(a, s1, "=")?;
    let eq = a.atom_eq(s0, s1);
    let cost = EQ_BASE_COST + (a.atom_len(s0) as Cost + a.atom_len(s1) as Cost) * EQ_COST_PER_BYTE;
    Ok(Reduction(cost, if eq { a.one() } else { a.nil() }))
}