add get_vote_signatures

anoushk1234 · anoushk1234 · commit 501e24585b3c · 2024-03-29T12:24:18.000Z
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/keypair.json b/keypair.json
@@ -0,0 +1 @@
+[217,4,91,191,84,247,101,66,202,150,225,0,142,220,120,194,8,157,138,212,166,243,178,233,172,92,206,166,89,157,235,27,149,165,102,148,110,132,67,250,69,254,91,119,181,12,209,45,152,207,172,206,95,33,203,151,118,248,222,6,32,66,62,217]
diff --git a/rpc-client-api/src/config.rs b/rpc-client-api/src/config.rs
@@ -6,6 +6,7 @@ use {
         commitment_config::{CommitmentConfig, CommitmentLevel},
     },
     solana_transaction_status::{TransactionDetails, UiTransactionEncoding},
+    std::collections::HashSet,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
@@ -90,6 +91,14 @@ pub struct RpcGetVoteAccountsConfig {
     pub delinquent_slot_distance: Option<u64>,
 }
 
+#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RpcGetVoteSignaturesConfig {
+    pub vote_pubkey: Option<HashSet<String>>, // validator vote address, as a base-58 encoded string
+    #[serde(flatten)]
+    pub commitment: Option<CommitmentConfig>,
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(untagged)]
 pub enum RpcLeaderScheduleConfigWrapper {
diff --git a/rpc-client-api/src/request.rs b/rpc-client-api/src/request.rs
@@ -107,6 +107,7 @@ pub enum RpcRequest {
     GetTransactionCount,
     GetVersion,
     GetVoteAccounts,
+    GetVoteSignatures,
     IsBlockhashValid,
     MinimumLedgerSlot,
     RegisterNode,
@@ -183,6 +184,7 @@ impl fmt::Display for RpcRequest {
             RpcRequest::GetTransactionCount => "getTransactionCount",
             RpcRequest::GetVersion => "getVersion",
             RpcRequest::GetVoteAccounts => "getVoteAccounts",
+            RpcRequest::GetVoteSignatures => "getVoteSignatures",
             RpcRequest::IsBlockhashValid => "isBlockhashValid",
             RpcRequest::MinimumLedgerSlot => "minimumLedgerSlot",
             RpcRequest::RegisterNode => "registerNode",
diff --git a/rpc-client/src/nonblocking/rpc_client.rs b/rpc-client/src/nonblocking/rpc_client.rs
@@ -12,6 +12,7 @@ use solana_rpc_client_api::deprecated_config::{
     RpcConfirmedBlockConfig, RpcConfirmedTransactionConfig,
     RpcGetConfirmedSignaturesForAddress2Config,
 };
+use solana_transaction_status::VoteSignatures;
 #[cfg(feature = "spinner")]
 use {crate::spinner, solana_sdk::clock::MAX_HASH_AGE_IN_SECONDS, std::cmp::min};
 use {
@@ -2487,6 +2488,20 @@ impl RpcClient {
             .await
     }
 
+    pub async fn get_vote_signatures(
+        &self,
+        slot: Slot,
+        encoding: UiTransactionEncoding,
+        config: RpcGetVoteSignaturesConfig,
+    ) -> ClientResult<VoteSignatures> {
+        self.send(
+            self.maybe_map_request(RpcRequest::GetVoteSignatures)
+                .await?,
+            json!([slot, encoding, config]),
+        )
+        .await
+    }
+
     /// Returns identity and transaction information about a confirmed block in the ledger.
     ///
     /// # RPC Reference
@@ -2854,6 +2869,7 @@ impl RpcClient {
         )
         .await
     }
+    
 
     #[deprecated(since = "1.7.0", note = "Please use RpcClient::get_blocks() instead")]
     #[allow(deprecated)]
diff --git a/rpc-client/src/rpc_client.rs b/rpc-client/src/rpc_client.rs
@@ -48,6 +48,7 @@ use {
         transaction::{self, uses_durable_nonce, Transaction, VersionedTransaction},
     },
     solana_transaction_status::{
+        VoteSignatures,
         EncodedConfirmedBlock, EncodedConfirmedTransactionWithStatusMeta, TransactionStatus,
         UiConfirmedBlock, UiTransactionEncoding,
     },
@@ -2120,7 +2121,17 @@ impl RpcClient {
     ) -> ClientResult<UiConfirmedBlock> {
         self.invoke((self.rpc_client.as_ref()).get_block_with_config(slot, config))
     }
-
+    pub fn get_vote_signatures(
+            &self,
+            slot: Slot,
+            config: RpcGetVoteSignaturesConfig,
+        ) -> ClientResult<VoteSignatures> {
+            self.invoke((self.rpc_client.as_ref()).get_vote_signatures(
+                slot,
+                UiTransactionEncoding::Json,
+                config,
+            ))
+    }
     #[deprecated(since = "1.7.0", note = "Please use RpcClient::get_block() instead")]
     #[allow(deprecated)]
     pub fn get_confirmed_block(&self, slot: Slot) -> ClientResult<EncodedConfirmedBlock> {
diff --git a/rpc.sh b/rpc.sh
@@ -0,0 +1,44 @@
+
+#! /bin/bash
+MG=5eykt4UsFv8P8NJdTREpY1vzqKqZKvdpKuc147dw2N9d
+TG=4uhcVJyU9pJkvQyS88uRDiswHXSCkY3zQawwpjk2NsNY
+# valgrind --leak-check=full --main-stacksize=10000000 --num-callers=500 
+
+exec target/release/solana-validator \
+--identity keypair.json \
+--entrypoint entrypoint.testnet.solana.com:8001 \
+--entrypoint entrypoint2.testnet.solana.com:8001 \
+--entrypoint entrypoint3.testnet.solana.com:8001 \
+--rpc-port 8899 \
+--dynamic-port-range 8002-8099 \
+--gossip-port 8001 \
+--no-voting \
+--private-rpc \
+--rpc-bind-address 0.0.0.0 \
+--enable-cpi-and-log-storage \
+--enable-rpc-transaction-history \
+--wal-recovery-mode skip_any_corrupted_record \
+--log /mnt/ssd1/validator.log \
+--accounts /mnt/ssd1/accounts \
+--ledger /mnt/ssd1/ledger \
+--snapshots /mnt/ssd1/snapshots \
+--limit-ledger-size 400000000 \
+--rpc-send-default-max-retries 3 \
+--rpc-send-service-max-retries 3 \
+--rpc-send-retry-ms 2000 \
+--full-rpc-api \
+--accounts-index-memory-limit-mb 250 \
+--no-poh-speed-test \
+--only-known-rpc \
+--accountsdb-plugin-config /root/solana-proofs/config.json \
+--known-validator 5D1fNXzvv5NjV1ysLjirC4WY92RNsVH18vjmcszZd8on \
+--known-validator eoKpUABi59aT4rR9HGS3LcMecfut9x7zJyodWWP43YQ \
+--known-validator nqkFSApiR4mTENxvmQwsNy9hXF2MGb6NqCA4Epmp7AH \
+--expected-genesis-hash $TG 
+
+
+
+# --no-genesis-fetch \
+# --entrypoint entrypoint.testnet.solana.com:8001 \
+# --entrypoint entrypoint2.testnet.solana.com:8001 \
+# --entrypoint entrypoint3.testnet.solana.com:8001 \
diff --git a/rpc/Cargo.toml b/rpc/Cargo.toml
@@ -38,6 +38,7 @@ solana-gossip = { workspace = true }
 solana-ledger = { workspace = true }
 solana-measure = { workspace = true }
 solana-metrics = { workspace = true }
+solana-program = { workshpace = true }
 solana-perf = { workspace = true }
 solana-poh = { workspace = true }
 solana-rayon-threadlimit = { workspace = true }
diff --git a/rpc/src/rpc.rs b/rpc/src/rpc.rs
@@ -19,6 +19,7 @@ use {
         inline_spl_token::{SPL_TOKEN_ACCOUNT_MINT_OFFSET, SPL_TOKEN_ACCOUNT_OWNER_OFFSET},
         inline_spl_token_2022::{self, ACCOUNTTYPE_ACCOUNT},
     },
+    solana_program::{instruction::CompiledInstruction, message::Message},
     solana_client::connection_cache::{ConnectionCache, Protocol},
     solana_entry::entry::Entry,
     solana_faucet::faucet::request_airdrop_transaction,
@@ -87,7 +88,8 @@ use {
     solana_storage_bigtable::Error as StorageError,
     solana_streamer::socket::SocketAddrSpace,
     solana_transaction_status::{
-        map_inner_instructions, BlockEncodingOptions, ConfirmedBlock,
+    EncodedTransaction, TransactionDetails, VoteSignatures,
+    map_inner_instructions, BlockEncodingOptions, ConfirmedBlock,
         ConfirmedTransactionStatusWithSignature, ConfirmedTransactionWithStatusMeta,
         EncodedConfirmedTransactionWithStatusMeta, Reward, RewardType, TransactionBinaryEncoding,
         TransactionConfirmationStatus, TransactionStatus, UiConfirmedBlock, UiTransactionEncoding,
@@ -1348,7 +1350,106 @@ impl JsonRpcRequestProcessor {
             }
         }
     }
-
+      pub async fn get_vote_signatures(
+        &self,
+        slot: Slot,
+        config: Option<RpcGetVoteSignaturesConfig>,
+    ) -> Result<VoteSignatures> {
+        const VOTE_PROGRAM_ID: &str = "Vote111111111111111111111111111111111111111";
+
+        // manually constructing config for `getBlock`
+        let cfg = Some(RpcEncodingConfigWrapper::Current(Some(RpcBlockConfig {
+            encoding: Some(UiTransactionEncoding::Json),
+            transaction_details: Some(TransactionDetails::Full),
+            rewards: None,
+            commitment: Some(CommitmentConfig {
+                commitment: CommitmentLevel::Confirmed,
+            }),
+            max_supported_transaction_version: Some(0),
+        })));
+
+        let block = self.get_block(slot, cfg).await;
+        let mut vote_signatures: VoteSignatures = VoteSignatures::default();
+
+        // info!("harsh | txn {:?}", block.clone.unwrap().unwrap().transactions.unwrap().len());
+        for outer_txn in block.unwrap().unwrap().transactions.unwrap() {
+            if let EncodedTransaction::Json(inner_txn) = outer_txn.transaction  {
+                    match inner_txn.message {
+                        solana_transaction_status::UiMessage::Raw(message) => {
+                            let aks: HashSet<String> = message
+                                .account_keys
+                                .clone()
+                                .into_iter()
+                                .map(|key| key)
+                                .collect();
+                            
+                            let mut compiled_instruction: Vec<CompiledInstruction> = vec![];
+                            let mut account_keys: Vec<Pubkey> = vec![];
+
+                            let messagec = message.clone();
+                            for ui_ix in messagec.instructions{
+                                compiled_instruction.push(
+                                    CompiledInstruction { program_id_index: ui_ix.program_id_index, accounts: ui_ix.accounts, data: bs58::decode( ui_ix.data).into_vec().unwrap() }
+                                );
+                            }
+                            for key in messagec.account_keys{
+                                account_keys.push(
+                                    Pubkey::from_str(&key).unwrap()
+                                );
+                            }
+                           let vote_message = Message{
+                               header: messagec.header,
+                               account_keys,
+                               recent_blockhash: Hash::from_str(&messagec.recent_blockhash).unwrap(),
+                               instructions: compiled_instruction
+                           };
+                           let vote_message = vote_message.serialize();
+                            let validator_identity =
+                                message.account_keys.get(0).unwrap();
+
+                            if let Some(c) = config.clone() {
+                                match c.vote_pubkey {
+                                    Some(p) => {
+                                        if aks.contains(&VOTE_PROGRAM_ID.to_string())
+                                            // p == validator_identity // for a single validator identity check
+                                            && p.contains(validator_identity.as_str()) 
+                                        {
+                                            let vote_signature =
+                                                Some(inner_txn.signatures[0].clone());
+                                            vote_signatures.vote_signature.push(vote_signature);
+                                            let vote_message = Some(vote_message);
+                                            vote_signatures.vote_messages.push(vote_message);
+                                        }
+                                            // } else if aks.contains(&VOTE_PROGRAM_ID.to_string()) {
+                                        //     let vote_signature =
+                                        //         Some(inner_txn.signatures[0].clone());
+                                        //     vote_signatures.vote_signature.push(vote_signature);
+                                        //     let vote_message = Some(vote_message);
+                                        //     vote_signature.vote_messages.push(vote_message);
+                                        // }
+                                    }
+                                    // if there's no specified vote_pubkey in config, then collect all vote signatures
+                                    None => {
+                                        if aks.contains(&VOTE_PROGRAM_ID.to_string())
+                                        {
+                                            let vote_signature =
+                                                Some(inner_txn.signatures[0].clone());
+                                            vote_signatures.vote_signature.push(vote_signature);
+                                            let vote_message = Some(vote_message);
+                                            vote_signatures.vote_messages.push(vote_message);
+                                        }
+                                    }
+                                }
+                            };
+                        }
+                        _ => {
+                            error!("harsh | failing here {:?}", inner_txn.message);
+                        }
+                    }
+                }
+        }
+        Ok(vote_signatures)
+    }
     pub fn get_signature_confirmation_status(
         &self,
         signature: Signature,
@@ -3318,6 +3419,14 @@ pub mod rpc_full {
             config: Option<RpcEncodingConfigWrapper<RpcBlockConfig>>,
         ) -> BoxFuture<Result<Option<UiConfirmedBlock>>>;
 
+        #[rpc(meta, name = "getVoteSignatures")]
+        fn get_vote_signatures(
+            &self,
+            meta: Self::Metadata,
+            slot: Slot,
+            config: Option<RpcGetVoteSignaturesConfig>,
+        ) -> BoxFuture<Result<VoteSignatures>>;
+
         #[rpc(meta, name = "getBlockTime")]
         fn get_block_time(
             &self,
@@ -3431,6 +3540,16 @@ pub mod rpc_full {
                 .collect())
         }
 
+        fn get_vote_signatures(
+            &self,
+            meta: Self::Metadata,
+            slot: Slot,
+            config: Option<RpcGetVoteSignaturesConfig>,
+        ) -> BoxFuture<Result<VoteSignatures>> {
+            debug!("get_block_headers rpc request received: {:?}", slot);
+            Box::pin(async move { meta.get_vote_signatures(slot, config).await })
+        }
+        
         fn get_cluster_nodes(&self, meta: Self::Metadata) -> Result<Vec<RpcContactInfo>> {
             debug!("get_cluster_nodes rpc request received");
             let cluster_info = &meta.cluster_info;
@@ -4258,7 +4377,15 @@ pub mod rpc_deprecated_v1_7 {
                     .await
             })
         }
-
+        // fn get_vote_signatures(
+        //     &self,
+        //     meta: Self::Metadata,
+        //     slot: Slot,
+        //     config: Option<RpcGetVoteSignaturesConfig>,
+        // ) -> BoxFuture<Result<VoteSignatures>> {
+        //     debug!("get_block_headers rpc request received: {:?}", slot);
+        //     Box::pin(async move { meta.get_vote_signatures(slot, config).await })
+        // }
         fn get_confirmed_blocks(
             &self,
             meta: Self::Metadata,
diff --git a/transaction-status/src/lib.rs b/transaction-status/src/lib.rs
@@ -644,6 +644,13 @@ pub struct ConfirmedBlock {
     pub block_height: Option<u64>,
 }
 
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct VoteSignatures {
+    pub vote_signature: Vec<Option<String>>,
+    pub vote_messages: Vec<Option<Vec<u8>>>,
+}
+
 // Confirmed block with type guarantees that transaction metadata
 // is always present. Used for uploading to BigTable.
 #[derive(Clone, Debug, PartialEq)]

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+[217,4,91,191,84,247,101,66,202,150,225,0,142,220,120,194,8,157,138,212,166,243,178,233,172,92,206,166,89,157,235,27,149,165,102,148,110,132,67,250,69,254,91,119,181,12,209,45,152,207,172,206,95,33,203,151,118,248,222,6,32,66,62,217]`