Remove usages of WritableAccount::create

account-decoder-client-types/src/lib.rs

@@ -16,8 +16,9 @@ use {
     core::str::FromStr,
     serde::{Deserialize, Serialize},
     serde_json::Value,
-    solana_account::WritableAccount,
+    solana_account::{Account, AccountSharedData},
     solana_pubkey::Pubkey,
+    std::sync::Arc,
 };
 pub mod token;
 
@@ -80,16 +81,27 @@ pub enum UiAccountEncoding {
 }
 
 impl UiAccount {
-    pub fn decode<T: WritableAccount>(&self) -> Option<T> {
-        let data = self.data.decode()?;
-        Some(T::create(
+    pub fn to_account_shared_data(&self) -> Option<AccountSharedData> {
+        let data = Arc::new(self.data.decode()?);
+        Some(AccountSharedData::create_from_existing_shared_data(
             self.lamports,
             data,
             Pubkey::from_str(&self.owner).ok()?,
             self.executable,
             self.rent_epoch,
         ))
     }
+
+    pub fn to_account(&self) -> Option<Account> {
+        let data = self.data.decode()?;
+        Some(Account {
+            lamports: self.lamports,
+            data,
+            owner: Pubkey::from_str(&self.owner).ok()?,
+            executable: self.executable,
+            rent_epoch: self.rent_epoch,
+        })
+    }
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]

account-decoder/src/lib.rs

@@ -248,9 +248,9 @@ mod test {
             UiAccountData::Binary(_, UiAccountEncoding::Base64Zstd)
         );
 
-        let decoded_account = encoded_account.decode::<Account>().unwrap();
+        let decoded_account = encoded_account.to_account_shared_data().unwrap();
         assert_eq!(decoded_account.data(), &vec![0; 1024]);
-        let decoded_account = encoded_account.decode::<AccountSharedData>().unwrap();
+        let decoded_account = encoded_account.to_account().unwrap();
         assert_eq!(decoded_account.data(), &vec![0; 1024]);
     }
 }

accounts-db/src/accounts.rs

@@ -733,9 +733,9 @@ mod tests {
                 meta: LookupTableMeta::default(),
                 addresses: Cow::Owned(table_addresses.clone()),
             };
-            AccountSharedData::create(
+            AccountSharedData::create_from_existing_shared_data(
                 1,
-                table_state.serialize_for_tests().unwrap(),
+                Arc::new(table_state.serialize_for_tests().unwrap()),
                 address_lookup_table::program::id(),
                 false,
                 0,

accounts-db/src/accounts_index.rs

@@ -1748,7 +1748,7 @@ pub mod tests {
     use {
         super::{bucket_map_holder::BucketMapHolder, *},
         crate::accounts_index::account_map_entry::AccountMapEntryMeta,
-        solana_account::{AccountSharedData, WritableAccount},
+        solana_account::AccountSharedData,
         solana_pubkey::PUBKEY_BYTES,
         spl_generic_token::{spl_token_ids, token::SPL_TOKEN_ACCOUNT_OWNER_OFFSET},
         std::ops::{
@@ -3124,9 +3124,9 @@ pub mod tests {
                 *slot,
                 &account_key,
                 // Make sure these accounts are added to secondary index
-                &AccountSharedData::create(
+                &AccountSharedData::create_from_existing_shared_data(
                     0,
-                    account_data.to_vec(),
+                    Arc::new(account_data.to_vec()),
                     spl_generic_token::token::id(),
                     false,
                     0,
@@ -3513,7 +3513,13 @@ pub mod tests {
             0,
             0,
             &account_key,
-            &AccountSharedData::create(0, account_data.to_vec(), Pubkey::default(), false, 0),
+            &AccountSharedData::create_from_existing_shared_data(
+                0,
+                Arc::new(account_data.to_vec()),
+                Pubkey::default(),
+                false,
+                0,
+            ),
             &secondary_indexes,
             true,
             &mut ReclaimsSlotList::new(),
@@ -3527,7 +3533,13 @@ pub mod tests {
             0,
             0,
             &account_key,
-            &AccountSharedData::create(0, account_data[1..].to_vec(), *token_id, false, 0),
+            &AccountSharedData::create_from_existing_shared_data(
+                0,
+                Arc::new(account_data[1..].to_vec()),
+                *token_id,
+                false,
+                0,
+            ),
             &secondary_indexes,
             true,
             &mut ReclaimsSlotList::new(),
@@ -3542,7 +3554,13 @@ pub mod tests {
         for _ in 0..2 {
             index.update_secondary_indexes(
                 &account_key,
-                &AccountSharedData::create(0, account_data.to_vec(), *token_id, false, 0),
+                &AccountSharedData::create_from_existing_shared_data(
+                    0,
+                    Arc::new(account_data.to_vec()),
+                    *token_id,
+                    false,
+                    0,
+                ),
                 &secondary_indexes,
             );
             check_secondary_index_mapping_correct(secondary_index, &[index_key], &account_key);
@@ -3560,7 +3578,13 @@ pub mod tests {
         secondary_index.reverse_index.clear();
         index.update_secondary_indexes(
             &account_key,
-            &AccountSharedData::create(0, account_data.to_vec(), *token_id, false, 0),
+            &AccountSharedData::create_from_existing_shared_data(
+                0,
+                Arc::new(account_data.to_vec()),
+                *token_id,
+                false,
+                0,
+            ),
             &secondary_indexes,
         );
         assert!(!secondary_index.index.is_empty());
@@ -3576,7 +3600,13 @@ pub mod tests {
         secondary_index.reverse_index.clear();
         index.update_secondary_indexes(
             &account_key,
-            &AccountSharedData::create(0, account_data.to_vec(), *token_id, false, 0),
+            &AccountSharedData::create_from_existing_shared_data(
+                0,
+                Arc::new(account_data.to_vec()),
+                *token_id,
+                false,
+                0,
+            ),
             &secondary_indexes,
         );
         assert!(!secondary_index.index.is_empty());
@@ -3652,7 +3682,13 @@ pub mod tests {
             slot,
             slot,
             &account_key,
-            &AccountSharedData::create(0, account_data1.to_vec(), *token_id, false, 0),
+            &AccountSharedData::create_from_existing_shared_data(
+                0,
+                Arc::new(account_data1.to_vec()),
+                *token_id,
+                false,
+                0,
+            ),
             secondary_indexes,
             true,
             &mut ReclaimsSlotList::new(),
@@ -3664,7 +3700,13 @@ pub mod tests {
             slot,
             slot,
             &account_key,
-            &AccountSharedData::create(0, account_data2.to_vec(), *token_id, false, 0),
+            &AccountSharedData::create_from_existing_shared_data(
+                0,
+                Arc::new(account_data2.to_vec()),
+                *token_id,
+                false,
+                0,
+            ),
             secondary_indexes,
             true,
             &mut ReclaimsSlotList::new(),
@@ -3684,7 +3726,13 @@ pub mod tests {
             later_slot,
             later_slot,
             &account_key,
-            &AccountSharedData::create(0, account_data1.to_vec(), *token_id, false, 0),
+            &AccountSharedData::create_from_existing_shared_data(
+                0,
+                Arc::new(account_data1.to_vec()),
+                *token_id,
+                false,
+                0,
+            ),
             secondary_indexes,
             true,
             &mut ReclaimsSlotList::new(),

accounts-db/src/append_vec.rs

@@ -31,7 +31,7 @@ use {
     log::*,
     memmap2::MmapMut,
     meta::StoredAccountNoData,
-    solana_account::{AccountSharedData, ReadableAccount, WritableAccount},
+    solana_account::{AccountSharedData, ReadableAccount},
     solana_pubkey::Pubkey,
     solana_system_interface::MAX_PERMITTED_DATA_LENGTH,
     std::{
@@ -44,7 +44,7 @@ use {
         ptr, slice,
         sync::{
             atomic::{AtomicBool, AtomicU64, AtomicUsize, Ordering},
-            Mutex, MutexGuard,
+            Arc, Mutex, MutexGuard,
         },
     },
     thiserror::Error,
@@ -891,9 +891,9 @@ impl AppendVec {
                     }
                     // SAFETY: we've just checked that `bytes_read` is at least `data_len`.
                     unsafe { data.set_len(data_len as usize) };
-                    AccountSharedData::create(
+                    AccountSharedData::create_from_existing_shared_data(
                         account_meta.lamports,
-                        data,
+                        Arc::new(data),
                         account_meta.owner,
                         account_meta.executable,
                         account_meta.rent_epoch,
@@ -1366,7 +1366,7 @@ pub mod tests {
         memoffset::offset_of,
         rand::{prelude::*, rng},
         rand_chacha::ChaChaRng,
-        solana_account::{accounts_equal, Account, AccountSharedData},
+        solana_account::{accounts_equal, Account, AccountSharedData, WritableAccount},
         solana_clock::Slot,
         std::{mem::ManuallyDrop, time::Instant},
         test_case::{test_case, test_matrix},

accounts-db/src/storable_accounts.rs

@@ -367,7 +367,7 @@ pub mod tests {
             accounts_file::AccountsFileProvider,
         },
         rand::Rng,
-        solana_account::{accounts_equal, AccountSharedData, WritableAccount},
+        solana_account::{accounts_equal, AccountSharedData},
         std::sync::Arc,
     };
 
@@ -547,9 +547,9 @@ pub mod tests {
                     let mut raw4 = Vec::new();
                     for entry in 0..entries {
                         let pk = Pubkey::from([entry; 32]);
-                        let account = AccountSharedData::create(
+                        let account = AccountSharedData::create_from_existing_shared_data(
                             (entry as u64) * starting_slot,
-                            Vec::default(),
+                            Arc::new(Vec::default()),
                             Pubkey::default(),
                             false,
                             0,
@@ -678,9 +678,9 @@ pub mod tests {
             let mut raw2 = Vec::new();
             for entry in 0..entries {
                 let pk = Pubkey::from([entry; 32]);
-                let account = AccountSharedData::create(
+                let account = AccountSharedData::create_from_existing_shared_data(
                     entry as u64,
-                    Vec::default(),
+                    Arc::new(Vec::default()),
                     Pubkey::default(),
                     false,
                     0,

accounts-db/src/tiered_storage/hot.rs

@@ -21,10 +21,10 @@ use {
     bytemuck_derive::{Pod, Zeroable},
     memmap2::{Mmap, MmapOptions},
     modular_bitfield::prelude::*,
-    solana_account::{AccountSharedData, ReadableAccount, WritableAccount},
+    solana_account::{AccountSharedData, ReadableAccount},
     solana_clock::Epoch,
     solana_pubkey::Pubkey,
-    std::{io::Write, option::Option, path::Path},
+    std::{io::Write, option::Option, path::Path, sync::Arc},
 };
 
 /// When rent is collected from an exempt account, rent_epoch is set to this
@@ -577,11 +577,11 @@ impl HotStorageReader {
         let account_block = self.get_account_block(account_offset, index_offset)?;
 
         let lamports = meta.lamports();
-        let data = meta.account_data(account_block).to_vec();
+        let data = Arc::new(meta.account_data(account_block).to_vec());
         let owner = *self.get_owner_address(meta.owner_offset())?;
         let executable = meta.flags().executable();
         let rent_epoch = meta.final_rent_epoch(account_block);
-        Ok(Some(AccountSharedData::create(
+        Ok(Some(AccountSharedData::create_from_existing_shared_data(
             lamports, data, owner, executable, rent_epoch,
         )))
     }

accounts-db/src/utils.rs

@@ -1,13 +1,13 @@
 use {
     agave_fs::dirs,
     log::*,
-    solana_account::{AccountSharedData, ReadableAccount, WritableAccount},
+    solana_account::{AccountSharedData, ReadableAccount},
     solana_measure::measure_time,
     std::{
         collections::HashSet,
         fs, io,
         path::{Path, PathBuf},
-        sync::Mutex,
+        sync::{Arc, Mutex},
         thread,
     },
 };
@@ -154,9 +154,9 @@ pub fn create_and_canonicalize_directory(directory: impl AsRef<Path>) -> io::Res
 /// Creates a new AccountSharedData structure for anything that implements ReadableAccount.
 /// This function implies data copies.
 pub fn create_account_shared_data(account: &impl ReadableAccount) -> AccountSharedData {
-    AccountSharedData::create(
+    AccountSharedData::create_from_existing_shared_data(
         account.lamports(),
-        account.data().to_vec(),
+        Arc::new(account.data().to_vec()),
         *account.owner(),
         account.executable(),
         account.rent_epoch(),

cli/src/cluster_query.rs

@@ -11,7 +11,7 @@ use {
     console::style,
     crossbeam_channel::unbounded,
     serde::{Deserialize, Serialize},
-    solana_account::{from_account, state_traits::StateMut, Account},
+    solana_account::{from_account, state_traits::StateMut},
     solana_clap_utils::{
         compute_budget::{compute_unit_price_arg, ComputeUnitLimit, COMPUTE_UNIT_PRICE_ARG},
         input_parsers::*,
@@ -2001,7 +2001,7 @@ pub async fn process_show_stakes(
 
     let mut stake_accounts: Vec<CliKeyedStakeState> = vec![];
     for (stake_pubkey, stake_ui_account) in all_stake_accounts {
-        let stake_account: Account = stake_ui_account.decode().expect(
+        let stake_account = stake_ui_account.to_account().expect(
             "It should be impossible at this point for the account data not to be decodable. \
              Ensure that the account was fetched using a binary encoding.",
         );

cli/src/program.rs

@@ -16,7 +16,7 @@ use {
     bip39::{Language, Mnemonic, MnemonicType, Seed},
     clap::{App, AppSettings, Arg, ArgMatches, SubCommand},
     log::*,
-    solana_account::{state_traits::StateMut, Account},
+    solana_account::state_traits::StateMut,
     solana_account_decoder::{UiAccount, UiAccountEncoding, UiDataSliceConfig},
     solana_clap_utils::{
         self,
@@ -1987,7 +1987,7 @@ async fn get_buffers(
 
     let mut buffers = vec![];
     for (address, ui_account) in results.iter() {
-        let account: Account = ui_account.decode().expect(
+        let account = ui_account.to_account().expect(
             "It should be impossible at this point for the account data not to be decodable. \
              Ensure that the account was fetched using a binary encoding.",
         );
@@ -2040,7 +2040,7 @@ async fn get_programs(
 
     let mut programs = vec![];
     for (programdata_address, programdata_ui_account) in results.iter() {
-        let programdata_account: Account = programdata_ui_account.decode().expect(
+        let programdata_account = programdata_ui_account.to_account().expect(
             "It should be impossible at this point for the account data not to be decodable. \
              Ensure that the account was fetched using a binary encoding.",
         );