Move KeyedAccount out of solana-program. Native programs are not supported by solana-program
This commit is contained in:
parent
0475107654
commit
1b343665a1
|
@ -216,7 +216,7 @@ fn bench_instruction_count_tuner(_bencher: &mut Bencher) {
|
|||
let keyed_accounts: Vec<_> = keys
|
||||
.iter()
|
||||
.zip(&accounts)
|
||||
.map(|(key, account)| solana_sdk::account::KeyedAccount::new(&key, false, &account))
|
||||
.map(|(key, account)| solana_sdk::keyed_account::KeyedAccount::new(&key, false, &account))
|
||||
.collect();
|
||||
let instruction_data = vec![0u8];
|
||||
|
||||
|
|
|
@ -18,12 +18,13 @@ use solana_runtime::{
|
|||
},
|
||||
};
|
||||
use solana_sdk::{
|
||||
account::{Account, KeyedAccount},
|
||||
account::Account,
|
||||
bpf_loader, bpf_loader_deprecated,
|
||||
client::SyncClient,
|
||||
clock::{DEFAULT_SLOTS_PER_EPOCH, MAX_PROCESSING_AGE},
|
||||
entrypoint::{MAX_PERMITTED_DATA_INCREASE, SUCCESS},
|
||||
instruction::{AccountMeta, CompiledInstruction, Instruction, InstructionError},
|
||||
keyed_account::KeyedAccount,
|
||||
message::Message,
|
||||
pubkey::Pubkey,
|
||||
signature::{Keypair, Signer},
|
||||
|
|
|
@ -21,11 +21,11 @@ use solana_runtime::{
|
|||
process_instruction::{ComputeMeter, Executor, InvokeContext},
|
||||
};
|
||||
use solana_sdk::{
|
||||
account::{is_executable, next_keyed_account, KeyedAccount},
|
||||
bpf_loader, bpf_loader_deprecated,
|
||||
decode_error::DecodeError,
|
||||
entrypoint::SUCCESS,
|
||||
instruction::InstructionError,
|
||||
keyed_account::{is_executable, next_keyed_account, KeyedAccount},
|
||||
loader_instruction::LoaderInstruction,
|
||||
program_utils::limited_deserialize,
|
||||
pubkey::Pubkey,
|
||||
|
|
|
@ -1,7 +1,7 @@
|
|||
use byteorder::{ByteOrder, LittleEndian, WriteBytesExt};
|
||||
use solana_sdk::{
|
||||
account::KeyedAccount, bpf_loader_deprecated, entrypoint::MAX_PERMITTED_DATA_INCREASE,
|
||||
instruction::InstructionError, pubkey::Pubkey,
|
||||
bpf_loader_deprecated, entrypoint::MAX_PERMITTED_DATA_INCREASE, instruction::InstructionError,
|
||||
keyed_account::KeyedAccount, pubkey::Pubkey,
|
||||
};
|
||||
use std::{
|
||||
io::prelude::*,
|
||||
|
|
|
@ -16,12 +16,12 @@ use solana_runtime::{
|
|||
};
|
||||
use solana_sdk::{
|
||||
account::Account,
|
||||
account::KeyedAccount,
|
||||
account_info::AccountInfo,
|
||||
bpf_loader, bpf_loader_deprecated,
|
||||
entrypoint::{MAX_PERMITTED_DATA_INCREASE, SUCCESS},
|
||||
hash::{Hasher, HASH_BYTES},
|
||||
instruction::{AccountMeta, Instruction, InstructionError},
|
||||
keyed_account::KeyedAccount,
|
||||
message::Message,
|
||||
program_error::ProgramError,
|
||||
pubkey::{Pubkey, PubkeyError},
|
||||
|
|
|
@ -7,9 +7,9 @@ use crate::{
|
|||
use chrono::prelude::{DateTime, Utc};
|
||||
use log::*;
|
||||
use solana_sdk::{
|
||||
account::{next_keyed_account, KeyedAccount},
|
||||
hash::hash,
|
||||
instruction::InstructionError,
|
||||
keyed_account::{next_keyed_account, KeyedAccount},
|
||||
program_utils::limited_deserialize,
|
||||
pubkey::Pubkey,
|
||||
};
|
||||
|
|
|
@ -3,8 +3,8 @@
|
|||
use crate::ConfigKeys;
|
||||
use bincode::deserialize;
|
||||
use log::*;
|
||||
use solana_sdk::account::{next_keyed_account, KeyedAccount};
|
||||
use solana_sdk::instruction::InstructionError;
|
||||
use solana_sdk::keyed_account::{next_keyed_account, KeyedAccount};
|
||||
use solana_sdk::program_utils::limited_deserialize;
|
||||
use solana_sdk::pubkey::Pubkey;
|
||||
|
||||
|
@ -107,7 +107,8 @@ mod tests {
|
|||
use bincode::serialized_size;
|
||||
use serde_derive::{Deserialize, Serialize};
|
||||
use solana_sdk::{
|
||||
account::{create_keyed_is_signer_accounts, Account},
|
||||
account::Account,
|
||||
keyed_account::create_keyed_is_signer_accounts,
|
||||
signature::{Keypair, Signer},
|
||||
system_instruction::SystemInstruction,
|
||||
};
|
||||
|
|
|
@ -8,7 +8,7 @@ use num_derive::{FromPrimitive, ToPrimitive};
|
|||
use serde_derive::Serialize;
|
||||
use solana_metrics::inc_new_counter_info;
|
||||
use solana_sdk::{
|
||||
account::KeyedAccount, decode_error::DecodeError, instruction::InstructionError,
|
||||
decode_error::DecodeError, instruction::InstructionError, keyed_account::KeyedAccount,
|
||||
program_utils::limited_deserialize, pubkey::Pubkey,
|
||||
};
|
||||
use std::cmp;
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
use solana_sdk::account::KeyedAccount;
|
||||
use solana_sdk::instruction::InstructionError;
|
||||
use solana_sdk::keyed_account::KeyedAccount;
|
||||
use solana_sdk::pubkey::Pubkey;
|
||||
|
||||
solana_sdk::declare_program!(
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
use log::*;
|
||||
use solana_sdk::account::KeyedAccount;
|
||||
use solana_sdk::instruction::InstructionError;
|
||||
use solana_sdk::keyed_account::KeyedAccount;
|
||||
use solana_sdk::pubkey::Pubkey;
|
||||
|
||||
solana_sdk::declare_program!(
|
||||
|
|
|
@ -3,8 +3,8 @@
|
|||
use crate::ownable_instruction::OwnableError;
|
||||
use bincode::serialize_into;
|
||||
use solana_sdk::{
|
||||
account::{next_keyed_account, KeyedAccount},
|
||||
instruction::InstructionError,
|
||||
keyed_account::{next_keyed_account, KeyedAccount},
|
||||
program_utils::limited_deserialize,
|
||||
pubkey::Pubkey,
|
||||
};
|
||||
|
|
|
@ -1,7 +1,7 @@
|
|||
use solana_sdk::pubkey::Pubkey;
|
||||
use solana_sdk::{
|
||||
account::KeyedAccount,
|
||||
instruction::{Instruction, InstructionError},
|
||||
keyed_account::KeyedAccount,
|
||||
};
|
||||
|
||||
pub fn process_instruction(
|
||||
|
|
|
@ -4,9 +4,8 @@ use bincode::{deserialize, serialized_size};
|
|||
use serde_derive::{Deserialize, Serialize};
|
||||
use solana_config_program::{create_config_account, get_config_data, ConfigState};
|
||||
use solana_sdk::{
|
||||
account::{Account, KeyedAccount},
|
||||
genesis_config::GenesisConfig,
|
||||
instruction::InstructionError,
|
||||
account::Account, genesis_config::GenesisConfig, instruction::InstructionError,
|
||||
keyed_account::KeyedAccount,
|
||||
};
|
||||
|
||||
// stake config ID
|
||||
|
|
|
@ -6,14 +6,14 @@ use log::*;
|
|||
use num_derive::{FromPrimitive, ToPrimitive};
|
||||
use serde_derive::{Deserialize, Serialize};
|
||||
use solana_sdk::{
|
||||
account::{get_signers, next_keyed_account, KeyedAccount},
|
||||
clock::{Epoch, UnixTimestamp},
|
||||
decode_error::DecodeError,
|
||||
instruction::{AccountMeta, Instruction, InstructionError},
|
||||
keyed_account::{from_keyed_account, get_signers, next_keyed_account, KeyedAccount},
|
||||
program_utils::limited_deserialize,
|
||||
pubkey::Pubkey,
|
||||
system_instruction,
|
||||
sysvar::{self, clock::Clock, rent::Rent, stake_history::StakeHistory, Sysvar},
|
||||
sysvar::{self, clock::Clock, rent::Rent, stake_history::StakeHistory},
|
||||
};
|
||||
use thiserror::Error;
|
||||
|
||||
|
@ -459,7 +459,7 @@ pub fn process_instruction(
|
|||
StakeInstruction::Initialize(authorized, lockup) => me.initialize(
|
||||
&authorized,
|
||||
&lockup,
|
||||
&Rent::from_keyed_account(next_keyed_account(keyed_accounts)?)?,
|
||||
&from_keyed_account::<Rent>(next_keyed_account(keyed_accounts)?)?,
|
||||
),
|
||||
StakeInstruction::Authorize(authorized_pubkey, stake_authorize) => {
|
||||
me.authorize(&signers, &authorized_pubkey, stake_authorize)
|
||||
|
@ -479,8 +479,8 @@ pub fn process_instruction(
|
|||
|
||||
me.delegate(
|
||||
&vote,
|
||||
&Clock::from_keyed_account(next_keyed_account(keyed_accounts)?)?,
|
||||
&StakeHistory::from_keyed_account(next_keyed_account(keyed_accounts)?)?,
|
||||
&from_keyed_account::<Clock>(next_keyed_account(keyed_accounts)?)?,
|
||||
&from_keyed_account::<StakeHistory>(next_keyed_account(keyed_accounts)?)?,
|
||||
&config::from_keyed_account(next_keyed_account(keyed_accounts)?)?,
|
||||
&signers,
|
||||
)
|
||||
|
@ -493,8 +493,8 @@ pub fn process_instruction(
|
|||
let source_stake = &next_keyed_account(keyed_accounts)?;
|
||||
me.merge(
|
||||
source_stake,
|
||||
&Clock::from_keyed_account(next_keyed_account(keyed_accounts)?)?,
|
||||
&StakeHistory::from_keyed_account(next_keyed_account(keyed_accounts)?)?,
|
||||
&from_keyed_account::<Clock>(next_keyed_account(keyed_accounts)?)?,
|
||||
&from_keyed_account::<StakeHistory>(next_keyed_account(keyed_accounts)?)?,
|
||||
&signers,
|
||||
)
|
||||
}
|
||||
|
@ -504,14 +504,14 @@ pub fn process_instruction(
|
|||
me.withdraw(
|
||||
lamports,
|
||||
to,
|
||||
&Clock::from_keyed_account(next_keyed_account(keyed_accounts)?)?,
|
||||
&StakeHistory::from_keyed_account(next_keyed_account(keyed_accounts)?)?,
|
||||
&from_keyed_account::<Clock>(next_keyed_account(keyed_accounts)?)?,
|
||||
&from_keyed_account::<StakeHistory>(next_keyed_account(keyed_accounts)?)?,
|
||||
next_keyed_account(keyed_accounts)?,
|
||||
keyed_accounts.next(),
|
||||
)
|
||||
}
|
||||
StakeInstruction::Deactivate => me.deactivate(
|
||||
&Clock::from_keyed_account(next_keyed_account(keyed_accounts)?)?,
|
||||
&from_keyed_account::<Clock>(next_keyed_account(keyed_accounts)?)?,
|
||||
&signers,
|
||||
),
|
||||
|
||||
|
@ -523,7 +523,11 @@ pub fn process_instruction(
|
|||
mod tests {
|
||||
use super::*;
|
||||
use bincode::serialize;
|
||||
use solana_sdk::{account::Account, rent::Rent, sysvar::stake_history::StakeHistory};
|
||||
use solana_sdk::{
|
||||
account::Account,
|
||||
rent::Rent,
|
||||
sysvar::{stake_history::StakeHistory, Sysvar},
|
||||
};
|
||||
use std::cell::RefCell;
|
||||
|
||||
fn create_default_account() -> RefCell<Account> {
|
||||
|
|
|
@ -10,10 +10,11 @@ use crate::{
|
|||
};
|
||||
use serde_derive::{Deserialize, Serialize};
|
||||
use solana_sdk::{
|
||||
account::{Account, KeyedAccount},
|
||||
account::Account,
|
||||
account_utils::{State, StateMut},
|
||||
clock::{Clock, Epoch, UnixTimestamp},
|
||||
instruction::InstructionError,
|
||||
keyed_account::KeyedAccount,
|
||||
pubkey::Pubkey,
|
||||
rent::Rent,
|
||||
stake_history::{StakeHistory, StakeHistoryEntry},
|
||||
|
|
|
@ -7,8 +7,9 @@ use chrono::prelude::*;
|
|||
use solana_config_program::date_instruction::DateConfig;
|
||||
use solana_config_program::get_config_data;
|
||||
use solana_sdk::{
|
||||
account::{next_keyed_account, Account, KeyedAccount},
|
||||
account::Account,
|
||||
instruction::InstructionError,
|
||||
keyed_account::{next_keyed_account, KeyedAccount},
|
||||
program_utils::limited_deserialize,
|
||||
pubkey::Pubkey,
|
||||
};
|
||||
|
|
|
@ -10,14 +10,14 @@ use num_derive::{FromPrimitive, ToPrimitive};
|
|||
use serde_derive::{Deserialize, Serialize};
|
||||
use solana_metrics::inc_new_counter_info;
|
||||
use solana_sdk::{
|
||||
account::{get_signers, next_keyed_account, KeyedAccount},
|
||||
decode_error::DecodeError,
|
||||
hash::Hash,
|
||||
instruction::{AccountMeta, Instruction, InstructionError},
|
||||
keyed_account::{from_keyed_account, get_signers, next_keyed_account, KeyedAccount},
|
||||
program_utils::limited_deserialize,
|
||||
pubkey::Pubkey,
|
||||
system_instruction,
|
||||
sysvar::{self, clock::Clock, slot_hashes::SlotHashes, Sysvar},
|
||||
sysvar::{self, clock::Clock, slot_hashes::SlotHashes},
|
||||
};
|
||||
use std::collections::HashSet;
|
||||
use thiserror::Error;
|
||||
|
@ -261,6 +261,18 @@ pub fn withdraw(
|
|||
Instruction::new(id(), &VoteInstruction::Withdraw(lamports), account_metas)
|
||||
}
|
||||
|
||||
fn verify_rent_exemption(
|
||||
keyed_account: &KeyedAccount,
|
||||
rent_sysvar_account: &KeyedAccount,
|
||||
) -> Result<(), InstructionError> {
|
||||
let rent: sysvar::rent::Rent = from_keyed_account(rent_sysvar_account)?;
|
||||
if !rent.is_exempt(keyed_account.lamports()?, keyed_account.data_len()?) {
|
||||
Err(InstructionError::InsufficientFunds)
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
pub fn process_instruction(
|
||||
_program_id: &Pubkey,
|
||||
keyed_accounts: &[KeyedAccount],
|
||||
|
@ -276,12 +288,12 @@ pub fn process_instruction(
|
|||
|
||||
match limited_deserialize(data)? {
|
||||
VoteInstruction::InitializeAccount(vote_init) => {
|
||||
sysvar::rent::verify_rent_exemption(me, next_keyed_account(keyed_accounts)?)?;
|
||||
verify_rent_exemption(me, next_keyed_account(keyed_accounts)?)?;
|
||||
vote_state::initialize_account(
|
||||
me,
|
||||
&vote_init,
|
||||
&signers,
|
||||
&Clock::from_keyed_account(next_keyed_account(keyed_accounts)?)?,
|
||||
&from_keyed_account::<Clock>(next_keyed_account(keyed_accounts)?)?,
|
||||
)
|
||||
}
|
||||
VoteInstruction::Authorize(voter_pubkey, vote_authorize) => vote_state::authorize(
|
||||
|
@ -289,7 +301,7 @@ pub fn process_instruction(
|
|||
&voter_pubkey,
|
||||
vote_authorize,
|
||||
&signers,
|
||||
&Clock::from_keyed_account(next_keyed_account(keyed_accounts)?)?,
|
||||
&from_keyed_account::<Clock>(next_keyed_account(keyed_accounts)?)?,
|
||||
),
|
||||
VoteInstruction::UpdateValidatorIdentity => vote_state::update_validator_identity(
|
||||
me,
|
||||
|
@ -303,8 +315,8 @@ pub fn process_instruction(
|
|||
inc_new_counter_info!("vote-native", 1);
|
||||
vote_state::process_vote(
|
||||
me,
|
||||
&SlotHashes::from_keyed_account(next_keyed_account(keyed_accounts)?)?,
|
||||
&Clock::from_keyed_account(next_keyed_account(keyed_accounts)?)?,
|
||||
&from_keyed_account::<SlotHashes>(next_keyed_account(keyed_accounts)?)?,
|
||||
&from_keyed_account::<Clock>(next_keyed_account(keyed_accounts)?)?,
|
||||
&vote,
|
||||
&signers,
|
||||
)
|
||||
|
@ -319,7 +331,7 @@ pub fn process_instruction(
|
|||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use solana_sdk::{account::Account, rent::Rent};
|
||||
use solana_sdk::{account::Account, rent::Rent, sysvar::Sysvar};
|
||||
use std::cell::RefCell;
|
||||
|
||||
// these are for 100% coverage in this file
|
||||
|
|
|
@ -6,12 +6,13 @@ use bincode::{deserialize, serialize_into, serialized_size, ErrorKind};
|
|||
use log::*;
|
||||
use serde_derive::{Deserialize, Serialize};
|
||||
use solana_sdk::{
|
||||
account::{Account, KeyedAccount},
|
||||
account::Account,
|
||||
account_utils::State,
|
||||
clock::{Epoch, Slot, UnixTimestamp},
|
||||
epoch_schedule::MAX_LEADER_SCHEDULE_EPOCH_OFFSET,
|
||||
hash::Hash,
|
||||
instruction::InstructionError,
|
||||
keyed_account::KeyedAccount,
|
||||
pubkey::Pubkey,
|
||||
rent::Rent,
|
||||
slot_hashes::SlotHash,
|
||||
|
@ -759,9 +760,10 @@ mod tests {
|
|||
use super::*;
|
||||
use crate::vote_state;
|
||||
use solana_sdk::{
|
||||
account::{get_signers, next_keyed_account, Account},
|
||||
account::Account,
|
||||
account_utils::StateMut,
|
||||
hash::hash,
|
||||
keyed_account::{get_signers, next_keyed_account},
|
||||
};
|
||||
use std::cell::RefCell;
|
||||
|
||||
|
|
|
@ -5,12 +5,12 @@ extern crate test;
|
|||
use log::*;
|
||||
use solana_runtime::{bank::*, bank_client::BankClient, loader_utils::create_invoke_instruction};
|
||||
use solana_sdk::{
|
||||
account::KeyedAccount,
|
||||
client::AsyncClient,
|
||||
client::SyncClient,
|
||||
clock::MAX_RECENT_BLOCKHASHES,
|
||||
genesis_config::create_genesis_config,
|
||||
instruction::InstructionError,
|
||||
keyed_account::KeyedAccount,
|
||||
message::Message,
|
||||
pubkey::Pubkey,
|
||||
signature::{Keypair, Signer},
|
||||
|
|
|
@ -4118,12 +4118,12 @@ mod tests {
|
|||
status_cache::MAX_CACHE_ENTRIES,
|
||||
};
|
||||
use solana_sdk::{
|
||||
account::KeyedAccount,
|
||||
account_utils::StateMut,
|
||||
clock::{DEFAULT_SLOTS_PER_EPOCH, DEFAULT_TICKS_PER_SLOT},
|
||||
epoch_schedule::MINIMUM_SLOTS_PER_EPOCH,
|
||||
genesis_config::create_genesis_config,
|
||||
instruction::{AccountMeta, CompiledInstruction, Instruction, InstructionError},
|
||||
keyed_account::KeyedAccount,
|
||||
message::{Message, MessageHeader},
|
||||
nonce,
|
||||
poh_config::PohConfig,
|
||||
|
|
|
@ -12,9 +12,10 @@ use crate::{
|
|||
use log::*;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use solana_sdk::{
|
||||
account::{create_keyed_readonly_accounts, Account, KeyedAccount},
|
||||
account::Account,
|
||||
clock::Epoch,
|
||||
instruction::{CompiledInstruction, Instruction, InstructionError},
|
||||
keyed_account::{create_keyed_readonly_accounts, KeyedAccount},
|
||||
message::Message,
|
||||
native_loader,
|
||||
pubkey::Pubkey,
|
||||
|
|
|
@ -7,10 +7,10 @@ use libloading::os::windows::*;
|
|||
use log::*;
|
||||
use num_derive::{FromPrimitive, ToPrimitive};
|
||||
use solana_sdk::{
|
||||
account::{next_keyed_account, KeyedAccount},
|
||||
decode_error::DecodeError,
|
||||
entrypoint_native::ProgramEntrypoint,
|
||||
instruction::InstructionError,
|
||||
keyed_account::{next_keyed_account, KeyedAccount},
|
||||
pubkey::Pubkey,
|
||||
};
|
||||
use std::{collections::HashMap, env, path::PathBuf, str, sync::RwLock};
|
||||
|
|
|
@ -3,8 +3,9 @@ use crate::feature_set::{
|
|||
pubkey_log_syscall_enabled, FeatureSet,
|
||||
};
|
||||
use solana_sdk::{
|
||||
account::{Account, KeyedAccount},
|
||||
account::Account,
|
||||
instruction::{CompiledInstruction, Instruction, InstructionError},
|
||||
keyed_account::KeyedAccount,
|
||||
message::Message,
|
||||
pubkey::Pubkey,
|
||||
};
|
||||
|
|
|
@ -1,14 +1,16 @@
|
|||
use log::*;
|
||||
use solana_sdk::{
|
||||
account::{get_signers, next_keyed_account, Account, KeyedAccount},
|
||||
account::Account,
|
||||
account_utils::StateMut,
|
||||
instruction::InstructionError,
|
||||
nonce::{self, Account as NonceAccount},
|
||||
keyed_account::{from_keyed_account, get_signers, next_keyed_account, KeyedAccount},
|
||||
nonce,
|
||||
nonce_keyed_account::NonceKeyedAccount,
|
||||
program_utils::limited_deserialize,
|
||||
pubkey::Pubkey,
|
||||
system_instruction::{SystemError, SystemInstruction, MAX_PERMITTED_DATA_LENGTH},
|
||||
system_program,
|
||||
sysvar::{self, recent_blockhashes::RecentBlockhashes, rent::Rent, Sysvar},
|
||||
sysvar::{self, recent_blockhashes::RecentBlockhashes, rent::Rent},
|
||||
};
|
||||
use std::collections::HashSet;
|
||||
|
||||
|
@ -267,7 +269,7 @@ pub fn process_instruction(
|
|||
SystemInstruction::AdvanceNonceAccount => {
|
||||
let me = &mut next_keyed_account(keyed_accounts_iter)?;
|
||||
me.advance_nonce_account(
|
||||
&RecentBlockhashes::from_keyed_account(next_keyed_account(keyed_accounts_iter)?)?,
|
||||
&from_keyed_account::<RecentBlockhashes>(next_keyed_account(keyed_accounts_iter)?)?,
|
||||
&signers,
|
||||
)
|
||||
}
|
||||
|
@ -277,8 +279,8 @@ pub fn process_instruction(
|
|||
me.withdraw_nonce_account(
|
||||
lamports,
|
||||
to,
|
||||
&RecentBlockhashes::from_keyed_account(next_keyed_account(keyed_accounts_iter)?)?,
|
||||
&Rent::from_keyed_account(next_keyed_account(keyed_accounts_iter)?)?,
|
||||
&from_keyed_account::<RecentBlockhashes>(next_keyed_account(keyed_accounts_iter)?)?,
|
||||
&from_keyed_account::<Rent>(next_keyed_account(keyed_accounts_iter)?)?,
|
||||
&signers,
|
||||
)
|
||||
}
|
||||
|
@ -286,8 +288,8 @@ pub fn process_instruction(
|
|||
let me = &mut next_keyed_account(keyed_accounts_iter)?;
|
||||
me.initialize_nonce_account(
|
||||
&authorized,
|
||||
&RecentBlockhashes::from_keyed_account(next_keyed_account(keyed_accounts_iter)?)?,
|
||||
&Rent::from_keyed_account(next_keyed_account(keyed_accounts_iter)?)?,
|
||||
&from_keyed_account::<RecentBlockhashes>(next_keyed_account(keyed_accounts_iter)?)?,
|
||||
&from_keyed_account::<Rent>(next_keyed_account(keyed_accounts_iter)?)?,
|
||||
)
|
||||
}
|
||||
SystemInstruction::AuthorizeNonceAccount(nonce_authority) => {
|
||||
|
|
|
@ -1,10 +1,5 @@
|
|||
use crate::{clock::Epoch, instruction::InstructionError, pubkey::Pubkey};
|
||||
use std::{
|
||||
cell::{Ref, RefCell, RefMut},
|
||||
cmp, fmt,
|
||||
iter::FromIterator,
|
||||
rc::Rc,
|
||||
};
|
||||
use crate::{clock::Epoch, pubkey::Pubkey};
|
||||
use std::{cell::RefCell, cmp, fmt, rc::Rc};
|
||||
|
||||
/// An Account with data that is stored on chain
|
||||
#[repr(C)]
|
||||
|
@ -114,189 +109,3 @@ impl Account {
|
|||
bincode::serialize_into(&mut self.data[..], state)
|
||||
}
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Debug)]
|
||||
pub struct KeyedAccount<'a> {
|
||||
is_signer: bool, // Transaction was signed by this account's key
|
||||
is_writable: bool,
|
||||
key: &'a Pubkey,
|
||||
pub account: &'a RefCell<Account>,
|
||||
}
|
||||
|
||||
impl<'a> KeyedAccount<'a> {
|
||||
pub fn signer_key(&self) -> Option<&Pubkey> {
|
||||
if self.is_signer {
|
||||
Some(self.key)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
pub fn unsigned_key(&self) -> &Pubkey {
|
||||
self.key
|
||||
}
|
||||
|
||||
pub fn is_writable(&self) -> bool {
|
||||
self.is_writable
|
||||
}
|
||||
|
||||
pub fn lamports(&self) -> Result<u64, InstructionError> {
|
||||
Ok(self.try_borrow()?.lamports)
|
||||
}
|
||||
|
||||
pub fn data_len(&self) -> Result<usize, InstructionError> {
|
||||
Ok(self.try_borrow()?.data.len())
|
||||
}
|
||||
|
||||
pub fn data_is_empty(&self) -> Result<bool, InstructionError> {
|
||||
Ok(self.try_borrow()?.data.is_empty())
|
||||
}
|
||||
|
||||
pub fn owner(&self) -> Result<Pubkey, InstructionError> {
|
||||
Ok(self.try_borrow()?.owner)
|
||||
}
|
||||
|
||||
pub fn executable(&self) -> Result<bool, InstructionError> {
|
||||
Ok(self.try_borrow()?.executable)
|
||||
}
|
||||
|
||||
pub fn rent_epoch(&self) -> Result<Epoch, InstructionError> {
|
||||
Ok(self.try_borrow()?.rent_epoch)
|
||||
}
|
||||
|
||||
pub fn try_account_ref(&'a self) -> Result<Ref<Account>, InstructionError> {
|
||||
self.try_borrow()
|
||||
}
|
||||
|
||||
pub fn try_account_ref_mut(&'a self) -> Result<RefMut<Account>, InstructionError> {
|
||||
self.try_borrow_mut()
|
||||
}
|
||||
|
||||
fn try_borrow(&self) -> Result<Ref<Account>, InstructionError> {
|
||||
self.account
|
||||
.try_borrow()
|
||||
.map_err(|_| InstructionError::AccountBorrowFailed)
|
||||
}
|
||||
fn try_borrow_mut(&self) -> Result<RefMut<Account>, InstructionError> {
|
||||
self.account
|
||||
.try_borrow_mut()
|
||||
.map_err(|_| InstructionError::AccountBorrowFailed)
|
||||
}
|
||||
|
||||
pub fn new(key: &'a Pubkey, is_signer: bool, account: &'a RefCell<Account>) -> Self {
|
||||
Self {
|
||||
is_signer,
|
||||
is_writable: true,
|
||||
key,
|
||||
account,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn new_readonly(key: &'a Pubkey, is_signer: bool, account: &'a RefCell<Account>) -> Self {
|
||||
Self {
|
||||
is_signer,
|
||||
is_writable: false,
|
||||
key,
|
||||
account,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> PartialEq for KeyedAccount<'a> {
|
||||
fn eq(&self, other: &Self) -> bool {
|
||||
self.key == other.key
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> From<(&'a Pubkey, &'a RefCell<Account>)> for KeyedAccount<'a> {
|
||||
fn from((key, account): (&'a Pubkey, &'a RefCell<Account>)) -> Self {
|
||||
Self {
|
||||
is_signer: false,
|
||||
is_writable: true,
|
||||
key,
|
||||
account,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> From<(&'a Pubkey, bool, &'a RefCell<Account>)> for KeyedAccount<'a> {
|
||||
fn from((key, is_signer, account): (&'a Pubkey, bool, &'a RefCell<Account>)) -> Self {
|
||||
Self {
|
||||
is_signer,
|
||||
is_writable: true,
|
||||
key,
|
||||
account,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> From<&'a (&'a Pubkey, &'a RefCell<Account>)> for KeyedAccount<'a> {
|
||||
fn from((key, account): &'a (&'a Pubkey, &'a RefCell<Account>)) -> Self {
|
||||
Self {
|
||||
is_signer: false,
|
||||
is_writable: true,
|
||||
key,
|
||||
account,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn create_keyed_accounts<'a>(
|
||||
accounts: &'a [(&'a Pubkey, &'a RefCell<Account>)],
|
||||
) -> Vec<KeyedAccount<'a>> {
|
||||
accounts.iter().map(Into::into).collect()
|
||||
}
|
||||
|
||||
pub fn create_keyed_is_signer_accounts<'a>(
|
||||
accounts: &'a [(&'a Pubkey, bool, &'a RefCell<Account>)],
|
||||
) -> Vec<KeyedAccount<'a>> {
|
||||
accounts
|
||||
.iter()
|
||||
.map(|(key, is_signer, account)| KeyedAccount {
|
||||
is_signer: *is_signer,
|
||||
is_writable: false,
|
||||
key,
|
||||
account,
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
pub fn create_keyed_readonly_accounts(
|
||||
accounts: &[(Pubkey, RefCell<Account>)],
|
||||
) -> Vec<KeyedAccount> {
|
||||
accounts
|
||||
.iter()
|
||||
.map(|(key, account)| KeyedAccount {
|
||||
is_signer: false,
|
||||
is_writable: false,
|
||||
key,
|
||||
account,
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Return all the signers from a set of KeyedAccounts
|
||||
pub fn get_signers<A>(keyed_accounts: &[KeyedAccount]) -> A
|
||||
where
|
||||
A: FromIterator<Pubkey>,
|
||||
{
|
||||
keyed_accounts
|
||||
.iter()
|
||||
.filter_map(|keyed_account| keyed_account.signer_key())
|
||||
.cloned()
|
||||
.collect::<A>()
|
||||
}
|
||||
|
||||
/// Return the next KeyedAccount or a NotEnoughAccountKeys error
|
||||
pub fn next_keyed_account<'a, 'b, I: Iterator<Item = &'a KeyedAccount<'b>>>(
|
||||
iter: &mut I,
|
||||
) -> Result<I::Item, InstructionError> {
|
||||
iter.next().ok_or(InstructionError::NotEnoughAccountKeys)
|
||||
}
|
||||
|
||||
/// Return true if the first keyed_account is executable, used to determine if
|
||||
/// the loader should call a program's 'main'
|
||||
pub fn is_executable(keyed_accounts: &[KeyedAccount]) -> Result<bool, InstructionError> {
|
||||
Ok(!keyed_accounts.is_empty() && keyed_accounts[0].executable()?)
|
||||
}
|
||||
|
|
|
@ -1,8 +1,5 @@
|
|||
//! useful extras for Account state
|
||||
use crate::{
|
||||
account::{Account, KeyedAccount},
|
||||
instruction::InstructionError,
|
||||
};
|
||||
use crate::{account::Account, instruction::InstructionError};
|
||||
use bincode::ErrorKind;
|
||||
|
||||
/// Convenience trait to covert bincode errors to instruction errors.
|
||||
|
@ -31,18 +28,6 @@ where
|
|||
}
|
||||
}
|
||||
|
||||
impl<'a, T> State<T> for KeyedAccount<'a>
|
||||
where
|
||||
T: serde::Serialize + serde::de::DeserializeOwned,
|
||||
{
|
||||
fn state(&self) -> Result<T, InstructionError> {
|
||||
self.try_account_ref()?.state()
|
||||
}
|
||||
fn set_state(&self, state: &T) -> Result<(), InstructionError> {
|
||||
self.try_account_ref_mut()?.set_state(state)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
|
|
@ -1,5 +1,18 @@
|
|||
pub mod account;
|
||||
pub use account::{create_account, Account};
|
||||
pub mod state;
|
||||
pub use state::State;
|
||||
pub mod utils;
|
||||
pub use state::State;
|
||||
|
||||
use crate::{account, nonce::state::Versions};
|
||||
use std::cell::RefCell;
|
||||
|
||||
pub fn create_account(lamports: u64) -> RefCell<account::Account> {
|
||||
RefCell::new(
|
||||
account::Account::new_data_with_space(
|
||||
lamports,
|
||||
&Versions::new_current(State::Uninitialized),
|
||||
State::size(),
|
||||
&crate::system_program::id(),
|
||||
)
|
||||
.expect("nonce_account"),
|
||||
)
|
||||
}
|
||||
|
|
|
@ -22,65 +22,3 @@ pub fn fee_calculator_of(account: &Account) -> Option<FeeCalculator> {
|
|||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::{
|
||||
account_utils::State as AccountUtilsState,
|
||||
hash::Hash,
|
||||
nonce::{account::with_test_keyed_account, Account as NonceAccount, State},
|
||||
sysvar::{recent_blockhashes::create_test_recent_blockhashes, rent::Rent},
|
||||
};
|
||||
use std::collections::HashSet;
|
||||
|
||||
#[test]
|
||||
fn verify_nonce_ok() {
|
||||
with_test_keyed_account(42, true, |nonce_account| {
|
||||
let mut signers = HashSet::new();
|
||||
signers.insert(nonce_account.signer_key().unwrap());
|
||||
let state: State = nonce_account.state().unwrap();
|
||||
// New is in Uninitialzed state
|
||||
assert_eq!(state, State::Uninitialized);
|
||||
let recent_blockhashes = create_test_recent_blockhashes(0);
|
||||
let authorized = nonce_account.unsigned_key();
|
||||
nonce_account
|
||||
.initialize_nonce_account(&authorized, &recent_blockhashes, &Rent::free())
|
||||
.unwrap();
|
||||
assert!(verify_nonce_account(
|
||||
&nonce_account.account.borrow(),
|
||||
&recent_blockhashes[0].blockhash,
|
||||
));
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn verify_nonce_bad_acc_state_fail() {
|
||||
with_test_keyed_account(42, true, |nonce_account| {
|
||||
assert!(!verify_nonce_account(
|
||||
&nonce_account.account.borrow(),
|
||||
&Hash::default()
|
||||
));
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn verify_nonce_bad_query_hash_fail() {
|
||||
with_test_keyed_account(42, true, |nonce_account| {
|
||||
let mut signers = HashSet::new();
|
||||
signers.insert(nonce_account.signer_key().unwrap());
|
||||
let state: State = nonce_account.state().unwrap();
|
||||
// New is in Uninitialzed state
|
||||
assert_eq!(state, State::Uninitialized);
|
||||
let recent_blockhashes = create_test_recent_blockhashes(0);
|
||||
let authorized = nonce_account.unsigned_key();
|
||||
nonce_account
|
||||
.initialize_nonce_account(&authorized, &recent_blockhashes, &Rent::free())
|
||||
.unwrap();
|
||||
assert!(!verify_nonce_account(
|
||||
&nonce_account.account.borrow(),
|
||||
&recent_blockhashes[1].blockhash,
|
||||
));
|
||||
});
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1,11 +1,7 @@
|
|||
//! named accounts for synthesized data accounts for bank state, etc.
|
||||
//!
|
||||
use crate::{
|
||||
account::{Account, KeyedAccount},
|
||||
account_info::AccountInfo,
|
||||
instruction::InstructionError,
|
||||
program_error::ProgramError,
|
||||
pubkey::Pubkey,
|
||||
account::Account, account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey,
|
||||
};
|
||||
|
||||
pub mod clock;
|
||||
|
@ -79,13 +75,6 @@ pub trait Sysvar:
|
|||
fn to_account_info(&self, account_info: &mut AccountInfo) -> Option<()> {
|
||||
bincode::serialize_into(&mut account_info.data.borrow_mut()[..], self).ok()
|
||||
}
|
||||
fn from_keyed_account(keyed_account: &KeyedAccount) -> Result<Self, InstructionError> {
|
||||
if !Self::check_id(keyed_account.unsigned_key()) {
|
||||
return Err(InstructionError::InvalidArgument);
|
||||
}
|
||||
Self::from_account(&*keyed_account.try_account_ref()?)
|
||||
.ok_or(InstructionError::InvalidArgument)
|
||||
}
|
||||
fn create_account(&self, lamports: u64) -> Account {
|
||||
let data_len = Self::size_of().max(bincode::serialized_size(self).unwrap() as usize);
|
||||
let mut account = Account::new(lamports, data_len, &id());
|
||||
|
|
|
@ -2,11 +2,7 @@
|
|||
//!
|
||||
pub use crate::rent::Rent;
|
||||
|
||||
use crate::{
|
||||
account::{Account, KeyedAccount},
|
||||
instruction::InstructionError,
|
||||
sysvar::Sysvar,
|
||||
};
|
||||
use crate::{account::Account, sysvar::Sysvar};
|
||||
|
||||
crate::declare_sysvar_id!("SysvarRent111111111111111111111111111111111", Rent);
|
||||
|
||||
|
@ -16,18 +12,6 @@ pub fn create_account(lamports: u64, rent: &Rent) -> Account {
|
|||
rent.create_account(lamports)
|
||||
}
|
||||
|
||||
pub fn verify_rent_exemption(
|
||||
keyed_account: &KeyedAccount,
|
||||
rent_sysvar_account: &KeyedAccount,
|
||||
) -> Result<(), InstructionError> {
|
||||
let rent = Rent::from_keyed_account(rent_sysvar_account)?;
|
||||
if !rent.is_exempt(keyed_account.lamports()?, keyed_account.data_len()?) {
|
||||
Err(InstructionError::InsufficientFunds)
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
|
|
@ -73,7 +73,7 @@ macro_rules! declare_builtin_name {
|
|||
/// // wrapper is used so that the macro invocation occurs in the item position
|
||||
/// // rather than in the statement position which isn't allowed.
|
||||
/// mod item_wrapper {
|
||||
/// use solana_sdk::account::KeyedAccount;
|
||||
/// use solana_sdk::keyed_account::KeyedAccount;
|
||||
/// use solana_sdk::instruction::InstructionError;
|
||||
/// use solana_sdk::pubkey::Pubkey;
|
||||
/// use solana_sdk::declare_builtin;
|
||||
|
@ -104,7 +104,7 @@ macro_rules! declare_builtin_name {
|
|||
/// # // wrapper is used so that the macro invocation occurs in the item position
|
||||
/// # // rather than in the statement position which isn't allowed.
|
||||
/// # mod item_wrapper {
|
||||
/// use solana_sdk::account::KeyedAccount;
|
||||
/// use solana_sdk::keyed_account::KeyedAccount;
|
||||
/// use solana_sdk::instruction::InstructionError;
|
||||
/// use solana_sdk::pubkey::Pubkey;
|
||||
/// use solana_sdk::declare_builtin;
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
//! @brief Solana Native program entry point
|
||||
|
||||
use crate::{account::KeyedAccount, instruction::InstructionError, pubkey::Pubkey};
|
||||
use crate::{instruction::InstructionError, keyed_account::KeyedAccount, pubkey::Pubkey};
|
||||
|
||||
// Prototype of a native program entry point
|
||||
///
|
||||
|
@ -86,7 +86,7 @@ macro_rules! declare_name {
|
|||
/// # // wrapper is used so that the macro invocation occurs in the item position
|
||||
/// # // rather than in the statement position which isn't allowed.
|
||||
/// # mod item_wrapper {
|
||||
/// use solana_sdk::account::KeyedAccount;
|
||||
/// use solana_sdk::keyed_account::KeyedAccount;
|
||||
/// use solana_sdk::instruction::InstructionError;
|
||||
/// use solana_sdk::pubkey::Pubkey;
|
||||
/// use solana_sdk::declare_program;
|
||||
|
@ -117,7 +117,7 @@ macro_rules! declare_name {
|
|||
/// # // wrapper is used so that the macro invocation occurs in the item position
|
||||
/// # // rather than in the statement position which isn't allowed.
|
||||
/// # mod item_wrapper {
|
||||
/// use solana_sdk::account::KeyedAccount;
|
||||
/// use solana_sdk::keyed_account::KeyedAccount;
|
||||
/// use solana_sdk::instruction::InstructionError;
|
||||
/// use solana_sdk::pubkey::Pubkey;
|
||||
/// use solana_sdk::declare_program;
|
||||
|
@ -150,7 +150,7 @@ macro_rules! declare_program(
|
|||
#[no_mangle]
|
||||
pub extern "C" fn $name(
|
||||
program_id: &$crate::pubkey::Pubkey,
|
||||
keyed_accounts: &[$crate::account::KeyedAccount],
|
||||
keyed_accounts: &[$crate::keyed_account::KeyedAccount],
|
||||
instruction_data: &[u8],
|
||||
) -> Result<(), $crate::instruction::InstructionError> {
|
||||
$entrypoint(program_id, keyed_accounts, instruction_data)
|
||||
|
|
|
@ -0,0 +1,219 @@
|
|||
use solana_program::{
|
||||
account::Account,
|
||||
account_utils::{State, StateMut},
|
||||
clock::Epoch,
|
||||
instruction::InstructionError,
|
||||
pubkey::Pubkey,
|
||||
sysvar::Sysvar,
|
||||
};
|
||||
use std::{
|
||||
cell::{Ref, RefCell, RefMut},
|
||||
iter::FromIterator,
|
||||
};
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Debug)]
|
||||
pub struct KeyedAccount<'a> {
|
||||
is_signer: bool, // Transaction was signed by this account's key
|
||||
is_writable: bool,
|
||||
key: &'a Pubkey,
|
||||
pub account: &'a RefCell<Account>,
|
||||
}
|
||||
|
||||
impl<'a> KeyedAccount<'a> {
|
||||
pub fn signer_key(&self) -> Option<&Pubkey> {
|
||||
if self.is_signer {
|
||||
Some(self.key)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
pub fn unsigned_key(&self) -> &Pubkey {
|
||||
self.key
|
||||
}
|
||||
|
||||
pub fn is_writable(&self) -> bool {
|
||||
self.is_writable
|
||||
}
|
||||
|
||||
pub fn lamports(&self) -> Result<u64, InstructionError> {
|
||||
Ok(self.try_borrow()?.lamports)
|
||||
}
|
||||
|
||||
pub fn data_len(&self) -> Result<usize, InstructionError> {
|
||||
Ok(self.try_borrow()?.data.len())
|
||||
}
|
||||
|
||||
pub fn data_is_empty(&self) -> Result<bool, InstructionError> {
|
||||
Ok(self.try_borrow()?.data.is_empty())
|
||||
}
|
||||
|
||||
pub fn owner(&self) -> Result<Pubkey, InstructionError> {
|
||||
Ok(self.try_borrow()?.owner)
|
||||
}
|
||||
|
||||
pub fn executable(&self) -> Result<bool, InstructionError> {
|
||||
Ok(self.try_borrow()?.executable)
|
||||
}
|
||||
|
||||
pub fn rent_epoch(&self) -> Result<Epoch, InstructionError> {
|
||||
Ok(self.try_borrow()?.rent_epoch)
|
||||
}
|
||||
|
||||
pub fn try_account_ref(&'a self) -> Result<Ref<Account>, InstructionError> {
|
||||
self.try_borrow()
|
||||
}
|
||||
|
||||
pub fn try_account_ref_mut(&'a self) -> Result<RefMut<Account>, InstructionError> {
|
||||
self.try_borrow_mut()
|
||||
}
|
||||
|
||||
fn try_borrow(&self) -> Result<Ref<Account>, InstructionError> {
|
||||
self.account
|
||||
.try_borrow()
|
||||
.map_err(|_| InstructionError::AccountBorrowFailed)
|
||||
}
|
||||
fn try_borrow_mut(&self) -> Result<RefMut<Account>, InstructionError> {
|
||||
self.account
|
||||
.try_borrow_mut()
|
||||
.map_err(|_| InstructionError::AccountBorrowFailed)
|
||||
}
|
||||
|
||||
pub fn new(key: &'a Pubkey, is_signer: bool, account: &'a RefCell<Account>) -> Self {
|
||||
Self {
|
||||
is_signer,
|
||||
is_writable: true,
|
||||
key,
|
||||
account,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn new_readonly(key: &'a Pubkey, is_signer: bool, account: &'a RefCell<Account>) -> Self {
|
||||
Self {
|
||||
is_signer,
|
||||
is_writable: false,
|
||||
key,
|
||||
account,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> PartialEq for KeyedAccount<'a> {
|
||||
fn eq(&self, other: &Self) -> bool {
|
||||
self.key == other.key
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> From<(&'a Pubkey, &'a RefCell<Account>)> for KeyedAccount<'a> {
|
||||
fn from((key, account): (&'a Pubkey, &'a RefCell<Account>)) -> Self {
|
||||
Self {
|
||||
is_signer: false,
|
||||
is_writable: true,
|
||||
key,
|
||||
account,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> From<(&'a Pubkey, bool, &'a RefCell<Account>)> for KeyedAccount<'a> {
|
||||
fn from((key, is_signer, account): (&'a Pubkey, bool, &'a RefCell<Account>)) -> Self {
|
||||
Self {
|
||||
is_signer,
|
||||
is_writable: true,
|
||||
key,
|
||||
account,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> From<&'a (&'a Pubkey, &'a RefCell<Account>)> for KeyedAccount<'a> {
|
||||
fn from((key, account): &'a (&'a Pubkey, &'a RefCell<Account>)) -> Self {
|
||||
Self {
|
||||
is_signer: false,
|
||||
is_writable: true,
|
||||
key,
|
||||
account,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn create_keyed_accounts<'a>(
|
||||
accounts: &'a [(&'a Pubkey, &'a RefCell<Account>)],
|
||||
) -> Vec<KeyedAccount<'a>> {
|
||||
accounts.iter().map(Into::into).collect()
|
||||
}
|
||||
|
||||
pub fn create_keyed_is_signer_accounts<'a>(
|
||||
accounts: &'a [(&'a Pubkey, bool, &'a RefCell<Account>)],
|
||||
) -> Vec<KeyedAccount<'a>> {
|
||||
accounts
|
||||
.iter()
|
||||
.map(|(key, is_signer, account)| KeyedAccount {
|
||||
is_signer: *is_signer,
|
||||
is_writable: false,
|
||||
key,
|
||||
account,
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
pub fn create_keyed_readonly_accounts(
|
||||
accounts: &[(Pubkey, RefCell<Account>)],
|
||||
) -> Vec<KeyedAccount> {
|
||||
accounts
|
||||
.iter()
|
||||
.map(|(key, account)| KeyedAccount {
|
||||
is_signer: false,
|
||||
is_writable: false,
|
||||
key,
|
||||
account,
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Return all the signers from a set of KeyedAccounts
|
||||
pub fn get_signers<A>(keyed_accounts: &[KeyedAccount]) -> A
|
||||
where
|
||||
A: FromIterator<Pubkey>,
|
||||
{
|
||||
keyed_accounts
|
||||
.iter()
|
||||
.filter_map(|keyed_account| keyed_account.signer_key())
|
||||
.cloned()
|
||||
.collect::<A>()
|
||||
}
|
||||
|
||||
/// Return the next KeyedAccount or a NotEnoughAccountKeys error
|
||||
pub fn next_keyed_account<'a, 'b, I: Iterator<Item = &'a KeyedAccount<'b>>>(
|
||||
iter: &mut I,
|
||||
) -> Result<I::Item, InstructionError> {
|
||||
iter.next().ok_or(InstructionError::NotEnoughAccountKeys)
|
||||
}
|
||||
|
||||
/// Return true if the first keyed_account is executable, used to determine if
|
||||
/// the loader should call a program's 'main'
|
||||
pub fn is_executable(keyed_accounts: &[KeyedAccount]) -> Result<bool, InstructionError> {
|
||||
Ok(!keyed_accounts.is_empty() && keyed_accounts[0].executable()?)
|
||||
}
|
||||
|
||||
impl<'a, T> State<T> for crate::keyed_account::KeyedAccount<'a>
|
||||
where
|
||||
T: serde::Serialize + serde::de::DeserializeOwned,
|
||||
{
|
||||
fn state(&self) -> Result<T, InstructionError> {
|
||||
self.try_account_ref()?.state()
|
||||
}
|
||||
fn set_state(&self, state: &T) -> Result<(), InstructionError> {
|
||||
self.try_account_ref_mut()?.set_state(state)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn from_keyed_account<S: Sysvar>(
|
||||
keyed_account: &crate::keyed_account::KeyedAccount,
|
||||
) -> Result<S, InstructionError> {
|
||||
if !S::check_id(keyed_account.unsigned_key()) {
|
||||
return Err(InstructionError::InvalidArgument);
|
||||
}
|
||||
S::from_account(&*keyed_account.try_account_ref()?).ok_or(InstructionError::InvalidArgument)
|
||||
}
|
|
@ -18,8 +18,10 @@ pub mod genesis_config;
|
|||
pub mod hard_forks;
|
||||
pub mod hash;
|
||||
pub mod inflation;
|
||||
pub mod keyed_account;
|
||||
pub mod log;
|
||||
pub mod native_loader;
|
||||
pub mod nonce_keyed_account;
|
||||
pub mod packet;
|
||||
pub mod poh_config;
|
||||
pub mod program_utils;
|
||||
|
|
|
@ -1,16 +1,15 @@
|
|||
use crate::{
|
||||
account::{self, KeyedAccount},
|
||||
use crate::keyed_account::KeyedAccount;
|
||||
use solana_program::{
|
||||
account_utils::State as AccountUtilsState,
|
||||
instruction::InstructionError,
|
||||
nonce::{self, state::Versions, State},
|
||||
pubkey::Pubkey,
|
||||
system_instruction::NonceError,
|
||||
system_program,
|
||||
sysvar::{recent_blockhashes::RecentBlockhashes, rent::Rent},
|
||||
};
|
||||
use std::{cell::RefCell, collections::HashSet};
|
||||
use std::collections::HashSet;
|
||||
|
||||
pub trait Account {
|
||||
pub trait NonceKeyedAccount {
|
||||
fn advance_nonce_account(
|
||||
&self,
|
||||
recent_blockhashes: &RecentBlockhashes,
|
||||
|
@ -37,7 +36,7 @@ pub trait Account {
|
|||
) -> Result<(), InstructionError>;
|
||||
}
|
||||
|
||||
impl<'a> Account for KeyedAccount<'a> {
|
||||
impl<'a> NonceKeyedAccount for KeyedAccount<'a> {
|
||||
fn advance_nonce_account(
|
||||
&self,
|
||||
recent_blockhashes: &RecentBlockhashes,
|
||||
|
@ -157,25 +156,13 @@ impl<'a> Account for KeyedAccount<'a> {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn create_account(lamports: u64) -> RefCell<account::Account> {
|
||||
RefCell::new(
|
||||
account::Account::new_data_with_space(
|
||||
lamports,
|
||||
&Versions::new_current(State::Uninitialized),
|
||||
State::size(),
|
||||
&system_program::id(),
|
||||
)
|
||||
.expect("nonce_account"),
|
||||
)
|
||||
}
|
||||
|
||||
/// Convenience function for working with keyed accounts in tests
|
||||
pub fn with_test_keyed_account<F>(lamports: u64, signer: bool, f: F)
|
||||
where
|
||||
F: Fn(&KeyedAccount),
|
||||
{
|
||||
let pubkey = Pubkey::new_unique();
|
||||
let account = create_account(lamports);
|
||||
let account = solana_program::nonce::create_account(lamports);
|
||||
let keyed_account = KeyedAccount::new(&pubkey, signer, &account);
|
||||
f(&keyed_account)
|
||||
}
|
||||
|
@ -184,12 +171,13 @@ where
|
|||
mod test {
|
||||
use super::*;
|
||||
use crate::{
|
||||
account::KeyedAccount,
|
||||
account_utils::State as AccountUtilsState,
|
||||
keyed_account::KeyedAccount,
|
||||
nonce::{self, State},
|
||||
system_instruction::NonceError,
|
||||
sysvar::recent_blockhashes::{create_test_recent_blockhashes, RecentBlockhashes},
|
||||
};
|
||||
use solana_program::{hash::Hash, nonce::utils::verify_nonce_account};
|
||||
use std::iter::FromIterator;
|
||||
|
||||
#[test]
|
||||
|
@ -881,4 +869,54 @@ mod test {
|
|||
assert_eq!(result, Err(InstructionError::MissingRequiredSignature));
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn verify_nonce_ok() {
|
||||
with_test_keyed_account(42, true, |nonce_account| {
|
||||
let mut signers = HashSet::new();
|
||||
signers.insert(nonce_account.signer_key().unwrap());
|
||||
let state: State = nonce_account.state().unwrap();
|
||||
// New is in Uninitialzed state
|
||||
assert_eq!(state, State::Uninitialized);
|
||||
let recent_blockhashes = create_test_recent_blockhashes(0);
|
||||
let authorized = nonce_account.unsigned_key();
|
||||
nonce_account
|
||||
.initialize_nonce_account(&authorized, &recent_blockhashes, &Rent::free())
|
||||
.unwrap();
|
||||
assert!(verify_nonce_account(
|
||||
&nonce_account.account.borrow(),
|
||||
&recent_blockhashes[0].blockhash,
|
||||
));
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn verify_nonce_bad_acc_state_fail() {
|
||||
with_test_keyed_account(42, true, |nonce_account| {
|
||||
assert!(!verify_nonce_account(
|
||||
&nonce_account.account.borrow(),
|
||||
&Hash::default()
|
||||
));
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn verify_nonce_bad_query_hash_fail() {
|
||||
with_test_keyed_account(42, true, |nonce_account| {
|
||||
let mut signers = HashSet::new();
|
||||
signers.insert(nonce_account.signer_key().unwrap());
|
||||
let state: State = nonce_account.state().unwrap();
|
||||
// New is in Uninitialzed state
|
||||
assert_eq!(state, State::Uninitialized);
|
||||
let recent_blockhashes = create_test_recent_blockhashes(0);
|
||||
let authorized = nonce_account.unsigned_key();
|
||||
nonce_account
|
||||
.initialize_nonce_account(&authorized, &recent_blockhashes, &Rent::free())
|
||||
.unwrap();
|
||||
assert!(!verify_nonce_account(
|
||||
&nonce_account.account.borrow(),
|
||||
&recent_blockhashes[1].blockhash,
|
||||
));
|
||||
});
|
||||
}
|
||||
}
|
Loading…
Reference in New Issue