add callback to subscribe

src/common/logs_parser.rs

@@ -0,0 +1,173 @@
+use base64::{Engine as _, engine::general_purpose::STANDARD as BASE64};
+
+use crate::error::{ClientError, ClientResult};
+use crate::common::{
+    logs_data::{DexInstruction, CreateTokenInfo, TradeInfo}, 
+    logs_filters::LogFilter
+};
+
+use solana_sdk::pubkey::Pubkey;
+
+pub async fn process_logs<F>(
+    signature: &str,
+    logs: Vec<String>,
+    callback: F,
+    payer: Option<Pubkey>,
+) -> ClientResult<()>
+where
+    F: Fn(&str, DexInstruction) + Send + Sync,
+{
+    let instructions = LogFilter::parse_instruction(&logs, payer)?;
+    for instruction in instructions {
+        callback(signature, instruction);
+    }
+    Ok(())
+}
+
+// Add parsing function
+pub fn parse_create_token_data(data: &str) -> ClientResult<CreateTokenInfo> {
+    // First do base64 decoding
+    let decoded = BASE64.decode(data)
+        .map_err(|e| ClientError::Other(format!("Failed to decode base64: {}", e)))?;
+    
+    // Skip prefix bytes (if any)
+    let mut cursor = if decoded.len() > 8 { 8 } else { 0 };
+    
+    // Read name length and name
+    if cursor + 4 > decoded.len() {
+        return Err(ClientError::Other("Data too short for name length".to_string()));
+    }
+    let name_len = read_u32(&decoded[cursor..]) as usize;
+    cursor += 4;
+    
+    if cursor + name_len > decoded.len() {
+        return Err(ClientError::Other(format!("Data too short for name: need {} bytes", name_len)));
+    }
+    let name = String::from_utf8(decoded[cursor..cursor + name_len].to_vec())
+        .map_err(|e| ClientError::Other(format!("Invalid UTF-8 in name: {}", e)))?;
+    cursor += name_len;
+    
+    // Read symbol length and symbol
+    if cursor + 4 > decoded.len() {
+        return Err(ClientError::Other("Data too short for symbol length".to_string()));
+    }
+    let symbol_len = read_u32(&decoded[cursor..]) as usize;
+    cursor += 4;
+    
+    if cursor + symbol_len > decoded.len() {
+        return Err(ClientError::Other(format!("Data too short for symbol: need {} bytes", symbol_len)));
+    }
+    let symbol = String::from_utf8(decoded[cursor..cursor + symbol_len].to_vec())
+        .map_err(|e| ClientError::Other(format!("Invalid UTF-8 in symbol: {}", e)))?;
+    cursor += symbol_len;
+    
+    // Read URI length and URI
+    if cursor + 4 > decoded.len() {
+        return Err(ClientError::Other("Data too short for URI length".to_string()));
+    }
+    let uri_len = read_u32(&decoded[cursor..]) as usize;
+    cursor += 4;
+    
+    if cursor + uri_len > decoded.len() {
+        return Err(ClientError::Other(format!("Data too short for URI: need {} bytes", uri_len)));
+    }
+    let uri = String::from_utf8(decoded[cursor..cursor + uri_len].to_vec())
+        .map_err(|e| ClientError::Other(format!("Invalid UTF-8 in uri: {}", e)))?;
+    cursor += uri_len;
+    
+    // Make sure there is enough data to read public keys
+    if cursor + 32 * 3 > decoded.len() {
+        return Err(ClientError::Other("Data too short for public keys".to_string()));
+    }
+    
+    // Parse Mint Public Key
+    let mint = bs58::encode(&decoded[cursor..cursor+32]).into_string();
+    cursor += 32;
+
+    // Parse Bonding Curve Public Key
+    let bonding_curve = bs58::encode(&decoded[cursor..cursor+32]).into_string();
+    cursor += 32;
+
+    // Parse User Public Key
+    let user = bs58::encode(&decoded[cursor..cursor+32]).into_string();
+
+    Ok(CreateTokenInfo {
+        signature: String::new(),
+        name,
+        symbol,
+        uri,
+        mint,
+        bonding_curve,
+        user,
+    })
+}
+
+fn read_u32(data: &[u8]) -> u32 {
+    let mut bytes = [0u8; 4];
+    bytes.copy_from_slice(&data[..4]);
+    u32::from_le_bytes(bytes)
+}
+
+pub fn parse_trade_data(data: &str) -> ClientResult<TradeInfo> {
+    let engine = base64::engine::general_purpose::STANDARD;
+    let decoded = engine.decode(data).map_err(|e| 
+        ClientError::Parse(
+            "Failed to decode base64".to_string(),
+            e.to_string()
+        )
+    )?;
+
+    let mut cursor = 8;  // Skip prefix
+
+    // 1. Mint (32 bytes)
+    let mint = bs58::encode(&decoded[cursor..cursor + 32]).into_string();
+    cursor += 32;
+
+    // 2. Sol Amount (8 bytes)
+    let sol_amount = u64::from_le_bytes(decoded[cursor..cursor + 8].try_into().unwrap());
+    cursor += 8;
+
+    // 3. Token Amount (8 bytes)
+    let token_amount = u64::from_le_bytes(decoded[cursor..cursor + 8].try_into().unwrap());
+    cursor += 8;
+
+    // 4. Is Buy (1 byte)
+    let is_buy = decoded[cursor] != 0;
+    cursor += 1;
+
+    // 5. User (32 bytes)
+    let user = bs58::encode(&decoded[cursor..cursor + 32]).into_string();
+    cursor += 32;
+
+    // 6. Timestamp (8 bytes)
+    let timestamp = i64::from_le_bytes(decoded[cursor..cursor + 8].try_into().unwrap());
+    cursor += 8;
+
+    // 7. Virtual Sol Reserves (8 bytes)
+    let virtual_sol_reserves = u64::from_le_bytes(decoded[cursor..cursor + 8].try_into().unwrap());
+    cursor += 8;
+
+    // 8. Virtual Token Reserves (8 bytes)
+    let virtual_token_reserves = u64::from_le_bytes(decoded[cursor..cursor + 8].try_into().unwrap());
+    cursor += 8;
+
+    let real_sol_reserves = u64::from_le_bytes(decoded[cursor..cursor + 8].try_into().unwrap());
+    cursor += 8;
+
+    let real_token_reserves = u64::from_le_bytes(decoded[cursor..cursor + 8].try_into().unwrap());
+
+    Ok(TradeInfo {
+        signature: String::new(),
+        mint,
+        bonding_curve: String::new(),
+        sol_amount,
+        token_amount,
+        is_buy,
+        user,
+        timestamp,
+        virtual_sol_reserves,
+        virtual_token_reserves,
+        real_sol_reserves,
+        real_token_reserves,
+    })
+}