use safecoin_sdk::{account::ReadableAccount, clock::Slot, pubkey::Pubkey};
pub trait StorableAccounts<'a, T: ReadableAccount + Sync>: Sync {
fn pubkey(&self, index: usize) -> &Pubkey;
fn account(&self, index: usize) -> &T;
fn slot(&self, index: usize) -> Slot;
fn target_slot(&self) -> Slot;
fn is_empty(&self) -> bool {
self.len() == 0
}
fn len(&self) -> usize;
fn contains_multiple_slots(&self) -> bool;
}
pub struct StorableAccountsMovingSlots<'a, T: ReadableAccount + Sync> {
pub accounts: &'a [(&'a Pubkey, &'a T)],
pub target_slot: Slot,
pub old_slot: Slot,
}
impl<'a, T: ReadableAccount + Sync> StorableAccounts<'a, T> for StorableAccountsMovingSlots<'a, T> {
fn pubkey(&self, index: usize) -> &Pubkey {
self.accounts[index].0
}
fn account(&self, index: usize) -> &T {
self.accounts[index].1
}
fn slot(&self, _index: usize) -> Slot {
self.old_slot
}
fn target_slot(&self) -> Slot {
self.target_slot
}
fn len(&self) -> usize {
self.accounts.len()
}
fn contains_multiple_slots(&self) -> bool {
false
}
}
impl<'a, T: ReadableAccount + Sync> StorableAccounts<'a, T> for (Slot, &'a [(&'a Pubkey, &'a T)]) {
fn pubkey(&self, index: usize) -> &Pubkey {
self.1[index].0
}
fn account(&self, index: usize) -> &T {
self.1[index].1
}
fn slot(&self, _index: usize) -> Slot {
self.target_slot()
}
fn target_slot(&self) -> Slot {
self.0
}
fn len(&self) -> usize {
self.1.len()
}
fn contains_multiple_slots(&self) -> bool {
false
}
}
impl<'a, T: ReadableAccount + Sync> StorableAccounts<'a, T>
for (Slot, &'a [(&'a Pubkey, &'a T, Slot)])
{
fn pubkey(&self, index: usize) -> &Pubkey {
self.1[index].0
}
fn account(&self, index: usize) -> &T {
self.1[index].1
}
fn slot(&self, index: usize) -> Slot {
self.1[index].2
}
fn target_slot(&self) -> Slot {
self.0
}
fn len(&self) -> usize {
self.1.len()
}
fn contains_multiple_slots(&self) -> bool {
let len = self.len();
if len > 0 {
let slot = self.slot(0);
(1..len).any(|i| slot != self.slot(i))
} else {
false
}
}
}
#[cfg(test)]
pub mod tests {
use {
super::*,
safecoin_sdk::account::{AccountSharedData, WritableAccount},
};
fn compare<'a, T: ReadableAccount + Sync + PartialEq + std::fmt::Debug>(
a: &impl StorableAccounts<'a, T>,
b: &impl StorableAccounts<'a, T>,
) {
assert_eq!(a.target_slot(), b.target_slot());
assert_eq!(a.len(), b.len());
assert_eq!(a.is_empty(), b.is_empty());
(0..a.len()).into_iter().for_each(|i| {
assert_eq!(a.pubkey(i), b.pubkey(i));
assert_eq!(a.account(i), b.account(i));
})
}
#[test]
fn test_contains_multiple_slots() {
let pk = Pubkey::new(&[1; 32]);
let account = AccountSharedData::create(1, Vec::default(), Pubkey::default(), false, 0);
let slot = 0;
let test3 = (
slot,
&vec![(&pk, &account, slot), (&pk, &account, slot)][..],
);
assert!(!(&test3).contains_multiple_slots());
let test3 = (
slot,
&vec![(&pk, &account, slot), (&pk, &account, slot + 1)][..],
);
assert!(test3.contains_multiple_slots());
}
#[test]
fn test_storable_accounts() {
let max_slots = 3_u64;
for target_slot in 0..max_slots {
for entries in 0..2 {
for starting_slot in 0..max_slots {
let mut raw = Vec::new();
for entry in 0..entries {
let pk = Pubkey::new(&[entry; 32]);
raw.push((
pk,
AccountSharedData::create(
((entry as u64) * starting_slot) as u64,
Vec::default(),
Pubkey::default(),
false,
0,
),
starting_slot % max_slots,
));
}
let mut two = Vec::new();
let mut three = Vec::new();
raw.iter().for_each(|raw| {
two.push((&raw.0, &raw.1)); three.push((&raw.0, &raw.1, raw.2)); });
let test2 = (target_slot, &two[..]);
let test3 = (target_slot, &three[..]);
let old_slot = starting_slot;
let test_moving_slots = StorableAccountsMovingSlots {
accounts: &two[..],
target_slot,
old_slot,
};
compare(&test2, &test3);
compare(&test2, &test_moving_slots);
for (i, raw) in raw.iter().enumerate() {
assert_eq!(raw.0, *test3.pubkey(i));
assert_eq!(raw.1, *test3.account(i));
assert_eq!(raw.2, test3.slot(i));
assert_eq!(target_slot, test2.slot(i));
assert_eq!(old_slot, test_moving_slots.slot(i));
}
assert_eq!(target_slot, test3.target_slot());
assert!(!test2.contains_multiple_slots());
assert!(!test_moving_slots.contains_multiple_slots());
assert_eq!(test3.contains_multiple_slots(), entries > 1);
}
}
}
}
}