Delete event.rs

src/bank.rs

@@ -7,7 +7,6 @@ extern crate libc;
 
 use chrono::prelude::*;
 use entry::Entry;
-use event::Event;
 use hash::Hash;
 use mint::Mint;
 use plan::{Payment, Plan, Witness};
@@ -259,34 +258,10 @@ impl Bank {
             .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<()> {
         for entry in entries {
             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?;
             }
         }
@@ -362,14 +337,6 @@ impl Bank {
         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
     /// `n` tokens where `last_id` is the last Entry ID observed by the client.
     pub fn transfer(

src/banking_stage.rs

@@ -1,8 +1,7 @@
-//! The `banking_stage` processes Event messages.
+//! The `banking_stage` processes Transaction messages.
 
 use bank::Bank;
 use bincode::deserialize;
-use event::Event;
 use packet;
 use packet::SharedPackets;
 use rayon::prelude::*;
@@ -16,6 +15,7 @@ use std::thread::{spawn, JoinHandle};
 use std::time::Duration;
 use std::time::Instant;
 use timing;
+use transaction::Transaction;
 
 pub struct BankingStage {
     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
             .par_iter()
             .map(|x| {
@@ -86,7 +86,7 @@ impl BankingStage {
                 .zip(vers)
                 .filter_map(|(event, ver)| match event {
                     None => None,
-                    Some((event, _addr)) => if event.verify() && ver != 0 {
+                    Some((event, _addr)) => if event.verify_plan() && ver != 0 {
                         Some(event)
                     } else {
                         None
@@ -95,7 +95,7 @@ impl BankingStage {
                 .collect();
 
             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();
             signal_sender.send(Signal::Events(events))?;
             debug!("done process_events");
@@ -120,7 +120,6 @@ impl BankingStage {
 
 //use bank::Bank;
 //use entry::Entry;
-//use event::Event;
 //use hash::Hash;
 //use record_stage::RecordStage;
 //use record_stage::Signal;
@@ -128,11 +127,11 @@ impl BankingStage {
 //use std::sync::mpsc::{channel, Sender};
 //use std::sync::{Arc, Mutex};
 //use std::time::Duration;
+//use transaction::Transaction;
 //
 //#[cfg(test)]
 //mod tests {
 //    use bank::Bank;
-//    use event::Event;
 //    use event_processor::EventProcessor;
 //    use mint::Mint;
 //    use signature::{KeyPair, KeyPairUtil};
@@ -152,12 +151,12 @@ impl BankingStage {
 //        // Process a batch that includes a transaction that receives two tokens.
 //        let alice = KeyPair::new();
 //        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();
 //
 //        // Process a second batch that spends one of those tokens.
 //        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();
 //
 //        // Collect the ledger and feed it to a new bank.
@@ -170,7 +169,7 @@ impl BankingStage {
 //        for entry in entries {
 //            assert!(
 //                bank
-//                    .process_verified_events(entry.events)
+//                    .process_verified_transactions(entry.events)
 //                    .into_iter()
 //                    .all(|x| x.is_ok())
 //            );
@@ -229,15 +228,10 @@ impl BankingStage {
 //            })
 //            .collect();
 //
-//        let events: Vec<_> = transactions
-//            .into_iter()
-//            .map(|tr| Event::Transaction(tr))
-//            .collect();
-//
 //        let event_processor = EventProcessor::new(bank, &mint.last_id(), None);
 //
 //        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 sec = duration.as_secs() as f64 + duration.subsec_nanos() as f64 / 1_000_000_000.0;
 //        let tps = txs as f64 / sec;
@@ -246,7 +240,7 @@ impl BankingStage {
 //        drop(event_processor.historian_input);
 //        let entries: Vec<Entry> = event_processor.output.lock().unwrap().iter().collect();
 //        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);
 //    }
@@ -258,7 +252,6 @@ mod bench {
     use self::test::Bencher;
     use bank::*;
     use banking_stage::BankingStage;
-    use event::Event;
     use mint::Mint;
     use packet::{to_packets, PacketRecycler};
     use record_stage::Signal;
@@ -266,6 +259,7 @@ mod bench {
     use std::iter;
     use std::sync::Arc;
     use std::sync::mpsc::channel;
+    use transaction::Transaction;
 
     #[bench]
     fn stage_bench(bencher: &mut Bencher) {
@@ -274,7 +268,7 @@ mod bench {
         let pubkey = KeyPair::new().pubkey();
 
         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();
 
         let (verified_sender, verified_receiver) = channel();

src/bin/genesis-demo.rs

@@ -7,9 +7,9 @@ use isatty::stdin_isatty;
 use rayon::prelude::*;
 use solana::bank::MAX_ENTRY_IDS;
 use solana::entry::{next_entry, Entry};
-use solana::event::Event;
 use solana::mint::MintDemo;
 use solana::signature::{GenKeys, KeyPairUtil};
+use solana::transaction::Transaction;
 use std::io::{stdin, Read};
 use std::process::exit;
 
@@ -46,7 +46,7 @@ fn main() {
         .into_par_iter()
         .map(|rando| {
             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();
 

src/bin/testnode.rs

@@ -11,7 +11,6 @@ use pnet::datalink;
 use solana::bank::Bank;
 use solana::crdt::ReplicatedData;
 use solana::entry::Entry;
-use solana::event::Event;
 use solana::server::Server;
 use solana::signature::{KeyPair, KeyPairUtil};
 use solana::transaction::Instruction;
@@ -97,7 +96,7 @@ fn main() {
     // fields are the same. That entry should be treated as a deposit, not a
     // transfer to oneself.
     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 {
         contract.plan.final_payment()
     } else {
@@ -115,7 +114,7 @@ fn main() {
     let mut last_id = entry1.id;
     for entry in entries {
         last_id = entry.id;
-        let results = bank.process_verified_events(entry.events);
+        let results = bank.process_verified_transactions(entry.events);
         for result in results {
             if let Err(e) = result {
                 eprintln!("failed to process event {:?}", e);

src/ecdsa.rs

@@ -2,7 +2,7 @@ use packet::{Packet, SharedPackets};
 use std::mem::size_of;
 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")]
 #[repr(C)]
@@ -144,7 +144,6 @@ pub fn ed25519_verify(batches: &Vec<SharedPackets>) -> Vec<Vec<u8>> {
 mod tests {
     use bincode::serialize;
     use ecdsa;
-    use event::Event;
     use packet::{Packet, Packets, SharedPackets};
     use std::sync::RwLock;
     use transaction::Transaction;
@@ -154,13 +153,13 @@ mod tests {
     fn test_layout() {
         let tr = test_tx();
         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, &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), None);
     }
 
     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();
         packet.meta.size = tx.len();
         packet.data[..packet.meta.size].copy_from_slice(&tx);

src/entry.rs

@@ -2,9 +2,9 @@
 //! 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`
 //! represents an approximate amount of time since the last Entry was created.
-use event::Event;
 use hash::{extend_and_hash, hash, Hash};
 use rayon::prelude::*;
+use transaction::Transaction;
 
 /// 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
@@ -21,12 +21,12 @@ use rayon::prelude::*;
 pub struct Entry {
     pub num_hashes: u64,
     pub id: Hash,
-    pub events: Vec<Event>,
+    pub events: Vec<Transaction>,
 }
 
 impl Entry {
     /// 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 id = next_hash(start_hash, 0, &events);
         Entry {
@@ -37,7 +37,7 @@ impl Entry {
     }
 
     /// 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);
         *start_hash = entry.id;
         *cur_hashes = 0;
@@ -57,24 +57,20 @@ impl Entry {
     /// 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.
     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)
     }
 }
 
-fn add_event_data(hash_data: &mut Vec<u8>, event: &Event) {
+fn add_event_data(hash_data: &mut Vec<u8>, tr: &Transaction) {
-    match *event {
-        Event::Transaction(ref tr) => {
     hash_data.push(0u8);
     hash_data.extend_from_slice(&tr.sig);
-        }
-    }
 }
 
 /// 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
 /// 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;
     for _ in 1..num_hashes {
         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`.
-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 {
         num_hashes,
         id: next_hash(start_hash, num_hashes, &events),
@@ -109,7 +105,6 @@ mod tests {
     use super::*;
     use chrono::prelude::*;
     use entry::Entry;
-    use event::Event;
     use hash::hash;
     use signature::{KeyPair, KeyPairUtil};
     use transaction::Transaction;
@@ -130,8 +125,8 @@ mod tests {
 
         // First, verify entries
         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()]);
         assert!(e0.verify(&zero));
 
@@ -147,12 +142,8 @@ mod tests {
 
         // First, verify entries
         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()]);
         assert!(e0.verify(&zero));
 

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(),
-        }
-    }
-}

src/ledger.rs

@@ -3,7 +3,6 @@
 
 use bincode::{deserialize, serialize_into};
 use entry::{next_entry, Entry};
-use event::Event;
 use hash::Hash;
 use packet;
 use packet::{SharedBlob, BLOB_DATA_SIZE, BLOB_SIZE};
@@ -12,6 +11,7 @@ use std::cmp::min;
 use std::collections::VecDeque;
 use std::io::Cursor;
 use std::mem::size_of;
+use transaction::Transaction;
 
 pub trait Block {
     /// 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`.
-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 entries = vec![];
     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 total = 0;
         for i in &list[start..] {
-            total += size_of::<Event>() * i.events.len();
+            total += size_of::<Transaction>() * i.events.len();
             total += size_of::<Entry>();
             if total >= BLOB_DATA_SIZE {
                 break;
@@ -60,7 +64,7 @@ pub fn process_entry_list_into_blobs(
         // See if we need to split the events
         if end <= start {
             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 =
                 (list[end].events.len() + num_events_per_blob - 1) / num_events_per_blob;
             trace!(
@@ -147,7 +151,7 @@ mod tests {
         let zero = Hash::default();
         let one = hash(&zero);
         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 e0 = Entry::new(&zero, 0, events);
 
@@ -165,7 +169,7 @@ mod tests {
         let mut id = Hash::default();
         let next_id = hash(&id);
         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 event_set = vec![events.clone(); 5];
         let entries0 = next_entries(&id, 0, event_set);

src/lib.rs

@@ -7,7 +7,6 @@ pub mod entry;
 pub mod entry_writer;
 #[cfg(feature = "erasure")]
 pub mod erasure;
-pub mod event;
 pub mod hash;
 pub mod ledger;
 pub mod logger;

src/mint.rs

@@ -1,7 +1,6 @@
 //! The `mint` module is a library for generating the chain's genesis block.
 
 use entry::Entry;
-use event::Event;
 use hash::{hash, Hash};
 use ring::rand::SystemRandom;
 use signature::{KeyPair, KeyPairUtil, PublicKey};
@@ -47,10 +46,10 @@ impl Mint {
         self.pubkey
     }
 
-    pub fn create_events(&self) -> Vec<Event> {
+    pub fn create_events(&self) -> Vec<Transaction> {
         let keypair = self.keypair();
         let tr = Transaction::new(&keypair, self.pubkey(), self.tokens, self.seed());
-        vec![Event::Transaction(tr)]
+        vec![tr]
     }
 
     pub fn create_entries(&self) -> Vec<Entry> {
@@ -76,7 +75,7 @@ mod tests {
     #[test]
     fn test_create_events() {
         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 Plan::Pay(payment) = contract.plan {
                 assert_eq!(tr.from, payment.to);

src/record_stage.rs

@@ -6,17 +6,17 @@
 //! The resulting stream of entries represents ordered events in time.
 
 use entry::Entry;
-use event::Event;
 use hash::Hash;
 use recorder::Recorder;
 use std::sync::mpsc::{channel, Receiver, Sender, TryRecvError};
 use std::thread::{spawn, JoinHandle};
 use std::time::{Duration, Instant};
+use transaction::Transaction;
 
 #[cfg_attr(feature = "cargo-clippy", allow(large_enum_variant))]
 pub enum Signal {
     Tick,
-    Events(Vec<Event>),
+    Events(Vec<Transaction>),
 }
 
 pub struct RecordStage {
@@ -140,8 +140,8 @@ mod tests {
         let record_stage = RecordStage::new(signal_receiver, &zero, None);
         let alice_keypair = KeyPair::new();
         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();
         drop(input);
         let entries: Vec<_> = record_stage.entry_receiver.iter().collect();

src/recorder.rs

@@ -2,9 +2,9 @@
 //! It records Event items on behalf of its users.
 
 use entry::Entry;
-use event::Event;
 use hash::{hash, Hash};
 use std::time::{Duration, Instant};
+use transaction::Transaction;
 
 pub struct Recorder {
     last_hash: Hash,
@@ -26,7 +26,7 @@ impl Recorder {
         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)
     }
 

src/request_processor.rs

@@ -2,7 +2,6 @@
 
 use bank::Bank;
 use bincode::{deserialize, serialize};
-use event::Event;
 use packet;
 use packet::SharedPackets;
 use rayon::prelude::*;
@@ -15,6 +14,7 @@ use std::sync::mpsc::Receiver;
 use std::time::Instant;
 use streamer;
 use timing;
+use transaction::Transaction;
 
 pub struct RequestProcessor {
     bank: Arc<Bank>,
@@ -76,7 +76,7 @@ impl RequestProcessor {
 
     // Copy-paste of deserialize_requests() because I can't figure out how to
     // 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
             .par_iter()
             .map(|x| {

src/thin_client.rs

@@ -4,7 +4,6 @@
 //! unstable and may change in future releases.
 
 use bincode::{deserialize, serialize};
-use event::Event;
 use futures::future::{ok, FutureResult};
 use hash::Hash;
 use request::{Request, Response};
@@ -75,8 +74,7 @@ impl ThinClient {
     /// Send a signed Transaction to the server for processing. This method
     /// does not wait for a response.
     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)
     }
 

src/tvu.rs

@@ -157,7 +157,6 @@ pub mod tests {
     use crdt::Crdt;
     use crdt::ReplicatedData;
     use entry::Entry;
-    use event::Event;
     use hash::{hash, Hash};
     use logger;
     use mint::Mint;
@@ -170,6 +169,7 @@ pub mod tests {
     use std::sync::{Arc, RwLock};
     use std::time::Duration;
     use streamer;
+    use transaction::Transaction;
     use tvu::Tvu;
 
     /// 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);
             cur_hash = hash(&cur_hash);
 
-            let tr1 = Event::new_transaction(
+            let tr1 = Transaction::new(
                 &mint.keypair(),
                 bob_keypair.pubkey(),
                 transfer_amount,