casper-node 2.0.3

The Casper blockchain node
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

use std::fmt::{Display, Formatter};

use datasize::DataSize;
use derive_more::From;

use casper_types::{Digest, TransactionHash, TransactionId};

use super::deploy_acquisition;

use casper_types::BlockHash;

#[derive(Clone, Copy, From, PartialEq, Eq, DataSize, Debug)]
pub(crate) enum BlockAcquisitionError {
    InvalidStateTransition,
    BlockHashMismatch {
        expected: BlockHash,
        actual: BlockHash,
    },
    RootHashMismatch {
        expected: Digest,
        actual: Digest,
    },
    InvalidAttemptToAcquireExecutionResults,
    #[from]
    InvalidAttemptToApplyApprovalsHashes(deploy_acquisition::Error),
    InvalidAttemptToApplyTransaction {
        txn_id: TransactionId,
    },
    MissingApprovalsHashes(TransactionHash),
    InvalidAttemptToMarkComplete,
    InvalidAttemptToEnqueueBlockForExecution,
    ExecutionResults(super::execution_results_acquisition::Error),
    InvalidTransactionType,
}

impl Display for BlockAcquisitionError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            BlockAcquisitionError::InvalidStateTransition => write!(f, "invalid state transition"),
            BlockAcquisitionError::InvalidAttemptToMarkComplete => {
                write!(f, "invalid attempt to mark complete")
            }
            BlockAcquisitionError::InvalidAttemptToAcquireExecutionResults => {
                write!(
                    f,
                    "invalid attempt to acquire execution results while in a terminal state"
                )
            }
            BlockAcquisitionError::BlockHashMismatch { expected, actual } => {
                write!(
                    f,
                    "block hash mismatch: expected {} actual: {}",
                    expected, actual
                )
            }
            BlockAcquisitionError::RootHashMismatch { expected, actual } => write!(
                f,
                "root hash mismatch: expected {} actual: {}",
                expected, actual
            ),
            BlockAcquisitionError::ExecutionResults(error) => {
                write!(f, "execution results error: {}", error)
            }
            BlockAcquisitionError::InvalidAttemptToApplyApprovalsHashes(error) => write!(
                f,
                "invalid attempt to apply approvals hashes results: {}",
                error
            ),
            BlockAcquisitionError::InvalidAttemptToEnqueueBlockForExecution => {
                write!(f, "invalid attempt to enqueue block for execution")
            }
            BlockAcquisitionError::InvalidAttemptToApplyTransaction { txn_id } => {
                write!(f, "invalid attempt to apply transaction: {}", txn_id)
            }
            BlockAcquisitionError::MissingApprovalsHashes(missing_txn_hash) => {
                write!(
                    f,
                    "missing approvals hashes for transaction {}",
                    missing_txn_hash
                )
            }
            BlockAcquisitionError::InvalidTransactionType => {
                write!(f, "invalid transaction identifier",)
            }
        }
    }
}