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

Boot Contract type from Budget 

In the old bank (before the contract engine), Contract wasn't specific
to Budget. It provided the same service as what is now called
SystemProgram::Move, but without requiring a separate account.
This commit is contained in:
Greg Fitzgerald 2018-10-12 23:50:43 -06:00
parent d0f43e9934
commit 15a89d4f17
3 changed files with 27 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
src/budget_instruction.rs
View File

@ -1,13 +1,6 @@
use budget::Budget;
use chrono::prelude::{DateTime, Utc};
/// A smart contract.
#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)]
pub struct Contract {
/// The number of tokens allocated to the `Budget` and any transaction fees.
pub tokens: i64,
pub budget: Budget,
}
#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)]
pub struct Vote {
/// We send some gossip specific membership information through the vote to shortcut
@ -22,13 +15,13 @@ pub struct Vote {
/// An instruction to progress the smart contract.
#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)]
pub enum Instruction {
/// Declare and instantiate `Contract`.
NewContract(Contract),
/// Declare and instantiate `Budget`.
NewBudget(i64, Budget),
/// Tell a payment plan acknowledge the given `DateTime` has past.
ApplyTimestamp(DateTime<Utc>),
/// Tell the payment plan that the `NewContract` with `Signature` has been
/// Tell the budget that the `NewBudget` with `Signature` has been
/// signed by the containing transaction's `Pubkey`.
ApplySignature,

14
src/budget_program.rs
View File

@ -112,17 +112,17 @@ impl BudgetState {
trace!("source is pending");
return Err(BudgetError::SourceIsPendingContract);
}
if let Instruction::NewContract(contract) = &instruction {
if contract.tokens < 0 {
if let Instruction::NewBudget(tokens, _) = instruction {
if *tokens < 0 {
trace!("negative tokens");
return Err(BudgetError::NegativeTokens);
}
if accounts[0].tokens < contract.tokens {
if accounts[0].tokens < *tokens {
trace!("insufficient funds");
return Err(BudgetError::InsufficientFunds);
} else {
accounts[0].tokens -= contract.tokens;
accounts[0].tokens -= *tokens;
}
};
}
@ -138,8 +138,8 @@ impl BudgetState {
instruction: &Instruction,
) -> Result<(), BudgetError> {
match instruction {
Instruction::NewContract(contract) => {
let budget = contract.budget.clone();
Instruction::NewBudget(tokens, budget) => {
let budget = budget.clone();
if let Some(payment) = budget.final_payment() {
accounts[1].tokens += payment.tokens;
Ok(())
@ -151,7 +151,7 @@ impl BudgetState {
} else {
let mut state = BudgetState::default();
state.pending_budget = Some(budget);
accounts[1].tokens += contract.tokens;
accounts[1].tokens += tokens;
state.initialized = true;
state.serialize(&mut accounts[1].userdata)
}

37
src/budget_transaction.rs
View File

@ -2,7 +2,7 @@
use bincode::{deserialize, serialize};
use budget::{Budget, Condition};
use budget_instruction::{Contract, Instruction, Vote};
use budget_instruction::{Instruction, Vote};
use budget_program::BudgetState;
use chrono::prelude::*;
use hash::Hash;
@ -81,7 +81,7 @@ impl BudgetTransaction for Transaction {
to,
};
let budget = Budget::Pay(payment);
let instruction = Instruction::NewContract(Contract { budget, tokens });
let instruction = Instruction::NewBudget(tokens, budget);
let userdata = serialize(&instruction).unwrap();
Self::new(
from_keypair,
@ -162,7 +162,7 @@ impl BudgetTransaction for Transaction {
} else {
Budget::After(Condition::Timestamp(dt, dt_pubkey), Payment { tokens, to })
};
let instruction = Instruction::NewContract(Contract { budget, tokens });
let instruction = Instruction::NewBudget(tokens, budget);
let userdata = serialize(&instruction).expect("serialize instruction");
Self::new(
from_keypair,
@ -191,7 +191,7 @@ impl BudgetTransaction for Transaction {
} else {
Budget::After(Condition::Signature(witness), Payment { tokens, to })
};
let instruction = Instruction::NewContract(Contract { budget, tokens });
let instruction = Instruction::NewBudget(tokens, budget);
let userdata = serialize(&instruction).expect("serialize instruction");
Self::new(
from_keypair,
@ -220,11 +220,8 @@ impl BudgetTransaction for Transaction {
/// Verify only the payment plan.
fn verify_plan(&self) -> bool {
for pix in 0..self.instructions.len() {
if let Some(Instruction::NewContract(contract)) = self.instruction(pix) {
if !(self.fee >= 0
&& self.fee <= contract.tokens
&& contract.budget.verify(contract.tokens - self.fee))
{
if let Some(Instruction::NewBudget(tokens, budget)) = self.instruction(pix) {
if !(self.fee >= 0 && self.fee <= tokens && budget.verify(tokens - self.fee)) {
return false;
}
}
@ -274,7 +271,7 @@ mod tests {
tokens: 0,
to: Default::default(),
});
let instruction = Instruction::NewContract(Contract { budget, tokens: 0 });
let instruction = Instruction::NewBudget(0, budget);
let userdata = serialize(&instruction).unwrap();
let instructions = vec![transaction::Instruction {
program_ids_index: 0,
@ -301,10 +298,10 @@ mod tests {
let pubkey = keypair.pubkey();
let mut tx = Transaction::budget_new(&keypair, pubkey, 42, zero);
let mut instruction = tx.instruction(0).unwrap();
if let Instruction::NewContract(ref mut contract) = instruction {
contract.tokens = 1_000_000; // <-- attack, part 1!
if let Budget::Pay(ref mut payment) = contract.budget {
payment.tokens = contract.tokens; // <-- attack, part 2!
if let Instruction::NewBudget(ref mut tokens, ref mut budget) = instruction {
*tokens = 1_000_000; // <-- attack, part 1!
if let Budget::Pay(ref mut payment) = budget {
payment.tokens = *tokens; // <-- attack, part 2!
}
}
tx.instructions[0].userdata = serialize(&instruction).unwrap();
@ -321,8 +318,8 @@ mod tests {
let zero = Hash::default();
let mut tx = Transaction::budget_new(&keypair0, pubkey1, 42, zero);
let mut instruction = tx.instruction(0);
if let Some(Instruction::NewContract(ref mut contract)) = instruction {
if let Budget::Pay(ref mut payment) = contract.budget {
if let Some(Instruction::NewBudget(_, ref mut budget)) = instruction {
if let Budget::Pay(ref mut payment) = budget {
payment.to = thief_keypair.pubkey(); // <-- attack!
}
}
@ -338,8 +335,8 @@ mod tests {
let zero = Hash::default();
let mut tx = Transaction::budget_new(&keypair0, keypair1.pubkey(), 1, zero);
let mut instruction = tx.instruction(0).unwrap();
if let Instruction::NewContract(ref mut contract) = instruction {
if let Budget::Pay(ref mut payment) = contract.budget {
if let Instruction::NewBudget(_, ref mut budget) = instruction {
if let Budget::Pay(ref mut payment) = budget {
payment.tokens = 2; // <-- attack!
}
}
@ -348,8 +345,8 @@ mod tests {
// Also, ensure all branchs of the plan spend all tokens
let mut instruction = tx.instruction(0).unwrap();
if let Instruction::NewContract(ref mut contract) = instruction {
if let Budget::Pay(ref mut payment) = contract.budget {
if let Instruction::NewBudget(_, ref mut budget) = instruction {
if let Budget::Pay(ref mut payment) = budget {
payment.tokens = 0; // <-- whoops!
}
}