gaspersic/solana
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Rename Transaction last_id field to recent_block_hash

Browse Source
This commit is contained in:
Michael Vines
2019-03-02 09:17:03 -08:00
committed by Greg Fitzgerald
parent 16b71a6be0
commit 176d5e0d37
14 changed files with 81 additions and 80 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
sdk/src/budget_transaction.rs
View File

@ -20,7 +20,7 @@ impl BudgetTransaction {
from_keypair: &Keypair,
to: Pubkey,
tokens: u64,
last_id: Hash,
recent_block_hash: Hash,
fee: u64,
) -> Transaction {
let contract = Keypair::new().pubkey();
@ -29,13 +29,13 @@ impl BudgetTransaction {
TransactionBuilder::new(fee)
.push(SystemInstruction::new_move(from, contract, tokens))
.push(Instruction::new_budget(contract, payment))
.sign(&[from_keypair], last_id)
.sign(&[from_keypair], recent_block_hash)
}
/// Create and sign a new Transaction. Used for unit-testing.
#[allow(clippy::new_ret_no_self)]
pub fn new(from_keypair: &Keypair, to: Pubkey, tokens: u64, last_id: Hash) -> Transaction {
Self::new_payment(from_keypair, to, tokens, last_id, 0)
pub fn new(from_keypair: &Keypair, to: Pubkey, tokens: u64, recent_block_hash: Hash) -> Transaction {
Self::new_payment(from_keypair, to, tokens, recent_block_hash, 0)
}
/// Create and sign a new Witness Timestamp. Used for unit-testing.
@ -44,7 +44,7 @@ impl BudgetTransaction {
contract: Pubkey,
to: Pubkey,
dt: DateTime<Utc>,
last_id: Hash,
recent_block_hash: Hash,
) -> Transaction {
let instruction = Instruction::ApplyTimestamp(dt);
Transaction::new(
@ -52,7 +52,7 @@ impl BudgetTransaction {
&[contract, to],
budget_program::id(),
&instruction,
last_id,
recent_block_hash,
0,
)
}
@ -62,7 +62,7 @@ impl BudgetTransaction {
from_keypair: &Keypair,
contract: Pubkey,
to: Pubkey,
last_id: Hash,
recent_block_hash: Hash,
) -> Transaction {
let instruction = Instruction::ApplySignature;
let mut keys = vec![contract];
@ -74,7 +74,7 @@ impl BudgetTransaction {
&keys,
budget_program::id(),
&instruction,
last_id,
recent_block_hash,
0,
)
}
@ -88,7 +88,7 @@ impl BudgetTransaction {
dt_pubkey: Pubkey,
cancelable: Option<Pubkey>,
tokens: u64,
last_id: Hash,
recent_block_hash: Hash,
) -> Transaction {
let expr = if let Some(from) = cancelable {
BudgetExpr::Or(
@ -113,7 +113,7 @@ impl BudgetTransaction {
&[contract],
budget_program::id(),
&instruction,
last_id,
recent_block_hash,
0,
)
}
@ -125,7 +125,7 @@ impl BudgetTransaction {
witness: Pubkey,
cancelable: Option<Pubkey>,
tokens: u64,
last_id: Hash,
recent_block_hash: Hash,
) -> Transaction {
let expr = if let Some(from) = cancelable {
BudgetExpr::Or(
@ -150,7 +150,7 @@ impl BudgetTransaction {
&[contract],
budget_program::id(),
&instruction,
last_id,
recent_block_hash,
0,
)
}

8
sdk/src/loader_transaction.rs
View File

@ -14,20 +14,20 @@ impl LoaderTransaction {
loader: Pubkey,
offset: u32,
bytes: Vec<u8>,
last_id: Hash,
recent_block_hash: Hash,
fee: u64,
) -> Transaction {
let instruction = LoaderInstruction::Write { offset, bytes };
Transaction::new(from_keypair, &[], loader, &instruction, last_id, fee)
Transaction::new(from_keypair, &[], loader, &instruction, recent_block_hash, fee)
}
pub fn new_finalize(
from_keypair: &Keypair,
loader: Pubkey,
last_id: Hash,
recent_block_hash: Hash,
fee: u64,
) -> Transaction {
let instruction = LoaderInstruction::Finalize;
Transaction::new(from_keypair, &[], loader, &instruction, last_id, fee)
Transaction::new(from_keypair, &[], loader, &instruction, recent_block_hash, fee)
}
}

18
sdk/src/storage_program.rs
View File

@ -80,7 +80,7 @@ impl StorageTransaction {
pub fn new_mining_proof(
from_keypair: &Keypair,
sha_state: Hash,
last_id: Hash,
recent_block_hash: Hash,
entry_height: u64,
signature: Signature,
) -> Transaction {
@ -89,25 +89,25 @@ impl StorageTransaction {
entry_height,
signature,
};
Transaction::new(from_keypair, &[], id(), &program, last_id, 0)
Transaction::new(from_keypair, &[], id(), &program, recent_block_hash, 0)
}
pub fn new_advertise_last_id(
pub fn new_advertise_recent_block_hash(
from_keypair: &Keypair,
storage_id: Hash,
last_id: Hash,
recent_block_hash: Hash,
entry_height: u64,
) -> Transaction {
let program = StorageProgram::AdvertiseStorageLastId {
id: storage_id,
entry_height,
};
Transaction::new(from_keypair, &[], id(), &program, last_id, 0)
Transaction::new(from_keypair, &[], id(), &program, recent_block_hash, 0)
}
pub fn new_proof_validation(
from_keypair: &Keypair,
last_id: Hash,
recent_block_hash: Hash,
entry_height: u64,
proof_mask: Vec<ProofStatus>,
) -> Transaction {
@ -115,15 +115,15 @@ impl StorageTransaction {
entry_height,
proof_mask,
};
Transaction::new(from_keypair, &[], id(), &program, last_id, 0)
Transaction::new(from_keypair, &[], id(), &program, recent_block_hash, 0)
}
pub fn new_reward_claim(
from_keypair: &Keypair,
last_id: Hash,
recent_block_hash: Hash,
entry_height: u64,
) -> Transaction {
let program = StorageProgram::ClaimStorageReward { entry_height };
Transaction::new(from_keypair, &[], id(), &program, last_id, 0)
Transaction::new(from_keypair, &[], id(), &program, recent_block_hash, 0)
}
}

20
sdk/src/system_transaction.rs
View File

@ -14,7 +14,7 @@ impl SystemTransaction {
pub fn new_program_account(
from_keypair: &Keypair,
to: Pubkey,
last_id: Hash,
recent_block_hash: Hash,
tokens: u64,
space: u64,
program_id: Pubkey,
@ -30,7 +30,7 @@ impl SystemTransaction {
&[to],
system_program::id(),
&create,
last_id,
recent_block_hash,
fee,
)
}
@ -40,16 +40,16 @@ impl SystemTransaction {
from_keypair: &Keypair,
to: Pubkey,
tokens: u64,
last_id: Hash,
recent_block_hash: Hash,
fee: u64,
) -> Transaction {
let program_id = system_program::id();
Self::new_program_account(from_keypair, to, last_id, tokens, 0, program_id, fee)
Self::new_program_account(from_keypair, to, recent_block_hash, tokens, 0, program_id, fee)
}
/// Create and sign new SystemInstruction::Assign transaction
pub fn new_assign(
from_keypair: &Keypair,
last_id: Hash,
recent_block_hash: Hash,
program_id: Pubkey,
fee: u64,
) -> Transaction {
@ -59,7 +59,7 @@ impl SystemTransaction {
&[],
system_program::id(),
&assign,
last_id,
recent_block_hash,
fee,
)
}
@ -68,7 +68,7 @@ impl SystemTransaction {
from_keypair: &Keypair,
to: Pubkey,
tokens: u64,
last_id: Hash,
recent_block_hash: Hash,
fee: u64,
) -> Transaction {
let move_tokens = SystemInstruction::Move { tokens };
@ -77,7 +77,7 @@ impl SystemTransaction {
&[to],
system_program::id(),
&move_tokens,
last_id,
recent_block_hash,
fee,
)
}
@ -85,7 +85,7 @@ impl SystemTransaction {
pub fn new_move_many(
from: &Keypair,
moves: &[(Pubkey, u64)],
last_id: Hash,
recent_block_hash: Hash,
fee: u64,
) -> Transaction {
let instructions: Vec<_> = moves
@ -101,7 +101,7 @@ impl SystemTransaction {
Transaction::new_with_instructions(
&[from],
&to_keys,
last_id,
recent_block_hash,
fee,
vec![system_program::id()],
instructions,

8
sdk/src/timing.rs
View File

@ -9,10 +9,10 @@ pub const NUM_TICKS_PER_SECOND: u64 = 10;
pub const DEFAULT_TICKS_PER_SLOT: u64 = 80;
pub const DEFAULT_SLOTS_PER_EPOCH: u64 = 64;
/// The time window of recent `last_id` values that the bank will track the signatures
/// of over. Once the bank discards a `last_id`, it will reject any transactions that use
/// that `last_id` in a transaction. Lowering this value reduces memory consumption,
/// but requires clients to update its `last_id` more frequently. Raising the value
/// The time window of recent block hash values that the bank will track the signatures
/// of over. Once the bank discards a block hash, it will reject any transactions that use
/// that `recent_block_hash` in a transaction. Lowering this value reduces memory consumption,
/// but requires clients to update its `recent_block_hash` more frequently. Raising the value
/// lengthens the time a client must wait to be certain a missing transaction will
/// not be processed by the network.
pub const MAX_HASH_AGE_IN_SECONDS: usize = 120;

34
sdk/src/transaction.rs
View File

@ -79,13 +79,13 @@ impl Instruction<u8, u8> {
/// An atomic transaction
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct Transaction {
/// A set of digital signatures of `account_keys`, `program_ids`, `last_id`, `fee` and `instructions`, signed by the first
/// A set of digital signatures of `account_keys`, `program_ids`, `recent_block_hash`, `fee` and `instructions`, signed by the first
/// signatures.len() keys of account_keys
pub signatures: Vec<Signature>,
/// All the account keys used by this transaction
pub account_keys: Vec<Pubkey>,
/// The id of a recent ledger entry.
pub last_id: Hash,
pub recent_block_hash: Hash,
/// The number of tokens paid for processing and storing of this transaction.
pub fee: u64,
/// All the program id keys used to execute this transaction's instructions
@ -101,7 +101,7 @@ impl Transaction {
transaction_keys: &[Pubkey],
program_id: Pubkey,
userdata: &S,
last_id: Hash,
recent_block_hash: Hash,
fee: u64,
) -> Self {
let program_ids = vec![program_id];
@ -110,7 +110,7 @@ impl Transaction {
Self::new_with_instructions(
&[from_keypair],
transaction_keys,
last_id,
recent_block_hash,
fee,
program_ids,
instructions,
@ -121,7 +121,7 @@ impl Transaction {
transaction_keys: &[Pubkey],
program_id: Pubkey,
userdata: &T,
last_id: Hash,
recent_block_hash: Hash,
fee: u64,
) -> Self {
let program_ids = vec![program_id];
@ -132,7 +132,7 @@ impl Transaction {
Self::new_with_instructions::<Keypair>(
&[],
&keys[..],
last_id,
recent_block_hash,
fee,
program_ids,
instructions,
@ -142,14 +142,14 @@ impl Transaction {
/// * `from_keypair` - The key used to sign the transaction. This key is stored as keys[0]
/// * `account_keys` - The keys for the transaction. These are the program state
/// instances or token recipient keys.
/// * `last_id` - The PoH hash.
/// * `recent_block_hash` - The PoH hash.
/// * `fee` - The transaction fee.
/// * `program_ids` - The keys that identify programs used in the `instruction` vector.
/// * `instructions` - The programs and their arguments that the transaction will execute atomically
pub fn new_with_instructions<T: KeypairUtil>(
from_keypairs: &[&T],
keys: &[Pubkey],
last_id: Hash,
recent_block_hash: Hash,
fee: u64,
program_ids: Vec<Pubkey>,
instructions: Vec<Instruction<u8, u8>>,
@ -162,12 +162,12 @@ impl Transaction {
let mut tx = Transaction {
signatures: vec![],
account_keys,
last_id: Hash::default(),
recent_block_hash: Hash::default(),
fee,
program_ids,
instructions,
};
tx.sign(from_keypairs, last_id);
tx.sign(from_keypairs, recent_block_hash);
tx
}
pub fn userdata(&self, instruction_index: usize) -> &[u8] {
@ -205,8 +205,8 @@ impl Transaction {
let mut wr = Cursor::new(&mut buf[..]);
serialize_vec_with(&mut wr, &self.account_keys, Transaction::serialize_pubkey)
.expect("serialize account_keys");
wr.write_all(self.last_id.as_ref())
.expect("serialize last_id");
wr.write_all(self.recent_block_hash.as_ref())
.expect("serialize recent_block_hash");
wr.write_u64::<LittleEndian>(self.fee)
.expect("serialize fee");
serialize_vec_with(&mut wr, &self.program_ids, Transaction::serialize_pubkey)
@ -218,8 +218,8 @@ impl Transaction {
}
/// Sign this transaction.
pub fn sign<T: KeypairUtil>(&mut self, keypairs: &[&T], last_id: Hash) {
self.last_id = last_id;
pub fn sign<T: KeypairUtil>(&mut self, keypairs: &[&T], recent_block_hash: Hash) {
self.recent_block_hash = recent_block_hash;
let message = self.message();
self.signatures = keypairs
.iter()
@ -332,7 +332,7 @@ impl Serialize for Transaction {
.map_err(Error::custom)?;
serialize_vec_with(&mut wr, &self.account_keys, Transaction::serialize_pubkey)
.map_err(Error::custom)?;
wr.write_all(self.last_id.as_ref()).map_err(Error::custom)?;
wr.write_all(self.recent_block_hash.as_ref()).map_err(Error::custom)?;
wr.write_u64::<LittleEndian>(self.fee)
.map_err(Error::custom)?;
serialize_vec_with(&mut wr, &self.program_ids, Transaction::serialize_pubkey)
@ -365,7 +365,7 @@ impl<'a> serde::de::Visitor<'a> for TransactionVisitor {
.map_err(Error::custom)?;
let mut buf = [0; size_of::<Hash>()];
rd.read_exact(&mut buf).map_err(Error::custom)?;
let last_id: Hash = Hash::new(&buf);
let recent_block_hash: Hash = Hash::new(&buf);
let fee = rd.read_u64::<LittleEndian>().map_err(Error::custom)?;
let program_ids: Vec<Pubkey> =
deserialize_vec_with(&mut rd, Transaction::deserialize_pubkey)
@ -375,7 +375,7 @@ impl<'a> serde::de::Visitor<'a> for TransactionVisitor {
Ok(Transaction {
signatures,
account_keys,
last_id,
recent_block_hash,
fee,
program_ids,
instructions,

4
sdk/src/transaction_builder.rs
View File

@ -91,7 +91,7 @@ impl TransactionBuilder {
}
/// Return a signed transaction.
pub fn sign<T: KeypairUtil>(&self, keypairs: &[&T], last_id: Hash) -> Transaction {
pub fn sign<T: KeypairUtil>(&self, keypairs: &[&T], recent_block_hash: Hash) -> Transaction {
let program_ids = self.program_ids();
let (mut signed_keys, unsigned_keys) = self.keys();
for (i, keypair) in keypairs.iter().enumerate() {
@ -104,7 +104,7 @@ impl TransactionBuilder {
Transaction::new_with_instructions(
keypairs,
&unsigned_keys,
last_id,
recent_block_hash,
self.fee,
program_ids,
instructions,

20
sdk/src/vote_transaction.rs
View File

@ -16,20 +16,20 @@ impl VoteTransaction {
pub fn new_vote<T: KeypairUtil>(
voting_keypair: &T,
slot_height: u64,
last_id: Hash,
recent_block_hash: Hash,
fee: u64,
) -> Transaction {
let vote = Vote { slot_height };
TransactionBuilder::new(fee)
.push(VoteInstruction::new_vote(voting_keypair.pubkey(), vote))
.sign(&[voting_keypair], last_id)
.sign(&[voting_keypair], recent_block_hash)
}
/// Fund or create the staking account with tokens
pub fn fund_staking_account(
from_keypair: &Keypair,
vote_account_id: Pubkey,
last_id: Hash,
recent_block_hash: Hash,
num_tokens: u64,
fee: u64,
) -> Transaction {
@ -41,7 +41,7 @@ impl VoteTransaction {
Transaction::new_with_instructions(
&[from_keypair],
&[vote_account_id],
last_id,
recent_block_hash,
fee,
vec![system_program::id(), vote_program::id()],
vec![
@ -54,7 +54,7 @@ impl VoteTransaction {
/// Choose a node id to `delegate` or `assign` this vote account to
pub fn delegate_vote_account<T: KeypairUtil>(
vote_keypair: &T,
last_id: Hash,
recent_block_hash: Hash,
node_id: Pubkey,
fee: u64,
) -> Transaction {
@ -63,7 +63,7 @@ impl VoteTransaction {
vote_keypair.pubkey(),
node_id,
))
.sign(&[vote_keypair], last_id)
.sign(&[vote_keypair], recent_block_hash)
}
fn get_vote(tx: &Transaction, ix_index: usize) -> Option<(Pubkey, Vote, Hash)> {
@ -72,7 +72,7 @@ impl VoteTransaction {
}
let instruction = deserialize(&tx.userdata(ix_index)).unwrap();
if let VoteInstruction::Vote(vote) = instruction {
Some((tx.account_keys[0], vote, tx.last_id))
Some((tx.account_keys[0], vote, tx.recent_block_hash))
} else {
None
}
@ -93,11 +93,11 @@ mod tests {
fn test_get_votes() {
let keypair = Keypair::new();
let slot_height = 1;
let last_id = Hash::default();
let transaction = VoteTransaction::new_vote(&keypair, slot_height, last_id, 0);
let recent_block_hash = Hash::default();
let transaction = VoteTransaction::new_vote(&keypair, slot_height, recent_block_hash, 0);
assert_eq!(
VoteTransaction::get_votes(&transaction),
vec![(keypair.pubkey(), Vote::new(slot_height), last_id)]
vec![(keypair.pubkey(), Vote::new(slot_height), recent_block_hash)]
);
}
}