blockworks-foundation
/
solana-with-rpc-optimizations
mirror of https://github.com/blockworks-foundation/solana-with-rpc-optimizations.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #41 from garious/genesis 

Add command-line tool for generating a genesis block
This commit is contained in:
Greg Fitzgerald 2018-03-04 01:27:59 -07:00 committed by GitHub
parent 74ebaf1744 9b26892bae
commit f63096620a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
13 changed files with 319 additions and 174 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
Cargo.toml
View File

@ -23,6 +23,14 @@ path = "src/bin/client-demo.rs"
name = "silk-testnode"
path = "src/bin/testnode.rs"
[[bin]]
name = "silk-genesis-block"
path = "src/bin/genesis-block.rs"
[[bin]]
name = "silk-genesis-file-demo"
path = "src/bin/genesis-file-demo.rs"
[badges]
codecov = { repository = "loomprotocol/silk", branch = "master", service = "github" }
@ -37,6 +45,7 @@ sha2-asm = {version="0.3", optional=true}
generic-array = { version = "0.9.0", default-features = false, features = ["serde"] }
serde = "1.0.27"
serde_derive = "1.0.27"
serde_json = "1.0.10"
ring = "0.12.1"
untrusted = "0.5.1"
bincode = "1.0.0"

180
src/accountant.rs
View File

@ -2,8 +2,9 @@
//! event log to record transactions. Its users can deposit funds and
//! transfer funds to other users.
use log::{Entry, Sha256Hash};
use log::{hash, Entry, Sha256Hash};
use event::{Event, PublicKey, Signature};
use genesis::Genesis;
use historian::Historian;
use ring::signature::Ed25519KeyPair;
use std::sync::mpsc::SendError;
@ -26,13 +27,18 @@ pub struct Accountant {
}
impl Accountant {
pub fn new(start_hash: &Sha256Hash, ms_per_tick: Option<u64>) -> Self {
let hist = Historian::<u64>::new(start_hash, ms_per_tick);
Accountant {
pub fn new(gen: &Genesis, ms_per_tick: Option<u64>) -> Self {
let start_hash = hash(&gen.pkcs8);
let hist = Historian::<u64>::new(&start_hash, ms_per_tick);
let mut acc = Accountant {
historian: hist,
balances: HashMap::new(),
end_hash: *start_hash,
end_hash: start_hash,
};
for (i, event) in gen.create_events().into_iter().enumerate() {
acc.process_verified_event(event, i < 2).unwrap();
}
acc
}
pub fn sync(self: &mut Self) -> Vec<Entry<u64>> {
@ -48,70 +54,62 @@ impl Accountant {
entries
}
pub fn deposit_signed(self: &mut Self, to: PublicKey, data: u64, sig: Signature) -> Result<()> {
let event = Event::new_claim(to, data, sig);
if !self.historian.verify_event(&event) {
return Err(AccountingError::InvalidEvent);
}
if let Err(SendError(_)) = self.historian.sender.send(event) {
return Err(AccountingError::SendError);
}
if self.balances.contains_key(&to) {
if let Some(x) = self.balances.get_mut(&to) {
*x += data;
}
} else {
self.balances.insert(to, data);
}
Ok(())
}
pub fn deposit(self: &mut Self, n: u64, keypair: &Ed25519KeyPair) -> Result<Signature> {
use event::{get_pubkey, sign_claim_data};
let key = get_pubkey(keypair);
let to = get_pubkey(keypair);
let sig = sign_claim_data(&n, keypair);
self.deposit_signed(key, n, sig).map(|_| sig)
}
pub fn transfer_signed(
self: &mut Self,
from: PublicKey,
to: PublicKey,
data: u64,
sig: Signature,
) -> Result<()> {
if self.get_balance(&from).unwrap_or(0) < data {
return Err(AccountingError::InsufficientFunds);
}
let event = Event::Transaction {
from: Some(from),
to,
data,
sig,
};
let event = Event::new_claim(to, n, sig);
if !self.historian.verify_event(&event) {
return Err(AccountingError::InvalidEvent);
}
if let Err(SendError(_)) = self.historian.sender.send(event) {
return Err(AccountingError::SendError);
}
self.process_verified_event(event, true).map(|_| sig)
}
if let Some(x) = self.balances.get_mut(&from) {
*x -= data;
}
fn is_deposit(allow_deposits: bool, from: &PublicKey, to: &PublicKey) -> bool {
allow_deposits && from == to
}
if self.balances.contains_key(&to) {
if let Some(x) = self.balances.get_mut(&to) {
*x += data;
pub fn process_event(self: &mut Self, event: Event<u64>) -> Result<()> {
if !self.historian.verify_event(&event) {
return Err(AccountingError::InvalidEvent);
}
self.process_verified_event(event, false)
}
fn process_verified_event(
self: &mut Self,
event: Event<u64>,
allow_deposits: bool,
) -> Result<()> {
match event {
Event::Tick => Ok(()),
Event::Transaction { from, to, data, .. } => {
if !Self::is_deposit(allow_deposits, &from, &to) {
if self.get_balance(&from).unwrap_or(0) < data {
return Err(AccountingError::InsufficientFunds);
}
}
if let Err(SendError(_)) = self.historian.sender.send(event) {
return Err(AccountingError::SendError);
}
if !Self::is_deposit(allow_deposits, &from, &to) {
if let Some(x) = self.balances.get_mut(&from) {
*x -= data;
}
}
if self.balances.contains_key(&to) {
if let Some(x) = self.balances.get_mut(&to) {
*x += data;
}
} else {
self.balances.insert(to, data);
}
Ok(())
}
} else {
self.balances.insert(to, data);
}
Ok(())
}
pub fn transfer(
@ -123,7 +121,13 @@ impl Accountant {
use event::{get_pubkey, sign_transaction_data};
let from = get_pubkey(keypair);
let sig = sign_transaction_data(&n, keypair, &to);
self.transfer_signed(from, to, n, sig).map(|_| sig)
let event = Event::Transaction {
from,
to,
data: n,
sig,
};
self.process_event(event).map(|_| sig)
}
pub fn get_balance(self: &Self, pubkey: &PublicKey) -> Option<u64> {
@ -153,19 +157,16 @@ mod tests {
use super::*;
use event::{generate_keypair, get_pubkey};
use logger::ExitReason;
use genesis::Creator;
#[test]
fn test_accountant() {
let zero = Sha256Hash::default();
let mut acc = Accountant::new(&zero, Some(2));
let alice_keypair = generate_keypair();
let bob_keypair = generate_keypair();
acc.deposit(10_000, &alice_keypair).unwrap();
let sig = acc.deposit(1_000, &bob_keypair).unwrap();
acc.wait_on_signature(&sig);
let bob = Creator::new(1_000);
let bob_pubkey = bob.pubkey;
let alice = Genesis::new(10_000, vec![bob]);
let mut acc = Accountant::new(&alice, Some(2));
let bob_pubkey = get_pubkey(&bob_keypair);
let sig = acc.transfer(500, &alice_keypair, bob_pubkey).unwrap();
let sig = acc.transfer(500, &alice.get_keypair(), bob_pubkey).unwrap();
acc.wait_on_signature(&sig);
assert_eq!(acc.get_balance(&bob_pubkey).unwrap(), 1_500);
@ -181,22 +182,18 @@ mod tests {
fn test_invalid_transfer() {
use std::thread::sleep;
use std::time::Duration;
let zero = Sha256Hash::default();
let mut acc = Accountant::new(&zero, Some(2));
let alice_keypair = generate_keypair();
let bob_keypair = generate_keypair();
acc.deposit(10_000, &alice_keypair).unwrap();
let sig = acc.deposit(1_000, &bob_keypair).unwrap();
acc.wait_on_signature(&sig);
let bob = Creator::new(1_000);
let bob_pubkey = bob.pubkey;
let alice = Genesis::new(11_000, vec![bob]);
let mut acc = Accountant::new(&alice, Some(2));
let bob_pubkey = get_pubkey(&bob_keypair);
assert_eq!(
acc.transfer(10_001, &alice_keypair, bob_pubkey),
acc.transfer(10_001, &alice.get_keypair(), bob_pubkey),
Err(AccountingError::InsufficientFunds)
);
sleep(Duration::from_millis(30));
let alice_pubkey = get_pubkey(&alice_keypair);
let alice_pubkey = get_pubkey(&alice.get_keypair());
assert_eq!(acc.get_balance(&alice_pubkey).unwrap(), 10_000);
assert_eq!(acc.get_balance(&bob_pubkey).unwrap(), 1_000);
@ -207,30 +204,11 @@ mod tests {
);
}
#[test]
fn test_multiple_claims() {
let zero = Sha256Hash::default();
let mut acc = Accountant::new(&zero, Some(2));
let keypair = generate_keypair();
acc.deposit(1, &keypair).unwrap();
let sig = acc.deposit(2, &keypair).unwrap();
acc.wait_on_signature(&sig);
let pubkey = get_pubkey(&keypair);
assert_eq!(acc.get_balance(&pubkey).unwrap(), 3);
drop(acc.historian.sender);
assert_eq!(
acc.historian.thread_hdl.join().unwrap().1,
ExitReason::RecvDisconnected
);
}
#[test]
fn test_transfer_to_newb() {
let zero = Sha256Hash::default();
let mut acc = Accountant::new(&zero, Some(2));
let alice_keypair = generate_keypair();
let alice = Genesis::new(10_000, vec![]);
let mut acc = Accountant::new(&alice, Some(2));
let alice_keypair = alice.get_keypair();
let bob_keypair = generate_keypair();
let sig = acc.deposit(10_000, &alice_keypair).unwrap();
acc.wait_on_signature(&sig);

22
src/accountant_skel.rs
View File

@ -1,7 +1,6 @@
use std::io;
use accountant::Accountant;
use event::{PublicKey, Signature};
//use serde::Serialize;
use event::{Event, PublicKey, Signature};
pub struct AccountantSkel {
pub obj: Accountant,
@ -9,11 +8,6 @@ pub struct AccountantSkel {
#[derive(Serialize, Deserialize, Debug)]
pub enum Request {
Deposit {
key: PublicKey,
val: u64,
sig: Signature,
},
Transfer {
from: PublicKey,
to: PublicKey,
@ -41,14 +35,14 @@ impl AccountantSkel {
pub fn process_request(self: &mut Self, msg: Request) -> Option<Response> {
match msg {
Request::Deposit { key, val, sig } => {
if let Err(err) = self.obj.deposit_signed(key, val, sig) {
println!("Deposit error: {:?}", err);
}
None
}
Request::Transfer { from, to, val, sig } => {
if let Err(err) = self.obj.transfer_signed(from, to, val, sig) {
let event = Event::Transaction {
from,
to,
data: val,
sig,
};
if let Err(err) = self.obj.process_event(event) {
println!("Transfer error: {:?}", err);
}
None

42
src/accountant_stub.rs
View File

@ -22,24 +22,6 @@ impl AccountantStub {
}
}
pub fn deposit_signed(
self: &Self,
key: PublicKey,
val: u64,
sig: Signature,
) -> io::Result<usize> {
let req = Request::Deposit { key, val, sig };
let data = serialize(&req).unwrap();
self.socket.send_to(&data, &self.addr)
}
pub fn deposit(self: &Self, n: u64, keypair: &Ed25519KeyPair) -> io::Result<Signature> {
use event::{get_pubkey, sign_claim_data};
let key = get_pubkey(keypair);
let sig = sign_claim_data(&n, keypair);
self.deposit_signed(key, n, sig).map(|_| sig)
}
pub fn transfer_signed(
self: &Self,
from: PublicKey,
@ -100,32 +82,22 @@ mod tests {
use accountant_skel::AccountantSkel;
use std::thread::{sleep, spawn};
use std::time::Duration;
use log::Sha256Hash;
use event::{generate_keypair, get_pubkey};
use genesis::{Creator, Genesis};
#[test]
fn test_accountant_stub() {
let addr = "127.0.0.1:9000";
let send_addr = "127.0.0.1:9001";
spawn(move || {
let zero = Sha256Hash::default();
let acc = Accountant::new(&zero, None);
let mut skel = AccountantSkel::new(acc);
skel.serve(addr).unwrap();
});
let bob = Creator::new(1_000);
let bob_pubkey = bob.pubkey;
let alice = Genesis::new(10_000, vec![bob]);
let acc = Accountant::new(&alice, None);
spawn(move || AccountantSkel::new(acc).serve(addr).unwrap());
sleep(Duration::from_millis(30));
let socket = UdpSocket::bind(send_addr).unwrap();
let acc = AccountantStub::new(addr, socket);
let alice_keypair = generate_keypair();
let bob_keypair = generate_keypair();
acc.deposit(10_000, &alice_keypair).unwrap();
let sig = acc.deposit(1_000, &bob_keypair).unwrap();
acc.wait_on_signature(&sig).unwrap();
let bob_pubkey = get_pubkey(&bob_keypair);
let sig = acc.transfer(500, &alice_keypair, bob_pubkey).unwrap();
let sig = acc.transfer(500, &alice.get_keypair(), bob_pubkey).unwrap();
acc.wait_on_signature(&sig).unwrap();
assert_eq!(acc.get_balance(&bob_pubkey).unwrap(), 1_500);
}

34
src/bin/client-demo.rs
View File

@ -1,24 +1,36 @@
//extern crate serde_json;
extern crate silk;
//use std::io::stdin;
fn main() {
use silk::accountant_stub::AccountantStub;
use silk::accountant_skel::AccountantSkel;
use silk::accountant::Accountant;
use silk::event::{generate_keypair, get_pubkey, sign_transaction_data};
use silk::genesis::Genesis;
use std::time::Instant;
use std::net::UdpSocket;
use silk::event::{generate_keypair, get_pubkey, sign_transaction_data};
use std::thread::{sleep, spawn};
use std::time::Duration;
let addr = "127.0.0.1:8000";
let send_addr = "127.0.0.1:8001";
let txs = 200;
let gen = Genesis::new(txs, vec![]);
let alice_keypair = generate_keypair();
//let gen: Genesis = serde_json::from_reader(stdin()).unwrap();
//let alice_keypair = gen.get_keypair();
let acc = Accountant::new(&gen, None);
spawn(move || AccountantSkel::new(acc).serve(addr).unwrap());
sleep(Duration::from_millis(30));
let socket = UdpSocket::bind(send_addr).unwrap();
let acc = AccountantStub::new(addr, socket);
let alice_keypair = generate_keypair();
let alice_pubkey = get_pubkey(&alice_keypair);
let txs = 2_000;
println!("Depositing {} units in Alice's account...", txs);
let sig = acc.deposit(txs, &alice_keypair).unwrap();
acc.wait_on_signature(&sig).unwrap();
assert_eq!(acc.get_balance(&alice_pubkey).unwrap(), txs);
println!("Done.");
let one = 1;
println!("Signing transactions...");
let now = Instant::now();
@ -45,7 +57,7 @@ fn main() {
let now = Instant::now();
for &(k, s) in &sigs {
let e = Event::Transaction {
from: Some(alice_pubkey),
from: alice_pubkey,
to: k,
data: one,
sig: s,
@ -64,7 +76,7 @@ fn main() {
println!("Transferring 1 unit {} times...", txs);
let now = Instant::now();
let mut sig = sig;
let mut sig = Default::default();
for (k, s) in sigs {
acc.transfer_signed(alice_pubkey, k, one, s).unwrap();
sig = s;

35
src/bin/genesis-block.rs Normal file
View File

@ -0,0 +1,35 @@
//! A command-line executable for generating the chain's genesis block.
extern crate ring;
extern crate serde_json;
extern crate silk;
use silk::genesis::Genesis;
use silk::log::{hash, verify_slice_u64};
use silk::logger::Logger;
use std::sync::mpsc::sync_channel;
use std::io::stdin;
fn main() {
let gen: Genesis = serde_json::from_reader(stdin()).unwrap();
let (_sender, event_receiver) = sync_channel(100);
let (entry_sender, receiver) = sync_channel(100);
let mut logger = Logger::new(event_receiver, entry_sender, hash(&gen.pkcs8));
for tx in gen.create_events() {
logger.log_event(tx).unwrap();
}
drop(logger.sender);
let entries = receiver.iter().collect::<Vec<_>>();
verify_slice_u64(&entries, &entries[0].end_hash);
println!("[");
let len = entries.len();
for (i, x) in entries.iter().enumerate() {
let s = serde_json::to_string(&x).unwrap();
let terminator = if i + 1 == len { "" } else { "," };
println!(" {}{}", s, terminator);
}
println!("]");
}

19
src/bin/genesis-file-demo.rs Normal file
View File

@ -0,0 +1,19 @@
extern crate serde_json;
extern crate silk;
use silk::genesis::{Creator, Genesis};
use silk::event::{generate_keypair, get_pubkey};
fn main() {
let alice = Creator {
tokens: 200,
pubkey: get_pubkey(&generate_keypair()),
};
let bob = Creator {
tokens: 100,
pubkey: get_pubkey(&generate_keypair()),
};
let creators = vec![alice, bob];
let gen = Genesis::new(300, creators);
println!("{}", serde_json::to_string(&gen).unwrap());
}

8
src/bin/testnode.rs
View File

@ -1,13 +1,15 @@
extern crate serde_json;
extern crate silk;
use silk::accountant_skel::AccountantSkel;
use silk::accountant::Accountant;
use silk::log::Sha256Hash;
use silk::genesis::Genesis;
use std::io::stdin;
fn main() {
let addr = "127.0.0.1:8000";
let zero = Sha256Hash::default();
let acc = Accountant::new(&zero, Some(1000));
let gen: Genesis = serde_json::from_reader(stdin()).unwrap();
let acc = Accountant::new(&gen, Some(1000));
let mut skel = AccountantSkel::new(acc);
println!("Listening on {}", addr);
skel.serve(addr).unwrap();

12
src/event.rs
View File

@ -30,7 +30,7 @@ pub type Signature = GenericArray<u8, U64>;
pub enum Event<T> {
Tick,
Transaction {
from: Option<PublicKey>,
from: PublicKey,
to: PublicKey,
data: T,
sig: Signature,
@ -40,7 +40,7 @@ pub enum Event<T> {
impl<T> Event<T> {
pub fn new_claim(to: PublicKey, data: T, sig: Signature) -> Self {
Event::Transaction {
from: None,
from: to,
to,
data,
sig,
@ -75,15 +75,13 @@ pub fn sign_transaction_data<T: Serialize>(
keypair: &Ed25519KeyPair,
to: &PublicKey,
) -> Signature {
let from = &Some(get_pubkey(keypair));
let from = &get_pubkey(keypair);
sign_serialized(&(from, to, data), keypair)
}
/// Return a signature for the given data using the private key from the given keypair.
pub fn sign_claim_data<T: Serialize>(data: &T, keypair: &Ed25519KeyPair) -> Signature {
let to = get_pubkey(keypair);
let from: Option<PublicKey> = None;
sign_serialized(&(&from, &to, data), keypair)
sign_transaction_data(data, keypair, &get_pubkey(keypair))
}
/// Verify a signed message with the given public key.
@ -113,7 +111,7 @@ pub fn verify_event<T: Serialize>(event: &Event<T>) -> bool {
} = *event
{
let sign_data = serialize(&(&from, &to, &data)).unwrap();
if !verify_signature(&from.unwrap_or(to), &sign_data, &sig) {
if !verify_signature(&from, &sign_data, &sig) {
return false;
}
}

100
src/genesis.rs Normal file
View File

@ -0,0 +1,100 @@
//! A library for generating the chain's genesis block.
use event::{generate_keypair, get_pubkey, sign_transaction_data, Event, PublicKey};
use ring::rand::SystemRandom;
use ring::signature::Ed25519KeyPair;
use untrusted::Input;
#[derive(Serialize, Deserialize, Debug)]
pub struct Creator {
pub pubkey: PublicKey,
pub tokens: u64,
}
impl Creator {
pub fn new(tokens: u64) -> Self {
Creator {
pubkey: get_pubkey(&generate_keypair()),
tokens,
}
}
}
#[derive(Serialize, Deserialize, Debug)]
pub struct Genesis {
pub pkcs8: Vec<u8>,
pub tokens: u64,
pub creators: Vec<Creator>,
}
impl Genesis {
pub fn new(tokens: u64, creators: Vec<Creator>) -> Self {
let rnd = SystemRandom::new();
let pkcs8 = Ed25519KeyPair::generate_pkcs8(&rnd).unwrap().to_vec();
Genesis {
pkcs8,
tokens,
creators,
}
}
pub fn get_keypair(&self) -> Ed25519KeyPair {
Ed25519KeyPair::from_pkcs8(Input::from(&self.pkcs8)).unwrap()
}
pub fn get_pubkey(&self) -> PublicKey {
get_pubkey(&self.get_keypair())
}
pub fn create_transaction(&self, data: u64, to: &PublicKey) -> Event<u64> {
let from = self.get_pubkey();
let sig = sign_transaction_data(&data, &self.get_keypair(), to);
Event::Transaction {
from,
to: *to,
data,
sig,
}
}
pub fn create_events(&self) -> Vec<Event<u64>> {
let pubkey = self.get_pubkey();
let event0 = Event::Tick;
let event1 = self.create_transaction(self.tokens, &pubkey);
let mut events = vec![event0, event1];
for x in &self.creators {
let tx = self.create_transaction(x.tokens, &x.pubkey);
events.push(tx);
}
events
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_create_events() {
let mut events = Genesis::new(100, vec![]).create_events().into_iter();
assert_eq!(events.next().unwrap(), Event::Tick);
if let Event::Transaction { from, to, .. } = events.next().unwrap() {
assert_eq!(from, to);
} else {
assert!(false);
}
assert_eq!(events.next(), None);
}
#[test]
fn test_create_creator() {
assert_eq!(
Genesis::new(100, vec![Creator::new(42)])
.create_events()
.len(),
3
);
}
}

1
src/lib.rs
View File

@ -2,6 +2,7 @@
pub mod log;
pub mod logger;
pub mod event;
pub mod genesis;
pub mod historian;
pub mod accountant;
pub mod accountant_skel;

6
src/log.rs
View File

@ -255,7 +255,7 @@ mod tests {
let pubkey1 = get_pubkey(&keypair1);
let data = hash(b"hello, world");
let event0 = Event::Transaction {
from: Some(get_pubkey(&keypair0)),
from: get_pubkey(&keypair0),
to: pubkey1,
data,
sig: sign_transaction_data(&data, &keypair0, &pubkey1),
@ -272,7 +272,7 @@ mod tests {
let pubkey1 = get_pubkey(&keypair1);
let data = hash(b"hello, world");
let event0 = Event::Transaction {
from: Some(get_pubkey(&keypair0)),
from: get_pubkey(&keypair0),
to: pubkey1,
data: hash(b"goodbye cruel world"), // <-- attack!
sig: sign_transaction_data(&data, &keypair0, &pubkey1),
@ -290,7 +290,7 @@ mod tests {
let pubkey1 = get_pubkey(&keypair1);
let data = hash(b"hello, world");
let event0 = Event::Transaction {
from: Some(get_pubkey(&keypair0)),
from: get_pubkey(&keypair0),
to: get_pubkey(&thief_keypair), // <-- attack!
data: hash(b"goodbye cruel world"),
sig: sign_transaction_data(&data, &keypair0, &pubkey1),

25
src/logger.rs
View File

@ -110,6 +110,8 @@ mod tests {
use super::*;
use log::*;
use event::*;
use genesis::*;
use std::sync::mpsc::sync_channel;
#[test]
fn test_bad_event_signature() {
@ -132,4 +134,27 @@ mod tests {
assert!(verify_event_and_reserve_signature(&mut sigs, &event0));
assert!(!verify_event_and_reserve_signature(&mut sigs, &event0));
}
fn run_genesis(gen: Genesis) -> Vec<Entry<u64>> {
let (_sender, event_receiver) = sync_channel(100);
let (entry_sender, receiver) = sync_channel(100);
let mut logger = Logger::new(event_receiver, entry_sender, hash(&gen.pkcs8));
for tx in gen.create_events() {
logger.log_event(tx).unwrap();
}
drop(logger.sender);
receiver.iter().collect::<Vec<_>>()
}
#[test]
fn test_genesis_no_creators() {
let entries = run_genesis(Genesis::new(100, vec![]));
assert!(verify_slice_u64(&entries, &entries[0].end_hash));
}
#[test]
fn test_genesis() {
let entries = run_genesis(Genesis::new(100, vec![Creator::new(42)]));
assert!(verify_slice_u64(&entries, &entries[0].end_hash));
}
}