feat: fix program issues

Author: trankhacvy

packages/program/programs/chess/src/constants.rs

@@ -5,3 +5,7 @@ pub const MOVE_HISTORY_SEED: &[u8] = b"move_history";
 pub const INTEGRATOR_SEED: &[u8] = b"integrator";
 pub const TOKEN_VAULT_SEED: &[u8] = b"token_vault";
 pub const GAME_AUTHORITY_SEED: &[u8] = b"game_authority";
+
+pub const BOARD_SIZE: usize = 64;
+pub const MAX_MOVE_COUNT: u8 = 100;
+pub const MAX_TIME_CONTROL: u32 = 86400; // 24 hours

packages/program/programs/chess/src/error.rs

@@ -3,10 +3,13 @@ use anchor_lang::prelude::*;
 #[error_code]
 pub enum ChessError {
     #[msg("Invalid admin")]
-    InvalidAdmin, 
-    
-    #[msg("Entry fee is too high")]
-    EntryFeeTooHigh,
+    InvalidAdmin,
+
+    #[msg("Invalid time control")]
+    InvalidTimeControl,
+
+    #[msg("Entry fee is too low")]
+    EntryFeeTooLow,
 
     #[msg("Insufficient funds to create game")]
     InsufficientFunds,
@@ -95,6 +98,9 @@ pub enum ChessError {
     #[msg("Invalid game result for distribution")]
     InvalidGameResult,
 
+    #[msg("Player is already claiming winnings")]
+    Claiming,
+
     #[msg("Player has already claimed winnings")]
     AlreadyClaimed,
 
@@ -118,7 +124,7 @@ pub enum ChessError {
 
     #[msg("Invalid piece type")]
     InvalidPieceType,
-    
+
     #[msg("Too many moves made in this game")]
     TooManyMoves,
 }

packages/program/programs/chess/src/instructions/accept_draw.rs

@@ -1,3 +1,5 @@
+#[warn(ambiguous_glob_reexports)]
+
 use anchor_lang::prelude::*;
 use ephemeral_rollups_sdk::{anchor::commit, ephem::commit_and_undelegate_accounts};
 

packages/program/programs/chess/src/instructions/claim_winnings.rs

@@ -242,6 +242,10 @@ pub fn handler(ctx: Context<ClaimWinnings>) -> Result<()> {
         ChessError::GameNotFinished
     );
 
+    let game_account = &mut ctx.accounts.game_account;
+    require!(!game_account.is_claiming, ChessError::Claiming);
+    game_account.is_claiming = true;
+
     // Validate claimer is a game participant
     let claimer_color = ctx
         .accounts
@@ -311,6 +315,7 @@ pub fn handler(ctx: Context<ClaimWinnings>) -> Result<()> {
     }
 
     let game_account = &ctx.accounts.game_account;
+
     emit!(PlayerClaimedEvent {
         game_id: game_account.game_id,
         player: ctx.accounts.claimer.key(),
@@ -329,11 +334,7 @@ pub fn handler(ctx: Context<ClaimWinnings>) -> Result<()> {
         distribution_complete: game_account.distribution_complete,
     });
 
-    msg!(
-        "Player {:?} claimed winnings: {:?}",
-        player_color,
-        &ctx.accounts.game_account
-    );
+    ctx.accounts.game_account.is_claiming = false;
 
     Ok(())
 }

packages/program/programs/chess/src/instructions/create_game.rs

@@ -6,8 +6,8 @@ use anchor_spl::{
 
 use crate::{
     error::ChessError, transfer_from_user, ChessMove, GameAccount, IntegratorConfig, MoveHistory,
-    TimeControl, GAME_AUTHORITY_SEED, GAME_SEED, INTEGRATOR_SEED, MOVE_HISTORY_SEED,
-    TOKEN_VAULT_SEED,
+    TimeControl, GAME_AUTHORITY_SEED, GAME_SEED, INTEGRATOR_SEED, MAX_MOVE_COUNT, MAX_TIME_CONTROL,
+    MOVE_HISTORY_SEED, TOKEN_VAULT_SEED,
 };
 
 #[derive(Accounts)]
@@ -91,11 +91,15 @@ pub struct CreateGame<'info> {
 }
 
 impl<'info> CreateGame<'info> {
-    pub fn validate(&self, entry_fee: u64) -> Result<()> {
-        require!(
-            entry_fee <= 10_000_000_000, // 10 SOL max
-            ChessError::EntryFeeTooHigh
-        );
+    pub fn validate(&self, time_control: &Option<TimeControl>) -> Result<()> {
+        // require!(entry_fee <= MAX_ENTRY_FEE, ChessError::EntryFeeTooHigh);
+
+        if let Some(tc) = time_control {
+            require!(
+                tc.initial_time <= MAX_TIME_CONTROL && tc.increment <= MAX_TIME_CONTROL,
+                ChessError::InvalidTimeControl
+            );
+        }
 
         Ok(())
     }
@@ -105,10 +109,9 @@ pub fn handler(
     ctx: Context<CreateGame>,
     entry_fee: u64,
     time_control: Option<TimeControl>,
-    rated_game: bool,
     allow_draw_offers: bool,
 ) -> Result<()> {
-    ctx.accounts.validate(entry_fee)?;
+    ctx.accounts.validate(&time_control)?;
 
     let integrator_config = &mut ctx.accounts.integrator_config;
     let game_account = &mut ctx.accounts.game_account;
@@ -129,14 +132,13 @@ pub fn handler(
         ctx.accounts.token_mint.key(),
         ctx.accounts.token_vault.key(),
         time_control,
-        rated_game,
     ));
 
     game_account.allow_draw_offers = allow_draw_offers;
 
     move_history.game_account = game_account.key();
     move_history.history_bump = ctx.bumps.move_history;
-    move_history.moves = [ChessMove::default(); 50];
+    move_history.moves = [ChessMove::default(); MAX_MOVE_COUNT as usize];
     move_history.move_count = 0;
 
     if entry_fee > 0 {

packages/program/programs/chess/src/instructions/make_move.rs

@@ -3,7 +3,7 @@ use ephemeral_rollups_sdk::{anchor::commit, ephem::commit_and_undelegate_account
 
 use crate::{
     error::ChessError, utils, ChessMove, GameAccount, GameStatus, LastMove, MoveHistory, PieceType,
-    PlayerColor, GAME_SEED,
+    PlayerColor, BOARD_SIZE, GAME_SEED,
 };
 
 #[cfg(feature = "local")]
@@ -62,8 +62,8 @@ pub struct MakeMove<'info> {
 
 impl<'info> MakeMove<'info> {
     pub fn validate(&self, from_square: u8, to_square: u8) -> Result<()> {
-        require!(from_square < 64, ChessError::InvalidSquare);
-        require!(to_square < 64, ChessError::InvalidSquare);
+        require!(from_square < (BOARD_SIZE as u8), ChessError::InvalidSquare);
+        require!(to_square < (BOARD_SIZE as u8), ChessError::InvalidSquare);
         require!(from_square != to_square, ChessError::InvalidMove);
 
         let game_account = &self.game_account;
@@ -79,8 +79,8 @@ impl<'info> MakeMove<'info> {
                 PlayerColor::Black => game_account.time_used_black,
             };
 
-            let elapsed_this_move = (current_time - last_move_time) as u32;
-            let total_time_used = time_used + elapsed_this_move;
+            let elapsed_this_move = (current_time - last_move_time).max(0) as u32;
+            let total_time_used = time_used.saturating_add(elapsed_this_move);
 
             require!(total_time_used <= time_limit, ChessError::TimeExpired);
         }
@@ -160,14 +160,16 @@ pub fn handler(
 
     match player_color {
         PlayerColor::White => {
-            game_account.time_used_white += time_taken;
+            game_account.time_used_white = game_account.time_used_white.saturating_add(time_taken);
+
             if let Some(increment) = game_account.get_time_increment() {
                 game_account.time_used_white =
                     game_account.time_used_white.saturating_sub(increment);
             }
         }
         PlayerColor::Black => {
-            game_account.time_used_black += time_taken;
+            game_account.time_used_black = game_account.time_used_black.saturating_add(time_taken);
+
             if let Some(increment) = game_account.get_time_increment() {
                 game_account.time_used_black =
                     game_account.time_used_black.saturating_sub(increment);

packages/program/programs/chess/src/instructions/mod.rs

@@ -1,7 +1,6 @@
 pub mod accept_draw;
 pub mod cancel_game;
 pub mod claim_winnings;
-pub mod close_game;
 pub mod create_game;
 pub mod forfeit_game;
 pub mod initialize_integrator;
@@ -15,7 +14,6 @@ pub mod update_integrator_config;
 pub use accept_draw::*;
 pub use cancel_game::*;
 pub use claim_winnings::*;
-pub use close_game::*;
 pub use create_game::*;
 pub use forfeit_game::*;
 pub use initialize_integrator::*;

packages/program/programs/chess/src/lib.rs

@@ -62,10 +62,9 @@ pub mod chess {
         ctx: Context<CreateGame>,
         entry_fee: u64,
         time_control: Option<TimeControl>,
-        rated_game: bool,
         allow_draw_offers: bool,
     ) -> Result<()> {
-        create_game::handler(ctx, entry_fee, time_control, rated_game, allow_draw_offers)
+        create_game::handler(ctx, entry_fee, time_control, allow_draw_offers)
     }
 
     pub fn cancel_game(ctx: Context<CancelGame>) -> Result<()> {

packages/program/programs/chess/src/state/game.rs

@@ -1,6 +1,6 @@
 use anchor_lang::prelude::*;
 
-use crate::error::ChessError;
+use crate::{error::ChessError, BOARD_SIZE, MAX_MOVE_COUNT};
 
 #[derive(AnchorSerialize, AnchorDeserialize, Debug, InitSpace, Default, Clone, PartialEq, Eq)]
 pub enum GameStatus {
@@ -168,15 +168,6 @@ pub struct TimeControl {
     pub move_time_limit: Option<u32>,
 }
 
-#[derive(AnchorSerialize, AnchorDeserialize, Debug, InitSpace, Clone)]
-pub struct RatingChange {
-    pub old_rating: u16,
-    pub new_rating: u16,
-    pub opponent_rating: u16,
-    pub timestamp: i64,
-    pub game_result: GameResult,
-}
-
 #[account]
 #[derive(Debug, InitSpace)]
 pub struct GameAccount {
@@ -194,7 +185,7 @@ pub struct GameAccount {
     // Game State
     pub game_status: GameStatus,
     pub current_turn: PlayerColor,
-    pub board_state: [u8; 64], // 8x8 board encoding
+    pub board_state: [u8; BOARD_SIZE], // 8x8 board encoding
     pub move_count: u16,
     pub halfmove_clock: u8, // for 50-move rule
     pub fullmove_number: u16,
@@ -224,11 +215,11 @@ pub struct GameAccount {
     pub move_time_limit: Option<u32>, // seconds per move
     pub total_time_limit_white: Option<u32>,
     pub total_time_limit_black: Option<u32>,
+    pub time_increment: Option<u32>, // seconds per move increment
     pub time_used_white: u32,
     pub time_used_black: u32,
 
     // Game Settings
-    pub rated_game: bool,
     pub allow_draw_offers: bool,
 
     // draw
@@ -246,6 +237,8 @@ pub struct GameAccount {
     pub white_claimed_amount: u64,
     pub black_claimed_amount: u64,
     pub distribution_complete: bool,
+    // state - prevent reentrancy
+    pub is_claiming: bool,
 }
 
 impl GameAccount {
@@ -258,7 +251,6 @@ impl GameAccount {
         token_mint: Pubkey,
         token_vault: Pubkey,
         time_control: Option<TimeControl>,
-        rated_game: bool,
     ) -> Self {
         let initial_board = Self::initialize_chess_board();
 
@@ -291,12 +283,12 @@ impl GameAccount {
             started_at: None,
             last_move_at: None,
             finished_at: None,
-            move_time_limit: time_control.as_ref().map(|tc| tc.move_time_limit).flatten(),
+            move_time_limit: time_control.as_ref().and_then(|tc| tc.move_time_limit),
             total_time_limit_white: time_control.as_ref().map(|tc| tc.initial_time),
             total_time_limit_black: time_control.as_ref().map(|tc| tc.initial_time),
+            time_increment: time_control.as_ref().map(|tc| tc.increment),
             time_used_white: 0,
             time_used_black: 0,
-            rated_game,
             allow_draw_offers: true,
             draw_offer_pending: false,
             draw_offered_by: None,
@@ -311,11 +303,12 @@ impl GameAccount {
             white_claimed_amount: 0,
             black_claimed_amount: 0,
             distribution_complete: false,
+            is_claiming: false,
         }
     }
 
-    fn initialize_chess_board() -> [u8; 64] {
-        let mut board = [0u8; 64];
+    fn initialize_chess_board() -> [u8; BOARD_SIZE] {
+        let mut board = [0u8; BOARD_SIZE];
 
         // White pieces (bottom ranks)
         board[0] = 0x14; // White Rook
@@ -356,15 +349,15 @@ impl GameAccount {
     }
 
     pub fn get_piece_at(&self, square: u8) -> u8 {
-        if square < 64 {
+        if square < (BOARD_SIZE as u8) {
             self.board_state[square as usize]
         } else {
             0
         }
     }
 
     pub fn set_piece_at(&mut self, square: u8, piece: u8) {
-        if square < 64 {
+        if square < (BOARD_SIZE as u8) {
             self.board_state[square as usize] = piece;
         }
     }
@@ -461,8 +454,7 @@ impl GameAccount {
 
     /// Get time increment for this game
     pub fn get_time_increment(&self) -> Option<u32> {
-        // This would be stored in time control settings if implemented
-        None // Placeholder
+        self.time_increment
     }
 
     pub fn clear_draw_offer(&mut self) {
@@ -480,17 +472,18 @@ pub struct MoveHistory {
     pub _padding1: [u8; 3],
     pub move_count: u8,
     pub _padding2: [u8; 3],
-    pub moves: [ChessMove; 50],
+    pub moves: [ChessMove; MAX_MOVE_COUNT as usize],
 }
 
 impl MoveHistory {
     pub fn add_move(&mut self, chess_move: ChessMove) -> Result<()> {
-        if self.move_count >= 50 {
-            return err!(ChessError::TooManyMoves);
-        }
+        require!(
+            (self.move_count as usize) < self.moves.len(),
+            ChessError::TooManyMoves
+        );
 
         self.moves[self.move_count as usize] = chess_move;
-        self.move_count += 1;
+        self.move_count = self.move_count.saturating_add(1);
         Ok(())
     }
 }