ton_lib_core 0.0.7

A collection of types and utilities for interacting with the TON network
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

use hex::FromHexError;
use std::env::VarError;
use std::sync::Arc;
use thiserror::Error;

#[macro_export]
macro_rules! bail_tl_core {
    ($($arg:tt)*) => {
        return Err(TLCoreError::Custom(format!($($arg)*)))
    };
}

#[derive(Error, Debug)]
pub enum TLCoreError {
    // ton_hash
    #[error("TonHashWrongLen: Expecting {exp} bytes, got {given}")]
    TonHashWrongLen { exp: usize, given: usize },
    #[error("TonAddressParseError: address={0}, err: {1}")]
    TonAddressParseError(String, String),

    // cell_parser
    #[error("ParserDataUnderflow: Requested {req} bits, but only {left} left")]
    ParserDataUnderflow { req: usize, left: usize },
    #[error("ParserBadPosition: New position is {new_pos}, but data_bits_len is {bits_len}")]
    ParserBadPosition { new_pos: i32, bits_len: usize },
    #[error("ParserWrongSlicePosition: expecting bit_pos=0, next_ref_pos=0. Got bit_position={bit_pos}, next_ref_position={next_ref_pos}")]
    ParserWrongSlicePosition { bit_pos: usize, next_ref_pos: usize },
    #[error("ParserRefsUnderflow: No ref with index={req}")]
    ParserRefsUnderflow { req: usize },
    #[error("ParserCellNotEmpty: Cell is not empty: {bits_left} bits left, {refs_left} refs left")]
    ParserCellNotEmpty { bits_left: usize, refs_left: usize },

    // cell_builder
    #[error("BuilderDataOverflow: Can't write {req} bits: only {left} free bits available")]
    BuilderDataOverflow { req: usize, left: usize },
    #[error("BuilderRefsOverflow: Can't write ref - 4 refs are written already")]
    BuilderRefsOverflow,
    #[error("BuilderNotEnoughData: Can't extract {required_bits} bits from {given} bytes")]
    BuilderNotEnoughData { required_bits: usize, given: usize },
    #[error("BuilderNumberBitsMismatch: Can't write number {number} as {bits} bits")]
    BuilderNumberBitsMismatch { number: String, bits: usize },
    #[error("BuilderMeta: Cell validation error: {0}")]
    BuilderMeta(String),

    // boc
    #[error("BOCEmpty: can't parse BOC from empty slice")]
    BOCEmpty,
    #[error("BOCWrongData: {0}")]
    BOCWrongData(String),
    #[error("BOCSingleRoot: Expected 1 root, got {0}")]
    BOCSingleRoot(usize),

    // tlb
    #[error("TLBWrongData: {0}")]
    TLBWrongData(String),
    #[error("TLBWrongPrefix: expected={exp}, given={given}, exp_bits={bits_exp}, left_bits={bits_left}")]
    TLBWrongPrefix {
        exp: usize,
        given: usize,
        bits_exp: usize,
        bits_left: usize,
    },
    #[error("TLBEnumOutOfOptions: data doesn't match any variant of {0}")]
    TLBEnumOutOfOptions(String),
    #[error("TLBObjectNoValue: No internal value found (method: {0})")]
    TLBObjectNoValue(String),

    // contracts
    #[error("ContractError: {0}")]
    ContractError(String),

    // General errors
    #[error("Custom: {0}")]
    Custom(String),
    #[error("UnexpectedValue: expected: {expected}, actual: {actual}")]
    UnexpectedValue { expected: String, actual: String },

    // handling external errors
    #[error("{0}")]
    IO(#[from] std::io::Error),
    #[error("{0}")]
    FromHex(#[from] FromHexError),
    #[error("{0}")]
    Base64Error(#[from] base64::DecodeError),
    #[error("{0}")]
    ParseInt(#[from] std::num::ParseIntError),
    #[error("{0}")]
    FromUtf8(#[from] std::string::FromUtf8Error),
    #[error("{0}")]
    Utf8Error(#[from] std::str::Utf8Error),
    #[error("{0}")]
    NulError(#[from] std::ffi::NulError),
    #[error("{0}")]
    SystemTimeError(#[from] std::time::SystemTimeError),

    #[error("{0}")]
    ParseBigIntError(#[from] num_bigint::ParseBigIntError),
    #[error("{0}")]
    VarError(#[from] VarError),
    #[error("{0}")]
    BoxedError(#[from] Box<dyn std::error::Error + Send + Sync>),
    #[error("{0}")]
    ArcError(#[from] Arc<dyn std::error::Error + Send + Sync>),
    #[error("{0}")]
    ArcSelf(#[from] Arc<TLCoreError>),
}