Update records header

Author: DogLooksGood

core/src/context.rs

@@ -491,6 +491,10 @@ impl GameContext {
         &self.nodes
     }
 
+    pub fn get_game_spec(&self) -> &GameSpec {
+        &self.spec
+    }
+
     pub fn game_addr(&self) -> &str {
         &self.spec.game_addr
     }
@@ -1187,6 +1191,10 @@ impl GameContext {
         self.sub_games.clear();
         self.checkpoint.close_sub_data();
     }
+
+    pub fn get_balances(&self) -> &[PlayerBalance] {
+        &self.balances
+    }
 }
 
 impl Default for GameContext {

event-record/src/lib.rs

@@ -6,20 +6,20 @@
 //! All content are serialized with borsh & base64.
 
 use borsh::{BorshSerialize, BorshDeserialize};
-use race_core::context::Node;
+use race_core::{context::Node, types::{PlayerBalance, GameSpec, EntryType}};
 use race_api::event::Event;
 
 #[derive(Default, Debug, BorshSerialize, BorshDeserialize)]
 pub struct RecordsHeader {
-    pub game_addr: String,
-    pub game_id: usize,
-    pub bundle_addr: String,
+    pub spec: GameSpec,
     pub chain: String,        // solana, sui, facade
+    pub init_data: Vec<u8>,
+    pub entry_type: EntryType,
 }
 
 impl RecordsHeader {
-    pub fn new(game_addr: String, game_id: usize, bundle_addr: String, chain: String) -> Self {
-        Self { game_addr, game_id, bundle_addr, chain }
+    pub fn new(spec: GameSpec, init_data: Vec<u8>, entry_type: EntryType, chain: String) -> Self {
+        Self { spec, init_data, entry_type, chain }
     }
 }
 
@@ -41,6 +41,9 @@ pub enum Record {
     Checkpoint {
         state: Vec<u8>,
         nodes: Vec<Node>,
+        balances: Vec<PlayerBalance>,
+        access_version: u64,
+        settle_version: u64,
     },
     Event {
         event: Event,
@@ -49,9 +52,15 @@ pub enum Record {
 }
 
 impl Record {
-    pub fn checkpoint(state: Vec<u8>, nodes: Vec<Node>) -> Self {
+    pub fn checkpoint(
+        state: Vec<u8>,
+        nodes: Vec<Node>,
+        balances: Vec<PlayerBalance>,
+        access_version: u64,
+        settle_version: u64
+    ) -> Self {
         Self::Checkpoint {
-            state, nodes,
+            state, nodes, balances, access_version, settle_version
         }
     }
 

replayer/src/handler.rs

@@ -0,0 +1,23 @@
+//! We need a handler for event handling.
+
+use std::sync::Arc;
+use race_core::types::accounts::GameBundle;
+use race_encryptor::Encryptor;
+use race_transactor_components::{
+    event_loop::EventLoop,
+    event_bus::EventBus,
+    wrapped_handler::WrappedHandler,
+};
+
+struct EventHandler {
+
+}
+
+
+impl EventHandler {
+    pub fn new(game_bundle: &GameBundle, records: Vec<Record>) -> Result<Self, ReplayerError> {
+        let encryptor = Arc::new(Encryptor::default());
+        let handler = WrappedHandler::load_by_bundle(game_bundle, encryptor)?;
+
+    }
+}

replayer/src/ui.rs

@@ -85,7 +85,7 @@ pub fn render_controller_ui(context: Arc<ReplayerContext>, header: RecordsHeader
                 ])
                 .split(f.size());
 
-            let header_spans = Text::from(format!("CHAIN: {}\nGAME: {}#{}\nBUNDLE: {}", header.chain, header.game_addr, header.game_id, header.bundle_addr));
+            let header_spans = Text::from(format!("CHAIN: {}\nGAME: {}#{}\nBUNDLE: {}", header.chain, header.spec.game_addr, header.spec.game_id, header.spec.bundle_addr));
 
             let paragraph = Paragraph::new(header_spans)
                 .block(Block::default().title("Info").borders(Borders::ALL))
@@ -96,7 +96,7 @@ pub fn render_controller_ui(context: Arc<ReplayerContext>, header: RecordsHeader
             let items: Vec<ListItem> = records_view_state.records.iter().map(|r| ListItem::new(format!("{}", r))).collect();
 
             let list = List::new(items)
-                .block(Block::default().title("events").borders(Borders::ALL))
+                .block(Block::default().title("Events").borders(Borders::ALL))
                 .style(Style::default().fg(Color::White))
                 .highlight_style(Style::default().fg(Color::Green));
 

transactor-components/src/broadcaster.rs

@@ -228,6 +228,7 @@ impl Component<ConsumerPorts, BroadcasterContext> for Broadcaster {
                     checkpoint,
                     state_sha,
                     nodes,
+                    ..
                 } => {
                     info!(
                         "{} Create new history group (via Checkpoint) with access_version = {}, settle_version = {}",

transactor-components/src/event_loop/event_handler.rs

@@ -50,6 +50,7 @@ async fn send_checkpoint(
                 settle_version: game_context.settle_version(),
                 state_sha: game_context.state_sha(),
                 nodes: game_context.get_nodes().to_owned(),
+                balances: game_context.get_balances().to_owned(),
             })
             .await;
     }

transactor-components/src/recorder.rs

@@ -1,8 +1,10 @@
 use async_trait::async_trait;
 use borsh::BorshSerialize;
+use race_core::types::GameSpec;
 use race_transactor_frames::EventFrame;
 use race_event_record::{RecordsHeader, Record};
 use race_core::chain::ChainType;
+use race_core::types::EntryType;
 use std::fs::{File, create_dir};
 use std::io::{Write, BufWriter};
 use std::path::{Path, PathBuf};
@@ -86,15 +88,16 @@ pub struct RecorderContext {
 
 impl Recorder {
     pub fn init(
-        game_addr: String,
-        game_id: usize,
-        bundle_addr: String,
+        spec: GameSpec,
+        init_data: Vec<u8>,
+        entry_type: EntryType,
         chain: ChainType,
         in_mem: bool,
     ) -> (Self, RecorderContext) {
         let writer: Arc<Mutex<dyn RecordWriter + Send + Sync>>;
+        let game_id = spec.game_id;
 
-        let header = RecordsHeader::new(game_addr.clone(), game_id, bundle_addr, chain.to_string());
+        let header = RecordsHeader::new(spec.clone(), init_data, entry_type, chain.to_string());
 
         if in_mem {
             writer = Arc::new(Mutex::new(InMemoryRecordWriter::new(header)))
@@ -103,10 +106,10 @@ impl Recorder {
             if !dir.exists() {
                 create_dir(dir).expect("Failed to create records directory");
             }
-            let file_path = if game_id == 0 {
-                format!("records/{}", game_addr)
+            let file_path = if spec.game_id == 0 {
+                format!("records/{}", spec.game_addr)
             } else {
-                format!("records/{}_{}", game_addr, game_id)
+                format!("records/{}_{}", spec.game_addr, spec.game_id)
             };
             writer = Arc::new(Mutex::new(FileRecordWriter::try_new(file_path.into(), header).expect("Fail to create record writer")))
         }
@@ -154,13 +157,16 @@ impl Component<ConsumerPorts, RecorderContext> for Recorder {
                 }
 
                 EventFrame::Checkpoint {
+                    access_version,
+                    settle_version,
                     checkpoint,
                     nodes,
+                    balances,
                     ..
                 } => {
                     if let Some(state) = checkpoint.get_data(game_id) {
                         let record = Record::Checkpoint {
-                            state, nodes
+                            state, nodes, access_version, settle_version, balances,
                         };
 
                         writer.write(record);

transactor-frames/src/lib.rs

@@ -4,7 +4,7 @@ use race_api::event::{Event, Message};
 use race_core::{
     checkpoint::{Checkpoint, VersionedData},
     context::{GameContext, SettleDetails, SubGameInit, Node},
-    types::{ClientMode, PlayerDeposit, PlayerJoin, ServerJoin, TxState, VoteType},
+    types::{PlayerBalance, ClientMode, PlayerDeposit, PlayerJoin, ServerJoin, TxState, VoteType},
 };
 
 #[derive(Debug)]
@@ -67,6 +67,7 @@ pub enum EventFrame {
     Checkpoint {
         checkpoint: Checkpoint,
         nodes: Vec<Node>,
+        balances: Vec<PlayerBalance>,
         access_version: u64,
         settle_version: u64,
         state_sha: String,

transactor/src/handle/transactor.rs

@@ -115,8 +115,13 @@ impl TransactorHandle {
         let (bridge, bridge_ctx) = EventBridgeParent::init(signal_tx);
         let mut bridge_handle = bridge.start(&game_account.addr, bridge_ctx);
 
-        let (recorder, recorder_ctx) = Recorder::init(game_account.addr.clone(), 0,
-            game_account.bundle_addr.clone(), config.chain.as_str().into(), false);
+        let (recorder, recorder_ctx) = Recorder::init(
+            game_context.get_game_spec().to_owned(),
+            game_account.data.clone(),
+            game_account.entry_type.clone(),
+            config.chain.as_str().into(),
+            false);
+
         let mut recorder_handle = recorder.start(&game_account.addr, recorder_ctx);
 
         let (event_loop, event_loop_ctx) = EventLoop::init(