0.7.11

CHANGELOG.md

@@ -41,3 +41,4 @@
 0.7.8 - Ajout du premier support Meteora DAMM v1 avec décodage create_pool/swap, persistance des événements décodés et détection métier automatique pool/pair/listing  
 0.7.9 - Ajout d’un registre des surfaces de lancement, d’une attribution automatique des pools détectés à une origine de lancement, et d’un premier support Meteora Fun Launch au-dessus de Meteora DBC / DAMM  
 0.7.10 - Ajout du premier support Orca Whirlpools avec décodage create_pool/swap, persistance des événements décodés et détection métier automatique pool/pair/listing  
+0.7.11 - Ajout du premier support FluxBeam avec décodage create_pool/swap, persistance des événements décodés et détection métier automatique pool/pair/listing  

Cargo.toml

@@ -8,7 +8,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.7.10"
+version = "0.7.11"
 edition = "2024"
 license = "MIT"
 repository = "https://git.sasedev.com/Sasedev/khadhroony-bobobot"

ROADMAP.md

@@ -558,15 +558,14 @@ Réalisé :
 - utilisation de `KbPoolKind::Clmm` pour refléter la nature concentrée de `Whirlpools`.
 
 ### 6.043. Version `0.7.11` — FluxBeam
-Objectif : couvrir un connecteur DEX supplémentaire orienté pools et listings Solana.
+Réalisé :
 
-À faire :
+- ajout du premier décodeur `FluxBeam`,
-
+- prise en charge initiale des événements de création de pool via un premier décodage `create_pool / initialize_pool`,
-- ajouter un décodeur dédié `FluxBeam`,
+- prise en charge initiale des swaps via `swap`,
-- identifier les événements utiles de création de pool et de swaps,
+- persistance des événements `FluxBeam` dans `kb_dex_decoded_events`,
-- persister les événements décodés dans `kb_dex_decoded_events`,
+- ajout de la détection métier `FluxBeam` vers `pool / pair / listing`,
-- ajouter la détection métier `pool / pair / listing` pour `FluxBeam`,
+- conservation d’un premier décodage heuristique à raffiner ultérieurement avec des transactions FluxBeam réelles.
-- préparer les variations éventuelles liées aux tokens étendus.
 
 ### 6.044. Version `0.7.12` — DexLab
 Objectif : couvrir un connecteur DEX / LP supplémentaire utile à la détection de listings.

kb_lib/src/dex.rs

@@ -2,6 +2,7 @@
 
 //! DEX-specific transaction decoders.
 
+mod fluxbeam;
 mod meteora_damm_v1;
 mod meteora_damm_v2;
 mod meteora_dbc;
@@ -10,6 +11,12 @@ mod pump_fun;
 mod pump_swap;
 mod raydium_amm_v4;
 
+pub use fluxbeam::KB_FLUXBEAM_PROGRAM_ID;
+pub use fluxbeam::KbFluxbeamCreatePoolDecoded;
+pub use fluxbeam::KbFluxbeamDecodedEvent;
+pub use fluxbeam::KbFluxbeamDecoder;
+pub use fluxbeam::KbFluxbeamSwapDecoded;
+
 pub use meteora_damm_v1::KB_METEORA_DAMM_V1_PROGRAM_ID;
 pub use meteora_damm_v1::KbMeteoraDammV1CreatePoolDecoded;
 pub use meteora_damm_v1::KbMeteoraDammV1DecodedEvent;

kb_lib/src/dex/fluxbeam.rs

@@ -0,0 +1,623 @@
+// file: kb_lib/src/dex/fluxbeam.rs
+
+//! FluxBeam transaction decoder.
+
+/// FluxBeam program id.
+pub const KB_FLUXBEAM_PROGRAM_ID: &str = "FLUXubRmkEi2q6K3Y9kBPg9248ggaZVsoSFhtJHSrm1X";
+
+/// Decoded FluxBeam create-pool event.
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct KbFluxbeamCreatePoolDecoded {
+    /// Parent transaction id.
+    pub transaction_id: i64,
+    /// Parent instruction id.
+    pub instruction_id: i64,
+    /// Transaction signature.
+    pub signature: std::string::String,
+    /// Program id.
+    pub program_id: std::string::String,
+    /// Optional pool account.
+    pub pool_account: std::option::Option<std::string::String>,
+    /// Optional LP mint.
+    pub lp_mint: std::option::Option<std::string::String>,
+    /// Optional token A mint.
+    pub token_a_mint: std::option::Option<std::string::String>,
+    /// Optional token B mint.
+    pub token_b_mint: std::option::Option<std::string::String>,
+    /// Optional creator / payer.
+    pub creator: std::option::Option<std::string::String>,
+    /// Decoded payload.
+    pub payload_json: serde_json::Value,
+}
+
+/// Decoded FluxBeam swap event.
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct KbFluxbeamSwapDecoded {
+    /// Parent transaction id.
+    pub transaction_id: i64,
+    /// Parent instruction id.
+    pub instruction_id: i64,
+    /// Transaction signature.
+    pub signature: std::string::String,
+    /// Program id.
+    pub program_id: std::string::String,
+    /// Trade side relative to normalized base.
+    pub trade_side: crate::KbSwapTradeSide,
+    /// Optional pool account.
+    pub pool_account: std::option::Option<std::string::String>,
+    /// Optional token A mint.
+    pub token_a_mint: std::option::Option<std::string::String>,
+    /// Optional token B mint.
+    pub token_b_mint: std::option::Option<std::string::String>,
+    /// Decoded payload.
+    pub payload_json: serde_json::Value,
+}
+
+/// Decoded FluxBeam event.
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub enum KbFluxbeamDecodedEvent {
+    /// Pool creation.
+    CreatePool(KbFluxbeamCreatePoolDecoded),
+    /// Swap.
+    Swap(KbFluxbeamSwapDecoded),
+}
+
+/// FluxBeam decoder.
+#[derive(Debug, Clone, Default)]
+pub struct KbFluxbeamDecoder;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum KbFluxbeamInstructionKind {
+    CreatePool,
+    Swap,
+    Unknown,
+}
+
+impl KbFluxbeamDecoder {
+    /// Creates a new decoder.
+    pub fn new() -> Self {
+        Self
+    }
+
+    /// Decodes one projected transaction into zero or more FluxBeam events.
+    pub fn decode_transaction(
+        &self,
+        transaction: &crate::KbChainTransactionDto,
+        instructions: &[crate::KbChainInstructionDto],
+    ) -> Result<std::vec::Vec<crate::KbFluxbeamDecodedEvent>, crate::KbError> {
+        let transaction_id_option = transaction.id;
+        let transaction_id = match transaction_id_option {
+            Some(transaction_id) => transaction_id,
+            None => {
+                return Err(crate::KbError::InvalidState(format!(
+                    "chain transaction '{}' has no internal id",
+                    transaction.signature
+                )));
+            }
+        };
+        let transaction_json_result =
+            serde_json::from_str::<serde_json::Value>(transaction.transaction_json.as_str());
+        let transaction_json = match transaction_json_result {
+            Ok(transaction_json) => transaction_json,
+            Err(error) => {
+                return Err(crate::KbError::Json(format!(
+                    "cannot parse transaction_json for signature '{}': {}",
+                    transaction.signature, error
+                )));
+            }
+        };
+        let log_messages = kb_extract_log_messages(&transaction_json);
+        let mut decoded_events = std::vec::Vec::new();
+        for instruction in instructions {
+            if instruction.parent_instruction_id.is_some() {
+                continue;
+            }
+            let program_id_option = &instruction.program_id;
+            let program_id = match program_id_option {
+                Some(program_id) => program_id,
+                None => continue,
+            };
+            if program_id.as_str() != crate::KB_FLUXBEAM_PROGRAM_ID {
+                continue;
+            }
+            let instruction_id_option = instruction.id;
+            let instruction_id = match instruction_id_option {
+                Some(instruction_id) => instruction_id,
+                None => continue,
+            };
+            let accounts_result = kb_parse_accounts_json(instruction.accounts_json.as_str());
+            let accounts = match accounts_result {
+                Ok(accounts) => accounts,
+                Err(error) => return Err(error),
+            };
+            let parsed_json_result =
+                kb_parse_optional_parsed_json(instruction.parsed_json.as_ref());
+            let parsed_json = match parsed_json_result {
+                Ok(parsed_json) => parsed_json,
+                Err(error) => return Err(error),
+            };
+            let instruction_kind =
+                kb_classify_instruction_kind(parsed_json.as_ref(), &log_messages);
+            let pool_account = kb_extract_string_by_candidate_keys(
+                parsed_json.as_ref(),
+                &[
+                    "pool",
+                    "poolAddress",
+                    "poolAccount",
+                    "amm",
+                    "ammPool",
+                    "poolState",
+                ],
+            )
+            .or_else(|| kb_extract_account(&accounts, 0));
+            let lp_mint = kb_extract_string_by_candidate_keys(
+                parsed_json.as_ref(),
+                &["lpMint", "lp_mint", "lpTokenMint"],
+            )
+            .or_else(|| kb_extract_account(&accounts, 1));
+            let token_a_mint = kb_extract_string_by_candidate_keys(
+                parsed_json.as_ref(),
+                &[
+                    "tokenA",
+                    "tokenAMint",
+                    "mintA",
+                    "baseMint",
+                    "token0Mint",
+                    "mint0",
+                ],
+            )
+            .or_else(|| kb_extract_account(&accounts, 2));
+            let token_b_mint = kb_extract_string_by_candidate_keys(
+                parsed_json.as_ref(),
+                &[
+                    "tokenB",
+                    "tokenBMint",
+                    "mintB",
+                    "quoteMint",
+                    "token1Mint",
+                    "mint1",
+                ],
+            )
+            .or_else(|| kb_extract_account(&accounts, 3));
+            let creator = kb_extract_string_by_candidate_keys(
+                parsed_json.as_ref(),
+                &["payer", "creator", "user", "owner"],
+            )
+            .or_else(|| kb_extract_account(&accounts, 4));
+            if instruction_kind == KbFluxbeamInstructionKind::CreatePool {
+                let payload_json = serde_json::json!({
+                    "decoder": "fluxbeam",
+                    "eventKind": "create_pool",
+                    "signature": transaction.signature,
+                    "instructionId": instruction_id,
+                    "instructionIndex": instruction.instruction_index,
+                    "accounts": accounts,
+                    "parsed": parsed_json,
+                    "logMessages": log_messages,
+                    "poolAccount": pool_account,
+                    "lpMint": lp_mint,
+                    "tokenAMint": token_a_mint,
+                    "tokenBMint": token_b_mint,
+                    "creator": creator
+                });
+                decoded_events.push(crate::KbFluxbeamDecodedEvent::CreatePool(
+                    crate::KbFluxbeamCreatePoolDecoded {
+                        transaction_id,
+                        instruction_id,
+                        signature: transaction.signature.clone(),
+                        program_id: program_id.clone(),
+                        pool_account,
+                        lp_mint,
+                        token_a_mint,
+                        token_b_mint,
+                        creator,
+                        payload_json,
+                    },
+                ));
+                continue;
+            }
+            if instruction_kind == KbFluxbeamInstructionKind::Swap {
+                let trade_side = kb_infer_trade_side(&log_messages);
+                let payload_json = serde_json::json!({
+                    "decoder": "fluxbeam",
+                    "eventKind": "swap",
+                    "signature": transaction.signature,
+                    "instructionId": instruction_id,
+                    "instructionIndex": instruction.instruction_index,
+                    "accounts": accounts,
+                    "parsed": parsed_json,
+                    "logMessages": log_messages,
+                    "poolAccount": pool_account,
+                    "tokenAMint": token_a_mint,
+                    "tokenBMint": token_b_mint,
+                    "tradeSide": format!("{:?}", trade_side)
+                });
+                decoded_events.push(crate::KbFluxbeamDecodedEvent::Swap(
+                    crate::KbFluxbeamSwapDecoded {
+                        transaction_id,
+                        instruction_id,
+                        signature: transaction.signature.clone(),
+                        program_id: program_id.clone(),
+                        trade_side,
+                        pool_account,
+                        token_a_mint,
+                        token_b_mint,
+                        payload_json,
+                    },
+                ));
+            }
+        }
+        Ok(decoded_events)
+    }
+}
+
+fn kb_classify_instruction_kind(
+    parsed_json: std::option::Option<&serde_json::Value>,
+    log_messages: &[std::string::String],
+) -> KbFluxbeamInstructionKind {
+    let parsed_instruction_name = kb_extract_string_by_candidate_keys(
+        parsed_json,
+        &["instruction", "instructionName", "type", "name"],
+    );
+    if let Some(parsed_instruction_name) = parsed_instruction_name {
+        let normalized = kb_normalize_text(parsed_instruction_name.as_str());
+        if normalized.contains("createpool") || normalized.contains("initializepool") {
+            return KbFluxbeamInstructionKind::CreatePool;
+        }
+        if normalized == "swap" {
+            return KbFluxbeamInstructionKind::Swap;
+        }
+    }
+    if kb_log_messages_contain_keyword(log_messages, "create_pool")
+        || kb_log_messages_contain_keyword(log_messages, "createpool")
+        || kb_log_messages_contain_keyword(log_messages, "initialize_pool")
+        || kb_log_messages_contain_keyword(log_messages, "initializepool")
+    {
+        return KbFluxbeamInstructionKind::CreatePool;
+    }
+    if kb_log_messages_contain_keyword(log_messages, "swap") {
+        return KbFluxbeamInstructionKind::Swap;
+    }
+    KbFluxbeamInstructionKind::Unknown
+}
+
+fn kb_extract_log_messages(
+    transaction_json: &serde_json::Value,
+) -> std::vec::Vec<std::string::String> {
+    let mut messages = std::vec::Vec::new();
+    let meta_option = transaction_json.get("meta");
+    let meta = match meta_option {
+        Some(meta) => meta,
+        None => return messages,
+    };
+    let logs_option = meta.get("logMessages");
+    let logs = match logs_option {
+        Some(logs) => logs,
+        None => return messages,
+    };
+    let logs_array = match logs.as_array() {
+        Some(logs_array) => logs_array,
+        None => return messages,
+    };
+    for value in logs_array {
+        let text_option = value.as_str();
+        if let Some(text) = text_option {
+            messages.push(text.to_string());
+        }
+    }
+    messages
+}
+
+fn kb_log_messages_contain_keyword(log_messages: &[std::string::String], keyword: &str) -> bool {
+    let keyword_normalized = kb_normalize_text(keyword);
+    for log_message in log_messages {
+        let log_normalized = kb_normalize_text(log_message.as_str());
+        if log_normalized.contains(keyword_normalized.as_str()) {
+            return true;
+        }
+    }
+    false
+}
+
+fn kb_normalize_text(value: &str) -> std::string::String {
+    let mut normalized = std::string::String::new();
+    for character in value.chars() {
+        if character.is_ascii_alphanumeric() {
+            normalized.push(character.to_ascii_lowercase());
+        }
+    }
+    normalized
+}
+
+fn kb_parse_accounts_json(
+    accounts_json: &str,
+) -> Result<std::vec::Vec<std::string::String>, crate::KbError> {
+    let values_result = serde_json::from_str::<std::vec::Vec<serde_json::Value>>(accounts_json);
+    let values = match values_result {
+        Ok(values) => values,
+        Err(error) => {
+            return Err(crate::KbError::Json(format!(
+                "cannot parse instruction accounts_json '{}': {}",
+                accounts_json, error
+            )));
+        }
+    };
+    let mut accounts = std::vec::Vec::new();
+    for value in values {
+        let text_option = value.as_str();
+        if let Some(text) = text_option {
+            accounts.push(text.to_string());
+        }
+    }
+    Ok(accounts)
+}
+
+fn kb_parse_optional_parsed_json(
+    parsed_json: std::option::Option<&std::string::String>,
+) -> Result<std::option::Option<serde_json::Value>, crate::KbError> {
+    let parsed_json = match parsed_json {
+        Some(parsed_json) => parsed_json,
+        None => return Ok(None),
+    };
+    let value_result = serde_json::from_str::<serde_json::Value>(parsed_json.as_str());
+    match value_result {
+        Ok(value) => Ok(Some(value)),
+        Err(error) => Err(crate::KbError::Json(format!(
+            "cannot parse instruction parsed_json '{}': {}",
+            parsed_json, error
+        ))),
+    }
+}
+
+fn kb_extract_string_by_candidate_keys(
+    value: std::option::Option<&serde_json::Value>,
+    candidate_keys: &[&str],
+) -> std::option::Option<std::string::String> {
+    let value = match value {
+        Some(value) => value,
+        None => return None,
+    };
+    kb_extract_string_by_candidate_keys_inner(value, candidate_keys)
+}
+
+fn kb_extract_string_by_candidate_keys_inner(
+    value: &serde_json::Value,
+    candidate_keys: &[&str],
+) -> std::option::Option<std::string::String> {
+    if let Some(object) = value.as_object() {
+        for candidate_key in candidate_keys {
+            let direct_option = object.get(*candidate_key);
+            if let Some(direct) = direct_option {
+                let direct_text_option = direct.as_str();
+                if let Some(direct_text) = direct_text_option {
+                    return Some(direct_text.to_string());
+                }
+            }
+        }
+        for nested_value in object.values() {
+            let nested_result =
+                kb_extract_string_by_candidate_keys_inner(nested_value, candidate_keys);
+            if nested_result.is_some() {
+                return nested_result;
+            }
+        }
+        return None;
+    }
+    if let Some(array) = value.as_array() {
+        for nested_value in array {
+            let nested_result =
+                kb_extract_string_by_candidate_keys_inner(nested_value, candidate_keys);
+            if nested_result.is_some() {
+                return nested_result;
+            }
+        }
+    }
+    None
+}
+
+fn kb_extract_account(
+    accounts: &[std::string::String],
+    index: usize,
+) -> std::option::Option<std::string::String> {
+    if index >= accounts.len() {
+        return None;
+    }
+    Some(accounts[index].clone())
+}
+
+fn kb_infer_trade_side(log_messages: &[std::string::String]) -> crate::KbSwapTradeSide {
+    if kb_log_messages_contain_keyword(log_messages, "buy") {
+        return crate::KbSwapTradeSide::BuyBase;
+    }
+    if kb_log_messages_contain_keyword(log_messages, "sell") {
+        return crate::KbSwapTradeSide::SellBase;
+    }
+    crate::KbSwapTradeSide::Unknown
+}
+
+#[cfg(test)]
+mod tests {
+    fn make_create_transaction() -> crate::KbChainTransactionDto {
+        let mut dto = crate::KbChainTransactionDto::new(
+            "sig-fluxbeam-create-1".to_string(),
+            Some(892001),
+            Some(1779700001),
+            Some("helius_primary_http".to_string()),
+            Some("0".to_string()),
+            None,
+            None,
+            serde_json::json!({
+                "slot": 892001,
+                "meta": {
+                    "logMessages": [
+                        "Program log: Instruction: CreatePool"
+                    ]
+                },
+                "transaction": {
+                    "message": {
+                        "instructions": []
+                    }
+                }
+            })
+            .to_string(),
+        );
+        dto.id = Some(701);
+        dto
+    }
+
+    fn make_create_instruction() -> crate::KbChainInstructionDto {
+        let mut dto = crate::KbChainInstructionDto::new(
+            701,
+            None,
+            0,
+            None,
+            Some(crate::KB_FLUXBEAM_PROGRAM_ID.to_string()),
+            Some("fluxbeam".to_string()),
+            Some(1),
+            serde_json::json!([
+                "FluxPool111",
+                "FluxLpMint111",
+                "FluxTokenA111",
+                "So11111111111111111111111111111111111111112",
+                "FluxCreator111"
+            ])
+            .to_string(),
+            None,
+            None,
+            Some(
+                serde_json::json!({
+                    "info": {
+                        "instruction": "create_pool",
+                        "pool": "FluxPool111",
+                        "lpMint": "FluxLpMint111",
+                        "tokenA": "FluxTokenA111",
+                        "tokenB": "So11111111111111111111111111111111111111112",
+                        "payer": "FluxCreator111"
+                    }
+                })
+                .to_string(),
+            ),
+        );
+        dto.id = Some(702);
+        dto
+    }
+
+    fn make_swap_transaction() -> crate::KbChainTransactionDto {
+        let mut dto = crate::KbChainTransactionDto::new(
+            "sig-fluxbeam-swap-1".to_string(),
+            Some(892002),
+            Some(1779700002),
+            Some("helius_primary_http".to_string()),
+            Some("0".to_string()),
+            None,
+            None,
+            serde_json::json!({
+                "slot": 892002,
+                "meta": {
+                    "logMessages": [
+                        "Program log: Instruction: Swap"
+                    ]
+                },
+                "transaction": {
+                    "message": {
+                        "instructions": []
+                    }
+                }
+            })
+            .to_string(),
+        );
+        dto.id = Some(703);
+        dto
+    }
+
+    fn make_swap_instruction() -> crate::KbChainInstructionDto {
+        let mut dto = crate::KbChainInstructionDto::new(
+            703,
+            None,
+            0,
+            None,
+            Some(crate::KB_FLUXBEAM_PROGRAM_ID.to_string()),
+            Some("fluxbeam".to_string()),
+            Some(1),
+            serde_json::json!([
+                "FluxSwapPool111",
+                "FluxSwapLpMint111",
+                "FluxSwapTokenA111",
+                "So11111111111111111111111111111111111111112"
+            ])
+            .to_string(),
+            None,
+            None,
+            Some(
+                serde_json::json!({
+                    "info": {
+                        "instruction": "swap",
+                        "pool": "FluxSwapPool111",
+                        "tokenA": "FluxSwapTokenA111",
+                        "tokenB": "So11111111111111111111111111111111111111112"
+                    }
+                })
+                .to_string(),
+            ),
+        );
+        dto.id = Some(704);
+        dto
+    }
+
+    #[test]
+    fn fluxbeam_create_pool_is_detected() {
+        let decoder = crate::KbFluxbeamDecoder::new();
+        let transaction = make_create_transaction();
+        let instructions = vec![make_create_instruction()];
+        let decoded_result = decoder.decode_transaction(&transaction, &instructions);
+        let decoded = match decoded_result {
+            Ok(decoded) => decoded,
+            Err(error) => panic!("decode must succeed: {}", error),
+        };
+        assert_eq!(decoded.len(), 1);
+        match &decoded[0] {
+            crate::KbFluxbeamDecodedEvent::CreatePool(event) => {
+                assert_eq!(event.transaction_id, 701);
+                assert_eq!(event.instruction_id, 702);
+                assert_eq!(event.pool_account, Some("FluxPool111".to_string()));
+                assert_eq!(event.lp_mint, Some("FluxLpMint111".to_string()));
+                assert_eq!(event.token_a_mint, Some("FluxTokenA111".to_string()));
+                assert_eq!(
+                    event.token_b_mint,
+                    Some("So11111111111111111111111111111111111111112".to_string())
+                );
+            }
+            crate::KbFluxbeamDecodedEvent::Swap(_) => {
+                panic!("unexpected swap event")
+            }
+        }
+    }
+
+    #[test]
+    fn fluxbeam_swap_is_detected() {
+        let decoder = crate::KbFluxbeamDecoder::new();
+        let transaction = make_swap_transaction();
+        let instructions = vec![make_swap_instruction()];
+        let decoded_result = decoder.decode_transaction(&transaction, &instructions);
+        let decoded = match decoded_result {
+            Ok(decoded) => decoded,
+            Err(error) => panic!("decode must succeed: {}", error),
+        };
+        assert_eq!(decoded.len(), 1);
+        match &decoded[0] {
+            crate::KbFluxbeamDecodedEvent::Swap(event) => {
+                assert_eq!(event.transaction_id, 703);
+                assert_eq!(event.instruction_id, 704);
+                assert_eq!(event.pool_account, Some("FluxSwapPool111".to_string()));
+                assert_eq!(event.token_a_mint, Some("FluxSwapTokenA111".to_string()));
+                assert_eq!(
+                    event.token_b_mint,
+                    Some("So11111111111111111111111111111111111111112".to_string())
+                );
+            }
+            crate::KbFluxbeamDecodedEvent::CreatePool(_) => {
+                panic!("unexpected create event")
+            }
+        }
+    }
+}

kb_lib/src/dex_decode.rs

@@ -14,6 +14,7 @@ pub struct KbDexDecodeService {
     meteora_dbc_decoder: crate::KbMeteoraDbcDecoder,
     meteora_damm_v1_decoder: crate::KbMeteoraDammV1Decoder,
     meteora_damm_v2_decoder: crate::KbMeteoraDammV2Decoder,
+    fluxbeam_decoder: crate::KbFluxbeamDecoder,
 }
 
 impl KbDexDecodeService {
@@ -30,6 +31,7 @@ impl KbDexDecodeService {
             meteora_dbc_decoder: crate::KbMeteoraDbcDecoder::new(),
             meteora_damm_v1_decoder: crate::KbMeteoraDammV1Decoder::new(),
             meteora_damm_v2_decoder: crate::KbMeteoraDammV2Decoder::new(),
+            fluxbeam_decoder: crate::KbFluxbeamDecoder::new(),
         }
     }
 
@@ -192,9 +194,223 @@ impl KbDexDecodeService {
             };
             persisted.push(persisted_event);
         }
+        let fluxbeam_decoded_result = self
+            .fluxbeam_decoder
+            .decode_transaction(&transaction, &instructions);
+        let fluxbeam_decoded = match fluxbeam_decoded_result {
+            Ok(fluxbeam_decoded) => fluxbeam_decoded,
+            Err(error) => return Err(error),
+        };
+        for decoded_event in &fluxbeam_decoded {
+            let persist_result = self
+                .persist_fluxbeam_event(&transaction, decoded_event)
+                .await;
+            let persisted_event = match persist_result {
+                Ok(persisted_event) => persisted_event,
+                Err(error) => return Err(error),
+            };
+            persisted.push(persisted_event);
+        }
         Ok(persisted)
     }
 
+    async fn persist_fluxbeam_event(
+        &self,
+        transaction: &crate::KbChainTransactionDto,
+        decoded_event: &crate::KbFluxbeamDecodedEvent,
+    ) -> Result<crate::KbDexDecodedEventDto, crate::KbError> {
+        match decoded_event {
+            crate::KbFluxbeamDecodedEvent::CreatePool(event) => {
+                let payload_json_result = serde_json::to_string(&event.payload_json);
+                let payload_json = match payload_json_result {
+                    Ok(payload_json) => payload_json,
+                    Err(error) => {
+                        return Err(crate::KbError::Json(format!(
+                            "cannot serialize decoded fluxbeam payload: {}",
+                            error
+                        )));
+                    }
+                };
+                let existing_result = crate::get_dex_decoded_event_by_key(
+                    self.database.as_ref(),
+                    event.transaction_id,
+                    Some(event.instruction_id),
+                    "fluxbeam.create_pool",
+                )
+                .await;
+                let existing_option = match existing_result {
+                    Ok(existing_option) => existing_option,
+                    Err(error) => return Err(error),
+                };
+                let already_present = existing_option.is_some();
+                let dto = crate::KbDexDecodedEventDto::new(
+                    event.transaction_id,
+                    Some(event.instruction_id),
+                    "fluxbeam".to_string(),
+                    event.program_id.clone(),
+                    "fluxbeam.create_pool".to_string(),
+                    event.pool_account.clone(),
+                    None,
+                    event.token_a_mint.clone(),
+                    event.token_b_mint.clone(),
+                    event.lp_mint.clone(),
+                    payload_json,
+                );
+                let upsert_result =
+                    crate::upsert_dex_decoded_event(self.database.as_ref(), &dto).await;
+                if let Err(error) = upsert_result {
+                    return Err(error);
+                }
+                let fetched_result = crate::get_dex_decoded_event_by_key(
+                    self.database.as_ref(),
+                    event.transaction_id,
+                    Some(event.instruction_id),
+                    "fluxbeam.create_pool",
+                )
+                .await;
+                let fetched_option = match fetched_result {
+                    Ok(fetched_option) => fetched_option,
+                    Err(error) => return Err(error),
+                };
+                let fetched = match fetched_option {
+                    Some(fetched) => fetched,
+                    None => {
+                        return Err(crate::KbError::InvalidState(
+                            "decoded event disappeared after upsert".to_string(),
+                        ));
+                    }
+                };
+                if !already_present {
+                    let payload_value = event.payload_json.clone();
+                    let observation_result = self
+                        .persistence
+                        .record_observation(&crate::KbDetectionObservationInput::new(
+                            "dex.fluxbeam.create_pool".to_string(),
+                            crate::KbObservationSourceKind::HttpRpc,
+                            transaction.source_endpoint_name.clone(),
+                            transaction.signature.clone(),
+                            transaction.slot,
+                            payload_value.clone(),
+                        ))
+                        .await;
+                    let observation_id = match observation_result {
+                        Ok(observation_id) => observation_id,
+                        Err(error) => return Err(error),
+                    };
+                    let signal_result = self
+                        .persistence
+                        .record_signal(&crate::KbDetectionSignalInput::new(
+                            "signal.dex.fluxbeam.create_pool".to_string(),
+                            crate::KbAnalysisSignalSeverity::Low,
+                            transaction.signature.clone(),
+                            Some(observation_id),
+                            None,
+                            payload_value,
+                        ))
+                        .await;
+                    if let Err(error) = signal_result {
+                        return Err(error);
+                    }
+                }
+                Ok(fetched)
+            }
+            crate::KbFluxbeamDecodedEvent::Swap(event) => {
+                let payload_json_result = serde_json::to_string(&event.payload_json);
+                let payload_json = match payload_json_result {
+                    Ok(payload_json) => payload_json,
+                    Err(error) => {
+                        return Err(crate::KbError::Json(format!(
+                            "cannot serialize decoded fluxbeam payload: {}",
+                            error
+                        )));
+                    }
+                };
+                let existing_result = crate::get_dex_decoded_event_by_key(
+                    self.database.as_ref(),
+                    event.transaction_id,
+                    Some(event.instruction_id),
+                    "fluxbeam.swap",
+                )
+                .await;
+                let existing_option = match existing_result {
+                    Ok(existing_option) => existing_option,
+                    Err(error) => return Err(error),
+                };
+                let already_present = existing_option.is_some();
+                let dto = crate::KbDexDecodedEventDto::new(
+                    event.transaction_id,
+                    Some(event.instruction_id),
+                    "fluxbeam".to_string(),
+                    event.program_id.clone(),
+                    "fluxbeam.swap".to_string(),
+                    event.pool_account.clone(),
+                    None,
+                    event.token_a_mint.clone(),
+                    event.token_b_mint.clone(),
+                    None,
+                    payload_json,
+                );
+                let upsert_result =
+                    crate::upsert_dex_decoded_event(self.database.as_ref(), &dto).await;
+                if let Err(error) = upsert_result {
+                    return Err(error);
+                }
+                let fetched_result = crate::get_dex_decoded_event_by_key(
+                    self.database.as_ref(),
+                    event.transaction_id,
+                    Some(event.instruction_id),
+                    "fluxbeam.swap",
+                )
+                .await;
+                let fetched_option = match fetched_result {
+                    Ok(fetched_option) => fetched_option,
+                    Err(error) => return Err(error),
+                };
+                let fetched = match fetched_option {
+                    Some(fetched) => fetched,
+                    None => {
+                        return Err(crate::KbError::InvalidState(
+                            "decoded event disappeared after upsert".to_string(),
+                        ));
+                    }
+                };
+                if !already_present {
+                    let payload_value = event.payload_json.clone();
+                    let observation_result = self
+                        .persistence
+                        .record_observation(&crate::KbDetectionObservationInput::new(
+                            "dex.fluxbeam.swap".to_string(),
+                            crate::KbObservationSourceKind::HttpRpc,
+                            transaction.source_endpoint_name.clone(),
+                            transaction.signature.clone(),
+                            transaction.slot,
+                            payload_value.clone(),
+                        ))
+                        .await;
+                    let observation_id = match observation_result {
+                        Ok(observation_id) => observation_id,
+                        Err(error) => return Err(error),
+                    };
+                    let signal_result = self
+                        .persistence
+                        .record_signal(&crate::KbDetectionSignalInput::new(
+                            "signal.dex.fluxbeam.swap".to_string(),
+                            crate::KbAnalysisSignalSeverity::Low,
+                            transaction.signature.clone(),
+                            Some(observation_id),
+                            None,
+                            payload_value,
+                        ))
+                        .await;
+                    if let Err(error) = signal_result {
+                        return Err(error);
+                    }
+                }
+                Ok(fetched)
+            }
+        }
+    }
+
     async fn persist_orca_whirlpools_event(
         &self,
         transaction: &crate::KbChainTransactionDto,
@@ -1938,4 +2154,94 @@ mod tests {
             Some("OrcaDecodeConfig111".to_string())
         );
     }
+
+    async fn seed_projected_fluxbeam_transaction(
+        database: std::sync::Arc<crate::KbDatabase>,
+        signature: &str,
+    ) {
+        let service = crate::KbTransactionModelService::new(database);
+        let resolved_transaction = serde_json::json!({
+            "slot": 999008,
+            "blockTime": 1779000008,
+            "version": 0,
+            "transaction": {
+                "message": {
+                    "instructions": [
+                        {
+                            "programId": crate::KB_FLUXBEAM_PROGRAM_ID,
+                            "program": "fluxbeam",
+                            "stackHeight": 1,
+                            "accounts": [
+                                "FluxDecodePool111",
+                                "FluxDecodeLpMint111",
+                                "FluxDecodeTokenA111",
+                                "So11111111111111111111111111111111111111112",
+                                "FluxDecodeCreator111"
+                            ],
+                            "parsed": {
+                                "info": {
+                                    "instruction": "create_pool",
+                                    "pool": "FluxDecodePool111",
+                                    "lpMint": "FluxDecodeLpMint111",
+                                    "tokenA": "FluxDecodeTokenA111",
+                                    "tokenB": "So11111111111111111111111111111111111111112",
+                                    "payer": "FluxDecodeCreator111"
+                                }
+                            },
+                            "data": "opaque"
+                        }
+                    ]
+                }
+            },
+            "meta": {
+                "err": null,
+                "logMessages": [
+                    "Program log: Instruction: CreatePool"
+                ]
+            }
+        });
+        let persist_result = service
+            .persist_resolved_transaction(
+                signature,
+                Some("helius_primary_http".to_string()),
+                &resolved_transaction,
+            )
+            .await;
+        if let Err(error) = persist_result {
+            panic!("projection must succeed: {}", error);
+        }
+    }
+
+    #[tokio::test]
+    async fn decode_transaction_by_signature_persists_decoded_fluxbeam_event() {
+        let database = make_database().await;
+        seed_projected_fluxbeam_transaction(database.clone(), "sig-dex-decode-fluxbeam-1").await;
+        let service = crate::KbDexDecodeService::new(database.clone());
+        let decoded_result = service
+            .decode_transaction_by_signature("sig-dex-decode-fluxbeam-1")
+            .await;
+        let decoded = match decoded_result {
+            Ok(decoded) => decoded,
+            Err(error) => panic!("decode must succeed: {}", error),
+        };
+        assert_eq!(decoded.len(), 1);
+        assert_eq!(decoded[0].protocol_name, "fluxbeam");
+        assert_eq!(decoded[0].event_kind, "fluxbeam.create_pool");
+        assert_eq!(
+            decoded[0].pool_account,
+            Some("FluxDecodePool111".to_string())
+        );
+        assert_eq!(
+            decoded[0].market_account,
+            Some("FluxDecodeLpMint111".to_string())
+        );
+        assert_eq!(
+            decoded[0].token_a_mint,
+            Some("FluxDecodeTokenA111".to_string())
+        );
+        assert_eq!(
+            decoded[0].token_b_mint,
+            Some("So11111111111111111111111111111111111111112".to_string())
+        );
+    }
 }

kb_lib/src/dex_detect.rs

@@ -225,6 +225,26 @@ impl KbDexDetectService {
                 };
                 detection_results.push(detect_result);
             }
+            if decoded_event.protocol_name == "fluxbeam"
+                && decoded_event.event_kind == "fluxbeam.create_pool"
+            {
+                let detect_result = self.detect_fluxbeam_pool(&transaction, decoded_event).await;
+                let detect_result = match detect_result {
+                    Ok(detect_result) => detect_result,
+                    Err(error) => return Err(error),
+                };
+                detection_results.push(detect_result);
+            }
+            if decoded_event.protocol_name == "fluxbeam"
+                && decoded_event.event_kind == "fluxbeam.swap"
+            {
+                let detect_result = self.detect_fluxbeam_pool(&transaction, decoded_event).await;
+                let detect_result = match detect_result {
+                    Ok(detect_result) => detect_result,
+                    Err(error) => return Err(error),
+                };
+                detection_results.push(detect_result);
+            }
         }
         Ok(detection_results)
     }
@@ -1954,6 +1974,276 @@ impl KbDexDetectService {
         })
     }
 
+    async fn detect_fluxbeam_pool(
+        &self,
+        transaction: &crate::KbChainTransactionDto,
+        decoded_event: &crate::KbDexDecodedEventDto,
+    ) -> Result<crate::KbDexPoolDetectionResult, crate::KbError> {
+        let decoded_event_id_option = decoded_event.id;
+        let decoded_event_id = match decoded_event_id_option {
+            Some(decoded_event_id) => decoded_event_id,
+            None => {
+                return Err(crate::KbError::InvalidState(
+                    "decoded dex event has no internal id".to_string(),
+                ));
+            }
+        };
+        let dex_id_result = self.ensure_fluxbeam_dex().await;
+        let dex_id = match dex_id_result {
+            Ok(dex_id) => dex_id,
+            Err(error) => return Err(error),
+        };
+        let pool_address_option = decoded_event.pool_account.clone();
+        let pool_address = match pool_address_option {
+            Some(pool_address) => pool_address,
+            None => {
+                return Err(crate::KbError::InvalidState(format!(
+                    "decoded event '{}' has no pool_account",
+                    decoded_event_id
+                )));
+            }
+        };
+        let token_a_mint_option = decoded_event.token_a_mint.clone();
+        let token_a_mint = match token_a_mint_option {
+            Some(token_a_mint) => token_a_mint,
+            None => {
+                return Err(crate::KbError::InvalidState(format!(
+                    "decoded event '{}' has no token_a_mint",
+                    decoded_event_id
+                )));
+            }
+        };
+        let token_b_mint_option = decoded_event.token_b_mint.clone();
+        let token_b_mint = match token_b_mint_option {
+            Some(token_b_mint) => token_b_mint,
+            None => {
+                return Err(crate::KbError::InvalidState(format!(
+                    "decoded event '{}' has no token_b_mint",
+                    decoded_event_id
+                )));
+            }
+        };
+        let base_is_token_a =
+            kb_choose_base_quote_order(token_a_mint.as_str(), token_b_mint.as_str());
+        let base_mint = if base_is_token_a {
+            token_a_mint.clone()
+        } else {
+            token_b_mint.clone()
+        };
+        let quote_mint = if base_is_token_a {
+            token_b_mint.clone()
+        } else {
+            token_a_mint.clone()
+        };
+        let base_token_id_result = self.ensure_token(base_mint.as_str()).await;
+        let base_token_id = match base_token_id_result {
+            Ok(base_token_id) => base_token_id,
+            Err(error) => return Err(error),
+        };
+        let quote_token_id_result = self.ensure_token(quote_mint.as_str()).await;
+        let quote_token_id = match quote_token_id_result {
+            Ok(quote_token_id) => quote_token_id,
+            Err(error) => return Err(error),
+        };
+        let existing_pool_result =
+            crate::get_pool_by_address(self.database.as_ref(), pool_address.as_str()).await;
+        let existing_pool_option = match existing_pool_result {
+            Ok(existing_pool_option) => existing_pool_option,
+            Err(error) => return Err(error),
+        };
+        let created_pool = existing_pool_option.is_none();
+        let pool_id = match existing_pool_option {
+            Some(pool) => {
+                let pool_id_option = pool.id;
+                match pool_id_option {
+                    Some(pool_id) => pool_id,
+                    None => {
+                        return Err(crate::KbError::InvalidState(format!(
+                            "pool '{}' has no internal id",
+                            pool.address
+                        )));
+                    }
+                }
+            }
+            None => {
+                let pool_dto = crate::KbPoolDto::new(
+                    dex_id,
+                    pool_address.clone(),
+                    crate::KbPoolKind::Amm,
+                    crate::KbPoolStatus::Active,
+                );
+                let upsert_result = crate::upsert_pool(self.database.as_ref(), &pool_dto).await;
+                match upsert_result {
+                    Ok(pool_id) => pool_id,
+                    Err(error) => return Err(error),
+                }
+            }
+        };
+        let existing_pair_result =
+            crate::get_pair_by_pool_id(self.database.as_ref(), pool_id).await;
+        let existing_pair_option = match existing_pair_result {
+            Ok(existing_pair_option) => existing_pair_option,
+            Err(error) => return Err(error),
+        };
+        let created_pair = existing_pair_option.is_none();
+        let pair_symbol = kb_build_pair_symbol(base_mint.as_str(), quote_mint.as_str());
+        let pair_id = match existing_pair_option {
+            Some(pair) => {
+                let pair_id_option = pair.id;
+                match pair_id_option {
+                    Some(pair_id) => pair_id,
+                    None => {
+                        return Err(crate::KbError::InvalidState(format!(
+                            "pair for pool '{}' has no internal id",
+                            pool_id
+                        )));
+                    }
+                }
+            }
+            None => {
+                let pair_dto = crate::KbPairDto::new(
+                    dex_id,
+                    pool_id,
+                    base_token_id,
+                    quote_token_id,
+                    pair_symbol,
+                );
+                let upsert_result = crate::upsert_pair(self.database.as_ref(), &pair_dto).await;
+                match upsert_result {
+                    Ok(pair_id) => pair_id,
+                    Err(error) => return Err(error),
+                }
+            }
+        };
+        let upsert_base_pool_token_result = crate::upsert_pool_token(
+            self.database.as_ref(),
+            &crate::KbPoolTokenDto::new(
+                pool_id,
+                base_token_id,
+                crate::KbPoolTokenRole::Base,
+                None,
+                Some(0),
+            ),
+        )
+        .await;
+        if let Err(error) = upsert_base_pool_token_result {
+            return Err(error);
+        }
+        let upsert_quote_pool_token_result = crate::upsert_pool_token(
+            self.database.as_ref(),
+            &crate::KbPoolTokenDto::new(
+                pool_id,
+                quote_token_id,
+                crate::KbPoolTokenRole::Quote,
+                None,
+                Some(1),
+            ),
+        )
+        .await;
+        if let Err(error) = upsert_quote_pool_token_result {
+            return Err(error);
+        }
+        let existing_listing_result =
+            crate::get_pool_listing_by_pool_id(self.database.as_ref(), pool_id).await;
+        let existing_listing_option = match existing_listing_result {
+            Ok(existing_listing_option) => existing_listing_option,
+            Err(error) => return Err(error),
+        };
+        let created_listing = existing_listing_option.is_none();
+        let pool_listing_id = match existing_listing_option {
+            Some(pool_listing) => pool_listing.id,
+            None => {
+                let listing_id_result = self
+                    .upsert_pool_listing_from_decoded_event(dex_id, pool_id, pair_id, transaction)
+                    .await;
+                match listing_id_result {
+                    Ok(listing_id) => Some(listing_id),
+                    Err(error) => return Err(error),
+                }
+            }
+        };
+        let payload_value_result = kb_parse_payload_json(decoded_event.payload_json.as_str());
+        let payload_value = match payload_value_result {
+            Ok(payload_value) => payload_value,
+            Err(error) => return Err(error),
+        };
+        if created_pool {
+            let signal_result = self
+                .record_detection_signal(
+                    transaction,
+                    "signal.dex.fluxbeam.new_pool",
+                    crate::KbAnalysisSignalSeverity::Low,
+                    payload_value.clone(),
+                )
+                .await;
+            if let Err(error) = signal_result {
+                return Err(error);
+            }
+        }
+        if created_pair {
+            let signal_result = self
+                .record_detection_signal(
+                    transaction,
+                    "signal.dex.fluxbeam.new_pair",
+                    crate::KbAnalysisSignalSeverity::Low,
+                    payload_value.clone(),
+                )
+                .await;
+            if let Err(error) = signal_result {
+                return Err(error);
+            }
+        }
+        if created_listing {
+            let signal_result = self
+                .record_detection_signal(
+                    transaction,
+                    "signal.dex.fluxbeam.first_listing_seen",
+                    crate::KbAnalysisSignalSeverity::Low,
+                    payload_value,
+                )
+                .await;
+            if let Err(error) = signal_result {
+                return Err(error);
+            }
+        }
+        Ok(crate::KbDexPoolDetectionResult {
+            decoded_event_id,
+            dex_id,
+            pool_id,
+            pair_id,
+            pool_listing_id,
+            created_pool,
+            created_pair,
+            created_listing,
+        })
+    }
+
+    async fn ensure_fluxbeam_dex(&self) -> Result<i64, crate::KbError> {
+        let dex_result = crate::get_dex_by_code(self.database.as_ref(), "fluxbeam").await;
+        let dex_option = match dex_result {
+            Ok(dex_option) => dex_option,
+            Err(error) => return Err(error),
+        };
+        match dex_option {
+            Some(dex) => match dex.id {
+                Some(dex_id) => Ok(dex_id),
+                None => Err(crate::KbError::InvalidState(
+                    "fluxbeam dex has no internal id".to_string(),
+                )),
+            },
+            None => {
+                let dex_dto = crate::KbDexDto::new(
+                    "fluxbeam".to_string(),
+                    "FluxBeam".to_string(),
+                    Some(crate::KB_FLUXBEAM_PROGRAM_ID.to_string()),
+                    None,
+                    true,
+                );
+                crate::upsert_dex(self.database.as_ref(), &dex_dto).await
+            }
+        }
+    }
+
     async fn ensure_orca_whirlpools_dex(&self) -> Result<i64, crate::KbError> {
         let dex_result = crate::get_dex_by_code(self.database.as_ref(), "orca_whirlpools").await;
         let dex_option = match dex_result {
@@ -3160,8 +3450,7 @@ mod tests {
         assert!(results[0].created_pool);
         assert!(results[0].created_pair);
         assert!(results[0].created_listing);
-        let pool_result =
+        let pool_result = crate::get_pool_by_address(database.as_ref(), "OrcaDetectPool111").await;
-            crate::get_pool_by_address(database.as_ref(), "OrcaDetectPool111").await;
         let pool_option = match pool_result {
             Ok(pool_option) => pool_option,
             Err(error) => panic!("pool fetch must succeed: {}", error),
@@ -3201,4 +3490,123 @@ mod tests {
         };
         assert_eq!(pool_tokens.len(), 2);
     }
+
+    async fn seed_decoded_fluxbeam_event(
+        database: std::sync::Arc<crate::KbDatabase>,
+        signature: &str,
+    ) {
+        let transaction_model = crate::KbTransactionModelService::new(database.clone());
+        let dex_decode = crate::KbDexDecodeService::new(database);
+        let resolved_transaction = serde_json::json!({
+            "slot": 910008,
+            "blockTime": 1779100008,
+            "version": 0,
+            "transaction": {
+                "message": {
+                    "instructions": [
+                        {
+                            "programId": crate::KB_FLUXBEAM_PROGRAM_ID,
+                            "program": "fluxbeam",
+                            "stackHeight": 1,
+                            "accounts": [
+                                "FluxDetectPool111",
+                                "FluxDetectLpMint111",
+                                "FluxDetectTokenA111",
+                                "So11111111111111111111111111111111111111112",
+                                "FluxDetectCreator111"
+                            ],
+                            "parsed": {
+                                "info": {
+                                    "instruction": "create_pool",
+                                    "pool": "FluxDetectPool111",
+                                    "lpMint": "FluxDetectLpMint111",
+                                    "tokenA": "FluxDetectTokenA111",
+                                    "tokenB": "So11111111111111111111111111111111111111112",
+                                    "payer": "FluxDetectCreator111"
+                                }
+                            },
+                            "data": "opaque"
+                        }
+                    ]
+                }
+            },
+            "meta": {
+                "err": null,
+                "logMessages": [
+                    "Program log: Instruction: CreatePool"
+                ]
+            }
+        });
+        let project_result = transaction_model
+            .persist_resolved_transaction(
+                signature,
+                Some("helius_primary_http".to_string()),
+                &resolved_transaction,
+            )
+            .await;
+        if let Err(error) = project_result {
+            panic!("projection must succeed: {}", error);
+        }
+        let decode_result = dex_decode.decode_transaction_by_signature(signature).await;
+        if let Err(error) = decode_result {
+            panic!("dex decode must succeed: {}", error);
+        }
+    }
+
+    #[tokio::test]
+    async fn detect_transaction_by_signature_creates_fluxbeam_pool_pair_and_listing() {
+        let database = make_database().await;
+        seed_decoded_fluxbeam_event(database.clone(), "sig-dex-detect-fluxbeam-1").await;
+        let detect_service = crate::KbDexDetectService::new(database.clone());
+        let detect_result = detect_service
+            .detect_transaction_by_signature("sig-dex-detect-fluxbeam-1")
+            .await;
+        let results = match detect_result {
+            Ok(results) => results,
+            Err(error) => panic!("dex detect must succeed: {}", error),
+        };
+        assert_eq!(results.len(), 1);
+        assert!(results[0].created_pool);
+        assert!(results[0].created_pair);
+        assert!(results[0].created_listing);
+        let pool_result = crate::get_pool_by_address(database.as_ref(), "FluxDetectPool111").await;
+        let pool_option = match pool_result {
+            Ok(pool_option) => pool_option,
+            Err(error) => panic!("pool fetch must succeed: {}", error),
+        };
+        let pool = match pool_option {
+            Some(pool) => pool,
+            None => panic!("pool must exist"),
+        };
+        assert_eq!(pool.id, Some(results[0].pool_id));
+        assert_eq!(pool.pool_kind, crate::KbPoolKind::Amm);
+        let pair_result = crate::get_pair_by_pool_id(database.as_ref(), results[0].pool_id).await;
+        let pair_option = match pair_result {
+            Ok(pair_option) => pair_option,
+            Err(error) => panic!("pair fetch must succeed: {}", error),
+        };
+        let pair = match pair_option {
+            Some(pair) => pair,
+            None => panic!("pair must exist"),
+        };
+        assert_eq!(pair.id, Some(results[0].pair_id));
+        let listing_result =
+            crate::get_pool_listing_by_pool_id(database.as_ref(), results[0].pool_id).await;
+        let listing_option = match listing_result {
+            Ok(listing_option) => listing_option,
+            Err(error) => panic!("listing fetch must succeed: {}", error),
+        };
+        let listing = match listing_option {
+            Some(listing) => listing,
+            None => panic!("listing must exist"),
+        };
+        assert_eq!(listing.id, results[0].pool_listing_id);
+        let pool_tokens_result =
+            crate::list_pool_tokens_by_pool_id(database.as_ref(), results[0].pool_id).await;
+        let pool_tokens = match pool_tokens_result {
+            Ok(pool_tokens) => pool_tokens,
+            Err(error) => panic!("pool tokens list must succeed: {}", error),
+        };
+        assert_eq!(pool_tokens.len(), 2);
+    }
 }

kb_lib/src/lib.rs

@@ -251,5 +251,10 @@ pub use dex::KbOrcaWhirlpoolsCreatePoolDecoded;
 pub use dex::KbOrcaWhirlpoolsDecodedEvent;
 pub use dex::KbOrcaWhirlpoolsDecoder;
 pub use dex::KbOrcaWhirlpoolsSwapDecoded;
+pub use dex::KB_FLUXBEAM_PROGRAM_ID;
+pub use dex::KbFluxbeamCreatePoolDecoded;
+pub use dex::KbFluxbeamDecodedEvent;
+pub use dex::KbFluxbeamDecoder;
+pub use dex::KbFluxbeamSwapDecoded;
 pub use launch_origin::KbLaunchAttributionResult;
 pub use launch_origin::KbLaunchOriginService;