// // When inserting a new Order into the royalties tree, we must make sure the existing // royalties don't get shared with that new node. To do this, we must "shave" down // the tree, pushing royalties from the root down to all nodes to the left of the // new node. // // Case to think about: // Selling 140000 USD to buy 2 BTC. Weight is ===140k USD // Selling 50000 GBP to buy 1 BTC. Weight is === 50k GBP // // Quick & Dirty Documentation // // Running lzf1 from a command line: // lzf1 # --Interactive is the default mode, no need to // lzf1 --log tuesday.log # Same as above, but log all commands to file tuesday.log // lzf1 --replay tuesday.log # Replay tuesday.log, then go into interactive mode // lzf1 --replay tuesday.log --log wednesday.log # Replay tuesday.log, then go interactive logging additional commands to wednesday.log // lzf1 --replay tuesday.log --log tuesday.log # Replay tuesday.log, then go interactive, then append additional commands to tuesday.log // Commands in Interactive Mode: // addasset USD # Case sensitive, no spaces // setroyalty USD 0.01 0.00 0.03 0.02 # Sets 1% royalty when order selling USD is placed, but no commission. // # Then additional 3% royalty when order executes, plus 2% commission // addtrader Teppy # Case sensitive, no spaces // addfunds Teppy 20000 USD # Create funds from thin air. Do this when we receive a wire transfer, for instance. // subfunds Teppy 0.5 BTC # Remove funds. Do this when we process a withdrawal. // balances Teppy # Show all of Teppy's funds (but not what has been moved to the market) // login Teppy # Some commands take an implicit Trader parameter. This sets that parameter // whoami # Shows logged in name for this Interactive session // showorders # Shows orders for the logged in Trader // wallet # Show all of the logged-in trader's funds (but not what is on the market) // order 0.5 BTC 30000 USD # Create an order selling 0.5 BTC to buy 30000 USD. Uses logged in Trader's balance. // orderbatch 0.5 BTC 30000 USD # Enter an order but don't execute it (allow it to contribute to a crossed market) // quit # Clean exit // // // // Thoughts on cheapest-path algorithm: // Create a square matrix of costs from each asset to each asset. Some of the entries will be infinity. The goal is to lower the entries. // In each cell, store not just the cost, but the path and path capacity. // Starting with the source asset, see if visiting each other asset lowers the cost to get there. If it does, replace that asset's cost with the new cost and path. // #![allow(unsafe_code)] #![allow(unused_variables)] #![allow(dead_code)] use std::fs::File; use std::fs::OpenOptions; use std::path::Path; use std::io::{self, BufRead, Write}; use std::env; use std::collections::HashMap; use std::collections::HashSet; use std::cmp::Ordering; use std::cmp::min; use rand::prelude::*; use rand::rngs::StdRng; use std::time::Instant; //use hashbrown::HashMap; mod finum; use finum::FiNum; #[derive(Debug, Clone)] struct Trader { name: String, password: String, // hash(name..salt..password) id: usize, balances: HashMap, // Maps Currency to Amount order_finder: HashMap, // Maps OrderIDs to asset pairs (Order trees) } #[derive(Clone)] struct Asset { name: String, royalty0_rate: FiNum, // Traders get this when entered royalty1_rate: FiNum, // Traders get this when executed commission0_rate: FiNum, // House gets this when entered commission1_rate: FiNum, // House gets this when executed } impl Asset { fn new(name: &str) -> Self { Asset { name: String::from(name), royalty0_rate:FiNum::zero(), royalty1_rate:FiNum::zero(), commission0_rate:FiNum::zero(), commission1_rate:FiNum::zero(), } } } impl Trader { fn new(name:&str,id:usize) -> Self { Trader { name: String::from(name), password: String::from(""), id: id, balances: HashMap::new(), order_finder: HashMap::new(), } } fn add_balance(&mut self, cur:usize, delta:FiNum) { self.balances.entry(cur).and_modify(|ent| *ent+=delta ).or_insert_with(|| delta); } fn sub_balance(&mut self, cur:usize, delta:FiNum) { self.balances.entry(cur).and_modify(|ent| *ent-=delta ); } fn get_balance(&self, cur:usize) -> FiNum { *self.balances.get(&cur).map(|bal| bal).unwrap_or(&FiNum::new(0u64)) } } #[derive(Debug, Clone)] struct Order { sell_qty: FiNum, sell_remain: FiNum, buy_qty: FiNum, royalty_remain: FiNum, // Based on royalty1. The thing that is being sold commission_remain: FiNum, // Based on commission1. The thing that is being sold owner: usize, order_id: usize, } struct Orderlet { // When executing against an Order, either the Order gets consumed or the Orderlet. Or occasionally both. buy_qty: FiNum, royalty0_qty: FiNum, royalty1_qty: FiNum, commission0_qty: FiNum, commission1_qty: FiNum, } struct RoyaltyTree { tree: Vec, next_entry: usize, spare_change: FiNum, // Waiting to be distributed order_finder: HashMap, // Maps OrderID to location (index) in the tree } struct Royalty { count: usize, // Here and below weight: FiNum, // Here and below lazy: FiNum, // To be distributed to here and to below based on weights acc: FiNum, // Accumulated here order_id: usize, } impl Royalty { fn new() -> Self { Royalty { weight:FiNum::zero(), lazy:FiNum::zero(), acc:FiNum::zero(), order_id:0, count:0 } } } impl RoyaltyTree { fn new() -> Self { RoyaltyTree { tree:Vec::new(), next_entry:0, spare_change:FiNum::zero(), order_finder:HashMap::new() } } fn acc_total(&self) -> FiNum { let mut rval=FiNum::zero(); for r in &self.tree { rval+= r.acc+r.lazy; } rval } fn weight_here_below(&self, index:usize) -> FiNum { self.tree[index].weight } fn count_here_below(&self, index:usize) -> usize { self.tree[index].count } fn weight_below(&self, index: usize) -> FiNum { if index&1==0 { FiNum::zero() } else { let w0=self.weight_here_below(wt_left (index).unwrap()); let w1=self.weight_here_below(wt_right(index).unwrap()); w0+w1 } } fn count_below(&self, index: usize) -> usize { if index&1==0 { 0 } else { let c0=self.count_here_below(wt_left (index).unwrap()); let c1=self.count_here_below(wt_right(index).unwrap()); c0+c1 } } fn weight_here(&self, index:usize) -> FiNum { if index&1==0 { self.weight_here_below(index) } else { let w0=self.weight_here_below(index); let w1=self.weight_below(index); w0-w1 } } fn count_here(&self, index:usize) -> usize { if index&1==0 { self.count_here_below(index) } else { let c0=self.count_here_below(index); let c1=self.count_below(index); if c1>c0 { println!("Count_here({}) ... c0={} c1={}",index,c0,c1) }; c0-c1 } } fn expand_to(&mut self, index: usize) -> &mut Self { for _ in self.tree.len()..=index { self.tree.push(Royalty::new()) } self } fn capture0(&mut self, index: usize) -> &mut Self { if index&1==0 { let lazy=self.tree[index].lazy; self.tree[index].acc+=lazy; self.tree[index].lazy=FiNum::zero(); } else { let lazy=self.tree[index].lazy; let d1=if lazy>0.into() { lazy*self.weight_here(index)/self.weight_here_below(index) } else { FiNum::zero() }; let d02=lazy-d1; let index_left =wt_left (index).unwrap(); let index_right=wt_right(index).unwrap(); if self.weight_below(index)>0.into() { let d0=if d02>0.into() { d02*self.weight_here_below(index_left)/self.weight_below(index) } else { FiNum::zero() }; let d2=d02-d0; // self.sanity(); if !self.weight_here_below(index_left ).is_zero() { self.tree[index_left ].lazy+=d0; } else { self.spare_change+=d0; } if !self.weight_here_below(index_right).is_zero() { self.tree[index_right].lazy+=d2; } else { self.spare_change+=d2; } } else { self.spare_change+=d02; } self.tree[index].acc+=d1; self.tree[index].lazy=FiNum::zero(); } self } fn sanity(&self) { for i in 0..self.tree.len() { assert!(!self.weight_here_below(i).is_tiny(),"Weight at {} is tiny",i); assert!(!self.tree[i].acc .is_tiny(),"Acc at {} is tiny",i); assert!(!self.tree[i].lazy.is_tiny(),"Lazy at {} is tiny",i); } } fn get_royalty(&mut self, index: usize) -> FiNum { let mut f=self.forefather(); while f!=index { self.capture0(f); f=if f>index { wt_left(f).unwrap() } else { wt_right(f).unwrap() } } self.capture0(f); self.tree[index].acc } fn add_royalty(&mut self, amount: FiNum) { if self.next_entry==0 || FiNum::is_zero(self.tree[self.forefather()].weight) { self.spare_change+=amount } else { let ff=self.forefather(); if self.weight_here_below(ff).is_zero() { self.spare_change+=amount } else { self.tree[ff].lazy+=amount+self.spare_change; self.spare_change=FiNum::zero() }; } } // We really need two methods: remove an order and redistribute, remove some and return captured amount fn remove_order_id(&mut self, id: usize) -> FiNum { // And zero out in the tree if let Some(pos)=self.order_finder.remove(&id) { self.capture0(pos); let weight=self.weight_here(pos); self.sub_weight(pos,weight); let rval=self.tree[pos].acc; self.tree[pos].acc=FiNum::zero(); rval } else { FiNum::zero() } } fn random_order_id(&self, rng: &mut rand::rngs::StdRng) -> Option { if self.tree.len()==0 { return None } let mut f=self.forefather(); while self.count_here_below(f)>0 { if f&1==0 { return Some(f); } let c0=self.count_here(f); let c1=if f&1==0 { self.count_here(f) } else { self.count_here_below(wt_left(f).unwrap()) }; let c2=if f&1==0 { self.count_here(f) } else { self.count_here_below(wt_right(f).unwrap()) }; let c=c0+c1+c2; let r=rng.gen_range(0..c); if r FiNum { if let Some(&index)=self.order_finder.get(&order_id) { self.capture0(index); let rval=self.tree[index].acc; self.tree[index].acc=FiNum::zero(); rval } else { FiNum::zero() } } fn sub_weight(&mut self, index: usize, mut weight: FiNum) { self.get_royalty(index); let delta_count; let wh=self.weight_here(index); if weight>=wh { delta_count=if wh>FiNum::zero() { 1 } else { 0 }; weight=wh; } else { delta_count=0; } let mut index=index; let ff=self.forefather(); loop { self.tree[index].weight-=weight; self.tree[index].count-=delta_count; if index==ff { break; } index=wt_parent(index); } } fn set_location(&mut self, id: usize, index: usize) { self.tree[index].order_id=id; self.order_finder.insert(id,index); } fn add_weight(&mut self, index: usize, weight: FiNum) { if self.tree.len()>0 { let mut ff0=self.forefather(); let ff1=wt_forefather(index); let w=self.tree[ff0].weight; let c=self.tree[ff0].count; self.expand_to(ff1*2); while ff0 usize { wt_forefather(self.tree.len()-1) } fn dump(&mut self) { for index in 0..self.tree.len() { let roy=self.get_royalty(index); println!("Index {} Count {} Weight {} Lazy {} Acc {} Royalty {}",index,self.tree[index].count,self.tree[index].weight,self.tree[index].lazy,self.tree[index].acc,roy); } } fn raw_dump(&mut self) { for index in 0..self.tree.len() { println!("Index {}: Weight {} Lazy {} Acc {} Order_ID {}",index,self.tree[index].weight,self.tree[index].lazy.value(),self.tree[index].acc,self.tree[index].order_id); } } } trait Dumpable { fn dump(&self); } impl Dumpable for usize { fn dump(&self) { println!("Dump Integer: {}",self); } } impl Dumpable for Order { fn dump(&self) { println!("Giving {}/{} ({} each) to get {}",self.sell_remain,self.sell_qty,self.buy_qty/self.sell_qty,self.buy_qty); } } struct Market { asset_name2num: HashMap, assets: Vec, money_supply: HashMap, traders: Vec, trader_name2num: HashMap, orders: HashMap<(usize,usize),OrderQueue>, shadows: HashSet<(usize,usize)>, royalties: HashMap, // Active orders that are accepting asset X. They receive royalties when someone makes an order to sell X royalty_rate: HashMap, order_finder: HashMap, // Maps Order ID to an asset pair (in other systems, a "market.") From there you can look in self.orders.get((usize,usize)) which is an OrderQueue, and OrderQueues have a mapping from ID to position in the OrderQueue order_count: usize, next_order_id: usize, rng: StdRng, } impl Market { fn new() -> Self { let mut rval=Market { asset_name2num: HashMap::new(), assets: Vec::new(), money_supply: HashMap::new(), traders: Vec::new(), trader_name2num: HashMap::new(), orders: HashMap::new(), shadows: HashSet::new(), royalties: HashMap::new(), royalty_rate: HashMap::new(), order_finder: HashMap::new(), order_count: 0, next_order_id: 1, rng: StdRng::seed_from_u64(1u64), }; rval.register_trader("*HOUSE*"); rval } fn sanity_check(&self) { println!("Sanity Checking Market..."); for (cur,amt) in self.money_supply.iter() { println!("Money Supply {}: {}",self.number_to_name(*cur),*amt); let mut off_orders=FiNum::new(0); let mut off_roy=FiNum::new(0); let mut off_com=FiNum::new(0); for (ac,pq) in &self.orders { if ac.0==*cur { for off in &*pq.v { off_orders+=off.sell_remain; off_roy +=off.royalty_remain; off_com +=off.commission_remain; } } } let mut acc_traders=FiNum::new(0); let mut ntraders=0; for t in &self.traders { let b=t.get_balance(*cur); if !b.is_zero() { ntraders+=1 } acc_traders+=b; } let ar = self.royalties.get(cur).map(|rt| rt.acc_total()).unwrap_or(FiNum::zero()); let sc = self.royalties.get(cur).map(|rt| rt.spare_change).unwrap_or(FiNum::zero()); let acc=acc_traders+off_orders+off_roy+off_com+ar+sc; println!(" Traders {}",acc_traders); println!(" Orders {}",off_orders); println!(" Royalties in Orders {}",off_roy); println!(" Commissions in Orders {}",off_com); println!(" Accumulated Royalties {}",ar); println!(" Spare Change Royalties {}",sc); println!(" Total from Above {}",acc); println!(" Total from Money Supply {} {}",*amt,if *amt!=acc { " Mismatch!" } else { "" }); } } fn random_order_id(&mut self) -> Option { let x=self.rng.gen_range(0..self.order_count); let mut bottom=0; for (pair,bucket) in &self.orders { if x usize { // Add error checking for inserting a trader twice let rval=self.traders.len(); self.trader_name2num.insert(String::from(name),self.traders.len()); self.traders.push(Trader::new(name,rval)); rval } // These are the only ways to get money into or out of the market. fn get_trader_balance(&self, who:usize, cur:usize) -> FiNum { self.traders[who].get_balance(cur) } fn add_trader_balance(&mut self, who:usize, cur:usize, delta: FiNum) { self.traders[who].add_balance(cur,delta); *self.money_supply.get_mut(&cur).unwrap()+=delta; } fn sub_trader_balance(&mut self, who:usize, cur:usize, delta: FiNum) { self.traders[who].sub_balance(cur,delta); *self.money_supply.get_mut(&cur).unwrap()-=delta; } fn register_asset(&mut self, name:&str) -> Option { if self.asset_name2num.contains_key(name) { return None } self.assets.push(Asset::new(name)); self.asset_name2num.insert(String::from(name),self.assets.len()-1); self.money_supply.insert(self.assets.len()-1,FiNum::new(0)); let rval=self.assets.len()-1; Some(rval) } fn set_royalty(&mut self, n: usize, roy0: FiNum, com0: FiNum, roy1: FiNum, com1: FiNum) { self.assets[n].royalty0_rate =roy0; self.assets[n].commission0_rate=com0; self.assets[n].royalty1_rate =roy1; self.assets[n].commission1_rate=com1; } fn number_to_asset(&self, n: usize) -> Asset { self.assets[n].clone() } fn number_to_name(&self, n: usize) -> String { self.assets[n].name.clone() } fn name_to_number(&self, name:&str) -> Option<&usize> { self.asset_name2num.get(name) } fn dump(&mut self) { println!("Dumping Market:"); println!("Asset MoneySupply Royalty% Commission%"); for index in 0..self.assets.len() { let ass=self.number_to_asset(index); let aname=self.money_supply[&index].to_string(); println!(" {:<3}{:>16} {}/{} {}/{}",ass.name,aname,ass.royalty0_rate.fmt_pct2(),ass.royalty1_rate.fmt_pct2(),ass.commission0_rate.fmt_pct2(),ass.commission1_rate.fmt_pct2()); } for (ap,pq) in &self.orders { println!("Orders selling {} to buy {}:",self.number_to_name(ap.0),self.number_to_name(ap.1)); let mut sorted=pq.v.clone(); sorted.sort_by(|a,b| { (b.sell_qty/b.buy_qty).cmp(&(a.sell_qty/a.buy_qty)) }); for off in sorted.iter() { let rt=self.royalties.get_mut(&ap.1).unwrap(); let indexr=rt.order_finder.get(&off.order_id).unwrap(); let royalty_amt=rt.get_royalty(*indexr); println!(" {} @ {} ({}) OrderID: {} Accumulated: {} Royalties {} Commissions: {}", off.sell_remain, // off.buy_qty*off.sell_remain/off.sell_qty, (off.buy_qty/off.sell_qty).fmt_recip(), self.traders[off.owner as usize].name, off.order_id, royalty_amt,off.royalty_remain,off.commission_remain); } } println!("Royalty Accum SpareChange"); for index in 0..self.assets.len() { self.royalties.entry(index).or_insert(RoyaltyTree::new()); let name=self.number_to_asset(index).name; let rt=self.royalties.get_mut(&index).unwrap(); let sc=rt.spare_change; let tot=rt.acc_total(); println!(" {:<3} {} {}",name,tot,sc); for indexr in 0..rt.tree.len() { let royalty_amt=rt.get_royalty(indexr); let r=&rt.tree[indexr]; let count=r.count; let weight=r.weight; let lazy=r.lazy; let acc=r.acc; if !royalty_amt.is_zero() || count!=0 || !weight.is_zero() || !lazy.is_zero() || !acc.is_zero() { // Heavy Debug println!(" Index {} Count {} Weight {} Lazy {} Acc {} Royalty {} OrderID {}",indexr,r.count,r.weight,r.lazy,r.acc,royalty_amt,r.order_id); println!(" Index {} Weight {} Royalty {} OrderID {}",indexr,r.weight,royalty_amt,r.order_id); } } // Heavy Debug for (k,v) in &rt.order_finder { println!(" Order ID {} at position {}",k,v); } } println!("Trader Balances:"); for t in &self.traders { println!(" Trader {}: {}",t.id,t.name); for (cur,bal) in t.balances.iter() { println!(" {}: {}",self.number_to_name(*cur),*bal) } } } fn replay_file(&mut self, fname:&str) { println!("Replaying {}",fname); let f=File::open(Path::new(fname)); let reader=io::BufReader::new(f.unwrap()); for line in reader.lines() { if let Ok(line) = line { let line=clean_replay(&line); let cmd=Command::deserialize(line); if let Command::NOP(comment)=cmd { println!("{}",comment); } else { println!("{}",cmd.explain(self)); let res=self.execute(&cmd); println!("{}",res.describe()); } } } } /* fn execute_batch(&mut self, asset_type0: usize, strike0: FiNum, asset_type1: usize, strike1: FiNum) -> Result { let mut log:Vec=Vec::new(); let asset0=self.number_to_asset(asset_type0); let asset1=self.number_to_asset(asset_type1); log.push(format!("Executing batch {} {} <-> {} {}",strike0,asset0.name,strike1,asset1.name)); println!("Executing batch {} {} <-> {} {}",strike0,asset0.name,strike1,asset1.name); let ap0=(asset_type0,asset_type1); let ap1=(asset_type1,asset_type0); let [bids0,bids1]=self.orders.get_many_mut([&ap0, &ap1]).unwrap(); // There's a workaround for this where you remove and reinsert the keys. let bids0p=bids0.peek(); let bids1p=bids1.peek(); while !bids0.empty() && !bids1.empty() && bids0.peek().sell_qty/bids0.peek().buy_qty>=strike0/strike1 && bids1.peek().sell_qty/bids1.peek().buy_qty>=strike1/strike0 { println!("For Asset0 ({}) paying either {} or {}",asset0.name,bids0.peek().sell_remain,strike0*bids1.peek().sell_remain/strike1); println!("For Asset1 ({}) paying either {} or {}",asset1.name,bids1.peek().sell_remain,strike1*bids0.peek().sell_remain/strike0); let asset0_paying =std::cmp::min(bids0.peek().sell_remain,strike0*bids1.peek().sell_remain/strike1); let asset1_paying =std::cmp::min(bids1.peek().sell_remain,strike1*bids0.peek().sell_remain/strike0); bids0.peek().sell_remain-=asset0_paying; bids1.peek().sell_remain-=asset1_paying; self.traders[bids0.peek().owner].add_balance(asset_type1,asset1_paying); self.traders[bids1.peek().owner].add_balance(asset_type0,asset0_paying); log.push(format!(" {} got {} {}, {} got {} {}",self.traders[bids0.peek().owner].name,asset1_paying,asset1.name, self.traders[bids1.peek().owner].name,asset0_paying,asset0.name)); if bids0.peek().sell_remain==FiNum::zero() { println!("Nope0!!!"); bids0.pop(); self.order_count-=1; } // Stopped work here. Must fixup all the data structures for these pops. if bids1.peek().sell_remain==FiNum::zero() { println!("Nope1!!!"); bids1.pop(); self.order_count-=1; } } Result::ExecutedBatch(log) } */ fn retract_order(&mut self, order_id:usize) -> Result { // Still need to credit back funds! let pair=self.order_finder.get(&order_id).unwrap(); let sell_type=pair.0; let buy_type=pair.1; let queue=self.orders.get_mut(pair).unwrap(); let queue_index=*queue.order_finder.get(&order_id).unwrap(); let order=&queue.v[queue_index]; let credit=order.sell_remain+order.royalty_remain+order.commission_remain; self.traders[order.owner].add_balance(sell_type,credit); println!("Order owner is {}",order.owner); // Remove from royalties let rt=self.royalties.get_mut(&pair.0).unwrap(); let dist=rt.remove_order_id(order_id); self.traders[order.owner].add_balance(buy_type,dist); // Remove from order_finder self.order_finder.remove(&order_id); // Remove from orders queue.remove(queue_index); self.order_count-=1; Result::RetractedOrder(order_id) } // Strategy for refactoring: // 1. Transfer balance needed for the trade into a structure ("Orderlet.") Fields are asset, royalty1, commission1, // 2. Function to execute an Orderlet against an OrderQueue. Modifies both the Orderlet and the OrderQueue // 3. Function to post an Orderlet in an OrderQueue. It would be a different OrderQueue than in Step #2 fn make_order(&mut self, owner:usize, sell_type:usize, buy_type:usize, sell_qty_initial:FiNum, buy_qty_initial:FiNum, execute_if_possible:bool) -> Result { let mut log:Vec=Vec::new(); let initial_balance=self.traders[owner].get_balance(sell_type); let asset=self.number_to_asset(sell_type); let mut royalty0_qty=asset.royalty0_rate*sell_qty_initial; let mut royalty1_qty=asset.royalty1_rate*sell_qty_initial; let mut commission0_qty=asset.commission0_rate*sell_qty_initial; let mut commission1_qty=asset.commission1_rate*sell_qty_initial; let sell_qty_plus=sell_qty_initial+royalty0_qty+royalty1_qty+commission0_qty+commission1_qty; // This is the maximum amount we are going to sell let sell_qty=sell_qty_initial; if initial_balanceFiNum::new(0) && self.orders.contains_key(&ap) && self.orders.get(&ap).unwrap().v.len()>0 { let elt=self.orders.get(&ap).unwrap().v[0].clone(); if sell_qty/buy_qty_initial>=elt.buy_qty/elt.sell_qty { // Transact at ask_rate let qty=std::cmp::min(elt.sell_remain,buy_qty); buy_qty-=qty; let pay_qty=qty*elt.buy_qty/elt.sell_qty; self.traders[owner ].sub_balance(sell_type,pay_qty); self.traders[owner ].add_balance(buy_type ,qty); self.traders[elt.owner].add_balance(sell_type,pay_qty); log.push(format!("Sold {} {} ({}) to buy {} {} ({})",pay_qty,self.number_to_name(sell_type),self.traders[owner ].name, qty ,self.number_to_name(buy_type ),self.traders[elt.owner].name)); let rq0=royalty0_qty *pay_qty/sell_qty_initial; let cq0=commission0_qty*pay_qty/sell_qty_initial; let rq1=royalty1_qty *pay_qty/sell_qty_initial; let cq1=commission1_qty*pay_qty/sell_qty_initial; let rq2=if !elt.sell_remain.is_zero() { elt.royalty_remain *qty/elt.sell_remain } else { FiNum::zero() }; let cq2=if !elt.sell_remain.is_zero() { elt.commission_remain*qty/elt.sell_remain } else { FiNum::zero() }; self.royalties.entry(sell_type).or_insert(RoyaltyTree::new()); self.royalties.entry(buy_type) .or_insert(RoyaltyTree::new()); let rtb=self.royalties.entry(buy_type) .or_insert(RoyaltyTree::new()); let rts=self.royalties.entry(sell_type).or_insert(RoyaltyTree::new()); if let Some(&cap_index)=rts.order_finder.get(&elt.order_id) { let wh0=rts.weight_here(cap_index); let acc0=rts.tree[cap_index].acc; let cap=rts.capture_by_order_id(elt.owner); rts.sub_weight(cap_index,pay_qty); let wh1=rts.weight_here(cap_index); let acc1=rts.tree[cap_index].acc; self.traders[elt.owner].add_balance(sell_type,cap); } royalty_acc+=rq0+rq1; commission_acc+=cq0+cq1; royalty0_qty-=rq0; royalty1_qty-=rq1; commission0_qty-=cq0; commission1_qty-=cq1; self.royalties.entry(sell_type).or_insert(RoyaltyTree::new()).add_royalty(rq0+rq1); self.royalties.entry(buy_type) .or_insert(RoyaltyTree::new()).add_royalty(rq2); let top_order=self.orders.get_mut(&ap).unwrap().peek(); top_order.royalty_remain-=rq2; top_order.commission_remain-=cq2; self.traders[0].add_balance(sell_type,cq0+cq1); self.traders[0].add_balance(buy_type,cq2); if elt.sell_remain==qty { // deal with pennies stored in royalty_remain and commission_remain let rq3=top_order.royalty_remain; let cq3=top_order.commission_remain; let dist=self.royalties.get_mut(&buy_type).unwrap().remove_order_id(top_order.order_id); self.traders[elt.owner].add_balance(sell_type,dist); self.order_finder.remove(&top_order.order_id); self.traders[top_order.owner].order_finder.remove(&top_order.order_id); self.orders.get_mut(&ap).unwrap().pop(); // This removes id (which is stored as part of the Order) from self.order's finder self.order_count-=1; self.traders[0].add_balance(buy_type,cq3); self.royalties.entry(buy_type).or_insert(RoyaltyTree::new()).add_royalty(rq3); } else { top_order.sell_remain-=qty; } } else { break; } } let mut id=0; if buy_qty>0.into() { let ap=(sell_type,buy_type); if let None=self.orders.get_mut(&ap) { self.orders.insert(ap,OrderQueue::new()); } let bids=self.orders.get_mut(&ap).unwrap(); let sell_qty_remain=sell_qty*buy_qty/buy_qty_initial; if sell_qty_remain>0.into() { // This block can not fail // Allocate the id for this new order id=self.next_order_id; self.next_order_id+=1; // Pay royalties to existing orders on the sell size self.royalties.entry(sell_type).or_insert(RoyaltyTree::new()).add_royalty(royalty0_qty); royalty_acc+=royalty0_qty; // Create a new entry in the RoyaltyTree to accumulate for this Order let rt=self.royalties.entry(buy_type).or_insert(RoyaltyTree::new()); rt.add_weight(rt.next_entry,buy_qty); // Weight should really be the quantity you would be able to immediately transact rather than how much you wish for. rt.set_location(id,rt.next_entry); rt.next_entry+=1; // Insert the new order in the priority queue (OrderQueue) let neworder=Order { owner:owner, sell_qty:sell_qty_remain, sell_remain:sell_qty_remain, buy_qty:buy_qty, royalty_remain:royalty1_qty, commission_remain:commission1_qty, order_id:id }; bids.insert(neworder); royalty_acc+=royalty1_qty; commission_acc+=commission1_qty; self.order_count+=1; self.order_finder.insert(id,(sell_type,buy_type)); self.traders[owner].sub_balance(sell_type,sell_qty_remain); self.traders[owner].sub_balance(sell_type,commission0_qty); self.traders[0].add_balance(sell_type,commission0_qty); self.traders[owner].order_finder.insert(id,(sell_type,buy_type)); log.push(format!("Moved {} {} ({}) to market",sell_qty_remain,self.number_to_name(sell_type),self.traders[owner].name)); } } // self.traders[0].add_balance(sell_type,commission_acc); self.traders[owner].sub_balance(sell_type,royalty_acc+commission_acc); log.push(format!("Paid {} {} in royalties and {} {} ({}) in commissions",royalty_acc ,self.number_to_name(sell_type), commission_acc,self.number_to_name(sell_type),self.traders[owner].name)); Result::PlacedOrder(id,log) } fn path_cost(&self, src: usize, dest: usize, depth_left: usize) -> TradePath { let mut cheapest=vec![TradePath::new();self.assets.len()]; cheapest[src].cost=FiNum::new_i32(1); cheapest[src].path[0]=src; cheapest[src].len=1; for i in 0..6 { let mut progress=false; for ass0 in 0..self.assets.len() { for ass1 in 0..self.assets.len() { if true || ass0!=ass1 { if let Some(topq)=self.orders.get(&(ass1,ass0)) { let top=topq.peek_nomut(); if true { println!("There is a direct path from {} to {} with a cost of {} {}", self.number_to_name(ass0),self.number_to_name(ass1),top.buy_qty/top.sell_qty,self.number_to_name(ass1)); let candidate=cheapest[ass0].cost*top.buy_qty/top.sell_qty; if candidate Self { TradePath { cost: FiNum::infinity(), path: [0; 600], len: 0, cap: FiNum::infinity(), arbitrage: false, } } } impl PartialOrd for Order { fn partial_cmp(&self, other:&Self) -> Option { let ord0=self .sell_qty/self .buy_qty; let ord1=other.sell_qty/other.buy_qty; if ord0ord1 { Some(Ordering::Greater) } else { Some(Ordering::Equal) } } } impl PartialEq for Order { fn eq(&self, other:&Self) -> bool { let ord0=self .sell_qty/self .buy_qty; let ord1=other.sell_qty/other.buy_qty; ord0==ord1 } } // // If Some(shadow) then peek should return a reference to shadow, and pop should replace shadow with v[next[0]] // struct OrderQueue { v: Vec, shadowing: bool, shadow: Option, next: Vec, // A priority queue order_finder: HashMap, // Maps OrderIDs to locations in v } impl OrderQueue { fn new()->Self { OrderQueue { v: Vec::new(), shadowing: false, shadow: None, next: Vec::new(), order_finder:HashMap::new(), } } fn assure_shadowing(&mut self) { if !self.shadowing { assert!(self.next.len()==0); self.shadowing=true; if self.v.len()>0 { self.shadow=Some(self.v[0].clone()); } else { self.shadow=None; } self.queue_shadow(0); } } fn stop_shadowing(&mut self) { if self.shadowing { self.next.clear(); self.shadowing=false; self.shadow=None; self.next=Vec::new(); } } fn queue_shadow(&mut self, parent: usize) { if parent*2+1 &mut Order { if !self.shadowing { self.v.first_mut().unwrap() } else { self.shadow.as_mut().expect("Shadowing mismatch") } } fn peek_nomut(&self) -> &Order { if !self.shadowing { self.v.first().unwrap() } else { self.shadow.as_ref().expect("Shadowing mismatch") } } fn peekn(&self) -> Option<&Order> { match &self.shadow { Some(order) => Some(order), None => { self.v.first() } } } fn empty(&self) -> bool { self.v.len()==0 } fn pop(&mut self) -> Option { if !self.shadowing { return self.remove(0); } let rval=self.shadow.clone(); if self.next.len()==0 { self.shadow=None; } else { self.shadow=Some(self.v[self.next[0]].clone()); self.queue_shadow(self.next[0]); if self.next.len()>1 { self.next[0]=self.next.pop().unwrap(); } else { self.next.pop(); } self.trickle_down_next(0); } rval } fn bubble_up_next(&mut self, pos: usize) { if pos>0 { let parent=(pos-1)/2; if self.v[self.next[parent]]0 { let parent=(pos-1)/2; if self.v[parent] Option { assert!(!self.shadowing); if self.v.len()<=pos { None } else { let end=self.v.len()-1; self.v.swap(pos,end); self.order_finder.remove(&self.v[end].order_id); let rval=self.v.pop(); self.trickle_down(pos); rval } } fn dump(&self) { for index in 0..self.v.len() { self.v[index].dump(); } if self.shadowing { for index in 0..self.next.len() { println!(" Shadow {}",self.next[index]); } } } } impl Market { fn seed_random(&mut self, seed: u64) { self.rng=StdRng::seed_from_u64(seed); } fn random_command(&mut self) -> Command { match self.rng.gen_range(1..4) { 1 => Command::AddFunds { user_id: self.rng.gen_range(1..self.traders.len()), asset_id: self.rng.gen_range(0..self.assets.len()), amt: FiNum::new(self.rng.gen_range(1<<32..20<<32+1)), }, 2 => Command::AddFunds { user_id: self.rng.gen_range(1..self.traders.len()), asset_id: self.rng.gen_range(0..self.assets.len()), amt: FiNum::new(self.rng.gen_range(1<<32..20<<32+1)), }, 3 => { let a0=self.rng.gen_range(0..self.assets.len()); let a1=(a0+self.rng.gen_range(1..self.assets.len()))%self.assets.len(); Command::Order { user_id: self.rng.gen_range(1..self.traders.len()), sell_type: a0, sell_qty: FiNum::new(self.rng.gen_range(1<<32..20<<32+1)), buy_type: a1, buy_qty: FiNum::new(self.rng.gen_range(1<<32..20<<32+1)), } }, 4 => if let Some(id)=self.random_order_id() { Command::RetractOrder { order_id:id } } else { Command::None }, _ => Command::Error("This can never happen".to_string()), } } fn exercise(&mut self) { let mut rng: StdRng=StdRng::seed_from_u64(13u64); let teppy=self.register_trader("Teppy"); let luni =self.register_trader("Luni"); let usd =self.register_asset("USD").unwrap(); let btc =self.register_asset("BTC").unwrap(); self.add_trader_balance(teppy,btc,100000.into()); self.add_trader_balance(luni ,usd,650000000.into()); let mut count=0; let mut tries=0; for _i in 1..=1000000 { let seller=if rng.gen_bool(0.5) { teppy } else { luni }; let (buy_type,sell_type,buy_qty,sell_qty):(usize,usize,FiNum,FiNum); if rng.gen_bool(0.5) { sell_type=btc; buy_type=usd; sell_qty=rng.gen_range(1..=5).into(); buy_qty=sell_qty*rng.gen_range(60..=70).into(); } else { sell_type=usd; buy_type=btc; buy_qty=rng.gen_range(1..=5).into(); sell_qty=buy_qty*rng.gen_range(60..=70).into(); } let mut _success=false; if let Result::Ok=self.make_order(seller,sell_type,buy_type,sell_qty,buy_qty,true) { count+=1; _success=true; }; if count>=1000000 { break; } tries+=1; } println!("Tries: {} Trades: {}",tries,count); self.sanity_check(); } } fn wt_level(index:usize) -> usize { (index^(index+1)).trailing_ones() as usize-1 } fn wt_leaf(index:usize) -> bool { index&1==0 } fn wt_left(index:usize) -> Option { let level=wt_level(index); if level>0 { Some(index-(1<<(wt_level(index)-1))) } else { None } } fn wt_right_edge(index: usize, edge: usize) -> Option { // Less than edge if index&1==0 { None } else { let mut r=wt_right(index).unwrap(); if r Option { let level=wt_level(index); if level>0 { Some(index+(1<<(wt_level(index)-1))) } else { None } } fn wt_parent(index:usize) -> usize { let lev=wt_level(index); let first_in_row=index%(1<>1; first_in_parent_row+nth_in_parent_row*skip_in_parent_row } fn wt_forefather(max_index:usize) -> usize { let mut rval=max_index; rval=rval|(rval>>1); rval=rval|(rval>>2); rval=rval|(rval>>4); rval=rval|(rval>>8); rval=rval|(rval>>16); rval=rval|(rval>>32); if rval>max_index { wt_left(rval).unwrap() } else { rval } } fn royalty_stuff() { let mut rng: StdRng=StdRng::seed_from_u64(13u64); let mut rt=RoyaltyTree::new(); rt.add_weight(4,FiNum::new_i32(1)); rt.dump(); rt.add_weight(5,FiNum::new_i32(1)); rt.dump(); // return; for i in 1..1000000 { // rt.dump(); let node=rng.gen_range(0..10); match rng.gen_range(0..10) { 0 => rt.add_weight(node,FiNum::new_i32(rng.gen_range(0..101))), 1 => { rt.sub_weight(node,FiNum::new_i32(rng.gen_range(0..101))); }, 2 => rt.add_royalty(FiNum::new_i32(rng.gen_range(0..10))), // 3 => println!("Random Order ID: {:?}",rt.random_order_id(&mut rng)), _ => (), } } rt.dump(); } enum Result { AddedTrader(usize,String), AddedAsset(usize,String), PlacedOrder(usize, Vec), RetractedOrder(usize), FundsRemaining(FiNum), ExecutedBatch(Vec), Error(String), Ok } enum Command { AddTrader { user: String }, AddAsset { asset: String }, SetRoyalty { asset_id: usize, roy0: FiNum, com0: FiNum, roy1: FiNum, com1: FiNum }, AddFunds { user_id: usize, asset_id: usize, amt: FiNum }, SubFunds { user_id: usize, asset_id: usize, amt: FiNum }, Order { user_id: usize, sell_type: usize, sell_qty: FiNum, buy_type: usize, buy_qty: FiNum }, SmartOrder { user_id: usize, sell_type: usize, sell_qty: FiNum, buy_type: usize, buy_qty: FiNum, max0: FiNum, max1: FiNum }, OrderBatch { user_id: usize, sell_type: usize, sell_qty: FiNum, buy_type: usize, buy_qty: FiNum }, ExecuteBatch { asset_type0: usize, strike0: FiNum, asset_type1: usize, strike1: FiNum }, RetractOrder { order_id: usize }, Error(String), NOP(String), None, } fn clean(s: &str) -> String { s.to_string() } fn clean_replay(input: &str) -> String { let before_semicolon = input.split(';').next().unwrap_or(""); // Split on semicolon; take first chunk (before semicolon), or "" if none before_semicolon.trim_end().to_string() // Trim trailing whitespace, then convert to owned String } impl Command { fn serialize(&self) -> String { match self { Self::AddTrader { user: name } => format!("AT {}",name), Self::AddAsset { asset: name } => format!("AA {}",name), Self::SetRoyalty { asset_id, roy0, com0 , roy1 , com1 } => format!("SR {} {} {} {} {}",asset_id,roy0.serialize(),com0.serialize(),roy1.serialize(),com1.serialize()), Self::AddFunds { user_id, asset_id, amt } => format!("AF {} {} {}",user_id,asset_id,amt.serialize()), Self::SubFunds { user_id, asset_id , amt } => format!("SF {} {} {}",user_id,asset_id,amt.serialize()), Self::Order { user_id, sell_type, sell_qty, buy_type, buy_qty } => format!("OR {} {} {} {} {}",user_id,sell_type,sell_qty.serialize(),buy_type,buy_qty.serialize()), Self::OrderBatch { user_id, sell_type, sell_qty, buy_type, buy_qty } => format!("ORB {} {} {} {} {}",user_id,sell_type,sell_qty.serialize(),buy_type,buy_qty.serialize()), Self::ExecuteBatch { asset_type0, strike0, asset_type1, strike1 } => format!("EXE {} {} {} {}",asset_type0,strike0.serialize(),asset_type1,strike1.serialize()), Self::RetractOrder { order_id } => format!("RE {}",order_id), Self::Error(str) => format!("NOP Error: {}",str), Self::NOP(str) => format!("NOP {}",clean(str)), _ => format!("NOP (This should never happen)"), } } fn explain(&self, m: &Market) -> String { match self { Self::AddTrader { user: name } => format!("addtrader {}",name), Self::AddAsset { asset: name } => format!("addasset {}",name), Self::SetRoyalty { asset_id, roy0, com0 , roy1 , com1 } => format!("setroyalty {} {} {} {} {}",m.number_to_name(*asset_id),roy0,com0,roy1,com1), Self::AddFunds { user_id, asset_id, amt } => format!("addfunds {} {} {}",m.traders[*user_id].name,m.number_to_name(*asset_id),amt), Self::SubFunds { user_id, asset_id , amt } => format!("subfunds {} {} {}",m.traders[*user_id].name,m.number_to_name(*asset_id),amt), Self::Order { user_id, sell_type, sell_qty, buy_type, buy_qty } => format!("order {} {} {} {} (as {})",sell_qty,m.number_to_name(*sell_type),buy_qty,m.number_to_name(*buy_type),m.traders[*user_id].name), Self::OrderBatch { user_id, sell_type, sell_qty, buy_type, buy_qty } => format!("orderbatch {} {} {} {} (as {})",sell_qty,m.number_to_name(*sell_type),buy_qty,m.number_to_name(*buy_type),m.traders[*user_id].name), Self::ExecuteBatch { asset_type0, strike0, asset_type1, strike1 } => format!("executebatch {} {} {} {}",strike0,m.number_to_name(*asset_type0),strike1,m.number_to_name(*asset_type1)), Self::RetractOrder { order_id } => format!("retract {}",order_id), Self::Error(str) => format!("NOP Error: {}",str), Self::NOP(str) => format!("NOP {}",clean(str)), _ => format!("NOP (This should never happen)"), } } fn deserialize(line: String) -> Self { let tokens: Vec<&str> = line.split_whitespace().collect(); match tokens.as_slice() { ["AT",name] => Self::AddTrader { user: name.to_string() }, ["AA",name] => Self::AddAsset { asset: name.to_string() }, ["SR",asset_id,roy0,com0,roy1,com1] => Self::SetRoyalty { asset_id: asset_id.parse::().unwrap(), roy0: FiNum::new_deserialize(roy0), com0: FiNum::new_deserialize(com0), roy1: FiNum::new_deserialize(roy1), com1: FiNum::new_deserialize(com1) }, ["AF",user_id,asset_id,amt] => Self::AddFunds { user_id: user_id.parse::().unwrap(), asset_id: asset_id.parse::().unwrap(), amt: FiNum::new_deserialize(amt) }, ["SF",user_id,asset_id,amt] => Self::SubFunds { user_id: user_id.parse::().unwrap(), asset_id: asset_id.parse::().unwrap(), amt: FiNum::new_deserialize(amt) }, ["OR",user_id,sell_type,sell_qty,buy_type,buy_qty] => Self::Order { user_id: user_id.parse::().unwrap(), sell_type: sell_type.parse::().unwrap(), sell_qty: FiNum::new_deserialize(sell_qty), buy_type: buy_type.parse::().unwrap(), buy_qty: FiNum::new_deserialize(buy_qty) }, ["ORB",user_id,sell_type,sell_qty,buy_type,buy_qty] => Self::OrderBatch { user_id: user_id.parse::().unwrap(), sell_type: sell_type.parse::().unwrap(), sell_qty: FiNum::new_deserialize(sell_qty), buy_type: buy_type.parse::().unwrap(), buy_qty: FiNum::new_deserialize(buy_qty) }, ["RE",order_id] => Self::RetractOrder { order_id: order_id.parse::().unwrap() }, ["EXE",asset_type0,strike0,asset_type1,strike1] => Self::ExecuteBatch { asset_type0: asset_type0.parse::().unwrap(),strike0: FiNum::new_deserialize(strike0), asset_type1: asset_type1.parse::().unwrap(), strike1: FiNum::new_deserialize(strike1) }, ["NOP", many_things @ ..] => Self::NOP(clean(&line)), _ => Self::Error("Unimplemented Parse".to_string()), } } } impl Result { fn describe(&self) -> String { match self { Self::PlacedOrder(order_id,vec) => format!("Placed order {}:\n {}",order_id,vec.join("\n ")), Self::AddedTrader(id,name) => format!("Added Trader Id {}: {}",id,name), Self::AddedAsset(id,name) => format!("Added Asset Id {}: {}",id,name), Self::ExecutedBatch(vec) => format!("{}",vec.join("\n")), Self::FundsRemaining(amt) => format!("Funds Remaining: {}",amt), Self::RetractedOrder(order_id) => format!("Retracted Order {}",order_id), Self::Ok => format!("Ok"), Self::Error(str) => format!("Error: {}",str), // _ => "Some other result".to_string(), } } fn print(&self) -> &Self { println!("{}",self.describe()); self } } impl Market { fn execute(&mut self, cmd: &Command) -> Result { match cmd { Command::AddTrader { user: user_name } => { let id=self.register_trader(user_name); Result::AddedTrader(id,user_name.to_string()) } Command::AddAsset { asset: asset_name } => { if let Some(cur)=self.register_asset(asset_name) { Result::AddedAsset(cur,asset_name.to_string()) } else { Result::Error(format!("Asset {} already exists.",asset_name)) } } Command::SetRoyalty { asset_id,roy0,com0,roy1,com1 } => { if *roy0+*com0+*roy1+*com1 { self.add_trader_balance(*user_id,*asset_id,*amt); Result::FundsRemaining(self.get_trader_balance(*user_id,*asset_id)) } Command::SubFunds { user_id,asset_id,amt } => { if *amt>self.get_trader_balance(*user_id,*asset_id) { Result::Error(format!("Not enough {} in {}",asset_id,user_id)) } else { self.sub_trader_balance(*user_id,*asset_id,*amt); Result::FundsRemaining(self.get_trader_balance(*user_id,*asset_id)) } } Command::Order { user_id, sell_type, sell_qty, buy_type, buy_qty } => { self.make_order(*user_id,*sell_type,*buy_type,*sell_qty,*buy_qty,true) } Command::SmartOrder { user_id, sell_type, sell_qty, buy_type, buy_qty, max0, max1 } => { self.make_smart_order(*user_id,*sell_type,*buy_type,*sell_qty,*buy_qty,*max0,*max1,true) } Command::OrderBatch { user_id, sell_type, sell_qty, buy_type, buy_qty } => { self.make_order(*user_id,*sell_type,*buy_type,*sell_qty,*buy_qty,false) } Command::RetractOrder { order_id } => { self.retract_order(*order_id) } Command::ExecuteBatch { asset_type0, strike0, asset_type1, strike1 } => { // self.execute_batch(*asset_type0, *strike0, *asset_type1, *strike1) Result::Error(format!("ExecuteBatch not Implemented.")) } Command::Error(str) => Result::Error(format!("Command Error")), Command::NOP(str) => Result::Ok, _ => Result::Error(format!("Tried to execute an unimplemented Command. This is a bug because all Commands should be implemented, even NOPs and Errors.")), } } } fn erase(filename: &str) { // Stub function for erasing a file println!("Erasing file: {}", filename); } fn copy(source: &str, destination: &str) { // Stub function for copying a file println!("Copying file from {} to {}", source, destination); } fn tokens_to_command(m: &Market, logged_in: usize, tokens: Vec<&str>,line: &str) -> Command { let cmd:Command=match &tokens[..] { ["addtrader", username] => Command::AddTrader { user: username.to_string() }, ["addasset", assetname] => Command::AddAsset { asset: assetname.to_string() }, ["setroyalty", assetname, roy0, com0, roy1, com1] => { if let Some(cur)=m.name_to_number(assetname) { let roy0=FiNum::new_str(roy0); let com0=FiNum::new_str(com0); let roy1=FiNum::new_str(roy1); let com1=FiNum::new_str(com1); if roy0+com0+roy1+com1 { let user=m.trader_name2num.get(*username); let qty=FiNum::new_str(qty0); let cur=m.name_to_number(cur0); if user.is_none() { Command::Error(format!("Could not find trader {}",username)) } else if qty.is_zero() { Command::Error(format!("Could not parse quantity {}",qty0)) } else if cur.is_none() { Command::Error(format!("Could not find asset {}",cur0)) } else { let user=*user.unwrap(); let cur=*cur.unwrap(); Command::AddFunds { user_id: user, asset_id: cur, amt: qty } } } ["subfunds", username, qty0, cur0 ] => { let user=m.trader_name2num.get(*username); let qty=FiNum::new_str(qty0); let cur=m.name_to_number(cur0); if user.is_none() { Command::Error(format!("Could not find trader {}",username)) } else if qty.is_zero() { Command::Error(format!("Could not parse quantity {}",qty0)) } else if cur.is_none() { Command::Error(format!("Could not find asset {}",cur0)) } else { let user=*user.unwrap(); let cur=*cur.unwrap(); Command::SubFunds { user_id: user, asset_id: cur, amt: qty } } } ["retract", p_order_id ] => { let order_id:usize=p_order_id.parse().unwrap(); if !m.order_finder.contains_key(&order_id) { return Command::Error(format!("Order not found: {}",p_order_id)) } let trader=&m.traders[logged_in]; let order_type=m.order_finder.get(&order_id); println!("Order_type {:?}",order_type); let order_queue=m.orders.get(order_type.expect("Retrieving Order Queue")); Command::RetractOrder { order_id: order_id } } ["order", qty0, cur0, qty1, cur1 ] => { let qty0=FiNum::new_str(qty0); let cur0=m.name_to_number(cur0); let qty1=FiNum::new_str(qty1); let cur1=m.name_to_number(cur1); if !cur0.is_some() { Command::Error("Count not find currency".to_string()) } else if !cur1.is_some() { Command::Error("Count not find currency".to_string()) } else if qty0.is_zero() { Command::Error("Qty0 is must be > 0".to_string()) } else if qty1.is_zero() { Command::Error("Qty1 is must be > 0".to_string()) } else { Command::Order { user_id: logged_in, sell_type: *cur0.unwrap(), sell_qty: qty0, buy_type: *cur1.unwrap(), buy_qty: qty1 } } } // Sell up to qty0 cur0 to buy up to qty1 cur1 where no suborder exceeds maxsub (expressed as a fraction) ["smart", qty0, cur0, qty1, cur1, max0, "/", max1 ] => { let qty0=FiNum::new_str(qty0); let cur0=m.name_to_number(cur0); let qty1=FiNum::new_str(qty1); let cur1=m.name_to_number(cur1); let max0=FiNum::new_str(max0); let max1=FiNum::new_str(max1); if !cur0.is_some() { Command::Error("Count not find currency".to_string()) } else if !cur1.is_some() { Command::Error("Count not find currency".to_string()) } else if qty0.is_zero() { Command::Error("Qty0 is must be > 0".to_string()) } else if qty1.is_zero() { Command::Error("Qty1 is must be > 0".to_string()) } else if max0.is_zero() { Command::Error("Max0 is must be > 0".to_string()) } else if max1.is_zero() { Command::Error("Max1 is must be > 0".to_string()) } else { Command::SmartOrder { user_id: logged_in, sell_type: *cur0.unwrap(), sell_qty: qty0, buy_type: *cur1.unwrap(), buy_qty: qty1, max0: max0, max1: max1 } } } ["orderbatch", qty0, cur0, qty1, cur1 ] => { let qty0=FiNum::new_str(qty0); let cur0=m.name_to_number(cur0); let qty1=FiNum::new_str(qty1); let cur1=m.name_to_number(cur1); if !cur0.is_some() { Command::Error("Count not find currency".to_string()) } else if !cur1.is_some() { Command::Error("Count not find currency".to_string()) } else if qty0.is_zero() { Command::Error("Qty0 is must be > 0".to_string()) } else if qty1.is_zero() { Command::Error("Qty1 is must be > 0".to_string()) } else { Command::OrderBatch { user_id: logged_in, sell_type: *cur0.unwrap(), sell_qty: qty0, buy_type: *cur1.unwrap(), buy_qty: qty1 } } } ["execute", strike0, asset_type0, strike1, asset_type1 ] => { let strike0=FiNum::new_str(strike0); let asset_type0=m.name_to_number(asset_type0); let strike1=FiNum::new_str(strike1); let asset_type1=m.name_to_number(asset_type1); if !asset_type0.is_some() { Command::Error("Count not find currency".to_string()) } else if !asset_type1.is_some() { Command::Error("Count not find currency".to_string()) } else if strike0.is_zero() { Command::Error("Strike0 is must be > 0".to_string()) } else if strike1.is_zero() { Command::Error("Strike1 is must be > 0".to_string()) } else { Command::ExecuteBatch { asset_type0: *asset_type0.unwrap(), strike0:strike0, asset_type1: *asset_type1.unwrap(), strike1: strike1 } } } _ => { Command::Error(line.to_string()) }, }; cmd } fn interactive(m: &mut Market, mut out: Option) { println!("Trading interactively in Tuesday Markets (demo)"); let stdin = io::stdin(); let mut trader:usize=0; for line in stdin.lock().lines() { match line { Ok(input) => { let tokens: Vec<&str> = input.split_whitespace().collect(); let cmd:Command=match tokens.as_slice() { ["dump"] => { m.dump(); Command::None }, ["sanity"] => { m.sanity_check(); Command::None }, ["path",src,dest] => { let cur0=*m.name_to_number(src).unwrap(); let cur1=*m.name_to_number(dest).unwrap(); let path=m.path_cost(cur0,cur1,6); let mut str=format!("Cost: {} Cap: {}",path.cost,path.cap); if path.len>0 { str=format!("{} {}",str,m.number_to_name(path.path[0])) } for i in 1..path.len { str=format!("{}->{}",str,m.number_to_name(path.path[i])) } println!("{}",str); Command::None }, ["randomorder"] => { println!("Random OrderID: {:?}",m.random_order_id()); Command::None } ["login", username] => { if let Some(t)=m.trader_name2num.get_mut(*username) { trader=*t; println!("Logged in as {}",m.traders[trader].name) } else { println!("Trader {} not found.",username) } Command::None }, ["whoami" ] => { println!("Logged in as {}, id {}",m.traders[trader].name,trader ); Command::None } ["showorders"] => { println!("Showing all orders for {}",m.traders[trader].name); for (key0,value0) in &m.traders[trader].order_finder { let oq=m.orders.get(value0).unwrap(); // OrderQueue println!("About to find key {}",key0); let oqi=*oq.order_finder.get(key0).unwrap(); let ord=oq.v[oqi].clone(); // Order println!(" OrderID {} is selling {} {} to buy {} {}",key0,ord.sell_remain,m.number_to_asset(value0.0).name,ord.buy_qty*ord.sell_remain/ord.sell_qty,m.number_to_asset(value0.1).name); } Command::None } ["wallet"] => { for (key,value) in &m.traders[trader].balances { println!(" {} {}",m.number_to_name(*key),value); } Command::None } ["balances", username] => { if let Some(user)=m.trader_name2num.get(*username) { println!("Balances for trader {}",m.traders[*user].name); for (key,value) in &m.traders[*user].balances { println!(" {} {}",m.number_to_name(*key),value); } } else { println!("Could not find trader {}",username); } Command::None }, ["seedrandom"|"sr", seed] => { let seed=seed.parse().unwrap(); m.seed_random(seed); println!("Seeded RNG with {}",seed); Command::None } ["testshadow",src,dst] => { if let Some(cur0)=m.name_to_number(src) { if let Some(cur1)=m.name_to_number(dst) { println!("Currencies are {} and {}",cur0,cur1); if let Some(q)=m.orders.get_mut(&(*cur0,*cur1)) { println!("Dumping queue"); q.dump(); println!("Dumping shadow"); q.assure_shadowing(); while let Some(ord)=q.pop() { ord.dump(); } q.stop_shadowing(); } } } Command::None } ["randomcommands"|"rc", qty] => { let qty:u32=qty.parse().unwrap(); let start = Instant::now(); for i in 0..qty { let cmd=m.random_command(); // println!("RandomCommand #{}: {}",1+i,cmd.serialize()); if let Some(ref mut f)=out { let ser=cmd.serialize(); if let Err(e)=writeln!(f,"{}",ser) { eprintln!("An error occurred while writing {}",e); } } else { // println!("{}",cmd.serialize()); } let res=m.execute(&cmd); // println!("Result: {}",res.describe()); } let duration = start.elapsed(); println!("Ran {} commands in {:?}",qty,duration); Command::None }, ["quit"] => { return }, _ => { let cmd=tokens_to_command(m,trader,tokens,&input); if let Some(ref mut f)=out { let ser=cmd.serialize(); if let Err(e)=writeln!(f,"{}",ser) { eprintln!("An error occurred while writing {}",e); } } else { println!("{}",cmd.serialize()); } let res=m.execute(&cmd); println!("Result: {}",res.describe()); Command::None }, }; } Err(error) => println!("Error reading input: {}", error), } } } fn numbers_stuff() { println!("Numbers_stuff"); let n=FiNum::new_i32(7)/FiNum::new_i32(2); let n_s=n.serialize(); let n_d=FiNum::new_deserialize(&n_s); println!("N is {}, Serialized to {}, Deserialized to {}",n,n_s,n_d); } fn paths_match(path0: &str, path1: &str) -> bool { let path0 = Path::new(path0); let path1 = Path::new(path1); path0 == path1 } // // Use cases: // Replace logfile // Replay logfile and then append to it // Replay one logfile and then replace a different one // Future additional use cases: // Replay logfile1+logfile2+... and then replace a different log file // Replay logfile1+logfile2+logfileN and then append to logfileN // fn main() { let args: Vec = env::args().collect(); let mut options:HashMap<&str,String>=HashMap::new(); let mut i=1; enum Mode { Help, Royalty, Interactive, Exercise, Numbers, None } let mut mode_count=0; let mut mode=Mode::None; while i { mode=Mode::Help; mode_count+=1; i+=1; } "--interactive" => { mode=Mode::Interactive; mode_count+=1; i+=1; } "--royalty" => { mode=Mode::Royalty; mode_count+=1; i+=1; } "--exercise" => { mode=Mode::Exercise; mode_count+=1; i+=1; } "--numbers" => { mode=Mode::Numbers; mode_count+=1; i+=1; } "--log" => { if i+1>=args.len() { println!("No log file specified."); return; } else { options.insert("logfile",args[i+1].clone()); i+=2; } } "--replay" => { if i+1>=args.len() { println!("No replay file specified."); return; } else { options.insert("replay",args[i+1].clone()); i+=2; } } _ => { println!("Unknown option."); return; } } } if mode_count==0 { mode=Mode::Interactive; mode_count+=1; } if mode_count!=1 { println!("You may only select one mode to run in."); return; } let mut m=Market::new(); // USD type is 1, EUR type is 2, BTC type is 10, ETH type is 11, SOL type is 12 if options.contains_key("replay") { m.replay_file(options.get("replay").unwrap()); } match mode { Mode::Interactive => { if options.contains_key("logfile") { let ap=options.contains_key("replay") && paths_match(options.get("replay").unwrap(),options.get("logfile").unwrap()); let f=OpenOptions::new().write(true).append(ap).truncate(!ap).create(true).open(options.get("logfile").unwrap()); if let Ok(f)=f { interactive(&mut m,Some(f)); } else { println!("Could not open logfile for writing."); } } else { interactive(&mut m,None); } } Mode::Exercise => m.exercise(), Mode::Numbers => numbers_stuff(), Mode::Royalty => royalty_stuff(), _ => println!("Unspecified mode"), } }