blockworks-foundation
/
solana-program-library
mirror of https://github.com/blockworks-foundation/solana-program-library.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Reboot program address derivation helpers

This commit is contained in:
Michael Vines 2021-03-31 22:24:35 -07:00
parent 8b989d562b
commit 48ab307cad
7 changed files with 143 additions and 178 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
stake-pool/cli/src/client.rs
View File

@ -79,9 +79,9 @@ pub(crate) fn get_stake_state(
Ok(stake_state)
}
pub(crate) fn get_stake_accounts_by_withdrawer(
pub(crate) fn get_stake_accounts_by_withdraw_authority(
rpc_client: &RpcClient,
withdrawer: &Pubkey,
withdraw_authority: &Pubkey,
) -> Result<Vec<(Pubkey, u64, stake_program::StakeState)>, ClientError> {
rpc_client
.get_program_accounts_with_config(
@ -89,7 +89,7 @@ pub(crate) fn get_stake_accounts_by_withdrawer(
RpcProgramAccountsConfig {
filters: Some(vec![RpcFilterType::Memcmp(Memcmp {
offset: 44, // 44 is Withdrawer authority offset in stake account stake
bytes: MemcmpEncodedBytes::Binary(format!("{}", withdrawer)),
bytes: MemcmpEncodedBytes::Binary(format!("{}", withdraw_authority)),
encoding: None,
})]),
account_config: RpcAccountInfoConfig {

176
stake-pool/cli/src/main.rs
View File

@ -28,10 +28,10 @@ use {
spl_stake_pool::{
self,
borsh::get_instance_packed_len,
create_pool_authority_address, find_authority_bump_seed, find_stake_address_for_validator,
find_deposit_authority_program_address, find_stake_program_address,
find_withdraw_authority_program_address,
stake_program::{self, StakeAuthorize, StakeState},
state::{StakePool, ValidatorList},
AUTHORITY_DEPOSIT, AUTHORITY_WITHDRAW,
},
std::process::exit,
};
@ -133,11 +133,8 @@ fn command_create_pool(
let default_decimals = spl_token::native_mint::DECIMALS;
// Calculate withdraw authority used for minting pool tokens
let (withdraw_authority, _) = find_authority_bump_seed(
&spl_stake_pool::id(),
&pool_account.pubkey(),
AUTHORITY_WITHDRAW,
);
let (withdraw_authority, _) =
find_withdraw_authority_program_address(&spl_stake_pool::id(), &pool_account.pubkey());
if config.verbose {
println!("Stake pool withdraw authority {}", withdraw_authority);
@ -227,9 +224,13 @@ fn command_create_pool(
Ok(())
}
fn command_vsa_create(config: &Config, pool: &Pubkey, vote_account: &Pubkey) -> CommandResult {
fn command_vsa_create(
config: &Config,
stake_pool_address: &Pubkey,
vote_account: &Pubkey,
) -> CommandResult {
let (stake_account, _) =
find_stake_address_for_validator(&spl_stake_pool::id(), &vote_account, &pool);
find_stake_program_address(&spl_stake_pool::id(), &vote_account, &stake_pool_address);
println!("Creating stake account {}", stake_account);
@ -238,7 +239,7 @@ fn command_vsa_create(config: &Config, pool: &Pubkey, vote_account: &Pubkey) ->
// Create new validator stake account address
spl_stake_pool::instruction::create_validator_stake_account(
&spl_stake_pool::id(),
&pool,
&stake_pool_address,
&config.owner.pubkey(),
&config.fee_payer.pubkey(),
&stake_account,
@ -260,7 +261,7 @@ fn command_vsa_create(config: &Config, pool: &Pubkey, vote_account: &Pubkey) ->
fn command_vsa_add(
config: &Config,
pool: &Pubkey,
stake_pool_address: &Pubkey,
stake: &Pubkey,
token_receiver: &Option<Pubkey>,
) -> CommandResult {
@ -269,10 +270,10 @@ fn command_vsa_add(
}
if !config.no_update {
command_update(config, pool)?;
command_update(config, stake_pool_address)?;
}
let stake_pool = get_stake_pool(&config.rpc_client, pool)?;
let stake_pool = get_stake_pool(&config.rpc_client, stake_pool_address)?;
let mut total_rent_free_balances: u64 = 0;
@ -295,20 +296,11 @@ fn command_vsa_add(
)?;
// Calculate Deposit and Withdraw stake pool authorities
let pool_deposit_authority: Pubkey = create_pool_authority_address(
&spl_stake_pool::id(),
pool,
AUTHORITY_DEPOSIT,
stake_pool.deposit_bump_seed,
)
.unwrap();
let pool_withdraw_authority: Pubkey = create_pool_authority_address(
&spl_stake_pool::id(),
pool,
AUTHORITY_WITHDRAW,
stake_pool.withdraw_bump_seed,
)
.unwrap();
let pool_deposit_authority =
find_deposit_authority_program_address(&spl_stake_pool::id(), stake_pool_address).0;
let pool_withdraw_authority =
find_withdraw_authority_program_address(&spl_stake_pool::id(), stake_pool_address).0;
instructions.extend(vec![
// Set Withdrawer on stake account to Deposit authority of the stake pool
@ -328,7 +320,7 @@ fn command_vsa_add(
// Add validator stake account to the pool
spl_stake_pool::instruction::add_validator_to_pool(
&spl_stake_pool::id(),
&pool,
&stake_pool_address,
&config.owner.pubkey(),
&pool_deposit_authority,
&pool_withdraw_authority,
@ -356,23 +348,18 @@ fn command_vsa_add(
fn command_vsa_remove(
config: &Config,
pool: &Pubkey,
stake_pool_address: &Pubkey,
stake: &Pubkey,
withdraw_from: &Pubkey,
new_authority: &Option<Pubkey>,
) -> CommandResult {
if !config.no_update {
command_update(config, pool)?;
command_update(config, stake_pool_address)?;
}
let stake_pool = get_stake_pool(&config.rpc_client, pool)?;
let pool_withdraw_authority: Pubkey = create_pool_authority_address(
&spl_stake_pool::id(),
pool,
AUTHORITY_WITHDRAW,
stake_pool.withdraw_bump_seed,
)
.unwrap();
let stake_pool = get_stake_pool(&config.rpc_client, stake_pool_address)?;
let pool_withdraw_authority =
find_withdraw_authority_program_address(&spl_stake_pool::id(), stake_pool_address).0;
let owner_pubkey = config.owner.pubkey();
let new_authority = new_authority.as_ref().unwrap_or(&owner_pubkey);
@ -409,7 +396,7 @@ fn command_vsa_remove(
// Create new validator stake account address
spl_stake_pool::instruction::remove_validator_from_pool(
&spl_stake_pool::id(),
&pool,
&stake_pool_address,
&config.owner.pubkey(),
&pool_withdraw_authority,
&new_authority,
@ -482,21 +469,21 @@ where
fn command_deposit(
config: &Config,
pool: &Pubkey,
stake_pool_address: &Pubkey,
stake: &Pubkey,
token_receiver: &Option<Pubkey>,
) -> CommandResult {
if !config.no_update {
command_update(config, pool)?;
command_update(config, stake_pool_address)?;
}
let stake_pool = get_stake_pool(&config.rpc_client, pool)?;
let stake_pool = get_stake_pool(&config.rpc_client, stake_pool_address)?;
let stake_state = get_stake_state(&config.rpc_client, &stake)?;
if config.verbose {
println!("Depositing stake account {:?}", stake_state);
}
let vote_account: Pubkey = match stake_state {
let vote_account = match stake_state {
StakeState::Stake(_, stake) => Ok(stake.delegation.voter_pubkey),
_ => Err("Wrong stake account state, must be delegated to validator"),
}?;
@ -509,7 +496,7 @@ fn command_deposit(
// Calculate validator stake account address linked to the pool
let (validator_stake_account, _) =
find_stake_address_for_validator(&spl_stake_pool::id(), &vote_account, pool);
find_stake_program_address(&spl_stake_pool::id(), &vote_account, stake_pool_address);
let validator_stake_state = get_stake_state(&config.rpc_client, &validator_stake_account)?;
println!("Depositing into stake account {}", validator_stake_account);
@ -538,20 +525,11 @@ fn command_deposit(
)?;
// Calculate Deposit and Withdraw stake pool authorities
let pool_deposit_authority: Pubkey = create_pool_authority_address(
&spl_stake_pool::id(),
pool,
AUTHORITY_DEPOSIT,
stake_pool.deposit_bump_seed,
)
.unwrap();
let pool_withdraw_authority: Pubkey = create_pool_authority_address(
&spl_stake_pool::id(),
pool,
AUTHORITY_WITHDRAW,
stake_pool.withdraw_bump_seed,
)
.unwrap();
let pool_deposit_authority =
find_deposit_authority_program_address(&spl_stake_pool::id(), stake_pool_address).0;
let pool_withdraw_authority =
find_withdraw_authority_program_address(&spl_stake_pool::id(), stake_pool_address).0;
instructions.extend(vec![
// Set Withdrawer on stake account to Deposit authority of the stake pool
@ -571,7 +549,7 @@ fn command_deposit(
// Add stake account to the pool
spl_stake_pool::instruction::deposit(
&spl_stake_pool::id(),
&pool,
&stake_pool_address,
&stake_pool.validator_list,
&pool_deposit_authority,
&pool_withdraw_authority,
@ -598,8 +576,8 @@ fn command_deposit(
Ok(())
}
fn command_list(config: &Config, pool: &Pubkey) -> CommandResult {
let stake_pool = get_stake_pool(&config.rpc_client, pool)?;
fn command_list(config: &Config, stake_pool_address: &Pubkey) -> CommandResult {
let stake_pool = get_stake_pool(&config.rpc_client, stake_pool_address)?;
if config.verbose {
println!("Current validator list");
@ -612,15 +590,11 @@ fn command_list(config: &Config, pool: &Pubkey) -> CommandResult {
}
}
let pool_withdraw_authority: Pubkey = create_pool_authority_address(
&spl_stake_pool::id(),
pool,
AUTHORITY_WITHDRAW,
stake_pool.withdraw_bump_seed,
)
.unwrap();
let pool_withdraw_authority =
find_withdraw_authority_program_address(&spl_stake_pool::id(), stake_pool_address).0;
let accounts = get_stake_accounts_by_withdrawer(&config.rpc_client, &pool_withdraw_authority)?;
let accounts =
get_stake_accounts_by_withdraw_authority(&config.rpc_client, &pool_withdraw_authority)?;
if accounts.is_empty() {
return Err("No accounts found.".to_string().into());
}
@ -640,8 +614,8 @@ fn command_list(config: &Config, pool: &Pubkey) -> CommandResult {
Ok(())
}
fn command_update(config: &Config, pool: &Pubkey) -> CommandResult {
let stake_pool = get_stake_pool(&config.rpc_client, pool)?;
fn command_update(config: &Config, stake_pool_address: &Pubkey) -> CommandResult {
let stake_pool = get_stake_pool(&config.rpc_client, stake_pool_address)?;
let validator_list = get_validator_list(&config.rpc_client, &stake_pool.validator_list)?;
let epoch_info = config.rpc_client.get_epoch_info()?;
@ -652,10 +626,10 @@ fn command_update(config: &Config, pool: &Pubkey) -> CommandResult {
if item.last_update_epoch >= epoch_info.epoch {
None
} else {
let (stake_account, _) = find_stake_address_for_validator(
let (stake_account, _) = find_stake_program_address(
&spl_stake_pool::id(),
&item.vote_account,
&pool,
&stake_pool_address,
);
Some(stake_account)
}
@ -679,7 +653,7 @@ fn command_update(config: &Config, pool: &Pubkey) -> CommandResult {
println!("Updating stake pool...");
instructions.push(spl_stake_pool::instruction::update_stake_pool_balance(
&spl_stake_pool::id(),
pool,
stake_pool_address,
&stake_pool.validator_list,
)?);
@ -706,7 +680,8 @@ fn prepare_withdraw_accounts(
pool_withdraw_authority: &Pubkey,
pool_amount: u64,
) -> Result<Vec<WithdrawAccount>, Error> {
let mut accounts = get_stake_accounts_by_withdrawer(rpc_client, &pool_withdraw_authority)?;
let mut accounts =
get_stake_accounts_by_withdraw_authority(rpc_client, &pool_withdraw_authority)?;
if accounts.is_empty() {
return Err("No accounts found.".to_string().into());
}
@ -756,26 +731,21 @@ fn prepare_withdraw_accounts(
fn command_withdraw(
config: &Config,
pool: &Pubkey,
stake_pool_address: &Pubkey,
pool_amount: f64,
withdraw_from: &Pubkey,
stake_receiver_param: &Option<Pubkey>,
) -> CommandResult {
if !config.no_update {
command_update(config, pool)?;
command_update(config, stake_pool_address)?;
}
let stake_pool = get_stake_pool(&config.rpc_client, pool)?;
let stake_pool = get_stake_pool(&config.rpc_client, stake_pool_address)?;
let pool_mint = get_token_mint(&config.rpc_client, &stake_pool.pool_mint)?;
let pool_amount = spl_token::ui_amount_to_amount(pool_amount, pool_mint.decimals);
let pool_withdraw_authority: Pubkey = create_pool_authority_address(
&spl_stake_pool::id(),
pool,
AUTHORITY_WITHDRAW,
stake_pool.withdraw_bump_seed,
)
.unwrap();
let pool_withdraw_authority =
find_withdraw_authority_program_address(&spl_stake_pool::id(), stake_pool_address).0;
// Check withdraw_from account type
let token_account =
@ -866,7 +836,7 @@ fn command_withdraw(
instructions.push(spl_stake_pool::instruction::withdraw(
&spl_stake_pool::id(),
&pool,
&stake_pool_address,
&stake_pool.validator_list,
&pool_withdraw_authority,
&withdraw_account.address,
@ -895,11 +865,11 @@ fn command_withdraw(
fn command_set_owner(
config: &Config,
pool: &Pubkey,
stake_pool_address: &Pubkey,
new_owner: &Option<Pubkey>,
new_fee_receiver: &Option<Pubkey>,
) -> CommandResult {
let stake_pool = get_stake_pool(&config.rpc_client, pool)?;
let stake_pool = get_stake_pool(&config.rpc_client, stake_pool_address)?;
// If new accounts are missing in the arguments use the old ones
let new_owner = match new_owner {
@ -924,7 +894,7 @@ fn command_set_owner(
let mut transaction = Transaction::new_with_payer(
&[spl_stake_pool::instruction::set_owner(
&spl_stake_pool::id(),
&pool,
&stake_pool_address,
&config.owner.pubkey(),
&new_owner,
&new_fee_receiver,
@ -1327,20 +1297,20 @@ fn main() {
)
}
("create-validator-stake", Some(arg_matches)) => {
let pool_account: Pubkey = pubkey_of(arg_matches, "pool").unwrap();
let vote_account: Pubkey = pubkey_of(arg_matches, "vote_account").unwrap();
let pool_account = pubkey_of(arg_matches, "pool").unwrap();
let vote_account = pubkey_of(arg_matches, "vote_account").unwrap();
command_vsa_create(&config, &pool_account, &vote_account)
}
("add-validator", Some(arg_matches)) => {
let pool_account: Pubkey = pubkey_of(arg_matches, "pool").unwrap();
let stake_account: Pubkey = pubkey_of(arg_matches, "stake_account").unwrap();
let pool_account = pubkey_of(arg_matches, "pool").unwrap();
let stake_account = pubkey_of(arg_matches, "stake_account").unwrap();
let token_receiver: Option<Pubkey> = pubkey_of(arg_matches, "token_receiver");
command_vsa_add(&config, &pool_account, &stake_account, &token_receiver)
}
("remove-validator", Some(arg_matches)) => {
let pool_account: Pubkey = pubkey_of(arg_matches, "pool").unwrap();
let stake_account: Pubkey = pubkey_of(arg_matches, "stake_account").unwrap();
let withdraw_from: Pubkey = pubkey_of(arg_matches, "withdraw_from").unwrap();
let pool_account = pubkey_of(arg_matches, "pool").unwrap();
let stake_account = pubkey_of(arg_matches, "stake_account").unwrap();
let withdraw_from = pubkey_of(arg_matches, "withdraw_from").unwrap();
let new_authority: Option<Pubkey> = pubkey_of(arg_matches, "new_authority");
command_vsa_remove(
&config,
@ -1351,22 +1321,22 @@ fn main() {
)
}
("deposit", Some(arg_matches)) => {
let pool_account: Pubkey = pubkey_of(arg_matches, "pool").unwrap();
let stake_account: Pubkey = pubkey_of(arg_matches, "stake_account").unwrap();
let pool_account = pubkey_of(arg_matches, "pool").unwrap();
let stake_account = pubkey_of(arg_matches, "stake_account").unwrap();
let token_receiver: Option<Pubkey> = pubkey_of(arg_matches, "token_receiver");
command_deposit(&config, &pool_account, &stake_account, &token_receiver)
}
("list", Some(arg_matches)) => {
let pool_account: Pubkey = pubkey_of(arg_matches, "pool").unwrap();
let pool_account = pubkey_of(arg_matches, "pool").unwrap();
command_list(&config, &pool_account)
}
("update", Some(arg_matches)) => {
let pool_account: Pubkey = pubkey_of(arg_matches, "pool").unwrap();
let pool_account = pubkey_of(arg_matches, "pool").unwrap();
command_update(&config, &pool_account)
}
("withdraw", Some(arg_matches)) => {
let pool_account: Pubkey = pubkey_of(arg_matches, "pool").unwrap();
let withdraw_from: Pubkey = pubkey_of(arg_matches, "withdraw_from").unwrap();
let pool_account = pubkey_of(arg_matches, "pool").unwrap();
let withdraw_from = pubkey_of(arg_matches, "withdraw_from").unwrap();
let pool_amount = value_t_or_exit!(arg_matches, "amount", f64);
let stake_receiver: Option<Pubkey> = pubkey_of(arg_matches, "stake_receiver");
command_withdraw(
@ -1378,7 +1348,7 @@ fn main() {
)
}
("set-owner", Some(arg_matches)) => {
let pool_account: Pubkey = pubkey_of(arg_matches, "pool").unwrap();
let pool_account = pubkey_of(arg_matches, "pool").unwrap();
let new_owner: Option<Pubkey> = pubkey_of(arg_matches, "new_owner");
let new_fee_receiver: Option<Pubkey> = pubkey_of(arg_matches, "new_fee_receiver");
command_set_owner(&config, &pool_account, &new_owner, &new_fee_receiver)

65
stake-pool/program/src/lib.rs
View File

@ -1,6 +1,6 @@
#![deny(missing_docs)]
//! A program for creating pools of Solana stakes managed by a Stake-o-Matic
//! A program for creating and managing pools of stake
pub mod borsh;
pub mod error;
@ -14,44 +14,47 @@ pub mod entrypoint;
// Export current sdk types for downstream users building with a different sdk version
pub use solana_program;
use solana_program::{program_error::ProgramError, pubkey::Pubkey};
use solana_program::pubkey::Pubkey;
/// Seed for deposit authority seed
pub const AUTHORITY_DEPOSIT: &[u8] = b"deposit";
const AUTHORITY_DEPOSIT: &[u8] = b"deposit";
/// Seed for withdraw authority seed
pub const AUTHORITY_WITHDRAW: &[u8] = b"withdraw";
const AUTHORITY_WITHDRAW: &[u8] = b"withdraw";
/// Calculates the authority address
pub fn create_pool_authority_address(
/// Generates the deposit authority program address for the stake pool
pub fn find_deposit_authority_program_address(
program_id: &Pubkey,
stake_pool: &Pubkey,
authority: &[u8],
bump_seed: u8,
) -> Result<Pubkey, ProgramError> {
Pubkey::create_program_address(
&[&stake_pool.to_bytes()[..32], authority, &[bump_seed]],
program_id,
)
.map_err(|_| crate::error::StakePoolError::InvalidProgramAddress.into())
}
/// Generates seed bump for stake pool authorities
pub fn find_authority_bump_seed(
program_id: &Pubkey,
stake_pool: &Pubkey,
authority: &[u8],
) -> (Pubkey, u8) {
Pubkey::find_program_address(&[&stake_pool.to_bytes()[..32], authority], program_id)
}
/// Generates stake account address for the validator
pub fn find_stake_address_for_validator(
program_id: &Pubkey,
validator: &Pubkey,
stake_pool: &Pubkey,
stake_pool_address: &Pubkey,
) -> (Pubkey, u8) {
Pubkey::find_program_address(
&[&validator.to_bytes()[..32], &stake_pool.to_bytes()[..32]],
&[&stake_pool_address.to_bytes()[..32], AUTHORITY_DEPOSIT],
program_id,
)
}
/// Generates the withdraw authority program address for the stake pool
pub fn find_withdraw_authority_program_address(
program_id: &Pubkey,
stake_pool_address: &Pubkey,
) -> (Pubkey, u8) {
Pubkey::find_program_address(
&[&stake_pool_address.to_bytes()[..32], AUTHORITY_WITHDRAW],
program_id,
)
}
/// Generates the stake program address for a validator's vote account
pub fn find_stake_program_address(
program_id: &Pubkey,
vote_account_address: &Pubkey,
stake_pool_address: &Pubkey,
) -> (Pubkey, u8) {
Pubkey::find_program_address(
&[
&vote_account_address.to_bytes()[..32],
&stake_pool_address.to_bytes()[..32],
],
program_id,
)
}

9
stake-pool/program/src/processor.rs
View File

@ -4,7 +4,6 @@ use {
crate::{
borsh::try_from_slice_unchecked,
error::StakePoolError,
find_authority_bump_seed, find_stake_address_for_validator,
instruction::{Fee, StakePoolInstruction},
stake_program,
state::{AccountType, StakePool, ValidatorList, ValidatorStakeInfo},
@ -56,7 +55,7 @@ impl Processor {
) -> bool {
// Check stake account address validity
let (stake_address, _) =
find_stake_address_for_validator(&program_id, &vote_account, &stake_pool_info.key);
crate::find_stake_program_address(&program_id, &vote_account, &stake_pool_info.key);
stake_address == *stake_account_info.key
}
@ -295,9 +294,9 @@ impl Processor {
}
let (_, deposit_bump_seed) =
find_authority_bump_seed(program_id, stake_pool_info.key, AUTHORITY_DEPOSIT);
crate::find_deposit_authority_program_address(program_id, stake_pool_info.key);
let (withdraw_authority_key, withdraw_bump_seed) =
find_authority_bump_seed(program_id, stake_pool_info.key, AUTHORITY_WITHDRAW);
crate::find_withdraw_authority_program_address(program_id, stake_pool_info.key);
let pool_mint = Mint::unpack_from_slice(&pool_mint_info.data.borrow())?;
@ -361,7 +360,7 @@ impl Processor {
return Err(ProgramError::IncorrectProgramId);
}
let (stake_address, bump_seed) = find_stake_address_for_validator(
let (stake_address, bump_seed) = crate::find_stake_program_address(
&program_id,
&validator_info.key,
&stake_pool_info.key,

33
stake-pool/program/src/state.rs
View File

@ -99,29 +99,32 @@ impl StakePool {
.ok()
}
/// Checks withdraw or deposit authority
/// Checks that the withdraw or deposit authority is valid
fn check_authority(
authority: &Pubkey,
authority_address: &Pubkey,
program_id: &Pubkey,
stake_pool_address: &Pubkey,
seed: &[u8],
authority_seed: &[u8],
bump_seed: u8,
) -> Result<(), ProgramError> {
if *authority
!= crate::create_pool_authority_address(
if *authority_address
== Pubkey::create_program_address(
&[
&stake_pool_address.to_bytes()[..32],
authority_seed,
&[bump_seed],
],
program_id,
stake_pool_address,
seed,
bump_seed,
)?
{
return Err(StakePoolError::InvalidProgramAddress.into());
Ok(())
} else {
Err(StakePoolError::InvalidProgramAddress.into())
}
Ok(())
}
/// Checks withdraw authority
pub fn check_authority_withdraw(
/// Checks that the withdraw authority is valid
pub(crate) fn check_authority_withdraw(
&self,
withdraw_authority: &Pubkey,
program_id: &Pubkey,
@ -135,8 +138,8 @@ impl StakePool {
self.withdraw_bump_seed,
)
}
/// Checks deposit authority
pub fn check_authority_deposit(
/// Checks that the deposit authority is valid
pub(crate) fn check_authority_deposit(
&self,
deposit_authority: &Pubkey,
program_id: &Pubkey,
@ -152,7 +155,7 @@ impl StakePool {
}
/// Check owner validity and signature
pub fn check_owner(&self, owner_info: &AccountInfo) -> Result<(), ProgramError> {
pub(crate) fn check_owner(&self, owner_info: &AccountInfo) -> Result<(), ProgramError> {
if *owner_info.key != self.owner {
return Err(StakePoolError::WrongOwner.into());
}

7
stake-pool/program/tests/helpers/mod.rs
View File

@ -13,8 +13,8 @@ use {
},
solana_vote_program::{self, vote_state::VoteState},
spl_stake_pool::{
borsh::get_instance_packed_len, find_stake_address_for_validator, id, instruction,
processor, stake_program, state,
borsh::get_instance_packed_len, find_stake_program_address, id, instruction, processor,
stake_program, state,
},
};
@ -376,8 +376,7 @@ pub struct ValidatorStakeAccount {
impl ValidatorStakeAccount {
pub fn new_with_target_authority(authority: &Pubkey, stake_pool: &Pubkey) -> Self {
let validator = Keypair::new();
let (stake_account, _) =
find_stake_address_for_validator(&id(), &validator.pubkey(), stake_pool);
let (stake_account, _) = find_stake_program_address(&id(), &validator.pubkey(), stake_pool);
ValidatorStakeAccount {
stake_account,
target_authority: *authority,

25
stake-pool/program/tests/vsa_create.rs
View File

@ -18,7 +18,7 @@ use {
transaction::TransactionError,
transport::TransportError,
},
spl_stake_pool::{error, find_stake_address_for_validator, id, instruction, stake_program},
spl_stake_pool::{error, find_stake_program_address, id, instruction, stake_program},
};
#[tokio::test]
@ -33,7 +33,7 @@ async fn success_create_validator_stake_account() {
let validator = Keypair::new();
create_vote(&mut banks_client, &payer, &recent_blockhash, &validator).await;
let (stake_account, _) = find_stake_address_for_validator(
let (stake_account, _) = find_stake_program_address(
&id(),
&validator.pubkey(),
&stake_pool_accounts.stake_pool.pubkey(),
@ -81,11 +81,8 @@ async fn fail_create_validator_stake_account_on_non_vote_account() {
let validator = Pubkey::new_unique();
let (stake_account, _) = find_stake_address_for_validator(
&id(),
&validator,
&stake_pool_accounts.stake_pool.pubkey(),
);
let (stake_account, _) =
find_stake_program_address(&id(), &validator, &stake_pool_accounts.stake_pool.pubkey());
let mut transaction = Transaction::new_with_payer(
&[instruction::create_validator_stake_account(
@ -124,11 +121,8 @@ async fn fail_create_validator_stake_account_with_wrong_system_program() {
let validator = Pubkey::new_unique();
let (stake_account, _) = find_stake_address_for_validator(
&id(),
&validator,
&stake_pool_accounts.stake_pool.pubkey(),
);
let (stake_account, _) =
find_stake_program_address(&id(), &validator, &stake_pool_accounts.stake_pool.pubkey());
let wrong_system_program = Pubkey::new_unique();
let accounts = vec![
AccountMeta::new_readonly(stake_pool_accounts.stake_pool.pubkey(), false),
@ -177,11 +171,8 @@ async fn fail_create_validator_stake_account_with_wrong_stake_program() {
let validator = Pubkey::new_unique();
let (stake_account, _) = find_stake_address_for_validator(
&id(),
&validator,
&stake_pool_accounts.stake_pool.pubkey(),
);
let (stake_account, _) =
find_stake_program_address(&id(), &validator, &stake_pool_accounts.stake_pool.pubkey());
let wrong_stake_program = Pubkey::new_unique();
let accounts = vec![
AccountMeta::new_readonly(stake_pool_accounts.stake_pool.pubkey(), false),