601 lines
17 KiB
Rust
601 lines
17 KiB
Rust
extern crate bincode;
|
|
extern crate elf;
|
|
extern crate solana;
|
|
extern crate solana_program_interface;
|
|
|
|
use bincode::serialize;
|
|
use solana::bank::Bank;
|
|
#[cfg(feature = "bpf_c")]
|
|
use solana::bpf_loader;
|
|
use solana::loader_transaction::LoaderTransaction;
|
|
use solana::logger;
|
|
use solana::mint::Mint;
|
|
use solana::native_loader;
|
|
use solana::signature::{Keypair, KeypairUtil};
|
|
use solana::system_transaction::SystemTransaction;
|
|
#[cfg(feature = "bpf_c")]
|
|
use solana::tictactoe_program::Command;
|
|
use solana::transaction::Transaction;
|
|
use solana_program_interface::pubkey::Pubkey;
|
|
#[cfg(feature = "bpf_c")]
|
|
use std::env;
|
|
#[cfg(feature = "bpf_c")]
|
|
use std::path::PathBuf;
|
|
|
|
/// BPF program file prefixes
|
|
#[cfg(feature = "bpf_c")]
|
|
const PLATFORM_FILE_PREFIX_BPF: &str = "";
|
|
/// BPF program file extension
|
|
#[cfg(feature = "bpf_c")]
|
|
const PLATFORM_FILE_EXTENSION_BPF: &str = "o";
|
|
/// BPF program ELF section name where the program code is located
|
|
pub const PLATFORM_SECTION_RS: &str = ".text,entrypoint";
|
|
pub const PLATFORM_SECTION_C: &str = ".text.entrypoint";
|
|
/// Create a BPF program file name
|
|
#[cfg(feature = "bpf_c")]
|
|
fn create_bpf_path(name: &str) -> PathBuf {
|
|
let pathbuf = {
|
|
let current_exe = env::current_exe().unwrap();
|
|
PathBuf::from(current_exe.parent().unwrap().parent().unwrap())
|
|
};
|
|
pathbuf.join(
|
|
PathBuf::from(PLATFORM_FILE_PREFIX_BPF.to_string() + name)
|
|
.with_extension(PLATFORM_FILE_EXTENSION_BPF),
|
|
)
|
|
}
|
|
|
|
fn check_tx_results(bank: &Bank, tx: &Transaction, result: Vec<solana::bank::Result<()>>) {
|
|
assert_eq!(result.len(), 1);
|
|
assert_eq!(result[0], Ok(()));
|
|
assert_eq!(bank.get_signature(&tx.last_id, &tx.signature), Some(Ok(())));
|
|
}
|
|
|
|
struct Loader {
|
|
mint: Mint,
|
|
bank: Bank,
|
|
loader: Pubkey,
|
|
}
|
|
|
|
impl Loader {
|
|
pub fn new_dynamic(loader_name: &str) -> Self {
|
|
let mint = Mint::new(50);
|
|
let bank = Bank::new(&mint);
|
|
let loader = Keypair::new();
|
|
|
|
// allocate, populate, finalize, and spawn loader
|
|
|
|
let tx = Transaction::system_create(
|
|
&mint.keypair(),
|
|
loader.pubkey(),
|
|
mint.last_id(),
|
|
1,
|
|
56, // TODO
|
|
native_loader::id(),
|
|
0,
|
|
);
|
|
check_tx_results(&bank, &tx, bank.process_transactions(&vec![tx.clone()]));
|
|
|
|
let name = String::from(loader_name);
|
|
let tx = Transaction::write(
|
|
&loader,
|
|
native_loader::id(),
|
|
0,
|
|
name.as_bytes().to_vec(),
|
|
mint.last_id(),
|
|
0,
|
|
);
|
|
check_tx_results(&bank, &tx, bank.process_transactions(&vec![tx.clone()]));
|
|
|
|
let tx = Transaction::finalize(&loader, native_loader::id(), mint.last_id(), 0);
|
|
check_tx_results(&bank, &tx, bank.process_transactions(&vec![tx.clone()]));
|
|
|
|
let tx = Transaction::system_spawn(&loader, mint.last_id(), 0);
|
|
check_tx_results(&bank, &tx, bank.process_transactions(&vec![tx.clone()]));
|
|
|
|
Loader {
|
|
mint,
|
|
bank,
|
|
loader: loader.pubkey(),
|
|
}
|
|
}
|
|
|
|
pub fn new_native() -> Self {
|
|
let mint = Mint::new(50);
|
|
let bank = Bank::new(&mint);
|
|
let loader = native_loader::id();
|
|
|
|
Loader { mint, bank, loader }
|
|
}
|
|
|
|
#[cfg(feature = "bpf_c")]
|
|
pub fn new_bpf() -> Self {
|
|
let mint = Mint::new(50);
|
|
let bank = Bank::new(&mint);
|
|
let loader = bpf_loader::id();
|
|
|
|
Loader { mint, bank, loader }
|
|
}
|
|
}
|
|
|
|
struct Program {
|
|
program: Keypair,
|
|
}
|
|
|
|
impl Program {
|
|
pub fn new(loader: &Loader, userdata: Vec<u8>) -> Self {
|
|
let program = Keypair::new();
|
|
|
|
// allocate, populate, finalize and spawn program
|
|
|
|
let tx = Transaction::system_create(
|
|
&loader.mint.keypair(),
|
|
program.pubkey(),
|
|
loader.mint.last_id(),
|
|
1,
|
|
userdata.len() as u64,
|
|
loader.loader,
|
|
0,
|
|
);
|
|
check_tx_results(
|
|
&loader.bank,
|
|
&tx,
|
|
loader.bank.process_transactions(&vec![tx.clone()]),
|
|
);
|
|
|
|
let chunk_size = 256; // Size of chunk just needs to fit into tx
|
|
let mut offset = 0;
|
|
for chunk in userdata.chunks(chunk_size) {
|
|
let tx = Transaction::write(
|
|
&program,
|
|
loader.loader,
|
|
offset,
|
|
chunk.to_vec(),
|
|
loader.mint.last_id(),
|
|
0,
|
|
);
|
|
check_tx_results(
|
|
&loader.bank,
|
|
&tx,
|
|
loader.bank.process_transactions(&vec![tx.clone()]),
|
|
);
|
|
offset += chunk_size as u32;
|
|
}
|
|
|
|
let tx = Transaction::finalize(&program, loader.loader, loader.mint.last_id(), 0);
|
|
check_tx_results(
|
|
&loader.bank,
|
|
&tx,
|
|
loader.bank.process_transactions(&vec![tx.clone()]),
|
|
);
|
|
|
|
let tx = Transaction::system_spawn(&program, loader.mint.last_id(), 0);
|
|
check_tx_results(
|
|
&loader.bank,
|
|
&tx,
|
|
loader.bank.process_transactions(&vec![tx.clone()]),
|
|
);
|
|
|
|
Program { program }
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_program_native_noop() {
|
|
logger::setup();
|
|
|
|
let loader = Loader::new_native();
|
|
let name = String::from("noop");
|
|
let userdata = name.as_bytes().to_vec();
|
|
let program = Program::new(&loader, userdata);
|
|
|
|
// Call user program
|
|
let tx = Transaction::new(
|
|
&loader.mint.keypair(),
|
|
&[],
|
|
program.program.pubkey(),
|
|
vec![1u8],
|
|
loader.mint.last_id(),
|
|
0,
|
|
);
|
|
check_tx_results(
|
|
&loader.bank,
|
|
&tx,
|
|
loader.bank.process_transactions(&vec![tx.clone()]),
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_program_lua_move_funds() {
|
|
logger::setup();
|
|
|
|
let loader = Loader::new_dynamic("lua_loader");
|
|
let userdata = r#"
|
|
print("Lua Script!")
|
|
local tokens, _ = string.unpack("I", data)
|
|
accounts[1].tokens = accounts[1].tokens - tokens
|
|
accounts[2].tokens = accounts[2].tokens + tokens
|
|
"#.as_bytes()
|
|
.to_vec();
|
|
let program = Program::new(&loader, userdata);
|
|
let from = Keypair::new();
|
|
let to = Keypair::new().pubkey();
|
|
|
|
// Call user program with two accounts
|
|
|
|
let tx = Transaction::system_create(
|
|
&loader.mint.keypair(),
|
|
from.pubkey(),
|
|
loader.mint.last_id(),
|
|
10,
|
|
0,
|
|
program.program.pubkey(),
|
|
0,
|
|
);
|
|
check_tx_results(
|
|
&loader.bank,
|
|
&tx,
|
|
loader.bank.process_transactions(&vec![tx.clone()]),
|
|
);
|
|
|
|
let tx = Transaction::system_create(
|
|
&loader.mint.keypair(),
|
|
to,
|
|
loader.mint.last_id(),
|
|
1,
|
|
0,
|
|
program.program.pubkey(),
|
|
0,
|
|
);
|
|
check_tx_results(
|
|
&loader.bank,
|
|
&tx,
|
|
loader.bank.process_transactions(&vec![tx.clone()]),
|
|
);
|
|
|
|
let data = serialize(&10).unwrap();
|
|
let tx = Transaction::new(
|
|
&from,
|
|
&[to],
|
|
program.program.pubkey(),
|
|
data,
|
|
loader.mint.last_id(),
|
|
0,
|
|
);
|
|
check_tx_results(
|
|
&loader.bank,
|
|
&tx,
|
|
loader.bank.process_transactions(&vec![tx.clone()]),
|
|
);
|
|
assert_eq!(loader.bank.get_balance(&from.pubkey()), 0);
|
|
assert_eq!(loader.bank.get_balance(&to), 11);
|
|
}
|
|
|
|
#[cfg(feature = "bpf_c")]
|
|
#[test]
|
|
fn test_program_builtin_bpf_noop() {
|
|
logger::setup();
|
|
|
|
let loader = Loader::new_bpf();
|
|
let program = Program::new(
|
|
&loader,
|
|
elf::File::open_path(&create_bpf_path("noop_c"))
|
|
.unwrap()
|
|
.get_section(PLATFORM_SECTION_C)
|
|
.unwrap()
|
|
.data
|
|
.clone(),
|
|
);
|
|
|
|
// Call user program
|
|
let tx = Transaction::new(
|
|
&loader.mint.keypair(),
|
|
&[],
|
|
program.program.pubkey(),
|
|
vec![1u8],
|
|
loader.mint.last_id(),
|
|
0,
|
|
);
|
|
check_tx_results(
|
|
&loader.bank,
|
|
&tx,
|
|
loader.bank.process_transactions(&vec![tx.clone()]),
|
|
);
|
|
}
|
|
|
|
#[cfg(feature = "bpf_c")]
|
|
#[test]
|
|
fn test_program_bpf_noop_c() {
|
|
logger::setup();
|
|
|
|
let loader = Loader::new_dynamic("bpf_loader");
|
|
let program = Program::new(
|
|
&loader,
|
|
elf::File::open_path(&create_bpf_path("noop_c"))
|
|
.unwrap()
|
|
.get_section(PLATFORM_SECTION_C)
|
|
.unwrap()
|
|
.data
|
|
.clone(),
|
|
);
|
|
|
|
// Call user program
|
|
let tx = Transaction::new(
|
|
&loader.mint.keypair(),
|
|
&[],
|
|
program.program.pubkey(),
|
|
vec![1u8],
|
|
loader.mint.last_id(),
|
|
0,
|
|
);
|
|
check_tx_results(
|
|
&loader.bank,
|
|
&tx,
|
|
loader.bank.process_transactions(&vec![tx.clone()]),
|
|
);
|
|
}
|
|
|
|
#[cfg(feature = "bpf_c")]
|
|
struct TicTacToe {
|
|
game: Keypair,
|
|
}
|
|
|
|
#[cfg(feature = "bpf_c")]
|
|
impl TicTacToe {
|
|
pub fn new(loader: &Loader, program: &Program) -> Self {
|
|
let game = Keypair::new();
|
|
|
|
// Create game account
|
|
let tx = Transaction::system_create(
|
|
&loader.mint.keypair(),
|
|
game.pubkey(),
|
|
loader.mint.last_id(),
|
|
1,
|
|
0x78, // corresponds to the C structure size
|
|
program.program.pubkey(),
|
|
0,
|
|
);
|
|
check_tx_results(
|
|
&loader.bank,
|
|
&tx,
|
|
loader.bank.process_transactions(&vec![tx.clone()]),
|
|
);
|
|
|
|
TicTacToe { game }
|
|
}
|
|
|
|
pub fn id(&self) -> Pubkey {
|
|
self.game.pubkey().clone()
|
|
}
|
|
|
|
pub fn init(&self, loader: &Loader, program: &Program, player: &Pubkey) {
|
|
let userdata = serialize(&Command::Init).unwrap();
|
|
let tx = Transaction::new(
|
|
&self.game,
|
|
&[self.game.pubkey(), *player],
|
|
program.program.pubkey(),
|
|
userdata,
|
|
loader.mint.last_id(),
|
|
0,
|
|
);
|
|
check_tx_results(
|
|
&loader.bank,
|
|
&tx,
|
|
loader.bank.process_transactions(&vec![tx.clone()]),
|
|
);
|
|
}
|
|
|
|
pub fn command(&self, loader: &Loader, program: &Program, command: Command, player: &Pubkey) {
|
|
let userdata = serialize(&command).unwrap();
|
|
let tx = Transaction::new(
|
|
&loader.mint.keypair(),
|
|
&[self.game.pubkey(), *player],
|
|
program.program.pubkey(),
|
|
userdata,
|
|
loader.mint.last_id(),
|
|
0,
|
|
);
|
|
check_tx_results(
|
|
&loader.bank,
|
|
&tx,
|
|
loader.bank.process_transactions(&vec![tx.clone()]),
|
|
);
|
|
}
|
|
|
|
pub fn get_player_x(&self, loader: &Loader) -> Vec<u8> {
|
|
loader
|
|
.bank
|
|
.get_account(&self.game.pubkey())
|
|
.unwrap()
|
|
.userdata[0..32]
|
|
.to_vec()
|
|
}
|
|
|
|
pub fn get_player_y(&self, loader: &Loader) -> Vec<u8> {
|
|
loader
|
|
.bank
|
|
.get_account(&self.game.pubkey())
|
|
.unwrap()
|
|
.userdata[32..64]
|
|
.to_vec()
|
|
}
|
|
|
|
pub fn game(&self, loader: &Loader) -> Vec<u8> {
|
|
loader
|
|
.bank
|
|
.get_account(&self.game.pubkey())
|
|
.unwrap()
|
|
.userdata[64..68]
|
|
.to_vec()
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "bpf_c")]
|
|
struct Dashboard {
|
|
dashboard: Keypair,
|
|
}
|
|
|
|
#[cfg(feature = "bpf_c")]
|
|
impl Dashboard {
|
|
pub fn new(loader: &Loader, program: &Program) -> Self {
|
|
let dashboard = Keypair::new();
|
|
|
|
// Create game account
|
|
let tx = Transaction::system_create(
|
|
&loader.mint.keypair(),
|
|
dashboard.pubkey(),
|
|
loader.mint.last_id(),
|
|
1,
|
|
0xD0, // corresponds to the C structure size
|
|
program.program.pubkey(),
|
|
0,
|
|
);
|
|
check_tx_results(
|
|
&loader.bank,
|
|
&tx,
|
|
loader.bank.process_transactions(&vec![tx.clone()]),
|
|
);
|
|
|
|
Dashboard { dashboard }
|
|
}
|
|
|
|
pub fn update(&self, loader: &Loader, program: &Program, game: &Pubkey) {
|
|
let tx = Transaction::new(
|
|
&self.dashboard,
|
|
&[self.dashboard.pubkey(), *game],
|
|
program.program.pubkey(),
|
|
vec![],
|
|
loader.mint.last_id(),
|
|
0,
|
|
);
|
|
check_tx_results(
|
|
&loader.bank,
|
|
&tx,
|
|
loader.bank.process_transactions(&vec![tx.clone()]),
|
|
);
|
|
}
|
|
|
|
pub fn get_game(&self, loader: &Loader, since_last: usize) -> Vec<u8> {
|
|
let userdata = loader
|
|
.bank
|
|
.get_account(&self.dashboard.pubkey())
|
|
.unwrap()
|
|
.userdata;
|
|
|
|
// TODO serialize
|
|
let last_game = userdata[192] as usize;
|
|
let this_game = (last_game + since_last * 4) % 5;
|
|
let start = 32 + this_game * 32;
|
|
let end = start + 32;
|
|
|
|
loader
|
|
.bank
|
|
.get_account(&self.dashboard.pubkey())
|
|
.unwrap()
|
|
.userdata[start..end]
|
|
.to_vec()
|
|
}
|
|
|
|
pub fn get_pending(&self, loader: &Loader) -> Vec<u8> {
|
|
loader
|
|
.bank
|
|
.get_account(&self.dashboard.pubkey())
|
|
.unwrap()
|
|
.userdata[0..32]
|
|
.to_vec()
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "bpf_c")]
|
|
#[test]
|
|
fn test_program_bpf_tictactoe_c() {
|
|
logger::setup();
|
|
|
|
let loader = Loader::new_dynamic("bpf_loader");
|
|
let program = Program::new(
|
|
&loader,
|
|
elf::File::open_path(&create_bpf_path("tictactoe_c"))
|
|
.unwrap()
|
|
.get_section(PLATFORM_SECTION_C)
|
|
.unwrap()
|
|
.data
|
|
.clone(),
|
|
);
|
|
let player_x = Pubkey::new(&[0xA; 32]);
|
|
let player_y = Pubkey::new(&[0xB; 32]);
|
|
|
|
let ttt = TicTacToe::new(&loader, &program);
|
|
ttt.init(&loader, &program, &player_x);
|
|
ttt.command(&loader, &program, Command::Join(0xAABBCCDD), &player_y);
|
|
ttt.command(&loader, &program, Command::Move(1, 1), &player_x);
|
|
ttt.command(&loader, &program, Command::Move(0, 0), &player_y);
|
|
ttt.command(&loader, &program, Command::Move(2, 0), &player_x);
|
|
ttt.command(&loader, &program, Command::Move(0, 2), &player_y);
|
|
ttt.command(&loader, &program, Command::Move(2, 2), &player_x);
|
|
ttt.command(&loader, &program, Command::Move(0, 1), &player_y);
|
|
|
|
assert_eq!(player_x.as_ref(), &ttt.get_player_x(&loader)[..]); // validate x's key
|
|
assert_eq!(player_y.as_ref(), &ttt.get_player_y(&loader)[..]); // validate o's key
|
|
assert_eq!([4, 0, 0, 0], ttt.game(&loader)[..]); // validate that o won
|
|
}
|
|
|
|
#[cfg(feature = "bpf_c")]
|
|
#[test]
|
|
fn test_program_bpf_tictactoe_dashboard_c() {
|
|
logger::setup();
|
|
|
|
let loader = Loader::new_dynamic("bpf_loader");
|
|
let ttt_program = Program::new(
|
|
&loader,
|
|
elf::File::open_path(&create_bpf_path("tictactoe_c"))
|
|
.unwrap()
|
|
.get_section(PLATFORM_SECTION_C)
|
|
.unwrap()
|
|
.data
|
|
.clone(),
|
|
);
|
|
let player_x = Pubkey::new(&[0xA; 32]);
|
|
let player_y = Pubkey::new(&[0xB; 32]);
|
|
|
|
let ttt1 = TicTacToe::new(&loader, &ttt_program);
|
|
ttt1.init(&loader, &ttt_program, &player_x);
|
|
ttt1.command(&loader, &ttt_program, Command::Join(0xAABBCCDD), &player_y);
|
|
ttt1.command(&loader, &ttt_program, Command::Move(1, 1), &player_x);
|
|
ttt1.command(&loader, &ttt_program, Command::Move(0, 0), &player_y);
|
|
ttt1.command(&loader, &ttt_program, Command::Move(2, 0), &player_x);
|
|
ttt1.command(&loader, &ttt_program, Command::Move(0, 2), &player_y);
|
|
ttt1.command(&loader, &ttt_program, Command::Move(2, 2), &player_x);
|
|
ttt1.command(&loader, &ttt_program, Command::Move(0, 1), &player_y);
|
|
|
|
let ttt2 = TicTacToe::new(&loader, &ttt_program);
|
|
ttt2.init(&loader, &ttt_program, &player_x);
|
|
ttt2.command(&loader, &ttt_program, Command::Join(0xAABBCCDD), &player_y);
|
|
ttt2.command(&loader, &ttt_program, Command::Move(1, 1), &player_x);
|
|
ttt2.command(&loader, &ttt_program, Command::Move(0, 0), &player_y);
|
|
ttt2.command(&loader, &ttt_program, Command::Move(2, 0), &player_x);
|
|
ttt2.command(&loader, &ttt_program, Command::Move(0, 2), &player_y);
|
|
ttt2.command(&loader, &ttt_program, Command::Move(2, 2), &player_x);
|
|
ttt2.command(&loader, &ttt_program, Command::Move(0, 1), &player_y);
|
|
|
|
let ttt3 = TicTacToe::new(&loader, &ttt_program);
|
|
ttt3.init(&loader, &ttt_program, &player_x);
|
|
|
|
let dashboard_program = Program::new(
|
|
&loader,
|
|
elf::File::open_path(&create_bpf_path("tictactoe_dashboard_c"))
|
|
.unwrap()
|
|
.get_section(PLATFORM_SECTION_C)
|
|
.unwrap()
|
|
.data
|
|
.clone(),
|
|
);
|
|
let dashboard = Dashboard::new(&loader, &dashboard_program);
|
|
|
|
dashboard.update(&loader, &dashboard_program, &ttt1.id());
|
|
dashboard.update(&loader, &dashboard_program, &ttt2.id());
|
|
dashboard.update(&loader, &dashboard_program, &ttt3.id());
|
|
|
|
assert_eq!(ttt1.id().as_ref(), &dashboard.get_game(&loader, 1)[..]);
|
|
assert_eq!(ttt2.id().as_ref(), &dashboard.get_game(&loader, 0)[..]);
|
|
assert_eq!(ttt3.id().as_ref(), &dashboard.get_pending(&loader)[..]);
|
|
}
|