// file: kb_lib/src/lib.rs

//! Core library of the `khadhroony-bobobot` workspace.
//!
//! This crate contains the reusable backend logic shared by the desktop
//! application and future clients.

#![deny(unreachable_pub)]
#![warn(missing_docs)]

/// JSON configuration structures and loading helpers for `kb_lib`.
mod config;
/// Solana program and mint constants reused by the project.
mod constants;
/// Database facade.
/// This module centralizes the database layer and exposes a storage API that is
/// intentionally structured to remain evolutive across backends.
mod db;
/// Detection pipeline facade.
/// This module sits between transport/connectors and persistence.
/// It centralizes how technical observations, analysis signals and
/// candidate tokens are persisted before richer detection logic is added.
mod detect;
/// DEX-specific transaction decoders.
mod dex;
/// Internal known DEX catalog.
mod dex_catalog;
/// Persistence-oriented DEX decoding service.
mod dex_decode;
/// Transaction context loading for DEX decoding.
mod dex_decode_context;
/// Decoded DEX event materialization helpers.
mod dex_decoded_event_materialization;
/// Business-level detection built from decoded DEX events.
mod dex_detect;
/// Decoded DEX event to business-detection routing.
mod dex_detection_route;
/// Shared DEX event classification and decoded-payload enrichment helpers.
mod dex_event_classification;
/// Event coverage synchronization and reporting.
mod dex_event_coverage;
/// Shared DEX pool materialization helpers.
mod dex_pool_materialization;
/// Shared DEX support matrix.
mod dex_support_matrix;
/// Shared error type for `kb_lib`.
mod error;
/// Generic asynchronous HTTP JSON-RPC client.
/// This module provides a reusable `HttpClient` built on top of `reqwest` for
/// Solana RPC HTTP endpoints.
mod http_client;
/// HTTP endpoint pool and routing.
mod http_pool;
/// Technical index for observed chain instructions.
mod instruction_observation_index;
/// Generic JSON-RPC 2.0 WebSocket helpers.
mod json_rpc_ws;
/// Launch surface attribution service.
mod launch_origin;
/// Local DEX corpus search service used by Demo3.
mod local_dex_corpus_search;
/// Local pipeline diagnostics service.
mod local_pipeline_diagnostics;
/// Local pipeline replay from already persisted raw transaction data.
mod local_pipeline_replay;
/// Local pipeline validation helpers for non-regression runs.
mod local_pipeline_validation;
/// Meteora swap amount inference from flattened CPI token transfers.
mod meteora_swap_amount_inference;
/// Useful non-trade DEX event materialization service.
mod non_trade_event_materialization;
/// On-chain DEX pair/pool discovery helpers used by Demo3.
mod onchain_dex_pair_discovery;
/// Pair analytic signal service.
mod pair_analytic_signal;
/// Pair-candle aggregation service.
mod pair_candle_aggregation;
/// Pair-candle query service.
mod pair_candle_query;
/// Pair display-symbol derivation.
mod pair_symbol;
/// Cross-DEX pool-origin recording service.
mod pool_origin;
/// Protocol candidate recording.
mod protocol_candidate_recording;
/// Typed Solana WebSocket PubSub helpers built on top of the generic JSON-RPC transport.
mod solana_pubsub_ws;
/// Historical token backfill service.
mod token_backfill;
/// Token metadata resolution and backfill.
mod token_metadata;
/// Tracing initialization helpers for `kb_lib`.
mod tracing;
/// Cross-DEX trade aggregation service.
mod trade_aggregation;
/// Database context loading for trade aggregation.
mod trade_aggregation_context;
/// Trade amount resolution orchestration.
mod trade_amount_resolution;
/// Trade-event materialization.
mod trade_event_materialization;
/// Trade metric update and pricing helpers.
mod trade_metric_update;
/// PumpSwap trade amount recovery helpers.
mod trade_pump_swap_amounts;
/// Trade-side resolution helpers.
mod trade_side_resolution;
/// Solana transaction/meta trade amount extraction helpers.
mod trade_solana_amounts;
/// Transaction classification service.
mod transaction_classification;
/// Projection of resolved transactions into normalized internal DB tables.
mod tx_model;
/// Transaction resolution pipeline.
mod tx_resolution;
/// Shared generic types for `kb_lib`.
mod types;
/// Upstream Git registry service facade.
mod upstream_registry;
/// Static upstream Git registry bootstrap data.
mod upstream_registry_generated;
/// Upstream Git registry matching helpers.
mod upstream_registry_match;
/// Upstream Git registry DTOs and static entry types.
mod upstream_registry_types;
/// Wallet-holding observation service.
mod wallet_holding_observation;
/// Wallet-observation service.
mod wallet_observation;
/// Generic asynchronous WebSocket transport client.
mod ws_client;
/// Hybrid WebSocket technical observation service.
mod ws_hybrid_observation;
/// Hybrid WebSocket runtime facade.
mod ws_hybrid_runtime;
/// Hybrid WebSocket watch-target collection service.
mod ws_hybrid_watch;
/// Multi-client WebSocket orchestration.
mod ws_manager;

/// Generic application settings.
pub use config::AppConfig;
/// Root application configuration loaded from `config.json`.
pub use config::Config;
/// Local data paths used by the application.
pub use config::DataConfig;
/// Database configuration.
pub use config::DatabaseConfig;
/// HTTP endpoint configuration.
pub use config::HttpEndpointConfig;
/// Logging and tracing configuration.
pub use config::LoggingConfig;
/// Solana transport configuration.
pub use config::SolanaConfig;
/// SQLite configuration.
pub use config::SqliteDatabaseConfig;
/// WebSocket endpoint configuration.
pub use config::WsEndpointConfig;
/// Address Lookup Table program identifier. ("AddressLookupTab1e1111111111111111111111111").
/// @see solana_sdk::pubkey::Pubkey =  solana_sdk_ids::address_lookup_table::ID
pub use constants::ADDRESS_LOOKUP_TABLE_PROGRAM_ID;
/// AlphaQ program id from Vybe supported DEX/AMM documentation.
pub use constants::ALPHAQ_PROGRAM_ID;
/// Aquifer program id from Vybe supported DEX/AMM documentation.
pub use constants::AQUIFER_PROGRAM_ID;
/// Arbitrage Bot (6MWVT) / Arbitrage or Sandwich Bot. ("6MWVTis8rmmk6Vt9zmAJJbmb3VuLpzoQ1aHH4N6wQEGh").
pub use constants::ARBITRAGE_BOT_6MWVT_PROGRAM_ID;
/// Associated Token Account program identifier. ("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL").
/// @see solana_sdk::pubkey::Pubkey = spl_associated_token_account_interface::program::ID
pub use constants::ASSOCIATED_TOKEN_PROGRAM_ID;
/// BisonFi program id from Vybe supported DEX/AMM documentation.
pub use constants::BISONFI_PROGRAM_ID;
/// Canonical Bonk token mint identifier.
pub use constants::BONK_MINT_ID;
/// Bonkswap program id extracted from upstream Git decoder source.
pub use constants::BONKSWAP_PROGRAM_ID;
/// Boop program id extracted from upstream Git decoder source.
pub use constants::BOOP_FUN_PROGRAM_ID;
/// BPF Loader program identifier. ("BPFLoader1111111111111111111111111111111111").
/// @see solana_sdk::pubkey::Pubkey =  solana_sdk_ids::bpf_loader_deprecated::ID
pub use constants::BPF_LOADER_DEPRECATED_PROGRAM_ID;
/// BPF Loader program identifier. ("BPFLoaderUpgradeab1e11111111111111111111111").
/// @see solana_sdk::pubkey::Pubkey =  solana_sdk_ids::bpf_loader_upgradeable::ID
pub use constants::BPF_LOADER_UPGRADEABLE_PROGRAM_ID;
/// Bubblegum program id extracted from upstream Git decoder source.
pub use constants::BUBBLEGUM_PROGRAM_ID;
/// Byreal program id from Vybe supported DEX/AMM documentation.
pub use constants::BYREAL_PROGRAM_ID;
/// Circle Message Transmitter v2 program id extracted from upstream Git decoder source.
pub use constants::CIRCLE_MESSAGE_TRANSMITTER_V2_PROGRAM_ID;
/// Circle Token Messenger v2 program id extracted from upstream Git decoder source.
pub use constants::CIRCLE_TOKEN_MESSENGER_V2_PROGRAM_ID;
/// Compute Budget program identifier. ("ComputeBudget111111111111111111111111111111").
/// @see solana_sdk::pubkey::Pubkey =  solana_sdk_ids::compute_budget::ID
pub use constants::COMPUTE_BUDGET_PROGRAM_ID;
/// Config program identifier. ("Config1111111111111111111111111111111111111").
/// @see solana_sdk::pubkey::Pubkey =  solana_sdk_ids::config::ID
pub use constants::CONFIG_PROGRAM_ID;
/// DexLab Swap/Pool program id. ("DSwpgjMvXhtGn6BsbqmacdBZyfLj6jSWf3HJpdJtmg6N").
pub use constants::DEXLAB_PROGRAM_ID;
/// DFlow Aggregator v4 program id extracted from upstream Git decoder source.
pub use constants::DFLOW_AGGREGATOR_V4_PROGRAM_ID;
/// Drift v2 program id extracted from upstream Git decoder source.
pub use constants::DRIFT_V2_PROGRAM_ID;
/// ED25519 program identifier. ("Ed25519SigVerify111111111111111111111111111").
/// @see solana_sdk::pubkey::Pubkey =  solana_sdk_ids::ed25519_program::ID
pub use constants::ED25519_PROGRAM_ID;
/// Feature program identifier. ("Feature111111111111111111111111111111111111").
/// @see solana_sdk::pubkey::Pubkey =  solana_sdk_ids::feature::ID
pub use constants::FEATURE_PROGRAM_ID;
/// Moonshot token authority account observed on Solscan program id. ("FLUXubRmkEi2q6K3Y9kBPg9248ggaZVsoSFhtJHSrm1X").
pub use constants::FLUXBEAM_PROGRAM_ID;
/// FusionAMM program id from Vybe supported DEX/AMM documentation.
pub use constants::FUSIONAMM_PROGRAM_ID;
/// Gavel program id extracted from upstream Git decoder source.
pub use constants::GAVEL_PROGRAM_ID;
/// Goonfi program id from Vybe supported DEX/AMM documentation.
pub use constants::GOONFI_PROGRAM_ID;
/// Goonfi v2 program id from Vybe supported DEX/AMM documentation.
pub use constants::GOONFI_V2_PROGRAM_ID;
/// GooseFX v1 program id from Vybe supported DEX/AMM documentation.
pub use constants::GOOSEFX_V1_PROGRAM_ID;
/// Heaven program id extracted from upstream Git decoder source.
pub use constants::HEAVEN_PROGRAM_ID;
/// Humidifi program id from Vybe supported DEX/AMM documentation.
pub use constants::HUMIDIFI_PROGRAM_ID;
/// Incinerator program identifier. ("1nc1nerator11111111111111111111111111111111").
/// @see solana_sdk::pubkey::Pubkey = solana_sdk_ids::incinerator::ID
pub use constants::INCINERATOR_PROGRAM_ID;
/// Canonical Jupiter governance token mint identifier.
pub use constants::JUP_MINT_ID;
/// Jupiter DCA program id extracted from upstream Git decoder source.
pub use constants::JUPITER_DCA_PROGRAM_ID;
/// Jupiter Lend program id extracted from upstream Git decoder source.
pub use constants::JUPITER_LEND_PROGRAM_ID;
/// Jupiter Limit Order 2 program id extracted from upstream Git decoder source.
pub use constants::JUPITER_LIMIT_ORDER_2_PROGRAM_ID;
/// Jupiter Limit Order program id extracted from upstream Git decoder source.
pub use constants::JUPITER_LIMIT_ORDER_PROGRAM_ID;
/// Jupiter Perpetuals program id extracted from upstream Git decoder source.
pub use constants::JUPITER_PERPETUALS_PROGRAM_ID;
/// Jupiter Swap program id extracted from upstream Git decoder source.
pub use constants::JUPITER_SWAP_PROGRAM_ID;
/// Kamino Farms program id extracted from upstream Git decoder source.
pub use constants::KAMINO_FARMS_PROGRAM_ID;
/// Kamino Lending program id extracted from upstream Git decoder source.
pub use constants::KAMINO_LENDING_PROGRAM_ID;
/// Kamino Limit Order program id extracted from upstream Git decoder source.
pub use constants::KAMINO_LIMIT_ORDER_PROGRAM_ID;
/// Kamino Vault program id extracted from upstream Git decoder source.
pub use constants::KAMINO_VAULT_PROGRAM_ID;
/// Lifinity AMM v2 program id extracted from upstream Git decoder source.
pub use constants::LIFINITY_AMM_V2_PROGRAM_ID;
/// Loader V4 program identifier. ("LoaderV411111111111111111111111111111111111").
/// @see solana_sdk::pubkey::Pubkey = solana_sdk_ids::loader_v4::ID
pub use constants::LOADER_V4_PROGRAM_ID;
/// Manifest CLOB program id from Vybe supported DEX/AMM documentation.
pub use constants::MANIFEST_CLOB_PROGRAM_ID;
/// Marginfi v2 program id extracted from upstream Git decoder source.
pub use constants::MARGINFI_V2_PROGRAM_ID;
/// Marinade Finance program id extracted from upstream Git decoder source.
pub use constants::MARINADE_FINANCE_PROGRAM_ID;
/// SPL Memo program id.
pub use constants::MEMO_PROGRAM_ID;
/// MetaDAO AMM v0.5.0 program id.
pub use constants::METADAO_AMM_V0_5_0_PROGRAM_ID;
/// MetaDAO Bid Wall v0.7.0 program id.
pub use constants::METADAO_BID_WALL_V0_7_0_PROGRAM_ID;
/// MetaDAO Futarchy v0.6.0 program id.
pub use constants::METADAO_FUTARCHY_V0_6_0_PROGRAM_ID;
/// MetaDAO Launchpad v0.7.0 program id.
pub use constants::METADAO_LAUNCHPAD_V0_7_0_PROGRAM_ID;
/// Meteora DAMM v1 program id. ("Eo7WjKq67rjJQSZxS6z3YkapzY3eMj6Xy8X5EQVn5UaB").
pub use constants::METEORA_DAMM_V1_PROGRAM_ID;
/// Meteora DAMM v2 program id. ("cpamdpZCGKUy5JxQXB4dcpGPiikHawvSWAd6mEn1sGG").
pub use constants::METEORA_DAMM_V2_PROGRAM_ID;
/// Meteora DBC program id. ("dbcij3LWUppWqq96dh6gJWwBifmcGfLSB5D4DuSMaqN").
pub use constants::METEORA_DBC_PROGRAM_ID;
/// Meteora DLMM program id. ("LBUZKhRxPF3XUpBCjp4YzTKgLccjZhTSDM9YuVaPwxo").
pub use constants::METEORA_DLMM_PROGRAM_ID;
/// Meteora Vault program id. ("MoonCVVNZFSYkqNXP6bxHLPL6QQJiMagDL3qcqUQTrG").
pub use constants::METEORA_VAULT_PROGRAM_ID;
/// Moonshot program id extracted from upstream Git decoder source.
pub use constants::MOONSHOT_PROGRAM_ID;
/// FluxBeam program id. ("7rtiKSUDLBm59b1SBmD9oajcP8xE64vAGSMbAN5CXy1q").
pub use constants::MOONSHOT_TOKEN_AUTHORITY_ID;
/// MPL Core program id extracted from upstream Git decoder source.
pub use constants::MPL_CORE_PROGRAM_ID;
/// MPL Token Metadata program id extracted from upstream Git decoder source.
pub use constants::MPL_TOKEN_METADATA_PROGRAM_ID;
/// Solana Name Service program id extracted from upstream Git decoder source.
pub use constants::NAME_SERVICE_PROGRAM_ID;
/// Native Loader program identifier. ("NativeLoader1111111111111111111111111111111").
/// @see solana_sdk::pubkey::Pubkey = solana_sdk_ids::native_loader::ID
pub use constants::NATIVE_LOADER_PROGRAM_ID;
/// Obric v2 program id from Vybe supported DEX/AMM documentation.
pub use constants::OBRIC_V2_PROGRAM_ID;
/// OKX DEX program id extracted from upstream Git decoder source.
pub use constants::OKX_DEX_PROGRAM_ID;
/// Onchain Labs DEX v2 program id extracted from upstream Git decoder source.
pub use constants::ONCHAIN_LABS_DEX_V2_PROGRAM_ID;
/// Ondo Global Market program id from Vybe supported DEX/AMM documentation.
pub use constants::ONDO_GLOBAL_MARKET_PROGRAM_ID;
/// OpenBook v2 program id extracted from upstream Git decoder source.
pub use constants::OPENBOOK_V2_PROGRAM_ID;
/// Orca Whirlpools program id. ("whirLbMiicVdio4qvUfM5KAg6Ct8VwpYzGff3uctyCc").
pub use constants::ORCA_WHIRLPOOLS_PROGRAM_ID;
/// Pancake Swap program id extracted from upstream Git decoder source.
pub use constants::PANCAKE_SWAP_PROGRAM_ID;
/// Phoenix v1 program id extracted from upstream Git decoder source.
pub use constants::PHOENIX_V1_PROGRAM_ID;
/// Printr program id candidate observed on Solscan.
pub use constants::PRINTR_PROGRAM_ID;
/// Pump Fees program id extracted from upstream Git decoder source.
pub use constants::PUMP_FEES_PROGRAM_ID;
/// Pump.fun program id. ("6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P").
pub use constants::PUMP_FUN_PROGRAM_ID;
/// PumpSwap / PumpAMM program id. ("pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA").
pub use constants::PUMP_SWAP_PROGRAM_ID;
/// Canonical Raydium token mint identifier.
pub use constants::RAY_MINT_ID;
/// Raydium AMM routing program id. ("routeUGWgWzqBWFcrCfv8tritsqukccJPu3q5GPP3xS").
pub use constants::RAYDIUM_AMM_ROUTING_PROGRAM_ID;
/// Raydium AmmV4 program id. ("675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8").
pub use constants::RAYDIUM_AMM_V4_PROGRAM_ID;
/// Raydium CLMM program id. ("CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK").
pub use constants::RAYDIUM_CLMM_PROGRAM_ID;
/// Raydium CPMM mainnet program id. ("CPMMoo8L3F4NbTegBCKVNunggL7H1ZpdTHKxQB5qKP1C").
pub use constants::RAYDIUM_CPMM_PROGRAM_ID;
/// Raydium LaunchLab platform config account observed on Solscan. ("4Bu96XjU84XjPDSpveTVf6LYGCkfW5FK7SNkREWcEfV4").
pub use constants::RAYDIUM_LAUNCHPAD_PLATFORM_CONFIG_ACCOUNT_ID;
/// Raydium LaunchLab / Launchpad program id. ("LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj").
pub use constants::RAYDIUM_LAUNCHPAD_PROGRAM_ID;
/// Raydium Liquidity Locking program id extracted from upstream Git decoder source.
pub use constants::RAYDIUM_LIQUIDITY_LOCKING_PROGRAM_ID;
/// Raydium Stable Swap AMM program id, deprecated. ("5quBtoiQqxF9Jv6KYKctB59NT3gtJD2Y65kdnB1Uev3h").
pub use constants::RAYDIUM_STABLE_SWAP_AMM_PROGRAM_ID;
/// Scorch program id from Vybe supported DEX/AMM documentation.
pub use constants::SCORCH_PROGRAM_ID;
/// Secp256k1 program identifier. ("KeccakSecp256k11111111111111111111111111111").
/// @see solana_sdk::pubkey::Pubkey = solana_sdk_ids::secp256k1_program::ID
pub use constants::SECP256K1_PROGRAM_ID;
/// Secp256r1 program identifier. ("Secp256r1SigVerify1111111111111111111111111").
/// @see solana_sdk::pubkey::Pubkey = solana_sdk_ids::secp256r1_program::ID
pub use constants::SECP256R1_PROGRAM_ID;
/// Sharky program id extracted from upstream Git decoder source.
pub use constants::SHARKY_PROGRAM_ID;
/// Solayer Restaking program id extracted from upstream Git decoder source.
pub use constants::SOLAYER_RESTAKING_PROGRAM_ID;
/// SolFi v2 program id from Vybe supported DEX/AMM documentation.
pub use constants::SOLFI_V2_PROGRAM_ID;
/// Manual Solscan account-source inventory collected for post-`0.7.50` DEX discovery.
pub use constants::SOLSCAN_ACCOUNT_SOURCES;
/// SPL Token-2022 program identifier. ("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb").
/// @see solana_sdk::pubkey::Pubkey = spl_token_2022_interface::ID
pub use constants::SPL_TOKEN_2022_PROGRAM_ID;
/// SPL Token program identifier. ("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA").
/// @see solana_sdk::pubkey::Pubkey = spl_token_interface::ID
pub use constants::SPL_TOKEN_PROGRAM_ID;
/// Stabble stable-swap program id extracted from upstream Git decoder source.
pub use constants::STABBLE_STABLE_SWAP_PROGRAM_ID;
/// Stabble weighted-swap program id extracted from upstream Git decoder source.
pub use constants::STABBLE_WEIGHTED_SWAP_PROGRAM_ID;
/// Stake Config program identifier. ("StakeConfig11111111111111111111111111111111").
/// @see solana_sdk::pubkey::Pubkey = solana_sdk_ids::stake::config::ID
pub use constants::STAKE_CONFIG_PROGRAM_ID;
/// Stake program identifier. ("Stake11111111111111111111111111111111111111").
/// @see solana_sdk::pubkey::Pubkey = solana_sdk_ids::stake::ID
pub use constants::STAKE_PROGRAM_ID;
/// Swig program id extracted from upstream Git decoder source.
pub use constants::SWIG_PROGRAM_ID;
/// System program identifier. ("11111111111111111111111111111111").
/// @see solana_sdk::pubkey::Pubkey = solana_sdk_ids::system_program::ID
pub use constants::SYSTEM_PROGRAM_ID;
/// Sysvar Clock program identifier. ("SysvarC1ock11111111111111111111111111111111").
/// @see solana_sdk::pubkey::Pubkey = solana_sdk_ids::sysvar::clock::ID
pub use constants::SYSVAR_CLOCK_PROGRAM_ID;
/// Sysvar Epoch Rewards program identifier. ("SysvarEpochRewards1111111111111111111111111").
/// @see solana_sdk::pubkey::Pubkey = solana_sdk_ids::sysvar::epoch_rewards::ID
pub use constants::SYSVAR_EPOCH_REWARDS_PROGRAM_ID;
/// Sysvar Epoch Schedule program identifier. ("SysvarEpochSchedu1e111111111111111111111111").
/// @see solana_sdk::pubkey::Pubkey = solana_sdk_ids::sysvar::epoch_schedule::ID
pub use constants::SYSVAR_EPOCH_SCHEDULE_PROGRAM_ID;
/// Sysvar Fees program identifier. ("SysvarFees111111111111111111111111111111111").
/// @see solana_sdk::pubkey::Pubkey = solana_sdk_ids::sysvar::fees::ID
pub use constants::SYSVAR_FEES_PROGRAM_ID;
/// Sysvar Instructions program identifier. ("Sysvar1nstructions1111111111111111111111111").
/// @see solana_sdk::pubkey::Pubkey = solana_sdk_ids::sysvar::instructions::ID
pub use constants::SYSVAR_INSTRUCTIONS_PROGRAM_ID;
/// Sysvar Last Restart Slot program identifier. ("SysvarLastRestartS1ot1111111111111111111111").
/// @see solana_sdk::pubkey::Pubkey = solana_sdk_ids::sysvar::last_restart_slot::ID
pub use constants::SYSVAR_LAST_RESTART_SLOT_PROGRAM_ID;
/// Sysvar program identifier. ("Sysvar1111111111111111111111111111111111111").
/// @see solana_sdk::pubkey::Pubkey = solana_sdk_ids::sysvar::ID
pub use constants::SYSVAR_PROGRAM_ID;
/// Sysvar Recent Blockhashes program identifier. ("SysvarRecentB1ockHashes11111111111111111111").
/// @see solana_sdk::pubkey::Pubkey = solana_sdk_ids::sysvar::recent_blockhashes::ID
pub use constants::SYSVAR_RECENT_BLOCKHASHES_PROGRAM_ID;
/// Sysvar Rent program identifier. ("SysvarRent111111111111111111111111111111111").
/// @see solana_sdk::pubkey::Pubkey = solana_sdk_ids::sysvar::rent::ID
pub use constants::SYSVAR_RENT_PROGRAM_ID;
/// Sysvar Rewards program identifier. ("SysvarRewards111111111111111111111111111111").
/// @see solana_sdk::pubkey::Pubkey = solana_sdk_ids::sysvar::rewards::ID
pub use constants::SYSVAR_REWARDS_PROGRAM_ID;
/// Sysvar Slot Hashes program identifier. ("SysvarS1otHashes111111111111111111111111111").
/// @see solana_sdk::pubkey::Pubkey = solana_sdk_ids::sysvar::slot_hashes::ID
pub use constants::SYSVAR_SLOT_HASHES_PROGRAM_ID;
/// Sysvar Slot History program identifier. ("SysvarS1otHistory11111111111111111111111111").
/// @see solana_sdk::pubkey::Pubkey = solana_sdk_ids::sysvar::slot_history::ID
pub use constants::SYSVAR_SLOT_HISTORY_PROGRAM_ID;
/// Sysvar Stake History program identifier. ("SysvarStakeHistory1111111111111111111111111").
/// @see solana_sdk::pubkey::Pubkey = solana_sdk_ids::sysvar::stake_history::ID
pub use constants::SYSVAR_STAKE_HISTORY_PROGRAM_ID;
/// One Solscan account source collected during manual DEX/program inventory.
pub use constants::SolscanAccountSource;
/// Canonical Solana USDC mint identifier.
pub use constants::USDC_MINT_ID;
/// Canonical Solana USDT mint identifier.
pub use constants::USDT_MINT_ID;
/// Vertigo program id extracted from upstream Git decoder source.
pub use constants::VERTIGO_PROGRAM_ID;
/// Virtuals program id extracted from upstream Git decoder source.
pub use constants::VIRTUALS_PROGRAM_ID;
/// Vote program identifier. ("Vote111111111111111111111111111111111111111").
/// @see solana_sdk::pubkey::Pubkey = solana_sdk_ids::vote::ID
pub use constants::VOTE_PROGRAM_ID;
/// Wavebreak program id extracted from upstream Git decoder source.
pub use constants::WAVEBREAK_PROGRAM_ID;
/// Woofi program id from Vybe supported DEX/AMM documentation.
pub use constants::WOOFI_PROGRAM_ID;
/// Wrapped SOL mint identifier. ("So11111111111111111111111111111111111111112").
/// @see solana_sdk::pubkey::Pubkey = spl_token_interface::native_mint::ID
pub use constants::WSOL_MINT_ID;
/// ZeroFi program id from Vybe supported DEX/AMM documentation.
pub use constants::ZEROFI_PROGRAM_ID;
/// Zeta program id extracted from upstream Git decoder source.
pub use constants::ZETA_PROGRAM_ID;
/// Zk El Gamal Proof program identifier. ("ZkE1Gama1Proof11111111111111111111111111111").
/// @see solana_sdk::pubkey::Pubkey = solana_sdk_ids::zk_elgamal_proof_program::ID
pub use constants::ZK_ELGAMAL_PROOF_PROGRAM_ID;
/// Zk Token Proof program identifier. ("ZkTokenProof1111111111111111111111111111111").
/// @see solana_sdk::pubkey::Pubkey = solana_sdk_ids::zk_token_proof_program::ID
pub use constants::ZK_TOKEN_PROOF_PROGRAM_ID;
/// Zora program id candidate observed on Solscan.
pub use constants::ZORA_PROGRAM_ID;
/// Application-facing analysis signal DTO.
pub use db::AnalysisSignalDto;
/// Persisted analysis signal row.
pub use db::AnalysisSignalEntity;
/// Severity for one analysis signal.
pub use db::AnalysisSignalSeverity;
/// Application-facing normalized chain instruction DTO.
pub use db::ChainInstructionDto;
/// Persisted Solana instruction row.
pub use db::ChainInstructionEntity;
/// Application-facing normalized chain slot DTO.
pub use db::ChainSlotDto;
/// Persisted Solana slot row.
pub use db::ChainSlotEntity;
/// Application-facing normalized chain transaction DTO.
pub use db::ChainTransactionDto;
/// Persisted Solana transaction row.
pub use db::ChainTransactionEntity;
/// Database facade.
pub use db::Database;
/// Supported database backends.
pub use db::DatabaseBackend;
/// Concrete database connection.
pub use db::DatabaseConnection;
/// Metadata DTO used by the application layer.
pub use db::DbMetadataDto;
/// Persisted metadata row.
pub use db::DbMetadataEntity;
/// Application-facing runtime event DTO.
pub use db::DbRuntimeEventDto;
/// Persisted runtime event row.
pub use db::DbRuntimeEventEntity;
/// Runtime event level used by the local database layer.
pub use db::DbRuntimeEventLevel;
/// Application-facing DEX decode replay ledger DTO.
pub use db::DexDecodeReplayLedgerDto;
/// Persisted DEX decode replay ledger row.
pub use db::DexDecodeReplayLedgerEntity;
/// Application-facing decoded DEX event DTO.
pub use db::DexDecodedEventDto;
/// Persisted decoded DEX event row.
pub use db::DexDecodedEventEntity;
/// Application-facing normalized DEX DTO.
pub use db::DexDto;
/// Persisted normalized DEX row.
pub use db::DexEntity;
/// Application-facing DEX event coverage entry DTO.
pub use db::DexEventCoverageEntryDto;
/// Persisted DEX event coverage entry row.
pub use db::DexEventCoverageEntryEntity;
/// Application-facing DEX event coverage summary DTO.
pub use db::DexEventCoverageSummaryDto;
/// Aggregated DEX event coverage summary row.
pub use db::DexEventCoverageSummaryEntity;
/// Normalized fee event persisted from useful non-trade DEX events.
pub use db::FeeEventDto;
/// Persisted fee event row.
pub use db::FeeEventEntity;
/// Application-facing on-chain observation DTO.
pub use db::InstructionObservationDto;
/// Persisted technical observation for one Solana instruction.
pub use db::InstructionObservationEntity;
/// Raw source row used to rebuild the technical instruction-observation index.
pub use db::InstructionObservationSourceRow;
/// Application-facing known HTTP endpoint DTO.
pub use db::KnownHttpEndpointDto;
/// Application-facing known WebSocket endpoint DTO.
pub use db::KnownHttpEndpointEntity;
/// Application-facing known WebSocket endpoint DTO.
pub use db::KnownWsEndpointDto;
/// Persisted known WebSocket endpoint row.
pub use db::KnownWsEndpointEntity;
/// Application-facing launch attribution DTO.
pub use db::LaunchAttributionDto;
/// Persisted launch attribution row.
pub use db::LaunchAttributionEntity;
/// Input used to upsert one launch event row.
pub use db::LaunchEventUpsertInput;
/// Application-facing launch surface DTO.
pub use db::LaunchSurfaceDto;
/// Persisted launch surface row.
pub use db::LaunchSurfaceEntity;
/// Application-facing launch surface key DTO.
pub use db::LaunchSurfaceKeyDto;
/// Persisted launch surface matching key row.
pub use db::LaunchSurfaceKeyEntity;
/// Application-facing normalized liquidity event DTO.
pub use db::LiquidityEventDto;
/// Persisted normalized liquidity event row.
pub use db::LiquidityEventEntity;
/// Normalized liquidity event kind.
pub use db::LiquidityEventKind;
/// Local decoded-event diagnostics summary.
pub use db::LocalDecodedEventDiagnosticSummaryDto;
/// Local DEX corpus decoded-event sample for Demo3.
pub use db::LocalDexCorpusDecodedEventSampleDto;
/// Local DEX corpus pool/pair sample for Demo3.
pub use db::LocalDexCorpusPoolPairSampleDto;
/// Local DEX corpus search request for Demo3.
pub use db::LocalDexCorpusSearchRequestDto;
/// Local DEX corpus search result for Demo3.
pub use db::LocalDexCorpusSearchResultDto;
/// Local DEX corpus search summary for Demo3.
pub use db::LocalDexCorpusSearchSummaryDto;
/// Local DEX corpus transaction sample for Demo3.
pub use db::LocalDexCorpusTransactionSampleDto;
/// Local DEX diagnostics summary.
pub use db::LocalDexDiagnosticSummaryDto;
/// Sample of duplicated trade rows grouped by decoded event id.
pub use db::LocalDuplicateDecodedEventTradeDiagnosticSampleDto;
/// Local decoded-event classification diagnostics summary.
pub use db::LocalEventClassificationDiagnosticSummaryDto;
/// Sample of a launch-origin attribution.
pub use db::LocalLaunchOriginDiagnosticSampleDto;
/// Sample of a decoded trade candidate without linked trade event.
pub use db::LocalMissingTradeEventDiagnosticSampleDto;
/// Missing trade event diagnostics grouped by reason.
pub use db::LocalMissingTradeEventReasonSummaryDto;
/// Sample of multi-trade groups sharing the same signature and pair id.
pub use db::LocalMultiTradeSignaturePairDiagnosticSampleDto;
/// Local pair diagnostics for pairs whose missing trade events are non-actionable.
pub use db::LocalNonActionablePairDiagnosticSummaryDto;
/// Local pair diagnostics grouped by materialization/actionability class.
pub use db::LocalPairActionabilityDiagnosticSummaryDto;
/// Local pair diagnostics summary.
pub use db::LocalPairDiagnosticSummaryDto;
/// Sample of a pair gap.
pub use db::LocalPairGapDiagnosticSampleDto;
/// Local pair diagnostics grouped by trading readiness class.
pub use db::LocalPairTradingReadinessDiagnosticSummaryDto;
/// Internal flat counter row for local diagnostics.
pub use db::LocalPipelineDiagnosticCountersDto;
/// Local pipeline diagnostics summary.
pub use db::LocalPipelineDiagnosticSummaryDto;
/// Sample of a pool-origin row and optional launch linkage.
pub use db::LocalPoolOriginDiagnosticSampleDto;
/// Projected instruction diagnostics grouped by Raydium program id.
pub use db::LocalRaydiumProgramInstructionDiagnosticSummaryDto;
/// Raydium DEX-first surface diagnostics.
pub use db::LocalRaydiumSurfaceDiagnosticSummaryDto;
/// Prioritized sample of an incomplete token metadata row.
pub use db::LocalTokenMetadataGapDiagnosticSampleDto;
/// Source family for one on-chain observation.
pub use db::ObservationSourceKind;
/// Application-facing observed token DTO.
pub use db::ObservedTokenDto;
/// Persisted observed token row.
pub use db::ObservedTokenEntity;
/// Local status of one observed token.
pub use db::ObservedTokenStatus;
/// Application-facing on-chain observation DTO.
pub use db::OnchainObservationDto;
/// Persisted on-chain observation row.
pub use db::OnchainObservationEntity;
/// Application-facing normalized orderbook or limit-order event DTO.
pub use db::OrderbookEventDto;
pub use db::OrderbookEventEntity;
/// Application-facing pair-analytic-signal DTO.
pub use db::PairAnalyticSignalDto;
/// Persisted pair-analytic-signal row.
pub use db::PairAnalyticSignalEntity;
/// Application-facing pair-candle DTO.
pub use db::PairCandleDto;
/// Persisted pair-candle row.
pub use db::PairCandleEntity;
/// Application-facing normalized pair DTO.
pub use db::PairDto;
/// Persisted normalized pair row.
pub use db::PairEntity;
/// Application-facing pair-metric DTO.
pub use db::PairMetricDto;
/// Persisted pair-metric row.
pub use db::PairMetricEntity;
/// Normalized pool administration event persisted from useful non-trade DEX events.
pub use db::PoolAdminEventDto;
/// Persisted pool administration event row.
pub use db::PoolAdminEventEntity;
/// Application-facing normalized pool DTO.
pub use db::PoolDto;
/// Persisted normalized pool row.
pub use db::PoolEntity;
/// Normalized pool kind.
pub use db::PoolKind;
/// Application-facing normalized pool lifecycle event DTO.
pub use db::PoolLifecycleEventDto;
/// Persisted normalized pool lifecycle event row.
pub use db::PoolLifecycleEventEntity;
/// Application-facing normalized pool listing DTO.
pub use db::PoolListingDto;
/// Persisted normalized pool listing row.
pub use db::PoolListingEntity;
/// Application-facing pool-origin DTO.
pub use db::PoolOriginDto;
/// Persisted pool-origin row.
pub use db::PoolOriginEntity;
/// Normalized pool status.
pub use db::PoolStatus;
/// Application-facing normalized pool token DTO.
pub use db::PoolTokenDto;
/// Persisted normalized pool token composition row.
pub use db::PoolTokenEntity;
/// Role of one token inside a normalized pool.
pub use db::PoolTokenRole;
/// Diagnostic row for instructions of one Solana program.
pub use db::ProgramInstructionDiagnosticDto;
/// Raw diagnostic row for instructions of one Solana program.
pub use db::ProgramInstructionDiagnosticEntity;
/// Raw row used to summarize instruction discriminators for one Solana program.
pub use db::ProgramInstructionDiscriminatorRowEntity;
/// Aggregated instruction discriminator diagnostic row.
pub use db::ProgramInstructionDiscriminatorSummaryDto;
/// Application-facing protocol candidate DTO.
///
/// A protocol candidate records a program/instruction that should be inspected
/// later because it may correspond to an unsupported DEX, launch surface,
/// migration path or protocol-specific non-trade event.
pub use db::ProtocolCandidateDto;
/// Persisted protocol candidate row.
pub use db::ProtocolCandidateEntity;
/// Aggregated protocol candidate diagnostic row.
pub use db::ProtocolCandidateSummaryDto;
/// Aggregated protocol candidate diagnostic row.
pub use db::ProtocolCandidateSummaryEntity;
/// Normalized reward event persisted from useful non-trade DEX events.
pub use db::RewardEventDto;
/// Persisted reward event row.
pub use db::RewardEventEntity;
/// Application-facing normalized swap DTO.
pub use db::SwapDto;
/// Persisted normalized swap row.
pub use db::SwapEntity;
/// Swap side relative to the normalized base token of the pair.
pub use db::SwapTradeSide;
/// Application-facing normalized token-account event DTO.
pub use db::TokenAccountEventDto;
/// Persisted normalized token-account event row.
pub use db::TokenAccountEventEntity;
/// Application-facing normalized token burn event DTO.
pub use db::TokenBurnEventDto;
/// Persisted normalized token burn event row.
pub use db::TokenBurnEventEntity;
/// Application-facing normalized token DTO.
pub use db::TokenDto;
/// Persisted normalized token row.
pub use db::TokenEntity;
/// Application-facing normalized token mint event DTO.
pub use db::TokenMintEventDto;
/// Persisted normalized token mint event row.
pub use db::TokenMintEventEntity;
/// Application-facing trade-event DTO.
pub use db::TradeEventDto;
/// Persisted trade-event row.
pub use db::TradeEventEntity;
/// Application-facing transaction classification DTO.
pub use db::TransactionClassificationDto;
/// Persisted transaction classification row.
pub use db::TransactionClassificationEntity;
/// Application-facing wallet DTO.
pub use db::WalletDto;
/// Persisted wallet row.
pub use db::WalletEntity;
/// Application-facing wallet-holding DTO.
pub use db::WalletHoldingDto;
/// Persisted wallet-holding row.
pub use db::WalletHoldingEntity;
/// Application-facing wallet-participation DTO.
pub use db::WalletParticipationDto;
/// Persisted wallet-participation row.
pub use db::WalletParticipationEntity;
/// Inserts one analysis signal row and returns its numeric id.
pub use db::query_analysis_signals_insert;
/// Lists recent analysis signals ordered from newest to oldest.
pub use db::query_analysis_signals_list;
/// Deletes all instructions for one transaction id.
pub use db::query_chain_instructions_delete_by_transaction_id;
/// Reads one chain instruction by its internal id.
pub use db::query_chain_instructions_get_by_id;
/// Inserts one normalized chain instruction row.
pub use db::query_chain_instructions_insert;
/// Lists instructions for one transaction ordered from outer to inner.
pub use db::query_chain_instructions_list_by_transaction_id;
/// Reads one chain slot row by slot number.
pub use db::query_chain_slots_get;
/// Lists recent chain slots ordered from newest to oldest.
pub use db::query_chain_slots_list_recent;
/// Inserts or updates one normalized chain slot row.
pub use db::query_chain_slots_upsert;
/// Reads one chain transaction row by signature.
pub use db::query_chain_transactions_get_by_signature;
/// Lists recent chain transactions ordered from newest to oldest.
pub use db::query_chain_transactions_list_recent;
/// Lists persisted chain transaction signatures for local pipeline replay.
pub use db::query_chain_transactions_list_signatures_for_replay;
/// Inserts or updates one normalized chain transaction row.
pub use db::query_chain_transactions_upsert;
/// Reads one metadata row by key.
pub use db::query_db_metadatas_get;
/// Lists all metadata rows.
pub use db::query_db_metadatas_list;
/// Inserts or updates one metadata row.
pub use db::query_db_metadatas_upsert;
/// Inserts one runtime event row and returns its numeric id.
pub use db::query_db_runtime_events_insert;
/// Lists recent runtime events ordered from newest to oldest.
pub use db::query_db_runtime_events_list_recent;
/// Reads one DEX decode replay ledger row by signature and decoder identity.
pub use db::query_dex_decode_replay_ledger_get_by_signature;
/// Reads one DEX decode replay ledger row by transaction and decoder identity.
pub use db::query_dex_decode_replay_ledger_get_by_transaction;
/// Inserts or updates one DEX decode replay ledger row.
pub use db::query_dex_decode_replay_ledger_upsert;
/// Cleans Raydium Launchpad self-CPI audit rows replaced by direct decoded rows.
pub use db::query_dex_decoded_events_cleanup_raydium_launchpad_anchor_self_cpi_audits;
/// Deletes one decoded DEX event row by its natural key.
pub use db::query_dex_decoded_events_delete_by_key;
/// Deletes an instruction-audit row by discriminator for one protocol.
pub use db::query_dex_decoded_events_delete_instruction_audit_by_discriminator;
/// Deletes local DEX decoded rows and linked materialization rows for one replayed transaction.
pub use db::query_dex_decoded_events_delete_local_replay_scope_by_transaction_id;
/// Deletes upstream registry instruction-match rows already covered by specialized local decoders.
pub use db::query_dex_decoded_events_delete_locally_covered_upstream_instruction_matches;
/// Deletes Meteora DLMM Anchor self-CPI swap audit rows already covered by decoded swaps.
pub use db::query_dex_decoded_events_delete_meteora_dlmm_anchor_swap_instruction_audits;
/// Deletes one Raydium CLMM instruction-audit row by discriminator.
pub use db::query_dex_decoded_events_delete_raydium_clmm_instruction_audit_by_discriminator;
/// Deletes one Raydium Launchpad self-CPI audit row by discriminator.
pub use db::query_dex_decoded_events_delete_raydium_launchpad_anchor_self_cpi_audit;
/// Deletes decoded DEX instruction audit rows related to one decoded instruction.
pub use db::query_dex_decoded_events_delete_related_instruction_audit;
/// Deletes Raydium CLMM instruction-audit rows for locally mapped CLMM instructions.
pub use db::query_dex_decoded_events_delete_replaced_raydium_clmm_instruction_audits;
/// Deletes Raydium CPMM instruction-audit rows already covered by local named rows.
pub use db::query_dex_decoded_events_delete_replaced_raydium_cpmm_instruction_audits;
/// Reads one decoded DEX event by its natural key.
pub use db::query_dex_decoded_events_get_by_key;
/// Returns the latest Pump.fun create payload associated with a token mint.
pub use db::query_dex_decoded_events_get_latest_pump_fun_create_payload_by_mint;
/// Lists decoded DEX events for one transaction.
pub use db::query_dex_decoded_events_list_by_transaction_id;
/// Updates the persisted payload of one decoded DEX event row.
pub use db::query_dex_decoded_events_update_payload_json_by_id;
/// Inserts or updates one decoded DEX event row.
pub use db::query_dex_decoded_events_upsert;
/// Deletes DEX event coverage entries for one decoder.
pub use db::query_dex_event_coverage_entries_delete_by_decoder;
/// Lists DEX event coverage entries for one decoder.
pub use db::query_dex_event_coverage_entries_list_by_decoder;
/// Lists DEX event coverage summaries grouped by decoder.
pub use db::query_dex_event_coverage_entries_list_summary_by_decoder;
/// Refreshes local DEX event coverage counts for every decoder.
pub use db::query_dex_event_coverage_entries_refresh_local_counts;
/// Refreshes local DEX event coverage counts for one decoder.
pub use db::query_dex_event_coverage_entries_refresh_local_counts_by_decoder;
/// Inserts or updates one DEX event coverage entry.
pub use db::query_dex_event_coverage_entries_upsert;
/// Reads one normalized DEX row by code.
pub use db::query_dexs_get_by_code;
/// Lists normalized DEX rows.
pub use db::query_dexs_list;
/// Inserts or updates one normalized DEX row by code.
pub use db::query_dexs_upsert;
/// Returns one fee event by decoded-event id.
pub use db::query_fee_events_get_by_decoded_event_id;
/// Lists recent fee events ordered from newest to oldest.
pub use db::query_fee_events_list_recent;
/// Inserts or updates one normalized fee event row.
pub use db::query_fee_events_upsert;
/// Inserts one on-chain observation row and returns its numeric id.
/// Lists instruction-observation source rows for one transaction signature.
pub use db::query_instruction_observation_source_rows_list_by_signature;
/// Lists recent instruction-observation source rows.
pub use db::query_instruction_observation_source_rows_list_recent;
/// Lists instruction-observation source rows for the local replay window.
pub use db::query_instruction_observation_source_rows_list_replay_window;
/// Deletes instruction observations for a set of transaction ids before rebuilding the technical index.
pub use db::query_instruction_observations_delete_by_transaction_ids;
/// Lists instruction observations by optional filters.
pub use db::query_instruction_observations_list_by_filter;
/// Upserts one instruction observation row.
pub use db::query_instruction_observations_upsert;
/// Reads one known HTTP endpoint by name.
pub use db::query_known_http_endpoints_get;
/// Lists all known HTTP endpoints.
pub use db::query_known_http_endpoints_list;
/// Inserts or updates one known HTTP endpoint row.
pub use db::query_known_http_endpoints_upsert;
/// Reads one known WS endpoint by name.
pub use db::query_known_ws_endpoints_get;
/// Lists all known WS endpoints.
pub use db::query_known_ws_endpoints_list;
/// Inserts or updates one known WS endpoint row.
pub use db::query_known_ws_endpoints_upsert;
/// Returns one launch attribution identified by its decoded-event id, if it exists.
pub use db::query_launch_attributions_get_by_decoded_event_id;
/// Lists all launch attributions attached to one pool id.
pub use db::query_launch_attributions_list_by_pool_id;
/// Inserts or updates one launch attribution row and returns its stable internal id.
pub use db::query_launch_attributions_upsert;
/// Inserts or updates one launch event row.
pub use db::query_launch_events_upsert;
/// Returns one launch-surface matching key identified by its kind and value, if it exists.
pub use db::query_launch_surface_keys_get_by_match;
/// Lists all launch-surface matching keys attached to one launch surface id.
pub use db::query_launch_surface_keys_list_by_surface_id;
/// Inserts or updates one launch-surface matching key and returns its stable internal id.
pub use db::query_launch_surface_keys_upsert;
/// Returns one launch surface identified by its stable short code, if it exists.
pub use db::query_launch_surfaces_get_by_code;
/// Lists all persisted launch surfaces ordered by code.
pub use db::query_launch_surfaces_list;
/// Inserts or updates one launch surface row and returns its stable internal id.
pub use db::query_launch_surfaces_upsert;
/// Lists recent liquidity events ordered from newest to oldest.
pub use db::query_liquidity_events_list_recent;
/// Inserts or updates one normalized liquidity event row.
pub use db::query_liquidity_events_upsert;
/// Lists local decoded-event diagnostic summaries.
pub use db::query_local_decoded_event_diagnostic_list_summaries;
/// Returns aggregate counts for a local DEX corpus search.
pub use db::query_local_dex_corpus_search_get_summary;
/// Lists matching decoded-event samples for a local DEX corpus search.
pub use db::query_local_dex_corpus_search_list_decoded_event_samples;
/// Lists matching pool/pair samples for a local DEX corpus search.
pub use db::query_local_dex_corpus_search_list_pool_pair_samples;
/// Lists matching transaction samples for a local DEX corpus search.
pub use db::query_local_dex_corpus_search_list_transaction_samples;
/// Lists samples of duplicated trade rows by decoded event id.
pub use db::query_local_duplicate_decoded_event_trade_diagnostic_list_samples;
/// Lists local decoded-event classification diagnostic summaries.
pub use db::query_local_event_classification_diagnostic_list_summaries;
/// Lists launch-origin diagnostic samples.
pub use db::query_local_launch_origin_diagnostic_list_samples;
/// Lists samples of decoded trade candidates without linked trade event.
pub use db::query_local_missing_trade_event_diagnostic_list_samples;
/// Lists missing trade events grouped by diagnostic reason.
pub use db::query_local_missing_trade_event_reason_list_summaries;
/// Lists samples of multi-trade signature/pair groups.
pub use db::query_local_multi_trade_signature_pair_diagnostic_list_samples;
/// Lists pair summaries for non-actionable missing trade events.
pub use db::query_local_non_actionable_pair_diagnostic_list_summaries;
/// Lists local pair materialization/actionability summaries.
pub use db::query_local_pair_actionability_diagnostic_list_summaries;
/// Lists local pair diagnostic summaries.
pub use db::query_local_pair_diagnostic_list_summaries;
/// Lists local pair trading-readiness summaries.
pub use db::query_local_pair_trading_readiness_diagnostic_list_summaries;
/// Lists samples of pairs without candles.
pub use db::query_local_pair_without_candle_diagnostic_list_samples;
/// Lists samples of pairs without trade events.
pub use db::query_local_pair_without_trade_diagnostic_list_samples;
/// Returns global local-pipeline diagnostic counters.
pub use db::query_local_pipeline_diagnostic_get_counters;
/// Lists local DEX diagnostic summaries.
pub use db::query_local_pipeline_diagnostic_list_summaries;
/// Lists pool-origin diagnostic samples.
pub use db::query_local_pool_origin_diagnostic_list_samples;
/// Lists observed Raydium program instruction diagnostics.
pub use db::query_local_raydium_program_instruction_diagnostic_list_summaries;
/// Lists prioritized token metadata gap diagnostic samples.
pub use db::query_local_token_metadata_gap_diagnostic_list_samples;
/// Reads one observed token by mint.
pub use db::query_observed_tokens_get_by_mint;
/// Lists observed tokens ordered by newest first.
pub use db::query_observed_tokens_list;
/// Inserts or updates one observed token by mint.
pub use db::query_observed_tokens_upsert;
/// Inserts one on-chain observation row and returns its numeric id.
pub use db::query_onchain_observations_insert;
/// Lists recent on-chain observations ordered from newest to oldest.
pub use db::query_onchain_observations_list_recent;
/// Inserts or updates one normalized orderbook event row.
pub use db::query_orderbook_events_upsert;
/// Returns one pair-analytic-signal row identified by its key, if it exists.
pub use db::query_pair_analytic_signals_get_by_key;
/// Lists all pair-analytic signals for one pair ordered by key.
pub use db::query_pair_analytic_signals_list_by_pair_id;
/// Inserts or updates one pair-analytic-signal row and returns its stable internal id.
pub use db::query_pair_analytic_signals_upsert;
/// Returns one pair-candle row identified by `(pair_id, timeframe_seconds, bucket_start_unix)`.
pub use db::query_pair_candles_get_by_key;
/// Lists candles for one pair and one timeframe ordered by bucket start.
pub use db::query_pair_candles_list_by_pair_and_timeframe;
/// Inserts or updates one pair-candle row and returns its stable internal id.
pub use db::query_pair_candles_upsert;
/// Returns one pair-metric row identified by its pair id, if it exists.
pub use db::query_pair_metrics_get_by_pair_id;
/// Lists all pair-metric rows ordered by pair id.
pub use db::query_pair_metrics_list;
/// Inserts or updates one pair-metric row and returns its stable internal id.
pub use db::query_pair_metrics_upsert;
/// Reads one normalized pair row by pool id.
pub use db::query_pairs_get_by_pool_id;
/// Lists normalized pairs ordered by id ascending.
pub use db::query_pairs_list;
/// Updates the display symbol of one normalized pair row.
pub use db::query_pairs_update_symbol;
/// Inserts or updates one normalized pair row by pool id.
pub use db::query_pairs_upsert;
/// Deletes one stale pool administration event by decoded-event id.
pub use db::query_pool_admin_events_delete_by_decoded_event_id;
/// Returns one pool administration event by decoded-event id.
pub use db::query_pool_admin_events_get_by_decoded_event_id;
/// Lists recent pool administration events ordered from newest to oldest.
pub use db::query_pool_admin_events_list_recent;
/// Inserts or updates one normalized pool administration event row.
pub use db::query_pool_admin_events_upsert;
/// Returns one pool lifecycle event by decoded event id.
pub use db::query_pool_lifecycle_events_get_by_decoded_event_id;
/// Lists recent pool lifecycle events ordered from newest to oldest.
pub use db::query_pool_lifecycle_events_list_recent;
/// Inserts or updates one normalized pool lifecycle event row.
pub use db::query_pool_lifecycle_events_upsert;
/// Reads one normalized pool listing row by pool id.
pub use db::query_pool_listings_get_by_pool_id;
/// Lists normalized pool listings ordered by detected date then id.
pub use db::query_pool_listings_list;
/// Inserts or updates one normalized pool listing row by pool id.
pub use db::query_pool_listings_upsert;
/// Reads one normalized token row by internal id.
pub use db::query_pool_origins_get_by_pool_id;
/// Lists all pool-origin rows ordered by creation time then id.
pub use db::query_pool_origins_list;
/// Inserts or updates one pool-origin row and returns its stable internal id.
pub use db::query_pool_origins_upsert;
/// Lists normalized pool token rows by pool id.
pub use db::query_pool_tokens_list_by_pool_id;
/// Inserts or updates one normalized pool token composition row.
pub use db::query_pool_tokens_upsert;
/// Reads one normalized pool row by address.
pub use db::query_pools_get_by_address;
/// Lists normalized pools ordered by id ascending.
pub use db::query_pools_list;
/// Inserts or updates one normalized pool row by address.
pub use db::query_pools_upsert;
/// Lists diagnostic instruction rows for one program id.
pub use db::query_program_instruction_diagnostics_list_by_program_id;
/// Lists instruction discriminator summaries for one program id.
pub use db::query_program_instruction_discriminator_summaries_list_by_program_id;
/// Lists protocol candidate summaries ordered by investigation priority.
pub use db::query_protocol_candidate_summaries_list_by_priority;
/// Deletes protocol candidates for one transaction.
///
/// This is useful before recomputing candidates for a replayed transaction.
pub use db::query_protocol_candidates_delete_by_transaction_id;
/// Inserts one protocol candidate row.
pub use db::query_protocol_candidates_insert;
/// Lists protocol candidates for one program id.
pub use db::query_protocol_candidates_list_by_program_id;
/// Lists protocol candidates for one transaction.
pub use db::query_protocol_candidates_list_by_transaction_id;
/// Lists recent protocol candidates ordered from newest to oldest.
pub use db::query_protocol_candidates_list_recent;
/// Returns one reward event by decoded-event id.
pub use db::query_reward_events_get_by_decoded_event_id;
/// Lists recent reward events ordered from newest to oldest.
pub use db::query_reward_events_list_recent;
/// Inserts or updates one normalized reward event row.
pub use db::query_reward_events_upsert;
/// Lists recent swaps ordered from newest to oldest.
pub use db::query_swaps_list_recent;
/// Inserts or updates one normalized swap row.
pub use db::query_swaps_upsert;
/// Inserts or updates one normalized token-account event row.
pub use db::query_token_account_events_upsert;
/// Lists recent token burn events ordered from newest to oldest.
pub use db::query_token_burn_events_list_recent;
/// Inserts or updates one normalized token burn event row.
pub use db::query_token_burn_events_upsert;
/// Lists recent token mint events ordered from newest to oldest.
pub use db::query_token_mint_events_list_recent;
/// Inserts or updates one normalized token mint event row.
pub use db::query_token_mint_events_upsert;
/// Reads one normalized token row by internal id.
pub use db::query_tokens_get_by_id;
/// Reads one normalized token row by mint.
pub use db::query_tokens_get_by_mint;
/// Lists all normalized token rows ordered by mint.
pub use db::query_tokens_list;
/// Lists token rows whose display or mint metadata is incomplete.
pub use db::query_tokens_list_missing_metadata;
/// Inserts or updates one normalized token row by mint.
pub use db::query_tokens_upsert;
/// Returns one trade-event row identified by its decoded-event id, if it exists.
pub use db::query_trade_events_get_by_decoded_event_id;
/// Lists trade-event rows for one pair id ordered by creation time then id.
pub use db::query_trade_events_list_by_pair_id;
/// Lists trade-event rows for one transaction id ordered by id.
pub use db::query_trade_events_list_by_transaction_id;
/// Inserts or updates one trade-event row and returns its stable internal id.
pub use db::query_trade_events_upsert;
/// Deletes all local market materialization rows rebuilt from trade events.
pub use db::query_trade_market_materialization_delete_all;
/// Reads one transaction classification by signature.
pub use db::query_transaction_classifications_get_by_signature;
/// Reads one transaction classification by transaction id.
pub use db::query_transaction_classifications_get_by_transaction_id;
/// Lists recent transaction classifications ordered from newest to oldest.
pub use db::query_transaction_classifications_list_recent;
/// Inserts or updates one transaction classification row.
pub use db::query_transaction_classifications_upsert;
/// Returns one wallet-holding row identified by `(wallet_id, token_id)`, if it exists.
pub use db::query_wallet_holdings_get_by_wallet_and_token;
/// Lists wallet-holding rows for one wallet id.
pub use db::query_wallet_holdings_list_by_wallet_id;
/// Inserts or updates one wallet-holding row and returns its stable internal id.
pub use db::query_wallet_holdings_upsert;
/// Returns one wallet-participation identified by its unique key, if it exists.
pub use db::query_wallet_participations_get_by_unique_key;
/// Lists wallet-participation rows for one pool id.
pub use db::query_wallet_participations_list_by_pool_id;
/// Lists wallet-participation rows for one wallet id.
pub use db::query_wallet_participations_list_by_wallet_id;
/// Inserts or updates one wallet-participation row and returns its stable internal id.
pub use db::query_wallet_participations_upsert;
/// Returns one wallet identified by its address, if it exists.
pub use db::query_wallets_get_by_address;
/// Lists all persisted wallets ordered by address.
pub use db::query_wallets_list;
/// Inserts or updates one wallet row and returns its stable internal id.
pub use db::query_wallets_upsert;
/// One normalized observation ready to be persisted.
pub use detect::DetectionObservationInput;
/// Persistence façade between technical detection and database storage.
pub use detect::DetectionPersistenceService;
/// One pool candidate detected from a technical source.
pub use detect::DetectionPoolCandidateInput;
/// Result of one pool candidate persistence operation.
pub use detect::DetectionPoolCandidateResult;
/// One normalized signal ready to be persisted.
pub use detect::DetectionSignalInput;
/// One token candidate detected from a technical source.
pub use detect::DetectionTokenCandidateInput;
/// Result of one token candidate persistence operation.
pub use detect::DetectionTokenCandidateResult;
/// Result of one Solana WebSocket detection pass.
pub use detect::SolanaWsDetectionOutcome;
/// Detection service for Solana WebSocket notifications.
pub use detect::SolanaWsDetectionService;
/// One forwarded WebSocket notification ready for detection.
pub use detect::WsDetectionNotificationEnvelope;
/// Asynchronous relay between `WsClient` notifications and the detection service.
pub use detect::WsDetectionRelay;
/// Runtime statistics for one relay worker.
pub use detect::WsDetectionRelayStats;
/// Decoded DexLab create-pool event.
pub use dex::DexlabCreatePoolDecoded;
/// Decoded DexLab event.
pub use dex::DexlabDecodedEvent;
/// DexLab decoder.
pub use dex::DexlabDecoder;
/// Decoded DexLab swap event.
pub use dex::DexlabSwapDecoded;
/// Decoded FluxBeam create-pool event.
pub use dex::FluxbeamCreatePoolDecoded;
/// Decoded FluxBeam event.
pub use dex::FluxbeamDecodedEvent;
/// FluxBeam decoder.
pub use dex::FluxbeamDecoder;
/// Decoded FluxBeam swap event.
pub use dex::FluxbeamSwapDecoded;
/// Decoded Meteora DAMM v1 create-pool event.
pub use dex::MeteoraDammV1CreatePoolDecoded;
/// Decoded Meteora DAMM v1 event.
pub use dex::MeteoraDammV1DecodedEvent;
/// Meteora DAMM v1 decoder.
pub use dex::MeteoraDammV1Decoder;
/// Decoded Meteora DAMM v1 fee event.
pub use dex::MeteoraDammV1FeeDecoded;
/// Decoded Meteora DAMM v1 liquidity event.
pub use dex::MeteoraDammV1LiquidityDecoded;
/// Decoded Meteora DAMM v1 pool administration event.
pub use dex::MeteoraDammV1PoolAdminDecoded;
/// Decoded Meteora DAMM v1 pool lifecycle event.
pub use dex::MeteoraDammV1PoolLifecycleDecoded;
/// Decoded Meteora DAMM v1 swap event.
pub use dex::MeteoraDammV1SwapDecoded;
/// Decoded Meteora DAMM v2 create-pool event.
pub use dex::MeteoraDammV2CreatePoolDecoded;
/// Decoded Meteora DAMM v2 event.
pub use dex::MeteoraDammV2DecodedEvent;
/// Meteora DAMM v2 decoder.
pub use dex::MeteoraDammV2Decoder;
/// Decoded Meteora DAMM v2 swap event.
pub use dex::MeteoraDammV2SwapDecoded;
/// Decoded Meteora DBC create-pool event.
pub use dex::MeteoraDbcCreatePoolDecoded;
/// Decoded Meteora DBC event.
pub use dex::MeteoraDbcDecodedEvent;
/// Meteora DBC decoder.
pub use dex::MeteoraDbcDecoder;
/// Decoded Meteora DBC swap event.
pub use dex::MeteoraDbcSwapDecoded;
/// Decoded Meteora DLMM create-pool event.
pub use dex::MeteoraDlmmCreatePoolDecoded;
/// Decoded Meteora DLMM event.
pub use dex::MeteoraDlmmDecodedEvent;
/// Meteora DLMM decoder.
pub use dex::MeteoraDlmmDecoder;
/// Decoded Meteora DLMM fee collection event.
pub use dex::MeteoraDlmmFeeDecoded;
/// Decoded Meteora DLMM liquidity lifecycle event.
pub use dex::MeteoraDlmmLiquidityDecoded;
/// Decoded Meteora DLMM pool lifecycle event.
pub use dex::MeteoraDlmmPoolLifecycleDecoded;
/// Decoded Meteora DLMM reward or emission event.
pub use dex::MeteoraDlmmRewardDecoded;
/// Decoded Meteora DLMM swap event.
pub use dex::MeteoraDlmmSwapDecoded;
/// Decoded OpenBook v2 audit event.
pub use dex::OpenBookV2AuditDecoded;
/// Decoded OpenBook v2 event.
pub use dex::OpenBookV2DecodedEvent;
/// OpenBook v2 audit-only decoder.
pub use dex::OpenBookV2Decoder;
/// Decoded Orca Whirlpools create-pool event.
pub use dex::OrcaWhirlpoolsCreatePoolDecoded;
/// Decoded Orca Whirlpools event.
pub use dex::OrcaWhirlpoolsDecodedEvent;
/// Orca Whirlpools decoder.
pub use dex::OrcaWhirlpoolsDecoder;
/// Decoded Orca Whirlpools swap event.
pub use dex::OrcaWhirlpoolsSwapDecoded;
/// Decoded Phoenix v1 audit event.
pub use dex::PhoenixV1AuditDecoded;
/// Decoded Phoenix v1 event.
pub use dex::PhoenixV1DecodedEvent;
/// Phoenix v1 audit-only decoder.
pub use dex::PhoenixV1Decoder;
/// Decoded Pump Fees event.
pub use dex::PumpFeesDecodedEvent;
/// Pump Fees decoder.
pub use dex::PumpFeesDecoder;
/// Decoded Pump Fees instruction or Anchor event.
pub use dex::PumpFeesInstructionDecoded;
/// Decoded Pump.fun `create_v2` token event.
pub use dex::PumpFunCreateV2TokenDecoded;
/// Decoded Pump.fun event.
pub use dex::PumpFunDecodedEvent;
/// Pump.fun decoder.
pub use dex::PumpFunDecoder;
/// Decoded Pump.fun audit-only instruction event.
pub use dex::PumpFunInstructionAuditDecoded;
/// Decoded Pump.fun bonding-curve trade event.
pub use dex::PumpFunTradeDecoded;
/// Decoded PumpSwap event.
pub use dex::PumpSwapDecodedEvent;
/// PumpSwap decoder.
pub use dex::PumpSwapDecoder;
/// Decoded PumpSwap non-trade instruction event.
pub use dex::PumpSwapInstructionDecoded;
/// Decoded PumpSwap trade event.
pub use dex::PumpSwapTradeDecoded;
/// Decoded Raydium AmmV4 event.
pub use dex::RaydiumAmmV4DecodedEvent;
/// Raydium AmmV4 decoder.
pub use dex::RaydiumAmmV4Decoder;
/// Decoded Raydium AmmV4 initialize2 pool event.
pub use dex::RaydiumAmmV4Initialize2PoolDecoded;
/// Decoded Raydium AmmV4 non-swap or decoded-only instruction event.
pub use dex::RaydiumAmmV4InstructionDecoded;
/// Decoded Raydium AMM v4 swap event.
pub use dex::RaydiumAmmV4SwapDecoded;
/// Decoded Raydium CLMM collect_protocol_fee instruction.
pub use dex::RaydiumClmmCollectProtocolFeeDecoded;
/// Decoded Raydium CLMM create_pool instruction.
pub use dex::RaydiumClmmCreatePoolDecoded;
/// Decoded Raydium CLMM event.
pub use dex::RaydiumClmmDecodedEvent;
/// Decoded Raydium CLMM instruction event with projected instruction id.
pub use dex::RaydiumClmmDecodedInstructionEvent;
/// Raydium CLMM transaction decoder.
pub use dex::RaydiumClmmDecoder;
/// Decoded Raydium CLMM Anchor Program data event payload.
pub use dex::RaydiumClmmProgramDataEventDecoded;
/// Decoded Raydium CLMM legacy swap event.
pub use dex::RaydiumClmmSwapLegacyDecoded;
/// Decoded Raydium CLMM swap_v2 instruction.
pub use dex::RaydiumClmmSwapV2Decoded;
/// Raydium CPMM decoded event.
pub use dex::RaydiumCpmmDecodedEvent;
/// Raydium CPMM Anchor CPI liquidity-change event.
pub use dex::RaydiumCpmmLpChangeEventDecoded;
/// Raydium CPMM decoded swap.
pub use dex::RaydiumCpmmSwapDecoded;
/// Raydium CPMM Anchor CPI swap event retained as audit evidence.
pub use dex::RaydiumCpmmSwapEventDecoded;
/// Raydium CPMM swap mode.
pub use dex::RaydiumCpmmSwapMode;
/// Raydium Stable Swap decoded event.
pub use dex::RaydiumStableSwapDecodedEvent;
/// Raydium Stable Swap decoder.
pub use dex::RaydiumStableSwapDecoder;
/// Decoded Raydium Stable Swap instruction.
pub use dex::RaydiumStableSwapInstructionDecoded;
/// Decoded Raydium Stable Swap program-data swap event.
pub use dex::RaydiumStableSwapSwapEventDecoded;
/// Decodes one Raydium CPMM instruction from projected instruction fields.
pub use dex::classify_raydium_cpmm_instruction_data;
/// Classifies one Raydium Stable Swap instruction data payload.
pub use dex::classify_raydium_stable_swap_instruction_data;
/// Decodes a Raydium CLMM instruction.
pub use dex::decode_raydium_clmm_instruction;
/// Decodes one Raydium CLMM Anchor Program data event.
pub use dex::decode_raydium_clmm_program_data_event;
/// Decodes one Raydium CPMM instruction from projected instruction fields.
pub use dex::decode_raydium_cpmm_instruction;
/// Decodes Raydium CPMM Anchor events emitted in `Program data:` logs.
pub use dex::decode_raydium_cpmm_program_data_event;
/// Decodes Raydium Stable Swap `Program data:` event payloads.
pub use dex::decode_raydium_stable_swap_program_data_event;
/// DEX decode service.
pub use dex_decode::DexDecodeService;
/// Business-level DEX detection service.
pub use dex_detect::DexDetectService;
/// Result of one business-level DEX pool detection.
pub use dex_detect::DexPoolDetectionResult;
/// Stable DEX event actionability class.
pub use dex_event_classification::DexEventActionability;
/// Stable DEX event business category.
pub use dex_event_classification::DexEventCategory;
/// Fine-grained DEX event lifecycle kind.
pub use dex_event_classification::DexEventLifecycleKind;
/// Classifies a DEX event into an actionability class.
pub use dex_event_classification::classify_dex_event_actionability;
/// Classifies a DEX event into an actionability class and returns its persisted code.
pub use dex_event_classification::classify_dex_event_actionability_code;
/// Classifies a DEX event kind into a stable category.
pub use dex_event_classification::classify_dex_event_category;
/// Classifies a DEX event kind and returns its persisted category code.
pub use dex_event_classification::classify_dex_event_category_code;
/// Classifies a DEX event kind into a fine-grained lifecycle kind.
pub use dex_event_classification::classify_dex_event_lifecycle_kind;
/// Classifies a DEX event kind into a fine-grained lifecycle kind code.
pub use dex_event_classification::classify_dex_event_lifecycle_kind_code;
/// Enriches and serializes a decoded DEX payload.
pub use dex_event_classification::enrich_and_serialize_dex_decoded_payload;
/// Enriches a decoded DEX payload with classification metadata.
pub use dex_event_classification::enrich_dex_decoded_payload;
/// Parses, enriches and serializes a decoded DEX payload.
pub use dex_event_classification::enrich_serialized_dex_decoded_payload;
/// Returns true when a decoded payload is a candle candidate.
pub use dex_event_classification::is_decoded_event_candle_candidate;
/// Returns true when a decoded payload is a trade candidate.
pub use dex_event_classification::is_decoded_event_trade_candidate;
/// Returns true for admin/config/permission DEX events.
pub use dex_event_classification::is_dex_admin_event_kind;
/// Returns true when a DEX event kind can directly feed candle materialization.
pub use dex_event_classification::is_dex_candle_candidate_event_kind;
/// Returns true for fee collection DEX events.
pub use dex_event_classification::is_dex_fee_event_kind;
pub use dex_event_classification::is_dex_informational_event_kind;
/// Returns true for launch or bonding-curve creation DEX events.
pub use dex_event_classification::is_dex_launch_event_kind;
/// Returns true for liquidity add-like DEX events.
pub use dex_event_classification::is_dex_liquidity_add_event_kind;
/// Returns true for liquidity lifecycle DEX events.
pub use dex_event_classification::is_dex_liquidity_event_kind;
/// Returns true for liquidity remove-like DEX events.
pub use dex_event_classification::is_dex_liquidity_remove_event_kind;
/// Returns true for migration DEX events.
pub use dex_event_classification::is_dex_migration_event_kind;
/// Returns true for orderbook or limit-order events that must not become candles.
pub use dex_event_classification::is_dex_orderbook_event_kind;
/// Returns true for pair creation DEX events.
pub use dex_event_classification::is_dex_pair_creation_event_kind;
/// Returns true for pool creation DEX events.
pub use dex_event_classification::is_dex_pool_creation_event_kind;
/// Returns true for pool lifecycle DEX events.
pub use dex_event_classification::is_dex_pool_lifecycle_event_kind;
/// Returns true for position close DEX events.
pub use dex_event_classification::is_dex_position_close_event_kind;
/// Returns true for position open DEX events.
pub use dex_event_classification::is_dex_position_open_event_kind;
/// Returns true for reward or emission DEX events.
pub use dex_event_classification::is_dex_reward_event_kind;
/// Returns true for token-account close events detected by DEX decoders.
pub use dex_event_classification::is_dex_token_account_close_event_kind;
/// Returns true for token-account creation events detected by DEX decoders.
pub use dex_event_classification::is_dex_token_account_create_event_kind;
/// Returns true for token-account lifecycle events detected by DEX decoders.
pub use dex_event_classification::is_dex_token_account_event_kind;
/// Returns true for token burn DEX events.
pub use dex_event_classification::is_dex_token_burn_event_kind;
/// Returns true for token mint DEX events.
pub use dex_event_classification::is_dex_token_mint_event_kind;
/// Returns true for swap-like DEX events.
pub use dex_event_classification::is_dex_trade_event_kind;
/// Service that syncs upstream registry entries into event coverage rows.
pub use dex_event_coverage::DexEventCoverageService;
/// Result of one event coverage sync or refresh pass.
pub use dex_event_coverage::DexEventCoverageSyncResult;
/// Static DEX support matrix entry.
pub use dex_support_matrix::DexSupportMatrixEntry;
/// Owned DEX support matrix entry DTO.
pub use dex_support_matrix::DexSupportMatrixEntryDto;
/// Returns all static DEX support matrix entries.
pub use dex_support_matrix::dex_support_matrix_entries;
/// Looks up one DEX support matrix entry by internal code.
pub use dex_support_matrix::dex_support_matrix_entry_by_code;
/// Looks up one DEX support matrix entry by primary or router program id.
pub use dex_support_matrix::dex_support_matrix_entry_by_program_id;
/// Returns all DEX support matrix entries as owned DTOs.
pub use dex_support_matrix::dex_support_matrix_entry_dtos;
/// Global error type used by the `kb_lib` crate.
///
/// The project intentionally avoids `anyhow` and `thiserror`, so this
/// enum centralizes the main error families with explicit textual messages.
pub use error::Error;
/// Generic asynchronous HTTP client.
pub use http_client::HttpClient;
/// Local endpoint status.
pub use http_client::HttpEndpointStatus;
/// Local HTTP method class used for independent limit buckets.
pub use http_client::HttpMethodClass;
/// JSON-RPC 2.0 error object.
pub use http_client::JsonRpcHttpErrorObject;
/// JSON-RPC 2.0 error response.
pub use http_client::JsonRpcHttpErrorResponse;
/// JSON-RPC 2.0 request envelope for HTTP.
pub use http_client::JsonRpcHttpRequest;
/// Parsed HTTP JSON-RPC response envelope.
pub use http_client::JsonRpcHttpResponse;
/// JSON-RPC 2.0 success response.
pub use http_client::JsonRpcHttpSuccessResponse;
/// Parses one JSON-RPC HTTP response text.
pub use http_client::parse_json_rpc_http_response_text;
/// Parses one JSON-RPC HTTP response value.
pub use http_client::parse_json_rpc_http_response_value;
/// Pool of HTTP endpoints.
pub use http_pool::HttpEndpointPool;
/// Snapshot of one pooled HTTP endpoint.
pub use http_pool::HttpPoolClientSnapshot;
/// Instruction-observation index refresh result.
pub use instruction_observation_index::InstructionObservationIndexRefreshResult;
/// Technical service that indexes observed Solana instructions.
pub use instruction_observation_index::InstructionObservationIndexService;
/// JSON-RPC 2.0 error object.
pub use json_rpc_ws::JsonRpcWsErrorObject;
/// JSON-RPC 2.0 error response.
pub use json_rpc_ws::JsonRpcWsErrorResponse;
/// Parsed incoming JSON-RPC WebSocket message.
pub use json_rpc_ws::JsonRpcWsIncomingMessage;
/// JSON-RPC 2.0 notification message.
pub use json_rpc_ws::JsonRpcWsNotification;
/// JSON-RPC 2.0 notification parameter object.
pub use json_rpc_ws::JsonRpcWsNotificationParams;
/// Generic JSON-RPC 2.0 request sent over WebSocket.
pub use json_rpc_ws::JsonRpcWsRequest;
/// JSON-RPC 2.0 success response.
pub use json_rpc_ws::JsonRpcWsSuccessResponse;
/// Parses a JSON value into a JSON-RPC incoming message.
///
/// This parser accepts only server-originating incoming message shapes:
/// success responses, error responses, and notifications.
pub use json_rpc_ws::is_probable_json_rpc_object_text;
/// Parses a raw text message into a JSON-RPC incoming message.
///
/// This parser accepts only server-originating incoming message shapes:
/// success responses, error responses, and notifications.
pub use json_rpc_ws::parse_json_rpc_ws_incoming_text;
/// Parses a JSON value into a JSON-RPC incoming message.
///
/// This parser accepts only server-originating incoming message shapes:
/// success responses, error responses, and notifications.
pub use json_rpc_ws::parse_json_rpc_ws_incoming_value;
/// Result of one launch surface attribution.
pub use launch_origin::LaunchAttributionResult;
/// Launch surface attribution service.
pub use launch_origin::LaunchOriginService;
/// Local DEX corpus search service used by Demo3.
pub use local_dex_corpus_search::LocalDexCorpusSearchService;
/// Local pipeline diagnostics service.
pub use local_pipeline_diagnostics::LocalPipelineDiagnosticsService;
/// Configuration for a local pipeline replay pass.
pub use local_pipeline_replay::LocalPipelineReplayConfig;
/// Summary of a local pipeline replay pass.
pub use local_pipeline_replay::LocalPipelineReplayResult;
/// Local pipeline replay service.
pub use local_pipeline_replay::LocalPipelineReplayService;
/// Replays the local pipeline from persisted raw chain transaction rows.
pub use local_pipeline_replay::replay_local_pipeline;
/// Configuration for a local pipeline validation pass.
pub use local_pipeline_validation::LocalPipelineValidationConfig;
/// A single local pipeline validation issue.
pub use local_pipeline_validation::LocalPipelineValidationIssueDto;
/// Result of a local pipeline validation pass.
pub use local_pipeline_validation::LocalPipelineValidationReportDto;
/// Complete local pipeline validation run result.
pub use local_pipeline_validation::LocalPipelineValidationRunDto;
/// Local pipeline validation service.
pub use local_pipeline_validation::LocalPipelineValidationService;
/// Validates a diagnostics summary without performing database access.
pub use local_pipeline_validation::validate_local_pipeline_diagnostics_summary;
/// Result of non-trade event materialization for one transaction.
pub use non_trade_event_materialization::NonTradeEventMaterializationResult;
/// Materializes useful non-trade decoded DEX events.
pub use non_trade_event_materialization::NonTradeEventMaterializationService;
/// Backfill signatures grouped by candidate kind.
pub use onchain_dex_pair_discovery::OnchainDexBackfillSignaturesByKindDto;
/// Candidate account inferred from generic transaction evidence.
pub use onchain_dex_pair_discovery::OnchainDexCandidateAccountDto;
/// Candidate summary grouped by kind and transaction success state.
pub use onchain_dex_pair_discovery::OnchainDexCandidateKindSummaryDto;
/// Cursor hint for one on-chain DEX discovery source address.
pub use onchain_dex_pair_discovery::OnchainDexPaginationCursorDto;
/// Candidate transaction/instruction observed on-chain for one DEX program id.
pub use onchain_dex_pair_discovery::OnchainDexPairCandidateDto;
/// Request for on-chain DEX pair/pool discovery.
pub use onchain_dex_pair_discovery::OnchainDexPairDiscoveryRequestDto;
/// Result of one on-chain DEX pair/pool discovery run.
pub use onchain_dex_pair_discovery::OnchainDexPairDiscoveryResultDto;
/// On-chain pair/pool discovery service.
pub use onchain_dex_pair_discovery::OnchainDexPairDiscoveryService;
/// Rejected on-chain DEX candidate summary DTO.
pub use onchain_dex_pair_discovery::OnchainDexRejectedCandidateSummaryDto;
/// Token-balance delta observed in one transaction through Solana transaction metadata.
pub use onchain_dex_pair_discovery::OnchainDexTokenBalanceDeltaDto;
/// One pair-analytic-signal recording result.
pub use pair_analytic_signal::PairAnalyticSignalResult;
/// Pair analytic signal service.
pub use pair_analytic_signal::PairAnalyticSignalService;
/// One pair-candle aggregation result.
pub use pair_candle_aggregation::PairCandleAggregationResult;
/// Pair-candle aggregation service.
///
/// This service materializes a small set of standard timeframes in base storage.
/// Arbitrary timeframes are rebuilt on demand through `PairCandleQueryService`.
pub use pair_candle_aggregation::PairCandleAggregationService;
/// Pair-candle query service.
///
/// Standard materialized timeframes are served from base storage.
/// Arbitrary timeframes are rebuilt on demand from `trade_events`.
pub use pair_candle_query::PairCandleQueryService;
/// Summary produced by a pair-symbol refresh pass.
pub use pair_symbol::PairSymbolRefreshResult;
/// Service that refreshes `k_sol_pairs.symbol` from base and quote token metadata.
pub use pair_symbol::PairSymbolRefreshService;
/// Builds a readable pair symbol from token symbols with mint fallback.
pub use pair_symbol::build_pair_symbol;
/// Refreshes all persisted pair display symbols.
pub use pair_symbol::refresh_pair_symbols;
/// One recorded pool-origin result.
pub use pool_origin::PoolOriginResult;
/// Pool-origin consolidation service.
pub use pool_origin::PoolOriginService;
/// Typed Solana PubSub notification payload.
pub use solana_pubsub_ws::SolanaWsTypedNotification;
/// Parses a Solana JSON-RPC notification into an official typed payload.
pub use solana_pubsub_ws::parse_solana_ws_typed_notification;
/// Parses a typed Solana PubSub notification from a generic websocket event.
///
/// This returns:
/// - `Ok(Some(...))` for JSON-RPC notification-bearing events
/// - `Ok(None)` for events that do not carry a notification
/// - `Err(...)` when a notification is present but cannot be decoded
pub use solana_pubsub_ws::parse_solana_ws_typed_notification_from_event;
/// One pool-backfill result summary.
pub use token_backfill::PoolBackfillResult;
/// One signature-backfill result summary.
pub use token_backfill::SignatureBackfillResult;
/// One item produced by a batch signature backfill.
pub use token_backfill::SignatureBatchBackfillItemResult;
/// Batch signature-backfill result summary.
pub use token_backfill::SignatureBatchBackfillResult;
/// One token-backfill result summary.
pub use token_backfill::TokenBackfillResult;
/// Historical token backfill service.
///
/// This service reuses the existing transaction projection and downstream
/// DEX pipeline instead of introducing a separate historical code path.
pub use token_backfill::TokenBackfillService;
/// Summary produced by a token metadata backfill pass.
pub use token_metadata::TokenMetadataBackfillResult;
/// Service that enriches persisted token rows with mint and display metadata.
pub use token_metadata::TokenMetadataBackfillService;
/// Guard keeping non-blocking tracing workers alive.
///
/// The guard must remain alive during the whole application lifetime so that
/// buffered log records are flushed correctly.
pub use tracing::TracingGuard;
/// Initializes the global tracing subscriber.
///
/// This function is expected to be called once at application startup.
pub use tracing::init_tracing;
/// One trade-aggregation result.
pub use trade_aggregation::TradeAggregationResult;
/// Trade-aggregation service.
pub use trade_aggregation::TradeAggregationService;
/// Service used to classify projected Solana transactions.
pub use transaction_classification::TransactionClassificationService;
/// Service projecting resolved transaction JSON into internal chain tables.
pub use tx_model::TransactionModelService;
/// Result of one transaction resolution pass.
pub use tx_resolution::TransactionResolutionOutcome;
/// One transaction resolution request built from a WebSocket notification.
pub use tx_resolution::TransactionResolutionRequest;
/// Transaction resolution service.
pub use tx_resolution::TransactionResolutionService;
/// One forwarded WebSocket notification envelope for transaction resolution.
pub use tx_resolution::WsTransactionResolutionEnvelope;
/// Relay that consumes forwarded WS notifications and resolves matching
/// signatures through HTTP `getTransaction`.
pub use tx_resolution::WsTransactionResolutionRelay;
/// Runtime statistics for one transaction resolution relay worker.
pub use tx_resolution::WsTransactionResolutionRelayStats;
/// Generic connection state used by transport clients.
pub use types::ConnectionState;
/// Read-only upstream registry service.
pub use upstream_registry::UpstreamRegistryService;
/// Static upstream registry entry kind for account layouts.
pub use upstream_registry_types::ENTRY_KIND_ACCOUNT;
/// Static upstream registry entry kind for events.
pub use upstream_registry_types::ENTRY_KIND_EVENT;
/// Static upstream registry entry kind for instructions.
pub use upstream_registry_types::ENTRY_KIND_INSTRUCTION;
/// Static upstream registry entry kind for programs.
pub use upstream_registry_types::ENTRY_KIND_PROGRAM;
/// Generic upstream Git proof status for layout-only unverified entries.
pub use upstream_registry_types::PROOF_STATUS_UPSTREAM_GIT_LAYOUT_UNVERIFIED;
/// Generic upstream Git proof status for locally materialized entries.
pub use upstream_registry_types::PROOF_STATUS_UPSTREAM_GIT_LOCAL_CORPUS_MATERIALIZED;
/// Generic upstream Git proof status for locally observed entries.
pub use upstream_registry_types::PROOF_STATUS_UPSTREAM_GIT_LOCAL_CORPUS_OBSERVED;
/// Generic upstream Git proof status for decoder-mapped unverified entries.
pub use upstream_registry_types::PROOF_STATUS_UPSTREAM_GIT_MAPPED_UNVERIFIED;
/// Generic upstream Git proof status for unverified entries.
pub use upstream_registry_types::PROOF_STATUS_UPSTREAM_GIT_UNVERIFIED;
/// Generic event kind used for instruction-level upstream registry matches.
pub use upstream_registry_types::UPSTREAM_REGISTRY_INSTRUCTION_MATCH_EVENT_KIND;
/// Generic protocol name used for upstream registry matches that are not business-materialized.
pub use upstream_registry_types::UPSTREAM_REGISTRY_PROTOCOL_NAME;
/// Static upstream registry entry.
pub use upstream_registry_types::UpstreamRegistryEntry;
/// Owned upstream registry entry DTO.
pub use upstream_registry_types::UpstreamRegistryEntryDto;
/// Upstream registry search request DTO.
pub use upstream_registry_types::UpstreamRegistrySearchRequestDto;
/// Upstream registry search result DTO.
pub use upstream_registry_types::UpstreamRegistrySearchResultDto;
/// Upstream registry summary DTO.
pub use upstream_registry_types::UpstreamRegistrySummaryDto;
/// One wallet-holding observation result.
pub use wallet_holding_observation::WalletHoldingObservationResult;
/// Wallet-holding observation service.
pub use wallet_holding_observation::WalletHoldingObservationService;
/// One wallet-observation result.
pub use wallet_observation::WalletObservationResult;
/// Wallet-observation service.
pub use wallet_observation::WalletObservationService;
/// Generic asynchronous WebSocket client.
pub use ws_client::WsClient;
/// Incoming WebSocket transport event emitted by [`crate::WsClient`].
pub use ws_client::WsEvent;
/// Outgoing transport-level WebSocket message.
pub use ws_client::WsOutgoingMessage;
/// Active subscription metadata tracked by the client runtime.
pub use ws_client::WsSubscriptionInfo;
/// One hybrid WebSocket observation result.
pub use ws_hybrid_observation::WsHybridObservationResult;
/// Hybrid WebSocket technical observation service.
pub use ws_hybrid_observation::WsHybridObservationService;
/// hybrid technical observation recording.
pub use ws_hybrid_runtime::WsHybridRuntimeService;
/// Snapshot of hybrid WebSocket watch targets.
pub use ws_hybrid_watch::WsHybridWatchService;
/// Snapshot of hybrid WebSocket watch targets.
pub use ws_hybrid_watch::WsHybridWatchSnapshot;
/// One hybrid WebSocket watch target.
pub use ws_hybrid_watch::WsWatchTarget;
/// Kind of hybrid WebSocket watch target.
pub use ws_hybrid_watch::WsWatchTargetKind;
/// Snapshot of one managed endpoint.
pub use ws_manager::WsManagedEndpointSnapshot;
/// Multi-client WebSocket orchestrator.
pub use ws_manager::WsManager;
/// Snapshot of the whole manager state.
pub use ws_manager::WsManagerSnapshot;