ckb-script-ipc-common 1.1.0

Common utilities for CKB Script IPC.
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

use ckb_rust_std::io::Error as CoreIoError;
use ckb_std::error::SysError;
use core::fmt::{self, Debug, Display};
use enumn::N;

// use core::error::Error when Rust 1.81 is used.
pub trait Error: Debug + Display {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        None
    }
}

#[derive(Debug, Clone)]
pub enum IpcError {
    CkbSysError(SysError),
    UnexpectedEof,
    IncompleteVlqSeq,
    DecodeVlqOverflow,
    ReadVlqError,
    SerializeError,
    DeserializeError,
    SliceWriteError,
    ReadUntilError,
    ReadExactError,
    BufReaderError,
    GeneralIoError,
    ProtocolError(ProtocolErrorCode),
}

impl Display for IpcError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{self:?}")
    }
}

impl Error for IpcError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        None
    }
}

impl From<CoreIoError> for IpcError {
    fn from(_: CoreIoError) -> Self {
        // TODO
        IpcError::GeneralIoError
    }
}

/// Protocol error code used in wire protocol.
/// Its range from 1 to 2^64 - 1.
/// 1~20 are with same values used in syscall error.
#[derive(Debug, Clone, N)]
#[repr(u64)]
pub enum ProtocolErrorCode {
    Ok = 0,
    /// Index out of bound
    IndexOutOfBound = 1,
    /// Field is missing for the target
    ItemMissing = 2,
    /// Buffer length is not enough, error contains actual data length
    LengthNotEnough = 3,
    /// Data encoding error(molecule)
    InvalidData = 4,
    /// Failed to wait.
    WaitFailure = 5,
    /// Invalid file descriptor.
    InvalidFd = 6,
    /// Reading from or writing to file descriptor failed due to other end closed.
    OtherEndClosed = 7,
    /// Max vms has been spawned.
    MaxVmsSpawned = 8,
    /// Max fds has been spawned.
    MaxFdsCreated = 9,

    /// Unknown error code
    UnknownError = 20,
    /// Unknown error from SysError in ckb-std
    UnknownSysError = 21,
    /// Unexpected EOF
    UnexpectedEof = 22,
    /// VLQ error: incomplete VLQ sequence
    IncompleteVlqSeq = 23,
    /// VLQ error: decoding overflow
    DecodeVlqOverflow = 24,
    /// VLQ error: reading error
    ReadVlqError = 25,
    /// Serialize error
    SerializeError = 26,
    /// Deserialize error
    DeserializeError = 27,
    /// general IO error
    GeneralIoError = 28,

    // increase when appending new error codes
    EndOfError = 29,
}

impl From<IpcError> for ProtocolErrorCode {
    fn from(err: IpcError) -> Self {
        match err {
            IpcError::CkbSysError(err) => match err {
                SysError::IndexOutOfBound => ProtocolErrorCode::IndexOutOfBound,
                SysError::ItemMissing => ProtocolErrorCode::ItemMissing,
                SysError::LengthNotEnough(_) => ProtocolErrorCode::LengthNotEnough,
                SysError::Encoding => ProtocolErrorCode::InvalidData,
                SysError::WaitFailure => ProtocolErrorCode::WaitFailure,
                SysError::InvalidFd => ProtocolErrorCode::InvalidFd,
                SysError::OtherEndClosed => ProtocolErrorCode::OtherEndClosed,
                SysError::MaxVmsSpawned => ProtocolErrorCode::MaxVmsSpawned,
                SysError::MaxFdsCreated => ProtocolErrorCode::MaxFdsCreated,
                _ => ProtocolErrorCode::UnknownSysError,
            },
            IpcError::UnexpectedEof => ProtocolErrorCode::UnexpectedEof,
            IpcError::IncompleteVlqSeq => ProtocolErrorCode::IncompleteVlqSeq,
            IpcError::DecodeVlqOverflow => ProtocolErrorCode::DecodeVlqOverflow,
            IpcError::ReadVlqError => ProtocolErrorCode::ReadVlqError,
            IpcError::SerializeError => ProtocolErrorCode::SerializeError,
            IpcError::DeserializeError => ProtocolErrorCode::DeserializeError,
            IpcError::SliceWriteError
            | IpcError::BufReaderError
            | IpcError::ReadUntilError
            | IpcError::ReadExactError => ProtocolErrorCode::GeneralIoError,
            IpcError::GeneralIoError => ProtocolErrorCode::GeneralIoError,
            IpcError::ProtocolError(e) => e,
        }
    }
}

impl From<u64> for ProtocolErrorCode {
    fn from(e: u64) -> Self {
        Self::n(e).unwrap()
    }
}