parent
c4346e6191
commit
c9138f964b
|
@ -74,7 +74,7 @@ fn bench_banking_stage_multi_accounts(bencher: &mut Bencher) {
|
|||
let fund = Transaction::system_move(
|
||||
&mint.keypair(),
|
||||
tx.account_keys[0],
|
||||
mint_total / txes as i64,
|
||||
mint_total / txes as u64,
|
||||
mint.last_id(),
|
||||
0,
|
||||
);
|
||||
|
@ -175,7 +175,7 @@ fn bench_banking_stage_multi_programs(bencher: &mut Bencher) {
|
|||
let fund = Transaction::system_move(
|
||||
&mint.keypair(),
|
||||
tx.account_keys[0],
|
||||
mint_total / txes as i64,
|
||||
mint_total / txes as u64,
|
||||
mint.last_id(),
|
||||
0,
|
||||
);
|
||||
|
|
|
@ -7,4 +7,4 @@ mkdir -p "$OUTDIR"
|
|||
# cargo +nightly rustc --release -- -C panic=abort --emit=llvm-ir
|
||||
cargo +nightly rustc --release -- -C panic=abort --emit=llvm-bc
|
||||
cp "$INTERDIR"/deps/noop_rust-*.bc "$OUTDIR"/noop_rust.bc
|
||||
/usr/local/opt/llvm/bin/llc -march=bpf -filetype=obj -o "$OUTDIR"/noop_rust.o "$OUTDIR"/noop_rust.bc
|
||||
/usr/local/opt/llvm/bin/llc -march=bpf -filetype=obj -o "$OUTDIR"/noop_rust.o "$OUTDIR"/noop_rust.bc
|
||||
|
|
|
@ -1,3 +1,3 @@
|
|||
#!/bin/sh
|
||||
|
||||
/usr/local/opt/llvm/bin/llvm-objdump -color -source -disassemble target/release/noop_rust.o
|
||||
/usr/local/opt/llvm/bin/llvm-objdump -color -source -disassemble target/release/noop_rust.o
|
||||
|
|
|
@ -70,7 +70,7 @@ fn serialize_parameters(keyed_accounts: &mut [KeyedAccount], data: &[u8]) -> Vec
|
|||
.unwrap();
|
||||
for info in keyed_accounts.iter_mut() {
|
||||
v.write_all(info.key.as_ref()).unwrap();
|
||||
v.write_i64::<LittleEndian>(info.account.tokens).unwrap();
|
||||
v.write_u64::<LittleEndian>(info.account.tokens).unwrap();
|
||||
v.write_u64::<LittleEndian>(info.account.userdata.len() as u64)
|
||||
.unwrap();
|
||||
v.write_all(&info.account.userdata).unwrap();
|
||||
|
@ -87,7 +87,7 @@ fn deserialize_parameters(keyed_accounts: &mut [KeyedAccount], buffer: &[u8]) {
|
|||
let mut start = mem::size_of::<u64>();
|
||||
for info in keyed_accounts.iter_mut() {
|
||||
start += mem::size_of::<Pubkey>(); // skip pubkey
|
||||
info.account.tokens = LittleEndian::read_i64(&buffer[start..]);
|
||||
info.account.tokens = LittleEndian::read_u64(&buffer[start..]);
|
||||
|
||||
start += mem::size_of::<u64>() // skip tokens
|
||||
+ mem::size_of::<u64>(); // skip length tag
|
||||
|
|
|
@ -68,7 +68,7 @@ pub struct Transaction {
|
|||
pub last_id: Hash,
|
||||
|
||||
/// The number of tokens paid for processing and storage of this transaction.
|
||||
pub fee: i64,
|
||||
pub fee: u64,
|
||||
|
||||
/// Keys identifying programs in the instructions vector.
|
||||
pub program_ids: Vec<Pubkey>,
|
||||
|
@ -86,7 +86,7 @@ Accounts maintain token state as well as program specific memory.
|
|||
/// An Account with userdata that is stored on chain
|
||||
pub struct Account {
|
||||
/// tokens in the account
|
||||
pub tokens: i64,
|
||||
pub tokens: u64,
|
||||
/// user data
|
||||
/// A transaction can write to its userdata
|
||||
pub userdata: Vec<u8>,
|
||||
|
@ -145,7 +145,7 @@ pub enum SystemProgram {
|
|||
/// * space - memory to allocate if greater then zero
|
||||
/// * program_id - the program id of the new account
|
||||
CreateAccount {
|
||||
tokens: i64,
|
||||
tokens: u64,
|
||||
space: u64,
|
||||
program_id: Pubkey,
|
||||
},
|
||||
|
@ -155,7 +155,7 @@ pub enum SystemProgram {
|
|||
/// Move tokens
|
||||
/// * Transaction::keys[0] - source
|
||||
/// * Transaction::keys[1] - destination
|
||||
Move { tokens: i64 },
|
||||
Move { tokens: u64 },
|
||||
}
|
||||
```
|
||||
The interface is best described by the `Instruction::userdata` that the user encodes.
|
||||
|
|
|
@ -5,7 +5,7 @@ use pubkey::Pubkey;
|
|||
#[derive(Serialize, Deserialize, Debug, Clone, Default)]
|
||||
pub struct Account {
|
||||
/// tokens in the account
|
||||
pub tokens: i64,
|
||||
pub tokens: u64,
|
||||
/// user data
|
||||
/// A transaction can write to its userdata
|
||||
pub userdata: Vec<u8>,
|
||||
|
@ -21,7 +21,7 @@ pub struct Account {
|
|||
|
||||
impl Account {
|
||||
// TODO do we want to add executable and leader_program_id even though they should always be false/default?
|
||||
pub fn new(tokens: i64, space: usize, program_id: Pubkey) -> Account {
|
||||
pub fn new(tokens: u64, space: usize, program_id: Pubkey) -> Account {
|
||||
Account {
|
||||
tokens,
|
||||
userdata: vec![0u8; space],
|
||||
|
|
48
src/bank.rs
48
src/bank.rs
|
@ -33,7 +33,7 @@ use std::sync::atomic::{AtomicUsize, Ordering};
|
|||
use std::sync::{Arc, Mutex, RwLock};
|
||||
use std::time::Instant;
|
||||
use storage_program::StorageProgram;
|
||||
use system_program::SystemProgram;
|
||||
use system_program::{Error, SystemProgram};
|
||||
use system_transaction::SystemTransaction;
|
||||
use timing::{duration_as_us, timestamp};
|
||||
use token_program;
|
||||
|
@ -80,6 +80,7 @@ pub enum BankError {
|
|||
LedgerVerificationFailed,
|
||||
/// Contract's transaction token balance does not equal the balance after the transaction
|
||||
UnbalancedTransaction(u8),
|
||||
|
||||
/// Contract's transactions resulted in an account with a negative balance
|
||||
/// The difference from InsufficientFundsForFee is that the transaction was executed by the
|
||||
/// contract
|
||||
|
@ -528,8 +529,8 @@ impl Bank {
|
|||
/// tick that has achieved finality
|
||||
pub fn get_finality_timestamp(
|
||||
&self,
|
||||
ticks_and_stakes: &mut [(u64, i64)],
|
||||
supermajority_stake: i64,
|
||||
ticks_and_stakes: &mut [(u64, u64)],
|
||||
supermajority_stake: u64,
|
||||
) -> Option<u64> {
|
||||
// Sort by tick height
|
||||
ticks_and_stakes.sort_by(|a, b| a.0.cmp(&b.0));
|
||||
|
@ -712,7 +713,7 @@ impl Bank {
|
|||
instruction_index: usize,
|
||||
tx_program_id: &Pubkey,
|
||||
pre_program_id: &Pubkey,
|
||||
pre_tokens: i64,
|
||||
pre_tokens: u64,
|
||||
account: &Account,
|
||||
) -> Result<()> {
|
||||
// Verify the transaction
|
||||
|
@ -727,9 +728,6 @@ impl Bank {
|
|||
instruction_index as u8,
|
||||
));
|
||||
}
|
||||
if account.tokens < 0 {
|
||||
return Err(BankError::ResultWithNegativeTokens(instruction_index as u8));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
|
@ -763,7 +761,7 @@ impl Bank {
|
|||
let tx_program_id = tx.program_id(instruction_index);
|
||||
// TODO: the runtime should be checking read/write access to memory
|
||||
// we are trusting the hard coded contracts not to clobber or allocate
|
||||
let pre_total: i64 = program_accounts.iter().map(|a| a.tokens).sum();
|
||||
let pre_total: u64 = program_accounts.iter().map(|a| a.tokens).sum();
|
||||
let pre_data: Vec<_> = program_accounts
|
||||
.iter_mut()
|
||||
.map(|a| (a.program_id, a.tokens))
|
||||
|
@ -783,9 +781,14 @@ impl Bank {
|
|||
// Call the contract method
|
||||
// It's up to the contract to implement its own rules on moving funds
|
||||
if SystemProgram::check_id(&tx_program_id) {
|
||||
if SystemProgram::process_transaction(&tx, instruction_index, program_accounts).is_err()
|
||||
if let Err(err) =
|
||||
SystemProgram::process_transaction(&tx, instruction_index, program_accounts)
|
||||
{
|
||||
return Err(BankError::ProgramRuntimeError(instruction_index as u8));
|
||||
let err = match err {
|
||||
Error::ResultWithNegativeTokens(i) => BankError::ResultWithNegativeTokens(i),
|
||||
_ => BankError::ProgramRuntimeError(instruction_index as u8),
|
||||
};
|
||||
return Err(err);
|
||||
}
|
||||
} else if BudgetState::check_id(&tx_program_id) {
|
||||
if BudgetState::process_transaction(&tx, instruction_index, program_accounts).is_err() {
|
||||
|
@ -873,7 +876,7 @@ impl Bank {
|
|||
}
|
||||
}
|
||||
// The total sum of all the tokens in all the pages cannot change.
|
||||
let post_total: i64 = program_accounts.iter().map(|a| a.tokens).sum();
|
||||
let post_total: u64 = program_accounts.iter().map(|a| a.tokens).sum();
|
||||
if pre_total != post_total {
|
||||
Err(BankError::UnbalancedTransaction(instruction_index as u8))
|
||||
} else {
|
||||
|
@ -1288,7 +1291,7 @@ impl Bank {
|
|||
/// `n` tokens where `last_id` is the last Entry ID observed by the client.
|
||||
pub fn transfer(
|
||||
&self,
|
||||
n: i64,
|
||||
n: u64,
|
||||
keypair: &Keypair,
|
||||
to: Pubkey,
|
||||
last_id: Hash,
|
||||
|
@ -1298,7 +1301,7 @@ impl Bank {
|
|||
self.process_transaction(&tx).map(|_| signature)
|
||||
}
|
||||
|
||||
pub fn read_balance(account: &Account) -> i64 {
|
||||
pub fn read_balance(account: &Account) -> u64 {
|
||||
if SystemProgram::check_id(&account.program_id) {
|
||||
SystemProgram::get_balance(account)
|
||||
} else if BudgetState::check_id(&account.program_id) {
|
||||
|
@ -1309,7 +1312,7 @@ impl Bank {
|
|||
}
|
||||
/// Each contract would need to be able to introspect its own state
|
||||
/// this is hard coded to the budget contract language
|
||||
pub fn get_balance(&self, pubkey: &Pubkey) -> i64 {
|
||||
pub fn get_balance(&self, pubkey: &Pubkey) -> u64 {
|
||||
self.get_account(pubkey)
|
||||
.map(|x| Self::read_balance(&x))
|
||||
.unwrap_or(0)
|
||||
|
@ -1317,7 +1320,7 @@ impl Bank {
|
|||
|
||||
/// TODO: Need to implement a real staking contract to hold node stake.
|
||||
/// Right now this just gets the account balances. See github issue #1655.
|
||||
pub fn get_stake(&self, pubkey: &Pubkey) -> i64 {
|
||||
pub fn get_stake(&self, pubkey: &Pubkey) -> u64 {
|
||||
self.get_balance(pubkey)
|
||||
}
|
||||
|
||||
|
@ -1482,7 +1485,6 @@ mod tests {
|
|||
use hash::hash;
|
||||
use jsonrpc_macros::pubsub::{Subscriber, SubscriptionId};
|
||||
use ledger;
|
||||
use logger;
|
||||
use signature::Keypair;
|
||||
use signature::{GenKeys, KeypairUtil};
|
||||
use std;
|
||||
|
@ -1611,18 +1613,6 @@ mod tests {
|
|||
assert_eq!(bank.get_signature(&t1.last_id, &t1.signature), Some(Ok(())));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_negative_tokens() {
|
||||
logger::setup();
|
||||
let mint = Mint::new(1);
|
||||
let pubkey = Keypair::new().pubkey();
|
||||
let bank = Bank::new(&mint);
|
||||
let res = bank.transfer(-1, &mint.keypair(), pubkey, mint.last_id());
|
||||
println!("{:?}", bank.get_account(&pubkey));
|
||||
assert_matches!(res, Err(BankError::ResultWithNegativeTokens(0)));
|
||||
assert_eq!(bank.transaction_count(), 0);
|
||||
}
|
||||
|
||||
// TODO: This test demonstrates that fees are not paid when a program fails.
|
||||
// See github issue 1157 (https://github.com/solana-labs/solana/issues/1157)
|
||||
#[test]
|
||||
|
@ -1890,7 +1880,7 @@ mod tests {
|
|||
let dummy_leader_id = Keypair::new().pubkey();
|
||||
let dummy_leader_tokens = 1;
|
||||
let mint = Mint::new_with_leader(
|
||||
length as i64 + 1 + dummy_leader_tokens,
|
||||
length as u64 + 1 + dummy_leader_tokens,
|
||||
dummy_leader_id,
|
||||
dummy_leader_tokens,
|
||||
);
|
||||
|
|
|
@ -46,7 +46,7 @@ pub struct NodeStats {
|
|||
pub tx: u64, // Total transactions reported by this node
|
||||
}
|
||||
|
||||
fn metrics_submit_token_balance(token_balance: i64) {
|
||||
fn metrics_submit_token_balance(token_balance: u64) {
|
||||
println!("Token balance: {}", token_balance);
|
||||
metrics::submit(
|
||||
influxdb::Point::new("bench-tps")
|
||||
|
@ -313,14 +313,14 @@ fn verify_transfer(client: &mut ThinClient, tx: &Transaction) -> bool {
|
|||
/// fund the dests keys by spending all of the source keys into MAX_SPENDS_PER_TX
|
||||
/// on every iteration. This allows us to replay the transfers because the source is either empty,
|
||||
/// or full
|
||||
fn fund_keys(client: &mut ThinClient, source: &Keypair, dests: &[Keypair], tokens: i64) {
|
||||
let total = tokens * dests.len() as i64;
|
||||
let mut funded: Vec<(&Keypair, i64)> = vec![(source, total)];
|
||||
fn fund_keys(client: &mut ThinClient, source: &Keypair, dests: &[Keypair], tokens: u64) {
|
||||
let total = tokens * dests.len() as u64;
|
||||
let mut funded: Vec<(&Keypair, u64)> = vec![(source, total)];
|
||||
let mut notfunded: Vec<&Keypair> = dests.iter().collect();
|
||||
|
||||
println!("funding keys {}", dests.len());
|
||||
while !notfunded.is_empty() {
|
||||
let mut new_funded: Vec<(&Keypair, i64)> = vec![];
|
||||
let mut new_funded: Vec<(&Keypair, u64)> = vec![];
|
||||
let mut to_fund = vec![];
|
||||
println!("creating from... {}", funded.len());
|
||||
for f in &mut funded {
|
||||
|
@ -329,7 +329,7 @@ fn fund_keys(client: &mut ThinClient, source: &Keypair, dests: &[Keypair], token
|
|||
break;
|
||||
}
|
||||
let start = notfunded.len() - max_units;
|
||||
let per_unit = f.1 / (max_units as i64);
|
||||
let per_unit = f.1 / (max_units as u64);
|
||||
let moves: Vec<_> = notfunded[start..]
|
||||
.iter()
|
||||
.map(|k| (k.pubkey(), per_unit))
|
||||
|
@ -376,7 +376,7 @@ fn fund_keys(client: &mut ThinClient, source: &Keypair, dests: &[Keypair], token
|
|||
}
|
||||
}
|
||||
|
||||
fn airdrop_tokens(client: &mut ThinClient, leader: &NodeInfo, id: &Keypair, tx_count: i64) {
|
||||
fn airdrop_tokens(client: &mut ThinClient, leader: &NodeInfo, id: &Keypair, tx_count: u64) {
|
||||
let mut drone_addr = leader.contact_info.tpu;
|
||||
drone_addr.set_port(DRONE_PORT);
|
||||
|
||||
|
@ -494,7 +494,7 @@ fn compute_and_report_stats(
|
|||
// First transfer 3/4 of the tokens to the dest accounts
|
||||
// then ping-pong 1/4 of the tokens back to the other account
|
||||
// this leaves 1/4 token buffer in each account
|
||||
fn should_switch_directions(num_tokens_per_account: i64, i: i64) -> bool {
|
||||
fn should_switch_directions(num_tokens_per_account: u64, i: u64) -> bool {
|
||||
i % (num_tokens_per_account / 4) == 0 && (i >= (3 * num_tokens_per_account) / 4)
|
||||
}
|
||||
|
||||
|
@ -653,7 +653,7 @@ fn main() {
|
|||
total_keys += target;
|
||||
target /= MAX_SPENDS_PER_TX;
|
||||
}
|
||||
let gen_keypairs = rnd.gen_n_keypairs(total_keys as i64);
|
||||
let gen_keypairs = rnd.gen_n_keypairs(total_keys as u64);
|
||||
let barrier_id = rnd.gen_n_keypairs(1).pop().unwrap();
|
||||
|
||||
println!("Get tokens...");
|
||||
|
@ -667,7 +667,7 @@ fn main() {
|
|||
|
||||
if num_tokens_per_account > keypair0_balance {
|
||||
let extra = num_tokens_per_account - keypair0_balance;
|
||||
let total = extra * (gen_keypairs.len() as i64);
|
||||
let total = extra * (gen_keypairs.len() as u64);
|
||||
airdrop_tokens(&mut client, &leader, &id, total);
|
||||
println!("adding more tokens {}", extra);
|
||||
fund_keys(&mut client, &id, &gen_keypairs, extra);
|
||||
|
@ -730,7 +730,7 @@ fn main() {
|
|||
let mut reclaim_tokens_back_to_source_account = false;
|
||||
let mut i = keypair0_balance;
|
||||
while start.elapsed() < duration {
|
||||
let balance = client.poll_get_balance(&id.pubkey()).unwrap_or(-1);
|
||||
let balance = client.poll_get_balance(&id.pubkey()).unwrap_or(0);
|
||||
metrics_submit_token_balance(balance);
|
||||
|
||||
// ping-pong between source and destination accounts for each loop iteration
|
||||
|
@ -782,7 +782,7 @@ fn main() {
|
|||
}
|
||||
}
|
||||
|
||||
let balance = client.poll_get_balance(&id.pubkey()).unwrap_or(-1);
|
||||
let balance = client.poll_get_balance(&id.pubkey()).unwrap_or(0);
|
||||
metrics_submit_token_balance(balance);
|
||||
|
||||
compute_and_report_stats(
|
||||
|
|
|
@ -59,7 +59,7 @@ fn main() -> Result<(), Box<error::Error>> {
|
|||
let leader_keypair = leader_config.keypair();
|
||||
|
||||
// Parse the input mint configuration
|
||||
let num_tokens = value_t_or_exit!(matches, "num_tokens", i64);
|
||||
let num_tokens = value_t_or_exit!(matches, "num_tokens", u64);
|
||||
let file = File::open(Path::new(&matches.value_of("mint").unwrap())).unwrap();
|
||||
let pkcs8: Vec<u8> = serde_json::from_reader(&file)?;
|
||||
let mint = Mint::new_with_pkcs8(num_tokens, pkcs8, leader_keypair.pubkey(), 1);
|
||||
|
|
|
@ -51,17 +51,17 @@ pub enum BudgetExpr {
|
|||
|
||||
impl BudgetExpr {
|
||||
/// Create the simplest budget - one that pays `tokens` to Pubkey.
|
||||
pub fn new_payment(tokens: i64, to: Pubkey) -> Self {
|
||||
pub fn new_payment(tokens: u64, to: Pubkey) -> Self {
|
||||
BudgetExpr::Pay(Payment { tokens, to })
|
||||
}
|
||||
|
||||
/// Create a budget that pays `tokens` to `to` after being witnessed by `from`.
|
||||
pub fn new_authorized_payment(from: Pubkey, tokens: i64, to: Pubkey) -> Self {
|
||||
pub fn new_authorized_payment(from: Pubkey, tokens: u64, to: Pubkey) -> Self {
|
||||
BudgetExpr::After(Condition::Signature(from), Payment { tokens, to })
|
||||
}
|
||||
|
||||
/// Create a budget that pays tokens` to `to` after being witnessed by 2x `from`s
|
||||
pub fn new_2_2_multisig_payment(from0: Pubkey, from1: Pubkey, tokens: i64, to: Pubkey) -> Self {
|
||||
pub fn new_2_2_multisig_payment(from0: Pubkey, from1: Pubkey, tokens: u64, to: Pubkey) -> Self {
|
||||
BudgetExpr::And(
|
||||
Condition::Signature(from0),
|
||||
Condition::Signature(from1),
|
||||
|
@ -70,7 +70,7 @@ impl BudgetExpr {
|
|||
}
|
||||
|
||||
/// Create a budget that pays `tokens` to `to` after the given DateTime.
|
||||
pub fn new_future_payment(dt: DateTime<Utc>, from: Pubkey, tokens: i64, to: Pubkey) -> Self {
|
||||
pub fn new_future_payment(dt: DateTime<Utc>, from: Pubkey, tokens: u64, to: Pubkey) -> Self {
|
||||
BudgetExpr::After(Condition::Timestamp(dt, from), Payment { tokens, to })
|
||||
}
|
||||
|
||||
|
@ -79,7 +79,7 @@ impl BudgetExpr {
|
|||
pub fn new_cancelable_future_payment(
|
||||
dt: DateTime<Utc>,
|
||||
from: Pubkey,
|
||||
tokens: i64,
|
||||
tokens: u64,
|
||||
to: Pubkey,
|
||||
) -> Self {
|
||||
BudgetExpr::Or(
|
||||
|
@ -97,7 +97,7 @@ impl BudgetExpr {
|
|||
}
|
||||
|
||||
/// Return true if the budget spends exactly `spendable_tokens`.
|
||||
pub fn verify(&self, spendable_tokens: i64) -> bool {
|
||||
pub fn verify(&self, spendable_tokens: u64) -> bool {
|
||||
match self {
|
||||
BudgetExpr::Pay(payment)
|
||||
| BudgetExpr::After(_, payment)
|
||||
|
|
|
@ -5,7 +5,7 @@ use chrono::prelude::{DateTime, Utc};
|
|||
#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)]
|
||||
pub struct Contract {
|
||||
/// The number of tokens allocated to the `BudgetExpr` and any transaction fees.
|
||||
pub tokens: i64,
|
||||
pub tokens: u64,
|
||||
pub budget_expr: BudgetExpr,
|
||||
}
|
||||
|
||||
|
|
|
@ -235,7 +235,7 @@ impl BudgetState {
|
|||
}
|
||||
|
||||
//TODO the contract needs to provide a "get_balance" introspection call of the userdata
|
||||
pub fn get_balance(account: &Account) -> i64 {
|
||||
pub fn get_balance(account: &Account) -> u64 {
|
||||
if let Ok(state) = deserialize(&account.userdata) {
|
||||
let state: BudgetState = state;
|
||||
if state.is_pending() {
|
||||
|
|
|
@ -16,12 +16,12 @@ pub trait BudgetTransaction {
|
|||
fn budget_new_taxed(
|
||||
from_keypair: &Keypair,
|
||||
to: Pubkey,
|
||||
tokens: i64,
|
||||
fee: i64,
|
||||
tokens: u64,
|
||||
fee: u64,
|
||||
last_id: Hash,
|
||||
) -> Self;
|
||||
|
||||
fn budget_new(from_keypair: &Keypair, to: Pubkey, tokens: i64, last_id: Hash) -> Self;
|
||||
fn budget_new(from_keypair: &Keypair, to: Pubkey, tokens: u64, last_id: Hash) -> Self;
|
||||
|
||||
fn budget_new_timestamp(
|
||||
from_keypair: &Keypair,
|
||||
|
@ -45,7 +45,7 @@ pub trait BudgetTransaction {
|
|||
dt: DateTime<Utc>,
|
||||
dt_pubkey: Pubkey,
|
||||
cancelable: Option<Pubkey>,
|
||||
tokens: i64,
|
||||
tokens: u64,
|
||||
last_id: Hash,
|
||||
) -> Self;
|
||||
|
||||
|
@ -55,7 +55,7 @@ pub trait BudgetTransaction {
|
|||
contract: Pubkey,
|
||||
witness: Pubkey,
|
||||
cancelable: Option<Pubkey>,
|
||||
tokens: i64,
|
||||
tokens: u64,
|
||||
last_id: Hash,
|
||||
) -> Self;
|
||||
|
||||
|
@ -70,8 +70,8 @@ impl BudgetTransaction for Transaction {
|
|||
fn budget_new_taxed(
|
||||
from_keypair: &Keypair,
|
||||
to: Pubkey,
|
||||
tokens: i64,
|
||||
fee: i64,
|
||||
tokens: u64,
|
||||
fee: u64,
|
||||
last_id: Hash,
|
||||
) -> Self {
|
||||
let contract = Keypair::new().pubkey();
|
||||
|
@ -106,7 +106,7 @@ impl BudgetTransaction for Transaction {
|
|||
}
|
||||
|
||||
/// Create and sign a new Transaction. Used for unit-testing.
|
||||
fn budget_new(from_keypair: &Keypair, to: Pubkey, tokens: i64, last_id: Hash) -> Self {
|
||||
fn budget_new(from_keypair: &Keypair, to: Pubkey, tokens: u64, last_id: Hash) -> Self {
|
||||
Self::budget_new_taxed(from_keypair, to, tokens, 0, last_id)
|
||||
}
|
||||
|
||||
|
@ -157,7 +157,7 @@ impl BudgetTransaction for Transaction {
|
|||
dt: DateTime<Utc>,
|
||||
dt_pubkey: Pubkey,
|
||||
cancelable: Option<Pubkey>,
|
||||
tokens: i64,
|
||||
tokens: u64,
|
||||
last_id: Hash,
|
||||
) -> Self {
|
||||
let expr = if let Some(from) = cancelable {
|
||||
|
@ -186,7 +186,7 @@ impl BudgetTransaction for Transaction {
|
|||
contract: Pubkey,
|
||||
witness: Pubkey,
|
||||
cancelable: Option<Pubkey>,
|
||||
tokens: i64,
|
||||
tokens: u64,
|
||||
last_id: Hash,
|
||||
) -> Self {
|
||||
let expr = if let Some(from) = cancelable {
|
||||
|
@ -221,7 +221,7 @@ impl BudgetTransaction for Transaction {
|
|||
fn verify_plan(&self) -> bool {
|
||||
if let Some(SystemProgram::Move { tokens }) = self.system_instruction(0) {
|
||||
if let Some(Instruction::NewBudget(expr)) = self.instruction(1) {
|
||||
if !(self.fee >= 0 && self.fee <= tokens && expr.verify(tokens - self.fee)) {
|
||||
if !(self.fee <= tokens && expr.verify(tokens - self.fee)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
@ -261,8 +261,6 @@ mod tests {
|
|||
let keypair0 = Keypair::new();
|
||||
let pubkey1 = Keypair::new().pubkey();
|
||||
assert!(Transaction::budget_new_taxed(&keypair0, pubkey1, 1, 1, zero).verify_plan());
|
||||
assert!(!Transaction::budget_new_taxed(&keypair0, pubkey1, 1, 2, zero).verify_plan());
|
||||
assert!(!Transaction::budget_new_taxed(&keypair0, pubkey1, 1, -1, zero).verify_plan());
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
|
@ -34,7 +34,7 @@ impl ComputeLeaderFinalityService {
|
|||
) -> result::Result<u64, FinalityError> {
|
||||
let mut total_stake = 0;
|
||||
|
||||
let mut ticks_and_stakes: Vec<(u64, i64)> = {
|
||||
let mut ticks_and_stakes: Vec<(u64, u64)> = {
|
||||
let bank_accounts = bank.accounts.read().unwrap();
|
||||
// TODO: Doesn't account for duplicates since a single validator could potentially register
|
||||
// multiple vote accounts. Once that is no longer possible (see the TODO in vote_program.rs,
|
||||
|
|
|
@ -131,7 +131,7 @@ impl Drone {
|
|||
Transaction::system_new(
|
||||
&self.mint_keypair,
|
||||
client_pubkey,
|
||||
airdrop_request_amount as i64,
|
||||
airdrop_request_amount as u64,
|
||||
last_id,
|
||||
)
|
||||
}
|
||||
|
@ -310,8 +310,8 @@ mod tests {
|
|||
#[test]
|
||||
#[ignore]
|
||||
fn test_send_airdrop() {
|
||||
const SMALL_BATCH: i64 = 50;
|
||||
const TPS_BATCH: i64 = 5_000_000;
|
||||
const SMALL_BATCH: u64 = 50;
|
||||
const TPS_BATCH: u64 = 5_000_000;
|
||||
|
||||
logger::setup();
|
||||
let leader_keypair = Arc::new(Keypair::new());
|
||||
|
|
|
@ -549,7 +549,7 @@ mod tests {
|
|||
let num_vote_account_tokens = 1;
|
||||
let mint = Mint::new(
|
||||
(((num_validators + 1) / 2) * (num_validators + 1)
|
||||
+ num_vote_account_tokens * num_validators) as i64,
|
||||
+ num_vote_account_tokens * num_validators) as u64,
|
||||
);
|
||||
let bank = Bank::new(&mint);
|
||||
let mut validators = vec![];
|
||||
|
@ -564,7 +564,7 @@ mod tests {
|
|||
validators.push(new_pubkey);
|
||||
// Give the validator some tokens
|
||||
bank.transfer(
|
||||
(i + 1 + num_vote_account_tokens) as i64,
|
||||
(i + 1 + num_vote_account_tokens) as u64,
|
||||
&mint.keypair(),
|
||||
new_pubkey,
|
||||
last_id,
|
||||
|
@ -574,7 +574,7 @@ mod tests {
|
|||
let new_vote_account = create_vote_account(
|
||||
&new_validator,
|
||||
&bank,
|
||||
num_vote_account_tokens as i64,
|
||||
num_vote_account_tokens as u64,
|
||||
mint.last_id(),
|
||||
).unwrap();
|
||||
// Vote to make the validator part of the active set for the entire test
|
||||
|
@ -743,7 +743,7 @@ mod tests {
|
|||
fn test_rank_active_set() {
|
||||
let num_validators: usize = 101;
|
||||
// Give mint sum(1..num_validators) tokens
|
||||
let mint = Mint::new((((num_validators + 1) / 2) * (num_validators + 1)) as i64);
|
||||
let mint = Mint::new((((num_validators + 1) / 2) * (num_validators + 1)) as u64);
|
||||
let bank = Bank::new(&mint);
|
||||
let mut validators = vec![];
|
||||
let last_id = mint
|
||||
|
@ -756,7 +756,7 @@ mod tests {
|
|||
let new_pubkey = new_validator.pubkey();
|
||||
validators.push(new_validator);
|
||||
bank.transfer(
|
||||
(num_validators - i) as i64,
|
||||
(num_validators - i) as u64,
|
||||
&mint.keypair(),
|
||||
new_pubkey,
|
||||
last_id,
|
||||
|
@ -782,7 +782,7 @@ mod tests {
|
|||
let new_pubkey = new_validator.pubkey();
|
||||
new_validators.push(new_validator);
|
||||
bank.transfer(
|
||||
(num_validators - i) as i64,
|
||||
(num_validators - i) as u64,
|
||||
&validators[i],
|
||||
new_pubkey,
|
||||
last_id,
|
||||
|
@ -803,7 +803,7 @@ mod tests {
|
|||
}
|
||||
|
||||
// Break ties between validators with the same balances using public key
|
||||
let mint = Mint::new(num_validators as i64);
|
||||
let mint = Mint::new(num_validators as u64);
|
||||
let bank = Bank::new(&mint);
|
||||
let mut tied_validators_pk = vec![];
|
||||
let last_id = mint
|
||||
|
@ -956,7 +956,7 @@ mod tests {
|
|||
// Create the bank and validators
|
||||
let mint = Mint::new(
|
||||
((((num_validators + 1) / 2) * (num_validators + 1))
|
||||
+ (num_vote_account_tokens * num_validators)) as i64,
|
||||
+ (num_vote_account_tokens * num_validators)) as u64,
|
||||
);
|
||||
let bank = Bank::new(&mint);
|
||||
let mut validators = vec![];
|
||||
|
@ -971,7 +971,7 @@ mod tests {
|
|||
validators.push(new_pubkey);
|
||||
// Give the validator some tokens
|
||||
bank.transfer(
|
||||
(i + 1 + num_vote_account_tokens) as i64,
|
||||
(i + 1 + num_vote_account_tokens) as u64,
|
||||
&mint.keypair(),
|
||||
new_pubkey,
|
||||
last_id,
|
||||
|
@ -981,7 +981,7 @@ mod tests {
|
|||
let new_vote_account = create_vote_account(
|
||||
&new_validator,
|
||||
&bank,
|
||||
num_vote_account_tokens as i64,
|
||||
num_vote_account_tokens as u64,
|
||||
mint.last_id(),
|
||||
).unwrap();
|
||||
|
||||
|
|
|
@ -623,9 +623,9 @@ pub fn create_tmp_ledger_with_mint(name: &str, mint: &Mint) -> String {
|
|||
|
||||
pub fn create_tmp_genesis(
|
||||
name: &str,
|
||||
num: i64,
|
||||
num: u64,
|
||||
bootstrap_leader_id: Pubkey,
|
||||
bootstrap_leader_tokens: i64,
|
||||
bootstrap_leader_tokens: u64,
|
||||
) -> (Mint, String) {
|
||||
let mint = Mint::new_with_leader(num, bootstrap_leader_id, bootstrap_leader_tokens);
|
||||
let path = create_tmp_ledger_with_mint(name, &mint);
|
||||
|
@ -646,10 +646,10 @@ pub fn create_ticks(num_ticks: usize, mut hash: Hash) -> Vec<Entry> {
|
|||
|
||||
pub fn create_tmp_sample_ledger(
|
||||
name: &str,
|
||||
num_tokens: i64,
|
||||
num_tokens: u64,
|
||||
num_ending_ticks: usize,
|
||||
bootstrap_leader_id: Pubkey,
|
||||
bootstrap_leader_tokens: i64,
|
||||
bootstrap_leader_tokens: u64,
|
||||
) -> (Mint, String, Vec<Entry>) {
|
||||
let mint = Mint::new_with_leader(num_tokens, bootstrap_leader_id, bootstrap_leader_tokens);
|
||||
let path = get_tmp_ledger_path(name);
|
||||
|
|
|
@ -14,10 +14,10 @@ pub trait LoaderTransaction {
|
|||
offset: u32,
|
||||
bytes: Vec<u8>,
|
||||
last_id: Hash,
|
||||
fee: i64,
|
||||
fee: u64,
|
||||
) -> Self;
|
||||
|
||||
fn finalize(from_keypair: &Keypair, loader: Pubkey, last_id: Hash, fee: i64) -> Self;
|
||||
fn finalize(from_keypair: &Keypair, loader: Pubkey, last_id: Hash, fee: u64) -> Self;
|
||||
}
|
||||
|
||||
impl LoaderTransaction for Transaction {
|
||||
|
@ -27,7 +27,7 @@ impl LoaderTransaction for Transaction {
|
|||
offset: u32,
|
||||
bytes: Vec<u8>,
|
||||
last_id: Hash,
|
||||
fee: i64,
|
||||
fee: u64,
|
||||
) -> Self {
|
||||
trace!(
|
||||
"LoaderTransaction::Write() program {:?} offset {} length {}",
|
||||
|
@ -40,7 +40,7 @@ impl LoaderTransaction for Transaction {
|
|||
Transaction::new(from_keypair, &[], loader, userdata, last_id, fee)
|
||||
}
|
||||
|
||||
fn finalize(from_keypair: &Keypair, loader: Pubkey, last_id: Hash, fee: i64) -> Self {
|
||||
fn finalize(from_keypair: &Keypair, loader: Pubkey, last_id: Hash, fee: u64) -> Self {
|
||||
trace!(
|
||||
"LoaderTransaction::Finalize() program {:?}",
|
||||
from_keypair.pubkey(),
|
||||
|
|
14
src/mint.rs
14
src/mint.rs
|
@ -13,17 +13,17 @@ use untrusted::Input;
|
|||
pub struct Mint {
|
||||
pub pkcs8: Vec<u8>,
|
||||
pubkey: Pubkey,
|
||||
pub tokens: i64,
|
||||
pub tokens: u64,
|
||||
pub bootstrap_leader_id: Pubkey,
|
||||
pub bootstrap_leader_tokens: i64,
|
||||
pub bootstrap_leader_tokens: u64,
|
||||
}
|
||||
|
||||
impl Mint {
|
||||
pub fn new_with_pkcs8(
|
||||
tokens: i64,
|
||||
tokens: u64,
|
||||
pkcs8: Vec<u8>,
|
||||
bootstrap_leader_id: Pubkey,
|
||||
bootstrap_leader_tokens: i64,
|
||||
bootstrap_leader_tokens: u64,
|
||||
) -> Self {
|
||||
let keypair =
|
||||
Keypair::from_pkcs8(Input::from(&pkcs8)).expect("from_pkcs8 in mint pub fn new");
|
||||
|
@ -38,9 +38,9 @@ impl Mint {
|
|||
}
|
||||
|
||||
pub fn new_with_leader(
|
||||
tokens: i64,
|
||||
tokens: u64,
|
||||
bootstrap_leader: Pubkey,
|
||||
bootstrap_leader_tokens: i64,
|
||||
bootstrap_leader_tokens: u64,
|
||||
) -> Self {
|
||||
let rnd = SystemRandom::new();
|
||||
let pkcs8 = Keypair::generate_pkcs8(&rnd)
|
||||
|
@ -49,7 +49,7 @@ impl Mint {
|
|||
Self::new_with_pkcs8(tokens, pkcs8, bootstrap_leader, bootstrap_leader_tokens)
|
||||
}
|
||||
|
||||
pub fn new(tokens: i64) -> Self {
|
||||
pub fn new(tokens: u64) -> Self {
|
||||
let rnd = SystemRandom::new();
|
||||
let pkcs8 = Keypair::generate_pkcs8(&rnd)
|
||||
.expect("generate_pkcs8 in mint pub fn new")
|
||||
|
|
|
@ -20,7 +20,7 @@ pub enum Witness {
|
|||
#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)]
|
||||
pub struct Payment {
|
||||
/// Amount to be paid.
|
||||
pub tokens: i64,
|
||||
pub tokens: u64,
|
||||
|
||||
/// The `Pubkey` that `tokens` should be paid to.
|
||||
pub to: Pubkey,
|
||||
|
|
|
@ -135,7 +135,7 @@ build_rpc_trait! {
|
|||
fn get_account_info(&self, Self::Metadata, String) -> Result<Account>;
|
||||
|
||||
#[rpc(meta, name = "getBalance")]
|
||||
fn get_balance(&self, Self::Metadata, String) -> Result<i64>;
|
||||
fn get_balance(&self, Self::Metadata, String) -> Result<u64>;
|
||||
|
||||
#[rpc(meta, name = "getFinality")]
|
||||
fn get_finality(&self, Self::Metadata) -> Result<usize>;
|
||||
|
@ -172,7 +172,7 @@ impl RpcSol for RpcSolImpl {
|
|||
let pubkey = verify_pubkey(id)?;
|
||||
meta.request_processor.get_account_info(pubkey)
|
||||
}
|
||||
fn get_balance(&self, meta: Self::Metadata, id: String) -> Result<i64> {
|
||||
fn get_balance(&self, meta: Self::Metadata, id: String) -> Result<u64> {
|
||||
info!("get_balance rpc request received: {:?}", id);
|
||||
let pubkey = verify_pubkey(id)?;
|
||||
meta.request_processor.get_balance(pubkey)
|
||||
|
@ -276,7 +276,7 @@ impl JsonRpcRequestProcessor {
|
|||
.get_account(&pubkey)
|
||||
.ok_or_else(Error::invalid_request)
|
||||
}
|
||||
fn get_balance(&self, pubkey: Pubkey) -> Result<i64> {
|
||||
fn get_balance(&self, pubkey: Pubkey) -> Result<u64> {
|
||||
let val = self.bank.get_balance(&pubkey);
|
||||
Ok(val)
|
||||
}
|
||||
|
|
|
@ -175,7 +175,7 @@ mod tests {
|
|||
Some(json!("deadbeefXjn8o3yroDHxUtKsZZgoy4GPkPPXfouKNHhx")),
|
||||
);
|
||||
assert!(balance.is_ok());
|
||||
assert_eq!(balance.unwrap().as_i64().unwrap(), 50);
|
||||
assert_eq!(balance.unwrap().as_u64().unwrap(), 50);
|
||||
|
||||
let last_id = RpcRequest::GetLastId.make_rpc_request(&rpc_addr, 2, None);
|
||||
assert!(last_id.is_ok());
|
||||
|
|
|
@ -84,11 +84,11 @@ impl GenKeys {
|
|||
seed
|
||||
}
|
||||
|
||||
fn gen_n_seeds(&mut self, n: i64) -> Vec<[u8; 32]> {
|
||||
fn gen_n_seeds(&mut self, n: u64) -> Vec<[u8; 32]> {
|
||||
(0..n).map(|_| self.gen_seed()).collect()
|
||||
}
|
||||
|
||||
pub fn gen_n_keypairs(&mut self, n: i64) -> Vec<Keypair> {
|
||||
pub fn gen_n_keypairs(&mut self, n: u64) -> Vec<Keypair> {
|
||||
self.gen_n_seeds(n)
|
||||
.into_par_iter()
|
||||
.map(|seed| Keypair::from_seed_unchecked(Input::from(&seed)).unwrap())
|
||||
|
@ -124,7 +124,7 @@ mod tests {
|
|||
}
|
||||
}
|
||||
|
||||
fn gen_n_pubkeys(seed: [u8; 32], n: i64) -> HashSet<Pubkey> {
|
||||
fn gen_n_pubkeys(seed: [u8; 32], n: u64) -> HashSet<Pubkey> {
|
||||
GenKeys::new(seed)
|
||||
.gen_n_keypairs(n)
|
||||
.into_iter()
|
||||
|
|
|
@ -31,7 +31,7 @@ impl StorageProgram {
|
|||
Pubkey::new(&STORAGE_PROGRAM_ID)
|
||||
}
|
||||
|
||||
pub fn get_balance(account: &Account) -> i64 {
|
||||
pub fn get_balance(account: &Account) -> u64 {
|
||||
account.tokens
|
||||
}
|
||||
|
||||
|
|
|
@ -11,6 +11,7 @@ pub enum Error {
|
|||
InvalidArgument,
|
||||
AssignOfUnownedAccount,
|
||||
AccountNotFinalized,
|
||||
ResultWithNegativeTokens(u8),
|
||||
}
|
||||
impl std::fmt::Display for Error {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
|
||||
|
@ -30,7 +31,7 @@ pub enum SystemProgram {
|
|||
/// * space - memory to allocate if greater then zero
|
||||
/// * program_id - the program id of the new account
|
||||
CreateAccount {
|
||||
tokens: i64,
|
||||
tokens: u64,
|
||||
space: u64,
|
||||
program_id: Pubkey,
|
||||
},
|
||||
|
@ -40,7 +41,7 @@ pub enum SystemProgram {
|
|||
/// Move tokens
|
||||
/// * Transaction::keys[0] - source
|
||||
/// * Transaction::keys[1] - destination
|
||||
Move { tokens: i64 },
|
||||
Move { tokens: u64 },
|
||||
|
||||
/// Spawn a new program from an account
|
||||
Spawn,
|
||||
|
@ -56,7 +57,7 @@ impl SystemProgram {
|
|||
pub fn id() -> Pubkey {
|
||||
Pubkey::new(&SYSTEM_PROGRAM_ID)
|
||||
}
|
||||
pub fn get_balance(account: &Account) -> i64 {
|
||||
pub fn get_balance(account: &Account) -> u64 {
|
||||
account.tokens
|
||||
}
|
||||
pub fn process_transaction(
|
||||
|
@ -84,6 +85,10 @@ impl SystemProgram {
|
|||
info!("Invalid account[1]");
|
||||
Err(Error::InvalidArgument)?;
|
||||
}
|
||||
if tokens > accounts[0].tokens {
|
||||
info!("Insufficient tokens in account[0]");
|
||||
Err(Error::ResultWithNegativeTokens(pix as u8))?;
|
||||
}
|
||||
accounts[0].tokens -= tokens;
|
||||
accounts[1].tokens += tokens;
|
||||
accounts[1].program_id = program_id;
|
||||
|
@ -99,6 +104,10 @@ impl SystemProgram {
|
|||
}
|
||||
SystemProgram::Move { tokens } => {
|
||||
//bank should be verifying correctness
|
||||
if tokens > accounts[0].tokens {
|
||||
info!("Insufficient tokens in account[0]");
|
||||
Err(Error::ResultWithNegativeTokens(pix as u8))?;
|
||||
}
|
||||
accounts[0].tokens -= tokens;
|
||||
accounts[1].tokens += tokens;
|
||||
}
|
||||
|
|
|
@ -12,32 +12,32 @@ pub trait SystemTransaction {
|
|||
from_keypair: &Keypair,
|
||||
to: Pubkey,
|
||||
last_id: Hash,
|
||||
tokens: i64,
|
||||
tokens: u64,
|
||||
space: u64,
|
||||
program_id: Pubkey,
|
||||
fee: i64,
|
||||
fee: u64,
|
||||
) -> Self;
|
||||
|
||||
fn system_assign(from_keypair: &Keypair, last_id: Hash, program_id: Pubkey, fee: i64) -> Self;
|
||||
fn system_assign(from_keypair: &Keypair, last_id: Hash, program_id: Pubkey, fee: u64) -> Self;
|
||||
|
||||
fn system_new(from_keypair: &Keypair, to: Pubkey, tokens: i64, last_id: Hash) -> Self;
|
||||
fn system_new(from_keypair: &Keypair, to: Pubkey, tokens: u64, last_id: Hash) -> Self;
|
||||
|
||||
fn system_move(
|
||||
from_keypair: &Keypair,
|
||||
to: Pubkey,
|
||||
tokens: i64,
|
||||
tokens: u64,
|
||||
last_id: Hash,
|
||||
fee: i64,
|
||||
fee: u64,
|
||||
) -> Self;
|
||||
|
||||
fn system_move_many(
|
||||
from_keypair: &Keypair,
|
||||
moves: &[(Pubkey, i64)],
|
||||
moves: &[(Pubkey, u64)],
|
||||
last_id: Hash,
|
||||
fee: i64,
|
||||
fee: u64,
|
||||
) -> Self;
|
||||
|
||||
fn system_spawn(from_keypair: &Keypair, last_id: Hash, fee: i64) -> Self;
|
||||
fn system_spawn(from_keypair: &Keypair, last_id: Hash, fee: u64) -> Self;
|
||||
}
|
||||
|
||||
impl SystemTransaction for Transaction {
|
||||
|
@ -46,10 +46,10 @@ impl SystemTransaction for Transaction {
|
|||
from_keypair: &Keypair,
|
||||
to: Pubkey,
|
||||
last_id: Hash,
|
||||
tokens: i64,
|
||||
tokens: u64,
|
||||
space: u64,
|
||||
program_id: Pubkey,
|
||||
fee: i64,
|
||||
fee: u64,
|
||||
) -> Self {
|
||||
let create = SystemProgram::CreateAccount {
|
||||
tokens, //TODO, the tokens to allocate might need to be higher then 0 in the future
|
||||
|
@ -67,7 +67,7 @@ impl SystemTransaction for Transaction {
|
|||
)
|
||||
}
|
||||
/// Create and sign new SystemProgram::Assign transaction
|
||||
fn system_assign(from_keypair: &Keypair, last_id: Hash, program_id: Pubkey, fee: i64) -> Self {
|
||||
fn system_assign(from_keypair: &Keypair, last_id: Hash, program_id: Pubkey, fee: u64) -> Self {
|
||||
let assign = SystemProgram::Assign { program_id };
|
||||
let userdata = serialize(&assign).unwrap();
|
||||
Transaction::new(
|
||||
|
@ -80,16 +80,16 @@ impl SystemTransaction for Transaction {
|
|||
)
|
||||
}
|
||||
/// Create and sign new SystemProgram::CreateAccount transaction with some defaults
|
||||
fn system_new(from_keypair: &Keypair, to: Pubkey, tokens: i64, last_id: Hash) -> Self {
|
||||
fn system_new(from_keypair: &Keypair, to: Pubkey, tokens: u64, last_id: Hash) -> Self {
|
||||
Transaction::system_create(from_keypair, to, last_id, tokens, 0, Pubkey::default(), 0)
|
||||
}
|
||||
/// Create and sign new SystemProgram::Move transaction
|
||||
fn system_move(
|
||||
from_keypair: &Keypair,
|
||||
to: Pubkey,
|
||||
tokens: i64,
|
||||
tokens: u64,
|
||||
last_id: Hash,
|
||||
fee: i64,
|
||||
fee: u64,
|
||||
) -> Self {
|
||||
let move_tokens = SystemProgram::Move { tokens };
|
||||
let userdata = serialize(&move_tokens).unwrap();
|
||||
|
@ -103,7 +103,7 @@ impl SystemTransaction for Transaction {
|
|||
)
|
||||
}
|
||||
/// Create and sign new SystemProgram::Move transaction to many destinations
|
||||
fn system_move_many(from: &Keypair, moves: &[(Pubkey, i64)], last_id: Hash, fee: i64) -> Self {
|
||||
fn system_move_many(from: &Keypair, moves: &[(Pubkey, u64)], last_id: Hash, fee: u64) -> Self {
|
||||
let instructions: Vec<_> = moves
|
||||
.iter()
|
||||
.enumerate()
|
||||
|
@ -127,7 +127,7 @@ impl SystemTransaction for Transaction {
|
|||
)
|
||||
}
|
||||
/// Create and sign new SystemProgram::Spawn transaction
|
||||
fn system_spawn(from_keypair: &Keypair, last_id: Hash, fee: i64) -> Self {
|
||||
fn system_spawn(from_keypair: &Keypair, last_id: Hash, fee: u64) -> Self {
|
||||
let spawn = SystemProgram::Spawn;
|
||||
let userdata = serialize(&spawn).unwrap();
|
||||
Transaction::new(
|
||||
|
|
|
@ -154,7 +154,7 @@ impl ThinClient {
|
|||
node_keypair: &Keypair,
|
||||
vote_account_id: Pubkey,
|
||||
last_id: &Hash,
|
||||
num_tokens: i64,
|
||||
num_tokens: u64,
|
||||
) -> io::Result<Signature> {
|
||||
let tx =
|
||||
Transaction::vote_account_new(&node_keypair, vote_account_id, *last_id, num_tokens);
|
||||
|
@ -175,7 +175,7 @@ impl ThinClient {
|
|||
/// Creates, signs, and processes a Transaction. Useful for writing unit-tests.
|
||||
pub fn transfer(
|
||||
&self,
|
||||
n: i64,
|
||||
n: u64,
|
||||
keypair: &Keypair,
|
||||
to: Pubkey,
|
||||
last_id: &Hash,
|
||||
|
@ -215,7 +215,7 @@ impl ThinClient {
|
|||
/// Request the balance of the user holding `pubkey`. This method blocks
|
||||
/// until the server sends a response. If the response packet is dropped
|
||||
/// by the network, this method will hang indefinitely.
|
||||
pub fn get_balance(&mut self, pubkey: &Pubkey) -> io::Result<i64> {
|
||||
pub fn get_balance(&mut self, pubkey: &Pubkey) -> io::Result<u64> {
|
||||
trace!("get_balance sending request to {}", self.requests_addr);
|
||||
let req = Request::GetAccount { key: *pubkey };
|
||||
let data = serialize(&req).expect("serialize GetAccount in pub fn get_balance");
|
||||
|
@ -337,7 +337,7 @@ impl ThinClient {
|
|||
pubkey: &Pubkey,
|
||||
polling_frequency: &Duration,
|
||||
timeout: &Duration,
|
||||
) -> io::Result<i64> {
|
||||
) -> io::Result<u64> {
|
||||
let now = Instant::now();
|
||||
loop {
|
||||
match self.get_balance(&pubkey) {
|
||||
|
@ -356,7 +356,7 @@ impl ThinClient {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn poll_get_balance(&mut self, pubkey: &Pubkey) -> io::Result<i64> {
|
||||
pub fn poll_get_balance(&mut self, pubkey: &Pubkey) -> io::Result<u64> {
|
||||
self.poll_balance_with_timeout(pubkey, &Duration::from_millis(100), &Duration::from_secs(1))
|
||||
}
|
||||
|
||||
|
@ -473,8 +473,8 @@ pub fn poll_gossip_for_leader(leader_ncp: SocketAddr, timeout: Option<u64>) -> R
|
|||
pub fn retry_get_balance(
|
||||
client: &mut ThinClient,
|
||||
bob_pubkey: &Pubkey,
|
||||
expected_balance: Option<i64>,
|
||||
) -> Option<i64> {
|
||||
expected_balance: Option<u64>,
|
||||
) -> Option<u64> {
|
||||
const LAST: usize = 30;
|
||||
for run in 0..LAST {
|
||||
let balance_result = client.poll_get_balance(bob_pubkey);
|
||||
|
|
|
@ -40,7 +40,7 @@ pub struct Transaction {
|
|||
pub last_id: Hash,
|
||||
|
||||
/// The number of tokens paid for processing and storage of this transaction.
|
||||
pub fee: i64,
|
||||
pub fee: u64,
|
||||
|
||||
/// Keys identifying programs in the instructions vector.
|
||||
pub program_ids: Vec<Pubkey>,
|
||||
|
@ -56,7 +56,7 @@ impl Transaction {
|
|||
program_id: Pubkey,
|
||||
userdata: Vec<u8>,
|
||||
last_id: Hash,
|
||||
fee: i64,
|
||||
fee: u64,
|
||||
) -> Self {
|
||||
let program_ids = vec![program_id];
|
||||
let instructions = vec![Instruction {
|
||||
|
@ -85,7 +85,7 @@ impl Transaction {
|
|||
from_keypair: &Keypair,
|
||||
keys: &[Pubkey],
|
||||
last_id: Hash,
|
||||
fee: i64,
|
||||
fee: u64,
|
||||
program_ids: Vec<Pubkey>,
|
||||
instructions: Vec<Instruction>,
|
||||
) -> Self {
|
||||
|
|
|
@ -15,24 +15,24 @@ use transaction::Transaction;
|
|||
use vote_program::{Vote, VoteInstruction, VoteProgram};
|
||||
|
||||
pub trait VoteTransaction {
|
||||
fn vote_new(vote_account: &Keypair, vote: Vote, last_id: Hash, fee: i64) -> Self;
|
||||
fn vote_new(vote_account: &Keypair, vote: Vote, last_id: Hash, fee: u64) -> Self;
|
||||
fn vote_account_new(
|
||||
validator_id: &Keypair,
|
||||
new_vote_account_id: Pubkey,
|
||||
last_id: Hash,
|
||||
num_tokens: i64,
|
||||
num_tokens: u64,
|
||||
) -> Self;
|
||||
fn vote_account_register(
|
||||
validator_id: &Keypair,
|
||||
vote_account_id: Pubkey,
|
||||
last_id: Hash,
|
||||
fee: i64,
|
||||
fee: u64,
|
||||
) -> Self;
|
||||
fn get_votes(&self) -> Vec<(Pubkey, Vote, Hash)>;
|
||||
}
|
||||
|
||||
impl VoteTransaction for Transaction {
|
||||
fn vote_new(vote_account: &Keypair, vote: Vote, last_id: Hash, fee: i64) -> Self {
|
||||
fn vote_new(vote_account: &Keypair, vote: Vote, last_id: Hash, fee: u64) -> Self {
|
||||
let instruction = VoteInstruction::NewVote(vote);
|
||||
let userdata = serialize(&instruction).expect("serialize instruction");
|
||||
Transaction::new(vote_account, &[], VoteProgram::id(), userdata, last_id, fee)
|
||||
|
@ -42,7 +42,7 @@ impl VoteTransaction for Transaction {
|
|||
validator_id: &Keypair,
|
||||
new_vote_account_id: Pubkey,
|
||||
last_id: Hash,
|
||||
num_tokens: i64,
|
||||
num_tokens: u64,
|
||||
) -> Self {
|
||||
Transaction::system_create(
|
||||
validator_id,
|
||||
|
@ -59,7 +59,7 @@ impl VoteTransaction for Transaction {
|
|||
validator_id: &Keypair,
|
||||
vote_account_id: Pubkey,
|
||||
last_id: Hash,
|
||||
fee: i64,
|
||||
fee: u64,
|
||||
) -> Self {
|
||||
let register_tx = VoteInstruction::RegisterAccount;
|
||||
let userdata = serialize(®ister_tx).unwrap();
|
||||
|
@ -91,7 +91,7 @@ impl VoteTransaction for Transaction {
|
|||
pub fn create_vote_account(
|
||||
node_keypair: &Keypair,
|
||||
bank: &Bank,
|
||||
num_tokens: i64,
|
||||
num_tokens: u64,
|
||||
last_id: Hash,
|
||||
) -> Result<Keypair> {
|
||||
let new_vote_account = Keypair::new();
|
||||
|
|
|
@ -37,7 +37,7 @@ const USERDATA_CHUNK_SIZE: usize = 256;
|
|||
#[derive(Debug, PartialEq)]
|
||||
pub enum WalletCommand {
|
||||
Address,
|
||||
AirDrop(i64),
|
||||
AirDrop(u64),
|
||||
Balance,
|
||||
Cancel(Pubkey),
|
||||
Confirm(Signature),
|
||||
|
@ -45,7 +45,7 @@ pub enum WalletCommand {
|
|||
GetTransactionCount,
|
||||
// Pay(tokens, to, timestamp, timestamp_pubkey, witness(es), cancelable)
|
||||
Pay(
|
||||
i64,
|
||||
u64,
|
||||
Pubkey,
|
||||
Option<DateTime<Utc>>,
|
||||
Option<Pubkey>,
|
||||
|
@ -308,7 +308,7 @@ pub fn process_command(config: &WalletConfig) -> Result<String, Box<error::Error
|
|||
let params = json!(format!("{}", config.id.pubkey()));
|
||||
let previous_balance = match RpcRequest::GetBalance
|
||||
.make_rpc_request(&config.rpc_addr, 1, Some(params))?
|
||||
.as_i64()
|
||||
.as_u64()
|
||||
{
|
||||
Some(tokens) => tokens,
|
||||
None => Err(WalletError::RpcRequestError(
|
||||
|
@ -325,7 +325,7 @@ pub fn process_command(config: &WalletConfig) -> Result<String, Box<error::Error
|
|||
let params = json!(format!("{}", config.id.pubkey()));
|
||||
current_balance = RpcRequest::GetBalance
|
||||
.make_rpc_request(&config.rpc_addr, 1, Some(params))?
|
||||
.as_i64()
|
||||
.as_u64()
|
||||
.unwrap_or(previous_balance);
|
||||
|
||||
if previous_balance < current_balance {
|
||||
|
@ -344,7 +344,7 @@ pub fn process_command(config: &WalletConfig) -> Result<String, Box<error::Error
|
|||
let params = json!(format!("{}", config.id.pubkey()));
|
||||
let balance = RpcRequest::GetBalance
|
||||
.make_rpc_request(&config.rpc_addr, 1, Some(params))?
|
||||
.as_i64();
|
||||
.as_u64();
|
||||
match balance {
|
||||
Some(0) => Ok("No account found! Request an airdrop to get started.".to_string()),
|
||||
Some(tokens) => Ok(format!("Your balance is: {:?}", tokens)),
|
||||
|
@ -385,7 +385,7 @@ pub fn process_command(config: &WalletConfig) -> Result<String, Box<error::Error
|
|||
let params = json!(format!("{}", config.id.pubkey()));
|
||||
let balance = RpcRequest::GetBalance
|
||||
.make_rpc_request(&config.rpc_addr, 1, Some(params))?
|
||||
.as_i64();
|
||||
.as_u64();
|
||||
if let Some(tokens) = balance {
|
||||
if tokens < 1 {
|
||||
Err(WalletError::DynamicProgramError(
|
||||
|
@ -589,7 +589,7 @@ pub fn process_command(config: &WalletConfig) -> Result<String, Box<error::Error
|
|||
let params = json!(format!("{}", config.id.pubkey()));
|
||||
let balance = RpcRequest::GetBalance
|
||||
.make_rpc_request(&config.rpc_addr, 1, Some(params))?
|
||||
.as_i64();
|
||||
.as_u64();
|
||||
if let Some(0) = balance {
|
||||
request_airdrop(&config.drone_addr, &config.id.pubkey(), 1)?;
|
||||
}
|
||||
|
@ -608,7 +608,7 @@ pub fn process_command(config: &WalletConfig) -> Result<String, Box<error::Error
|
|||
let params = json!(format!("{}", config.id.pubkey()));
|
||||
let balance = RpcRequest::GetBalance
|
||||
.make_rpc_request(&config.rpc_addr, 1, Some(params))?
|
||||
.as_i64();
|
||||
.as_u64();
|
||||
if let Some(0) = balance {
|
||||
request_airdrop(&config.drone_addr, &config.id.pubkey(), 1)?;
|
||||
}
|
||||
|
@ -1314,21 +1314,21 @@ mod tests {
|
|||
let config_payer_balance = RpcRequest::GetBalance
|
||||
.make_rpc_request(&config_payer.rpc_addr, 1, Some(params))
|
||||
.unwrap()
|
||||
.as_i64()
|
||||
.as_u64()
|
||||
.unwrap();
|
||||
assert_eq!(config_payer_balance, 39);
|
||||
let params = json!(format!("{}", process_id));
|
||||
let contract_balance = RpcRequest::GetBalance
|
||||
.make_rpc_request(&config_payer.rpc_addr, 1, Some(params))
|
||||
.unwrap()
|
||||
.as_i64()
|
||||
.as_u64()
|
||||
.unwrap();
|
||||
assert_eq!(contract_balance, 11);
|
||||
let params = json!(format!("{}", bob_pubkey));
|
||||
let recipient_balance = RpcRequest::GetBalance
|
||||
.make_rpc_request(&config_payer.rpc_addr, 1, Some(params))
|
||||
.unwrap()
|
||||
.as_i64()
|
||||
.as_u64()
|
||||
.unwrap();
|
||||
assert_eq!(recipient_balance, 0);
|
||||
|
||||
|
@ -1341,21 +1341,21 @@ mod tests {
|
|||
let config_payer_balance = RpcRequest::GetBalance
|
||||
.make_rpc_request(&config_payer.rpc_addr, 1, Some(params))
|
||||
.unwrap()
|
||||
.as_i64()
|
||||
.as_u64()
|
||||
.unwrap();
|
||||
assert_eq!(config_payer_balance, 39);
|
||||
let params = json!(format!("{}", process_id));
|
||||
let contract_balance = RpcRequest::GetBalance
|
||||
.make_rpc_request(&config_payer.rpc_addr, 1, Some(params))
|
||||
.unwrap()
|
||||
.as_i64()
|
||||
.as_u64()
|
||||
.unwrap();
|
||||
assert_eq!(contract_balance, 1);
|
||||
let params = json!(format!("{}", bob_pubkey));
|
||||
let recipient_balance = RpcRequest::GetBalance
|
||||
.make_rpc_request(&config_payer.rpc_addr, 1, Some(params))
|
||||
.unwrap()
|
||||
.as_i64()
|
||||
.as_u64()
|
||||
.unwrap();
|
||||
assert_eq!(recipient_balance, 10);
|
||||
|
||||
|
@ -1437,21 +1437,21 @@ mod tests {
|
|||
let config_payer_balance = RpcRequest::GetBalance
|
||||
.make_rpc_request(&config_payer.rpc_addr, 1, Some(params))
|
||||
.unwrap()
|
||||
.as_i64()
|
||||
.as_u64()
|
||||
.unwrap();
|
||||
assert_eq!(config_payer_balance, 39);
|
||||
let params = json!(format!("{}", process_id));
|
||||
let contract_balance = RpcRequest::GetBalance
|
||||
.make_rpc_request(&config_payer.rpc_addr, 1, Some(params))
|
||||
.unwrap()
|
||||
.as_i64()
|
||||
.as_u64()
|
||||
.unwrap();
|
||||
assert_eq!(contract_balance, 11);
|
||||
let params = json!(format!("{}", bob_pubkey));
|
||||
let recipient_balance = RpcRequest::GetBalance
|
||||
.make_rpc_request(&config_payer.rpc_addr, 1, Some(params))
|
||||
.unwrap()
|
||||
.as_i64()
|
||||
.as_u64()
|
||||
.unwrap();
|
||||
assert_eq!(recipient_balance, 0);
|
||||
|
||||
|
@ -1464,21 +1464,21 @@ mod tests {
|
|||
let config_payer_balance = RpcRequest::GetBalance
|
||||
.make_rpc_request(&config_payer.rpc_addr, 1, Some(params))
|
||||
.unwrap()
|
||||
.as_i64()
|
||||
.as_u64()
|
||||
.unwrap();
|
||||
assert_eq!(config_payer_balance, 39);
|
||||
let params = json!(format!("{}", process_id));
|
||||
let contract_balance = RpcRequest::GetBalance
|
||||
.make_rpc_request(&config_payer.rpc_addr, 1, Some(params))
|
||||
.unwrap()
|
||||
.as_i64()
|
||||
.as_u64()
|
||||
.unwrap();
|
||||
assert_eq!(contract_balance, 1);
|
||||
let params = json!(format!("{}", bob_pubkey));
|
||||
let recipient_balance = RpcRequest::GetBalance
|
||||
.make_rpc_request(&config_payer.rpc_addr, 1, Some(params))
|
||||
.unwrap()
|
||||
.as_i64()
|
||||
.as_u64()
|
||||
.unwrap();
|
||||
assert_eq!(recipient_balance, 10);
|
||||
|
||||
|
@ -1562,21 +1562,21 @@ mod tests {
|
|||
let config_payer_balance = RpcRequest::GetBalance
|
||||
.make_rpc_request(&config_payer.rpc_addr, 1, Some(params))
|
||||
.unwrap()
|
||||
.as_i64()
|
||||
.as_u64()
|
||||
.unwrap();
|
||||
assert_eq!(config_payer_balance, 39);
|
||||
let params = json!(format!("{}", process_id));
|
||||
let contract_balance = RpcRequest::GetBalance
|
||||
.make_rpc_request(&config_payer.rpc_addr, 1, Some(params))
|
||||
.unwrap()
|
||||
.as_i64()
|
||||
.as_u64()
|
||||
.unwrap();
|
||||
assert_eq!(contract_balance, 11);
|
||||
let params = json!(format!("{}", bob_pubkey));
|
||||
let recipient_balance = RpcRequest::GetBalance
|
||||
.make_rpc_request(&config_payer.rpc_addr, 1, Some(params))
|
||||
.unwrap()
|
||||
.as_i64()
|
||||
.as_u64()
|
||||
.unwrap();
|
||||
assert_eq!(recipient_balance, 0);
|
||||
|
||||
|
@ -1589,21 +1589,21 @@ mod tests {
|
|||
let config_payer_balance = RpcRequest::GetBalance
|
||||
.make_rpc_request(&config_payer.rpc_addr, 1, Some(params))
|
||||
.unwrap()
|
||||
.as_i64()
|
||||
.as_u64()
|
||||
.unwrap();
|
||||
assert_eq!(config_payer_balance, 49);
|
||||
let params = json!(format!("{}", process_id));
|
||||
let contract_balance = RpcRequest::GetBalance
|
||||
.make_rpc_request(&config_payer.rpc_addr, 1, Some(params))
|
||||
.unwrap()
|
||||
.as_i64()
|
||||
.as_u64()
|
||||
.unwrap();
|
||||
assert_eq!(contract_balance, 1);
|
||||
let params = json!(format!("{}", bob_pubkey));
|
||||
let recipient_balance = RpcRequest::GetBalance
|
||||
.make_rpc_request(&config_payer.rpc_addr, 1, Some(params))
|
||||
.unwrap()
|
||||
.as_i64()
|
||||
.as_u64()
|
||||
.unwrap();
|
||||
assert_eq!(recipient_balance, 0);
|
||||
|
||||
|
|
|
@ -504,7 +504,7 @@ fn test_leader_restart_validator_start_from_old_ledger() -> result::Result<()> {
|
|||
let initial_leader_balance = 500;
|
||||
let (alice, ledger_path) = create_tmp_genesis(
|
||||
"leader_restart_validator_start_from_old_ledger",
|
||||
100_000 + 500 * solana::window_service::MAX_REPAIR_BACKOFF as i64,
|
||||
100_000 + 500 * solana::window_service::MAX_REPAIR_BACKOFF as u64,
|
||||
leader_keypair.pubkey(),
|
||||
initial_leader_balance,
|
||||
);
|
||||
|
@ -737,7 +737,7 @@ fn test_multi_node_dynamic_network() {
|
|||
info!("Took {} s to converge", duration_as_s(&start.elapsed()),);
|
||||
info!("Verifying signature of the last transaction in the validators");
|
||||
|
||||
let mut num_nodes_behind = 0i64;
|
||||
let mut num_nodes_behind = 0u64;
|
||||
validators.retain(|server| {
|
||||
let mut client = mk_client(&server.0);
|
||||
trace!("{} checking signature", server.0.id);
|
||||
|
@ -855,11 +855,11 @@ fn test_leader_to_validator_transition() {
|
|||
// to ensure that each transaction is packaged as a single entry,
|
||||
// so that we can be sure leader rotation is triggered
|
||||
let result =
|
||||
send_tx_and_retry_get_balance(&leader_info, &mint, &bob_pubkey, 1, Some(i as i64));
|
||||
send_tx_and_retry_get_balance(&leader_info, &mint, &bob_pubkey, 1, Some(i as u64));
|
||||
|
||||
// If the transaction wasn't reflected in the node, then we assume
|
||||
// the node has transitioned already
|
||||
if result != Some(i as i64) {
|
||||
if result != Some(i as u64) {
|
||||
break;
|
||||
}
|
||||
|
||||
|
@ -989,7 +989,7 @@ fn test_leader_validator_basic() {
|
|||
|
||||
// If the transaction wasn't reflected in the node, then we assume
|
||||
// the node has transitioned already
|
||||
if result != Some(i as i64) {
|
||||
if result != Some(i as u64) {
|
||||
break;
|
||||
}
|
||||
|
||||
|
@ -1470,9 +1470,9 @@ fn send_tx_and_retry_get_balance(
|
|||
leader: &NodeInfo,
|
||||
alice: &Mint,
|
||||
bob_pubkey: &Pubkey,
|
||||
transfer_amount: i64,
|
||||
expected: Option<i64>,
|
||||
) -> Option<i64> {
|
||||
transfer_amount: u64,
|
||||
expected: Option<u64>,
|
||||
) -> Option<u64> {
|
||||
let mut client = mk_client(leader);
|
||||
trace!("getting leader last_id");
|
||||
let last_id = client.get_last_id();
|
||||
|
@ -1486,8 +1486,8 @@ fn retry_send_tx_and_retry_get_balance(
|
|||
leader: &NodeInfo,
|
||||
alice: &Mint,
|
||||
bob_pubkey: &Pubkey,
|
||||
expected: Option<i64>,
|
||||
) -> Option<i64> {
|
||||
expected: Option<u64>,
|
||||
) -> Option<u64> {
|
||||
let mut client = mk_client(leader);
|
||||
trace!("getting leader last_id");
|
||||
let last_id = client.get_last_id();
|
||||
|
|
Loading…
Reference in New Issue