Delete event.rs
This commit is contained in:
35
src/bank.rs
35
src/bank.rs
@ -7,7 +7,6 @@ extern crate libc;
|
|||||||
|
|
||||||
use chrono::prelude::*;
|
use chrono::prelude::*;
|
||||||
use entry::Entry;
|
use entry::Entry;
|
||||||
use event::Event;
|
|
||||||
use hash::Hash;
|
use hash::Hash;
|
||||||
use mint::Mint;
|
use mint::Mint;
|
||||||
use plan::{Payment, Plan, Witness};
|
use plan::{Payment, Plan, Witness};
|
||||||
@ -259,34 +258,10 @@ impl Bank {
|
|||||||
.collect()
|
.collect()
|
||||||
}
|
}
|
||||||
|
|
||||||
fn partition_events(events: Vec<Event>) -> (Vec<Transaction>, Vec<Event>) {
|
|
||||||
(
|
|
||||||
events
|
|
||||||
.into_iter()
|
|
||||||
.map(|Event::Transaction(tr)| tr)
|
|
||||||
.collect(),
|
|
||||||
vec![],
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn process_verified_events(&self, events: Vec<Event>) -> Vec<Result<Event>> {
|
|
||||||
let (trs, rest) = Self::partition_events(events);
|
|
||||||
let mut results: Vec<_> = self.process_verified_transactions(trs)
|
|
||||||
.into_iter()
|
|
||||||
.map(|x| x.map(Event::Transaction))
|
|
||||||
.collect();
|
|
||||||
|
|
||||||
for event in rest {
|
|
||||||
results.push(self.process_verified_event(event));
|
|
||||||
}
|
|
||||||
|
|
||||||
results
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn process_verified_entries(&self, entries: Vec<Entry>) -> Result<()> {
|
pub fn process_verified_entries(&self, entries: Vec<Entry>) -> Result<()> {
|
||||||
for entry in entries {
|
for entry in entries {
|
||||||
self.register_entry_id(&entry.id);
|
self.register_entry_id(&entry.id);
|
||||||
for result in self.process_verified_events(entry.events) {
|
for result in self.process_verified_transactions(entry.events) {
|
||||||
result?;
|
result?;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -362,14 +337,6 @@ impl Bank {
|
|||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Process an Transaction or Witness that has already been verified.
|
|
||||||
pub fn process_verified_event(&self, event: Event) -> Result<Event> {
|
|
||||||
match event {
|
|
||||||
Event::Transaction(ref tr) => self.process_verified_transaction(tr),
|
|
||||||
}?;
|
|
||||||
Ok(event)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Create, sign, and process a Transaction from `keypair` to `to` of
|
/// Create, sign, and process a Transaction from `keypair` to `to` of
|
||||||
/// `n` tokens where `last_id` is the last Entry ID observed by the client.
|
/// `n` tokens where `last_id` is the last Entry ID observed by the client.
|
||||||
pub fn transfer(
|
pub fn transfer(
|
||||||
|
@ -1,8 +1,7 @@
|
|||||||
//! The `banking_stage` processes Event messages.
|
//! The `banking_stage` processes Transaction messages.
|
||||||
|
|
||||||
use bank::Bank;
|
use bank::Bank;
|
||||||
use bincode::deserialize;
|
use bincode::deserialize;
|
||||||
use event::Event;
|
|
||||||
use packet;
|
use packet;
|
||||||
use packet::SharedPackets;
|
use packet::SharedPackets;
|
||||||
use rayon::prelude::*;
|
use rayon::prelude::*;
|
||||||
@ -16,6 +15,7 @@ use std::thread::{spawn, JoinHandle};
|
|||||||
use std::time::Duration;
|
use std::time::Duration;
|
||||||
use std::time::Instant;
|
use std::time::Instant;
|
||||||
use timing;
|
use timing;
|
||||||
|
use transaction::Transaction;
|
||||||
|
|
||||||
pub struct BankingStage {
|
pub struct BankingStage {
|
||||||
pub thread_hdl: JoinHandle<()>,
|
pub thread_hdl: JoinHandle<()>,
|
||||||
@ -49,7 +49,7 @@ impl BankingStage {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_events(p: &packet::Packets) -> Vec<Option<(Event, SocketAddr)>> {
|
fn deserialize_events(p: &packet::Packets) -> Vec<Option<(Transaction, SocketAddr)>> {
|
||||||
p.packets
|
p.packets
|
||||||
.par_iter()
|
.par_iter()
|
||||||
.map(|x| {
|
.map(|x| {
|
||||||
@ -86,7 +86,7 @@ impl BankingStage {
|
|||||||
.zip(vers)
|
.zip(vers)
|
||||||
.filter_map(|(event, ver)| match event {
|
.filter_map(|(event, ver)| match event {
|
||||||
None => None,
|
None => None,
|
||||||
Some((event, _addr)) => if event.verify() && ver != 0 {
|
Some((event, _addr)) => if event.verify_plan() && ver != 0 {
|
||||||
Some(event)
|
Some(event)
|
||||||
} else {
|
} else {
|
||||||
None
|
None
|
||||||
@ -95,7 +95,7 @@ impl BankingStage {
|
|||||||
.collect();
|
.collect();
|
||||||
|
|
||||||
debug!("process_events");
|
debug!("process_events");
|
||||||
let results = bank.process_verified_events(events);
|
let results = bank.process_verified_transactions(events);
|
||||||
let events = results.into_iter().filter_map(|x| x.ok()).collect();
|
let events = results.into_iter().filter_map(|x| x.ok()).collect();
|
||||||
signal_sender.send(Signal::Events(events))?;
|
signal_sender.send(Signal::Events(events))?;
|
||||||
debug!("done process_events");
|
debug!("done process_events");
|
||||||
@ -120,7 +120,6 @@ impl BankingStage {
|
|||||||
|
|
||||||
//use bank::Bank;
|
//use bank::Bank;
|
||||||
//use entry::Entry;
|
//use entry::Entry;
|
||||||
//use event::Event;
|
|
||||||
//use hash::Hash;
|
//use hash::Hash;
|
||||||
//use record_stage::RecordStage;
|
//use record_stage::RecordStage;
|
||||||
//use record_stage::Signal;
|
//use record_stage::Signal;
|
||||||
@ -128,11 +127,11 @@ impl BankingStage {
|
|||||||
//use std::sync::mpsc::{channel, Sender};
|
//use std::sync::mpsc::{channel, Sender};
|
||||||
//use std::sync::{Arc, Mutex};
|
//use std::sync::{Arc, Mutex};
|
||||||
//use std::time::Duration;
|
//use std::time::Duration;
|
||||||
|
//use transaction::Transaction;
|
||||||
//
|
//
|
||||||
//#[cfg(test)]
|
//#[cfg(test)]
|
||||||
//mod tests {
|
//mod tests {
|
||||||
// use bank::Bank;
|
// use bank::Bank;
|
||||||
// use event::Event;
|
|
||||||
// use event_processor::EventProcessor;
|
// use event_processor::EventProcessor;
|
||||||
// use mint::Mint;
|
// use mint::Mint;
|
||||||
// use signature::{KeyPair, KeyPairUtil};
|
// use signature::{KeyPair, KeyPairUtil};
|
||||||
@ -152,12 +151,12 @@ impl BankingStage {
|
|||||||
// // Process a batch that includes a transaction that receives two tokens.
|
// // Process a batch that includes a transaction that receives two tokens.
|
||||||
// let alice = KeyPair::new();
|
// let alice = KeyPair::new();
|
||||||
// let tr = Transaction::new(&mint.keypair(), alice.pubkey(), 2, mint.last_id());
|
// let tr = Transaction::new(&mint.keypair(), alice.pubkey(), 2, mint.last_id());
|
||||||
// let events = vec![Event::Transaction(tr)];
|
// let events = vec![tr];
|
||||||
// let entry0 = event_processor.process_events(events).unwrap();
|
// let entry0 = event_processor.process_events(events).unwrap();
|
||||||
//
|
//
|
||||||
// // Process a second batch that spends one of those tokens.
|
// // Process a second batch that spends one of those tokens.
|
||||||
// let tr = Transaction::new(&alice, mint.pubkey(), 1, mint.last_id());
|
// let tr = Transaction::new(&alice, mint.pubkey(), 1, mint.last_id());
|
||||||
// let events = vec![Event::Transaction(tr)];
|
// let events = vec![tr];
|
||||||
// let entry1 = event_processor.process_events(events).unwrap();
|
// let entry1 = event_processor.process_events(events).unwrap();
|
||||||
//
|
//
|
||||||
// // Collect the ledger and feed it to a new bank.
|
// // Collect the ledger and feed it to a new bank.
|
||||||
@ -170,7 +169,7 @@ impl BankingStage {
|
|||||||
// for entry in entries {
|
// for entry in entries {
|
||||||
// assert!(
|
// assert!(
|
||||||
// bank
|
// bank
|
||||||
// .process_verified_events(entry.events)
|
// .process_verified_transactions(entry.events)
|
||||||
// .into_iter()
|
// .into_iter()
|
||||||
// .all(|x| x.is_ok())
|
// .all(|x| x.is_ok())
|
||||||
// );
|
// );
|
||||||
@ -229,15 +228,10 @@ impl BankingStage {
|
|||||||
// })
|
// })
|
||||||
// .collect();
|
// .collect();
|
||||||
//
|
//
|
||||||
// let events: Vec<_> = transactions
|
|
||||||
// .into_iter()
|
|
||||||
// .map(|tr| Event::Transaction(tr))
|
|
||||||
// .collect();
|
|
||||||
//
|
|
||||||
// let event_processor = EventProcessor::new(bank, &mint.last_id(), None);
|
// let event_processor = EventProcessor::new(bank, &mint.last_id(), None);
|
||||||
//
|
//
|
||||||
// let now = Instant::now();
|
// let now = Instant::now();
|
||||||
// assert!(event_processor.process_events(events).is_ok());
|
// assert!(event_processor.process_events(transactions).is_ok());
|
||||||
// let duration = now.elapsed();
|
// let duration = now.elapsed();
|
||||||
// let sec = duration.as_secs() as f64 + duration.subsec_nanos() as f64 / 1_000_000_000.0;
|
// let sec = duration.as_secs() as f64 + duration.subsec_nanos() as f64 / 1_000_000_000.0;
|
||||||
// let tps = txs as f64 / sec;
|
// let tps = txs as f64 / sec;
|
||||||
@ -246,7 +240,7 @@ impl BankingStage {
|
|||||||
// drop(event_processor.historian_input);
|
// drop(event_processor.historian_input);
|
||||||
// let entries: Vec<Entry> = event_processor.output.lock().unwrap().iter().collect();
|
// let entries: Vec<Entry> = event_processor.output.lock().unwrap().iter().collect();
|
||||||
// assert_eq!(entries.len(), 1);
|
// assert_eq!(entries.len(), 1);
|
||||||
// assert_eq!(entries[0].events.len(), txs as usize);
|
// assert_eq!(entries[0].transactions.len(), txs as usize);
|
||||||
//
|
//
|
||||||
// println!("{} tps", tps);
|
// println!("{} tps", tps);
|
||||||
// }
|
// }
|
||||||
@ -258,7 +252,6 @@ mod bench {
|
|||||||
use self::test::Bencher;
|
use self::test::Bencher;
|
||||||
use bank::*;
|
use bank::*;
|
||||||
use banking_stage::BankingStage;
|
use banking_stage::BankingStage;
|
||||||
use event::Event;
|
|
||||||
use mint::Mint;
|
use mint::Mint;
|
||||||
use packet::{to_packets, PacketRecycler};
|
use packet::{to_packets, PacketRecycler};
|
||||||
use record_stage::Signal;
|
use record_stage::Signal;
|
||||||
@ -266,6 +259,7 @@ mod bench {
|
|||||||
use std::iter;
|
use std::iter;
|
||||||
use std::sync::Arc;
|
use std::sync::Arc;
|
||||||
use std::sync::mpsc::channel;
|
use std::sync::mpsc::channel;
|
||||||
|
use transaction::Transaction;
|
||||||
|
|
||||||
#[bench]
|
#[bench]
|
||||||
fn stage_bench(bencher: &mut Bencher) {
|
fn stage_bench(bencher: &mut Bencher) {
|
||||||
@ -274,7 +268,7 @@ mod bench {
|
|||||||
let pubkey = KeyPair::new().pubkey();
|
let pubkey = KeyPair::new().pubkey();
|
||||||
|
|
||||||
let events: Vec<_> = (0..tx)
|
let events: Vec<_> = (0..tx)
|
||||||
.map(|i| Event::new_transaction(&mint.keypair(), pubkey, i as i64, mint.last_id()))
|
.map(|i| Transaction::new(&mint.keypair(), pubkey, i as i64, mint.last_id()))
|
||||||
.collect();
|
.collect();
|
||||||
|
|
||||||
let (verified_sender, verified_receiver) = channel();
|
let (verified_sender, verified_receiver) = channel();
|
||||||
|
@ -7,9 +7,9 @@ use isatty::stdin_isatty;
|
|||||||
use rayon::prelude::*;
|
use rayon::prelude::*;
|
||||||
use solana::bank::MAX_ENTRY_IDS;
|
use solana::bank::MAX_ENTRY_IDS;
|
||||||
use solana::entry::{next_entry, Entry};
|
use solana::entry::{next_entry, Entry};
|
||||||
use solana::event::Event;
|
|
||||||
use solana::mint::MintDemo;
|
use solana::mint::MintDemo;
|
||||||
use solana::signature::{GenKeys, KeyPairUtil};
|
use solana::signature::{GenKeys, KeyPairUtil};
|
||||||
|
use solana::transaction::Transaction;
|
||||||
use std::io::{stdin, Read};
|
use std::io::{stdin, Read};
|
||||||
use std::process::exit;
|
use std::process::exit;
|
||||||
|
|
||||||
@ -46,7 +46,7 @@ fn main() {
|
|||||||
.into_par_iter()
|
.into_par_iter()
|
||||||
.map(|rando| {
|
.map(|rando| {
|
||||||
let last_id = demo.mint.last_id();
|
let last_id = demo.mint.last_id();
|
||||||
Event::new_transaction(&mint_keypair, rando.pubkey(), tokens_per_user, last_id)
|
Transaction::new(&mint_keypair, rando.pubkey(), tokens_per_user, last_id)
|
||||||
})
|
})
|
||||||
.collect();
|
.collect();
|
||||||
|
|
||||||
|
@ -11,7 +11,6 @@ use pnet::datalink;
|
|||||||
use solana::bank::Bank;
|
use solana::bank::Bank;
|
||||||
use solana::crdt::ReplicatedData;
|
use solana::crdt::ReplicatedData;
|
||||||
use solana::entry::Entry;
|
use solana::entry::Entry;
|
||||||
use solana::event::Event;
|
|
||||||
use solana::server::Server;
|
use solana::server::Server;
|
||||||
use solana::signature::{KeyPair, KeyPairUtil};
|
use solana::signature::{KeyPair, KeyPairUtil};
|
||||||
use solana::transaction::Instruction;
|
use solana::transaction::Instruction;
|
||||||
@ -97,7 +96,7 @@ fn main() {
|
|||||||
// fields are the same. That entry should be treated as a deposit, not a
|
// fields are the same. That entry should be treated as a deposit, not a
|
||||||
// transfer to oneself.
|
// transfer to oneself.
|
||||||
let entry1: Entry = entries.next().unwrap();
|
let entry1: Entry = entries.next().unwrap();
|
||||||
let Event::Transaction(ref tr) = entry1.events[0];
|
let tr = &entry1.events[0];
|
||||||
let deposit = if let Instruction::NewContract(contract) = &tr.instruction {
|
let deposit = if let Instruction::NewContract(contract) = &tr.instruction {
|
||||||
contract.plan.final_payment()
|
contract.plan.final_payment()
|
||||||
} else {
|
} else {
|
||||||
@ -115,7 +114,7 @@ fn main() {
|
|||||||
let mut last_id = entry1.id;
|
let mut last_id = entry1.id;
|
||||||
for entry in entries {
|
for entry in entries {
|
||||||
last_id = entry.id;
|
last_id = entry.id;
|
||||||
let results = bank.process_verified_events(entry.events);
|
let results = bank.process_verified_transactions(entry.events);
|
||||||
for result in results {
|
for result in results {
|
||||||
if let Err(e) = result {
|
if let Err(e) = result {
|
||||||
eprintln!("failed to process event {:?}", e);
|
eprintln!("failed to process event {:?}", e);
|
||||||
|
@ -2,7 +2,7 @@ use packet::{Packet, SharedPackets};
|
|||||||
use std::mem::size_of;
|
use std::mem::size_of;
|
||||||
use transaction::{PUB_KEY_OFFSET, SIGNED_DATA_OFFSET, SIG_OFFSET};
|
use transaction::{PUB_KEY_OFFSET, SIGNED_DATA_OFFSET, SIG_OFFSET};
|
||||||
|
|
||||||
pub const TX_OFFSET: usize = 4;
|
pub const TX_OFFSET: usize = 0;
|
||||||
|
|
||||||
#[cfg(feature = "cuda")]
|
#[cfg(feature = "cuda")]
|
||||||
#[repr(C)]
|
#[repr(C)]
|
||||||
@ -144,7 +144,6 @@ pub fn ed25519_verify(batches: &Vec<SharedPackets>) -> Vec<Vec<u8>> {
|
|||||||
mod tests {
|
mod tests {
|
||||||
use bincode::serialize;
|
use bincode::serialize;
|
||||||
use ecdsa;
|
use ecdsa;
|
||||||
use event::Event;
|
|
||||||
use packet::{Packet, Packets, SharedPackets};
|
use packet::{Packet, Packets, SharedPackets};
|
||||||
use std::sync::RwLock;
|
use std::sync::RwLock;
|
||||||
use transaction::Transaction;
|
use transaction::Transaction;
|
||||||
@ -154,13 +153,13 @@ mod tests {
|
|||||||
fn test_layout() {
|
fn test_layout() {
|
||||||
let tr = test_tx();
|
let tr = test_tx();
|
||||||
let tx = serialize(&tr).unwrap();
|
let tx = serialize(&tr).unwrap();
|
||||||
let packet = serialize(&Event::Transaction(tr)).unwrap();
|
let packet = serialize(&tr).unwrap();
|
||||||
assert_matches!(memfind(&packet, &tx), Some(ecdsa::TX_OFFSET));
|
assert_matches!(memfind(&packet, &tx), Some(ecdsa::TX_OFFSET));
|
||||||
assert_matches!(memfind(&packet, &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), None);
|
assert_matches!(memfind(&packet, &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), None);
|
||||||
}
|
}
|
||||||
|
|
||||||
fn make_packet_from_transaction(tr: Transaction) -> Packet {
|
fn make_packet_from_transaction(tr: Transaction) -> Packet {
|
||||||
let tx = serialize(&Event::Transaction(tr)).unwrap();
|
let tx = serialize(&tr).unwrap();
|
||||||
let mut packet = Packet::default();
|
let mut packet = Packet::default();
|
||||||
packet.meta.size = tx.len();
|
packet.meta.size = tx.len();
|
||||||
packet.data[..packet.meta.size].copy_from_slice(&tx);
|
packet.data[..packet.meta.size].copy_from_slice(&tx);
|
||||||
|
37
src/entry.rs
37
src/entry.rs
@ -2,9 +2,9 @@
|
|||||||
//! unique ID that is the hash of the Entry before it, plus the hash of the
|
//! unique ID that is the hash of the Entry before it, plus the hash of the
|
||||||
//! transactions within it. Entries cannot be reordered, and its field `num_hashes`
|
//! transactions within it. Entries cannot be reordered, and its field `num_hashes`
|
||||||
//! represents an approximate amount of time since the last Entry was created.
|
//! represents an approximate amount of time since the last Entry was created.
|
||||||
use event::Event;
|
|
||||||
use hash::{extend_and_hash, hash, Hash};
|
use hash::{extend_and_hash, hash, Hash};
|
||||||
use rayon::prelude::*;
|
use rayon::prelude::*;
|
||||||
|
use transaction::Transaction;
|
||||||
|
|
||||||
/// Each Entry contains three pieces of data. The `num_hashes` field is the number
|
/// Each Entry contains three pieces of data. The `num_hashes` field is the number
|
||||||
/// of hashes performed since the previous entry. The `id` field is the result
|
/// of hashes performed since the previous entry. The `id` field is the result
|
||||||
@ -21,12 +21,12 @@ use rayon::prelude::*;
|
|||||||
pub struct Entry {
|
pub struct Entry {
|
||||||
pub num_hashes: u64,
|
pub num_hashes: u64,
|
||||||
pub id: Hash,
|
pub id: Hash,
|
||||||
pub events: Vec<Event>,
|
pub events: Vec<Transaction>,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Entry {
|
impl Entry {
|
||||||
/// Creates the next Entry `num_hashes` after `start_hash`.
|
/// Creates the next Entry `num_hashes` after `start_hash`.
|
||||||
pub fn new(start_hash: &Hash, cur_hashes: u64, events: Vec<Event>) -> Self {
|
pub fn new(start_hash: &Hash, cur_hashes: u64, events: Vec<Transaction>) -> Self {
|
||||||
let num_hashes = cur_hashes + if events.is_empty() { 0 } else { 1 };
|
let num_hashes = cur_hashes + if events.is_empty() { 0 } else { 1 };
|
||||||
let id = next_hash(start_hash, 0, &events);
|
let id = next_hash(start_hash, 0, &events);
|
||||||
Entry {
|
Entry {
|
||||||
@ -37,7 +37,7 @@ impl Entry {
|
|||||||
}
|
}
|
||||||
|
|
||||||
/// Creates the next Tick Entry `num_hashes` after `start_hash`.
|
/// Creates the next Tick Entry `num_hashes` after `start_hash`.
|
||||||
pub fn new_mut(start_hash: &mut Hash, cur_hashes: &mut u64, events: Vec<Event>) -> Self {
|
pub fn new_mut(start_hash: &mut Hash, cur_hashes: &mut u64, events: Vec<Transaction>) -> Self {
|
||||||
let entry = Self::new(start_hash, *cur_hashes, events);
|
let entry = Self::new(start_hash, *cur_hashes, events);
|
||||||
*start_hash = entry.id;
|
*start_hash = entry.id;
|
||||||
*cur_hashes = 0;
|
*cur_hashes = 0;
|
||||||
@ -57,24 +57,20 @@ impl Entry {
|
|||||||
/// Verifies self.id is the result of hashing a `start_hash` `self.num_hashes` times.
|
/// Verifies self.id is the result of hashing a `start_hash` `self.num_hashes` times.
|
||||||
/// If the event is not a Tick, then hash that as well.
|
/// If the event is not a Tick, then hash that as well.
|
||||||
pub fn verify(&self, start_hash: &Hash) -> bool {
|
pub fn verify(&self, start_hash: &Hash) -> bool {
|
||||||
self.events.par_iter().all(|event| event.verify())
|
self.events.par_iter().all(|event| event.verify_plan())
|
||||||
&& self.id == next_hash(start_hash, self.num_hashes, &self.events)
|
&& self.id == next_hash(start_hash, self.num_hashes, &self.events)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn add_event_data(hash_data: &mut Vec<u8>, event: &Event) {
|
fn add_event_data(hash_data: &mut Vec<u8>, tr: &Transaction) {
|
||||||
match *event {
|
hash_data.push(0u8);
|
||||||
Event::Transaction(ref tr) => {
|
hash_data.extend_from_slice(&tr.sig);
|
||||||
hash_data.push(0u8);
|
|
||||||
hash_data.extend_from_slice(&tr.sig);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Creates the hash `num_hashes` after `start_hash`. If the event contains
|
/// Creates the hash `num_hashes` after `start_hash`. If the event contains
|
||||||
/// a signature, the final hash will be a hash of both the previous ID and
|
/// a signature, the final hash will be a hash of both the previous ID and
|
||||||
/// the signature.
|
/// the signature.
|
||||||
pub fn next_hash(start_hash: &Hash, num_hashes: u64, events: &[Event]) -> Hash {
|
pub fn next_hash(start_hash: &Hash, num_hashes: u64, events: &[Transaction]) -> Hash {
|
||||||
let mut id = *start_hash;
|
let mut id = *start_hash;
|
||||||
for _ in 1..num_hashes {
|
for _ in 1..num_hashes {
|
||||||
id = hash(&id);
|
id = hash(&id);
|
||||||
@ -96,7 +92,7 @@ pub fn next_hash(start_hash: &Hash, num_hashes: u64, events: &[Event]) -> Hash {
|
|||||||
}
|
}
|
||||||
|
|
||||||
/// Creates the next Tick or Event Entry `num_hashes` after `start_hash`.
|
/// Creates the next Tick or Event Entry `num_hashes` after `start_hash`.
|
||||||
pub fn next_entry(start_hash: &Hash, num_hashes: u64, events: Vec<Event>) -> Entry {
|
pub fn next_entry(start_hash: &Hash, num_hashes: u64, events: Vec<Transaction>) -> Entry {
|
||||||
Entry {
|
Entry {
|
||||||
num_hashes,
|
num_hashes,
|
||||||
id: next_hash(start_hash, num_hashes, &events),
|
id: next_hash(start_hash, num_hashes, &events),
|
||||||
@ -109,7 +105,6 @@ mod tests {
|
|||||||
use super::*;
|
use super::*;
|
||||||
use chrono::prelude::*;
|
use chrono::prelude::*;
|
||||||
use entry::Entry;
|
use entry::Entry;
|
||||||
use event::Event;
|
|
||||||
use hash::hash;
|
use hash::hash;
|
||||||
use signature::{KeyPair, KeyPairUtil};
|
use signature::{KeyPair, KeyPairUtil};
|
||||||
use transaction::Transaction;
|
use transaction::Transaction;
|
||||||
@ -130,8 +125,8 @@ mod tests {
|
|||||||
|
|
||||||
// First, verify entries
|
// First, verify entries
|
||||||
let keypair = KeyPair::new();
|
let keypair = KeyPair::new();
|
||||||
let tr0 = Event::new_transaction(&keypair, keypair.pubkey(), 0, zero);
|
let tr0 = Transaction::new(&keypair, keypair.pubkey(), 0, zero);
|
||||||
let tr1 = Event::new_transaction(&keypair, keypair.pubkey(), 1, zero);
|
let tr1 = Transaction::new(&keypair, keypair.pubkey(), 1, zero);
|
||||||
let mut e0 = Entry::new(&zero, 0, vec![tr0.clone(), tr1.clone()]);
|
let mut e0 = Entry::new(&zero, 0, vec![tr0.clone(), tr1.clone()]);
|
||||||
assert!(e0.verify(&zero));
|
assert!(e0.verify(&zero));
|
||||||
|
|
||||||
@ -147,12 +142,8 @@ mod tests {
|
|||||||
|
|
||||||
// First, verify entries
|
// First, verify entries
|
||||||
let keypair = KeyPair::new();
|
let keypair = KeyPair::new();
|
||||||
let tr0 = Event::Transaction(Transaction::new_timestamp(&keypair, Utc::now(), zero));
|
let tr0 = Transaction::new_timestamp(&keypair, Utc::now(), zero);
|
||||||
let tr1 = Event::Transaction(Transaction::new_signature(
|
let tr1 = Transaction::new_signature(&keypair, Default::default(), zero);
|
||||||
&keypair,
|
|
||||||
Default::default(),
|
|
||||||
zero,
|
|
||||||
));
|
|
||||||
let mut e0 = Entry::new(&zero, 0, vec![tr0.clone(), tr1.clone()]);
|
let mut e0 = Entry::new(&zero, 0, vec![tr0.clone(), tr1.clone()]);
|
||||||
assert!(e0.verify(&zero));
|
assert!(e0.verify(&zero));
|
||||||
|
|
||||||
|
31
src/event.rs
31
src/event.rs
@ -1,31 +0,0 @@
|
|||||||
//! The `event` module handles events, which may be a `Transaction`, or a `Witness` used to process a pending
|
|
||||||
//! Transaction.
|
|
||||||
|
|
||||||
use hash::Hash;
|
|
||||||
use signature::{KeyPair, PublicKey};
|
|
||||||
use transaction::Transaction;
|
|
||||||
|
|
||||||
#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)]
|
|
||||||
pub enum Event {
|
|
||||||
Transaction(Transaction),
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Event {
|
|
||||||
pub fn new_transaction(
|
|
||||||
from_keypair: &KeyPair,
|
|
||||||
to: PublicKey,
|
|
||||||
tokens: i64,
|
|
||||||
last_id: Hash,
|
|
||||||
) -> Self {
|
|
||||||
let tr = Transaction::new(from_keypair, to, tokens, last_id);
|
|
||||||
Event::Transaction(tr)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Verify the Event's signature's are valid and if a transaction, that its
|
|
||||||
/// spending plan is valid.
|
|
||||||
pub fn verify(&self) -> bool {
|
|
||||||
match *self {
|
|
||||||
Event::Transaction(ref tr) => tr.verify_plan(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
@ -3,7 +3,6 @@
|
|||||||
|
|
||||||
use bincode::{deserialize, serialize_into};
|
use bincode::{deserialize, serialize_into};
|
||||||
use entry::{next_entry, Entry};
|
use entry::{next_entry, Entry};
|
||||||
use event::Event;
|
|
||||||
use hash::Hash;
|
use hash::Hash;
|
||||||
use packet;
|
use packet;
|
||||||
use packet::{SharedBlob, BLOB_DATA_SIZE, BLOB_SIZE};
|
use packet::{SharedBlob, BLOB_DATA_SIZE, BLOB_SIZE};
|
||||||
@ -12,6 +11,7 @@ use std::cmp::min;
|
|||||||
use std::collections::VecDeque;
|
use std::collections::VecDeque;
|
||||||
use std::io::Cursor;
|
use std::io::Cursor;
|
||||||
use std::mem::size_of;
|
use std::mem::size_of;
|
||||||
|
use transaction::Transaction;
|
||||||
|
|
||||||
pub trait Block {
|
pub trait Block {
|
||||||
/// Verifies the hashes and counts of a slice of events are all consistent.
|
/// Verifies the hashes and counts of a slice of events are all consistent.
|
||||||
@ -27,7 +27,11 @@ impl Block for [Entry] {
|
|||||||
}
|
}
|
||||||
|
|
||||||
/// Create a vector of Entries of length `event_set.len()` from `start_hash` hash, `num_hashes`, and `event_set`.
|
/// Create a vector of Entries of length `event_set.len()` from `start_hash` hash, `num_hashes`, and `event_set`.
|
||||||
pub fn next_entries(start_hash: &Hash, num_hashes: u64, event_set: Vec<Vec<Event>>) -> Vec<Entry> {
|
pub fn next_entries(
|
||||||
|
start_hash: &Hash,
|
||||||
|
num_hashes: u64,
|
||||||
|
event_set: Vec<Vec<Transaction>>,
|
||||||
|
) -> Vec<Entry> {
|
||||||
let mut id = *start_hash;
|
let mut id = *start_hash;
|
||||||
let mut entries = vec![];
|
let mut entries = vec![];
|
||||||
for event_list in &event_set {
|
for event_list in &event_set {
|
||||||
@ -50,7 +54,7 @@ pub fn process_entry_list_into_blobs(
|
|||||||
let mut entries: Vec<Vec<Entry>> = Vec::new();
|
let mut entries: Vec<Vec<Entry>> = Vec::new();
|
||||||
let mut total = 0;
|
let mut total = 0;
|
||||||
for i in &list[start..] {
|
for i in &list[start..] {
|
||||||
total += size_of::<Event>() * i.events.len();
|
total += size_of::<Transaction>() * i.events.len();
|
||||||
total += size_of::<Entry>();
|
total += size_of::<Entry>();
|
||||||
if total >= BLOB_DATA_SIZE {
|
if total >= BLOB_DATA_SIZE {
|
||||||
break;
|
break;
|
||||||
@ -60,7 +64,7 @@ pub fn process_entry_list_into_blobs(
|
|||||||
// See if we need to split the events
|
// See if we need to split the events
|
||||||
if end <= start {
|
if end <= start {
|
||||||
let mut event_start = 0;
|
let mut event_start = 0;
|
||||||
let num_events_per_blob = BLOB_DATA_SIZE / size_of::<Event>();
|
let num_events_per_blob = BLOB_DATA_SIZE / size_of::<Transaction>();
|
||||||
let total_entry_chunks =
|
let total_entry_chunks =
|
||||||
(list[end].events.len() + num_events_per_blob - 1) / num_events_per_blob;
|
(list[end].events.len() + num_events_per_blob - 1) / num_events_per_blob;
|
||||||
trace!(
|
trace!(
|
||||||
@ -147,7 +151,7 @@ mod tests {
|
|||||||
let zero = Hash::default();
|
let zero = Hash::default();
|
||||||
let one = hash(&zero);
|
let one = hash(&zero);
|
||||||
let keypair = KeyPair::new();
|
let keypair = KeyPair::new();
|
||||||
let tr0 = Event::Transaction(Transaction::new(&keypair, keypair.pubkey(), 1, one));
|
let tr0 = Transaction::new(&keypair, keypair.pubkey(), 1, one);
|
||||||
let events = vec![tr0.clone(); 10000];
|
let events = vec![tr0.clone(); 10000];
|
||||||
let e0 = Entry::new(&zero, 0, events);
|
let e0 = Entry::new(&zero, 0, events);
|
||||||
|
|
||||||
@ -165,7 +169,7 @@ mod tests {
|
|||||||
let mut id = Hash::default();
|
let mut id = Hash::default();
|
||||||
let next_id = hash(&id);
|
let next_id = hash(&id);
|
||||||
let keypair = KeyPair::new();
|
let keypair = KeyPair::new();
|
||||||
let tr0 = Event::Transaction(Transaction::new(&keypair, keypair.pubkey(), 1, next_id));
|
let tr0 = Transaction::new(&keypair, keypair.pubkey(), 1, next_id);
|
||||||
let events = vec![tr0.clone(); 5];
|
let events = vec![tr0.clone(); 5];
|
||||||
let event_set = vec![events.clone(); 5];
|
let event_set = vec![events.clone(); 5];
|
||||||
let entries0 = next_entries(&id, 0, event_set);
|
let entries0 = next_entries(&id, 0, event_set);
|
||||||
|
@ -7,7 +7,6 @@ pub mod entry;
|
|||||||
pub mod entry_writer;
|
pub mod entry_writer;
|
||||||
#[cfg(feature = "erasure")]
|
#[cfg(feature = "erasure")]
|
||||||
pub mod erasure;
|
pub mod erasure;
|
||||||
pub mod event;
|
|
||||||
pub mod hash;
|
pub mod hash;
|
||||||
pub mod ledger;
|
pub mod ledger;
|
||||||
pub mod logger;
|
pub mod logger;
|
||||||
|
@ -1,7 +1,6 @@
|
|||||||
//! The `mint` module is a library for generating the chain's genesis block.
|
//! The `mint` module is a library for generating the chain's genesis block.
|
||||||
|
|
||||||
use entry::Entry;
|
use entry::Entry;
|
||||||
use event::Event;
|
|
||||||
use hash::{hash, Hash};
|
use hash::{hash, Hash};
|
||||||
use ring::rand::SystemRandom;
|
use ring::rand::SystemRandom;
|
||||||
use signature::{KeyPair, KeyPairUtil, PublicKey};
|
use signature::{KeyPair, KeyPairUtil, PublicKey};
|
||||||
@ -47,10 +46,10 @@ impl Mint {
|
|||||||
self.pubkey
|
self.pubkey
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn create_events(&self) -> Vec<Event> {
|
pub fn create_events(&self) -> Vec<Transaction> {
|
||||||
let keypair = self.keypair();
|
let keypair = self.keypair();
|
||||||
let tr = Transaction::new(&keypair, self.pubkey(), self.tokens, self.seed());
|
let tr = Transaction::new(&keypair, self.pubkey(), self.tokens, self.seed());
|
||||||
vec![Event::Transaction(tr)]
|
vec![tr]
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn create_entries(&self) -> Vec<Entry> {
|
pub fn create_entries(&self) -> Vec<Entry> {
|
||||||
@ -76,7 +75,7 @@ mod tests {
|
|||||||
#[test]
|
#[test]
|
||||||
fn test_create_events() {
|
fn test_create_events() {
|
||||||
let mut events = Mint::new(100).create_events().into_iter();
|
let mut events = Mint::new(100).create_events().into_iter();
|
||||||
let Event::Transaction(tr) = events.next().unwrap();
|
let tr = events.next().unwrap();
|
||||||
if let Instruction::NewContract(contract) = tr.instruction {
|
if let Instruction::NewContract(contract) = tr.instruction {
|
||||||
if let Plan::Pay(payment) = contract.plan {
|
if let Plan::Pay(payment) = contract.plan {
|
||||||
assert_eq!(tr.from, payment.to);
|
assert_eq!(tr.from, payment.to);
|
||||||
|
@ -6,17 +6,17 @@
|
|||||||
//! The resulting stream of entries represents ordered events in time.
|
//! The resulting stream of entries represents ordered events in time.
|
||||||
|
|
||||||
use entry::Entry;
|
use entry::Entry;
|
||||||
use event::Event;
|
|
||||||
use hash::Hash;
|
use hash::Hash;
|
||||||
use recorder::Recorder;
|
use recorder::Recorder;
|
||||||
use std::sync::mpsc::{channel, Receiver, Sender, TryRecvError};
|
use std::sync::mpsc::{channel, Receiver, Sender, TryRecvError};
|
||||||
use std::thread::{spawn, JoinHandle};
|
use std::thread::{spawn, JoinHandle};
|
||||||
use std::time::{Duration, Instant};
|
use std::time::{Duration, Instant};
|
||||||
|
use transaction::Transaction;
|
||||||
|
|
||||||
#[cfg_attr(feature = "cargo-clippy", allow(large_enum_variant))]
|
#[cfg_attr(feature = "cargo-clippy", allow(large_enum_variant))]
|
||||||
pub enum Signal {
|
pub enum Signal {
|
||||||
Tick,
|
Tick,
|
||||||
Events(Vec<Event>),
|
Events(Vec<Transaction>),
|
||||||
}
|
}
|
||||||
|
|
||||||
pub struct RecordStage {
|
pub struct RecordStage {
|
||||||
@ -140,8 +140,8 @@ mod tests {
|
|||||||
let record_stage = RecordStage::new(signal_receiver, &zero, None);
|
let record_stage = RecordStage::new(signal_receiver, &zero, None);
|
||||||
let alice_keypair = KeyPair::new();
|
let alice_keypair = KeyPair::new();
|
||||||
let bob_pubkey = KeyPair::new().pubkey();
|
let bob_pubkey = KeyPair::new().pubkey();
|
||||||
let event0 = Event::new_transaction(&alice_keypair, bob_pubkey, 1, zero);
|
let event0 = Transaction::new(&alice_keypair, bob_pubkey, 1, zero);
|
||||||
let event1 = Event::new_transaction(&alice_keypair, bob_pubkey, 2, zero);
|
let event1 = Transaction::new(&alice_keypair, bob_pubkey, 2, zero);
|
||||||
input.send(Signal::Events(vec![event0, event1])).unwrap();
|
input.send(Signal::Events(vec![event0, event1])).unwrap();
|
||||||
drop(input);
|
drop(input);
|
||||||
let entries: Vec<_> = record_stage.entry_receiver.iter().collect();
|
let entries: Vec<_> = record_stage.entry_receiver.iter().collect();
|
||||||
|
@ -2,9 +2,9 @@
|
|||||||
//! It records Event items on behalf of its users.
|
//! It records Event items on behalf of its users.
|
||||||
|
|
||||||
use entry::Entry;
|
use entry::Entry;
|
||||||
use event::Event;
|
|
||||||
use hash::{hash, Hash};
|
use hash::{hash, Hash};
|
||||||
use std::time::{Duration, Instant};
|
use std::time::{Duration, Instant};
|
||||||
|
use transaction::Transaction;
|
||||||
|
|
||||||
pub struct Recorder {
|
pub struct Recorder {
|
||||||
last_hash: Hash,
|
last_hash: Hash,
|
||||||
@ -26,7 +26,7 @@ impl Recorder {
|
|||||||
self.num_hashes += 1;
|
self.num_hashes += 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn record(&mut self, events: Vec<Event>) -> Entry {
|
pub fn record(&mut self, events: Vec<Transaction>) -> Entry {
|
||||||
Entry::new_mut(&mut self.last_hash, &mut self.num_hashes, events)
|
Entry::new_mut(&mut self.last_hash, &mut self.num_hashes, events)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -2,7 +2,6 @@
|
|||||||
|
|
||||||
use bank::Bank;
|
use bank::Bank;
|
||||||
use bincode::{deserialize, serialize};
|
use bincode::{deserialize, serialize};
|
||||||
use event::Event;
|
|
||||||
use packet;
|
use packet;
|
||||||
use packet::SharedPackets;
|
use packet::SharedPackets;
|
||||||
use rayon::prelude::*;
|
use rayon::prelude::*;
|
||||||
@ -15,6 +14,7 @@ use std::sync::mpsc::Receiver;
|
|||||||
use std::time::Instant;
|
use std::time::Instant;
|
||||||
use streamer;
|
use streamer;
|
||||||
use timing;
|
use timing;
|
||||||
|
use transaction::Transaction;
|
||||||
|
|
||||||
pub struct RequestProcessor {
|
pub struct RequestProcessor {
|
||||||
bank: Arc<Bank>,
|
bank: Arc<Bank>,
|
||||||
@ -76,7 +76,7 @@ impl RequestProcessor {
|
|||||||
|
|
||||||
// Copy-paste of deserialize_requests() because I can't figure out how to
|
// Copy-paste of deserialize_requests() because I can't figure out how to
|
||||||
// route the lifetimes in a generic version.
|
// route the lifetimes in a generic version.
|
||||||
pub fn deserialize_events(p: &packet::Packets) -> Vec<Option<(Event, SocketAddr)>> {
|
pub fn deserialize_events(p: &packet::Packets) -> Vec<Option<(Transaction, SocketAddr)>> {
|
||||||
p.packets
|
p.packets
|
||||||
.par_iter()
|
.par_iter()
|
||||||
.map(|x| {
|
.map(|x| {
|
||||||
|
@ -4,7 +4,6 @@
|
|||||||
//! unstable and may change in future releases.
|
//! unstable and may change in future releases.
|
||||||
|
|
||||||
use bincode::{deserialize, serialize};
|
use bincode::{deserialize, serialize};
|
||||||
use event::Event;
|
|
||||||
use futures::future::{ok, FutureResult};
|
use futures::future::{ok, FutureResult};
|
||||||
use hash::Hash;
|
use hash::Hash;
|
||||||
use request::{Request, Response};
|
use request::{Request, Response};
|
||||||
@ -75,8 +74,7 @@ impl ThinClient {
|
|||||||
/// Send a signed Transaction to the server for processing. This method
|
/// Send a signed Transaction to the server for processing. This method
|
||||||
/// does not wait for a response.
|
/// does not wait for a response.
|
||||||
pub fn transfer_signed(&self, tr: Transaction) -> io::Result<usize> {
|
pub fn transfer_signed(&self, tr: Transaction) -> io::Result<usize> {
|
||||||
let event = Event::Transaction(tr);
|
let data = serialize(&tr).expect("serialize Transaction in pub fn transfer_signed");
|
||||||
let data = serialize(&event).expect("serialize Transaction in pub fn transfer_signed");
|
|
||||||
self.events_socket.send_to(&data, &self.events_addr)
|
self.events_socket.send_to(&data, &self.events_addr)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -157,7 +157,6 @@ pub mod tests {
|
|||||||
use crdt::Crdt;
|
use crdt::Crdt;
|
||||||
use crdt::ReplicatedData;
|
use crdt::ReplicatedData;
|
||||||
use entry::Entry;
|
use entry::Entry;
|
||||||
use event::Event;
|
|
||||||
use hash::{hash, Hash};
|
use hash::{hash, Hash};
|
||||||
use logger;
|
use logger;
|
||||||
use mint::Mint;
|
use mint::Mint;
|
||||||
@ -170,6 +169,7 @@ pub mod tests {
|
|||||||
use std::sync::{Arc, RwLock};
|
use std::sync::{Arc, RwLock};
|
||||||
use std::time::Duration;
|
use std::time::Duration;
|
||||||
use streamer;
|
use streamer;
|
||||||
|
use transaction::Transaction;
|
||||||
use tvu::Tvu;
|
use tvu::Tvu;
|
||||||
|
|
||||||
/// Test that mesasge sent from leader to target1 and repliated to target2
|
/// Test that mesasge sent from leader to target1 and repliated to target2
|
||||||
@ -252,7 +252,7 @@ pub mod tests {
|
|||||||
bank.register_entry_id(&cur_hash);
|
bank.register_entry_id(&cur_hash);
|
||||||
cur_hash = hash(&cur_hash);
|
cur_hash = hash(&cur_hash);
|
||||||
|
|
||||||
let tr1 = Event::new_transaction(
|
let tr1 = Transaction::new(
|
||||||
&mint.keypair(),
|
&mint.keypair(),
|
||||||
bob_keypair.pubkey(),
|
bob_keypair.pubkey(),
|
||||||
transfer_amount,
|
transfer_amount,
|
||||||
|
Reference in New Issue
Block a user