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
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

use crate::NodePtr;
use thiserror::Error;

pub type Result<T> = std::result::Result<T, EvalErr>;

#[derive(Debug, Error, PartialEq)]
pub enum EvalErr {
    #[error("bad encoding")]
    SerializationError,

    #[error("invalid backreference during deserialisation")]
    SerializationBackreferenceError,

    #[error("Out of Memory")]
    OutOfMemory,

    #[error("path into atom")]
    PathIntoAtom,

    #[error("too many pairs")]
    TooManyPairs,

    #[error("Too Many Atoms")]
    TooManyAtoms,

    #[error("cost exceeded or below zero")]
    CostExceeded,

    #[error("unknown softfork extension")]
    UnknownSoftforkExtension,

    #[error("softfork specified cost mismatch")]
    SoftforkCostMismatch,

    #[error("Internal Error: {1}")]
    InternalError(NodePtr, String),

    #[error("clvm raise")]
    Raise(NodePtr),

    #[error("Invalid Nil Terminator in operand list")]
    InvalidNilTerminator(NodePtr),

    #[error("Division by zero")]
    DivisionByZero(NodePtr),

    #[error("Value Stack Limit Reached")]
    ValueStackLimitReached(NodePtr),

    #[error("Environment Stack Limit Reached")]
    EnvironmentStackLimitReached(NodePtr),

    #[error("Shift too large")]
    ShiftTooLarge(NodePtr),

    #[error("Reserved operator")]
    Reserved(NodePtr),

    #[error("invalid operator")]
    Invalid(NodePtr),

    #[error("unimplemented operator")]
    Unimplemented(NodePtr),

    #[error("InvalidOperatorArg: {1}")]
    InvalidOpArg(NodePtr, String),

    #[error("InvalidAllocatorArg: {1}")]
    InvalidAllocArg(NodePtr, String),

    #[error("bls_pairing_identity failed")]
    BLSPairingIdentityFailed(NodePtr),

    #[error("bls_verify failed")]
    BLSVerifyFailed(NodePtr),

    #[error("Secp256 Verify Error: failed")]
    Secp256Failed(NodePtr),

    #[error("softfork stack depth exceeded")]
    SoftforkStackDepthExceeded,
}
impl From<std::io::Error> for EvalErr {
    fn from(_: std::io::Error) -> Self {
        EvalErr::SerializationError
    }
}

impl EvalErr {
    fn node(&self) -> Option<NodePtr> {
        match self {
            EvalErr::InternalError(node, _) => Some(*node),
            EvalErr::Raise(node) => Some(*node),
            EvalErr::InvalidNilTerminator(node) => Some(*node),
            EvalErr::DivisionByZero(node) => Some(*node),
            EvalErr::ValueStackLimitReached(node) => Some(*node),
            EvalErr::EnvironmentStackLimitReached(node) => Some(*node),
            EvalErr::ShiftTooLarge(node) => Some(*node),
            EvalErr::Reserved(node) => Some(*node),
            EvalErr::Invalid(node) => Some(*node),
            EvalErr::Unimplemented(node) => Some(*node),
            EvalErr::InvalidOpArg(node, _) => Some(*node),
            EvalErr::InvalidAllocArg(node, _) => Some(*node),
            EvalErr::BLSPairingIdentityFailed(node) => Some(*node),
            EvalErr::BLSVerifyFailed(node) => Some(*node),
            EvalErr::Secp256Failed(node) => Some(*node),
            _ => None,
        }
    }

    pub fn node_ptr(&self) -> NodePtr {
        // This is a convenience function to get the node pointer
        self.node().unwrap_or_default()
    }
}