Merge branch 'master' into master

README.md

@@ -47,8 +47,8 @@ $ sudo dnf install openssl-devel systemd-devel pkg-config zlib-devel llvm clang
 ## **2. Download the source code.**
 
 ```bash
-$ git clone https://github.com/solana-labs/solana.git
-$ cd solana
+$ git clone https://github.com/anza-xyz/agave.git
+$ cd agave
 ```
 
 ## **3. Build.**

account-decoder/src/parse_sysvar.rs

@@ -94,7 +94,7 @@ pub fn parse_sysvar(data: &[u8], pubkey: &Pubkey) -> Result<SysvarAccountType, P
         } else if pubkey == &sysvar::epoch_rewards::id() {
             deserialize::<EpochRewards>(data)
                 .ok()
-                .map(SysvarAccountType::EpochRewards)
+                .map(|epoch_rewards| SysvarAccountType::EpochRewards(epoch_rewards.into()))
         } else {
             None
         }
@@ -119,7 +119,7 @@ pub enum SysvarAccountType {
     SlotHistory(UiSlotHistory),
     StakeHistory(Vec<UiStakeHistoryEntry>),
     LastRestartSlot(UiLastRestartSlot),
-    EpochRewards(EpochRewards),
+    EpochRewards(UiEpochRewards),
 }
 
 #[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Default)]
@@ -239,6 +239,32 @@ pub struct UiLastRestartSlot {
     pub last_restart_slot: Slot,
 }
 
+#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct UiEpochRewards {
+    pub distribution_starting_block_height: u64,
+    pub num_partitions: u64,
+    pub parent_blockhash: String,
+    pub total_points: u128,
+    pub total_rewards: u64,
+    pub distributed_rewards: u64,
+    pub active: bool,
+}
+
+impl From<EpochRewards> for UiEpochRewards {
+    fn from(epoch_rewards: EpochRewards) -> Self {
+        Self {
+            distribution_starting_block_height: epoch_rewards.distribution_starting_block_height,
+            num_partitions: epoch_rewards.num_partitions,
+            parent_blockhash: epoch_rewards.parent_blockhash.to_string(),
+            total_points: epoch_rewards.total_points,
+            total_rewards: epoch_rewards.total_rewards,
+            distributed_rewards: epoch_rewards.distributed_rewards,
+            active: epoch_rewards.active,
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
     #[allow(deprecated)]
@@ -381,7 +407,7 @@ mod test {
         let epoch_rewards_sysvar = create_account_for_test(&epoch_rewards);
         assert_eq!(
             parse_sysvar(&epoch_rewards_sysvar.data, &sysvar::epoch_rewards::id()).unwrap(),
-            SysvarAccountType::EpochRewards(epoch_rewards),
+            SysvarAccountType::EpochRewards(epoch_rewards.into()),
         );
     }
 }

accounts-db/benches/accounts.rs

@@ -143,10 +143,13 @@ fn store_accounts_with_possible_contention<F: 'static>(
     let pubkeys: Vec<_> = std::iter::repeat_with(solana_sdk::pubkey::new_rand)
         .take(num_keys)
         .collect();
-    let accounts_data: Vec<_> = std::iter::repeat(Account {
-        lamports: 1,
-        ..Default::default()
-    })
+    let accounts_data: Vec<_> = std::iter::repeat(
+        Account {
+            lamports: 1,
+            ..Default::default()
+        }
+        .to_account_shared_data(),
+    )
     .take(num_keys)
     .collect();
     let storable_accounts: Vec<_> = pubkeys.iter().zip(accounts_data.iter()).collect();

accounts-db/benches/append_vec.rs

@@ -4,8 +4,7 @@ extern crate test;
 use {
     rand::{thread_rng, Rng},
     solana_accounts_db::{
-        account_storage::meta::{StorableAccountsWithHashes, StoredAccountInfo, StoredMeta},
-        accounts_hash::AccountHash,
+        account_storage::meta::{StoredAccountInfo, StoredMeta},
         append_vec::{
             test_utils::{create_test_account, get_append_vec_path},
             AppendVec,
@@ -14,7 +13,6 @@ use {
     solana_sdk::{
         account::{AccountSharedData, ReadableAccount},
         clock::Slot,
-        hash::Hash,
     },
     std::{
         sync::{Arc, Mutex},
@@ -31,13 +29,11 @@ fn append_account(
     vec: &AppendVec,
     storage_meta: StoredMeta,
     account: &AccountSharedData,
-    hash: AccountHash,
 ) -> Option<StoredAccountInfo> {
     let slot_ignored = Slot::MAX;
     let accounts = [(&storage_meta.pubkey, account)];
     let slice = &accounts[..];
-    let accounts = (slot_ignored, slice);
-    let storable_accounts = StorableAccountsWithHashes::new_with_hashes(&accounts, vec![&hash]);
+    let storable_accounts = (slot_ignored, slice);
     let res = vec.append_accounts(&storable_accounts, 0);
     res.and_then(|res| res.first().cloned())
 }
@@ -48,7 +44,7 @@ fn append_vec_append(bencher: &mut Bencher) {
     let vec = AppendVec::new(&path.path, true, 64 * 1024);
     bencher.iter(|| {
         let (meta, account) = create_test_account(0);
-        if append_account(&vec, meta, &account, AccountHash(Hash::default())).is_none() {
+        if append_account(&vec, meta, &account).is_none() {
             vec.reset();
         }
     });
@@ -58,8 +54,7 @@ fn add_test_accounts(vec: &AppendVec, size: usize) -> Vec<(usize, usize)> {
     (0..size)
         .filter_map(|sample| {
             let (meta, account) = create_test_account(sample);
-            append_account(vec, meta, &account, AccountHash(Hash::default()))
-                .map(|info| (sample, info.offset))
+            append_account(vec, meta, &account).map(|info| (sample, info.offset))
         })
         .collect()
 }
@@ -73,7 +68,7 @@ fn append_vec_sequential_read(bencher: &mut Bencher) {
     bencher.iter(|| {
         let (sample, pos) = indexes.pop().unwrap();
         println!("reading pos {sample} {pos}");
-        let (account, _next) = vec.get_account(pos).unwrap();
+        let (account, _next) = vec.get_stored_account_meta(pos).unwrap();
         let (_meta, test) = create_test_account(sample);
         assert_eq!(account.data(), test.data());
         indexes.push((sample, pos));
@@ -88,7 +83,7 @@ fn append_vec_random_read(bencher: &mut Bencher) {
     bencher.iter(|| {
         let random_index: usize = thread_rng().gen_range(0..indexes.len());
         let (sample, pos) = &indexes[random_index];
-        let (account, _next) = vec.get_account(*pos).unwrap();
+        let (account, _next) = vec.get_stored_account_meta(*pos).unwrap();
         let (_meta, test) = create_test_account(*sample);
         assert_eq!(account.data(), test.data());
     });
@@ -104,7 +99,7 @@ fn append_vec_concurrent_append_read(bencher: &mut Bencher) {
     spawn(move || loop {
         let sample = indexes1.lock().unwrap().len();
         let (meta, account) = create_test_account(sample);
-        if let Some(info) = append_account(&vec1, meta, &account, AccountHash(Hash::default())) {
+        if let Some(info) = append_account(&vec1, meta, &account) {
             indexes1.lock().unwrap().push((sample, info.offset))
         } else {
             break;
@@ -117,7 +112,7 @@ fn append_vec_concurrent_append_read(bencher: &mut Bencher) {
         let len = indexes.lock().unwrap().len();
         let random_index: usize = thread_rng().gen_range(0..len);
         let (sample, pos) = *indexes.lock().unwrap().get(random_index).unwrap();
-        let (account, _next) = vec.get_account(pos).unwrap();
+        let (account, _next) = vec.get_stored_account_meta(pos).unwrap();
         let (_meta, test) = create_test_account(sample);
         assert_eq!(account.data(), test.data());
     });
@@ -137,14 +132,14 @@ fn append_vec_concurrent_read_append(bencher: &mut Bencher) {
         }
         let random_index: usize = thread_rng().gen_range(0..len + 1);
         let (sample, pos) = *indexes1.lock().unwrap().get(random_index % len).unwrap();
-        let (account, _next) = vec1.get_account(pos).unwrap();
+        let (account, _next) = vec1.get_stored_account_meta(pos).unwrap();
         let (_meta, test) = create_test_account(sample);
         assert_eq!(account.data(), test.data());
     });
     bencher.iter(|| {
         let sample: usize = thread_rng().gen_range(0..256);
         let (meta, account) = create_test_account(sample);
-        if let Some(info) = append_account(&vec, meta, &account, AccountHash(Hash::default())) {
+        if let Some(info) = append_account(&vec, meta, &account) {
             indexes.lock().unwrap().push((sample, info.offset))
         }
     });

accounts-db/benches/bench_accounts_file.rs

@@ -8,7 +8,7 @@ use {
         tiered_storage::hot::HotStorageWriter,
     },
     solana_sdk::{
-        account::Account, clock::Slot, hash::Hash, pubkey::Pubkey,
+        account::AccountSharedData, clock::Slot, hash::Hash, pubkey::Pubkey,
         rent_collector::RENT_EXEMPT_RENT_EPOCH,
     },
 };
@@ -34,7 +34,7 @@ fn bench_write_accounts_file(c: &mut Criterion) {
         let accounts: Vec<_> = std::iter::repeat_with(|| {
             (
                 Pubkey::new_unique(),
-                Account::new_rent_epoch(
+                AccountSharedData::new_rent_epoch(
                     lamports,
                     space,
                     &Pubkey::new_unique(),
@@ -59,7 +59,9 @@ fn bench_write_accounts_file(c: &mut Criterion) {
                     AppendVec::new(path, true, file_size)
                 },
                 |append_vec| {
-                    let res = append_vec.append_accounts(&storable_accounts, 0).unwrap();
+                    let res = append_vec
+                        .append_accounts(storable_accounts.accounts, 0)
+                        .unwrap();
                     let accounts_written_count = res.len();
                     assert_eq!(accounts_written_count, accounts_count);
                 },
@@ -77,7 +79,9 @@ fn bench_write_accounts_file(c: &mut Criterion) {
                     HotStorageWriter::new(path).unwrap()
                 },
                 |hot_storage| {
-                    let res = hot_storage.write_accounts(&storable_accounts, 0).unwrap();
+                    let res = hot_storage
+                        .write_accounts(storable_accounts.accounts, 0)
+                        .unwrap();
                     let accounts_written_count = res.len();
                     assert_eq!(accounts_written_count, accounts_count);
                 },

accounts-db/src/account_storage/meta.rs

@@ -3,7 +3,7 @@ use {
         account_info::AccountInfo,
         accounts_hash::AccountHash,
         append_vec::AppendVecStoredAccountMeta,
-        storable_accounts::StorableAccounts,
+        storable_accounts::{AccountForStorage, StorableAccounts},
         tiered_storage::hot::{HotAccount, HotAccountMeta},
     },
     solana_sdk::{account::ReadableAccount, hash::Hash, pubkey::Pubkey, stake_history::Epoch},
@@ -26,29 +26,18 @@ lazy_static! {
 /// This struct contains what is needed to store accounts to a storage
 /// 1. account & pubkey (StorableAccounts)
 /// 2. hash per account (Maybe in StorableAccounts, otherwise has to be passed in separately)
-pub struct StorableAccountsWithHashes<
-    'a: 'b,
-    'b,
-    T: ReadableAccount + Sync + 'b,
-    U: StorableAccounts<'a, T>,
-    V: Borrow<AccountHash>,
-> {
+pub struct StorableAccountsWithHashes<'a: 'b, 'b, U: StorableAccounts<'a>, V: Borrow<AccountHash>> {
     /// accounts to store
     /// always has pubkey and account
     /// may also have hash per account
-    pub(crate) accounts: &'b U,
+    pub accounts: &'b U,
     /// if accounts does not have hash, this has a hash per account
     hashes: Option<Vec<V>>,
-    _phantom: PhantomData<&'a T>,
+    _phantom: PhantomData<&'a ()>,
 }
 
-impl<
-        'a: 'b,
-        'b,
-        T: ReadableAccount + Sync + 'b,
-        U: StorableAccounts<'a, T>,
-        V: Borrow<AccountHash>,
-    > StorableAccountsWithHashes<'a, 'b, T, U, V>
+impl<'a: 'b, 'b, U: StorableAccounts<'a>, V: Borrow<AccountHash>>
+    StorableAccountsWithHashes<'a, 'b, U, V>
 {
     /// used when accounts contains hash already
     pub fn new(accounts: &'b U) -> Self {
@@ -72,23 +61,31 @@ impl<
     }
 
     /// get all account fields at 'index'
-    pub fn get(&self, index: usize) -> (Option<&T>, &Pubkey, &AccountHash) {
-        let account = self.accounts.account_default_if_zero_lamport(index);
-        let pubkey = self.accounts.pubkey(index);
+    pub fn get<Ret>(
+        &self,
+        index: usize,
+        mut callback: impl FnMut(AccountForStorage, &AccountHash) -> Ret,
+    ) -> Ret {
         let hash = if self.accounts.has_hash() {
             self.accounts.hash(index)
         } else {
             let item = self.hashes.as_ref().unwrap();
             item[index].borrow()
         };
-        (account, pubkey, hash)
+        self.accounts
+            .account_default_if_zero_lamport(index, |account| callback(account, hash))
     }
 
     /// None if account at index has lamports == 0
     /// Otherwise, Some(account)
     /// This is the only way to access the account.
-    pub fn account(&self, index: usize) -> Option<&T> {
-        self.accounts.account_default_if_zero_lamport(index)
+    pub fn account<Ret>(
+        &self,
+        index: usize,
+        callback: impl for<'local> FnMut(AccountForStorage<'local>) -> Ret,
+    ) -> Ret {
+        self.accounts
+            .account_default_if_zero_lamport(index, callback)
     }
 
     /// # accounts to write

accounts-db/src/accounts.rs

@@ -4,7 +4,7 @@ use {
             AccountsAddRootTiming, AccountsDb, LoadHint, LoadedAccount, ScanAccountStorageData,
             ScanStorageResult, VerifyAccountsHashAndLamportsConfig,
         },
-        accounts_index::{IndexKey, ScanConfig, ScanError, ScanResult, ZeroLamport},
+        accounts_index::{IndexKey, ScanConfig, ScanError, ScanResult},
         ancestors::Ancestors,
         storable_accounts::StorableAccounts,
     },
@@ -677,10 +677,7 @@ impl Accounts {
             .store_cached_inline_update_index((slot, &accounts_to_store[..]), Some(&transactions));
     }
 
-    pub fn store_accounts_cached<'a, T: ReadableAccount + Sync + ZeroLamport + 'a>(
-        &self,
-        accounts: impl StorableAccounts<'a, T>,
-    ) {
+    pub fn store_accounts_cached<'a>(&self, accounts: impl StorableAccounts<'a>) {
         self.accounts_db.store_cached(accounts, None)
     }