Jito Bell: Copy Directed Stake Targets (#143)

aoikurokawa · web-flow · commit 323e68fb5591 · 2025-12-27T09:40:49.000+09:00
* fix: update

* fix: test

* fix: review
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -13,6 +13,7 @@ defillama-rs = "0.1.1"
 dotenvy = { version = "0.15.7" }
 env_logger = "0.11.3"
 futures = "0.3.24"
+hex = "0.4"
 hmac = "0.12"
 jito-vault-client = "0.0.5"
 jito-vault-sdk = "0.0.5"
diff --git a/jito-bell/Cargo.toml b/jito-bell/Cargo.toml
@@ -48,3 +48,6 @@ tracing-subscriber = { workspace = true }
 twitterust = { workspace = true }
 yellowstone-grpc-client = { workspace = true }
 yellowstone-grpc-proto = { workspace = true }
+
+[dev-dependencies]
+hex = { workspace = true }
diff --git a/jito-bell/src/ix_parser/jito_steward.rs b/jito-bell/src/ix_parser/jito_steward.rs
@@ -1,6 +1,9 @@
 use std::str::FromStr;
 
 use solana_pubkey::Pubkey;
+use solana_sdk::instruction::{AccountMeta, Instruction};
+
+use crate::ix_parser::instruction::ParsableInstruction;
 
 /// Jito Steward Instructions
 #[derive(Debug, PartialEq)]
@@ -36,6 +39,12 @@ pub enum JitoStewardInstruction {
     IncreaseAdditionalValidatorStake,
     DecreaseAdditionalValidatorStake,
     UpdatePriorityFeeParameters,
+    CopyDirectedStakeTargets {
+        ix: Instruction,
+        vote_pubkey: Pubkey,
+        total_target_lamports: u64,
+        validator_list_index: u32,
+    },
 }
 
 impl std::fmt::Display for JitoStewardInstruction {
@@ -88,6 +97,14 @@ impl std::fmt::Display for JitoStewardInstruction {
             JitoStewardInstruction::UpdatePriorityFeeParameters => {
                 write!(f, "update_priority_fee_parameters")
             }
+            JitoStewardInstruction::CopyDirectedStakeTargets {
+                ix: _,
+                vote_pubkey: _,
+                total_target_lamports: _,
+                validator_list_index: _,
+            } => {
+                write!(f, "copy_directed_stake_targets")
+            }
         }
     }
 }
@@ -97,4 +114,120 @@ impl JitoStewardInstruction {
     pub fn program_id() -> Pubkey {
         Pubkey::from_str("Stewardf95sJbmtcZsyagb2dg4Mo8eVQho8gpECvLx8").unwrap()
     }
+
+    /// Parse Jito Steward instruction
+    pub fn parse<T: ParsableInstruction>(
+        instruction: &T,
+        account_keys: &[Pubkey],
+    ) -> Option<JitoStewardInstruction> {
+        let instruction_data = instruction.data();
+        match instruction_data[0..8] {
+            [135, 132, 9, 127, 189, 161, 14, 5] => {
+                let vote_pubkey = {
+                    let mut pubkey_array = [0; 32];
+                    pubkey_array.copy_from_slice(&instruction_data[8..40]);
+                    Pubkey::new_from_array(pubkey_array)
+                };
+
+                let total_target_lamports = {
+                    let mut slice = [0; 8];
+                    slice.copy_from_slice(&instruction_data[40..48]);
+                    u64::from_le_bytes(slice)
+                };
+
+                let validator_list_index = {
+                    let mut slice = [0; 4];
+                    slice.copy_from_slice(&instruction_data[48..52]);
+                    u32::from_le_bytes(slice)
+                };
+
+                Some(Self::parse_copy_directed_stake_targets_ix(
+                    instruction,
+                    account_keys,
+                    vote_pubkey,
+                    total_target_lamports,
+                    validator_list_index,
+                ))
+            }
+            _ => None,
+        }
+    }
+
+    /// #[account(0, name = "config")]
+    /// #[account(1, writable, name = "directed_stake_meta")]
+    /// #[account(2, name = "clock")]
+    /// #[account(3, writable, name = "validator_list")]
+    /// #[account(4, writable, signer, name = "authority")]
+    pub fn parse_copy_directed_stake_targets_ix<T: ParsableInstruction>(
+        instruction: &T,
+        account_keys: &[Pubkey],
+        vote_pubkey: Pubkey,
+        total_target_lamports: u64,
+        validator_list_index: u32,
+    ) -> Self {
+        let mut account_metas = [
+            AccountMeta::new(Pubkey::new_unique(), false),
+            AccountMeta::new(Pubkey::new_unique(), false),
+            AccountMeta::new(Pubkey::new_unique(), false),
+            AccountMeta::new(Pubkey::new_unique(), false),
+            AccountMeta::new_readonly(Pubkey::new_unique(), true),
+        ];
+
+        for (index, account) in instruction.accounts().iter().enumerate() {
+            if let Some(account_meta) = account_metas.get_mut(index) {
+                if let Some(account) = account_keys.get(*account as usize) {
+                    account_meta.pubkey = *account;
+                }
+            }
+        }
+
+        let ix = Instruction {
+            program_id: Self::program_id(),
+            accounts: account_metas.to_vec(),
+            data: instruction.data().to_vec(),
+        };
+
+        Self::CopyDirectedStakeTargets {
+            ix,
+            vote_pubkey,
+            total_target_lamports,
+            validator_list_index,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use yellowstone_grpc_proto::prelude::CompiledInstruction;
+
+    use crate::ix_parser::jito_steward::JitoStewardInstruction;
+
+    #[test]
+    fn test_parse_copy_directed_stake_targets() {
+        let instruction = {
+            let data =
+             hex::decode(
+                 "8784097fbda10e054613d432f5da8f600ac38dcd8f5c07df361f5b832400b012604624443b3f457000000000000000006e000000"
+             ).unwrap();
+            CompiledInstruction {
+                program_id_index: 0,
+                accounts: vec![0],
+                data,
+            }
+        };
+
+        let account_keys = vec![];
+        let jito_steward_instruction =
+            JitoStewardInstruction::parse(&instruction, &account_keys).unwrap();
+
+        match jito_steward_instruction {
+            JitoStewardInstruction::CopyDirectedStakeTargets {
+                ix: _,
+                vote_pubkey: _,
+                total_target_lamports: _,
+                validator_list_index: _,
+            } => {}
+            _ => panic!("Wrong instruction"),
+        }
+    }
 }
diff --git a/jito-bell/src/lib.rs b/jito-bell/src/lib.rs
@@ -36,7 +36,7 @@ use yellowstone_grpc_proto::{
 use crate::{
     config::JitoBellConfig,
     event_parser::{jito_steward::JitoStewardEvent, EventParser},
-    ix_parser::InstructionParser,
+    ix_parser::{jito_steward::JitoStewardInstruction, InstructionParser},
     notification_info::Destination,
     program::{EventConfig, Instruction, ProgramName},
     tx_parser::JitoTransactionParser,
@@ -274,7 +274,31 @@ impl JitoBellHandler {
                             .await?;
                     }
                 }
-                InstructionParser::JitoSteward(_) => {}
+                InstructionParser::JitoSteward(jito_steward_instruction) => {
+                    debug!("Jito Steward");
+
+                    let jito_steward_program_str = jito_steward_instruction.to_string();
+
+                    let instruction_opt = self
+                        .config
+                        .programs
+                        .get(&ProgramName::JitoSteward)
+                        .and_then(|program_config| {
+                            program_config
+                                .instructions
+                                .get(&jito_steward_program_str)
+                                .cloned()
+                        });
+
+                    if let Some(instruction) = instruction_opt {
+                        self.handle_jito_steward_program(
+                            parser,
+                            jito_steward_instruction,
+                            &instruction,
+                        )
+                        .await?;
+                    }
+                }
             }
         }
 
@@ -856,6 +880,38 @@ impl JitoBellHandler {
         Ok(())
     }
 
+    /// Sends a notification for each matching `CopyDirectedStakeTargets` instruction
+    /// that includes notification metadata.
+    async fn handle_jito_steward_program(
+        &mut self,
+        parser: &JitoTransactionParser,
+        jito_steward_instruction: &JitoStewardInstruction,
+        instruction: &Instruction,
+    ) -> Result<(), JitoBellError> {
+        debug!("Jito Steward Instruction: {jito_steward_instruction}");
+
+        if let JitoStewardInstruction::CopyDirectedStakeTargets {
+            ix: _,
+            vote_pubkey: _,
+            total_target_lamports,
+            validator_list_index: _,
+        } = jito_steward_instruction
+        {
+            if let Some(ref notification_info) = instruction.notification_info {
+                self.dispatch_platform_notifications(
+                    &notification_info.destinations,
+                    &notification_info.description,
+                    Some(*total_target_lamports as f64),
+                    Some("lamports"),
+                    &parser.transaction_signature,
+                )
+                .await?;
+            }
+        }
+
+        Ok(())
+    }
+
     /// Dispatch platform notifications
     ///
     /// - Return error only if ALL platforms failed, or handle as needed
diff --git a/jito-bell/src/program.rs b/jito-bell/src/program.rs
@@ -3,7 +3,7 @@ use std::collections::HashMap;
 use serde::Deserialize;
 
 use crate::{
-    notification_info::Destination,
+    notification_info::{Destination, NotificationInfo},
     threshold_config::{ThresholdConfig, UsdThresholdConfig},
 };
 
@@ -51,6 +51,9 @@ pub struct Instruction {
 
     /// Vault receipt token (VRT)
     pub vrts: Option<HashMap<String, AlertConfig>>,
+
+    /// Notification info
+    pub notification_info: Option<NotificationInfo>,
 }
 
 #[derive(Debug, Clone, Deserialize)]
diff --git a/jito-bell/src/tx_parser.rs b/jito-bell/src/tx_parser.rs
@@ -102,6 +102,13 @@ impl JitoTransactionParser {
                                             if program_id
                                                 .eq(&JitoStewardInstruction::program_id()) =>
                                         {
+                                            if let Some(ix_info) =
+                                                JitoStewardInstruction::parse(instruction, &pubkeys)
+                                            {
+                                                parsed_instructions
+                                                    .push(InstructionParser::JitoSteward(ix_info));
+                                            }
+
                                             for log in &meta.log_messages {
                                                 if let Some(event) =
                                                     JitoStewardEvent::parse_log(log)
diff --git a/jito_bell_config_sample.yaml b/jito_bell_config_sample.yaml
@@ -1,6 +1,11 @@
 programs:
   jito_steward:
     program_id: "Stewardf95sJbmtcZsyagb2dg4Mo8eVQho8gpECvLx8"
+    instructions:
+      notification_info:
+        copy_directed_stake_targets:
+          description: "Copy directed stake targets detected"
+          destinations: ["stakenet_event_alerts_slack"]
     events:
       auto_remove_validator:
         destinations: ["stake_pool_alerts_slack"]
