fix: validator can not start up

Author: lxedge

core/src/types/transactor_params.rs

@@ -16,6 +16,7 @@ pub struct AttachGameParams {
 
 #[derive(Debug, Clone, PartialEq, Eq, BorshDeserialize, BorshSerialize)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
 pub struct CheckpointParams {
     pub settle_version: u64,
 }

transactor/src/component/connection.rs

@@ -20,17 +20,21 @@ use jsonrpsee::{
     rpc_params,
     ws_client::{WsClient, WsClientBuilder},
 };
-use race_core::error::{Error, Result};
 use race_core::types::{BroadcastFrame, SubscribeEventParams};
+use race_core::{
+    checkpoint::CheckpointOffChain,
+    error::{Error, Result},
+    types::CheckpointParams,
+};
 use race_core::{
     connection::ConnectionT,
     encryptor::EncryptorT,
     types::{AttachGameParams, ExitGameParams, SubmitEventParams},
 };
 
-use crate::{frame::EventFrame, utils::current_timestamp};
 use crate::utils::base64_decode;
 use crate::{component::common::Attachable, utils::base64_encode};
+use crate::{frame::EventFrame, utils::current_timestamp};
 
 /// A connection to local event bus, for transactor loopback.
 #[allow(dead_code)]
@@ -187,7 +191,7 @@ impl RemoteConnection {
                 }
                 Err(e) => {
                     warn!("Error in request[{}]: {:?}", method, e);
-                },
+                }
             }
 
             if retries < self.max_retries {
@@ -199,6 +203,22 @@ impl RemoteConnection {
         }
     }
 
+    pub async fn get_checkpoint_off_chain(
+        &self,
+        game_addr: &str,
+        params: CheckpointParams,
+    ) -> Result<Option<CheckpointOffChain>> {
+        let req = self.make_request_no_sig(game_addr, &params)?;
+
+        match self.request::<Option<Vec<u8>>>("get_checkpoint", req).await {
+            Ok(Some(res)) => {
+                let checkpoint_off_chain = CheckpointOffChain::try_from_slice(&res)?;
+                Ok(Some(checkpoint_off_chain))
+            }
+            _ => Ok(None),
+        }
+    }
+
     pub async fn subscribe_events(
         &self,
         game_addr: &str,

transactor/src/handle/validator.rs

@@ -5,11 +5,11 @@ use crate::component::{
     Voter, WrappedClient, WrappedHandler,
 };
 use crate::frame::{EventFrame, SignalFrame};
-use race_core::error::{Error, Result};
 use race_core::context::GameContext;
+use race_core::error::{Error, Result};
 use race_core::storage::StorageT;
 use race_core::transport::TransportT;
-use race_core::types::{ClientMode, GameMode, GetCheckpointParams, ServerAccount};
+use race_core::types::{CheckpointParams, ClientMode, GameMode, ServerAccount};
 use race_encryptor::Encryptor;
 use race_env::TransactorConfig;
 use tokio::sync::mpsc;
@@ -29,43 +29,57 @@ impl ValidatorHandle {
         server_account: &ServerAccount,
         encryptor: Arc<Encryptor>,
         transport: Arc<dyn TransportT + Send + Sync>,
-        storage: Arc<dyn StorageT + Send + Sync>,
+        _storage: Arc<dyn StorageT + Send + Sync>,
         signal_tx: mpsc::Sender<SignalFrame>,
         _config: &TransactorConfig,
     ) -> Result<Self> {
-        info!(
-            "Start game handle for {} with Validator mode",
-            game_addr,
-        );
+        info!("Start game handle for {} with Validator mode", game_addr,);
         let Some(game_account) = transport.get_game_account(game_addr).await? else {
             return Err(Error::GameAccountNotFound);
         };
 
-        let checkpoint_off_chain = storage
-            .get_checkpoint(GetCheckpointParams {
-                game_addr: game_addr.to_owned(),
+        let transactor_addr = game_account
+            .transactor_addr
+            .as_ref()
+            .ok_or(Error::GameNotServed)?;
+        let transactor_account = transport
+            .get_server_account(transactor_addr)
+            .await?
+            .ok_or(Error::CantFindTransactor)?;
+
+        let connection = Arc::new(
+            RemoteConnection::try_new(
+                &server_account.addr,
+                &transactor_account.endpoint,
+                encryptor.clone(),
+            )
+            .await?,
+        );
+
+        let checkpoint_off_chain = connection.get_checkpoint_off_chain(
+            game_addr,
+            CheckpointParams {
                 settle_version: game_account.settle_version,
-            })
-            .await?;
+            },
+        ).await?;
+
+        // let checkpoint_off_chain = storage
+        //     .get_checkpoint(GetCheckpointParams {
+        //         game_addr: game_addr.to_owned(),
+        //         settle_version: game_account.settle_version,
+        //     })
+        //     .await?;
 
         let game_context = GameContext::try_new(&game_account, checkpoint_off_chain)?;
         let checkpoint = game_context.checkpoint().clone();
 
-        let Some(bundle_account) = transport.get_game_bundle(&game_account.bundle_addr).await? else {
+        let Some(bundle_account) = transport.get_game_bundle(&game_account.bundle_addr).await?
+        else {
             return Err(Error::GameBundleNotFound);
         };
 
         let handler = WrappedHandler::load_by_bundle(&bundle_account, encryptor.clone()).await?;
 
-        let transactor_addr = game_account
-            .transactor_addr
-            .as_ref()
-            .ok_or(Error::GameNotServed)?;
-        let transactor_account = transport
-            .get_server_account(transactor_addr)
-            .await?
-            .ok_or(Error::CantFindTransactor)?;
-
         info!("Creating components");
         let event_bus = EventBus::new(game_account.addr.clone());
 
@@ -76,14 +90,6 @@ impl ValidatorHandle {
             EventLoop::init(handler, game_context, ClientMode::Validator, GameMode::Main);
         let mut event_loop_handle = event_loop.start(&game_account.addr, event_loop_ctx);
 
-        let connection = Arc::new(
-            RemoteConnection::try_new(
-                &server_account.addr,
-                &transactor_account.endpoint,
-                encryptor.clone(),
-            )
-            .await?,
-        );
         let (subscriber, subscriber_context) =
             Subscriber::init(&game_account, server_account, connection.clone());
         let mut subscriber_handle = subscriber.start(&game_account.addr, subscriber_context);