project-serum
/
serum-dex
mirror of https://github.com/project-serum/serum-dex.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
serum-dex/crank/src/main.rs

1454 lines
44 KiB
Rust
Raw Blame History

#![allow(unused)]
use anyhow::{format_err, Result};
use clap::Clap;
use rand::prelude::*;
use log::{error, info, warn};
use rand::rngs::OsRng;
use safe_transmute::{
guard::{PermissiveGuard, SingleManyGuard, SingleValueGuard},
to_bytes::{transmute_one_to_bytes, transmute_to_bytes},
transmute_many, transmute_many_pedantic, transmute_many_permissive, transmute_one,
transmute_one_pedantic, try_copy,
};
use serum_dex::instruction::{MarketInstruction, NewOrderInstruction};
use serum_dex::matching::{OrderType, Side};
use serum_dex::state::gen_vault_signer_key;
use serum_dex::state::Event;
use serum_dex::state::EventQueueHeader;
use serum_dex::state::MarketState;
use serum_dex::state::QueueHeader;
use serum_dex::state::Request;
use serum_dex::state::RequestQueueHeader;
use solana_client::rpc_client::RpcClient;
use solana_client::rpc_config::RpcSendTransactionConfig;
use solana_sdk::commitment_config::CommitmentConfig;
use solana_sdk::instruction::{AccountMeta, Instruction};
use solana_sdk::pubkey::Pubkey;
use solana_sdk::signature::Signature;
use solana_sdk::signature::{Keypair, Signer};
use solana_sdk::system_instruction::SystemInstruction;
use solana_sdk::transaction::Transaction;
use spl_token::instruction as token_instruction;
use spl_token::pack::Pack;
use std::borrow::Cow;
use std::collections::BTreeSet;
use std::mem::size_of;
use std::num::NonZeroU64;
use std::str::FromStr;
use std::{thread, time};
use std::sync::mpsc::{Sender, Receiver};
use sloggers::file::FileLoggerBuilder;
use sloggers::types::Severity;
use sloggers::Build;
pub fn with_logging<F: FnOnce()>(to: &str, fnc: F) {
fnc();
}
#[derive(Debug)]
enum Cluster {
Testnet,
Mainnet,
VipMainnet,
Devnet,
Localnet,
Debug,
}
impl FromStr for Cluster {
type Err = anyhow::Error;
fn from_str(s: &str) -> Result<Cluster> {
match s.to_lowercase().as_str() {
"t" | "testnet" => Ok(Cluster::Testnet),
"m" | "mainnet" => Ok(Cluster::Mainnet),
"v" | "vipmainnet" => Ok(Cluster::VipMainnet),
"d" | "devnet" => Ok(Cluster::Devnet),
"l" | "localnet" => Ok(Cluster::Localnet),
"g" | "debug" => Ok(Cluster::Debug),
_ => Err(anyhow::Error::msg(
"Cluster must be one of [testnet, mainnet, devnet]\n",
)),
}
}
}
impl Cluster {
fn url(&self) -> &'static str {
match self {
Cluster::Devnet => "https://devnet.solana.com",
Cluster::Testnet => "https://testnet.solana.com",
Cluster::Mainnet => "https://api.mainnet-beta.solana.com",
Cluster::VipMainnet => "https://vip-api.mainnet-beta.solana.com",
Cluster::Localnet => "http://127.0.0.1:8899",
Cluster::Debug => "http://34.90.18.145:8899",
}
}
}
fn read_keypair_file(s: &str) -> Result<Keypair> {
solana_sdk::signature::read_keypair_file(s)
.map_err(|_| format_err!("failed to read keypair from {}", s))
}
#[derive(Clap, Debug)]
struct Opts {
#[clap(default_value = "mainnet")]
cluster: Cluster,
#[clap(subcommand)]
command: Command,
}
#[derive(Clap, Debug)]
enum Command {
Genesis {
#[clap(long, short)]
payer: String,
#[clap(long, short)]
mint: String,
#[clap(long, short)]
owner_pubkey: Pubkey,
#[clap(long, short)]
decimals: u8,
},
Mint {
#[clap(long, short)]
payer: String,
#[clap(long, short)]
signer: String,
#[clap(long, short)]
mint_pubkey: Pubkey,
#[clap(long, short)]
recipient: Option<Pubkey>,
#[clap(long, short)]
quantity: u64,
},
CreateAccount {
mint_pubkey: Pubkey,
owner_pubkey: Pubkey,
payer: String,
},
ConsumeEvents {
#[clap(long, short)]
dex_program_id: Pubkey,
#[clap(long)]
payer: String,
#[clap(long, short)]
market: Pubkey,
#[clap(long, short)]
coin_wallet: Pubkey,
#[clap(long, short)]
pc_wallet: Pubkey,
#[clap(long, short)]
num_workers: usize,
#[clap(long, short)]
events_per_worker: usize,
#[clap(long)]
num_accounts: Option<usize>,
#[clap(long)]
log_directory: String,
},
MatchOrders {
#[clap(long, short)]
dex_program_id: Pubkey,
#[clap(long)]
payer: String,
#[clap(long, short)]
market: Pubkey,
#[clap(long, short)]
coin_wallet: Pubkey,
#[clap(long, short)]
pc_wallet: Pubkey,
},
MonitorQueue {
#[clap(long, short)]
dex_program_id: Pubkey,
#[clap(long, short)]
market: Pubkey,
#[clap(long)]
port: u16,
},
PrintEventQueue {
dex_program_id: Pubkey,
market: Pubkey,
},
WholeShebang {
payer: String,
dex_program_id: Pubkey,
},
SettleFunds {
payer: String,
dex_program_id: Pubkey,
market: Pubkey,
orders: Pubkey,
coin_wallet: Pubkey,
pc_wallet: Pubkey,
#[clap(long, short)]
signer: Option<String>,
},
ListMarket {
payer: String,
dex_program_id: Pubkey,
#[clap(long, short)]
coin_mint: Pubkey,
#[clap(long, short)]
pc_mint: Pubkey,
#[clap(long)]
coin_lot_size: Option<u64>,
#[clap(long)]
pc_lot_size: Option<u64>,
},
InitializeTokenAccount {
mint: Pubkey,
owner_account: String,
},
}
impl Opts {
fn client(&self) -> RpcClient {
RpcClient::new(self.cluster.url().to_string())
}
}
fn main() -> Result<()> {
let opts = Opts::parse();
let client = opts.client();
match opts.command {
Command::Genesis {
payer,
mint,
owner_pubkey,
decimals,
} => {
let payer = read_keypair_file(&payer)?;
let mint = read_keypair_file(&mint)?;
genesis(&client, &payer, &mint, &owner_pubkey, decimals)?;
}
Command::Mint {
payer,
signer,
mint_pubkey,
recipient,
quantity,
} => {
let payer = read_keypair_file(&payer)?;
let minter = read_keypair_file(&signer)?;
match recipient.as_ref() {
Some(recipient) => {
mint_to_existing_account(
&client,
&payer,
&minter,
&mint_pubkey,
recipient,
quantity,
)?;
}
None => {
mint_to_new_account(&client, &payer, &minter, &mint_pubkey, quantity)?;
}
};
}
Command::CreateAccount { .. } => unimplemented!(),
Command::MatchOrders {
ref dex_program_id,
ref payer,
ref market,
ref coin_wallet,
ref pc_wallet,
} => {
let payer = read_keypair_file(&payer)?;
println!("Getting market keys ...");
let market_keys = get_keys_for_market(&client, dex_program_id, &market)?;
println!("{:#?}", market_keys);
match_orders(
&client,
dex_program_id,
&payer,
&market_keys,
coin_wallet,
pc_wallet,
)?;
}
Command::ConsumeEvents {
ref dex_program_id,
ref payer,
ref market,
ref coin_wallet,
ref pc_wallet,
ref num_workers,
ref events_per_worker,
ref num_accounts,
ref log_directory,
} => {
consume_events_loop(
&opts,
&dex_program_id,
&payer,
&market,
&coin_wallet,
&pc_wallet,
num_workers,
*events_per_worker,
num_accounts.unwrap_or(32),
log_directory,
);
}
Command::MonitorQueue {
dex_program_id,
market,
port,
} => {
let (send, recv) = std::sync::mpsc::channel();
let queue_send = send.clone();
let client = opts.client();
let _ = std::thread::spawn(move || accept_loop(port, send));
let websockets = std::thread::spawn(move || websockets_loop(recv));
let _ = std::thread::spawn(move || read_queue_length_loop(client,
dex_program_id,
market,
queue_send));
// Failures in the others will propagate to this loop via timeout
websockets.join();
}
Command::PrintEventQueue {
ref dex_program_id,
ref market,
} => {
let market_keys = get_keys_for_market(&client, dex_program_id, &market)?;
let event_q_data = client.get_account_data(&market_keys.event_q)?;
let inner: Cow<[u64]> = remove_dex_account_padding(&event_q_data)?;
let (header, events_seg0, events_seg1) = parse_event_queue(&inner)?;
println!("Header:\n{:#x?}", header);
println!("Seg0:\n{:#x?}", events_seg0);
println!("Seg1:\n{:#x?}", events_seg1);
}
Command::WholeShebang {
ref dex_program_id,
ref payer,
} => {
let payer = read_keypair_file(payer)?;
whole_shebang(&client, dex_program_id, &payer)?;
}
Command::SettleFunds {
ref payer,
ref dex_program_id,
ref market,
ref orders,
ref coin_wallet,
ref pc_wallet,
ref signer,
} => {
let payer = read_keypair_file(payer)?;
let signer = signer.as_ref().map(|s| read_keypair_file(&s)).transpose()?;
let market_keys = get_keys_for_market(&client, dex_program_id, &market)?;
settle_funds(
&client,
dex_program_id,
&payer,
&market_keys,
signer.as_ref(),
orders,
coin_wallet,
pc_wallet,
)?;
}
Command::ListMarket {
ref payer,
ref dex_program_id,
ref coin_mint,
ref pc_mint,
coin_lot_size,
pc_lot_size,
} => {
let payer = read_keypair_file(payer)?;
let market_keys = list_market(
&client,
dex_program_id,
&payer,
coin_mint,
pc_mint,
coin_lot_size.unwrap_or(1_000_000),
pc_lot_size.unwrap_or(10_000),
)?;
println!("Listed market: {:#?}", market_keys);
}
Command::InitializeTokenAccount {
ref mint,
ref owner_account,
} => {
let owner = read_keypair_file(owner_account)?;
let initialized_account = initialize_token_account(&client, mint, &owner)?;
println!("Initialized account: {}", initialized_account.pubkey());
}
}
Ok(())
}
fn send_txn(client: &RpcClient, txn: &Transaction, simulate: bool) -> Result<Signature> {
Ok(client.send_and_confirm_transaction_with_spinner_and_config(
txn,
CommitmentConfig::single(),
RpcSendTransactionConfig {
skip_preflight: true,
},
)?)
}
#[derive(Debug)]
struct MarketPubkeys {
market: Box<Pubkey>,
req_q: Box<Pubkey>,
event_q: Box<Pubkey>,
bids: Box<Pubkey>,
asks: Box<Pubkey>,
coin_vault: Box<Pubkey>,
pc_vault: Box<Pubkey>,
vault_signer_key: Box<Pubkey>,
}
#[cfg(target_endian = "little")]
fn remove_dex_account_padding<'a>(data: &'a [u8]) -> Result<Cow<'a, [u64]>> {
use serum_dex::state::{ACCOUNT_HEAD_PADDING, ACCOUNT_TAIL_PADDING};
let head = &data[..ACCOUNT_HEAD_PADDING.len()];
if data.len() < ACCOUNT_HEAD_PADDING.len() + ACCOUNT_TAIL_PADDING.len() {
return Err(format_err!(
"dex account length {} is too small to contain valid padding",
data.len()
));
}
if head != ACCOUNT_HEAD_PADDING {
return Err(format_err!("dex account head padding mismatch"));
}
let tail = &data[data.len() - ACCOUNT_TAIL_PADDING.len()..];
if tail != ACCOUNT_TAIL_PADDING {
return Err(format_err!("dex account tail padding mismatch"));
}
let inner_data_range = ACCOUNT_HEAD_PADDING.len()..(data.len() - ACCOUNT_TAIL_PADDING.len());
let inner: &'a [u8] = &data[inner_data_range];
let words: Cow<'a, [u64]> = match transmute_many_pedantic::<u64>(inner) {
Ok(word_slice) => Cow::Borrowed(word_slice),
Err(transmute_error) => {
let word_vec = transmute_error.copy().map_err(|e| e.without_src())?;
Cow::Owned(word_vec)
}
};
Ok(words)
}
#[cfg(target_endian = "little")]
fn get_keys_for_market<'a>(
client: &'a RpcClient,
program_id: &'a Pubkey,
market: &'a Pubkey,
) -> Result<MarketPubkeys> {
let account_data: Vec<u8> = client.get_account_data(&market)?;
let words: Cow<[u64]> = remove_dex_account_padding(&account_data)?;
let market_state: MarketState =
transmute_one_pedantic::<MarketState>(transmute_to_bytes(&words))
.map_err(|e| e.without_src())?;
market_state.check_flags()?;
let vault_signer_key =
gen_vault_signer_key(market_state.vault_signer_nonce, market, program_id)?;
assert_eq!(
transmute_to_bytes(&market_state.own_address),
market.as_ref()
);
Ok(MarketPubkeys {
market: Box::new(*market),
req_q: Box::new(Pubkey::new(transmute_one_to_bytes(&market_state.req_q))),
event_q: Box::new(Pubkey::new(transmute_one_to_bytes(&market_state.event_q))),
bids: Box::new(Pubkey::new(transmute_one_to_bytes(&market_state.bids))),
asks: Box::new(Pubkey::new(transmute_one_to_bytes(&market_state.asks))),
coin_vault: Box::new(Pubkey::new(transmute_one_to_bytes(
&market_state.coin_vault,
))),
pc_vault: Box::new(Pubkey::new(transmute_one_to_bytes(&market_state.pc_vault))),
vault_signer_key: Box::new(vault_signer_key),
})
}
fn parse_event_queue(data_words: &[u64]) -> Result<(EventQueueHeader, &[Event], &[Event])> {
let (header_words, event_words) = data_words.split_at(size_of::<EventQueueHeader>() >> 3);
let header: EventQueueHeader =
transmute_one_pedantic(transmute_to_bytes(header_words)).map_err(|e| e.without_src())?;
let events: &[Event] = transmute_many::<_, SingleManyGuard>(transmute_to_bytes(event_words))
.map_err(|e| e.without_src())?;
let (tail_seg, head_seg) = events.split_at(header.head() as usize);
let head_len = head_seg.len().min(header.count() as usize);
let tail_len = header.count() as usize - head_len;
Ok((header, &head_seg[..head_len], &tail_seg[..tail_len]))
}
fn parse_req_queue(data_words: &[u64]) -> Result<(RequestQueueHeader, &[Request], &[Request])> {
let (header_words, request_words) = data_words.split_at(size_of::<RequestQueueHeader>() >> 3);
let header: RequestQueueHeader =
transmute_one_pedantic(transmute_to_bytes(header_words)).map_err(|e| e.without_src())?;
let request: &[Request] =
transmute_many::<_, SingleManyGuard>(transmute_to_bytes(request_words))
.map_err(|e| e.without_src())?;
let (tail_seg, head_seg) = request.split_at(header.head() as usize);
let head_len = head_seg.len().min(header.count() as usize);
let tail_len = header.count() as usize - head_len;
Ok((header, &head_seg[..head_len], &tail_seg[..tail_len]))
}
fn hash_accounts(val: &[u64; 4]) -> u64 {
val.iter().fold(0, |a, b| b.wrapping_add(a))
}
fn consume_events_loop(
opts: &Opts,
program_id: &Pubkey,
payer_path: &String,
market: &Pubkey,
coin_wallet: &Pubkey,
pc_wallet: &Pubkey,
num_workers: &usize,
events_per_worker: usize,
num_accounts: usize,
log_directory: &str,
) -> Result<()> {
let path = std::path::Path::new(log_directory);
let parent = path.parent().unwrap();
std::fs::create_dir_all(parent).unwrap();
let mut builder = FileLoggerBuilder::new(log_directory);
builder.level(Severity::Info).rotate_size(8 * 1024 * 1024);
let log = builder.build().unwrap();
let _guard = slog_scope::set_global_logger(log);
slog_stdlog::init().unwrap();
info!("Getting market keys ...");
let client = opts.client();
let market_keys = get_keys_for_market(&client, &program_id, &market)?;
info!("{:#?}", market_keys);
let pool = threadpool::ThreadPool::new(*num_workers);
loop {
let loop_start = std::time::Instant::now();
let start_time = std::time::Instant::now();
let event_q_data = client
.get_account_with_commitment(&market_keys.event_q, CommitmentConfig::recent())?
.value
.expect("Failed to retrieve account")
.data;
let req_q_data = client
.get_account_with_commitment(&market_keys.req_q, CommitmentConfig::recent())?
.value
.expect("Failed to retrieve account")
.data;
let inner: Cow<[u64]> = remove_dex_account_padding(&event_q_data)?;
let (header, seg0, seg1) = parse_event_queue(&inner)?;
let req_inner: Cow<[u64]> = remove_dex_account_padding(&req_q_data)?;
let (req_header, req_seg0, req_seg1) = parse_event_queue(&req_inner)?;
let event_q_len = seg0.len() + seg1.len();
let req_q_len = req_seg0.len() + req_seg1.len();
info!("Size of request queue is {}", req_q_len);
if event_q_len == 0 {
println!("Total event queue length: 0, returning early");
let one_hundred_millis = time::Duration::from_millis(300);
thread::sleep(one_hundred_millis);
} else {
info!("Total event queue length: {}", event_q_len);
let accounts = seg0.iter().chain(seg1.iter()).map(|event| event.owner);
let mut used_accounts = BTreeSet::new();
for account in accounts {
used_accounts.insert(account);
if (used_accounts.len() >= num_accounts) {
break;
}
}
let mut orders_accounts: Vec<_> = used_accounts.into_iter().collect();
info!("Number of unique order accounts: {}", orders_accounts.len());
info!(
"First 5 accouts: {:?}",
orders_accounts
.iter()
.take(5)
.map(hash_accounts)
.collect::<Vec::<_>>()
);
let mut account_metas = Vec::with_capacity(orders_accounts.len() + 4);
for pubkey_words in orders_accounts {
let pubkey = Pubkey::new(transmute_to_bytes(&pubkey_words));
account_metas.push(AccountMeta::new(pubkey, false));
}
for pubkey in [
&market_keys.market,
&market_keys.event_q,
coin_wallet,
pc_wallet,
]
.iter()
{
account_metas.push(AccountMeta::new(**pubkey, false));
}
println!("Number of workers: {}", num_workers);
let end_time = std::time::Instant::now();
info!(
"Fetching {} events from the queue took {}",
event_q_len,
end_time.duration_since(start_time).as_millis()
);
for thread_num in 0..*num_workers {
let payer = read_keypair_file(&payer_path)?;
let program_id = program_id.clone();
let client = opts.client();
let account_metas = account_metas.clone();
pool.execute(move || {
consume_events_wrapper(
&client,
&program_id,
&payer,
account_metas,
thread_num,
events_per_worker,
)
.unwrap()
});
}
pool.join();
let loop_end = std::time::Instant::now();
info!(
"Total loop time took {}",
loop_end.duration_since(loop_start).as_millis()
);
}
}
return Ok(());
}
#[cfg(target_endian = "little")]
fn consume_events_wrapper(
client: &RpcClient,
program_id: &Pubkey,
payer: &Keypair,
account_metas: Vec<AccountMeta>,
thread_num: usize,
to_consume: usize,
) -> Result<()> {
let result = consume_events_once(
&client,
program_id,
&payer,
account_metas,
to_consume,
thread_num,
);
match result {
Ok(()) => (info!("[thread {}] Successfully consumed events.", thread_num)),
Err(err) => {
error!("[thread {}] Received error: {:?}", thread_num, err);
warn!(
"[thread {}] Done consuming events. Sleeping for 100ms...",
thread_num
);
}
};
Ok(())
}
#[cfg(target_endian = "little")]
fn consume_events_once(
client: &RpcClient,
program_id: &Pubkey,
payer: &Keypair,
account_metas: Vec<AccountMeta>,
to_consume: usize,
thread_number: usize,
) -> Result<()> {
let start = std::time::Instant::now();
let instruction_data: Vec<u8> = MarketInstruction::ConsumeEvents(to_consume as u16).pack();
let instruction = Instruction {
program_id: *program_id,
accounts: account_metas,
data: instruction_data,
};
let random_instruction = solana_sdk::system_instruction::transfer(
&payer.pubkey(),
&payer.pubkey(),
rand::random::<u64>() % 10000 + 1,
);
let (recent_hash, _fee_calc) = client.get_recent_blockhash()?;
info!("Consuming events ...");
let txn = Transaction::new_signed_with_payer(
&[instruction, random_instruction],
Some(&payer.pubkey()),
&[payer],
recent_hash,
);
info!("Consuming events ...");
let rval = send_txn(client, &txn, false).map(|_| ());
let end = std::time::Instant::now();
info!(
"Thread {} took {} milliseconds to consume {} events",
thread_number,
end.duration_since(start).as_millis(),
to_consume
);
rval
}
#[cfg(target_endian = "little")]
fn consume_events(
client: &RpcClient,
program_id: &Pubkey,
payer: &Keypair,
state: &MarketPubkeys,
coin_wallet: &Pubkey,
pc_wallet: &Pubkey,
) -> Result<()> {
let event_q_data = client.get_account_data(&state.event_q)?;
let inner: Cow<[u64]> = remove_dex_account_padding(&event_q_data)?;
let (header, seg0, seg1) = parse_event_queue(&inner)?;
if seg0.len() + seg1.len() == 0 {
info!("Total event queue length: 0, returning early");
return Ok(());
} else {
info!("Total event queue length: {}", seg0.len() + seg1.len());
}
let accounts = seg0.iter().chain(seg1.iter()).map(|event| event.owner);
let mut orders_accounts: Vec<_> = accounts.collect();
orders_accounts.sort_unstable();
orders_accounts.dedup();
// todo: Shuffle the accounts before truncating, to avoid favoring low sort order accounts
orders_accounts.truncate(32);
info!("Number of unique order accounts: {}", orders_accounts.len());
let mut account_metas = Vec::with_capacity(orders_accounts.len() + 4);
for pubkey_words in orders_accounts {
let pubkey = Pubkey::new(transmute_to_bytes(&pubkey_words));
account_metas.push(AccountMeta::new(pubkey, false));
}
for pubkey in [&state.market, &state.event_q, coin_wallet, pc_wallet].iter() {
account_metas.push(AccountMeta::new(**pubkey, false));
}
let instruction_data: Vec<u8> =
MarketInstruction::ConsumeEvents(account_metas.len() as u16).pack();
let instruction = Instruction {
program_id: *program_id,
accounts: account_metas,
data: instruction_data,
};
let (recent_hash, _fee_calc) = client.get_recent_blockhash()?;
info!("Consuming events ...");
let txn = Transaction::new_signed_with_payer(
std::slice::from_ref(&instruction),
Some(&payer.pubkey()),
&[payer],
recent_hash,
);
info!("Consuming events ...");
send_txn(client, &txn, false)?;
Ok(())
}
fn whole_shebang(client: &RpcClient, program_id: &Pubkey, payer: &Keypair) -> Result<()> {
let coin_mint = Keypair::generate(&mut OsRng);
println!("Coin mint: {}", coin_mint.pubkey());
genesis(client, payer, &coin_mint, &payer.pubkey(), 3)?;
let pc_mint = Keypair::generate(&mut OsRng);
println!("Pc mint: {}", pc_mint.pubkey());
genesis(client, payer, &pc_mint, &payer.pubkey(), 3)?;
let market_keys = list_market(
client,
program_id,
payer,
&coin_mint.pubkey(),
&pc_mint.pubkey(),
1_000_000,
10_000,
)?;
println!("Market keys: {:#?}", market_keys);
println!("Minting coin...");
let coin_wallet = mint_to_new_account(
client,
payer,
payer,
&coin_mint.pubkey(),
1_000_000_000_000_000,
)?;
println!("Minted {}", coin_wallet.pubkey());
println!("Minting price currency...");
let pc_wallet = mint_to_new_account(
client,
payer,
payer,
&pc_mint.pubkey(),
1_000_000_000_000_000,
)?;
println!("Minted {}", pc_wallet.pubkey());
println!("Placing bid...");
let mut orders = None;
place_order(
client,
program_id,
payer,
&pc_wallet.pubkey(),
&market_keys,
&mut orders,
NewOrderInstruction {
side: Side::Bid,
limit_price: NonZeroU64::new(500).unwrap(),
max_qty: NonZeroU64::new(1_000).unwrap(),
order_type: OrderType::Limit,
client_id: 019269,
},
)?;
println!("Bid account: {}", orders.unwrap());
println!("Placing offer...");
let mut orders = None;
place_order(
client,
program_id,
payer,
&coin_wallet.pubkey(),
&market_keys,
&mut orders,
NewOrderInstruction {
side: Side::Ask,
limit_price: NonZeroU64::new(499).unwrap(),
max_qty: NonZeroU64::new(1_000).unwrap(),
order_type: OrderType::Limit,
client_id: 985982,
},
)?;
println!("Ask account: {}", orders.unwrap());
println!("Matching orders in 15s ...");
std::thread::sleep(std::time::Duration::new(15, 0));
match_orders(
client,
program_id,
payer,
&market_keys,
&coin_wallet.pubkey(),
&pc_wallet.pubkey(),
)?;
println!("Consuming events in 15s ...");
std::thread::sleep(std::time::Duration::new(15, 0));
consume_events(
client,
program_id,
payer,
&market_keys,
&coin_wallet.pubkey(),
&pc_wallet.pubkey(),
)?;
settle_funds(
client,
program_id,
payer,
&market_keys,
Some(payer),
&orders.unwrap(),
&coin_wallet.pubkey(),
&pc_wallet.pubkey(),
)?;
Ok(())
}
fn place_order(
client: &RpcClient,
program_id: &Pubkey,
payer: &Keypair,
wallet: &Pubkey,
state: &MarketPubkeys,
orders: &mut Option<Pubkey>,
new_order: NewOrderInstruction,
) -> Result<()> {
let mut instructions = Vec::new();
let orders_keypair;
let mut signers = Vec::new();
let orders_pubkey = match *orders {
Some(pk) => pk,
None => {
let (orders_key, instruction) = create_dex_account(
client,
program_id,
&payer.pubkey(),
size_of::<serum_dex::state::OpenOrders>(),
)?;
orders_keypair = orders_key;
signers.push(&orders_keypair);
instructions.push(instruction);
orders_keypair.pubkey()
}
};
*orders = Some(orders_pubkey);
let side = new_order.side;
let data = MarketInstruction::NewOrder(new_order).pack();
let instruction = Instruction {
program_id: *program_id,
data,
accounts: vec![
AccountMeta::new(*state.market, false),
AccountMeta::new(orders_pubkey, false),
AccountMeta::new(*state.req_q, false),
AccountMeta::new(*wallet, false),
AccountMeta::new(payer.pubkey(), true),
AccountMeta::new(*state.coin_vault, false),
AccountMeta::new(*state.pc_vault, false),
AccountMeta::new(spl_token::ID, false),
AccountMeta::new_readonly(solana_sdk::sysvar::rent::ID, false),
],
};
instructions.push(instruction);
signers.push(payer);
let (recent_hash, _fee_calc) = client.get_recent_blockhash()?;
let txn = Transaction::new_signed_with_payer(
&instructions,
Some(&payer.pubkey()),
&signers,
recent_hash,
);
send_txn(client, &txn, false)?;
Ok(())
}
fn settle_funds(
client: &RpcClient,
program_id: &Pubkey,
payer: &Keypair,
state: &MarketPubkeys,
signer: Option<&Keypair>,
orders: &Pubkey,
coin_wallet: &Pubkey,
pc_wallet: &Pubkey,
) -> Result<()> {
let data = MarketInstruction::SettleFunds.pack();
let instruction = Instruction {
program_id: *program_id,
data,
accounts: vec![
AccountMeta::new(*state.market, false),
AccountMeta::new(*orders, false),
AccountMeta::new_readonly(signer.unwrap_or(payer).pubkey(), true),
AccountMeta::new(*state.coin_vault, false),
AccountMeta::new(*state.pc_vault, false),
AccountMeta::new(*coin_wallet, false),
AccountMeta::new(*pc_wallet, false),
AccountMeta::new_readonly(*state.vault_signer_key, false),
AccountMeta::new_readonly(spl_token::ID, false),
],
};
let (recent_hash, _fee_calc) = client.get_recent_blockhash()?;
let mut signers = vec![payer];
if let Some(s) = signer {
signers.push(s);
}
let txn = Transaction::new_signed_with_payer(
&[instruction],
Some(&payer.pubkey()),
&signers,
recent_hash,
);
let mut i = 0;
loop {
i += 1;
assert!(i < 10);
println!("Simulating SettleFunds instruction ...");
let result = client.simulate_transaction(&txn, true)?;
println!("{:#?}", result.value);
if result.value.err.is_none() {
break;
}
}
println!("Settling ...");
send_txn(client, &txn, false)?;
Ok(())
}
fn list_market(
client: &RpcClient,
program_id: &Pubkey,
payer: &Keypair,
coin_mint: &Pubkey,
pc_mint: &Pubkey,
coin_lot_size: u64,
pc_lot_size: u64,
) -> Result<MarketPubkeys> {
let (listing_keys, mut instructions) =
gen_listing_params(client, program_id, &payer.pubkey(), coin_mint, pc_mint)?;
let ListingKeys {
market_key,
req_q_key,
event_q_key,
bids_key,
asks_key,
vault_signer_pk,
vault_signer_nonce,
} = listing_keys;
println!("Creating coin vault...");
let coin_vault = create_account(client, coin_mint, &vault_signer_pk, payer)?;
println!("Creating pc vault...");
let pc_vault = create_account(client, pc_mint, &listing_keys.vault_signer_pk, payer)?;
let init_market_instruction = serum_dex::instruction::initialize_market(
&market_key.pubkey(),
program_id,
coin_mint,
pc_mint,
&coin_vault.pubkey(),
&pc_vault.pubkey(),
&bids_key.pubkey(),
&asks_key.pubkey(),
&req_q_key.pubkey(),
&event_q_key.pubkey(),
coin_lot_size,
pc_lot_size,
vault_signer_nonce,
100,
)?;
println!(
"initialize_market_instruction: {:#?}",
&init_market_instruction
);
instructions.push(init_market_instruction);
let (recent_hash, _fee_calc) = client.get_recent_blockhash()?;
let signers = vec![
payer,
&market_key,
&req_q_key,
&event_q_key,
&bids_key,
&asks_key,
&req_q_key,
&event_q_key,
];
let txn = Transaction::new_signed_with_payer(
&instructions,
Some(&payer.pubkey()),
&signers,
recent_hash,
);
println!("txn:\n{:#x?}", txn);
let result = client.simulate_transaction(&txn, true)?;
println!("{:#?}", result.value);
println!("Listing {} ...", market_key.pubkey());
send_txn(client, &txn, false)?;
Ok(MarketPubkeys {
market: Box::new(market_key.pubkey()),
req_q: Box::new(req_q_key.pubkey()),
event_q: Box::new(event_q_key.pubkey()),
bids: Box::new(bids_key.pubkey()),
asks: Box::new(asks_key.pubkey()),
coin_vault: Box::new(coin_vault.pubkey()),
pc_vault: Box::new(pc_vault.pubkey()),
vault_signer_key: Box::new(vault_signer_pk),
})
}
struct ListingKeys {
market_key: Keypair,
req_q_key: Keypair,
event_q_key: Keypair,
bids_key: Keypair,
asks_key: Keypair,
vault_signer_pk: Pubkey,
vault_signer_nonce: u64,
}
fn gen_listing_params(
client: &RpcClient,
program_id: &Pubkey,
payer: &Pubkey,
coin_mint: &Pubkey,
pc_mint: &Pubkey,
) -> Result<(ListingKeys, Vec<Instruction>)> {
let (market_key, create_market) = create_dex_account(client, program_id, payer, 368)?;
let (req_q_key, create_req_q) = create_dex_account(client, program_id, payer, 640)?;
let (event_q_key, create_event_q) = create_dex_account(client, program_id, payer, 1 << 20)?;
let (bids_key, create_bids) = create_dex_account(client, program_id, payer, 1 << 16)?;
let (asks_key, create_asks) = create_dex_account(client, program_id, payer, 1 << 16)?;
let (vault_signer_nonce, vault_signer_pk) = {
let mut i = 0;
loop {
assert!(i < 100);
if let Ok(pk) = gen_vault_signer_key(i, &market_key.pubkey(), program_id) {
break (i, pk);
}
i += 1;
}
};
let info = ListingKeys {
market_key,
req_q_key,
event_q_key,
bids_key,
asks_key,
vault_signer_pk,
vault_signer_nonce,
};
let instructions = vec![
create_market,
create_req_q,
create_event_q,
create_bids,
create_asks,
];
Ok((info, instructions))
}
fn create_dex_account(
client: &RpcClient,
program_id: &Pubkey,
payer: &Pubkey,
unpadded_len: usize,
) -> Result<(Keypair, Instruction)> {
let len = unpadded_len + 12;
let key = Keypair::generate(&mut OsRng);
let create_account_instr = solana_sdk::system_instruction::create_account(
payer,
&key.pubkey(),
client.get_minimum_balance_for_rent_exemption(len)?,
len as u64,
program_id,
);
Ok((key, create_account_instr))
}
fn match_orders(
client: &RpcClient,
program_id: &Pubkey,
payer: &Keypair,
state: &MarketPubkeys,
coin_wallet: &Pubkey,
pc_wallet: &Pubkey,
) -> Result<()> {
let instruction_data: Vec<u8> = MarketInstruction::MatchOrders(2).pack();
let instruction = Instruction {
program_id: *program_id,
accounts: vec![
AccountMeta::new(*state.market, false),
AccountMeta::new(*state.req_q, false),
AccountMeta::new(*state.event_q, false),
AccountMeta::new(*state.bids, false),
AccountMeta::new(*state.asks, false),
AccountMeta::new(*coin_wallet, false),
AccountMeta::new(*pc_wallet, false),
],
data: instruction_data,
};
let (recent_hash, _fee_calc) = client.get_recent_blockhash()?;
let txn = Transaction::new_signed_with_payer(
std::slice::from_ref(&instruction),
Some(&payer.pubkey()),
&[payer],
recent_hash,
);
println!("Simulating order matching ...");
let result = client.simulate_transaction(&txn, true)?;
println!("{:#?}", result.value);
if result.value.err.is_none() {
println!("Matching orders ...");
send_txn(client, &txn, false)?;
}
Ok(())
}
fn create_account(
client: &RpcClient,
mint_pubkey: &Pubkey,
owner_pubkey: &Pubkey,
payer: &Keypair,
) -> Result<Keypair> {
let spl_account = Keypair::generate(&mut OsRng);
let signers = vec![payer, &spl_account];
let lamports = client.get_minimum_balance_for_rent_exemption(spl_token::state::Account::LEN)?;
let create_account_instr = solana_sdk::system_instruction::create_account(
&payer.pubkey(),
&spl_account.pubkey(),
lamports,
spl_token::state::Account::LEN as u64,
&spl_token::ID,
);
let init_account_instr = token_instruction::initialize_account(
&spl_token::ID,
&spl_account.pubkey(),
&mint_pubkey,
&owner_pubkey,
)?;
let instructions = vec![create_account_instr, init_account_instr];
let (recent_hash, _fee_calc) = client.get_recent_blockhash()?;
let txn = Transaction::new_signed_with_payer(
&instructions,
Some(&payer.pubkey()),
&signers,
recent_hash,
);
println!("Creating account: {} ...", spl_account.pubkey());
send_txn(client, &txn, false)?;
Ok(spl_account)
}
fn mint_to_existing_account(
client: &RpcClient,
payer: &Keypair,
minting_key: &Keypair,
mint: &Pubkey,
recipient: &Pubkey,
quantity: u64,
) -> Result<()> {
let signers = vec![payer, minting_key];
let mint_tokens_instr = token_instruction::mint_to(
&spl_token::ID,
mint,
recipient,
&minting_key.pubkey(),
&[],
quantity,
)?;
let instructions = vec![mint_tokens_instr];
let (recent_hash, _fee_calc) = client.get_recent_blockhash()?;
let txn = Transaction::new_signed_with_payer(
&instructions,
Some(&payer.pubkey()),
&signers,
recent_hash,
);
send_txn(client, &txn, false)?;
Ok(())
}
fn mint_to_new_account(
client: &RpcClient,
payer: &Keypair,
minting_key: &Keypair,
mint: &Pubkey,
quantity: u64,
) -> Result<Keypair> {
let recip_keypair = Keypair::generate(&mut OsRng);
let lamports = client.get_minimum_balance_for_rent_exemption(spl_token::state::Account::LEN)?;
let signers = vec![payer, minting_key, &recip_keypair];
let create_recip_instr = solana_sdk::system_instruction::create_account(
&payer.pubkey(),
&recip_keypair.pubkey(),
lamports,
spl_token::state::Account::LEN as u64,
&spl_token::ID,
);
let init_recip_instr = token_instruction::initialize_account(
&spl_token::ID,
&recip_keypair.pubkey(),
mint,
&payer.pubkey(),
)?;
let mint_tokens_instr = token_instruction::mint_to(
&spl_token::ID,
mint,
&recip_keypair.pubkey(),
&minting_key.pubkey(),
&[],
quantity,
)?;
let instructions = vec![create_recip_instr, init_recip_instr, mint_tokens_instr];
let (recent_hash, _fee_calc) = client.get_recent_blockhash()?;
let txn = Transaction::new_signed_with_payer(
&instructions,
Some(&payer.pubkey()),
&signers,
recent_hash,
);
send_txn(client, &txn, false)?;
Ok(recip_keypair)
}
fn initialize_token_account(client: &RpcClient, mint: &Pubkey, owner: &Keypair) -> Result<Keypair> {
let recip_keypair = Keypair::generate(&mut OsRng);
let lamports = client.get_minimum_balance_for_rent_exemption(spl_token::state::Account::LEN)?;
let create_recip_instr = solana_sdk::system_instruction::create_account(
&owner.pubkey(),
&recip_keypair.pubkey(),
lamports,
spl_token::state::Account::LEN as u64,
&spl_token::ID,
);
let init_recip_instr = token_instruction::initialize_account(
&spl_token::ID,
&recip_keypair.pubkey(),
mint,
&owner.pubkey(),
)?;
let signers = vec![owner, &recip_keypair];
let instructions = vec![create_recip_instr, init_recip_instr];
let (recent_hash, _fee_calc) = client.get_recent_blockhash()?;
let txn = Transaction::new_signed_with_payer(
&instructions,
Some(&owner.pubkey()),
&signers,
recent_hash,
);
send_txn(client, &txn, false)?;
Ok(recip_keypair)
}
fn genesis(
client: &RpcClient,
payer_keypair: &Keypair,
mint_keypair: &Keypair,
owner_pubkey: &Pubkey,
decimals: u8,
) -> Result<()> {
let signers = vec![payer_keypair, mint_keypair];
let lamports = client.get_minimum_balance_for_rent_exemption(spl_token::state::Mint::LEN)?;
let create_mint_account_instruction = solana_sdk::system_instruction::create_account(
&payer_keypair.pubkey(),
&mint_keypair.pubkey(),
lamports,
spl_token::state::Mint::LEN as u64,
&spl_token::ID,
);
let initialize_mint_instruction = token_instruction::initialize_mint(
&spl_token::ID,
&mint_keypair.pubkey(),
owner_pubkey,
None,
decimals,
)?;
let instructions = vec![create_mint_account_instruction, initialize_mint_instruction];
let (recent_hash, _fee_calc) = client.get_recent_blockhash()?;
let txn = Transaction::new_signed_with_payer(
&instructions,
Some(&payer_keypair.pubkey()),
&signers,
recent_hash,
);
send_txn(client, &txn, false)?;
Ok(())
}
enum MonitorEvent {
NumEvents(usize),
NewConn(std::net::TcpStream),
}
fn accept_loop(port: u16, mut send: Sender<MonitorEvent>) {
let address = format!("127.0.0.1:{}", port);
let listener = std::net::TcpListener::bind(&address).unwrap();
for stream in listener.incoming() {
send.send(MonitorEvent::NewConn(stream.unwrap())).unwrap();
}
}
fn websockets_loop(mut recv: Receiver<MonitorEvent>) {
let mut websockets: Vec<tungstenite::WebSocket<std::net::TcpStream>> = Vec::new();
let recv_every = time::Duration::from_millis(10000);
while let Ok(value) = recv.recv_timeout(recv_every) {
match value {
MonitorEvent::NumEvents(events) => {
let message = format!("{{ \"events_in_queue\": {} }}", events);
let message = tungstenite::Message::Text(message);
for socket in &mut websockets {
socket.write_message(message.clone()).unwrap();
}
},
MonitorEvent::NewConn(conn) => {
// Tungstenite errors don't implement debug so we can't unwrap?
// Generally we just die here anyways
if let Ok(conn) = tungstenite::accept(conn) {
websockets.push(conn);
} else {
panic!("Couldn't accept websocket stream for unknown reason");
}
}
}
}
}
fn read_queue_length_loop(
client: RpcClient,
program_id: Pubkey,
market: Pubkey,
sender: std::sync::mpsc::Sender<MonitorEvent>
) -> Result<()> {
let market_keys = get_keys_for_market(&client, &program_id, &market)?;
loop {
let event_q_data = client
.get_account_with_commitment(&market_keys.event_q, CommitmentConfig::recent())?
.value
.expect("Failed to retrieve account")
.data;
let inner: Cow<[u64]> = remove_dex_account_padding(&event_q_data)?;
let (header, seg0, seg1) = parse_event_queue(&inner)?;
let event_q_len = seg0.len() + seg1.len();
sender.send(MonitorEvent::NumEvents(event_q_len)).unwrap();
let send_every = time::Duration::from_millis(3000);
thread::sleep(send_every);
}
}
Reference in New Issue View Git Blame Copy Permalink