feat(geyser): load ALT for V0 messages on deshred-transactions (#312)

leafaar · web-flow · commit 9d2aae03b97a · 2026-03-31T04:38:58.000Z
* feat(geyser): load ALT for V0 messages on deshred-transactions

* chore(geyser): add metrics for alt loading and deshred-txn
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/core/src/completed_data_sets_service.rs b/core/src/completed_data_sets_service.rs
@@ -11,17 +11,21 @@ use {
         blockstore::{Blockstore, CompletedDataSetInfo},
         deshred_transaction_notifier_interface::DeshredTransactionNotifierArc,
     },
+    solana_measure::measure::Measure,
+    solana_message::{v0::LoadedAddresses, VersionedMessage},
+    solana_metrics::*,
     solana_rpc::{max_slots::MaxSlots, rpc_subscriptions::RpcSubscriptions},
-    solana_message::VersionedMessage,
+    solana_runtime::bank_forks::BankForks,
     solana_signature::Signature,
+    solana_svm_transaction::message_address_table_lookup::SVMMessageAddressTableLookup,
     solana_transaction::{
         simple_vote_transaction_checker::is_simple_vote_transaction_impl,
         versioned::VersionedTransaction,
     },
     std::{
         sync::{
             atomic::{AtomicBool, Ordering},
-            Arc,
+            Arc, RwLock,
         },
         thread::{self, Builder, JoinHandle},
         time::Duration,
@@ -45,6 +49,32 @@ fn is_simple_vote_transaction(tx: &VersionedTransaction) -> bool {
     is_simple_vote_transaction_impl(&tx.signatures, is_legacy, instruction_programs)
 }
 
+/// Load addresses from address lookup tables for a versioned transaction.
+/// Returns None for legacy transactions or if address resolution fails.
+/// Takes a Bank reference to avoid repeated lock acquisition.
+fn load_transaction_addresses(
+    tx: &VersionedTransaction,
+    bank: &solana_runtime::bank::Bank,
+) -> Option<LoadedAddresses> {
+    let VersionedMessage::V0(message) = &tx.message else {
+        // Legacy transactions don't have address table lookups
+        return None;
+    };
+
+    if message.address_table_lookups.is_empty() {
+        return None;
+    }
+
+    bank.load_addresses_from_ref(
+        message
+            .address_table_lookups
+            .iter()
+            .map(SVMMessageAddressTableLookup::from),
+    )
+    .ok()
+    .map(|(addresses, _deactivation_slot)| addresses)
+}
+
 pub struct CompletedDataSetsService {
     thread_hdl: JoinHandle<()>,
 }
@@ -57,6 +87,7 @@ impl CompletedDataSetsService {
         deshred_transaction_notifier: Option<DeshredTransactionNotifierArc>,
         exit: Arc<AtomicBool>,
         max_slots: Arc<MaxSlots>,
+        bank_forks: Arc<RwLock<BankForks>>,
     ) -> Self {
         let thread_hdl = Builder::new()
             .name("solComplDataSet".to_string())
@@ -72,6 +103,7 @@ impl CompletedDataSetsService {
                         &rpc_subscriptions,
                         &deshred_transaction_notifier,
                         &max_slots,
+                        &bank_forks,
                     ) {
                         break;
                     }
@@ -88,21 +120,70 @@ impl CompletedDataSetsService {
         rpc_subscriptions: &RpcSubscriptions,
         deshred_transaction_notifier: &Option<DeshredTransactionNotifierArc>,
         max_slots: &Arc<MaxSlots>,
+        bank_forks: &RwLock<BankForks>,
     ) -> Result<(), RecvTimeoutError> {
         const RECV_TIMEOUT: Duration = Duration::from_secs(1);
-        let handle_completed_data_set_info = |completed_data_set_info| {
+
+        let mut batch_measure = Measure::start("deshred_geyser_batch");
+
+        // Get root bank once per batch to minimize lock contention
+        let root_bank = deshred_transaction_notifier
+            .as_ref()
+            .and_then(|_| bank_forks.read().ok())
+            .map(|forks| forks.root_bank());
+
+        // Metrics accumulators
+        let mut total_lut_load_us: u64 = 0;
+        let mut total_notify_us: u64 = 0;
+        let mut total_transactions: u64 = 0;
+        let mut total_entries: u64 = 0;
+        let mut total_data_sets: u64 = 0;
+        let mut lut_transactions: u64 = 0;
+
+        let handle_completed_data_set_info = |completed_data_set_info: CompletedDataSetInfo,
+                                               total_lut_load_us: &mut u64,
+                                               total_notify_us: &mut u64,
+                                               total_transactions: &mut u64,
+                                               total_entries: &mut u64,
+                                               total_data_sets: &mut u64,
+                                               lut_transactions: &mut u64| {
             let CompletedDataSetInfo { slot, indices } = completed_data_set_info;
             match blockstore.get_entries_in_data_block(slot, indices, /*slot_meta:*/ None) {
                 Ok(entries) => {
+                    *total_data_sets += 1;
+                    *total_entries += entries.len() as u64;
+
                     // Notify deshred transactions if notifier is enabled
                     if let Some(notifier) = deshred_transaction_notifier {
                         for entry in entries.iter() {
                             for tx in &entry.transactions {
                                 if let Some(signature) = tx.signatures.first() {
+                                    *total_transactions += 1;
                                     let is_vote = is_simple_vote_transaction(tx);
+
+                                    // Measure LUT loading time
+                                    let mut lut_measure = Measure::start("load_lut");
+                                    let loaded_addresses = root_bank
+                                        .as_ref()
+                                        .and_then(|bank| load_transaction_addresses(tx, bank));
+                                    lut_measure.stop();
+
+                                    if loaded_addresses.is_some() {
+                                        *lut_transactions += 1;
+                                        *total_lut_load_us += lut_measure.as_us();
+                                    }
+
+                                    // Measure notification time
+                                    let mut notify_measure = Measure::start("notify_deshred");
                                     notifier.notify_deshred_transaction(
-                                        slot, signature, is_vote, tx,
+                                        slot,
+                                        signature,
+                                        is_vote,
+                                        tx,
+                                        loaded_addresses.as_ref(),
                                     );
+                                    notify_measure.stop();
+                                    *total_notify_us += notify_measure.as_us();
                                 }
                             }
                         }
@@ -118,15 +199,49 @@ impl CompletedDataSetsService {
             }
             slot
         };
+
         let slots = completed_sets_receiver
             .recv_timeout(RECV_TIMEOUT)
             .map(std::iter::once)?
             .chain(completed_sets_receiver.try_iter())
             .flatten()
-            .map(handle_completed_data_set_info);
+            .map(|info| {
+                handle_completed_data_set_info(
+                    info,
+                    &mut total_lut_load_us,
+                    &mut total_notify_us,
+                    &mut total_transactions,
+                    &mut total_entries,
+                    &mut total_data_sets,
+                    &mut lut_transactions,
+                )
+            });
+
         if let Some(slot) = slots.max() {
             max_slots.shred_insert.fetch_max(slot, Ordering::Relaxed);
         }
+
+        batch_measure.stop();
+
+        // Report metrics if we processed any transactions
+        if total_transactions > 0 {
+            datapoint_info!(
+                "deshred_geyser_timing",
+                ("batch_total_us", batch_measure.as_us() as i64, i64),
+                ("notify_total_us", total_notify_us as i64, i64),
+                ("lut_load_total_us", total_lut_load_us as i64, i64),
+                ("transactions_count", total_transactions as i64, i64),
+                ("lut_transactions_count", lut_transactions as i64, i64),
+                ("entries_count", total_entries as i64, i64),
+                ("data_sets_count", total_data_sets as i64, i64),
+                (
+                    "avg_notify_us",
+                    (total_notify_us / total_transactions) as i64,
+                    i64
+                ),
+            );
+        }
+
         Ok(())
     }
 
diff --git a/core/src/validator.rs b/core/src/validator.rs
@@ -1313,6 +1313,7 @@ impl Validator {
                         deshred_transaction_notifier.clone(),
                         exit.clone(),
                         max_slots.clone(),
+                        bank_forks.clone(),
                     );
                     (
                         Some(completed_data_sets_sender),
diff --git a/geyser-plugin-interface/Cargo.toml b/geyser-plugin-interface/Cargo.toml
@@ -19,6 +19,7 @@ agave-unstable-api = []
 log = { workspace = true, features = ["std"] }
 solana-clock = { workspace = true }
 solana-hash = { workspace = true }
+solana-message = { workspace = true }
 solana-signature = { workspace = true }
 solana-transaction = { workspace = true }
 solana-transaction-status = { workspace = true }
diff --git a/geyser-plugin-interface/src/geyser_plugin_interface.rs b/geyser-plugin-interface/src/geyser_plugin_interface.rs
@@ -5,6 +5,7 @@
 use {
     solana_clock::{Slot, UnixTimestamp},
     solana_hash::Hash,
+    solana_message::v0::LoadedAddresses,
     solana_signature::Signature,
     solana_transaction::{sanitized::SanitizedTransaction, versioned::VersionedTransaction},
     solana_transaction_status::{Reward, RewardsAndNumPartitions, TransactionStatusMeta},
@@ -206,6 +207,10 @@ pub struct ReplicaDeshredTransactionInfo<'a> {
 
     /// The versioned transaction.
     pub transaction: &'a VersionedTransaction,
+
+    /// Addresses loaded from address lookup tables for V0 transactions.
+    /// This is None for legacy transactions or if address resolution failed.
+    pub loaded_addresses: Option<&'a LoadedAddresses>,
 }
 
 /// A wrapper to future-proof ReplicaDeshredTransactionInfo handling.
diff --git a/geyser-plugin-manager/Cargo.toml b/geyser-plugin-manager/Cargo.toml
@@ -31,6 +31,7 @@ solana-entry = { workspace = true }
 solana-hash = { workspace = true }
 solana-ledger = { workspace = true }
 solana-measure = { workspace = true }
+solana-message = { workspace = true }
 solana-metrics = { workspace = true }
 solana-pubkey = { workspace = true }
 solana-rpc = { workspace = true }
diff --git a/geyser-plugin-manager/src/deshred_transaction_notifier.rs b/geyser-plugin-manager/src/deshred_transaction_notifier.rs
@@ -8,6 +8,7 @@ use {
     solana_clock::Slot,
     solana_ledger::deshred_transaction_notifier_interface::DeshredTransactionNotifier,
     solana_measure::measure::Measure,
+    solana_message::v0::LoadedAddresses,
     solana_metrics::*,
     solana_signature::Signature,
     solana_transaction::versioned::VersionedTransaction,
@@ -30,13 +31,15 @@ impl DeshredTransactionNotifier for DeshredTransactionNotifierImpl {
         signature: &Signature,
         is_vote: bool,
         transaction: &VersionedTransaction,
+        loaded_addresses: Option<&LoadedAddresses>,
     ) {
         let mut measure =
             Measure::start("geyser-plugin-notify_plugins_of_deshred_transaction_info");
         let transaction_info = Self::build_replica_deshred_transaction_info(
             signature,
             is_vote,
             transaction,
+            loaded_addresses,
         );
 
         let plugin_manager = self.plugin_manager.read().unwrap();
@@ -87,11 +90,13 @@ impl DeshredTransactionNotifierImpl {
         signature: &'a Signature,
         is_vote: bool,
         transaction: &'a VersionedTransaction,
+        loaded_addresses: Option<&'a LoadedAddresses>,
     ) -> ReplicaDeshredTransactionInfo<'a> {
         ReplicaDeshredTransactionInfo {
             signature,
             is_vote,
             transaction,
+            loaded_addresses,
         }
     }
 }
diff --git a/ledger/src/deshred_transaction_notifier_interface.rs b/ledger/src/deshred_transaction_notifier_interface.rs
@@ -1,5 +1,6 @@
 use {
     solana_clock::Slot,
+    solana_message::v0::LoadedAddresses,
     solana_signature::Signature,
     solana_transaction::versioned::VersionedTransaction,
     std::sync::Arc,
@@ -14,6 +15,7 @@ pub trait DeshredTransactionNotifier {
         signature: &Signature,
         is_vote: bool,
         transaction: &VersionedTransaction,
+        loaded_addresses: Option<&LoadedAddresses>,
     );
 }
 

Original file line number	Diff line number	Diff line change
`@@ -1313,6 +1313,7 @@ impl Validator {`
`1313`	`1313`	`deshred_transaction_notifier.clone(),`
`1314`	`1314`	`exit.clone(),`
`1315`	`1315`	`max_slots.clone(),`
	`1316`	`+ bank_forks.clone(),`
`1316`	`1317`	`);`
`1317`	`1318`	`(`
`1318`	`1319`	`Some(completed_data_sets_sender),`