blockworks-foundation
/
solana-with-rpc-optimizations
mirror of https://github.com/blockworks-foundation/solana-with-rpc-optimizations.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Boot VoteTransaction

This commit is contained in:
Greg Fitzgerald 2019-03-25 16:08:22 -06:00 committed by Grimes
parent e8814b1297
commit 4bc3f70150
10 changed files with 89 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
core/src/entry.rs
View File

@ -440,7 +440,7 @@ mod tests {
use solana_sdk::hash::hash;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_transaction::SystemTransaction;
use solana_vote_api::vote_transaction::VoteTransaction;
use solana_vote_api::vote_instruction::{Vote, VoteInstruction};
use std::net::{IpAddr, Ipv4Addr, SocketAddr};
fn create_sample_payment(keypair: &Keypair, hash: Hash) -> Transaction {
@ -461,6 +461,12 @@ mod tests {
Transaction::new_signed_instructions(&[keypair], vec![ix], hash, 0)
}
fn create_sample_vote(keypair: &Keypair, hash: Hash) -> Transaction {
let pubkey = keypair.pubkey();
let ix = VoteInstruction::new_vote(&pubkey, Vote::new(1));
Transaction::new_signed_instructions(&[keypair], vec![ix], hash, 0)
}
#[test]
fn test_entry_verify() {
let zero = Hash::default();
@ -564,7 +570,7 @@ mod tests {
let one = hash(&zero.as_ref());
let keypair = Keypair::new();
let vote_account = Keypair::new();
let tx0 = VoteTransaction::new_vote(&vote_account.pubkey(), &vote_account, 1, one, 1);
let tx0 = create_sample_vote(&vote_account, one);
let tx1 = create_sample_timestamp(&keypair, one);
//
// TODO: this magic number and the mix of transaction types
@ -623,8 +629,7 @@ mod tests {
let next_hash = solana_sdk::hash::hash(&hash.as_ref());
let keypair = Keypair::new();
let vote_account = Keypair::new();
let tx_small =
VoteTransaction::new_vote(&vote_account.pubkey(), &vote_account, 1, next_hash, 2);
let tx_small = create_sample_vote(&vote_account, next_hash);
let tx_large = create_sample_payment(&keypair, next_hash);
let tx_small_size = tx_small.serialized_size().unwrap() as usize;

23
core/src/fullnode.rs
View File

@ -27,7 +27,8 @@ use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_transaction::SystemTransaction;
use solana_sdk::timing::timestamp;
use solana_vote_api::vote_transaction::VoteTransaction;
use solana_sdk::transaction::Transaction;
use solana_vote_api::vote_instruction::{Vote, VoteInstruction};
use std::net::{IpAddr, Ipv4Addr, SocketAddr};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::mpsc::Receiver;
@ -325,23 +326,23 @@ pub fn make_active_set_entries(
let voting_keypair = Keypair::new();
let vote_account_id = voting_keypair.pubkey();
let new_vote_account_tx = VoteTransaction::new_account(
active_keypair,
let new_vote_account_ixs = VoteInstruction::new_account(
&active_keypair.pubkey(),
&vote_account_id,
*blockhash,
stake.saturating_sub(2),
);
let new_vote_account_tx = Transaction::new_signed_instructions(
&[active_keypair.as_ref()],
new_vote_account_ixs,
*blockhash,
1,
);
let new_vote_account_entry = next_entry_mut(&mut last_entry_hash, 1, vec![new_vote_account_tx]);
// 3) Create vote entry
let vote_tx = VoteTransaction::new_vote(
&voting_keypair.pubkey(),
&voting_keypair,
slot_to_vote_on,
*blockhash,
0,
);
let vote_ix = VoteInstruction::new_vote(&voting_keypair.pubkey(), Vote::new(slot_to_vote_on));
let vote_tx =
Transaction::new_signed_instructions(&[&voting_keypair], vec![vote_ix], *blockhash, 0);
let vote_entry = next_entry_mut(&mut last_entry_hash, 1, vec![vote_tx]);
// 4) Create `num_ending_ticks` empty ticks

14
core/src/leader_confirmation_service.rs
View File

@ -119,7 +119,8 @@ mod tests {
use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::timing::MAX_RECENT_BLOCKHASHES;
use solana_vote_api::vote_transaction::VoteTransaction;
use solana_sdk::transaction::Transaction;
use solana_vote_api::vote_instruction::{Vote, VoteInstruction};
use std::sync::Arc;
#[test]
@ -177,13 +178,10 @@ mod tests {
// Get another validator to vote, so we now have 2/3 consensus
let voting_keypair = &vote_accounts[7].0;
let vote_tx = VoteTransaction::new_vote(
&voting_keypair.pubkey(),
voting_keypair,
MAX_RECENT_BLOCKHASHES as u64,
blockhash,
0,
);
let vote = Vote::new(MAX_RECENT_BLOCKHASHES as u64);
let vote_ix = VoteInstruction::new_vote(&voting_keypair.pubkey(), vote);
let vote_tx =
Transaction::new_signed_instructions(&[voting_keypair], vec![vote_ix], blockhash, 0);
bank.process_transaction(&vote_tx).unwrap();
LeaderConfirmationService::compute_confirmation(&bank, &mut last_confirmation_time);

23
core/src/local_cluster.rs
View File

@ -14,8 +14,9 @@ use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::system_transaction::SystemTransaction;
use solana_sdk::timing::DEFAULT_SLOTS_PER_EPOCH;
use solana_sdk::timing::DEFAULT_TICKS_PER_SLOT;
use solana_sdk::transaction::Transaction;
use solana_vote_api::vote_instruction::VoteInstruction;
use solana_vote_api::vote_state::VoteState;
use solana_vote_api::vote_transaction::VoteTransaction;
use std::collections::HashMap;
use std::fs::remove_dir_all;
use std::io::{Error, ErrorKind, Result};
@ -295,11 +296,12 @@ impl LocalCluster {
// Create the vote account if necessary
if client.poll_get_balance(&vote_account_pubkey).unwrap_or(0) == 0 {
// 1) Create vote account
let mut transaction = VoteTransaction::new_account(
from_account,
&vote_account_pubkey,
let instructions =
VoteInstruction::new_account(&from_account.pubkey(), &vote_account_pubkey, amount);
let mut transaction = Transaction::new_signed_instructions(
&[from_account.as_ref()],
instructions,
client.get_recent_blockhash().unwrap(),
amount,
1,
);
@ -311,11 +313,14 @@ impl LocalCluster {
.expect("get balance");
// 2) Set delegate for new vote account
let mut transaction = VoteTransaction::delegate_vote_account(
vote_account,
let vote_instruction =
VoteInstruction::new_delegate_stake(&vote_account_pubkey, &delegate_id);
let mut transaction = Transaction::new_signed_instructions(
&[vote_account],
vec![vote_instruction],
client.get_recent_blockhash().unwrap(),
&delegate_id,
0,
1,
);
client

26
core/src/replay_stage.rs
View File

@ -19,7 +19,8 @@ use solana_sdk::hash::Hash;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::KeypairUtil;
use solana_sdk::timing::{self, duration_as_ms};
use solana_vote_api::vote_transaction::VoteTransaction;
use solana_sdk::transaction::Transaction;
use solana_vote_api::vote_instruction::{Vote, VoteInstruction};
use std::collections::HashMap;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::mpsc::{channel, Receiver, RecvTimeoutError, Sender};
@ -297,11 +298,10 @@ impl ReplayStage {
T: 'static + KeypairUtil + Send + Sync,
{
if let Some(ref voting_keypair) = voting_keypair {
let keypair = voting_keypair.as_ref();
let vote = VoteTransaction::new_vote(
&vote_account,
keypair,
bank.slot(),
let vote_ix = VoteInstruction::new_vote(&vote_account, Vote::new(bank.slot()));
let vote_tx = Transaction::new_signed_instructions(
&[voting_keypair.as_ref()],
vec![vote_ix],
bank.last_blockhash(),
0,
);
@ -310,7 +310,7 @@ impl ReplayStage {
Self::handle_new_root(&bank_forks, progress);
}
locktower.update_epoch(&bank);
cluster_info.write().unwrap().push_vote(vote);
cluster_info.write().unwrap().push_vote(vote_tx);
}
}
@ -606,10 +606,14 @@ mod test {
&poh_recorder,
);
let keypair = voting_keypair.as_ref();
let vote =
VoteTransaction::new_vote(&keypair.pubkey(), keypair, 0, bank.last_blockhash(), 0);
cluster_info_me.write().unwrap().push_vote(vote);
let vote_ix = VoteInstruction::new_vote(&voting_keypair.pubkey(), Vote::new(0));
let vote_tx = Transaction::new_signed_instructions(
&[voting_keypair.as_ref()],
vec![vote_ix],
bank.last_blockhash(),
0,
);
cluster_info_me.write().unwrap().push_vote(vote_tx);
info!("Send ReplayStage an entry, should see it on the ledger writer receiver");
let next_tick = create_ticks(1, bank.last_blockhash());

46
core/src/voting_keypair.rs
View File

@ -106,9 +106,17 @@ impl VotingKeypair {
#[cfg(test)]
pub mod tests {
use solana_runtime::bank::Bank;
use solana_sdk::instruction::Instruction;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_vote_api::vote_transaction::VoteTransaction;
use solana_sdk::transaction::Transaction;
use solana_vote_api::vote_instruction::{Vote, VoteInstruction};
fn process_instructions<T: KeypairUtil>(bank: &Bank, keypairs: &[&T], ixs: Vec<Instruction>) {
let blockhash = bank.last_blockhash();
let tx = Transaction::new_signed_instructions(keypairs, ixs, blockhash, 0);
bank.process_transaction(&tx).unwrap();
}
pub fn new_vote_account(
from_keypair: &Keypair,
@ -116,9 +124,8 @@ pub mod tests {
bank: &Bank,
lamports: u64,
) {
let blockhash = bank.last_blockhash();
let tx = VoteTransaction::new_account(from_keypair, voting_pubkey, blockhash, lamports, 0);
bank.process_transaction(&tx).unwrap();
let ixs = VoteInstruction::new_account(&from_keypair.pubkey(), voting_pubkey, lamports);
process_instructions(bank, &[from_keypair], ixs);
}
pub fn new_vote_account_with_delegate(
@ -128,33 +135,32 @@ pub mod tests {
bank: &Bank,
lamports: u64,
) {
let blockhash = bank.last_blockhash();
let tx = VoteTransaction::new_account_with_delegate(
from_keypair,
voting_keypair,
let voting_pubkey = voting_keypair.pubkey();
let mut ixs =
VoteInstruction::new_account(&from_keypair.pubkey(), &voting_pubkey, lamports);
ixs.push(VoteInstruction::new_delegate_stake(
&voting_pubkey,
delegate,
blockhash,
lamports,
0,
);
bank.process_transaction(&tx).unwrap();
));
process_instructions(bank, &[from_keypair, voting_keypair], ixs);
}
pub fn push_vote<T: KeypairUtil>(voting_keypair: &T, bank: &Bank, slot: u64) {
let blockhash = bank.last_blockhash();
let tx =
VoteTransaction::new_vote(&voting_keypair.pubkey(), voting_keypair, slot, blockhash, 0);
bank.process_transaction(&tx).unwrap();
let ix = VoteInstruction::new_vote(&voting_keypair.pubkey(), Vote::new(slot));
process_instructions(bank, &[voting_keypair], vec![ix]);
}
pub fn new_vote_account_with_vote<T: KeypairUtil>(
from_keypair: &Keypair,
from_keypair: &T,
voting_keypair: &T,
bank: &Bank,
lamports: u64,
slot: u64,
) {
new_vote_account(from_keypair, &voting_keypair.pubkey(), bank, lamports);
push_vote(voting_keypair, bank, slot);
let voting_pubkey = voting_keypair.pubkey();
let mut ixs =
VoteInstruction::new_account(&from_keypair.pubkey(), &voting_pubkey, lamports);
ixs.push(VoteInstruction::new_vote(&voting_pubkey, Vote::new(slot)));
process_instructions(bank, &[from_keypair, voting_keypair], ixs);
}
}

1
programs/vote_api/src/lib.rs
View File

@ -1,7 +1,6 @@
pub mod vote_instruction;
pub mod vote_processor;
pub mod vote_state;
pub mod vote_transaction;
use solana_sdk::pubkey::Pubkey;

86
programs/vote_api/src/vote_transaction.rs
View File

@ -1,86 +0,0 @@
//! The `vote_transaction` module provides functionality for creating vote transactions.
use crate::vote_instruction::{Vote, VoteInstruction};
use solana_sdk::hash::Hash;
use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::{Keypair, KeypairUtil};
use solana_sdk::transaction::Transaction;
pub struct VoteTransaction {}
impl VoteTransaction {
pub fn new_vote<T: KeypairUtil>(
staking_account: &Pubkey,
authorized_voter_keypair: &T,
slot: u64,
recent_blockhash: Hash,
fee: u64,
) -> Transaction {
let ix = VoteInstruction::new_vote(staking_account, Vote { slot });
Transaction::new_signed_instructions(
&[authorized_voter_keypair],
vec![ix],
recent_blockhash,
fee,
)
}
/// Fund or create the staking account with lamports
pub fn new_account(
from_keypair: &Keypair,
staker_id: &Pubkey,
recent_blockhash: Hash,
lamports: u64,
fee: u64,
) -> Transaction {
let from_id = from_keypair.pubkey();
let ixs = VoteInstruction::new_account(&from_id, staker_id, lamports);
Transaction::new_signed_instructions(&[from_keypair], ixs, recent_blockhash, fee)
}
/// Fund or create the staking account with lamports
pub fn new_account_with_delegate(
from_keypair: &Keypair,
voter_keypair: &Keypair,
delegate_id: &Pubkey,
recent_blockhash: Hash,
lamports: u64,
fee: u64,
) -> Transaction {
let from_id = from_keypair.pubkey();
let voter_id = voter_keypair.pubkey();
let mut ixs = VoteInstruction::new_account(&from_id, &voter_id, lamports);
let delegate_ix = VoteInstruction::new_delegate_stake(&voter_id, &delegate_id);
ixs.push(delegate_ix);
Transaction::new_signed_instructions(
&[from_keypair, voter_keypair],
ixs,
recent_blockhash,
fee,
)
}
/// Choose a voter id to accept signed votes from
pub fn new_authorize_voter(
vote_keypair: &Keypair,
recent_blockhash: Hash,
authorized_voter_id: &Pubkey,
fee: u64,
) -> Transaction {
let ix = VoteInstruction::new_authorize_voter(&vote_keypair.pubkey(), authorized_voter_id);
Transaction::new_signed_instructions(&[vote_keypair], vec![ix], recent_blockhash, fee)
}
/// Choose a node id to `delegate` or `assign` this vote account to
pub fn delegate_vote_account<T: KeypairUtil>(
vote_keypair: &T,
recent_blockhash: Hash,
node_id: &Pubkey,
fee: u64,
) -> Transaction {
let ix = VoteInstruction::new_delegate_stake(&vote_keypair.pubkey(), node_id);
Transaction::new_signed_instructions(&[vote_keypair], vec![ix], recent_blockhash, fee)
}
}

6
tests/thin_client.rs
View File

@ -11,8 +11,8 @@ use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::{Keypair, KeypairUtil, Signature};
use solana_sdk::system_instruction::SystemInstruction;
use solana_sdk::system_transaction::SystemTransaction;
use solana_vote_api::vote_instruction::VoteInstruction;
use solana_vote_api::vote_state::VoteState;
use solana_vote_api::vote_transaction::VoteTransaction;
use std::fs::remove_dir_all;
use std::net::UdpSocket;
use std::thread::sleep;
@ -124,8 +124,10 @@ fn test_register_vote_account() {
let vote_account_id = validator_vote_account_keypair.pubkey();
let blockhash = client.get_recent_blockhash().unwrap();
let instructions =
VoteInstruction::new_account(&validator_keypair.pubkey(), &vote_account_id, 1);
let transaction =
VoteTransaction::new_account(&validator_keypair, &vote_account_id, blockhash, 1, 1);
Transaction::new_signed_instructions(&[&validator_keypair], instructions, blockhash, 1);
let signature = client.transfer_signed(&transaction).unwrap();
client.poll_for_signature(&signature).unwrap();

8
wallet/src/wallet.rs
View File

@ -21,7 +21,6 @@ use solana_sdk::signature::{Keypair, KeypairUtil, Signature};
use solana_sdk::system_transaction::SystemTransaction;
use solana_sdk::transaction::Transaction;
use solana_vote_api::vote_instruction::VoteInstruction;
use solana_vote_api::vote_transaction::VoteTransaction;
use std::fs::File;
use std::io::Read;
use std::net::{IpAddr, Ipv4Addr, SocketAddr};
@ -345,8 +344,7 @@ fn process_configure_staking(
&authorized_voter_id,
));
}
let mut tx = Transaction::new(ixs);
tx.sign(&[&config.id], recent_blockhash);
let mut tx = Transaction::new_signed_instructions(&[&config.id], ixs, recent_blockhash, 0);
let signature_str = rpc_client.send_and_confirm_transaction(&mut tx, &config.id)?;
Ok(signature_str.to_string())
}
@ -358,8 +356,8 @@ fn process_create_staking(
lamports: u64,
) -> ProcessResult {
let recent_blockhash = rpc_client.get_recent_blockhash()?;
let mut tx =
VoteTransaction::new_account(&config.id, voting_account_id, recent_blockhash, lamports, 0);
let ixs = VoteInstruction::new_account(&config.id.pubkey(), voting_account_id, lamports);
let mut tx = Transaction::new_signed_instructions(&[&config.id], ixs, recent_blockhash, 0);
let signature_str = rpc_client.send_and_confirm_transaction(&mut tx, &config.id)?;
Ok(signature_str.to_string())
}