ave-core 0.9.0

Averiun Ledger core runtime and node API
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

use crate::model::common::contract::ContractError;
use thiserror::Error;

#[derive(Debug, Error, Clone)]
pub enum CompilerError {
    #[error("invalid contract path [{path}]: {details}")]
    InvalidContractPath { path: String, details: String },

    #[error("base64 decode failed: {details}")]
    Base64DecodeFailed { details: String },

    #[error("directory creation failed [{path}]: {details}")]
    DirectoryCreationFailed { path: String, details: String },

    #[error("file write failed [{path}]: {details}")]
    FileWriteFailed { path: String, details: String },

    #[error("file read failed [{path}]: {details}")]
    FileReadFailed { path: String, details: String },

    #[error("cargo build failed: {details}")]
    CargoBuildFailed { details: String },

    #[error("compilation failed")]
    CompilationFailed,

    #[error("missing helper: {name}")]
    MissingHelper { name: &'static str },

    #[error("contract register failed: {details}")]
    ContractRegisterFailed { details: String },

    #[error("toolchain fingerprint failed: {details}")]
    ToolchainFingerprintFailed { details: String },

    #[error("wasm precompile failed: {details}")]
    WasmPrecompileFailed { details: String },

    #[error("wasm deserialization failed: {details}")]
    WasmDeserializationFailed { details: String },

    #[error("invalid module: {kind}")]
    InvalidModule { kind: InvalidModuleKind },

    #[error("fuel limit error: {details}")]
    FuelLimitError { details: String },

    #[error("instantiation failed: {details}")]
    InstantiationFailed { details: String },

    #[error("entry point not found: {function}")]
    EntryPointNotFound { function: &'static str },

    #[error("contract execution failed: {details}")]
    ContractExecutionFailed { details: String },

    #[error("serialization error [{context}]: {details}")]
    SerializationError {
        context: &'static str,
        details: String,
    },

    #[error("invalid contract output: {details}")]
    InvalidContractOutput { details: String },

    #[error("memory allocation failed: {details}")]
    MemoryAllocationFailed { details: String },

    #[error("contract check failed: {error}")]
    ContractCheckFailed { error: String },
}

#[derive(Debug, Clone)]
pub enum InvalidModuleKind {
    UnknownImportFunction { name: String },
    NonFunctionImport { import_type: String },
    MissingImports { missing: Vec<String> },
}

impl std::fmt::Display for InvalidModuleKind {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::UnknownImportFunction { name } => {
                write!(
                    f,
                    "module has function '{}' that is not contemplated in the SDK",
                    name
                )
            }
            Self::NonFunctionImport { import_type } => {
                write!(
                    f,
                    "module has a '{}' import that is not a function",
                    import_type
                )
            }
            Self::MissingImports { missing } => {
                write!(
                    f,
                    "module is missing SDK imports: {}",
                    missing.join(", ")
                )
            }
        }
    }
}

impl From<ContractError> for CompilerError {
    fn from(error: ContractError) -> Self {
        match error {
            ContractError::MemoryAllocationFailed { details } => {
                Self::MemoryAllocationFailed { details }
            }
            ContractError::InvalidPointer { pointer } => {
                Self::MemoryAllocationFailed {
                    details: format!("invalid pointer: {}", pointer),
                }
            }
            ContractError::WriteOutOfBounds { offset, size } => {
                Self::MemoryAllocationFailed {
                    details: format!(
                        "write out of bounds: offset {} >= size {}",
                        offset, size
                    ),
                }
            }
            ContractError::AllocationTooLarge { size, max } => {
                Self::MemoryAllocationFailed {
                    details: format!(
                        "allocation size {} exceeds maximum of {} bytes",
                        size, max
                    ),
                }
            }
            ContractError::TotalMemoryExceeded { total, max } => {
                Self::MemoryAllocationFailed {
                    details: format!(
                        "total memory {} exceeds maximum of {} bytes",
                        total, max
                    ),
                }
            }
            ContractError::AllocationOverflow => Self::MemoryAllocationFailed {
                details: "memory allocation would overflow".to_string(),
            },
            ContractError::LinkerError { function, details } => {
                Self::InstantiationFailed {
                    details: format!(
                        "linker error [{}]: {}",
                        function, details
                    ),
                }
            }
        }
    }
}