automatically lookup errors for batch action commands

Cargo.toml

@@ -44,6 +44,8 @@ spl-token = "3.5.0"
 structopt = "0.3.26"
 thiserror = "1.0.40"
 tokio = "1.14.1"
+regex = "1.8.3"
+once_cell = "1.18.0"
 
 [features]
 

src/cache/mod.rs

@@ -2,9 +2,12 @@ use anyhow::{anyhow, Result as AnyResult};
 use async_trait::async_trait;
 use indexmap::IndexMap;
 use log::info;
+use once_cell::sync::Lazy;
+use regex::Regex;
 use serde::{Deserialize, Serialize};
 use solana_client::rpc_client::RpcClient;
 use solana_sdk::signature::Keypair;
+
 use std::{
     collections::HashMap,
     fs::{File, OpenOptions},
@@ -16,7 +19,7 @@ use std::{
 
 use crate::{
     constants::NANO_SECONDS_IN_SECOND, errors::ActionError,
-    limiter::create_rate_limiter_with_capacity, spinner::create_progress_bar,
+    limiter::create_rate_limiter_with_capacity, spinner::create_progress_bar, utils::find_tm_error,
 };
 
 #[derive(Debug, Deserialize, Serialize)]
@@ -60,11 +63,23 @@ impl Cache {
         // Clear out old errors.
         self.clear();
 
+        //Regex to find hex codes in error
+        static RE: Lazy<Regex> =
+            Lazy::new(|| Regex::new(r" 0x[0-9a-fA-F]+").expect("Failed to create regex"));
+
         for error in errors {
             match error {
                 ActionError::ActionFailed(mint_address, _) => {
+                    // Find hex codes in error message.
+                    let error_message = if let Some(mat) = RE.find(&error.to_string()) {
+                        find_tm_error(&mat.as_str().trim_start().replace("0x", ""))
+                            .unwrap_or_else(|| error.to_string())
+                    } else {
+                        error.to_string()
+                    };
+
                     let item = CacheItem {
-                        error: Some(error.to_string()),
+                        error: Some(error_message),
                     };
 
                     self.insert(mint_address.to_string(), item);

src/utils.rs

@@ -236,6 +236,12 @@ pub fn find_errors(hex_code: &str) -> Vec<FoundError> {
     found_errors
 }
 
+pub fn find_tm_error(hex_code: &str) -> Option<String> {
+    let hex_code = hex_code.to_uppercase();
+
+    METADATA_ERROR.get(&hex_code).map(|e| e.to_string())
+}
+
 pub fn clone_keypair(keypair: &Keypair) -> Keypair {
     Keypair::from_bytes(&keypair.to_bytes()).unwrap()
 }