Enum Error 

#[non_exhaustive]
pub enum Error {
    BadRequest,
    InvalidFieldFormat(String),
    InvalidMandatoryField(String),
    Unauthorized(String),
    InvalidTokenB2B,
    InvalidCustomerToken,
    TokenNotFoundB2B,
    CustomerTokenNotFound,
    TransactionExpired,
    FeatureNotAllowed(String),
    ExceedsTransactionAmountLimit,
    SuspectedFraud,
    ActivityCountLimitExceeded,
    DoNotHonor,
    FeatureNotAllowedAtThisTime(String),
    CardBlocked,
    CardExpired,
    DormantAccount,
    NeedToSetTokenLimit,
    OTPBlocked,
    OTPLifetimeExpired,
    OTPSentToCardholder,
    InsufficientFunds,
    TransactionNotPermitted(String),
    SuspendTransaction,
    TokenLimitExceeded,
    InactiveCardOrAccountOrCustomer,
    MerchantBlacklisted,
    MerchantLimitExceed,
    SetLimitNotAllowed,
    TokenLimitInvalid,
    AccountLimitExceed,
    InvalidTransactionStatus,
    TransactionNotFound,
    InvalidRouting,
    BankNotSupportedBySwitch,
    TransactionCancelled,
    MerchantNotRegisteredForCardRegistrationServices,
    NeedToRequestOTP,
    JourneyNotFound,
    InvalidMerchant,
    NoIssuer,
    InvalidAPITransition,
    InvalidCardOrAccountOrCustomerOrVirtualAccount(String),
    InvalidBillOrVirtualAccountWithReason(String),
    InvalidAmount,
    PaidBill,
    InvalidOTP,
    PartnerNotFound,
    InvalidTerminal,
    InconsistentRequest,
    InvalidBillOrVirtualAccount,
    RequestedFunctionIsNotSupported,
    RequestedOperationIsNotAllowed,
    Conflict,
    DuplicatePartnerReferenceNo,
    TooManyRequests,
    GeneralError,
    InternalServerError,
    ExternalServerError,
    Timeout,
    Crypto(Error),
}

All known SNAP BI error variants plus a feature-gated Crypto bridge.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

BadRequest

General request failed error, including message parsing failed.

InvalidFieldFormat(String)

Invalid format

InvalidMandatoryField(String)

Missing or invalid format on mandatory field

Unauthorized(String)

General unauthorized error (No Interface Def, API is Invalid, Oauth Failed, Verify Client Secret Fail, Client Forbidden Access API, Unknown Client, Key not Found).

InvalidTokenB2B

Token found in request is invalid (Access Token Not Exist, Access Token Expiry)

InvalidCustomerToken

Token found in request is invalid (Access Token Not Exist, Access Token Expiry)

TokenNotFoundB2B

Token not found in the system. This occurs on any API that requires token as input parameter

CustomerTokenNotFound

Token not found in the system. This occurs on any API that requires token as input parameter

TransactionExpired

Transaction expired

FeatureNotAllowed(String)

This merchant is not allowed to call Direct Debit APIs

ExceedsTransactionAmountLimit

Exceeds Transaction Amount Limit

SuspectedFraud

Suspected Fraud

ActivityCountLimitExceeded

Too many requests, exceeds transaction frequency limit

DoNotHonor

Account or User status is abnormal

FeatureNotAllowedAtThisTime(String)

Cut off in progress

CardBlocked

The payment card is blocked

CardExpired

The payment card is expired

DormantAccount

The account is dormant

NeedToSetTokenLimit

Need to set token limit

OTPBlocked

OTP has been blocked

OTPLifetimeExpired

OTP has been expired

OTPSentToCardholder

Initiates request OTP to the issuer

InsufficientFunds

Insufficient funds

TransactionNotPermitted(String)

Transaction not permitted

SuspendTransaction

Suspend transaction

TokenLimitExceeded

Purchase amount exceeds the token limit set prior

InactiveCardOrAccountOrCustomer

Inactive account

MerchantBlacklisted

Merchant is suspended from calling any APIs

MerchantLimitExceed

Merchant aggregated purchase amount on that day exceeds the agreed limit

SetLimitNotAllowed

Set limit not allowed on particular token

TokenLimitInvalid

The token limit desired by the merchant is not within the agreed range between the merchant and the Issuer

AccountLimitExceed

Account aggregated purchase amount on that day exceeds the agreed limit

InvalidTransactionStatus

Invalid transaction status

TransactionNotFound

Transaction not found

InvalidRouting

Invalid routing

BankNotSupportedBySwitch

Bank not supported by switch

TransactionCancelled

Transaction is cancelled by customer

MerchantNotRegisteredForCardRegistrationServices

Merchant is not registered for Card Registration services

NeedToRequestOTP

Need to request OTP

JourneyNotFound

The journeyId cannot be found in the system

InvalidMerchant

Merchant does not exist or status abnormal

NoIssuer

No issuer

InvalidAPITransition

Invalid API transition within a journey

InvalidCardOrAccountOrCustomerOrVirtualAccount(String)

Card information may be invalid, or the card account may be blacklisted, or Virtual Account number maybe invalid.

InvalidBillOrVirtualAccountWithReason(String)

The bill or Virtual account is blocked/ suspended/not found.

InvalidAmount

The amount doesn’t match with what supposed to

PaidBill

The bill has been paid

InvalidOTP

OTP is incorrect

PartnerNotFound

Partner number can’t be found

InvalidTerminal

Terminal does not exist in the system

InconsistentRequest

Inconsistent request parameter found for the same partner reference number/transaction id.

InvalidBillOrVirtualAccount

The bill is expired.

RequestedFunctionIsNotSupported

Requested function is not supported

RequestedOperationIsNotAllowed

Requested operation to cancel/refund transaction is not allowed at this time.

Conflict

Cannot use same X-EXTERNAL-ID in same day

DuplicatePartnerReferenceNo

Transaction has previously been processed indicates the same partnerReferenceNo already success

TooManyRequests

Maximum transaction limit exceeded

GeneralError

General Error

InternalServerError

Unknown internal server failure, please retry the process again

ExternalServerError

Backend system failure, etc.

Timeout

Timeout from the issuer

Crypto(Error)

Bridge variant carrying a kamu_snap_crypto::Error. Only present when the crypto feature is enabled.

Implementations

impl Error

pub fn category(&self) -> Category

Coarse Category for retry-policy / logging consumers.

Examples found in repository

examples/client_parse.rs (line 42)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let wires = [
        r#"{"responseCode":"2001100","responseMessage":"Successful","accountNo":"1234","currentBalance":"99000.00"}"#,
        r#"{"responseCode":"4011100","responseMessage":"Unauthorized. Invalid token"}"#,
        r#"{"responseCode":"4031114","responseMessage":"Insufficient Funds"}"#,
        // BRI's 6-digit source-doc defect — still parseable, raw preserved.
        r#"{"responseCode":"500000","responseMessage":"General Error"}"#,
    ];

    for wire in wires {
        println!("---");
        println!("wire: {wire}");

        let resp: SnapResponse<BalancePayload> = serde_json::from_str(wire)?;
        println!("raw responseCode: {}", resp.envelope.response_code.raw());

        match resp.envelope.response_code.classify() {
            Some(err) => {
                println!("classified error: {err}");
                println!("category: {}", err.category());
                let action = match err.category() {
                    Category::Business => "do NOT retry (business rule violation)",
                    Category::System => "retry with backoff",
                    Category::Message => "fix client request before retry",
                    Category::Success => "no action",
                    _ => "review manually",
                };
                println!("policy: {action}");
            }
            None => {
                if let Some(payload) = resp.payload() {
                    println!("success! account {} balance {}", payload.account_no, payload.current_balance);
                } else {
                    println!("unrecognized code with no payload — log and escalate");
                }
            }
        }
    }
    Ok(())
}

pub fn http_status(&self) -> StatusCode

HTTP status code mapped per the SNAP BI taxonomy.

pub fn case_code(&self) -> u8

2-digit case code embedded in the responseCode.

pub fn response_code(&self, service: ServiceCode) -> ResponseCode

Compose the full wire responseCode for this variant under service.

pub fn from_http_and_case(http: u16, case: u8) -> Option<Self>

Inverse classifier — given a received (http, case), return the matching variant with empty payload for string-bearing variants. None for unknown pairs.

Trait Implementations

impl Debug for Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Error

fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Error for Error

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<Error> for Error

fn from(source: Error) -> Self

Converts to this type from the input type.