Updates frozen abi test for bank snapshot serialization (#1544)

accounts-db/src/epoch_accounts_hash.rs

@@ -13,6 +13,7 @@ mod manager;
 pub use manager::Manager as EpochAccountsHashManager;
 
 /// The EpochAccountsHash holds the result after calculating the accounts hash once per epoch
+#[cfg_attr(feature = "frozen-abi", derive(AbiExample))]
 #[derive(Debug, Serialize, Deserialize, Hash, PartialEq, Eq, Clone, Copy)]
 pub struct EpochAccountsHash(Hash);
 

runtime/src/bank/serde_snapshot.rs

@@ -406,7 +406,7 @@ mod tests {
         let mut buf = Vec::new();
         let cursor = Cursor::new(&mut buf);
         let mut writer = BufWriter::new(cursor);
-        serde_snapshot::serialize_bank_snapshot(
+        serde_snapshot::serialize_bank_snapshot_into(
             &mut writer,
             bank2.get_fields_to_serialize(),
             &bank2.rc.accounts.accounts_db,
@@ -718,22 +718,22 @@ mod tests {
 
     #[cfg(RUSTC_WITH_SPECIALIZATION)]
     mod test_bank_serialize {
-        use {super::*, crate::serde_snapshot::serialize_test_bank_and_storage};
+        use {super::*, solana_sdk::clock::Slot};
 
         // This some what long test harness is required to freeze the ABI of
         // Bank's serialization due to versioned nature
         #[cfg_attr(
             feature = "frozen-abi",
             derive(AbiExample),
-            frozen_abi(digest = "7K1xfUkoCwhxssszgoSpbeMCcX3KEyjycGyLXrpFaJNe")
+            frozen_abi(digest = "6riNuebfnAUpS2e3GYb5G8udH5PoEtep48ULchLjRDCB")
         )]
         #[derive(Serialize)]
-        pub struct BankAbiTestWrapperNewer {
+        pub struct BankAbiTestWrapper {
             #[serde(serialize_with = "wrapper")]
             bank: Bank,
         }
 
-        pub fn wrapper<S>(bank: &Bank, s: S) -> std::result::Result<S::Ok, S::Error>
+        pub fn wrapper<S>(bank: &Bank, serializer: S) -> Result<S::Ok, S::Error>
         where
             S: serde::Serializer,
         {
@@ -745,14 +745,26 @@ mod tests {
                 bank.slot(),
                 (AccountsHash(Hash::new_unique()), u64::default()),
             );
-            let snapshot_storages = bank.rc.accounts.accounts_db.get_snapshot_storages(..=0).0;
-            // ensure there is a single snapshot storage example for ABI digesting
-            assert_eq!(snapshot_storages.len(), 1);
 
-            serialize_test_bank_and_storage::<S>(
-                bank,
+            let snapshot_storages = bank.get_snapshot_storages(None);
+            // ensure there is at least one snapshot storage example for ABI digesting
+            assert!(!snapshot_storages.is_empty());
+
+            let incremental_snapshot_persistence = BankIncrementalSnapshotPersistence {
+                full_slot: Slot::default(),
+                full_hash: SerdeAccountsHash(Hash::new_unique()),
+                full_capitalization: u64::default(),
+                incremental_hash: SerdeIncrementalAccountsHash(Hash::new_unique()),
+                incremental_capitalization: u64::default(),
+            };
+
+            serde_snapshot::serialize_bank_snapshot_with(
+                serializer,
+                bank.get_fields_to_serialize(),
+                &bank.rc.accounts.accounts_db,
                 &get_storages_to_serialize(&snapshot_storages),
-                s,
+                Some(&incremental_snapshot_persistence),
+                Some(EpochAccountsHash::new(Hash::new_unique())),
             )
         }
     }

runtime/src/serde_snapshot.rs

@@ -580,8 +580,8 @@ where
     )
 }
 
-/// Serializes bank snapshot into `stream`
-pub fn serialize_bank_snapshot<W>(
+/// Serializes bank snapshot into `stream` with bincode
+pub fn serialize_bank_snapshot_into<W>(
     stream: &mut BufWriter<W>,
     bank_fields: BankFieldsToSerialize,
     accounts_db: &AccountsDb,
@@ -591,6 +591,32 @@ pub fn serialize_bank_snapshot<W>(
 ) -> Result<(), Error>
 where
     W: Write,
+{
+    let mut serializer = bincode::Serializer::new(
+        stream,
+        bincode::DefaultOptions::new().with_fixint_encoding(),
+    );
+    serialize_bank_snapshot_with(
+        &mut serializer,
+        bank_fields,
+        accounts_db,
+        account_storage_entries,
+        incremental_snapshot_persistence,
+        epoch_accounts_hash,
+    )
+}
+
+/// Serializes bank snapshot with `serializer`
+pub fn serialize_bank_snapshot_with<S>(
+    serializer: S,
+    bank_fields: BankFieldsToSerialize,
+    accounts_db: &AccountsDb,
+    account_storage_entries: &[Vec<Arc<AccountStorageEntry>>],
+    incremental_snapshot_persistence: Option<&BankIncrementalSnapshotPersistence>,
+    epoch_accounts_hash: Option<EpochAccountsHash>,
+) -> Result<S::Ok, S::Error>
+where
+    S: serde::Serializer,
 {
     let slot = bank_fields.slot;
     let lamports_per_signature = bank_fields.fee_rate_governor.lamports_per_signature;
@@ -600,16 +626,15 @@ where
         slot,
         account_storage_entries,
     };
-    bincode::serialize_into(
-        stream,
-        &(
-            serializable_bank,
-            serializable_accounts_db,
-            lamports_per_signature,
-            incremental_snapshot_persistence,
-            epoch_accounts_hash,
-        ),
+
+    (
+        serializable_bank,
+        serializable_accounts_db,
+        lamports_per_signature,
+        incremental_snapshot_persistence,
+        epoch_accounts_hash,
     )
+        .serialize(serializer)
 }
 
 /// deserialize the bank from 'stream_reader'
@@ -749,22 +774,6 @@ impl<'a> Serialize for SerializableBankAndStorage<'a> {
     }
 }
 
-#[cfg(test)]
-pub fn serialize_test_bank_and_storage<S>(
-    bank: &Bank,
-    storage: &[Vec<Arc<AccountStorageEntry>>],
-    s: S,
-) -> std::result::Result<S::Ok, S::Error>
-where
-    S: serde::Serializer,
-{
-    SerializableBankAndStorage {
-        bank,
-        snapshot_storages: storage,
-    }
-    .serialize(s)
-}
-
 #[cfg(test)]
 struct SerializableBankAndStorageNoExtra<'a> {
     bank: &'a Bank,

runtime/src/snapshot_utils.rs

@@ -863,7 +863,7 @@ fn serialize_snapshot(
             );
 
         let bank_snapshot_serializer = move |stream: &mut BufWriter<fs::File>| -> Result<()> {
-            serde_snapshot::serialize_bank_snapshot(
+            serde_snapshot::serialize_bank_snapshot_into(
                 stream,
                 bank_fields,
                 accounts_db,