diff --git a/src/bank.rs b/src/bank.rs index 99cafa0b6f..39fad69210 100644 --- a/src/bank.rs +++ b/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) -> (Vec, Vec) { - ( - events - .into_iter() - .map(|Event::Transaction(tr)| tr) - .collect(), - vec![], - ) - } - - pub fn process_verified_events(&self, events: Vec) -> Vec> { - 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) -> 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 { - 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( diff --git a/src/banking_stage.rs b/src/banking_stage.rs index aa8fe52aae..426c6032c5 100644 --- a/src/banking_stage.rs +++ b/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> { + fn deserialize_events(p: &packet::Packets) -> Vec> { 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 = 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(); diff --git a/src/bin/genesis-demo.rs b/src/bin/genesis-demo.rs index 11fe5df3d4..f904990d37 100644 --- a/src/bin/genesis-demo.rs +++ b/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(); diff --git a/src/bin/testnode.rs b/src/bin/testnode.rs index 6a2bc0f9d2..4fa66b9068 100644 --- a/src/bin/testnode.rs +++ b/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); diff --git a/src/ecdsa.rs b/src/ecdsa.rs index b1d0e62017..22e37afdc8 100644 --- a/src/ecdsa.rs +++ b/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) -> Vec> { 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); diff --git a/src/entry.rs b/src/entry.rs index ff70cf4252..997e4eb1cd 100644 --- a/src/entry.rs +++ b/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, + pub events: Vec, } impl Entry { /// Creates the next Entry `num_hashes` after `start_hash`. - pub fn new(start_hash: &Hash, cur_hashes: u64, events: Vec) -> Self { + pub fn new(start_hash: &Hash, cur_hashes: u64, events: Vec) -> 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) -> Self { + pub fn new_mut(start_hash: &mut Hash, cur_hashes: &mut u64, events: Vec) -> 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, event: &Event) { - match *event { - Event::Transaction(ref tr) => { - hash_data.push(0u8); - hash_data.extend_from_slice(&tr.sig); - } - } +fn add_event_data(hash_data: &mut Vec, tr: &Transaction) { + 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) -> Entry { +pub fn next_entry(start_hash: &Hash, num_hashes: u64, events: Vec) -> 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 tr1 = Event::new_transaction(&keypair, keypair.pubkey(), 1, zero); + let tr0 = Transaction::new(&keypair, keypair.pubkey(), 0, 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 tr1 = Event::Transaction(Transaction::new_signature( - &keypair, - Default::default(), - zero, - )); + let tr0 = Transaction::new_timestamp(&keypair, Utc::now(), zero); + let tr1 = Transaction::new_signature(&keypair, Default::default(), zero); let mut e0 = Entry::new(&zero, 0, vec![tr0.clone(), tr1.clone()]); assert!(e0.verify(&zero)); diff --git a/src/event.rs b/src/event.rs deleted file mode 100644 index af297a1ca3..0000000000 --- a/src/event.rs +++ /dev/null @@ -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(), - } - } -} diff --git a/src/ledger.rs b/src/ledger.rs index f63846e008..715a63befa 100644 --- a/src/ledger.rs +++ b/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 { +pub fn next_entries( + start_hash: &Hash, + num_hashes: u64, + event_set: Vec>, +) -> Vec { 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::new(); let mut total = 0; for i in &list[start..] { - total += size_of::() * i.events.len(); + total += size_of::() * i.events.len(); total += size_of::(); 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::(); + let num_events_per_blob = BLOB_DATA_SIZE / size_of::(); 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); diff --git a/src/lib.rs b/src/lib.rs index 930c96d3fc..48dedfbc7a 100644 --- a/src/lib.rs +++ b/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; diff --git a/src/mint.rs b/src/mint.rs index 41e69b19a9..450e7151f8 100644 --- a/src/mint.rs +++ b/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 { + pub fn create_events(&self) -> Vec { 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 { @@ -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); diff --git a/src/record_stage.rs b/src/record_stage.rs index f2823e673a..d2f21a46cf 100644 --- a/src/record_stage.rs +++ b/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), + Events(Vec), } 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 event1 = Event::new_transaction(&alice_keypair, bob_pubkey, 2, zero); + let event0 = Transaction::new(&alice_keypair, bob_pubkey, 1, 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(); diff --git a/src/recorder.rs b/src/recorder.rs index 790c7ee77a..26a246e176 100644 --- a/src/recorder.rs +++ b/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) -> Entry { + pub fn record(&mut self, events: Vec) -> Entry { Entry::new_mut(&mut self.last_hash, &mut self.num_hashes, events) } diff --git a/src/request_processor.rs b/src/request_processor.rs index 63f6c6ddb9..4272576978 100644 --- a/src/request_processor.rs +++ b/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, @@ -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> { + pub fn deserialize_events(p: &packet::Packets) -> Vec> { p.packets .par_iter() .map(|x| { diff --git a/src/thin_client.rs b/src/thin_client.rs index d6065aad23..c1318b6e90 100644 --- a/src/thin_client.rs +++ b/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 { - let event = Event::Transaction(tr); - let data = serialize(&event).expect("serialize Transaction in pub fn transfer_signed"); + let data = serialize(&tr).expect("serialize Transaction in pub fn transfer_signed"); self.events_socket.send_to(&data, &self.events_addr) } diff --git a/src/tvu.rs b/src/tvu.rs index 836086b9eb..5b2be0f672 100644 --- a/src/tvu.rs +++ b/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,