dg_xch_core 2.1.1

Core library containing type/error definitions, CLVM tools, Consensus and Pool definitions
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

use crate::clvm::sexp::SExp;
use crate::formatting::{i32_from_slice, number_from_slice};
use num_bigint::BigInt;
use std::io::{Error, ErrorKind};

pub const NO_NEG_DIV: u32 = 0x0001;
pub const NO_UNKNOWN_OPS: u32 = 0x0002;
pub const COND_CANON_INTS: u32 = 0x0001_0000;
pub const NO_UNKNOWN_CONDS: u32 = 0x20000;
pub const COND_ARGS_NIL: u32 = 0x40000;
pub const STRICT_ARGS_COUNT: u32 = 0x80000;
pub const MEMPOOL_MODE: u32 =
    NO_NEG_DIV | COND_CANON_INTS | NO_UNKNOWN_CONDS | NO_UNKNOWN_OPS | COND_ARGS_NIL;
pub const INFINITE_COST: u64 = 0x7FFF_FFFF_FFFF_FFFF;

pub fn check_cost(cost: u64, max_cost: u64) -> Result<(), Error> {
    if cost > max_cost {
        Err(Error::new(
            ErrorKind::InvalidData,
            format!("cost {cost} exceeded {max_cost}"),
        ))
    } else {
        Ok(())
    }
}

pub fn check_arg_count(args: &SExp, expected: usize, name: &str) -> Result<(), Error> {
    if args.arg_count(expected) == expected {
        Ok(())
    } else {
        Err(Error::new(
            ErrorKind::InvalidData,
            format!(
                "{name} takes exactly {expected} argument{}",
                if expected == 1 { "" } else { "s" }
            ),
        ))
    }
}

pub fn int_atom<'a>(args: &'a SExp, op_name: &str) -> Result<&'a [u8], Error> {
    args.atom().map(|b| b.data.as_slice()).map_err(|_| {
        Error::new(
            ErrorKind::InvalidInput,
            format!("{op_name} requires int args: Got {args}"),
        )
    })
}

pub fn atom<'a>(args: &'a SExp, op_name: &str) -> Result<&'a [u8], Error> {
    args.atom()
        .map(|b| b.data.as_slice())
        .map_err(|_| Error::new(ErrorKind::InvalidInput, format!("{op_name} on list")))
}

pub fn two_ints(args: &SExp, op_name: &str) -> Result<(BigInt, usize, BigInt, usize), Error> {
    check_arg_count(args, 2, op_name)?;
    let a0 = args.first()?;
    let a1 = args.rest()?.first()?;
    let n0 = int_atom(a0, op_name)?;
    let n1 = int_atom(a1, op_name)?;
    Ok((
        number_from_slice(n0),
        n0.len(),
        number_from_slice(n1),
        n1.len(),
    ))
}

pub fn i32_atom(args: &SExp, op_name: &str) -> Result<i32, Error> {
    let Ok(buf) = args.atom() else {
        return Err(Error::new(
            ErrorKind::InvalidData,
            format!("{op_name} requires int32 args"),
        ));
    };
    match i32_from_slice(&buf.data) {
        Some(v) => Ok(v),
        _ => Err(Error::new(
            ErrorKind::InvalidData,
            format!("{op_name} requires int32 args (with no leading zeros)"),
        )),
    }
}