2018-06-19 23:51:04 -07:00
|
|
|
//! The `drone` module provides an object for launching a Solana Drone,
|
|
|
|
//! which is the custodian of any remaining tokens in a mint.
|
|
|
|
//! The Solana Drone builds and send airdrop transactions,
|
|
|
|
//! checking requests against a request cap for a given time time_slice
|
|
|
|
//! and (to come) an IP rate limit.
|
|
|
|
|
2018-07-05 21:40:09 -07:00
|
|
|
use influx_db_client as influxdb;
|
|
|
|
use metrics;
|
2018-07-20 15:58:13 -07:00
|
|
|
use signature::Signature;
|
2018-08-09 08:13:57 -07:00
|
|
|
use signature::{Keypair, Pubkey};
|
2018-06-19 21:39:53 -07:00
|
|
|
use std::io;
|
2018-06-19 23:51:04 -07:00
|
|
|
use std::io::{Error, ErrorKind};
|
2018-06-19 21:39:53 -07:00
|
|
|
use std::net::{IpAddr, SocketAddr, UdpSocket};
|
|
|
|
use std::time::Duration;
|
|
|
|
use thin_client::ThinClient;
|
|
|
|
use transaction::Transaction;
|
|
|
|
|
2018-06-19 23:51:04 -07:00
|
|
|
pub const TIME_SLICE: u64 = 60;
|
2018-08-23 15:30:35 -07:00
|
|
|
pub const REQUEST_CAP: u64 = 10_000_000;
|
2018-07-18 12:38:18 -07:00
|
|
|
pub const DRONE_PORT: u16 = 9900;
|
2018-06-19 21:39:53 -07:00
|
|
|
|
2018-07-11 20:10:25 -07:00
|
|
|
#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
|
2018-06-19 21:39:53 -07:00
|
|
|
pub enum DroneRequest {
|
2018-06-19 23:51:04 -07:00
|
|
|
GetAirdrop {
|
2018-06-21 19:41:47 -07:00
|
|
|
airdrop_request_amount: u64,
|
2018-08-09 08:13:57 -07:00
|
|
|
client_pubkey: Pubkey,
|
2018-06-19 23:51:04 -07:00
|
|
|
},
|
2018-06-19 21:39:53 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
pub struct Drone {
|
2018-08-09 07:56:04 -07:00
|
|
|
mint_keypair: Keypair,
|
2018-06-19 21:39:53 -07:00
|
|
|
ip_cache: Vec<IpAddr>,
|
2018-06-19 23:51:04 -07:00
|
|
|
_airdrop_addr: SocketAddr,
|
2018-06-24 00:37:18 -07:00
|
|
|
transactions_addr: SocketAddr,
|
|
|
|
requests_addr: SocketAddr,
|
2018-06-19 23:51:04 -07:00
|
|
|
pub time_slice: Duration,
|
2018-06-19 21:39:53 -07:00
|
|
|
request_cap: u64,
|
2018-06-19 23:51:04 -07:00
|
|
|
pub request_current: u64,
|
2018-06-19 21:39:53 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
impl Drone {
|
|
|
|
pub fn new(
|
2018-08-09 07:56:04 -07:00
|
|
|
mint_keypair: Keypair,
|
2018-06-19 23:51:04 -07:00
|
|
|
_airdrop_addr: SocketAddr,
|
2018-06-24 00:37:18 -07:00
|
|
|
transactions_addr: SocketAddr,
|
|
|
|
requests_addr: SocketAddr,
|
2018-06-19 21:39:53 -07:00
|
|
|
time_input: Option<u64>,
|
|
|
|
request_cap_input: Option<u64>,
|
|
|
|
) -> Drone {
|
|
|
|
let time_slice = match time_input {
|
|
|
|
Some(time) => Duration::new(time, 0),
|
2018-06-19 23:51:04 -07:00
|
|
|
None => Duration::new(TIME_SLICE, 0),
|
2018-06-19 21:39:53 -07:00
|
|
|
};
|
|
|
|
let request_cap = match request_cap_input {
|
|
|
|
Some(cap) => cap,
|
2018-06-19 23:51:04 -07:00
|
|
|
None => REQUEST_CAP,
|
2018-06-19 21:39:53 -07:00
|
|
|
};
|
|
|
|
Drone {
|
|
|
|
mint_keypair,
|
|
|
|
ip_cache: Vec::new(),
|
2018-06-19 23:51:04 -07:00
|
|
|
_airdrop_addr,
|
2018-06-24 00:37:18 -07:00
|
|
|
transactions_addr,
|
|
|
|
requests_addr,
|
2018-06-19 21:39:53 -07:00
|
|
|
time_slice,
|
|
|
|
request_cap,
|
|
|
|
request_current: 0,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-06-21 22:11:24 -07:00
|
|
|
pub fn check_request_limit(&mut self, request_amount: u64) -> bool {
|
|
|
|
(self.request_current + request_amount) <= self.request_cap
|
2018-06-19 23:51:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn clear_request_count(&mut self) {
|
|
|
|
self.request_current = 0;
|
|
|
|
}
|
|
|
|
|
2018-06-19 21:39:53 -07:00
|
|
|
pub fn add_ip_to_cache(&mut self, ip: IpAddr) {
|
|
|
|
self.ip_cache.push(ip);
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn clear_ip_cache(&mut self) {
|
|
|
|
self.ip_cache.clear();
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn check_rate_limit(&mut self, ip: IpAddr) -> Result<IpAddr, IpAddr> {
|
|
|
|
// [WIP] This is placeholder code for a proper rate limiter.
|
|
|
|
// Right now it will only allow one total drone request per IP
|
|
|
|
if self.ip_cache.contains(&ip) {
|
|
|
|
// Add proper error handling here
|
|
|
|
Err(ip)
|
2018-06-19 23:51:04 -07:00
|
|
|
} else {
|
2018-06-19 21:39:53 -07:00
|
|
|
self.add_ip_to_cache(ip);
|
|
|
|
Ok(ip)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-07-20 15:58:13 -07:00
|
|
|
pub fn send_airdrop(&mut self, req: DroneRequest) -> Result<Signature, io::Error> {
|
2018-06-21 22:11:24 -07:00
|
|
|
let request_amount: u64;
|
|
|
|
let requests_socket = UdpSocket::bind("0.0.0.0:0").unwrap();
|
|
|
|
let transactions_socket = UdpSocket::bind("0.0.0.0:0").unwrap();
|
|
|
|
|
|
|
|
let mut client = ThinClient::new(
|
2018-06-24 00:37:18 -07:00
|
|
|
self.requests_addr,
|
2018-06-21 22:11:24 -07:00
|
|
|
requests_socket,
|
2018-06-24 00:37:18 -07:00
|
|
|
self.transactions_addr,
|
2018-06-21 22:11:24 -07:00
|
|
|
transactions_socket,
|
|
|
|
);
|
|
|
|
let last_id = client.get_last_id();
|
|
|
|
|
2018-07-20 16:05:39 -07:00
|
|
|
let tx = match req {
|
2018-06-21 22:11:24 -07:00
|
|
|
DroneRequest::GetAirdrop {
|
|
|
|
airdrop_request_amount,
|
2018-08-09 08:03:08 -07:00
|
|
|
client_pubkey,
|
2018-06-21 22:11:24 -07:00
|
|
|
} => {
|
2018-07-13 22:30:05 -07:00
|
|
|
info!(
|
|
|
|
"Requesting airdrop of {} to {:?}",
|
2018-08-09 08:03:08 -07:00
|
|
|
airdrop_request_amount, client_pubkey
|
2018-07-13 22:30:05 -07:00
|
|
|
);
|
2018-07-11 13:40:46 -07:00
|
|
|
request_amount = airdrop_request_amount;
|
2018-07-20 16:05:39 -07:00
|
|
|
Transaction::new(
|
2018-06-21 22:11:24 -07:00
|
|
|
&self.mint_keypair,
|
2018-08-09 08:03:08 -07:00
|
|
|
client_pubkey,
|
2018-06-21 22:11:24 -07:00
|
|
|
airdrop_request_amount as i64,
|
|
|
|
last_id,
|
2018-07-20 16:05:39 -07:00
|
|
|
)
|
2018-06-19 21:39:53 -07:00
|
|
|
}
|
2018-07-20 16:05:39 -07:00
|
|
|
};
|
2018-06-21 22:11:24 -07:00
|
|
|
if self.check_request_limit(request_amount) {
|
|
|
|
self.request_current += request_amount;
|
2018-07-05 21:40:09 -07:00
|
|
|
metrics::submit(
|
|
|
|
influxdb::Point::new("drone")
|
|
|
|
.add_tag("op", influxdb::Value::String("airdrop".to_string()))
|
|
|
|
.add_field(
|
|
|
|
"request_amount",
|
|
|
|
influxdb::Value::Integer(request_amount as i64),
|
|
|
|
)
|
|
|
|
.add_field(
|
|
|
|
"request_current",
|
|
|
|
influxdb::Value::Integer(self.request_current as i64),
|
|
|
|
)
|
|
|
|
.to_owned(),
|
|
|
|
);
|
2018-08-26 15:58:22 -07:00
|
|
|
client.retry_transfer_signed(&tx, 10)
|
2018-06-19 23:51:04 -07:00
|
|
|
} else {
|
2018-06-21 19:41:47 -07:00
|
|
|
Err(Error::new(ErrorKind::Other, "token limit reached"))
|
2018-06-19 21:39:53 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-07-05 21:40:09 -07:00
|
|
|
impl Drop for Drone {
|
|
|
|
fn drop(&mut self) {
|
|
|
|
metrics::flush();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-06-19 21:39:53 -07:00
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
|
|
|
use bank::Bank;
|
|
|
|
use crdt::{get_ip_addr, TestNode};
|
2018-06-21 19:41:47 -07:00
|
|
|
use drone::{Drone, DroneRequest, REQUEST_CAP, TIME_SLICE};
|
2018-08-09 14:29:07 -07:00
|
|
|
use fullnode::Fullnode;
|
2018-06-19 21:39:53 -07:00
|
|
|
use logger;
|
|
|
|
use mint::Mint;
|
2018-07-03 21:14:08 -07:00
|
|
|
use service::Service;
|
2018-08-09 07:56:04 -07:00
|
|
|
use signature::{Keypair, KeypairUtil};
|
2018-08-03 11:06:06 -07:00
|
|
|
use std::fs::remove_dir_all;
|
2018-06-19 21:39:53 -07:00
|
|
|
use std::net::{SocketAddr, UdpSocket};
|
2018-06-19 23:51:04 -07:00
|
|
|
use std::sync::atomic::{AtomicBool, Ordering};
|
2018-06-20 11:50:14 -07:00
|
|
|
use std::sync::Arc;
|
2018-06-19 21:39:53 -07:00
|
|
|
use std::thread::sleep;
|
|
|
|
use std::time::Duration;
|
|
|
|
use thin_client::ThinClient;
|
|
|
|
|
2018-06-19 23:51:04 -07:00
|
|
|
#[test]
|
2018-06-21 19:41:47 -07:00
|
|
|
fn test_check_request_limit() {
|
2018-08-09 07:56:04 -07:00
|
|
|
let keypair = Keypair::new();
|
2018-06-19 23:51:04 -07:00
|
|
|
let mut addr: SocketAddr = "0.0.0.0:9900".parse().unwrap();
|
|
|
|
addr.set_ip(get_ip_addr().unwrap());
|
2018-06-24 00:37:18 -07:00
|
|
|
let transactions_addr = "0.0.0.0:0".parse().unwrap();
|
|
|
|
let requests_addr = "0.0.0.0:0".parse().unwrap();
|
2018-06-24 00:58:44 -07:00
|
|
|
let mut drone = Drone::new(
|
|
|
|
keypair,
|
|
|
|
addr,
|
|
|
|
transactions_addr,
|
|
|
|
requests_addr,
|
|
|
|
None,
|
|
|
|
Some(3),
|
|
|
|
);
|
2018-06-21 22:11:24 -07:00
|
|
|
assert!(drone.check_request_limit(1));
|
|
|
|
drone.request_current = 3;
|
|
|
|
assert!(!drone.check_request_limit(1));
|
2018-06-19 23:51:04 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_clear_request_count() {
|
2018-08-09 07:56:04 -07:00
|
|
|
let keypair = Keypair::new();
|
2018-06-19 23:51:04 -07:00
|
|
|
let mut addr: SocketAddr = "0.0.0.0:9900".parse().unwrap();
|
|
|
|
addr.set_ip(get_ip_addr().unwrap());
|
2018-06-24 00:37:18 -07:00
|
|
|
let transactions_addr = "0.0.0.0:0".parse().unwrap();
|
|
|
|
let requests_addr = "0.0.0.0:0".parse().unwrap();
|
|
|
|
let mut drone = Drone::new(keypair, addr, transactions_addr, requests_addr, None, None);
|
2018-06-19 23:51:04 -07:00
|
|
|
drone.request_current = drone.request_current + 256;
|
2018-06-20 11:33:35 -07:00
|
|
|
assert_eq!(drone.request_current, 256);
|
2018-06-19 23:51:04 -07:00
|
|
|
drone.clear_request_count();
|
2018-06-20 11:33:35 -07:00
|
|
|
assert_eq!(drone.request_current, 0);
|
2018-06-19 23:51:04 -07:00
|
|
|
}
|
|
|
|
|
2018-06-19 21:39:53 -07:00
|
|
|
#[test]
|
|
|
|
fn test_add_ip_to_cache() {
|
2018-08-09 07:56:04 -07:00
|
|
|
let keypair = Keypair::new();
|
2018-06-19 21:39:53 -07:00
|
|
|
let mut addr: SocketAddr = "0.0.0.0:9900".parse().unwrap();
|
|
|
|
addr.set_ip(get_ip_addr().unwrap());
|
2018-06-24 00:37:18 -07:00
|
|
|
let transactions_addr = "0.0.0.0:0".parse().unwrap();
|
|
|
|
let requests_addr = "0.0.0.0:0".parse().unwrap();
|
|
|
|
let mut drone = Drone::new(keypair, addr, transactions_addr, requests_addr, None, None);
|
2018-06-19 21:39:53 -07:00
|
|
|
let ip = "127.0.0.1".parse().expect("create IpAddr from string");
|
|
|
|
assert_eq!(drone.ip_cache.len(), 0);
|
|
|
|
drone.add_ip_to_cache(ip);
|
|
|
|
assert_eq!(drone.ip_cache.len(), 1);
|
|
|
|
assert!(drone.ip_cache.contains(&ip));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_clear_ip_cache() {
|
2018-08-09 07:56:04 -07:00
|
|
|
let keypair = Keypair::new();
|
2018-06-19 21:39:53 -07:00
|
|
|
let mut addr: SocketAddr = "0.0.0.0:9900".parse().unwrap();
|
|
|
|
addr.set_ip(get_ip_addr().unwrap());
|
2018-06-24 00:37:18 -07:00
|
|
|
let transactions_addr = "0.0.0.0:0".parse().unwrap();
|
|
|
|
let requests_addr = "0.0.0.0:0".parse().unwrap();
|
|
|
|
let mut drone = Drone::new(keypair, addr, transactions_addr, requests_addr, None, None);
|
2018-06-19 21:39:53 -07:00
|
|
|
let ip = "127.0.0.1".parse().expect("create IpAddr from string");
|
|
|
|
assert_eq!(drone.ip_cache.len(), 0);
|
|
|
|
drone.add_ip_to_cache(ip);
|
|
|
|
assert_eq!(drone.ip_cache.len(), 1);
|
|
|
|
drone.clear_ip_cache();
|
|
|
|
assert_eq!(drone.ip_cache.len(), 0);
|
|
|
|
assert!(drone.ip_cache.is_empty());
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_drone_default_init() {
|
2018-08-09 07:56:04 -07:00
|
|
|
let keypair = Keypair::new();
|
2018-06-19 21:39:53 -07:00
|
|
|
let mut addr: SocketAddr = "0.0.0.0:9900".parse().unwrap();
|
|
|
|
addr.set_ip(get_ip_addr().unwrap());
|
2018-06-24 00:37:18 -07:00
|
|
|
let transactions_addr = "0.0.0.0:0".parse().unwrap();
|
|
|
|
let requests_addr = "0.0.0.0:0".parse().unwrap();
|
2018-06-19 21:39:53 -07:00
|
|
|
let time_slice: Option<u64> = None;
|
|
|
|
let request_cap: Option<u64> = None;
|
2018-06-24 00:58:44 -07:00
|
|
|
let drone = Drone::new(
|
|
|
|
keypair,
|
|
|
|
addr,
|
|
|
|
transactions_addr,
|
|
|
|
requests_addr,
|
|
|
|
time_slice,
|
|
|
|
request_cap,
|
|
|
|
);
|
2018-06-19 21:39:53 -07:00
|
|
|
assert_eq!(drone.time_slice, Duration::new(TIME_SLICE, 0));
|
|
|
|
assert_eq!(drone.request_cap, REQUEST_CAP);
|
|
|
|
}
|
|
|
|
|
2018-08-03 11:06:06 -07:00
|
|
|
fn tmp_ledger_path(name: &str) -> String {
|
2018-08-13 12:53:30 -07:00
|
|
|
use std::env;
|
2018-08-13 19:45:25 -07:00
|
|
|
let out_dir = env::var("OUT_DIR").unwrap_or_else(|_| "target".to_string());
|
2018-08-09 07:56:04 -07:00
|
|
|
let keypair = Keypair::new();
|
2018-08-03 11:06:06 -07:00
|
|
|
|
2018-08-13 12:53:30 -07:00
|
|
|
format!("{}/tmp-ledger-{}-{}", out_dir, name, keypair.pubkey())
|
2018-08-03 11:06:06 -07:00
|
|
|
}
|
|
|
|
|
2018-06-19 21:39:53 -07:00
|
|
|
#[test]
|
2018-07-03 11:06:34 -07:00
|
|
|
#[ignore]
|
2018-06-19 21:39:53 -07:00
|
|
|
fn test_send_airdrop() {
|
2018-06-21 19:41:47 -07:00
|
|
|
const SMALL_BATCH: i64 = 50;
|
|
|
|
const TPS_BATCH: i64 = 5_000_000;
|
|
|
|
|
2018-06-19 21:39:53 -07:00
|
|
|
logger::setup();
|
2018-08-09 07:56:04 -07:00
|
|
|
let leader_keypair = Keypair::new();
|
2018-07-31 22:07:53 -07:00
|
|
|
let leader = TestNode::new_localhost_with_pubkey(leader_keypair.pubkey());
|
2018-06-19 21:39:53 -07:00
|
|
|
|
|
|
|
let alice = Mint::new(10_000_000);
|
|
|
|
let bank = Bank::new(&alice);
|
2018-08-09 07:56:04 -07:00
|
|
|
let bob_pubkey = Keypair::new().pubkey();
|
|
|
|
let carlos_pubkey = Keypair::new().pubkey();
|
2018-06-19 21:39:53 -07:00
|
|
|
let exit = Arc::new(AtomicBool::new(false));
|
2018-06-28 14:51:53 -07:00
|
|
|
let leader_data = leader.data.clone();
|
2018-08-03 11:06:06 -07:00
|
|
|
let ledger_path = tmp_ledger_path("send_airdrop");
|
2018-06-19 21:39:53 -07:00
|
|
|
|
2018-08-22 16:37:57 -07:00
|
|
|
let server = Fullnode::new_with_bank(
|
2018-07-31 22:07:53 -07:00
|
|
|
leader_keypair,
|
2018-06-19 21:39:53 -07:00
|
|
|
bank,
|
2018-06-27 12:35:58 -07:00
|
|
|
0,
|
2018-08-09 11:35:52 -07:00
|
|
|
&[],
|
2018-06-28 14:51:53 -07:00
|
|
|
leader,
|
2018-08-22 16:37:57 -07:00
|
|
|
None,
|
2018-06-19 21:39:53 -07:00
|
|
|
exit.clone(),
|
2018-08-22 16:37:57 -07:00
|
|
|
Some(&ledger_path),
|
2018-07-31 16:54:24 -07:00
|
|
|
false,
|
2018-06-19 21:39:53 -07:00
|
|
|
);
|
2018-07-03 11:06:34 -07:00
|
|
|
//TODO: this seems unstable
|
2018-06-19 21:39:53 -07:00
|
|
|
sleep(Duration::from_millis(900));
|
|
|
|
|
2018-06-22 13:02:57 -07:00
|
|
|
let mut addr: SocketAddr = "0.0.0.0:9900".parse().expect("bind to drone socket");
|
|
|
|
addr.set_ip(get_ip_addr().expect("drone get_ip_addr"));
|
2018-06-19 23:51:04 -07:00
|
|
|
let mut drone = Drone::new(
|
|
|
|
alice.keypair(),
|
|
|
|
addr,
|
2018-07-09 17:55:11 -07:00
|
|
|
leader_data.contact_info.tpu,
|
|
|
|
leader_data.contact_info.rpu,
|
2018-06-19 23:51:04 -07:00
|
|
|
None,
|
2018-07-02 21:57:39 -07:00
|
|
|
Some(150_000),
|
2018-06-19 23:51:04 -07:00
|
|
|
);
|
2018-06-19 21:39:53 -07:00
|
|
|
|
2018-06-22 13:02:57 -07:00
|
|
|
let requests_socket = UdpSocket::bind("0.0.0.0:0").expect("drone bind to requests socket");
|
2018-06-22 13:41:43 -07:00
|
|
|
let transactions_socket =
|
|
|
|
UdpSocket::bind("0.0.0.0:0").expect("drone bind to transactions socket");
|
2018-06-24 00:58:44 -07:00
|
|
|
|
2018-06-19 21:39:53 -07:00
|
|
|
let mut client = ThinClient::new(
|
2018-07-09 17:55:11 -07:00
|
|
|
leader_data.contact_info.rpu,
|
2018-06-19 21:39:53 -07:00
|
|
|
requests_socket,
|
2018-07-09 17:55:11 -07:00
|
|
|
leader_data.contact_info.tpu,
|
2018-06-19 21:39:53 -07:00
|
|
|
transactions_socket,
|
|
|
|
);
|
|
|
|
|
2018-07-20 16:19:00 -07:00
|
|
|
let bob_req = DroneRequest::GetAirdrop {
|
|
|
|
airdrop_request_amount: 50,
|
2018-08-09 08:03:08 -07:00
|
|
|
client_pubkey: bob_pubkey,
|
2018-07-20 16:19:00 -07:00
|
|
|
};
|
|
|
|
let bob_sig = drone.send_airdrop(bob_req).unwrap();
|
|
|
|
assert!(client.poll_for_signature(&bob_sig).is_ok());
|
|
|
|
|
|
|
|
let carlos_req = DroneRequest::GetAirdrop {
|
|
|
|
airdrop_request_amount: 5_000_000,
|
2018-08-09 08:03:08 -07:00
|
|
|
client_pubkey: carlos_pubkey,
|
2018-07-20 16:19:00 -07:00
|
|
|
};
|
|
|
|
let carlos_sig = drone.send_airdrop(carlos_req).unwrap();
|
|
|
|
assert!(client.poll_for_signature(&carlos_sig).is_ok());
|
|
|
|
|
|
|
|
let bob_balance = client.get_balance(&bob_pubkey);
|
2018-06-21 19:41:47 -07:00
|
|
|
info!("Small request balance: {:?}", bob_balance);
|
2018-06-19 21:39:53 -07:00
|
|
|
assert_eq!(bob_balance.unwrap(), SMALL_BATCH);
|
|
|
|
|
2018-07-20 16:19:00 -07:00
|
|
|
let carlos_balance = client.get_balance(&carlos_pubkey);
|
2018-06-21 19:41:47 -07:00
|
|
|
info!("TPS request balance: {:?}", carlos_balance);
|
2018-06-19 21:39:53 -07:00
|
|
|
assert_eq!(carlos_balance.unwrap(), TPS_BATCH);
|
|
|
|
|
|
|
|
exit.store(true, Ordering::Relaxed);
|
2018-07-03 21:14:08 -07:00
|
|
|
server.join().unwrap();
|
2018-08-03 11:06:06 -07:00
|
|
|
remove_dir_all(ledger_path).unwrap();
|
2018-06-19 21:39:53 -07:00
|
|
|
}
|
|
|
|
}
|