1use 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#[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
134pub 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
152pub 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
167fn 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
303pub 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 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
347pub 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
360pub 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
396pub 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 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 (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}