typhoon-errors 0.3.0

Error handling types and utilities
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

use solana_program_error::{ProgramError, ToStr};

#[derive(Debug, PartialEq, Eq)]
pub enum ErrorCode {
    UnknownInstruction = 100,
    AccountNotSigner,
    AccountDiscriminatorMismatch,
    HasOneConstraint,
    AssertConstraint,
    AddressConstraint,
    TryingToInitPayerAsProgramAccount,
    TokenConstraintViolated,
    BufferFull,
    InvalidReturnData,
    InvalidDataLength,
    InvalidDataAlignment,
}

impl TryFrom<u32> for ErrorCode {
    type Error = ProgramError;

    fn try_from(value: u32) -> Result<Self, Self::Error> {
        match value {
            100 => Ok(ErrorCode::UnknownInstruction),
            101 => Ok(ErrorCode::AccountNotSigner),
            102 => Ok(ErrorCode::AccountDiscriminatorMismatch),
            103 => Ok(ErrorCode::HasOneConstraint),
            104 => Ok(ErrorCode::AssertConstraint),
            105 => Ok(ErrorCode::AddressConstraint),
            106 => Ok(ErrorCode::TryingToInitPayerAsProgramAccount),
            107 => Ok(ErrorCode::TokenConstraintViolated),
            108 => Ok(ErrorCode::BufferFull),
            109 => Ok(ErrorCode::InvalidReturnData),
            110 => Ok(ErrorCode::InvalidDataLength),
            111 => Ok(ErrorCode::InvalidDataAlignment),
            _ => Err(ProgramError::InvalidArgument),
        }
    }
}

impl From<ErrorCode> for ProgramError {
    fn from(e: ErrorCode) -> Self {
        ProgramError::Custom(e as u32)
    }
}

impl ToStr for ErrorCode {
    fn to_str(&self) -> &'static str {
        match self {
            ErrorCode::UnknownInstruction => "Error: Unknown instruction",
            ErrorCode::AccountNotSigner => "Error: Account is not a signer",
            ErrorCode::AccountDiscriminatorMismatch => {
                "Error: Discriminator did not match what was expected"
            }
            ErrorCode::HasOneConstraint => "Error: has_one constraint violated",
            ErrorCode::AssertConstraint => "Error: assert constraint violated",
            ErrorCode::AddressConstraint => "Error: address constraint violated",
            ErrorCode::TryingToInitPayerAsProgramAccount => {
                "Error: Cannot initialize a program account with the payer account"
            }
            ErrorCode::TokenConstraintViolated => "Error: Token constraint was violated",
            ErrorCode::BufferFull => "Error: Buffer is full",
            ErrorCode::InvalidReturnData => "Error: The return data is invalid",
            ErrorCode::InvalidDataLength => "Error: Invalid data length",
            ErrorCode::InvalidDataAlignment => "Error: Invalid data alignment",
        }
    }
}