dusk-rusk 1.6.0

Rusk is the Dusk Network node implementation
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

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
//
// Copyright (c) DUSK NETWORK. All rights reserved.

use std::io;

use dusk_bytes::Serializable;
use dusk_core::signatures::bls::PublicKey as BlsPublicKey;
use dusk_core::transfer::phoenix::CoreError as PhoenixError;
use dusk_core::{BlsScalar, Error as ExecErr};
use dusk_vm::Error as VMError;

#[derive(Debug, thiserror::Error)]
pub enum Error {
    /// Out of gas in block execution
    #[error("Out of gas")]
    OutOfGas,
    /// Repeated nullifier in transaction verification
    #[error("Nullifiers already spent: {0:?}")]
    RepeatingNullifiers(Vec<BlsScalar>),
    /// Repeated nullifier in the same transaction
    #[error("Double nullifiers")]
    DoubleNullifiers,
    /// Repeating a nonce that has already been used
    #[error("Nonce repeat: {} {1}", bs58::encode(.0.to_bytes()).into_string())]
    RepeatingNonce(Box<BlsPublicKey>, u64),
    /// Wrong inputs and/or outputs in the transaction verification
    #[error("Expected: 0 < (inputs: {0}) < 5, 0 ≤ (outputs: {1}) < 3")]
    InvalidCircuitArguments(usize, usize),
    /// Failed to fetch opening
    #[error("Failed to fetch opening of position {0}")]
    OpeningPositionNotFound(u64),
    /// Bytes Serialization Errors
    #[error("Serialization Error: {0:?}")]
    Serialization(dusk_bytes::Error),
    /// Originating from transaction-creation
    #[error("Transaction Error: {0}")]
    Transaction(ExecErr),
    /// Originating from Phoenix.
    #[error("Phoenix Error: {0}")]
    Phoenix(PhoenixError),
    /// Piecrust VM internal Errors
    #[error("VM Error: {0}")]
    Vm(#[from] VMError),
    /// IO Errors
    #[error("IO Error: {0}")]
    Io(#[from] io::Error),
    /// Other
    #[error("Other Error: {0}")]
    Other(#[from] Box<dyn std::error::Error>),
    /// Commit not found amongst existing commits
    #[error("Commit not found, id = {}", hex::encode(.0))]
    CommitNotFound([u8; 32]),
    /// Invalid credits count
    #[error("Invalid credits: H= {0}, credits= {1}")]
    InvalidCreditsCount(u64, usize),
    /// Memo too large
    #[error("The memo size {0} is too large")]
    MemoTooLarge(usize),
    /// Blob related errors
    #[error("Blob error: {0}")]
    Blob(String),
}

impl From<dusk_core::Error> for Error {
    fn from(err: ExecErr) -> Self {
        match err {
            ExecErr::InsufficientBalance => {
                Self::Transaction(ExecErr::InsufficientBalance)
            }
            ExecErr::Replay => Self::Transaction(ExecErr::Replay),
            ExecErr::PhoenixOwnership => {
                Self::Transaction(ExecErr::PhoenixOwnership)
            }
            ExecErr::PhoenixCircuit(e) => {
                Self::Transaction(ExecErr::PhoenixCircuit(e))
            }
            ExecErr::PhoenixProver(e) => {
                Self::Transaction(ExecErr::PhoenixProver(e))
            }
            ExecErr::InvalidData => {
                Self::Serialization(dusk_bytes::Error::InvalidData)
            }
            ExecErr::BadLength(found, expected) => {
                Self::Serialization(dusk_bytes::Error::BadLength {
                    found,
                    expected,
                })
            }
            ExecErr::InvalidChar(ch, index) => {
                Self::Serialization(dusk_bytes::Error::InvalidChar {
                    ch,
                    index,
                })
            }
            ExecErr::Rkyv(e) => Self::Transaction(ExecErr::Rkyv(e)),
            ExecErr::MemoTooLarge(size) => Self::MemoTooLarge(size),
            ExecErr::Blob(e) => Self::Blob(e),
        }
    }
}

impl From<dusk_bytes::Error> for Error {
    fn from(err: dusk_bytes::Error) -> Self {
        Self::Serialization(err)
    }
}

impl From<PhoenixError> for Error {
    fn from(pe: PhoenixError) -> Self {
        Self::Phoenix(pe)
    }
}