0.7.28 - final

kb_lib/src/db/dtos/program_instruction_diagnostic.rs

@@ -0,0 +1,298 @@
+// file: kb_lib/src/db/dtos/program_instruction_diagnostic.rs
+
+//! Program instruction diagnostic DTO.
+
+/// Diagnostic row for instructions of one Solana program.
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct ProgramInstructionDiagnosticDto {
+    /// Parent transaction id.
+    pub transaction_id: i64,
+    /// Transaction signature.
+    pub signature: std::string::String,
+    /// Optional Solana slot.
+    pub slot: std::option::Option<u64>,
+    /// Internal instruction id.
+    pub instruction_id: i64,
+    /// Optional parent instruction id.
+    pub parent_instruction_id: std::option::Option<i64>,
+    /// Outer instruction index.
+    pub instruction_index: u32,
+    /// Optional inner instruction index.
+    pub inner_instruction_index: std::option::Option<u32>,
+    /// Program id.
+    pub program_id: std::option::Option<std::string::String>,
+    /// Optional program name.
+    pub program_name: std::option::Option<std::string::String>,
+    /// Optional stack height.
+    pub stack_height: std::option::Option<u32>,
+    /// Number of accounts in `accounts_json`.
+    pub accounts_count: u64,
+    /// First account, when present.
+    pub account_0: std::option::Option<std::string::String>,
+    /// Second account, when present.
+    pub account_1: std::option::Option<std::string::String>,
+    /// Third account, when present.
+    pub account_2: std::option::Option<std::string::String>,
+    /// Fourth account, when present.
+    pub account_3: std::option::Option<std::string::String>,
+    /// Last account, when present.
+    pub last_account: std::option::Option<std::string::String>,
+    /// Optional parsed instruction type.
+    pub parsed_type: std::option::Option<std::string::String>,
+    /// True when `data_json` exists.
+    pub has_data_json: bool,
+    /// True when `parsed_json` exists.
+    pub has_parsed_json: bool,
+    /// Short data JSON preview.
+    pub data_json_preview: std::option::Option<std::string::String>,
+    /// Short parsed JSON preview.
+    pub parsed_json_preview: std::option::Option<std::string::String>,
+    /// JSON array of useful log hints.
+    pub log_hints_json: std::string::String,
+}
+
+impl TryFrom<crate::ProgramInstructionDiagnosticEntity> for ProgramInstructionDiagnosticDto {
+    type Error = crate::Error;
+
+    fn try_from(entity: crate::ProgramInstructionDiagnosticEntity) -> Result<Self, Self::Error> {
+        let slot = match entity.slot {
+            Some(slot) => match u64::try_from(slot) {
+                Ok(slot) => Some(slot),
+                Err(error) => {
+                    return Err(crate::Error::Db(format!(
+                        "cannot convert program instruction diagnostic slot '{}' to u64: {}",
+                        slot, error
+                    )));
+                },
+            },
+            None => None,
+        };
+        let instruction_index = match u32::try_from(entity.instruction_index) {
+            Ok(instruction_index) => instruction_index,
+            Err(error) => {
+                return Err(crate::Error::Db(format!(
+                    "cannot convert program instruction diagnostic instruction_index '{}' to u32: {}",
+                    entity.instruction_index, error
+                )));
+            },
+        };
+        let inner_instruction_index = match entity.inner_instruction_index {
+            Some(inner_instruction_index) => match u32::try_from(inner_instruction_index) {
+                Ok(inner_instruction_index) => Some(inner_instruction_index),
+                Err(error) => {
+                    return Err(crate::Error::Db(format!(
+                        "cannot convert program instruction diagnostic inner_instruction_index '{}' to u32: {}",
+                        inner_instruction_index, error
+                    )));
+                },
+            },
+            None => None,
+        };
+        let stack_height = match entity.stack_height {
+            Some(stack_height) => match u32::try_from(stack_height) {
+                Ok(stack_height) => Some(stack_height),
+                Err(error) => {
+                    return Err(crate::Error::Db(format!(
+                        "cannot convert program instruction diagnostic stack_height '{}' to u32: {}",
+                        stack_height, error
+                    )));
+                },
+            },
+            None => None,
+        };
+        let accounts = parse_accounts_json(entity.accounts_json.as_str());
+        let accounts_count = match u64::try_from(accounts.len()) {
+            Ok(accounts_count) => accounts_count,
+            Err(error) => {
+                return Err(crate::Error::Db(format!(
+                    "cannot convert accounts count to u64: {}",
+                    error
+                )));
+            },
+        };
+        let account_0 = account_at(&accounts, 0);
+        let account_1 = account_at(&accounts, 1);
+        let account_2 = account_at(&accounts, 2);
+        let account_3 = account_at(&accounts, 3);
+        let last_account = match accounts.last() {
+            Some(last_account) => Some(last_account.clone()),
+            None => None,
+        };
+        let log_hints =
+            collect_log_hints(entity.meta_json.as_deref(), entity.transaction_json.as_str());
+        let log_hints_json_result = serde_json::to_string(&log_hints);
+        let log_hints_json = match log_hints_json_result {
+            Ok(log_hints_json) => log_hints_json,
+            Err(error) => {
+                return Err(crate::Error::Json(format!(
+                    "cannot serialize program instruction log hints: {}",
+                    error
+                )));
+            },
+        };
+        return Ok(Self {
+            transaction_id: entity.transaction_id,
+            signature: entity.signature,
+            slot,
+            instruction_id: entity.instruction_id,
+            parent_instruction_id: entity.parent_instruction_id,
+            instruction_index,
+            inner_instruction_index,
+            program_id: entity.program_id,
+            program_name: entity.program_name,
+            stack_height,
+            accounts_count,
+            account_0,
+            account_1,
+            account_2,
+            account_3,
+            last_account,
+            parsed_type: entity.parsed_type,
+            has_data_json: entity.data_json.is_some(),
+            has_parsed_json: entity.parsed_json.is_some(),
+            data_json_preview: preview_text(entity.data_json.as_deref(), 600),
+            parsed_json_preview: preview_text(entity.parsed_json.as_deref(), 1200),
+            log_hints_json,
+        });
+    }
+}
+
+fn account_at(
+    accounts: &[std::string::String],
+    index: usize,
+) -> std::option::Option<std::string::String> {
+    match accounts.get(index) {
+        Some(account) => return Some(account.clone()),
+        None => return None,
+    }
+}
+
+fn preview_text(
+    text: std::option::Option<&str>,
+    max_len: usize,
+) -> std::option::Option<std::string::String> {
+    let text = match text {
+        Some(text) => text,
+        None => return None,
+    };
+    if text.len() <= max_len {
+        return Some(text.to_string());
+    }
+    let mut preview = text.chars().take(max_len).collect::<std::string::String>();
+    preview.push_str("...");
+    return Some(preview);
+}
+
+fn parse_accounts_json(accounts_json: &str) -> std::vec::Vec<std::string::String> {
+    let parsed_result = serde_json::from_str::<serde_json::Value>(accounts_json);
+    let parsed = match parsed_result {
+        Ok(parsed) => parsed,
+        Err(_) => return std::vec::Vec::new(),
+    };
+    let array = match parsed.as_array() {
+        Some(array) => array,
+        None => return std::vec::Vec::new(),
+    };
+    let mut accounts = std::vec::Vec::new();
+    for item in array {
+        if let Some(text) = item.as_str() {
+            accounts.push(text.to_string());
+            continue;
+        }
+        if let Some(pubkey) = item.get("pubkey").and_then(|value| value.as_str()) {
+            accounts.push(pubkey.to_string());
+        }
+    }
+    return accounts;
+}
+
+fn collect_log_hints(
+    meta_json: std::option::Option<&str>,
+    transaction_json: &str,
+) -> std::vec::Vec<std::string::String> {
+    let mut hints = std::vec::Vec::new();
+    if let Some(meta_json) = meta_json {
+        collect_log_hints_from_json_text(meta_json, &mut hints);
+    }
+    collect_log_hints_from_json_text(transaction_json, &mut hints);
+    hints.sort();
+    hints.dedup();
+    return hints;
+}
+
+fn collect_log_hints_from_json_text(
+    json_text: &str,
+    hints: &mut std::vec::Vec<std::string::String>,
+) {
+    let value_result = serde_json::from_str::<serde_json::Value>(json_text);
+    let value = match value_result {
+        Ok(value) => value,
+        Err(_) => return,
+    };
+    collect_log_hints_from_value(&value, hints);
+}
+
+fn collect_log_hints_from_value(
+    value: &serde_json::Value,
+    hints: &mut std::vec::Vec<std::string::String>,
+) {
+    match value {
+        serde_json::Value::String(text) => {
+            let normalized = text.to_ascii_lowercase();
+            if normalized.contains("instruction:")
+                || normalized.contains("meteora")
+                || normalized.contains("dlmm")
+                || normalized.contains("lb")
+                || normalized.contains("swap")
+                || normalized.contains("bin")
+            {
+                hints.push(text.clone());
+            }
+        },
+        serde_json::Value::Array(values) => {
+            for nested in values {
+                collect_log_hints_from_value(nested, hints);
+            }
+        },
+        serde_json::Value::Object(object) => {
+            for nested in object.values() {
+                collect_log_hints_from_value(nested, hints);
+            }
+        },
+        _ => {},
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn accounts_json_extracts_string_accounts() {
+        let accounts = super::parse_accounts_json(
+            serde_json::json!(["A111", "B222", "C333"]).to_string().as_str(),
+        );
+        assert_eq!(accounts.len(), 3);
+        assert_eq!(accounts[0], "A111");
+        assert_eq!(accounts[1], "B222");
+        assert_eq!(accounts[2], "C333");
+    }
+
+    #[test]
+    fn log_hints_are_extracted_from_nested_json() {
+        let mut hints = std::vec::Vec::new();
+        super::collect_log_hints_from_json_text(
+            serde_json::json!({
+                "meta": {
+                    "logMessages": [
+                        "Program log: Instruction: Swap",
+                        "irrelevant"
+                    ]
+                }
+            })
+            .to_string()
+            .as_str(),
+            &mut hints,
+        );
+        assert_eq!(hints.len(), 1);
+        assert_eq!(hints[0], "Program log: Instruction: Swap");
+    }
+}