Add error logging

Author: febo

Cargo.lock

@@ -12,8 +12,8 @@ readme = "./README.md"
 crate-type = ["rlib"]
 
 [dependencies]
-pinocchio = { version = "0.7", git = "https://github.com/febo/pinocchio.git", branch = "febo/close-unstable" }
-pinocchio-pubkey = { version = "0.2", git = "https://github.com/febo/pinocchio.git", branch = "febo/close-unstable" }
+pinocchio = { version = "0.7", git = "https://github.com/febo/pinocchio.git", branch = "febo/error-to-str" }
+pinocchio-pubkey = { version = "0.2", git = "https://github.com/febo/pinocchio.git", branch = "febo/error-to-str" }
 
 [dev-dependencies]
 strum = "0.27"

interface/Cargo.toml

@@ -1,6 +1,6 @@
 //! Error types
 
-use pinocchio::program_error::ProgramError;
+use pinocchio::program_error::{ProgramError, ToStr};
 
 /// Errors that may be returned by the Token program.
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -59,3 +59,72 @@ impl From<TokenError> for ProgramError {
         ProgramError::Custom(e as u32)
     }
 }
+
+impl ToStr for TokenError {
+    fn to_str<E>(&self) -> &'static str
+    where
+        E: 'static + ToStr + TryFrom<u32>,
+    {
+        match self {
+            TokenError::NotRentExempt => "Error: Lamport balance below rent-exempt threshold",
+            TokenError::InsufficientFunds => "Error: insufficient funds",
+            TokenError::InvalidMint => "Error: Invalid Mint",
+            TokenError::MintMismatch => "Error: Account not associated with this Mint",
+            TokenError::OwnerMismatch => "Error: owner does not match",
+            TokenError::FixedSupply => "Error: the total supply of this token is fixed",
+            TokenError::AlreadyInUse => "Error: account or token already in use",
+            TokenError::InvalidNumberOfProvidedSigners => {
+                "Error: Invalid number of provided signers"
+            }
+            TokenError::InvalidNumberOfRequiredSigners => {
+                "Error: Invalid number of required signers"
+            }
+            TokenError::UninitializedState => "Error: State is uninitialized",
+            TokenError::NativeNotSupported => "Error: Instruction does not support native tokens",
+            TokenError::NonNativeHasBalance => {
+                "Error: Non-native account can only be closed if its balance is zero"
+            }
+            TokenError::InvalidInstruction => "Error: Invalid instruction",
+            TokenError::InvalidState => "Error: Invalid account state for operation",
+            TokenError::Overflow => "Error: Operation overflowed",
+            TokenError::AuthorityTypeNotSupported => {
+                "Error: Account does not support specified authority type"
+            }
+            TokenError::MintCannotFreeze => "Error: This token mint cannot freeze accounts",
+            TokenError::AccountFrozen => "Error: Account is frozen",
+            TokenError::MintDecimalsMismatch => "Error: decimals different from the Mint decimals",
+            TokenError::NonNativeNotSupported => {
+                "Error: Instruction does not support non-native tokens"
+            }
+        }
+    }
+}
+
+impl TryFrom<u32> for TokenError {
+    type Error = ProgramError;
+    fn try_from(value: u32) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(TokenError::NotRentExempt),
+            1 => Ok(TokenError::InsufficientFunds),
+            2 => Ok(TokenError::InvalidMint),
+            3 => Ok(TokenError::MintMismatch),
+            4 => Ok(TokenError::OwnerMismatch),
+            5 => Ok(TokenError::FixedSupply),
+            6 => Ok(TokenError::AlreadyInUse),
+            7 => Ok(TokenError::InvalidNumberOfProvidedSigners),
+            8 => Ok(TokenError::InvalidNumberOfRequiredSigners),
+            9 => Ok(TokenError::UninitializedState),
+            10 => Ok(TokenError::NativeNotSupported),
+            11 => Ok(TokenError::NonNativeHasBalance),
+            12 => Ok(TokenError::InvalidInstruction),
+            13 => Ok(TokenError::InvalidState),
+            14 => Ok(TokenError::Overflow),
+            15 => Ok(TokenError::AuthorityTypeNotSupported),
+            16 => Ok(TokenError::MintCannotFreeze),
+            17 => Ok(TokenError::AccountFrozen),
+            18 => Ok(TokenError::MintDecimalsMismatch),
+            19 => Ok(TokenError::NonNativeNotSupported),
+            _ => Err(ProgramError::InvalidArgument),
+        }
+    }
+}

interface/src/error.rs

@@ -15,8 +15,8 @@ crate-type = ["cdylib"]
 logging = []
 
 [dependencies]
-pinocchio = { version = "0.7", git = "https://github.com/febo/pinocchio.git", branch = "febo/close-unstable" }
-pinocchio-log = { version = "0.3", git = "https://github.com/febo/pinocchio.git", branch = "febo/close-unstable" }
+pinocchio = { version = "0.7", git = "https://github.com/febo/pinocchio.git", branch = "febo/error-to-str" }
+pinocchio-log = { version = "0.3", git = "https://github.com/febo/pinocchio.git", branch = "febo/error-to-str" }
 spl-token-interface = { version = "^0", path = "../interface" }
 
 [dev-dependencies]

p-token/Cargo.toml

@@ -1,7 +1,11 @@
 use pinocchio::{
-    account_info::AccountInfo, default_panic_handler, no_allocator, program_entrypoint,
-    program_error::ProgramError, pubkey::Pubkey, ProgramResult,
+    account_info::AccountInfo,
+    default_panic_handler, no_allocator, program_entrypoint,
+    program_error::{ProgramError, ToStr},
+    pubkey::Pubkey,
+    ProgramResult,
 };
+use spl_token_interface::error::TokenError;
 
 use crate::processor::*;
 
@@ -11,6 +15,12 @@ no_allocator!();
 // Use the default panic handler.
 default_panic_handler!();
 
+/// Log an error.
+#[cold]
+fn log_error(error: &ProgramError) {
+    pinocchio::log::sol_log(error.to_str::<TokenError>());
+}
+
 /// Process an instruction.
 ///
 /// In the first stage, the entrypoint checks the discriminator of the instruction data
@@ -27,15 +37,17 @@ pub fn process_instruction(
         return Err(ProgramError::InvalidInstructionData);
     };
 
-    if *discriminator == 255 {
+    let result = if *discriminator == 255 {
         // 255 - Batch
         #[cfg(feature = "logging")]
         pinocchio::msg!("Instruction: Batch");
 
-        return process_batch(accounts, remaining);
-    }
+        process_batch(accounts, remaining)
+    } else {
+        inner_process_instruction(accounts, instruction_data)
+    };
 
-    inner_process_instruction(accounts, instruction_data)
+    result.inspect_err(log_error)
 }
 
 /// Process a "regular" instruction.