Settlement timing enhancement

api/src/effect.rs

@@ -3,14 +3,19 @@
 use std::collections::HashMap;
 
 use borsh::{BorshDeserialize, BorshSerialize};
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
 
 use crate::{
     engine::GameHandler,
     error::{HandleError, HandleResult},
     event::BridgeEvent,
     prelude::InitAccount,
     random::RandomSpec,
-    types::{Award, DecisionId, EntryLock, GameDeposit, GameId, GamePlayer, PlayerBalance, RandomId, Transfer},
+    types::{
+        Award, DecisionId, EntryLock, GameDeposit, GameId, GamePlayer, PlayerBalance, RandomId,
+        Transfer,
+    },
 };
 
 #[derive(BorshSerialize, BorshDeserialize, Debug, PartialEq, Eq)]
@@ -55,6 +60,7 @@ pub struct ActionTimeout {
 }
 
 #[derive(BorshSerialize, BorshDeserialize, Debug, PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct SubGame {
     pub id: GameId,
     pub bundle_addr: String,
@@ -92,6 +98,7 @@ impl SubGame {
 }
 
 #[derive(BorshSerialize, BorshDeserialize, Debug, PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct EmitBridgeEvent {
     pub dest: GameId,
     pub raw: Vec<u8>,
@@ -104,6 +111,13 @@ impl EmitBridgeEvent {
             raw: borsh::to_vec(&bridge_event)?,
         })
     }
+
+    pub fn new_empty(dest: GameId) -> Self {
+        Self {
+            dest,
+            raw: vec![]
+        }
+    }
 }
 
 #[derive(BorshSerialize, BorshDeserialize, Debug, PartialEq, Eq, Clone)]

api/src/engine.rs

@@ -4,7 +4,7 @@ use crate::{effect::Effect, error::HandleResult, event::Event, init_account::Ini
 
 pub trait GameHandler: Sized + BorshSerialize + BorshDeserialize {
     /// Initialize handler state with on-chain game account data.
-    fn init_state(init_account: InitAccount) -> HandleResult<Self>;
+    fn init_state(effect: &mut Effect, init_account: InitAccount) -> HandleResult<Self>;
 
     /// Handle event.
     fn handle_event(&mut self, effect: &mut Effect, event: Event) -> HandleResult<()>;

api/src/event.rs

@@ -30,10 +30,6 @@ pub enum Event {
         raw: Vec<u8>,
     },
 
-    /// A event sent by system, the first event sent by transactor
-    /// when game is loaded.
-    Ready,
-
     /// Transactor shares its secert to specific player.
     /// The `secret_data` is encrypted with the receiver's public key.
     ShareSecrets {
@@ -159,7 +155,6 @@ impl std::fmt::Display for Event {
                     dest_game_id, from_game_id, raw[0]
                 )
             }
-            Event::Ready => write!(f, "Ready"),
             Event::ShareSecrets { sender, shares } => {
                 let repr = shares
                     .iter()

api/src/init_account.rs

@@ -1,9 +1,12 @@
 use borsh::{BorshDeserialize, BorshSerialize};
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
 
 use crate::error::HandleError;
 
 /// A set of arguments for game handler initialization.
 #[derive(Debug, Clone, BorshSerialize, BorshDeserialize, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct InitAccount {
     pub max_players: u16,
     pub data: Vec<u8>,

api/src/types.rs

@@ -66,7 +66,7 @@ impl Settle {
     }
 }
 
-#[derive(Clone, BorshSerialize, BorshDeserialize, Debug, PartialEq, Eq)]
+#[derive(Clone, BorshSerialize, BorshDeserialize, Debug, PartialEq, Eq, Default)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
 pub struct Award {

core/src/checkpoint.rs

@@ -1,17 +1,17 @@
 use std::{collections::HashMap, fmt::Display};
 
-use borsh::{BorshDeserialize, BorshSerialize};
-use rs_merkle::{
-    algorithms::Sha256, proof_serializers::ReverseHashesOrder, Hasher,
-    MerkleTree,
+use crate::{
+    context::{DispatchEvent, Versions},
+    error::Error,
 };
-use crate::{context::Versions, error::Error};
+use borsh::{BorshDeserialize, BorshSerialize};
+use rs_merkle::{algorithms::Sha256, proof_serializers::ReverseHashesOrder, Hasher, MerkleTree};
 
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
-use race_api::types::GameId;
 use crate::types::GameSpec;
+use race_api::{effect::{EmitBridgeEvent, SubGame}, types::GameId};
 
 /// Checkpoint represents the state snapshot of game.
 /// It is used as a submission to the blockchain.
@@ -23,6 +23,7 @@ pub struct Checkpoint {
     pub access_version: u64,
     pub data: HashMap<GameId, VersionedData>,
     pub proofs: HashMap<GameId, Vec<u8>>,
+    pub launch_subgames: Vec<SubGame>,
 }
 
 #[derive(Default, Debug, Clone, PartialEq, Eq, BorshSerialize, BorshDeserialize)]
@@ -40,6 +41,7 @@ pub struct CheckpointOnChain {
 pub struct CheckpointOffChain {
     pub data: HashMap<GameId, VersionedData>,
     pub proofs: HashMap<GameId, Vec<u8>>,
+    pub launch_subgames: Vec<SubGame>,
 }
 
 #[derive(Clone, Debug, Default, PartialEq, Eq, BorshSerialize, BorshDeserialize)]
@@ -50,6 +52,15 @@ pub struct VersionedData {
     pub data: Vec<u8>,
     pub sha: Vec<u8>,
     pub game_spec: GameSpec,
+    pub dispatch: Option<DispatchEvent>,
+    pub bridge_events: Vec<EmitBridgeEvent>,
+}
+
+impl VersionedData {
+    fn clear_future_events(&mut self) {
+        self.dispatch = None;
+        self.bridge_events.clear();
+    }
 }
 
 impl Display for Checkpoint {
@@ -77,20 +88,27 @@ impl Checkpoint {
                     versions,
                     data: root_data,
                     sha: sha.into(),
+                    dispatch: None,
+                    bridge_events: vec![],
                 },
             )]),
             proofs: HashMap::new(),
+            launch_subgames: vec![],
         };
         ret.update_root_and_proofs();
         ret
     }
 
-    pub fn new_from_parts(offchain_part: CheckpointOffChain, onchain_part: CheckpointOnChain) -> Self {
+    pub fn new_from_parts(
+        offchain_part: CheckpointOffChain,
+        onchain_part: CheckpointOnChain,
+    ) -> Self {
         Self {
             proofs: offchain_part.proofs,
             data: offchain_part.data,
             access_version: onchain_part.access_version,
             root: onchain_part.root,
+            launch_subgames: offchain_part.launch_subgames,
         }
     }
 
@@ -103,7 +121,7 @@ impl Checkpoint {
             return;
         }
         let merkle_tree = self.to_merkle_tree();
-        let Some(root) = merkle_tree.root()  else {
+        let Some(root) = merkle_tree.root() else {
             // Skip root update as this is not a master checkpoint
             return;
         };
@@ -142,7 +160,13 @@ impl Checkpoint {
         }
     }
 
-    pub fn init_data(&mut self, id: GameId, game_spec: GameSpec, versions: Versions, data: Vec<u8>) -> Result<(), Error> {
+    pub fn init_data(
+        &mut self,
+        id: GameId,
+        game_spec: GameSpec,
+        versions: Versions,
+        data: Vec<u8>,
+    ) -> Result<(), Error> {
         match self.data.entry(id) {
             std::collections::hash_map::Entry::Occupied(_) => {
                 return Err(Error::CheckpointAlreadyExists);
@@ -156,6 +180,8 @@ impl Checkpoint {
                     sha: sha.into(),
                     game_spec,
                     versions,
+                    dispatch: None,
+                    bridge_events: vec![],
                 };
                 v.insert(versioned_data);
                 self.update_root_and_proofs();
@@ -188,6 +214,48 @@ impl Checkpoint {
         }
     }
 
+    pub fn set_dispatch_in_versioned_data(
+        &mut self,
+        id: GameId,
+        dispatch: Option<DispatchEvent>,
+    ) -> Result<(), Error> {
+        if let Some(versioned_data) = self.data.get_mut(&id) {
+            versioned_data.dispatch = dispatch;
+            Ok(())
+        } else {
+            Err(Error::MissingCheckpoint)
+        }
+    }
+
+    pub fn set_bridge_in_versioned_data(
+        &mut self,
+        id: GameId,
+        bridge_events: Vec<EmitBridgeEvent>,
+    ) -> Result<(), Error> {
+        if let Some(versioned_data) = self.data.get_mut(&id) {
+            versioned_data.bridge_events = bridge_events;
+            Ok(())
+        } else {
+            Err(Error::MissingCheckpoint)
+        }
+    }
+
+    pub fn append_launch_subgames(&mut self, subgame: SubGame) {
+        self.launch_subgames.push(subgame);
+    }
+
+    pub fn delete_launch_subgames(&mut self, id: GameId) {
+        self.launch_subgames.retain(|subgame| subgame.id != id);
+    }
+
+    pub fn get_launch_subgames(&self) -> Vec<SubGame> {
+        self.launch_subgames.clone()
+    }
+
+    pub fn clear_future_events(&mut self) {
+        self.data.values_mut().for_each(VersionedData::clear_future_events);
+    }
+
     pub fn list_versioned_data(&self) -> Vec<&VersionedData> {
         self.data.values().collect()
     }
@@ -203,14 +271,14 @@ impl Checkpoint {
     pub fn get_sha(&self, id: GameId) -> Option<[u8; 32]> {
         self.data
             .get(&id)
-            .map(|d| d.sha.clone().try_into().unwrap())
+            .map(|d| d.sha.clone().try_into().expect("Failed to get SHA"))
     }
 
     pub fn to_merkle_tree(&self) -> MerkleTree<Sha256> {
         let mut leaves: Vec<[u8; 32]> = vec![];
         let mut i = 0;
         while let Some(vd) = self.data.get(&i) {
-            leaves.push(vd.sha.clone().try_into().unwrap());
+            leaves.push(vd.sha.clone().try_into().expect("Failed to build merkle tree"));
             i += 1;
         }
         MerkleTree::from_leaves(&leaves)
@@ -232,6 +300,7 @@ impl Checkpoint {
         CheckpointOffChain {
             proofs: self.proofs.clone(),
             data: self.data.clone(),
+            launch_subgames: self.launch_subgames.clone(),
         }
     }