Skip to main content

multiliquid_svm_sdk/
errors.rs

1//! IDL error metadata and invocation-scoped simulation diagnostics.
2
3use std::{collections::BTreeMap, fmt, sync::LazyLock};
4
5use serde::{Deserialize, Serialize};
6use serde_json::Value;
7
8use crate::{
9    constants::{SPL_TOKEN_PROGRAM_ADDRESS, TOKEN_2022_PROGRAM_ADDRESS},
10    events::{parse_program_log, ProgramLog},
11    generated::{swap, treasury},
12    types::SwapDirection,
13    Pubkey,
14};
15
16pub use crate::generated::ProgramErrorMetadata;
17
18#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
19#[serde(rename_all = "snake_case")]
20pub enum SwapErrorCategory {
21    Slippage,
22    Paused,
23    Oracle,
24    InputValidation,
25    Math,
26    Liquidity,
27    UserFunds,
28}
29
30#[derive(Debug, Clone, Copy, PartialEq, Eq)]
31pub struct SwapErrorMetadata {
32    pub code: u32,
33    pub name: &'static str,
34    pub message: &'static str,
35    pub category: SwapErrorCategory,
36}
37
38#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
39pub struct ParsedProgramError {
40    pub code: u32,
41    pub name: String,
42    pub message: String,
43    pub logs: Option<Vec<String>>,
44}
45
46#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
47pub struct ParsedSwapError {
48    pub code: u32,
49    pub name: String,
50    pub message: String,
51    pub category: SwapErrorCategory,
52    pub logs: Option<Vec<String>>,
53}
54
55/// The namespace is retained because swap and treasury error numbers overlap.
56#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
57#[serde(tag = "program", content = "error", rename_all = "snake_case")]
58pub enum ParsedSimulationProgramError {
59    Swap(ParsedSwapError),
60    Treasury(ParsedProgramError),
61}
62
63impl ParsedSimulationProgramError {
64    pub fn code(&self) -> u32 {
65        match self {
66            Self::Swap(error) => error.code,
67            Self::Treasury(error) => error.code,
68        }
69    }
70
71    pub fn name(&self) -> &str {
72        match self {
73            Self::Swap(error) => &error.name,
74            Self::Treasury(error) => &error.name,
75        }
76    }
77
78    pub fn message(&self) -> &str {
79        match self {
80            Self::Swap(error) => &error.message,
81            Self::Treasury(error) => &error.message,
82        }
83    }
84
85    pub fn logs(&self) -> Option<&[String]> {
86        match self {
87            Self::Swap(error) => error.logs.as_deref(),
88            Self::Treasury(error) => error.logs.as_deref(),
89        }
90    }
91
92    pub fn category(&self) -> Option<SwapErrorCategory> {
93        match self {
94            Self::Swap(error) => Some(error.category),
95            Self::Treasury(_) => None,
96        }
97    }
98
99    fn with_logs(mut self, logs: Vec<String>) -> Self {
100        match &mut self {
101            Self::Swap(error) => error.logs = Some(logs),
102            Self::Treasury(error) => error.logs = Some(logs),
103        }
104        self
105    }
106}
107
108impl fmt::Display for ParsedSimulationProgramError {
109    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
110        write!(
111            formatter,
112            "{} ({}): {}",
113            self.name(),
114            self.code(),
115            self.message()
116        )
117    }
118}
119
120impl std::error::Error for ParsedSimulationProgramError {}
121
122impl From<ParsedSwapError> for ParsedSimulationProgramError {
123    fn from(error: ParsedSwapError) -> Self {
124        Self::Swap(error)
125    }
126}
127
128impl From<ParsedProgramError> for ParsedSimulationProgramError {
129    fn from(error: ParsedProgramError) -> Self {
130        Self::Treasury(error)
131    }
132}
133
134/// Complete checked-in swap IDL metadata, enriched with SDK categories.
135pub static SWAP_ERROR_MAP: LazyLock<BTreeMap<u32, SwapErrorMetadata>> = LazyLock::new(|| {
136    swap::ERRORS
137        .iter()
138        .map(|metadata| {
139            (
140                metadata.code,
141                SwapErrorMetadata {
142                    code: metadata.code,
143                    name: metadata.name,
144                    message: metadata.message,
145                    category: swap_error_category(metadata.name),
146                },
147            )
148        })
149        .collect()
150});
151
152/// Complete checked-in treasury IDL metadata; never looked up through the swap map.
153pub static TREASURY_ERROR_MAP: LazyLock<BTreeMap<u32, ProgramErrorMetadata>> =
154    LazyLock::new(|| {
155        treasury::ERRORS
156            .iter()
157            .map(|metadata| (metadata.code, *metadata))
158            .collect()
159    });
160
161#[derive(Clone, Copy)]
162struct AnchorErrorCode<'a> {
163    code: u32,
164    name: Option<&'a str>,
165}
166
167// The linked navdata crate has its own Anchor numbering, overlapping both
168// program IDLs. A number alone must never select dependency metadata.
169fn named_navdata_error(error: AnchorErrorCode<'_>) -> Option<ProgramErrorMetadata> {
170    let (name, message) = match error.code {
171        6000 => ("InvalidNav", "Invalid NAV"),
172        6001 => ("ConfidenceTooLow", "Confidence too low"),
173        6003 => (
174            "MustProvideAtLeastOneNavData",
175            "Must provide at least one NAV data",
176        ),
177        6004 => ("MustProvideHardcodedPrice", "Must provide hardcoded price"),
178        6011 => ("Max5NavData", "Max 5 NAV data"),
179        6016 => ("PriceDecimalsTooLarge", "Price decimals too large"),
180        6018 => ("MathOverflow", "Math Overflow"),
181        6021 => ("NavMustBePositive", "Nav must be positive"),
182        6025 => ("InvalidAccountPublicKey", "Invalid account public key"),
183        6028 => ("InvalidFeedId", "Invalid pyth feed id"),
184        6029 => ("InvalidMaxAge", "Pyth max age must be > 0"),
185        6030 => ("MaxAgeTooLarge", "Pyth max age too high"),
186        6031 => ("ConfBpsTooLarge", "Pyth max conf too high"),
187        6032 => (
188            "MissingPythAccount",
189            "Pyth feed missing from remaining accounts",
190        ),
191        6033 => ("FeedIdMismatch", "Pyth feed mismatch"),
192        6034 => (
193            "MissingRedstoneAccount",
194            "Redstone price account missing from remaining accounts",
195        ),
196        6035 => (
197            "RedstoneValueTooLarge",
198            "Redstone price value overflows u64",
199        ),
200        6036 => (
201            "NavAccountDataTooShort",
202            "Account data is too short for the configured price offset",
203        ),
204        6037 => (
205            "InvalidNavAccountOwner",
206            "NAV account is not owned by the expected oracle program",
207        ),
208        6038 => ("DuplicateNavSource", "Duplicate NAV source"),
209        _ => return None,
210    };
211    (error.name == Some(name)).then_some(ProgramErrorMetadata {
212        code: error.code,
213        name,
214        message,
215    })
216}
217
218pub fn swap_error_category(name: &str) -> SwapErrorCategory {
219    match name {
220        "ProgramPaused" | "PairPaused" | "RwaPaused" | "StablePaused" | "FeeAssetPaused" => {
221            SwapErrorCategory::Paused
222        }
223        "AmountInTooHigh" | "AmountOutTooLow" => SwapErrorCategory::Slippage,
224        "InsufficientLiquidity" => SwapErrorCategory::Liquidity,
225        "InsufficientLpFeeBalance" => SwapErrorCategory::UserFunds,
226        "InvalidNav"
227        | "ConfidenceTooLow"
228        | "NavMustBePositive"
229        | "InvalidAccountPublicKey"
230        | "InvalidFeedId"
231        | "MissingPythAccount"
232        | "FeedIdMismatch"
233        | "MissingRedstoneAccount"
234        | "RedstoneValueTooLarge"
235        | "NavAccountDataTooShort"
236        | "InvalidNavAccountOwner"
237        | "DuplicateNavSource" => SwapErrorCategory::Oracle,
238        "OutOfRange"
239        | "SwapAmountTooSmall"
240        | "DiscountMustBePositive"
241        | "MathOverflow"
242        | "MathUnderflow"
243        | "FeesOutOfRange" => SwapErrorCategory::Math,
244        _ => SwapErrorCategory::InputValidation,
245    }
246}
247
248pub fn create_no_liquidity_error(logs: Option<Vec<String>>) -> ParsedSwapError {
249    ParsedSwapError {
250        code: 1,
251        name: "NoLiquidity".into(),
252        message: "No liquidity".into(),
253        category: SwapErrorCategory::Liquidity,
254        logs,
255    }
256}
257
258pub fn create_no_user_funds_error(logs: Option<Vec<String>>) -> ParsedSwapError {
259    ParsedSwapError {
260        code: 2,
261        name: "NoUserFunds".into(),
262        message: "No user funds".into(),
263        category: SwapErrorCategory::UserFunds,
264        logs,
265    }
266}
267
268fn parsed_swap_error(
269    error: AnchorErrorCode<'_>,
270    logs: Option<Vec<String>>,
271) -> Option<ParsedSwapError> {
272    let metadata = named_navdata_error(error)
273        .map(|metadata| SwapErrorMetadata {
274            code: metadata.code,
275            name: metadata.name,
276            message: metadata.message,
277            category: swap_error_category(metadata.name),
278        })
279        .or_else(|| SWAP_ERROR_MAP.get(&error.code).copied())?;
280    Some(ParsedSwapError {
281        code: error.code,
282        name: metadata.name.into(),
283        message: metadata.message.into(),
284        category: metadata.category,
285        logs,
286    })
287}
288
289fn parsed_treasury_error(
290    error: AnchorErrorCode<'_>,
291    logs: Option<Vec<String>>,
292) -> Option<ParsedProgramError> {
293    let metadata =
294        named_navdata_error(error).or_else(|| TREASURY_ERROR_MAP.get(&error.code).copied())?;
295    Some(ParsedProgramError {
296        code: error.code,
297        name: metadata.name.into(),
298        message: metadata.message.into(),
299        logs,
300    })
301}
302
303/// Parse Anchor errors, nested SDK errors, or JSON-RPC simulation envelopes.
304/// An explicit program ID filters logged errors. An unscoped structured Anchor
305/// code is accepted only when there is no contradictory runtime context.
306pub fn parse_swap_error(error: &Value, program_id: Option<&Pubkey>) -> Option<ParsedSwapError> {
307    let logs = find_error_logs(error);
308    let code = namespace_error_code(error, logs.as_deref(), program_id)?;
309    let mut parsed = parsed_swap_error(code, None)?;
310    parsed.logs = logs;
311    Some(parsed)
312}
313
314pub fn parse_treasury_error(
315    error: &Value,
316    program_id: Option<&Pubkey>,
317) -> Option<ParsedProgramError> {
318    let logs = find_error_logs(error);
319    let code = namespace_error_code(error, logs.as_deref(), program_id)?;
320    let mut parsed = parsed_treasury_error(code, None)?;
321    parsed.logs = logs;
322    Some(parsed)
323}
324
325fn namespace_error_code<'a>(
326    error: &'a Value,
327    logs: Option<&'a [String]>,
328    program_id: Option<&Pubkey>,
329) -> Option<AnchorErrorCode<'a>> {
330    if let Some(logs) = logs {
331        let trace = InvocationTrace::parse(logs);
332        let scan = scan_program_errors(logs, &trace, |active| {
333            program_id.is_none() || active == program_id
334        });
335        if let Some(logged) = scan.error {
336            return Some(logged.error);
337        }
338        // Do not let a bare structured code override another program's error,
339        // or resurrect a code emitted by an invocation that succeeded.
340        if scan.saw_error || (program_id.is_some() && trace.has_context) {
341            return None;
342        }
343    }
344    read_structured_error_code(error, program_id.is_none())
345}
346
347/// Attribute a simulation failure using runtime invocation ownership, not just
348/// its numeric Custom code. Bare Custom codes cannot identify a program.
349pub fn parse_simulation_program_error(
350    error: &Value,
351    swap_program_id: &Pubkey,
352    treasury_program_id: Option<&Pubkey>,
353) -> Option<ParsedSimulationProgramError> {
354    let logs = find_error_logs(error)?;
355    let logged = simulation_logged_error(&logs, swap_program_id, treasury_program_id)?;
356    let parsed = parsed_simulation_error(logged, treasury_program_id)?;
357    Some(parsed.with_logs(logs))
358}
359
360/// Log-slice variant for `Rpc::simulate_transaction` consumers; no JSON wrapper
361/// or cloned logs are needed until a recognized error is returned.
362pub fn parse_simulation_program_error_from_logs(
363    logs: &[String],
364    swap_program_id: &Pubkey,
365    treasury_program_id: Option<&Pubkey>,
366) -> Option<ParsedSimulationProgramError> {
367    let logged = simulation_logged_error(logs, swap_program_id, treasury_program_id)?;
368    let parsed = parsed_simulation_error(logged, treasury_program_id)?;
369    Some(parsed.with_logs(logs.to_vec()))
370}
371
372fn simulation_logged_error<'a>(
373    logs: &'a [String],
374    swap_program_id: &Pubkey,
375    treasury_program_id: Option<&Pubkey>,
376) -> Option<LoggedProgramError<'a>> {
377    let trace = InvocationTrace::parse(logs);
378    scan_program_errors(logs, &trace, |active| {
379        active == Some(swap_program_id)
380            || treasury_program_id.is_some_and(|treasury| active == Some(treasury))
381    })
382    .error
383}
384
385fn parsed_simulation_error(
386    logged: LoggedProgramError<'_>,
387    treasury_program_id: Option<&Pubkey>,
388) -> Option<ParsedSimulationProgramError> {
389    if treasury_program_id.is_some_and(|treasury| logged.program_id.as_ref() == Some(treasury)) {
390        parsed_treasury_error(logged.error, None).map(ParsedSimulationProgramError::Treasury)
391    } else {
392        parsed_swap_error(logged.error, None).map(ParsedSimulationProgramError::Swap)
393    }
394}
395
396/// Classify insufficient SPL Token funds by the transfer's immediate caller.
397/// Swap transfers run in fee (optional), output, input order; treasury transfers
398/// have independent ordinals and represent LP liquidity. Only a failing token
399/// invocation can supply a funds error; a completed transfer cannot leak its
400/// attribution into a later CPI or transfer-hook failure.
401pub fn parse_synthetic_simulation_error(
402    logs: &[String],
403    swap_direction: SwapDirection,
404    user_input_token_account: Option<&Pubkey>,
405    user_output_token_account: Option<&Pubkey>,
406    swap_program_id: &Pubkey,
407    treasury_program_id: Option<&Pubkey>,
408    has_protocol_fee_transfer: bool,
409) -> Option<ParsedSwapError> {
410    let trace = InvocationTrace::parse(logs);
411    if let Some((caller, ordinal)) =
412        failed_transfer_checked(logs, &trace, swap_program_id, treasury_program_id)
413    {
414        if treasury_program_id == Some(&caller) {
415            return Some(create_no_liquidity_error(Some(logs.to_vec())));
416        }
417        let output_ordinal = if has_protocol_fee_transfer { 2 } else { 1 };
418        if ordinal <= output_ordinal {
419            return Some(create_no_liquidity_error(Some(logs.to_vec())));
420        }
421        if ordinal == output_ordinal + 1 {
422            return Some(create_no_user_funds_error(Some(logs.to_vec())));
423        }
424    }
425
426    let account = uninitialized_user_token_account(logs, &trace, swap_program_id)?;
427    let is_input = matches!(
428        (account, swap_direction),
429        (UserTokenAccount::Quote, SwapDirection::QuoteToBase)
430            | (UserTokenAccount::Base, SwapDirection::BaseToQuote)
431    );
432    if (is_input && user_input_token_account.is_none())
433        || (!is_input && user_output_token_account.is_none())
434    {
435        Some(create_no_user_funds_error(Some(logs.to_vec())))
436    } else {
437        None
438    }
439}
440
441#[derive(Debug)]
442struct Invocation {
443    program_id: Pubkey,
444    depth: usize,
445    parent: Option<usize>,
446    completed: bool,
447    succeeded: bool,
448    own_anchor_code: Option<u32>,
449    last_failed_child: Option<(usize, Option<u32>)>,
450    propagated_child: Option<usize>,
451}
452
453struct InvocationTrace {
454    invocations: Vec<Invocation>,
455    line_invocations: Vec<Option<usize>>,
456    has_context: bool,
457}
458
459impl InvocationTrace {
460    fn parse(logs: &[String]) -> Self {
461        let mut trace = Self {
462            invocations: Vec::new(),
463            line_invocations: Vec::with_capacity(logs.len()),
464            has_context: false,
465        };
466        let mut stack: Vec<usize> = Vec::new();
467        for line in logs {
468            let mut owner = stack.last().copied();
469            match parse_program_log(line) {
470                Some(ProgramLog::Invoke { program_id, depth }) => {
471                    trace.has_context = true;
472                    while stack
473                        .last()
474                        .is_some_and(|index| trace.invocations[*index].depth >= depth)
475                    {
476                        stack.pop();
477                    }
478                    let parent = stack.last().copied().filter(|index| {
479                        trace.invocations[*index].depth.checked_add(1) == Some(depth)
480                    });
481                    let index = trace.invocations.len();
482                    trace.invocations.push(Invocation {
483                        program_id,
484                        depth,
485                        parent,
486                        completed: false,
487                        succeeded: false,
488                        own_anchor_code: None,
489                        last_failed_child: None,
490                        propagated_child: None,
491                    });
492                    stack.push(index);
493                    owner = Some(index);
494                }
495                Some(ProgramLog::Exit {
496                    program_id,
497                    failed,
498                    custom_code,
499                }) => {
500                    trace.has_context = true;
501                    owner = stack
502                        .iter()
503                        .rposition(|index| trace.invocations[*index].program_id == program_id)
504                        .map(|position| {
505                            let index = stack[position];
506                            let parent = {
507                                let invocation = &mut trace.invocations[index];
508                                invocation.completed = true;
509                                invocation.succeeded = !failed;
510                                invocation.propagated_child = if failed
511                                    && custom_code.is_some()
512                                    && invocation.own_anchor_code != custom_code
513                                {
514                                    invocation
515                                        .last_failed_child
516                                        .and_then(|(child, child_code)| {
517                                            (child_code == custom_code).then_some(child)
518                                        })
519                                } else {
520                                    None
521                                };
522                                invocation.parent
523                            };
524                            if failed {
525                                if let Some(parent) = parent {
526                                    trace.invocations[parent].last_failed_child =
527                                        Some((index, custom_code));
528                                }
529                            }
530                            stack.truncate(position);
531                            index
532                        });
533                }
534                None => {
535                    if let (Some(index), Some((_, code))) = (owner, anchor_error(line)) {
536                        trace.invocations[index].own_anchor_code = Some(code);
537                    }
538                }
539            }
540            trace.line_invocations.push(owner);
541        }
542        trace
543    }
544
545    fn succeeded(&self, mut owner: Option<usize>) -> bool {
546        while let Some(index) = owner {
547            let invocation = &self.invocations[index];
548            if invocation.succeeded {
549                return true;
550            }
551            owner = invocation.parent;
552        }
553        false
554    }
555
556    fn is_on_failure_path(&self, owner: Option<usize>) -> bool {
557        let Some(mut index) = owner else {
558            return true;
559        };
560        loop {
561            let invocation = &self.invocations[index];
562            if invocation.succeeded {
563                return false;
564            }
565            let Some(parent) = invocation.parent else {
566                return true;
567            };
568            let ancestor = &self.invocations[parent];
569            if ancestor.succeeded
570                || (ancestor.completed && ancestor.propagated_child != Some(index))
571            {
572                return false;
573            }
574            index = parent;
575        }
576    }
577}
578
579#[derive(Clone, Copy)]
580struct LoggedProgramError<'a> {
581    error: AnchorErrorCode<'a>,
582    program_id: Option<Pubkey>,
583}
584
585struct ProgramErrorScan<'a> {
586    error: Option<LoggedProgramError<'a>>,
587    saw_error: bool,
588}
589
590fn scan_program_errors<'a>(
591    logs: &'a [String],
592    trace: &InvocationTrace,
593    accepts: impl Fn(Option<&Pubkey>) -> bool,
594) -> ProgramErrorScan<'a> {
595    let mut scan = ProgramErrorScan {
596        error: None,
597        saw_error: false,
598    };
599    for (line, owner) in logs.iter().zip(&trace.line_invocations) {
600        let (error, is_completion) = if let Some((name, code)) = anchor_error(line) {
601            (
602                AnchorErrorCode {
603                    code,
604                    name: Some(name),
605                },
606                false,
607            )
608        } else if let Some(ProgramLog::Exit {
609            failed: true,
610            custom_code: Some(code),
611            ..
612        }) = parse_program_log(line)
613        {
614            (AnchorErrorCode { code, name: None }, true)
615        } else {
616            continue;
617        };
618        scan.saw_error = true;
619        if !trace.is_on_failure_path(*owner) {
620            continue;
621        }
622        let invocation = owner.map(|index| &trace.invocations[index]);
623        if is_completion && invocation.is_some_and(|frame| frame.propagated_child.is_some()) {
624            continue;
625        }
626        let program_id = invocation.map(|frame| frame.program_id);
627        if accepts(program_id.as_ref()) {
628            scan.error = Some(LoggedProgramError { error, program_id });
629            break;
630        }
631    }
632    scan
633}
634
635fn anchor_error(line: &str) -> Option<(&str, u32)> {
636    let (_, suffix) = line.split_once("Error Code: ")?;
637    let (name, number) = suffix.split_once(". Error Number: ")?;
638    if name.is_empty()
639        || !name
640            .bytes()
641            .all(|byte| byte.is_ascii_alphanumeric() || byte == b'_')
642    {
643        return None;
644    }
645    let (number, _) = number.split_once('.')?;
646    if number.is_empty() || !number.bytes().all(|byte| byte.is_ascii_digit()) {
647        return None;
648    }
649    Some((name, number.parse().ok()?))
650}
651
652fn find_error_logs(value: &Value) -> Option<Vec<String>> {
653    let mut pending = vec![value];
654    while let Some(value) = pending.pop() {
655        let entries = value
656            .get("logs")
657            .and_then(Value::as_array)
658            .or_else(|| value.as_array());
659        if let Some(entries) = entries {
660            let logs: Vec<String> = entries
661                .iter()
662                .filter_map(Value::as_str)
663                .map(str::to_owned)
664                .collect();
665            if !logs.is_empty() {
666                return Some(logs);
667            }
668        }
669        // Reverse push preserves the SDK's context/cause/error precedence, then
670        // supports standard JSON-RPC error.data and result.value envelopes.
671        for key in ["value", "result", "data", "error", "cause", "context"] {
672            if let Some(nested) = value.get(key) {
673                pending.push(nested);
674            }
675        }
676    }
677    None
678}
679
680fn read_structured_error_code(
681    value: &Value,
682    allow_unscoped_custom: bool,
683) -> Option<AnchorErrorCode<'_>> {
684    let mut pending = vec![value];
685    while let Some(value) = pending.pop() {
686        if let Some(code) = value
687            .pointer("/errorCode/number")
688            .and_then(structured_code_number)
689        {
690            return Some(AnchorErrorCode {
691                code,
692                name: value.pointer("/errorCode/code").and_then(Value::as_str),
693            });
694        }
695        if allow_unscoped_custom {
696            if let Some(code) = value
697                .pointer("/InstructionError/1/Custom")
698                .and_then(structured_code_number)
699            {
700                return Some(AnchorErrorCode { code, name: None });
701            }
702        }
703        for key in [
704            "err", "value", "result", "data", "error", "cause", "context",
705        ] {
706            if let Some(nested) = value.get(key) {
707                pending.push(nested);
708            }
709        }
710    }
711    None
712}
713
714fn structured_code_number(value: &Value) -> Option<u32> {
715    let number = value.as_f64()?;
716    // JSON has one numeric type; integral floating-point encodings are valid
717    // Anchor numbers too. All u32 codes are exactly representable as f64.
718    (number >= 0.0 && number <= f64::from(u32::MAX) && number.fract() == 0.0)
719        .then_some(number as u32)
720}
721
722fn failed_transfer_checked(
723    logs: &[String],
724    trace: &InvocationTrace,
725    swap_program_id: &Pubkey,
726    treasury_program_id: Option<&Pubkey>,
727) -> Option<(Pubkey, usize)> {
728    let mut counts = vec![0; trace.invocations.len()];
729    let mut ordinals = vec![None; trace.invocations.len()];
730    for (line, owner) in logs.iter().zip(&trace.line_invocations) {
731        let Some(index) = *owner else { continue };
732        let invocation = &trace.invocations[index];
733        if invocation.program_id != SPL_TOKEN_PROGRAM_ADDRESS
734            && invocation.program_id != TOKEN_2022_PROGRAM_ADDRESS
735        {
736            continue;
737        }
738        let Some(parent) = invocation.parent else {
739            continue;
740        };
741        let caller = trace.invocations[parent].program_id;
742        if caller != *swap_program_id && treasury_program_id != Some(&caller) {
743            continue;
744        }
745        if line == "Program log: Instruction: TransferChecked" && ordinals[index].is_none() {
746            counts[parent] += 1;
747            ordinals[index] = Some(counts[parent]);
748        }
749        if line.eq_ignore_ascii_case("Program log: Error: insufficient funds")
750            && invocation.propagated_child.is_none()
751            && trace.is_on_failure_path(Some(index))
752        {
753            if let Some(ordinal) = ordinals[index] {
754                return Some((caller, ordinal));
755            }
756        }
757    }
758    None
759}
760
761#[derive(Clone, Copy)]
762enum UserTokenAccount {
763    Quote,
764    Base,
765}
766
767fn uninitialized_user_token_account(
768    logs: &[String],
769    trace: &InvocationTrace,
770    swap_program_id: &Pubkey,
771) -> Option<UserTokenAccount> {
772    let mut accounts = vec![(false, None); trace.invocations.len()];
773    for (line, owner) in logs.iter().zip(&trace.line_invocations) {
774        let Some(index) = *owner else { continue };
775        if trace.invocations[index].program_id != *swap_program_id || trace.succeeded(Some(index)) {
776            continue;
777        }
778        let (uninitialized, account) = &mut accounts[index];
779        if anchor_error(line).is_some_and(|(name, _)| name == "AccountNotInitialized") {
780            *uninitialized = true;
781        }
782        if let Some((_, name)) = line.split_once("account:") {
783            let name = name
784                .trim_start()
785                .split(|character: char| !character.is_ascii_alphanumeric() && character != '_')
786                .next();
787            match name {
788                Some("quote_token_user_token_account") => *account = Some(UserTokenAccount::Quote),
789                Some("base_token_user_token_account") => *account = Some(UserTokenAccount::Base),
790                _ => {}
791            }
792        }
793    }
794    accounts
795        .into_iter()
796        .find_map(|(uninitialized, account)| if uninitialized { account } else { None })
797}
798
799#[cfg(test)]
800mod tests {
801    use super::*;
802    use serde_json::json;
803
804    fn swap_id() -> Pubkey {
805        Pubkey::new_from_array([3; 32])
806    }
807    fn treasury_id() -> Pubkey {
808        Pubkey::new_from_array([4; 32])
809    }
810    fn other_id() -> Pubkey {
811        Pubkey::new_from_array([5; 32])
812    }
813
814    fn transfer(depth: usize, failed: bool) -> Vec<String> {
815        let token = SPL_TOKEN_PROGRAM_ADDRESS;
816        let mut logs = vec![
817            format!("Program {token} invoke [{depth}]"),
818            "Program log: Instruction: TransferChecked".into(),
819        ];
820        if failed {
821            logs.push("Program log: Error: insufficient funds".into());
822            logs.push(format!("Program {token} failed: custom program error: 0x1"));
823        } else {
824            logs.push(format!("Program {token} success"));
825        }
826        logs
827    }
828
829    #[test]
830    fn colliding_codes_use_the_emitting_program_and_keep_scanning_for_outer_errors() {
831        let swap = swap_id();
832        let treasury = treasury_id();
833        let logs = vec![
834            format!("Program {swap} invoke [1]"),
835            format!("Program {treasury} invoke [2]"),
836            "Program log: Error Code: MissingApyEntry. Error Number: 6014.".into(),
837            format!("Program {treasury} failed: custom program error: 0x177e"),
838            "Program log: Error Code: AmountInTooHigh. Error Number: 6026.".into(),
839        ];
840        let error = json!({"error": {"data": {"logs": logs}, "errorCode": {"number": 6014}}});
841        let parsed = parse_simulation_program_error(&error, &swap, Some(&treasury)).unwrap();
842        assert!(matches!(parsed, ParsedSimulationProgramError::Treasury(_)));
843        assert_eq!(parsed.name(), "MissingApyEntry");
844        assert_eq!(
845            parse_swap_error(&error, Some(&swap)).unwrap().name,
846            "AmountInTooHigh"
847        );
848    }
849
850    #[test]
851    fn terminating_sibling_failure_selects_the_propagated_program_error() {
852        let router = other_id();
853        let swap = swap_id();
854        let treasury = treasury_id();
855        for (caught_name, caught_code) in [
856            ("AmountInTooHigh", 6026_u32),
857            ("AmountInMustBePositive", 6014_u32),
858        ] {
859            let logs = vec![
860                format!("Program {router} invoke [1]"),
861                format!("Program {swap} invoke [2]"),
862                format!("Program log: Error Code: {caught_name}. Error Number: {caught_code}."),
863                format!("Program {swap} failed: custom program error: {caught_code:#x}"),
864                format!("Program {treasury} invoke [2]"),
865                "Program log: Error Code: MissingApyEntry. Error Number: 6014.".into(),
866                format!("Program {treasury} failed: custom program error: 0x177e"),
867                format!("Program {router} failed: custom program error: 0x177e"),
868            ];
869            let parsed =
870                parse_simulation_program_error_from_logs(&logs, &swap, Some(&treasury)).unwrap();
871            assert!(matches!(parsed, ParsedSimulationProgramError::Treasury(_)));
872            assert_eq!(parsed.name(), "MissingApyEntry");
873            assert!(parse_swap_error(&json!({ "logs": logs }), Some(&swap)).is_none());
874        }
875    }
876
877    #[test]
878    fn scoped_navdata_names_override_colliding_swap_idl_numbers() {
879        let swap = swap_id();
880        for (code, name, message) in [
881            (
882                6034,
883                "MissingRedstoneAccount",
884                "Redstone price account missing from remaining accounts",
885            ),
886            (
887                6035,
888                "RedstoneValueTooLarge",
889                "Redstone price value overflows u64",
890            ),
891            (
892                6036,
893                "NavAccountDataTooShort",
894                "Account data is too short for the configured price offset",
895            ),
896            (
897                6037,
898                "InvalidNavAccountOwner",
899                "NAV account is not owned by the expected oracle program",
900            ),
901            (6038, "DuplicateNavSource", "Duplicate NAV source"),
902            (
903                6032,
904                "MissingPythAccount",
905                "Pyth feed missing from remaining accounts",
906            ),
907        ] {
908            let logs = vec![
909                format!("Program {swap} invoke [1]"),
910                format!("Program log: AnchorError occurred. Error Code: {name}. Error Number: {code}. Error Message: {message}."),
911                format!("Program {swap} failed: custom program error: {code:#x}"),
912            ];
913            let parsed = parse_simulation_program_error_from_logs(&logs, &swap, None).unwrap();
914            assert!(matches!(parsed, ParsedSimulationProgramError::Swap(_)));
915            assert_eq!(parsed.code(), code);
916            assert_eq!(parsed.name(), name);
917            assert_eq!(parsed.message(), message);
918            assert_eq!(parsed.category(), Some(SwapErrorCategory::Oracle));
919            assert_eq!(
920                parse_swap_error(&json!({"logs": logs}), Some(&swap))
921                    .unwrap()
922                    .name,
923                name
924            );
925        }
926    }
927
928    #[test]
929    fn treasury_navdata_errors_keep_the_enclosing_program_namespace() {
930        let swap = swap_id();
931        let treasury = treasury_id();
932        let error = json!({"logs": [
933            format!("Program {swap} invoke [1]"),
934            format!("Program {treasury} invoke [2]"),
935            "Program log: AnchorError occurred. Error Code: InvalidNav. Error Number: 6000. Error Message: Invalid NAV.",
936            format!("Program {treasury} failed: custom program error: 0x1770"),
937            format!("Program {swap} failed: custom program error: 0x1770"),
938        ]});
939        let parsed = parse_simulation_program_error(&error, &swap, Some(&treasury)).unwrap();
940        assert!(matches!(parsed, ParsedSimulationProgramError::Treasury(_)));
941        assert_eq!(parsed.name(), "InvalidNav");
942        assert_eq!(parsed.message(), "Invalid NAV");
943        assert_eq!(
944            parse_treasury_error(&error, Some(&treasury)).unwrap().name,
945            "InvalidNav"
946        );
947        assert!(parse_swap_error(&error, Some(&swap)).is_none());
948
949        let own = parse_treasury_error(
950            &json!({"error": {"errorCode": {"number": 6006, "code": "InvalidNav"}}}),
951            None,
952        )
953        .unwrap();
954        assert_eq!(own.name, "InvalidNav");
955        assert_eq!(own.message, "NAV must be positive");
956    }
957
958    #[test]
959    fn structured_navdata_names_require_matching_numbers_and_keep_numeric_fallback() {
960        let named =
961            json!({"error": {"errorCode": {"number": 6034, "code": "MissingRedstoneAccount"}}});
962        assert_eq!(
963            parse_swap_error(&named, None).unwrap().name,
964            "MissingRedstoneAccount"
965        );
966        assert_eq!(
967            parse_treasury_error(&named, None).unwrap().name,
968            "MissingRedstoneAccount"
969        );
970        let own = json!({"error": {"errorCode": {"number": 6034, "code": "FeedIdMismatch"}}});
971        assert_eq!(parse_swap_error(&own, None).unwrap().name, "FeedIdMismatch");
972        let mismatched =
973            json!({"error": {"errorCode": {"number": 6035, "code": "MissingRedstoneAccount"}}});
974        assert_eq!(
975            parse_swap_error(&mismatched, None).unwrap().name,
976            "MissingTreasuryAccounts"
977        );
978        let number_only = json!({"error": {"errorCode": {"number": 6034}}});
979        assert_eq!(
980            parse_swap_error(&number_only, None).unwrap().name,
981            "FeedIdMismatch"
982        );
983        assert_eq!(
984            parse_treasury_error(&number_only, None).unwrap().name,
985            "ApyExceedsMax"
986        );
987    }
988
989    #[test]
990    fn foreign_cpi_cannot_spoof_navdata_identity_or_revive_it_via_structured_fallback() {
991        let swap = swap_id();
992        let other = other_id();
993        let error = json!({
994            "logs": [
995                format!("Program {swap} invoke [1]"),
996                format!("Program {other} invoke [2]"),
997                "Program log: Error Code: MissingRedstoneAccount. Error Number: 6034.",
998                format!("Program {other} failed: custom program error: 0x1792"),
999                format!("Program {swap} failed: custom program error: 0x1792"),
1000            ],
1001            "error": {"errorCode": {"number": 6034, "code": "MissingRedstoneAccount"}},
1002        });
1003        assert!(parse_swap_error(&error, Some(&swap)).is_none());
1004        assert!(parse_simulation_program_error(&error, &swap, None).is_none());
1005    }
1006
1007    #[test]
1008    fn successful_or_caught_cpi_name_cannot_override_an_outer_same_number_error() {
1009        let swap = swap_id();
1010        let treasury = treasury_id();
1011        let wrapper = other_id();
1012        for exit in ["success", "failed: custom program error: 0x1792"] {
1013            let logs = vec![
1014                format!("Program {swap} invoke [1]"),
1015                format!("Program {wrapper} invoke [2]"),
1016                format!("Program {treasury} invoke [3]"),
1017                "Program log: Error Code: MissingRedstoneAccount. Error Number: 6034.".into(),
1018                format!("Program {treasury} {exit}"),
1019                format!("Program {wrapper} success"),
1020                "Program log: Error Code: FeedIdMismatch. Error Number: 6034.".into(),
1021                format!("Program {swap} failed: custom program error: 0x1792"),
1022            ];
1023            let parsed =
1024                parse_simulation_program_error_from_logs(&logs, &swap, Some(&treasury)).unwrap();
1025            assert!(matches!(parsed, ParsedSimulationProgramError::Swap(_)));
1026            assert_eq!(parsed.name(), "FeedIdMismatch");
1027            assert_eq!(parsed.category(), Some(SwapErrorCategory::Oracle));
1028            assert!(parse_treasury_error(&json!({"logs": logs}), Some(&treasury)).is_none());
1029        }
1030    }
1031
1032    #[test]
1033    fn production_errors_preserve_namespace_and_fee_pause_category() {
1034        let swap = swap_id();
1035        let treasury = treasury_id();
1036        let fee_pause = parse_swap_error(&json!({"errorCode": {"number": 6045}}), None).unwrap();
1037        assert_eq!(fee_pause.name, "FeeAssetPaused");
1038        assert_eq!(fee_pause.category, SwapErrorCategory::Paused);
1039        for (code, expected) in [
1040            (6045, "SignerInRemainingAccounts"),
1041            (6046, "AmountOutTooLow"),
1042            (6047, "AmountInTooHigh"),
1043        ] {
1044            let logs = vec![
1045                format!("Program {swap} invoke [1]"),
1046                format!("Program {treasury} invoke [2]"),
1047                format!("Program {treasury} failed: custom program error: {code:#x}"),
1048                format!("Program {swap} failed: custom program error: {code:#x}"),
1049            ];
1050            let error = parse_simulation_program_error(
1051                &json!({"data": {"logs": logs}}),
1052                &swap,
1053                Some(&treasury),
1054            )
1055            .unwrap();
1056            assert!(matches!(error, ParsedSimulationProgramError::Treasury(_)));
1057            assert_eq!(error.name(), expected);
1058        }
1059    }
1060
1061    #[test]
1062    fn successful_cpi_and_caught_failed_cpi_do_not_supply_later_errors() {
1063        let swap = swap_id();
1064        let treasury = treasury_id();
1065        for exit in ["success", "failed: custom program error: 0x177e"] {
1066            let wrapper = other_id();
1067            let logs = vec![
1068                format!("Program {swap} invoke [1]"),
1069                format!("Program {wrapper} invoke [2]"),
1070                format!("Program {treasury} invoke [3]"),
1071                "Program log: Error Code: MissingApyEntry. Error Number: 6014.".into(),
1072                format!("Program {treasury} {exit}"),
1073                format!("Program {wrapper} success"),
1074                "Program log: Error Code: AmountInTooHigh. Error Number: 6026.".into(),
1075            ];
1076            let parsed =
1077                parse_simulation_program_error_from_logs(&logs, &swap, Some(&treasury)).unwrap();
1078            assert!(matches!(parsed, ParsedSimulationProgramError::Swap(_)));
1079            assert_eq!(parsed.code(), 6026);
1080        }
1081    }
1082
1083    #[test]
1084    fn rpc_custom_errors_require_runtime_ownership_and_do_not_relabel_propagation() {
1085        let swap = swap_id();
1086        let treasury = treasury_id();
1087        let error = json!({"result": {"value": {
1088            "err": {"InstructionError": [0, {"Custom": 6014}]},
1089            "logs": [
1090                format!("Program {swap} invoke [1]"),
1091                format!("Program {treasury} invoke [2]"),
1092                format!("Program {treasury} failed: custom program error: 0x177e"),
1093                format!("Program {swap} failed: custom program error: 0x177e")
1094            ]
1095        }}});
1096        assert_eq!(
1097            parse_simulation_program_error(&error, &swap, Some(&treasury))
1098                .unwrap()
1099                .name(),
1100            "MissingApyEntry"
1101        );
1102        assert!(parse_swap_error(&error, Some(&swap)).is_none());
1103        let unscoped = json!({"err": {"InstructionError": [0, {"Custom": 6014}]}});
1104        assert!(parse_simulation_program_error(&unscoped, &swap, Some(&treasury)).is_none());
1105        assert!(parse_swap_error(&unscoped, Some(&swap)).is_none());
1106        assert_eq!(
1107            parse_swap_error(&unscoped, None).unwrap().name,
1108            "AmountInMustBePositive"
1109        );
1110    }
1111
1112    #[test]
1113    fn nested_logs_and_structured_anchor_codes_preserve_metadata_without_cross_program_fallback() {
1114        let swap = swap_id();
1115        let other = other_id();
1116        let error = json!({"context": {"cause": {"logs": [123, "Program log: unrelated", "Program log: Error Code: AmountOutTooLow. Error Number: 6027.", null]}}});
1117        let parsed = parse_swap_error(&error, None).unwrap();
1118        assert_eq!(parsed.category, SwapErrorCategory::Slippage);
1119        assert_eq!(
1120            parsed.logs.unwrap(),
1121            vec![
1122                "Program log: unrelated",
1123                "Program log: Error Code: AmountOutTooLow. Error Number: 6027."
1124            ]
1125        );
1126        assert!(parse_swap_error(&error, Some(&swap)).is_none());
1127        let structured = json!({"logs": ["Program log: no Anchor code"], "error": {"errorCode": {"number": 6026.0}}});
1128        assert_eq!(
1129            parse_swap_error(&structured, Some(&swap)).unwrap().name,
1130            "AmountInTooHigh"
1131        );
1132        let rejected = json!({"logs": [format!("Program {other} invoke [1]"), "Program log: Error Code: Other. Error Number: 6014."], "error": {"errorCode": {"number": 6014}}});
1133        assert!(parse_swap_error(&rejected, Some(&swap)).is_none());
1134        for number in [
1135            json!("6000"),
1136            json!(6000.5),
1137            json!(-1),
1138            json!(u64::MAX),
1139            json!(7000),
1140        ] {
1141            assert!(
1142                parse_swap_error(&json!({"error": {"errorCode": {"number": number}}}), None)
1143                    .is_none()
1144            );
1145        }
1146    }
1147
1148    #[test]
1149    fn transfer_ordinals_are_per_caller_and_optional_fees_shift_user_input() {
1150        let swap = swap_id();
1151        let treasury = treasury_id();
1152        let mut logs = vec![format!("Program {swap} invoke [1]")];
1153        logs.extend(transfer(2, false));
1154        logs.push(format!("Program {treasury} invoke [2]"));
1155        logs.extend(transfer(3, false));
1156        logs.push(format!("Program {treasury} success"));
1157        logs.extend(transfer(2, false));
1158        logs.extend(transfer(2, true));
1159        let parsed = parse_synthetic_simulation_error(
1160            &logs,
1161            SwapDirection::BaseToQuote,
1162            None,
1163            None,
1164            &swap,
1165            Some(&treasury),
1166            true,
1167        )
1168        .unwrap();
1169        assert_eq!(parsed.category, SwapErrorCategory::UserFunds);
1170        assert_eq!(parsed.code, 2);
1171
1172        let mut treasury_failure = vec![
1173            format!("Program {swap} invoke [1]"),
1174            format!("Program {treasury} invoke [2]"),
1175        ];
1176        treasury_failure.extend(transfer(3, true));
1177        let parsed = parse_synthetic_simulation_error(
1178            &treasury_failure,
1179            SwapDirection::QuoteToBase,
1180            None,
1181            None,
1182            &swap,
1183            Some(&treasury),
1184            false,
1185        )
1186        .unwrap();
1187        assert_eq!(parsed.category, SwapErrorCategory::Liquidity);
1188        assert_eq!(parsed.code, 1);
1189    }
1190
1191    #[test]
1192    fn completed_transfers_and_transfer_hooks_cannot_leak_funds_attribution() {
1193        let swap = swap_id();
1194        let other = other_id();
1195        let mut logs = vec![format!("Program {swap} invoke [1]")];
1196        logs.extend(transfer(2, false));
1197        logs.extend([
1198            format!("Program {other} invoke [2]"),
1199            "Program log: Error: insufficient funds".into(),
1200            format!("Program {other} failed: custom program error: 0x1"),
1201        ]);
1202        assert!(parse_synthetic_simulation_error(
1203            &logs,
1204            SwapDirection::QuoteToBase,
1205            None,
1206            None,
1207            &swap,
1208            None,
1209            false
1210        )
1211        .is_none());
1212
1213        let token = SPL_TOKEN_PROGRAM_ADDRESS;
1214        let hook_logs = vec![
1215            format!("Program {swap} invoke [1]"),
1216            format!("Program {token} invoke [2]"),
1217            "Program log: Instruction: TransferChecked".into(),
1218            format!("Program {other} invoke [3]"),
1219            "Program log: Error: insufficient funds".into(),
1220            format!("Program {other} failed: custom program error: 0x1"),
1221            format!("Program {token} failed: custom program error: 0x1"),
1222        ];
1223        assert!(parse_synthetic_simulation_error(
1224            &hook_logs,
1225            SwapDirection::QuoteToBase,
1226            None,
1227            None,
1228            &swap,
1229            None,
1230            false
1231        )
1232        .is_none());
1233    }
1234
1235    #[test]
1236    fn token_2022_propagated_hook_error_is_not_a_balance_diagnosis() {
1237        let swap = swap_id();
1238        let token = TOKEN_2022_PROGRAM_ADDRESS;
1239        let hook = other_id();
1240        let logs = vec![
1241            format!("Program {swap} invoke [1]"),
1242            format!("Program {token} invoke [2]"),
1243            "Program log: Instruction: TransferChecked".into(),
1244            format!("Program {hook} invoke [3]"),
1245            format!("Program {hook} failed: custom program error: 0x1"),
1246            "Program log: Error: insufficient funds".into(),
1247            format!("Program {token} failed: custom program error: 0x1"),
1248            format!("Program {swap} failed: custom program error: 0x1"),
1249        ];
1250        assert!(parse_synthetic_simulation_error(
1251            &logs,
1252            SwapDirection::QuoteToBase,
1253            None,
1254            None,
1255            &swap,
1256            None,
1257            false
1258        )
1259        .is_none());
1260    }
1261
1262    #[test]
1263    fn token_2022_direct_balance_failure_keeps_funds_attribution() {
1264        let swap = swap_id();
1265        let token = TOKEN_2022_PROGRAM_ADDRESS;
1266        let logs = vec![
1267            format!("Program {swap} invoke [1]"),
1268            format!("Program {token} invoke [2]"),
1269            "Program log: Instruction: TransferChecked".into(),
1270            "Program log: Error: insufficient funds".into(),
1271            format!("Program {token} failed: custom program error: 0x1"),
1272            format!("Program {swap} failed: custom program error: 0x1"),
1273        ];
1274        let parsed = parse_synthetic_simulation_error(
1275            &logs,
1276            SwapDirection::QuoteToBase,
1277            None,
1278            None,
1279            &swap,
1280            None,
1281            false,
1282        )
1283        .unwrap();
1284        assert_eq!(parsed.category, SwapErrorCategory::Liquidity);
1285        assert_eq!(parsed.code, 1);
1286    }
1287
1288    #[test]
1289    fn uninitialized_accounts_are_scoped_to_swap_and_respect_explicit_overrides() {
1290        let swap = swap_id();
1291        let other = other_id();
1292        let mut logs = vec![
1293            format!("Program {swap} invoke [1]"),
1294            "Program log: AnchorError caused by account: quote_token_user_token_account. Error Code: AccountNotInitialized. Error Number: 3012.".into(),
1295        ];
1296        assert_eq!(
1297            parse_synthetic_simulation_error(
1298                &logs,
1299                SwapDirection::QuoteToBase,
1300                None,
1301                None,
1302                &swap,
1303                None,
1304                false
1305            )
1306            .unwrap()
1307            .category,
1308            SwapErrorCategory::UserFunds
1309        );
1310        assert!(parse_synthetic_simulation_error(
1311            &logs,
1312            SwapDirection::QuoteToBase,
1313            Some(&other),
1314            None,
1315            &swap,
1316            None,
1317            false
1318        )
1319        .is_none());
1320        logs[0] = format!("Program {other} invoke [1]");
1321        assert!(parse_synthetic_simulation_error(
1322            &logs,
1323            SwapDirection::QuoteToBase,
1324            None,
1325            None,
1326            &swap,
1327            None,
1328            false
1329        )
1330        .is_none());
1331    }
1332}