use std::{collections::BTreeMap, fmt, sync::LazyLock};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use solana_sdk::pubkey::Pubkey;
use crate::{
constants::{SPL_TOKEN_PROGRAM_ADDRESS, TOKEN_2022_PROGRAM_ADDRESS},
events::{parse_program_log, ProgramLog},
generated::{swap, treasury},
types::SwapDirection,
};
pub use crate::generated::ProgramErrorMetadata;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SwapErrorCategory {
Slippage,
Paused,
Oracle,
InputValidation,
Math,
Liquidity,
UserFunds,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct SwapErrorMetadata {
pub code: u32,
pub name: &'static str,
pub message: &'static str,
pub category: SwapErrorCategory,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ParsedProgramError {
pub code: u32,
pub name: String,
pub message: String,
pub logs: Option<Vec<String>>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ParsedSwapError {
pub code: u32,
pub name: String,
pub message: String,
pub category: SwapErrorCategory,
pub logs: Option<Vec<String>>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "program", content = "error", rename_all = "snake_case")]
pub enum ParsedSimulationProgramError {
Swap(ParsedSwapError),
Treasury(ParsedProgramError),
}
impl ParsedSimulationProgramError {
pub fn code(&self) -> u32 {
match self {
Self::Swap(error) => error.code,
Self::Treasury(error) => error.code,
}
}
pub fn name(&self) -> &str {
match self {
Self::Swap(error) => &error.name,
Self::Treasury(error) => &error.name,
}
}
pub fn message(&self) -> &str {
match self {
Self::Swap(error) => &error.message,
Self::Treasury(error) => &error.message,
}
}
pub fn logs(&self) -> Option<&[String]> {
match self {
Self::Swap(error) => error.logs.as_deref(),
Self::Treasury(error) => error.logs.as_deref(),
}
}
pub fn category(&self) -> Option<SwapErrorCategory> {
match self {
Self::Swap(error) => Some(error.category),
Self::Treasury(_) => None,
}
}
fn with_logs(mut self, logs: Vec<String>) -> Self {
match &mut self {
Self::Swap(error) => error.logs = Some(logs),
Self::Treasury(error) => error.logs = Some(logs),
}
self
}
}
impl fmt::Display for ParsedSimulationProgramError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(
formatter,
"{} ({}): {}",
self.name(),
self.code(),
self.message()
)
}
}
impl std::error::Error for ParsedSimulationProgramError {}
impl From<ParsedSwapError> for ParsedSimulationProgramError {
fn from(error: ParsedSwapError) -> Self {
Self::Swap(error)
}
}
impl From<ParsedProgramError> for ParsedSimulationProgramError {
fn from(error: ParsedProgramError) -> Self {
Self::Treasury(error)
}
}
pub static SWAP_ERROR_MAP: LazyLock<BTreeMap<u32, SwapErrorMetadata>> = LazyLock::new(|| {
swap::ERRORS
.iter()
.map(|metadata| {
(
metadata.code,
SwapErrorMetadata {
code: metadata.code,
name: metadata.name,
message: metadata.message,
category: swap_error_category(metadata.name),
},
)
})
.collect()
});
pub static TREASURY_ERROR_MAP: LazyLock<BTreeMap<u32, ProgramErrorMetadata>> =
LazyLock::new(|| {
treasury::ERRORS
.iter()
.map(|metadata| (metadata.code, *metadata))
.collect()
});
#[derive(Clone, Copy)]
struct AnchorErrorCode<'a> {
code: u32,
name: Option<&'a str>,
}
fn named_navdata_error(error: AnchorErrorCode<'_>) -> Option<ProgramErrorMetadata> {
let (name, message) = match error.code {
6000 => ("InvalidNav", "Invalid NAV"),
6001 => ("ConfidenceTooLow", "Confidence too low"),
6003 => (
"MustProvideAtLeastOneNavData",
"Must provide at least one NAV data",
),
6004 => ("MustProvideHardcodedPrice", "Must provide hardcoded price"),
6011 => ("Max5NavData", "Max 5 NAV data"),
6016 => ("PriceDecimalsTooLarge", "Price decimals too large"),
6018 => ("MathOverflow", "Math Overflow"),
6021 => ("NavMustBePositive", "Nav must be positive"),
6025 => ("InvalidAccountPublicKey", "Invalid account public key"),
6028 => ("InvalidFeedId", "Invalid pyth feed id"),
6029 => ("InvalidMaxAge", "Pyth max age must be > 0"),
6030 => ("MaxAgeTooLarge", "Pyth max age too high"),
6031 => ("ConfBpsTooLarge", "Pyth max conf too high"),
6032 => (
"MissingPythAccount",
"Pyth feed missing from remaining accounts",
),
6033 => ("FeedIdMismatch", "Pyth feed mismatch"),
6034 => (
"MissingRedstoneAccount",
"Redstone price account missing from remaining accounts",
),
6035 => (
"RedstoneValueTooLarge",
"Redstone price value overflows u64",
),
6036 => (
"NavAccountDataTooShort",
"Account data is too short for the configured price offset",
),
6037 => (
"InvalidNavAccountOwner",
"NAV account is not owned by the expected oracle program",
),
6038 => ("DuplicateNavSource", "Duplicate NAV source"),
_ => return None,
};
(error.name == Some(name)).then_some(ProgramErrorMetadata {
code: error.code,
name,
message,
})
}
pub fn swap_error_category(name: &str) -> SwapErrorCategory {
match name {
"ProgramPaused" | "PairPaused" | "RwaPaused" | "StablePaused" | "FeeAssetPaused" => {
SwapErrorCategory::Paused
}
"AmountInTooHigh" | "AmountOutTooLow" => SwapErrorCategory::Slippage,
"InsufficientLiquidity" => SwapErrorCategory::Liquidity,
"InsufficientLpFeeBalance" => SwapErrorCategory::UserFunds,
"InvalidNav"
| "ConfidenceTooLow"
| "NavMustBePositive"
| "InvalidAccountPublicKey"
| "InvalidFeedId"
| "MissingPythAccount"
| "FeedIdMismatch"
| "MissingRedstoneAccount"
| "RedstoneValueTooLarge"
| "NavAccountDataTooShort"
| "InvalidNavAccountOwner"
| "DuplicateNavSource" => SwapErrorCategory::Oracle,
"OutOfRange"
| "SwapAmountTooSmall"
| "DiscountMustBePositive"
| "MathOverflow"
| "MathUnderflow"
| "FeesOutOfRange" => SwapErrorCategory::Math,
_ => SwapErrorCategory::InputValidation,
}
}
pub fn create_no_liquidity_error(logs: Option<Vec<String>>) -> ParsedSwapError {
ParsedSwapError {
code: 1,
name: "NoLiquidity".into(),
message: "No liquidity".into(),
category: SwapErrorCategory::Liquidity,
logs,
}
}
pub fn create_no_user_funds_error(logs: Option<Vec<String>>) -> ParsedSwapError {
ParsedSwapError {
code: 2,
name: "NoUserFunds".into(),
message: "No user funds".into(),
category: SwapErrorCategory::UserFunds,
logs,
}
}
fn parsed_swap_error(
error: AnchorErrorCode<'_>,
logs: Option<Vec<String>>,
) -> Option<ParsedSwapError> {
let metadata = named_navdata_error(error)
.map(|metadata| SwapErrorMetadata {
code: metadata.code,
name: metadata.name,
message: metadata.message,
category: swap_error_category(metadata.name),
})
.or_else(|| SWAP_ERROR_MAP.get(&error.code).copied())?;
Some(ParsedSwapError {
code: error.code,
name: metadata.name.into(),
message: metadata.message.into(),
category: metadata.category,
logs,
})
}
fn parsed_treasury_error(
error: AnchorErrorCode<'_>,
logs: Option<Vec<String>>,
) -> Option<ParsedProgramError> {
let metadata =
named_navdata_error(error).or_else(|| TREASURY_ERROR_MAP.get(&error.code).copied())?;
Some(ParsedProgramError {
code: error.code,
name: metadata.name.into(),
message: metadata.message.into(),
logs,
})
}
pub fn parse_swap_error(error: &Value, program_id: Option<&Pubkey>) -> Option<ParsedSwapError> {
let logs = find_error_logs(error);
let code = namespace_error_code(error, logs.as_deref(), program_id)?;
let mut parsed = parsed_swap_error(code, None)?;
parsed.logs = logs;
Some(parsed)
}
pub fn parse_treasury_error(
error: &Value,
program_id: Option<&Pubkey>,
) -> Option<ParsedProgramError> {
let logs = find_error_logs(error);
let code = namespace_error_code(error, logs.as_deref(), program_id)?;
let mut parsed = parsed_treasury_error(code, None)?;
parsed.logs = logs;
Some(parsed)
}
fn namespace_error_code<'a>(
error: &'a Value,
logs: Option<&'a [String]>,
program_id: Option<&Pubkey>,
) -> Option<AnchorErrorCode<'a>> {
if let Some(logs) = logs {
let trace = InvocationTrace::parse(logs);
let scan = scan_program_errors(logs, &trace, |active| {
program_id.is_none() || active == program_id
});
if let Some(logged) = scan.error {
return Some(logged.error);
}
if scan.saw_error || (program_id.is_some() && trace.has_context) {
return None;
}
}
read_structured_error_code(error, program_id.is_none())
}
pub fn parse_simulation_program_error(
error: &Value,
swap_program_id: &Pubkey,
treasury_program_id: Option<&Pubkey>,
) -> Option<ParsedSimulationProgramError> {
let logs = find_error_logs(error)?;
let logged = simulation_logged_error(&logs, swap_program_id, treasury_program_id)?;
let parsed = parsed_simulation_error(logged, treasury_program_id)?;
Some(parsed.with_logs(logs))
}
pub fn parse_simulation_program_error_from_logs(
logs: &[String],
swap_program_id: &Pubkey,
treasury_program_id: Option<&Pubkey>,
) -> Option<ParsedSimulationProgramError> {
let logged = simulation_logged_error(logs, swap_program_id, treasury_program_id)?;
let parsed = parsed_simulation_error(logged, treasury_program_id)?;
Some(parsed.with_logs(logs.to_vec()))
}
fn simulation_logged_error<'a>(
logs: &'a [String],
swap_program_id: &Pubkey,
treasury_program_id: Option<&Pubkey>,
) -> Option<LoggedProgramError<'a>> {
let trace = InvocationTrace::parse(logs);
scan_program_errors(logs, &trace, |active| {
active == Some(swap_program_id)
|| treasury_program_id.is_some_and(|treasury| active == Some(treasury))
})
.error
}
fn parsed_simulation_error(
logged: LoggedProgramError<'_>,
treasury_program_id: Option<&Pubkey>,
) -> Option<ParsedSimulationProgramError> {
if treasury_program_id.is_some_and(|treasury| logged.program_id.as_ref() == Some(treasury)) {
parsed_treasury_error(logged.error, None).map(ParsedSimulationProgramError::Treasury)
} else {
parsed_swap_error(logged.error, None).map(ParsedSimulationProgramError::Swap)
}
}
pub fn parse_synthetic_simulation_error(
logs: &[String],
swap_direction: SwapDirection,
user_input_token_account: Option<&Pubkey>,
user_output_token_account: Option<&Pubkey>,
swap_program_id: &Pubkey,
treasury_program_id: Option<&Pubkey>,
has_protocol_fee_transfer: bool,
) -> Option<ParsedSwapError> {
let trace = InvocationTrace::parse(logs);
if let Some((caller, ordinal)) =
failed_transfer_checked(logs, &trace, swap_program_id, treasury_program_id)
{
if treasury_program_id == Some(&caller) {
return Some(create_no_liquidity_error(Some(logs.to_vec())));
}
let output_ordinal = if has_protocol_fee_transfer { 2 } else { 1 };
if ordinal <= output_ordinal {
return Some(create_no_liquidity_error(Some(logs.to_vec())));
}
if ordinal == output_ordinal + 1 {
return Some(create_no_user_funds_error(Some(logs.to_vec())));
}
}
let account = uninitialized_user_token_account(logs, &trace, swap_program_id)?;
let is_input = matches!(
(account, swap_direction),
(UserTokenAccount::Quote, SwapDirection::QuoteToBase)
| (UserTokenAccount::Base, SwapDirection::BaseToQuote)
);
if (is_input && user_input_token_account.is_none())
|| (!is_input && user_output_token_account.is_none())
{
Some(create_no_user_funds_error(Some(logs.to_vec())))
} else {
None
}
}
#[derive(Debug)]
struct Invocation {
program_id: Pubkey,
depth: usize,
parent: Option<usize>,
completed: bool,
succeeded: bool,
own_anchor_code: Option<u32>,
last_failed_child: Option<(usize, Option<u32>)>,
propagated_child: Option<usize>,
}
struct InvocationTrace {
invocations: Vec<Invocation>,
line_invocations: Vec<Option<usize>>,
has_context: bool,
}
impl InvocationTrace {
fn parse(logs: &[String]) -> Self {
let mut trace = Self {
invocations: Vec::new(),
line_invocations: Vec::with_capacity(logs.len()),
has_context: false,
};
let mut stack: Vec<usize> = Vec::new();
for line in logs {
let mut owner = stack.last().copied();
match parse_program_log(line) {
Some(ProgramLog::Invoke { program_id, depth }) => {
trace.has_context = true;
while stack
.last()
.is_some_and(|index| trace.invocations[*index].depth >= depth)
{
stack.pop();
}
let parent = stack.last().copied().filter(|index| {
trace.invocations[*index].depth.checked_add(1) == Some(depth)
});
let index = trace.invocations.len();
trace.invocations.push(Invocation {
program_id,
depth,
parent,
completed: false,
succeeded: false,
own_anchor_code: None,
last_failed_child: None,
propagated_child: None,
});
stack.push(index);
owner = Some(index);
}
Some(ProgramLog::Exit {
program_id,
failed,
custom_code,
}) => {
trace.has_context = true;
owner = stack
.iter()
.rposition(|index| trace.invocations[*index].program_id == program_id)
.map(|position| {
let index = stack[position];
let parent = {
let invocation = &mut trace.invocations[index];
invocation.completed = true;
invocation.succeeded = !failed;
invocation.propagated_child = if failed
&& custom_code.is_some()
&& invocation.own_anchor_code != custom_code
{
invocation
.last_failed_child
.and_then(|(child, child_code)| {
(child_code == custom_code).then_some(child)
})
} else {
None
};
invocation.parent
};
if failed {
if let Some(parent) = parent {
trace.invocations[parent].last_failed_child =
Some((index, custom_code));
}
}
stack.truncate(position);
index
});
}
None => {
if let (Some(index), Some((_, code))) = (owner, anchor_error(line)) {
trace.invocations[index].own_anchor_code = Some(code);
}
}
}
trace.line_invocations.push(owner);
}
trace
}
fn succeeded(&self, mut owner: Option<usize>) -> bool {
while let Some(index) = owner {
let invocation = &self.invocations[index];
if invocation.succeeded {
return true;
}
owner = invocation.parent;
}
false
}
fn is_on_failure_path(&self, owner: Option<usize>) -> bool {
let Some(mut index) = owner else {
return true;
};
loop {
let invocation = &self.invocations[index];
if invocation.succeeded {
return false;
}
let Some(parent) = invocation.parent else {
return true;
};
let ancestor = &self.invocations[parent];
if ancestor.succeeded
|| (ancestor.completed && ancestor.propagated_child != Some(index))
{
return false;
}
index = parent;
}
}
}
#[derive(Clone, Copy)]
struct LoggedProgramError<'a> {
error: AnchorErrorCode<'a>,
program_id: Option<Pubkey>,
}
struct ProgramErrorScan<'a> {
error: Option<LoggedProgramError<'a>>,
saw_error: bool,
}
fn scan_program_errors<'a>(
logs: &'a [String],
trace: &InvocationTrace,
accepts: impl Fn(Option<&Pubkey>) -> bool,
) -> ProgramErrorScan<'a> {
let mut scan = ProgramErrorScan {
error: None,
saw_error: false,
};
for (line, owner) in logs.iter().zip(&trace.line_invocations) {
let (error, is_completion) = if let Some((name, code)) = anchor_error(line) {
(
AnchorErrorCode {
code,
name: Some(name),
},
false,
)
} else if let Some(ProgramLog::Exit {
failed: true,
custom_code: Some(code),
..
}) = parse_program_log(line)
{
(AnchorErrorCode { code, name: None }, true)
} else {
continue;
};
scan.saw_error = true;
if !trace.is_on_failure_path(*owner) {
continue;
}
let invocation = owner.map(|index| &trace.invocations[index]);
if is_completion && invocation.is_some_and(|frame| frame.propagated_child.is_some()) {
continue;
}
let program_id = invocation.map(|frame| frame.program_id);
if accepts(program_id.as_ref()) {
scan.error = Some(LoggedProgramError { error, program_id });
break;
}
}
scan
}
fn anchor_error(line: &str) -> Option<(&str, u32)> {
let (_, suffix) = line.split_once("Error Code: ")?;
let (name, number) = suffix.split_once(". Error Number: ")?;
if name.is_empty()
|| !name
.bytes()
.all(|byte| byte.is_ascii_alphanumeric() || byte == b'_')
{
return None;
}
let (number, _) = number.split_once('.')?;
if number.is_empty() || !number.bytes().all(|byte| byte.is_ascii_digit()) {
return None;
}
Some((name, number.parse().ok()?))
}
fn find_error_logs(value: &Value) -> Option<Vec<String>> {
let mut pending = vec![value];
while let Some(value) = pending.pop() {
let entries = value
.get("logs")
.and_then(Value::as_array)
.or_else(|| value.as_array());
if let Some(entries) = entries {
let logs: Vec<String> = entries
.iter()
.filter_map(Value::as_str)
.map(str::to_owned)
.collect();
if !logs.is_empty() {
return Some(logs);
}
}
for key in ["value", "result", "data", "error", "cause", "context"] {
if let Some(nested) = value.get(key) {
pending.push(nested);
}
}
}
None
}
fn read_structured_error_code(
value: &Value,
allow_unscoped_custom: bool,
) -> Option<AnchorErrorCode<'_>> {
let mut pending = vec![value];
while let Some(value) = pending.pop() {
if let Some(code) = value
.pointer("/errorCode/number")
.and_then(structured_code_number)
{
return Some(AnchorErrorCode {
code,
name: value.pointer("/errorCode/code").and_then(Value::as_str),
});
}
if allow_unscoped_custom {
if let Some(code) = value
.pointer("/InstructionError/1/Custom")
.and_then(structured_code_number)
{
return Some(AnchorErrorCode { code, name: None });
}
}
for key in [
"err", "value", "result", "data", "error", "cause", "context",
] {
if let Some(nested) = value.get(key) {
pending.push(nested);
}
}
}
None
}
fn structured_code_number(value: &Value) -> Option<u32> {
let number = value.as_f64()?;
(number >= 0.0 && number <= f64::from(u32::MAX) && number.fract() == 0.0)
.then_some(number as u32)
}
fn failed_transfer_checked(
logs: &[String],
trace: &InvocationTrace,
swap_program_id: &Pubkey,
treasury_program_id: Option<&Pubkey>,
) -> Option<(Pubkey, usize)> {
let mut counts = vec![0; trace.invocations.len()];
let mut ordinals = vec![None; trace.invocations.len()];
for (line, owner) in logs.iter().zip(&trace.line_invocations) {
let Some(index) = *owner else { continue };
let invocation = &trace.invocations[index];
if invocation.program_id != SPL_TOKEN_PROGRAM_ADDRESS
&& invocation.program_id != TOKEN_2022_PROGRAM_ADDRESS
{
continue;
}
let Some(parent) = invocation.parent else {
continue;
};
let caller = trace.invocations[parent].program_id;
if caller != *swap_program_id && treasury_program_id != Some(&caller) {
continue;
}
if line == "Program log: Instruction: TransferChecked" && ordinals[index].is_none() {
counts[parent] += 1;
ordinals[index] = Some(counts[parent]);
}
if line.eq_ignore_ascii_case("Program log: Error: insufficient funds")
&& invocation.propagated_child.is_none()
&& trace.is_on_failure_path(Some(index))
{
if let Some(ordinal) = ordinals[index] {
return Some((caller, ordinal));
}
}
}
None
}
#[derive(Clone, Copy)]
enum UserTokenAccount {
Quote,
Base,
}
fn uninitialized_user_token_account(
logs: &[String],
trace: &InvocationTrace,
swap_program_id: &Pubkey,
) -> Option<UserTokenAccount> {
let mut accounts = vec![(false, None); trace.invocations.len()];
for (line, owner) in logs.iter().zip(&trace.line_invocations) {
let Some(index) = *owner else { continue };
if trace.invocations[index].program_id != *swap_program_id || trace.succeeded(Some(index)) {
continue;
}
let (uninitialized, account) = &mut accounts[index];
if anchor_error(line).is_some_and(|(name, _)| name == "AccountNotInitialized") {
*uninitialized = true;
}
if let Some((_, name)) = line.split_once("account:") {
let name = name
.trim_start()
.split(|character: char| !character.is_ascii_alphanumeric() && character != '_')
.next();
match name {
Some("quote_token_user_token_account") => *account = Some(UserTokenAccount::Quote),
Some("base_token_user_token_account") => *account = Some(UserTokenAccount::Base),
_ => {}
}
}
}
accounts
.into_iter()
.find_map(|(uninitialized, account)| if uninitialized { account } else { None })
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
fn swap_id() -> Pubkey {
Pubkey::new_from_array([3; 32])
}
fn treasury_id() -> Pubkey {
Pubkey::new_from_array([4; 32])
}
fn other_id() -> Pubkey {
Pubkey::new_from_array([5; 32])
}
fn transfer(depth: usize, failed: bool) -> Vec<String> {
let token = SPL_TOKEN_PROGRAM_ADDRESS;
let mut logs = vec![
format!("Program {token} invoke [{depth}]"),
"Program log: Instruction: TransferChecked".into(),
];
if failed {
logs.push("Program log: Error: insufficient funds".into());
logs.push(format!("Program {token} failed: custom program error: 0x1"));
} else {
logs.push(format!("Program {token} success"));
}
logs
}
#[test]
fn colliding_codes_use_the_emitting_program_and_keep_scanning_for_outer_errors() {
let swap = swap_id();
let treasury = treasury_id();
let logs = vec![
format!("Program {swap} invoke [1]"),
format!("Program {treasury} invoke [2]"),
"Program log: Error Code: MissingApyEntry. Error Number: 6014.".into(),
format!("Program {treasury} failed: custom program error: 0x177e"),
"Program log: Error Code: AmountInTooHigh. Error Number: 6026.".into(),
];
let error = json!({"error": {"data": {"logs": logs}, "errorCode": {"number": 6014}}});
let parsed = parse_simulation_program_error(&error, &swap, Some(&treasury)).unwrap();
assert!(matches!(parsed, ParsedSimulationProgramError::Treasury(_)));
assert_eq!(parsed.name(), "MissingApyEntry");
assert_eq!(
parse_swap_error(&error, Some(&swap)).unwrap().name,
"AmountInTooHigh"
);
}
#[test]
fn terminating_sibling_failure_selects_the_propagated_program_error() {
let router = other_id();
let swap = swap_id();
let treasury = treasury_id();
for (caught_name, caught_code) in [
("AmountInTooHigh", 6026_u32),
("AmountInMustBePositive", 6014_u32),
] {
let logs = vec![
format!("Program {router} invoke [1]"),
format!("Program {swap} invoke [2]"),
format!("Program log: Error Code: {caught_name}. Error Number: {caught_code}."),
format!("Program {swap} failed: custom program error: {caught_code:#x}"),
format!("Program {treasury} invoke [2]"),
"Program log: Error Code: MissingApyEntry. Error Number: 6014.".into(),
format!("Program {treasury} failed: custom program error: 0x177e"),
format!("Program {router} failed: custom program error: 0x177e"),
];
let parsed =
parse_simulation_program_error_from_logs(&logs, &swap, Some(&treasury)).unwrap();
assert!(matches!(parsed, ParsedSimulationProgramError::Treasury(_)));
assert_eq!(parsed.name(), "MissingApyEntry");
assert!(parse_swap_error(&json!({ "logs": logs }), Some(&swap)).is_none());
}
}
#[test]
fn scoped_navdata_names_override_colliding_swap_idl_numbers() {
let swap = swap_id();
for (code, name, message) in [
(
6034,
"MissingRedstoneAccount",
"Redstone price account missing from remaining accounts",
),
(
6035,
"RedstoneValueTooLarge",
"Redstone price value overflows u64",
),
(
6036,
"NavAccountDataTooShort",
"Account data is too short for the configured price offset",
),
(
6037,
"InvalidNavAccountOwner",
"NAV account is not owned by the expected oracle program",
),
(6038, "DuplicateNavSource", "Duplicate NAV source"),
(
6032,
"MissingPythAccount",
"Pyth feed missing from remaining accounts",
),
] {
let logs = vec![
format!("Program {swap} invoke [1]"),
format!("Program log: AnchorError occurred. Error Code: {name}. Error Number: {code}. Error Message: {message}."),
format!("Program {swap} failed: custom program error: {code:#x}"),
];
let parsed = parse_simulation_program_error_from_logs(&logs, &swap, None).unwrap();
assert!(matches!(parsed, ParsedSimulationProgramError::Swap(_)));
assert_eq!(parsed.code(), code);
assert_eq!(parsed.name(), name);
assert_eq!(parsed.message(), message);
assert_eq!(parsed.category(), Some(SwapErrorCategory::Oracle));
assert_eq!(
parse_swap_error(&json!({"logs": logs}), Some(&swap))
.unwrap()
.name,
name
);
}
}
#[test]
fn treasury_navdata_errors_keep_the_enclosing_program_namespace() {
let swap = swap_id();
let treasury = treasury_id();
let error = json!({"logs": [
format!("Program {swap} invoke [1]"),
format!("Program {treasury} invoke [2]"),
"Program log: AnchorError occurred. Error Code: InvalidNav. Error Number: 6000. Error Message: Invalid NAV.",
format!("Program {treasury} failed: custom program error: 0x1770"),
format!("Program {swap} failed: custom program error: 0x1770"),
]});
let parsed = parse_simulation_program_error(&error, &swap, Some(&treasury)).unwrap();
assert!(matches!(parsed, ParsedSimulationProgramError::Treasury(_)));
assert_eq!(parsed.name(), "InvalidNav");
assert_eq!(parsed.message(), "Invalid NAV");
assert_eq!(
parse_treasury_error(&error, Some(&treasury)).unwrap().name,
"InvalidNav"
);
assert!(parse_swap_error(&error, Some(&swap)).is_none());
let own = parse_treasury_error(
&json!({"error": {"errorCode": {"number": 6006, "code": "InvalidNav"}}}),
None,
)
.unwrap();
assert_eq!(own.name, "InvalidNav");
assert_eq!(own.message, "NAV must be positive");
}
#[test]
fn structured_navdata_names_require_matching_numbers_and_keep_numeric_fallback() {
let named =
json!({"error": {"errorCode": {"number": 6034, "code": "MissingRedstoneAccount"}}});
assert_eq!(
parse_swap_error(&named, None).unwrap().name,
"MissingRedstoneAccount"
);
assert_eq!(
parse_treasury_error(&named, None).unwrap().name,
"MissingRedstoneAccount"
);
let own = json!({"error": {"errorCode": {"number": 6034, "code": "FeedIdMismatch"}}});
assert_eq!(parse_swap_error(&own, None).unwrap().name, "FeedIdMismatch");
let mismatched =
json!({"error": {"errorCode": {"number": 6035, "code": "MissingRedstoneAccount"}}});
assert_eq!(
parse_swap_error(&mismatched, None).unwrap().name,
"MissingTreasuryAccounts"
);
let number_only = json!({"error": {"errorCode": {"number": 6034}}});
assert_eq!(
parse_swap_error(&number_only, None).unwrap().name,
"FeedIdMismatch"
);
assert_eq!(
parse_treasury_error(&number_only, None).unwrap().name,
"ApyExceedsMax"
);
}
#[test]
fn foreign_cpi_cannot_spoof_navdata_identity_or_revive_it_via_structured_fallback() {
let swap = swap_id();
let other = other_id();
let error = json!({
"logs": [
format!("Program {swap} invoke [1]"),
format!("Program {other} invoke [2]"),
"Program log: Error Code: MissingRedstoneAccount. Error Number: 6034.",
format!("Program {other} failed: custom program error: 0x1792"),
format!("Program {swap} failed: custom program error: 0x1792"),
],
"error": {"errorCode": {"number": 6034, "code": "MissingRedstoneAccount"}},
});
assert!(parse_swap_error(&error, Some(&swap)).is_none());
assert!(parse_simulation_program_error(&error, &swap, None).is_none());
}
#[test]
fn successful_or_caught_cpi_name_cannot_override_an_outer_same_number_error() {
let swap = swap_id();
let treasury = treasury_id();
let wrapper = other_id();
for exit in ["success", "failed: custom program error: 0x1792"] {
let logs = vec![
format!("Program {swap} invoke [1]"),
format!("Program {wrapper} invoke [2]"),
format!("Program {treasury} invoke [3]"),
"Program log: Error Code: MissingRedstoneAccount. Error Number: 6034.".into(),
format!("Program {treasury} {exit}"),
format!("Program {wrapper} success"),
"Program log: Error Code: FeedIdMismatch. Error Number: 6034.".into(),
format!("Program {swap} failed: custom program error: 0x1792"),
];
let parsed =
parse_simulation_program_error_from_logs(&logs, &swap, Some(&treasury)).unwrap();
assert!(matches!(parsed, ParsedSimulationProgramError::Swap(_)));
assert_eq!(parsed.name(), "FeedIdMismatch");
assert_eq!(parsed.category(), Some(SwapErrorCategory::Oracle));
assert!(parse_treasury_error(&json!({"logs": logs}), Some(&treasury)).is_none());
}
}
#[test]
fn production_errors_preserve_namespace_and_fee_pause_category() {
let swap = swap_id();
let treasury = treasury_id();
let fee_pause = parse_swap_error(&json!({"errorCode": {"number": 6045}}), None).unwrap();
assert_eq!(fee_pause.name, "FeeAssetPaused");
assert_eq!(fee_pause.category, SwapErrorCategory::Paused);
for (code, expected) in [
(6045, "SignerInRemainingAccounts"),
(6046, "AmountOutTooLow"),
(6047, "AmountInTooHigh"),
] {
let logs = vec![
format!("Program {swap} invoke [1]"),
format!("Program {treasury} invoke [2]"),
format!("Program {treasury} failed: custom program error: {code:#x}"),
format!("Program {swap} failed: custom program error: {code:#x}"),
];
let error = parse_simulation_program_error(
&json!({"data": {"logs": logs}}),
&swap,
Some(&treasury),
)
.unwrap();
assert!(matches!(error, ParsedSimulationProgramError::Treasury(_)));
assert_eq!(error.name(), expected);
}
}
#[test]
fn successful_cpi_and_caught_failed_cpi_do_not_supply_later_errors() {
let swap = swap_id();
let treasury = treasury_id();
for exit in ["success", "failed: custom program error: 0x177e"] {
let wrapper = other_id();
let logs = vec![
format!("Program {swap} invoke [1]"),
format!("Program {wrapper} invoke [2]"),
format!("Program {treasury} invoke [3]"),
"Program log: Error Code: MissingApyEntry. Error Number: 6014.".into(),
format!("Program {treasury} {exit}"),
format!("Program {wrapper} success"),
"Program log: Error Code: AmountInTooHigh. Error Number: 6026.".into(),
];
let parsed =
parse_simulation_program_error_from_logs(&logs, &swap, Some(&treasury)).unwrap();
assert!(matches!(parsed, ParsedSimulationProgramError::Swap(_)));
assert_eq!(parsed.code(), 6026);
}
}
#[test]
fn rpc_custom_errors_require_runtime_ownership_and_do_not_relabel_propagation() {
let swap = swap_id();
let treasury = treasury_id();
let error = json!({"result": {"value": {
"err": {"InstructionError": [0, {"Custom": 6014}]},
"logs": [
format!("Program {swap} invoke [1]"),
format!("Program {treasury} invoke [2]"),
format!("Program {treasury} failed: custom program error: 0x177e"),
format!("Program {swap} failed: custom program error: 0x177e")
]
}}});
assert_eq!(
parse_simulation_program_error(&error, &swap, Some(&treasury))
.unwrap()
.name(),
"MissingApyEntry"
);
assert!(parse_swap_error(&error, Some(&swap)).is_none());
let unscoped = json!({"err": {"InstructionError": [0, {"Custom": 6014}]}});
assert!(parse_simulation_program_error(&unscoped, &swap, Some(&treasury)).is_none());
assert!(parse_swap_error(&unscoped, Some(&swap)).is_none());
assert_eq!(
parse_swap_error(&unscoped, None).unwrap().name,
"AmountInMustBePositive"
);
}
#[test]
fn nested_logs_and_structured_anchor_codes_preserve_metadata_without_cross_program_fallback() {
let swap = swap_id();
let other = other_id();
let error = json!({"context": {"cause": {"logs": [123, "Program log: unrelated", "Program log: Error Code: AmountOutTooLow. Error Number: 6027.", null]}}});
let parsed = parse_swap_error(&error, None).unwrap();
assert_eq!(parsed.category, SwapErrorCategory::Slippage);
assert_eq!(
parsed.logs.unwrap(),
vec![
"Program log: unrelated",
"Program log: Error Code: AmountOutTooLow. Error Number: 6027."
]
);
assert!(parse_swap_error(&error, Some(&swap)).is_none());
let structured = json!({"logs": ["Program log: no Anchor code"], "error": {"errorCode": {"number": 6026.0}}});
assert_eq!(
parse_swap_error(&structured, Some(&swap)).unwrap().name,
"AmountInTooHigh"
);
let rejected = json!({"logs": [format!("Program {other} invoke [1]"), "Program log: Error Code: Other. Error Number: 6014."], "error": {"errorCode": {"number": 6014}}});
assert!(parse_swap_error(&rejected, Some(&swap)).is_none());
for number in [
json!("6000"),
json!(6000.5),
json!(-1),
json!(u64::MAX),
json!(7000),
] {
assert!(
parse_swap_error(&json!({"error": {"errorCode": {"number": number}}}), None)
.is_none()
);
}
}
#[test]
fn transfer_ordinals_are_per_caller_and_optional_fees_shift_user_input() {
let swap = swap_id();
let treasury = treasury_id();
let mut logs = vec![format!("Program {swap} invoke [1]")];
logs.extend(transfer(2, false));
logs.push(format!("Program {treasury} invoke [2]"));
logs.extend(transfer(3, false));
logs.push(format!("Program {treasury} success"));
logs.extend(transfer(2, false));
logs.extend(transfer(2, true));
let parsed = parse_synthetic_simulation_error(
&logs,
SwapDirection::BaseToQuote,
None,
None,
&swap,
Some(&treasury),
true,
)
.unwrap();
assert_eq!(parsed.category, SwapErrorCategory::UserFunds);
assert_eq!(parsed.code, 2);
let mut treasury_failure = vec![
format!("Program {swap} invoke [1]"),
format!("Program {treasury} invoke [2]"),
];
treasury_failure.extend(transfer(3, true));
let parsed = parse_synthetic_simulation_error(
&treasury_failure,
SwapDirection::QuoteToBase,
None,
None,
&swap,
Some(&treasury),
false,
)
.unwrap();
assert_eq!(parsed.category, SwapErrorCategory::Liquidity);
assert_eq!(parsed.code, 1);
}
#[test]
fn completed_transfers_and_transfer_hooks_cannot_leak_funds_attribution() {
let swap = swap_id();
let other = other_id();
let mut logs = vec![format!("Program {swap} invoke [1]")];
logs.extend(transfer(2, false));
logs.extend([
format!("Program {other} invoke [2]"),
"Program log: Error: insufficient funds".into(),
format!("Program {other} failed: custom program error: 0x1"),
]);
assert!(parse_synthetic_simulation_error(
&logs,
SwapDirection::QuoteToBase,
None,
None,
&swap,
None,
false
)
.is_none());
let token = SPL_TOKEN_PROGRAM_ADDRESS;
let hook_logs = vec![
format!("Program {swap} invoke [1]"),
format!("Program {token} invoke [2]"),
"Program log: Instruction: TransferChecked".into(),
format!("Program {other} invoke [3]"),
"Program log: Error: insufficient funds".into(),
format!("Program {other} failed: custom program error: 0x1"),
format!("Program {token} failed: custom program error: 0x1"),
];
assert!(parse_synthetic_simulation_error(
&hook_logs,
SwapDirection::QuoteToBase,
None,
None,
&swap,
None,
false
)
.is_none());
}
#[test]
fn token_2022_propagated_hook_error_is_not_a_balance_diagnosis() {
let swap = swap_id();
let token = TOKEN_2022_PROGRAM_ADDRESS;
let hook = other_id();
let logs = vec![
format!("Program {swap} invoke [1]"),
format!("Program {token} invoke [2]"),
"Program log: Instruction: TransferChecked".into(),
format!("Program {hook} invoke [3]"),
format!("Program {hook} failed: custom program error: 0x1"),
"Program log: Error: insufficient funds".into(),
format!("Program {token} failed: custom program error: 0x1"),
format!("Program {swap} failed: custom program error: 0x1"),
];
assert!(parse_synthetic_simulation_error(
&logs,
SwapDirection::QuoteToBase,
None,
None,
&swap,
None,
false
)
.is_none());
}
#[test]
fn token_2022_direct_balance_failure_keeps_funds_attribution() {
let swap = swap_id();
let token = TOKEN_2022_PROGRAM_ADDRESS;
let logs = vec![
format!("Program {swap} invoke [1]"),
format!("Program {token} invoke [2]"),
"Program log: Instruction: TransferChecked".into(),
"Program log: Error: insufficient funds".into(),
format!("Program {token} failed: custom program error: 0x1"),
format!("Program {swap} failed: custom program error: 0x1"),
];
let parsed = parse_synthetic_simulation_error(
&logs,
SwapDirection::QuoteToBase,
None,
None,
&swap,
None,
false,
)
.unwrap();
assert_eq!(parsed.category, SwapErrorCategory::Liquidity);
assert_eq!(parsed.code, 1);
}
#[test]
fn uninitialized_accounts_are_scoped_to_swap_and_respect_explicit_overrides() {
let swap = swap_id();
let other = other_id();
let mut logs = vec![
format!("Program {swap} invoke [1]"),
"Program log: AnchorError caused by account: quote_token_user_token_account. Error Code: AccountNotInitialized. Error Number: 3012.".into(),
];
assert_eq!(
parse_synthetic_simulation_error(
&logs,
SwapDirection::QuoteToBase,
None,
None,
&swap,
None,
false
)
.unwrap()
.category,
SwapErrorCategory::UserFunds
);
assert!(parse_synthetic_simulation_error(
&logs,
SwapDirection::QuoteToBase,
Some(&other),
None,
&swap,
None,
false
)
.is_none());
logs[0] = format!("Program {other} invoke [1]");
assert!(parse_synthetic_simulation_error(
&logs,
SwapDirection::QuoteToBase,
None,
None,
&swap,
None,
false
)
.is_none());
}
}