229 lines
8.3 KiB
Rust
229 lines
8.3 KiB
Rust
use crate::bank::Bank;
|
|
use solana_sdk::account::Account;
|
|
use solana_sdk::account_utils::State;
|
|
use solana_sdk::pubkey::Pubkey;
|
|
use solana_storage_api::storage_contract::StorageContract;
|
|
use std::collections::{HashMap, HashSet};
|
|
|
|
#[derive(Default, Clone, PartialEq, Debug, Deserialize, Serialize)]
|
|
pub struct StorageAccounts {
|
|
/// validator storage accounts and their credits
|
|
validator_accounts: HashSet<Pubkey>,
|
|
|
|
/// replicator storage accounts and their credits
|
|
replicator_accounts: HashSet<Pubkey>,
|
|
|
|
/// unclaimed points.
|
|
// 1 point == 1 storage account credit
|
|
points: HashMap<Pubkey, u64>,
|
|
}
|
|
|
|
pub fn is_storage(account: &Account) -> bool {
|
|
solana_storage_api::check_id(&account.owner)
|
|
}
|
|
|
|
impl StorageAccounts {
|
|
pub fn store(&mut self, pubkey: &Pubkey, account: &Account) {
|
|
if let Ok(storage_state) = account.state() {
|
|
if let StorageContract::ReplicatorStorage { credits, .. } = storage_state {
|
|
if account.lamports == 0 {
|
|
self.replicator_accounts.remove(pubkey);
|
|
} else {
|
|
self.replicator_accounts.insert(*pubkey);
|
|
self.points.insert(*pubkey, credits.current_epoch);
|
|
}
|
|
} else if let StorageContract::ValidatorStorage { credits, .. } = storage_state {
|
|
if account.lamports == 0 {
|
|
self.validator_accounts.remove(pubkey);
|
|
} else {
|
|
self.validator_accounts.insert(*pubkey);
|
|
self.points.insert(*pubkey, credits.current_epoch);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
/// currently unclaimed points
|
|
pub fn points(&self) -> u64 {
|
|
self.points.values().sum()
|
|
}
|
|
|
|
/// "claims" points, resets points to 0
|
|
pub fn claim_points(&mut self) -> u64 {
|
|
let points = self.points();
|
|
self.points.clear();
|
|
points
|
|
}
|
|
}
|
|
|
|
pub fn validator_accounts(bank: &Bank) -> HashMap<Pubkey, Account> {
|
|
bank.storage_accounts()
|
|
.validator_accounts
|
|
.iter()
|
|
.filter_map(|account_id| {
|
|
bank.get_account(account_id)
|
|
.and_then(|account| Some((*account_id, account)))
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
pub fn replicator_accounts(bank: &Bank) -> HashMap<Pubkey, Account> {
|
|
bank.storage_accounts()
|
|
.replicator_accounts
|
|
.iter()
|
|
.filter_map(|account_id| {
|
|
bank.get_account(account_id)
|
|
.and_then(|account| Some((*account_id, account)))
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
#[cfg(test)]
|
|
pub(crate) mod tests {
|
|
use super::*;
|
|
use crate::bank_client::BankClient;
|
|
use solana_sdk::client::SyncClient;
|
|
use solana_sdk::genesis_block::create_genesis_block;
|
|
use solana_sdk::message::Message;
|
|
use solana_sdk::signature::{Keypair, KeypairUtil};
|
|
use solana_storage_api::storage_contract::{StorageAccount, STORAGE_ACCOUNT_SPACE};
|
|
use solana_storage_api::{storage_instruction, storage_processor};
|
|
use std::sync::Arc;
|
|
|
|
#[test]
|
|
fn test_store_and_recover() {
|
|
let (genesis_block, mint_keypair) = create_genesis_block(1000);
|
|
let mint_pubkey = mint_keypair.pubkey();
|
|
let replicator_keypair = Keypair::new();
|
|
let replicator_pubkey = replicator_keypair.pubkey();
|
|
let validator_keypair = Keypair::new();
|
|
let validator_pubkey = validator_keypair.pubkey();
|
|
let mut bank = Bank::new(&genesis_block);
|
|
bank.add_instruction_processor(
|
|
solana_storage_api::id(),
|
|
storage_processor::process_instruction,
|
|
);
|
|
|
|
let bank = Arc::new(bank);
|
|
let bank_client = BankClient::new_shared(&bank);
|
|
|
|
bank_client
|
|
.transfer(10, &mint_keypair, &replicator_pubkey)
|
|
.unwrap();
|
|
let message = Message::new(storage_instruction::create_replicator_storage_account(
|
|
&mint_pubkey,
|
|
&Pubkey::default(),
|
|
&replicator_pubkey,
|
|
1,
|
|
));
|
|
bank_client.send_message(&[&mint_keypair], message).unwrap();
|
|
|
|
bank_client
|
|
.transfer(10, &mint_keypair, &validator_pubkey)
|
|
.unwrap();
|
|
let message = Message::new(storage_instruction::create_validator_storage_account(
|
|
&mint_pubkey,
|
|
&Pubkey::default(),
|
|
&validator_pubkey,
|
|
1,
|
|
));
|
|
bank_client.send_message(&[&mint_keypair], message).unwrap();
|
|
|
|
assert_eq!(validator_accounts(bank.as_ref()).len(), 1);
|
|
assert_eq!(replicator_accounts(bank.as_ref()).len(), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn test_points() {
|
|
// note: storage_points == storage_credits
|
|
let credits = 42;
|
|
let mut storage_accounts = StorageAccounts::default();
|
|
assert_eq!(storage_accounts.points(), 0);
|
|
assert_eq!(storage_accounts.claim_points(), 0);
|
|
|
|
// create random validator and replicator accounts with `credits`
|
|
let ((validator_pubkey, validator_account), (replicator_pubkey, replicator_account)) =
|
|
create_storage_accounts_with_credits(credits);
|
|
|
|
storage_accounts.store(&validator_pubkey, &validator_account);
|
|
storage_accounts.store(&replicator_pubkey, &replicator_account);
|
|
// check that 2x credits worth of points are available
|
|
assert_eq!(storage_accounts.points(), credits * 2);
|
|
|
|
let ((validator_pubkey, validator_account), (replicator_pubkey, mut replicator_account)) =
|
|
create_storage_accounts_with_credits(credits);
|
|
|
|
storage_accounts.store(&validator_pubkey, &validator_account);
|
|
storage_accounts.store(&replicator_pubkey, &replicator_account);
|
|
// check that 4x credits worth of points are available
|
|
assert_eq!(storage_accounts.points(), credits * 2 * 2);
|
|
|
|
storage_accounts.store(&validator_pubkey, &validator_account);
|
|
storage_accounts.store(&replicator_pubkey, &replicator_account);
|
|
// check that storing again has no effect
|
|
assert_eq!(storage_accounts.points(), credits * 2 * 2);
|
|
|
|
let storage_contract = &mut replicator_account.state().unwrap();
|
|
if let StorageContract::ReplicatorStorage {
|
|
credits: account_credits,
|
|
..
|
|
} = storage_contract
|
|
{
|
|
account_credits.current_epoch += 1;
|
|
}
|
|
replicator_account.set_state(storage_contract).unwrap();
|
|
storage_accounts.store(&replicator_pubkey, &replicator_account);
|
|
|
|
// check that incremental store increases credits
|
|
assert_eq!(storage_accounts.points(), credits * 2 * 2 + 1);
|
|
|
|
assert_eq!(storage_accounts.claim_points(), credits * 2 * 2 + 1);
|
|
// check that once redeemed, the points are gone
|
|
assert_eq!(storage_accounts.claim_points(), 0);
|
|
}
|
|
|
|
pub fn create_storage_accounts_with_credits(
|
|
credits: u64,
|
|
) -> ((Pubkey, Account), (Pubkey, Account)) {
|
|
let validator_pubkey = Pubkey::new_rand();
|
|
let replicator_pubkey = Pubkey::new_rand();
|
|
|
|
let mut validator_account =
|
|
Account::new(1, STORAGE_ACCOUNT_SPACE as usize, &solana_storage_api::id());
|
|
let mut validator = StorageAccount::new(validator_pubkey, &mut validator_account);
|
|
validator
|
|
.initialize_validator_storage(validator_pubkey)
|
|
.unwrap();
|
|
let storage_contract = &mut validator_account.state().unwrap();
|
|
if let StorageContract::ValidatorStorage {
|
|
credits: account_credits,
|
|
..
|
|
} = storage_contract
|
|
{
|
|
account_credits.current_epoch = credits;
|
|
}
|
|
validator_account.set_state(storage_contract).unwrap();
|
|
|
|
let mut replicator_account =
|
|
Account::new(1, STORAGE_ACCOUNT_SPACE as usize, &solana_storage_api::id());
|
|
let mut replicator = StorageAccount::new(replicator_pubkey, &mut replicator_account);
|
|
replicator
|
|
.initialize_replicator_storage(replicator_pubkey)
|
|
.unwrap();
|
|
let storage_contract = &mut replicator_account.state().unwrap();
|
|
if let StorageContract::ReplicatorStorage {
|
|
credits: account_credits,
|
|
..
|
|
} = storage_contract
|
|
{
|
|
account_credits.current_epoch = credits;
|
|
}
|
|
replicator_account.set_state(storage_contract).unwrap();
|
|
|
|
(
|
|
(validator_pubkey, validator_account),
|
|
(replicator_pubkey, replicator_account),
|
|
)
|
|
}
|
|
}
|