More types (#5846)

automerge

programs/vote_api/src/vote_state.rs

@@ -5,6 +5,7 @@ use bincode::{deserialize, serialize_into, serialized_size, ErrorKind};
 use log::*;
 use num_derive::{FromPrimitive, ToPrimitive};
 use serde_derive::{Deserialize, Serialize};
+use solana_sdk::sysvar::slot_hashes::SlotHash;
 use solana_sdk::{
     account::{Account, KeyedAccount},
     account_utils::State,
@@ -231,7 +232,7 @@ impl VoteState {
     pub fn process_vote(
         &mut self,
         vote: &Vote,
-        slot_hashes: &[(Slot, Hash)],
+        slot_hashes: &[SlotHash],
         epoch: Epoch,
     ) -> Result<(), VoteError> {
         if vote.slots.is_empty() {
@@ -407,7 +408,7 @@ pub fn initialize_account(
 
 pub fn process_vote(
     vote_account: &mut KeyedAccount,
-    slot_hashes: &[(Slot, Hash)],
+    slot_hashes: &[SlotHash],
     clock: &Clock,
     other_signers: &[KeyedAccount],
     vote: &Vote,
@@ -487,7 +488,7 @@ mod tests {
         vote_pubkey: &Pubkey,
         vote_account: &mut Account,
         vote: &Vote,
-        slot_hashes: &[(u64, Hash)],
+        slot_hashes: &[SlotHash],
         epoch: u64,
     ) -> Result<VoteState, InstructionError> {
         process_vote(

runtime/src/accounts.rs

@@ -52,6 +52,13 @@ pub type TransactionCredits = Vec<u64>;
 pub type TransactionRents = Vec<u64>;
 pub type TransactionLoaders = Vec<Vec<(Pubkey, Account)>>;
 
+pub type TransactionLoadResult = (
+    TransactionAccounts,
+    TransactionLoaders,
+    TransactionCredits,
+    TransactionRents,
+);
+
 impl Accounts {
     pub fn new(paths: Option<String>) -> Self {
         let accounts_db = Arc::new(AccountsDB::new(paths));
@@ -217,14 +224,7 @@ impl Accounts {
         hash_queue: &BlockhashQueue,
         error_counters: &mut ErrorCounters,
         rent_collector: &RentCollector,
-    ) -> Vec<
-        Result<(
-            TransactionAccounts,
-            TransactionLoaders,
-            TransactionCredits,
-            TransactionRents,
-        )>,
-    > {
+    ) -> Vec<Result<TransactionLoadResult>> {
         //PERF: hold the lock to scan for the references, but not to clone the accounts
         //TODO: two locks usually leads to deadlocks, should this be one structure?
         let accounts_index = self.accounts_db.accounts_index.read().unwrap();
@@ -529,12 +529,7 @@ impl Accounts {
         txs: &[Transaction],
         txs_iteration_order: Option<&[usize]>,
         res: &[Result<()>],
-        loaded: &mut [Result<(
-            TransactionAccounts,
-            TransactionLoaders,
-            TransactionCredits,
-            TransactionRents,
-        )>],
+        loaded: &mut [Result<TransactionLoadResult>],
     ) {
         let accounts_to_store =
             self.collect_accounts_to_store(txs, txs_iteration_order, res, loaded);
@@ -611,12 +606,7 @@ impl Accounts {
         txs: &'a [Transaction],
         txs_iteration_order: Option<&'a [usize]>,
         res: &'a [Result<()>],
-        loaded: &'a mut [Result<(
-            TransactionAccounts,
-            TransactionLoaders,
-            TransactionCredits,
-            TransactionRents,
-        )>],
+        loaded: &'a mut [Result<TransactionLoadResult>],
     ) -> Vec<(&'a Pubkey, &'a Account)> {
         let mut accounts = Vec::new();
         for (i, (raccs, tx)) in loaded
@@ -693,14 +683,7 @@ mod tests {
         ka: &Vec<(Pubkey, Account)>,
         fee_calculator: &FeeCalculator,
         error_counters: &mut ErrorCounters,
-    ) -> Vec<
-        Result<(
-            TransactionAccounts,
-            TransactionLoaders,
-            TransactionCredits,
-            TransactionRents,
-        )>,
-    > {
+    ) -> Vec<Result<TransactionLoadResult>> {
         let mut hash_queue = BlockhashQueue::new(100);
         hash_queue.register_hash(&tx.message().recent_blockhash, &fee_calculator);
         let accounts = Accounts::new(None);
@@ -726,14 +709,7 @@ mod tests {
         tx: Transaction,
         ka: &Vec<(Pubkey, Account)>,
         error_counters: &mut ErrorCounters,
-    ) -> Vec<
-        Result<(
-            TransactionAccounts,
-            TransactionLoaders,
-            TransactionCredits,
-            TransactionRents,
-        )>,
-    > {
+    ) -> Vec<Result<TransactionLoadResult>> {
         let fee_calculator = FeeCalculator::default();
         load_accounts_with_fee(tx, ka, &fee_calculator, error_counters)
     }

runtime/src/bank.rs

@@ -4,9 +4,7 @@
 //! already been signed and verified.
 use crate::transaction_utils::OrderedIterator;
 use crate::{
-    accounts::{
-        Accounts, TransactionAccounts, TransactionCredits, TransactionLoaders, TransactionRents,
-    },
+    accounts::{Accounts, TransactionLoadResult},
     accounts_db::{AccountStorageEntry, AccountsDBSerialize, AppendVecId, ErrorCounters},
     accounts_index::Fork,
     blockhash_queue::BlockhashQueue,
@@ -797,14 +795,7 @@ impl Bank {
         txs_iteration_order: Option<&[usize]>,
         results: Vec<Result<()>>,
         error_counters: &mut ErrorCounters,
-    ) -> Vec<
-        Result<(
-            TransactionAccounts,
-            TransactionLoaders,
-            TransactionCredits,
-            TransactionRents,
-        )>,
-    > {
+    ) -> Vec<Result<TransactionLoadResult>> {
         self.rc.accounts.load_accounts(
             &self.ancestors,
             txs,
@@ -969,14 +960,7 @@ impl Bank {
         lock_results: &LockedAccountsResults,
         max_age: usize,
     ) -> (
-        Vec<
-            Result<(
-                TransactionAccounts,
-                TransactionLoaders,
-                TransactionCredits,
-                TransactionRents,
-            )>,
-        >,
+        Vec<Result<TransactionLoadResult>>,
         Vec<Result<()>>,
         Vec<usize>,
         usize,
@@ -1106,12 +1090,7 @@ impl Bank {
         &self,
         txs: &[Transaction],
         txs_iteration_order: Option<&[usize]>,
-        loaded_accounts: &mut [Result<(
-            TransactionAccounts,
-            TransactionLoaders,
-            TransactionCredits,
-            TransactionRents,
-        )>],
+        loaded_accounts: &mut [Result<TransactionLoadResult>],
         executed: &[Result<()>],
         tx_count: usize,
         signature_count: usize,
@@ -1391,12 +1370,7 @@ impl Bank {
         txs: &[Transaction],
         txs_iteration_order: Option<&[usize]>,
         res: &[Result<()>],
-        loaded: &[Result<(
-            TransactionAccounts,
-            TransactionLoaders,
-            TransactionCredits,
-            TransactionRents,
-        )>],
+        loaded: &[Result<TransactionLoadResult>],
     ) {
         for (i, (raccs, tx)) in loaded
             .iter()
@@ -1415,7 +1389,7 @@ impl Bank {
                     .account_keys
                     .iter()
                     .zip(acc.0.iter())
-                    .filter(|(_, account)| {
+                    .filter(|(_key, account)| {
                         (Stakes::is_stake(account)) || storage_utils::is_storage(account)
                     })
             {

sdk/src/sysvar/slot_hashes.rs

@@ -19,8 +19,10 @@ crate::solana_name_id!(ID, "SysvarS1otHashes111111111111111111111111111");
 
 pub const MAX_SLOT_HASHES: usize = 512; // 512 slots to get your vote in
 
+pub type SlotHash = (Slot, Hash);
+
 #[derive(Serialize, Deserialize, PartialEq, Debug)]
-pub struct SlotHashes(Vec<(Slot, Hash)>);
+pub struct SlotHashes(Vec<SlotHash>);
 
 impl SlotHashes {
     pub fn from(account: &Account) -> Option<Self> {
@@ -46,19 +48,19 @@ impl SlotHashes {
             .ok()
             .map(|index| &self[index].1)
     }
-    pub fn new(slot_hashes: &[(Slot, Hash)]) -> Self {
+    pub fn new(slot_hashes: &[SlotHash]) -> Self {
         Self(slot_hashes.to_vec())
     }
 }
 
 impl Deref for SlotHashes {
-    type Target = Vec<(u64, Hash)>;
+    type Target = Vec<SlotHash>;
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
 
-pub fn create_account(lamports: u64, slot_hashes: &[(Slot, Hash)]) -> Account {
+pub fn create_account(lamports: u64, slot_hashes: &[SlotHash]) -> Account {
     let mut account = Account::new(lamports, SlotHashes::size_of(), &sysvar::id());
     SlotHashes::new(slot_hashes).to(&mut account).unwrap();
     account