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-09-14 01:58:59 -07:00
|
|
|
use bincode::{deserialize, serialize};
|
2018-11-14 18:57:34 -08:00
|
|
|
use byteorder::{ByteOrder, LittleEndian};
|
2018-09-14 01:58:59 -07:00
|
|
|
use bytes::Bytes;
|
2018-12-14 20:39:10 -08:00
|
|
|
use log::*;
|
|
|
|
use serde_derive::{Deserialize, Serialize};
|
2018-11-16 08:45:59 -08:00
|
|
|
use solana_metrics;
|
|
|
|
use solana_metrics::influxdb;
|
2018-11-16 08:04:46 -08:00
|
|
|
use solana_sdk::hash::Hash;
|
|
|
|
use solana_sdk::packet::PACKET_DATA_SIZE;
|
2018-10-25 11:13:08 -07:00
|
|
|
use solana_sdk::pubkey::Pubkey;
|
2018-11-16 08:04:46 -08:00
|
|
|
use solana_sdk::signature::Keypair;
|
2018-12-03 13:32:31 -08:00
|
|
|
use solana_sdk::system_instruction::SystemInstruction;
|
|
|
|
use solana_sdk::system_program;
|
2018-11-16 08:04:46 -08:00
|
|
|
use solana_sdk::transaction::Transaction;
|
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-11-14 18:57:34 -08:00
|
|
|
use std::net::{IpAddr, Ipv4Addr, SocketAddr, TcpStream};
|
2018-09-14 01:58:59 -07:00
|
|
|
use std::sync::mpsc::Sender;
|
|
|
|
use std::sync::{Arc, Mutex};
|
|
|
|
use std::thread;
|
2018-06-19 21:39:53 -07:00
|
|
|
use std::time::Duration;
|
2018-09-14 01:58:59 -07:00
|
|
|
use tokio;
|
|
|
|
use tokio::net::TcpListener;
|
|
|
|
use tokio::prelude::*;
|
|
|
|
use tokio_codec::{BytesCodec, Decoder};
|
2018-11-16 08:04:46 -08:00
|
|
|
|
|
|
|
#[macro_export]
|
|
|
|
macro_rules! socketaddr {
|
|
|
|
($ip:expr, $port:expr) => {
|
|
|
|
SocketAddr::from((Ipv4Addr::from($ip), $port))
|
|
|
|
};
|
|
|
|
($str:expr) => {{
|
|
|
|
let a: SocketAddr = $str.parse().unwrap();
|
|
|
|
a
|
|
|
|
}};
|
|
|
|
}
|
2018-06-19 21:39:53 -07:00
|
|
|
|
2018-06-19 23:51:04 -07:00
|
|
|
pub const TIME_SLICE: u64 = 60;
|
2018-09-06 14:20:01 -07:00
|
|
|
pub const REQUEST_CAP: u64 = 500_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-11-14 18:57:34 -08:00
|
|
|
tokens: u64,
|
|
|
|
to: Pubkey,
|
|
|
|
last_id: Hash,
|
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
|
|
|
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 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(),
|
|
|
|
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-11-14 18:57:34 -08:00
|
|
|
pub fn build_airdrop_transaction(
|
|
|
|
&mut self,
|
|
|
|
req: DroneRequest,
|
|
|
|
) -> Result<Transaction, io::Error> {
|
|
|
|
trace!("build_airdrop_transaction: {:?}", req);
|
|
|
|
match req {
|
2018-06-21 22:11:24 -07:00
|
|
|
DroneRequest::GetAirdrop {
|
2018-11-14 18:57:34 -08:00
|
|
|
tokens,
|
|
|
|
to,
|
|
|
|
last_id,
|
2018-06-21 22:11:24 -07:00
|
|
|
} => {
|
2018-11-14 18:57:34 -08:00
|
|
|
if self.check_request_limit(tokens) {
|
|
|
|
self.request_current += tokens;
|
2018-11-16 08:45:59 -08:00
|
|
|
solana_metrics::submit(
|
2018-11-14 18:57:34 -08:00
|
|
|
influxdb::Point::new("drone")
|
|
|
|
.add_tag("op", influxdb::Value::String("airdrop".to_string()))
|
|
|
|
.add_field("request_amount", influxdb::Value::Integer(tokens as i64))
|
|
|
|
.add_field(
|
|
|
|
"request_current",
|
|
|
|
influxdb::Value::Integer(self.request_current as i64),
|
2018-12-07 19:01:28 -08:00
|
|
|
)
|
|
|
|
.to_owned(),
|
2018-11-14 18:57:34 -08:00
|
|
|
);
|
|
|
|
|
|
|
|
info!("Requesting airdrop of {} to {:?}", tokens, to);
|
2018-11-16 08:04:46 -08:00
|
|
|
|
|
|
|
let create_instruction = SystemInstruction::CreateAccount {
|
|
|
|
tokens,
|
|
|
|
space: 0,
|
|
|
|
program_id: Pubkey::default(),
|
|
|
|
};
|
|
|
|
let mut transaction = Transaction::new(
|
|
|
|
&self.mint_keypair,
|
|
|
|
&[to],
|
2018-12-03 13:32:31 -08:00
|
|
|
system_program::id(),
|
2018-11-16 08:04:46 -08:00
|
|
|
&create_instruction,
|
|
|
|
last_id,
|
|
|
|
0, /*fee*/
|
|
|
|
);
|
|
|
|
|
|
|
|
transaction.sign(&[&self.mint_keypair], last_id);
|
|
|
|
Ok(transaction)
|
2018-11-14 18:57:34 -08:00
|
|
|
} else {
|
|
|
|
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) {
|
2018-11-16 08:45:59 -08:00
|
|
|
solana_metrics::flush();
|
2018-07-05 21:40:09 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-11-14 18:57:34 -08:00
|
|
|
pub fn request_airdrop_transaction(
|
|
|
|
drone_addr: &SocketAddr,
|
|
|
|
id: &Pubkey,
|
|
|
|
tokens: u64,
|
|
|
|
last_id: Hash,
|
|
|
|
) -> Result<Transaction, Error> {
|
|
|
|
// TODO: make this async tokio client
|
|
|
|
let mut stream = TcpStream::connect_timeout(drone_addr, Duration::new(3, 0))?;
|
|
|
|
stream.set_read_timeout(Some(Duration::new(10, 0)))?;
|
|
|
|
let req = DroneRequest::GetAirdrop {
|
|
|
|
tokens,
|
|
|
|
last_id,
|
|
|
|
to: *id,
|
|
|
|
};
|
|
|
|
let req = serialize(&req).expect("serialize drone request");
|
|
|
|
stream.write_all(&req)?;
|
|
|
|
|
|
|
|
// Read length of transaction
|
|
|
|
let mut buffer = [0; 2];
|
|
|
|
stream.read_exact(&mut buffer).or_else(|err| {
|
|
|
|
info!(
|
|
|
|
"request_airdrop_transaction: buffer length read_exact error: {:?}",
|
|
|
|
err
|
|
|
|
);
|
|
|
|
Err(Error::new(ErrorKind::Other, "Airdrop failed"))
|
|
|
|
})?;
|
|
|
|
let transaction_length = LittleEndian::read_u16(&buffer) as usize;
|
|
|
|
if transaction_length >= PACKET_DATA_SIZE {
|
|
|
|
Err(Error::new(
|
|
|
|
ErrorKind::Other,
|
|
|
|
format!(
|
|
|
|
"request_airdrop_transaction: invalid transaction_length from drone: {}",
|
|
|
|
transaction_length
|
|
|
|
),
|
|
|
|
))?;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Read the transaction
|
|
|
|
let mut buffer = Vec::new();
|
|
|
|
buffer.resize(transaction_length, 0);
|
|
|
|
stream.read_exact(&mut buffer).or_else(|err| {
|
|
|
|
info!(
|
|
|
|
"request_airdrop_transaction: buffer read_exact error: {:?}",
|
|
|
|
err
|
|
|
|
);
|
|
|
|
Err(Error::new(ErrorKind::Other, "Airdrop failed"))
|
|
|
|
})?;
|
|
|
|
|
|
|
|
let transaction: Transaction = deserialize(&buffer).or_else(|err| {
|
|
|
|
Err(Error::new(
|
|
|
|
ErrorKind::Other,
|
|
|
|
format!("request_airdrop_transaction deserialize failure: {:?}", err),
|
|
|
|
))
|
|
|
|
})?;
|
|
|
|
Ok(transaction)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn run_local_drone(mint_keypair: Keypair, sender: Sender<SocketAddr>) {
|
2018-09-14 01:58:59 -07:00
|
|
|
thread::spawn(move || {
|
|
|
|
let drone_addr = socketaddr!(0, 0);
|
2018-11-14 18:57:34 -08:00
|
|
|
let drone = Arc::new(Mutex::new(Drone::new(mint_keypair, None, None)));
|
2018-09-14 01:58:59 -07:00
|
|
|
let socket = TcpListener::bind(&drone_addr).unwrap();
|
|
|
|
sender.send(socket.local_addr().unwrap()).unwrap();
|
|
|
|
info!("Drone started. Listening on: {}", drone_addr);
|
|
|
|
let done = socket
|
|
|
|
.incoming()
|
|
|
|
.map_err(|e| debug!("failed to accept socket; error = {:?}", e))
|
|
|
|
.for_each(move |socket| {
|
|
|
|
let drone2 = drone.clone();
|
|
|
|
let framed = BytesCodec::new().framed(socket);
|
|
|
|
let (writer, reader) = framed.split();
|
|
|
|
|
|
|
|
let processor = reader.and_then(move |bytes| {
|
|
|
|
let req: DroneRequest = deserialize(&bytes).or_else(|err| {
|
|
|
|
Err(io::Error::new(
|
|
|
|
io::ErrorKind::Other,
|
|
|
|
format!("deserialize packet in drone: {:?}", err),
|
|
|
|
))
|
|
|
|
})?;
|
|
|
|
|
|
|
|
info!("Airdrop requested...");
|
2018-11-14 18:57:34 -08:00
|
|
|
let res = drone2.lock().unwrap().build_airdrop_transaction(req);
|
|
|
|
match res {
|
2018-09-14 01:58:59 -07:00
|
|
|
Ok(_) => info!("Airdrop sent!"),
|
|
|
|
Err(_) => info!("Request limit reached for this time slice"),
|
|
|
|
}
|
2018-11-14 18:57:34 -08:00
|
|
|
let response = res?;
|
|
|
|
|
2018-09-14 01:58:59 -07:00
|
|
|
info!("Airdrop tx signature: {:?}", response);
|
|
|
|
let response_vec = serialize(&response).or_else(|err| {
|
|
|
|
Err(io::Error::new(
|
|
|
|
io::ErrorKind::Other,
|
|
|
|
format!("serialize signature in drone: {:?}", err),
|
|
|
|
))
|
|
|
|
})?;
|
2018-11-14 18:57:34 -08:00
|
|
|
|
|
|
|
let mut response_vec_with_length = vec![0; 2];
|
|
|
|
LittleEndian::write_u16(
|
|
|
|
&mut response_vec_with_length,
|
|
|
|
response_vec.len() as u16,
|
|
|
|
);
|
|
|
|
info!(
|
|
|
|
"Airdrop response_vec_with_length: {:?}",
|
|
|
|
response_vec_with_length
|
|
|
|
);
|
|
|
|
response_vec_with_length.extend_from_slice(&response_vec);
|
|
|
|
|
|
|
|
let response_bytes = Bytes::from(response_vec_with_length.clone());
|
|
|
|
info!("Airdrop response_bytes: {:?}", response_bytes);
|
2018-09-14 01:58:59 -07:00
|
|
|
Ok(response_bytes)
|
|
|
|
});
|
|
|
|
let server = writer
|
|
|
|
.send_all(processor.or_else(|err| {
|
|
|
|
Err(io::Error::new(
|
|
|
|
io::ErrorKind::Other,
|
|
|
|
format!("Drone response: {:?}", err),
|
|
|
|
))
|
2018-12-07 19:01:28 -08:00
|
|
|
}))
|
|
|
|
.then(|_| Ok(()));
|
2018-09-14 01:58:59 -07:00
|
|
|
tokio::spawn(server)
|
|
|
|
});
|
|
|
|
tokio::run(done);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2018-06-19 21:39:53 -07:00
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
2018-12-14 15:34:17 -08:00
|
|
|
use super::*;
|
2018-11-16 08:04:46 -08:00
|
|
|
use solana_sdk::signature::{Keypair, KeypairUtil};
|
2018-06-19 21:39:53 -07:00
|
|
|
use std::time::Duration;
|
|
|
|
|
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-11-14 18:57:34 -08:00
|
|
|
let mut drone = Drone::new(keypair, 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-11-14 18:57:34 -08:00
|
|
|
let mut drone = Drone::new(keypair, 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-11-14 18:57:34 -08:00
|
|
|
let mut drone = Drone::new(keypair, 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-11-14 18:57:34 -08:00
|
|
|
let mut drone = Drone::new(keypair, 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 time_slice: Option<u64> = None;
|
|
|
|
let request_cap: Option<u64> = None;
|
2018-11-14 18:57:34 -08:00
|
|
|
let drone = Drone::new(keypair, 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-12-14 15:34:17 -08: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-12-14 15:34:17 -08:00
|
|
|
use solana::bank::Bank;
|
|
|
|
use solana::cluster_info::Node;
|
|
|
|
use solana::fullnode::Fullnode;
|
|
|
|
use solana::leader_scheduler::LeaderScheduler;
|
|
|
|
use solana::ledger::get_tmp_ledger_path;
|
|
|
|
use solana::mint::Mint;
|
|
|
|
use solana::netutil::get_ip_addr;
|
|
|
|
use solana::thin_client::ThinClient;
|
|
|
|
use solana_logger;
|
|
|
|
use std::fs::remove_dir_all;
|
|
|
|
use std::net::UdpSocket;
|
|
|
|
use std::sync::{Arc, RwLock};
|
|
|
|
|
2018-11-05 08:36:22 -08:00
|
|
|
const SMALL_BATCH: u64 = 50;
|
|
|
|
const TPS_BATCH: u64 = 5_000_000;
|
2018-06-21 19:41:47 -07:00
|
|
|
|
2018-12-14 12:36:50 -08:00
|
|
|
solana_logger::setup();
|
2018-10-25 16:58:40 -07:00
|
|
|
let leader_keypair = Arc::new(Keypair::new());
|
2018-08-28 16:32:40 -07:00
|
|
|
let leader = Node::new_localhost_with_pubkey(leader_keypair.pubkey());
|
2018-06-19 21:39:53 -07:00
|
|
|
|
|
|
|
let alice = Mint::new(10_000_000);
|
2018-10-25 16:58:40 -07:00
|
|
|
let mut bank = Bank::new(&alice);
|
|
|
|
let leader_scheduler = Arc::new(RwLock::new(LeaderScheduler::from_bootstrap_leader(
|
|
|
|
leader.info.id,
|
|
|
|
)));
|
|
|
|
bank.leader_scheduler = leader_scheduler;
|
2018-08-09 07:56:04 -07:00
|
|
|
let bob_pubkey = Keypair::new().pubkey();
|
|
|
|
let carlos_pubkey = Keypair::new().pubkey();
|
2018-08-31 00:10:39 -07:00
|
|
|
let leader_data = leader.info.clone();
|
2018-10-17 13:42:54 -07:00
|
|
|
let ledger_path = get_tmp_ledger_path("send_airdrop");
|
2018-06-19 21:39:53 -07:00
|
|
|
|
2018-10-25 16:58:40 -07:00
|
|
|
let vote_account_keypair = Arc::new(Keypair::new());
|
2018-10-30 10:05:18 -07:00
|
|
|
let last_id = bank.last_id();
|
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-10-25 16:58:40 -07:00
|
|
|
vote_account_keypair,
|
2018-06-19 21:39:53 -07:00
|
|
|
bank,
|
2018-06-27 12:35:58 -07:00
|
|
|
0,
|
2018-10-30 10:05:18 -07:00
|
|
|
&last_id,
|
2018-06-28 14:51:53 -07:00
|
|
|
leader,
|
2018-08-22 16:37:57 -07:00
|
|
|
None,
|
2018-09-14 01:53:18 -07:00
|
|
|
&ledger_path,
|
2018-07-31 16:54:24 -07:00
|
|
|
false,
|
2018-11-05 09:50:58 -08:00
|
|
|
None,
|
2018-06-19 21:39:53 -07:00
|
|
|
);
|
|
|
|
|
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-11-14 18:57:34 -08:00
|
|
|
let mut drone = Drone::new(alice.keypair(), None, Some(150_000));
|
2018-06-19 21:39:53 -07:00
|
|
|
|
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-11-15 13:23:26 -08:00
|
|
|
let mut client = ThinClient::new(leader_data.rpc, leader_data.tpu, transactions_socket);
|
2018-06-19 21:39:53 -07:00
|
|
|
|
2018-07-20 16:19:00 -07:00
|
|
|
let bob_req = DroneRequest::GetAirdrop {
|
2018-11-14 18:57:34 -08:00
|
|
|
tokens: 50,
|
|
|
|
to: bob_pubkey,
|
|
|
|
last_id,
|
2018-07-20 16:19:00 -07:00
|
|
|
};
|
2018-11-14 18:57:34 -08:00
|
|
|
let bob_tx = drone.build_airdrop_transaction(bob_req).unwrap();
|
|
|
|
let bob_sig = client.transfer_signed(&bob_tx).unwrap();
|
2018-07-20 16:19:00 -07:00
|
|
|
assert!(client.poll_for_signature(&bob_sig).is_ok());
|
|
|
|
|
2018-09-10 20:25:14 -07:00
|
|
|
// restart the leader, drone should find the new one at the same gossip port
|
2018-09-10 23:38:40 -07:00
|
|
|
server.close().unwrap();
|
2018-09-10 20:25:14 -07:00
|
|
|
|
2018-10-25 16:58:40 -07:00
|
|
|
let leader_keypair = Arc::new(Keypair::new());
|
2018-09-10 20:25:14 -07:00
|
|
|
let leader = Node::new_localhost_with_pubkey(leader_keypair.pubkey());
|
|
|
|
let leader_data = leader.info.clone();
|
2018-10-10 16:49:41 -07:00
|
|
|
let server = Fullnode::new(
|
|
|
|
leader,
|
|
|
|
&ledger_path,
|
|
|
|
leader_keypair,
|
2018-10-25 16:58:40 -07:00
|
|
|
Arc::new(Keypair::new()),
|
2018-10-10 16:49:41 -07:00
|
|
|
None,
|
|
|
|
false,
|
|
|
|
LeaderScheduler::from_bootstrap_leader(leader_data.id),
|
2018-11-05 09:50:58 -08:00
|
|
|
None,
|
2018-10-10 16:49:41 -07:00
|
|
|
);
|
2018-09-10 20:25:14 -07:00
|
|
|
|
|
|
|
let transactions_socket =
|
|
|
|
UdpSocket::bind("0.0.0.0:0").expect("drone bind to transactions socket");
|
|
|
|
|
2018-11-15 13:23:26 -08:00
|
|
|
let mut client = ThinClient::new(leader_data.rpc, leader_data.tpu, transactions_socket);
|
2018-09-10 20:25:14 -07:00
|
|
|
|
2018-07-20 16:19:00 -07:00
|
|
|
let carlos_req = DroneRequest::GetAirdrop {
|
2018-11-14 18:57:34 -08:00
|
|
|
tokens: 5_000_000,
|
|
|
|
to: carlos_pubkey,
|
|
|
|
last_id,
|
2018-07-20 16:19:00 -07:00
|
|
|
};
|
2018-09-10 20:25:14 -07:00
|
|
|
|
|
|
|
// using existing drone, new thin client
|
2018-11-14 18:57:34 -08:00
|
|
|
let carlos_tx = drone.build_airdrop_transaction(carlos_req).unwrap();
|
|
|
|
let carlos_sig = client.transfer_signed(&carlos_tx).unwrap();
|
2018-07-20 16:19:00 -07:00
|
|
|
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);
|
|
|
|
|
2018-09-10 20:25:14 -07:00
|
|
|
server.close().unwrap();
|
2018-08-03 11:06:06 -07:00
|
|
|
remove_dir_all(ledger_path).unwrap();
|
2018-06-19 21:39:53 -07:00
|
|
|
}
|
2018-12-14 15:34:17 -08:00
|
|
|
*/
|
2018-06-19 21:39:53 -07:00
|
|
|
}
|