Some clippy traffic, update the debug game a bit

prozacchiwawa · prozacchiwawa · commit 973e1f9751e1 · 2024-05-13T08:24:56.000-07:00
diff --git a/resources/debug_game_handler.clsp b/resources/debug_game_handler.clsp
@@ -41,8 +41,6 @@
    )
   )
 
-(defun one-or-zero (X) (i X X 0x00))
-
 (defun do_my_turn (MOD_HASH PUZZLE AMOUNT MY_TURN SLASH_INFO readable_new_move amount state entropy)
   (assign
 
@@ -51,7 +49,7 @@
    new_validation_program_hash (shatree state "this is not right") ;; XXX just anything
 
    (list
-    (concat (one-or-zero set_cheated) set_share)
+    (logior (logand 1 set_cheated) (ash set_share 1))
     validation_program
     new_validation_program_hash
     (c set_share set_cheated)
@@ -65,7 +63,7 @@
 
 (defun do_their_turn (MOD_HASH PUZZLE AMOUNT MY_TURN SLASH_INFO amount last_state new_move new_validation_info_hash new_max_move_size new_mover_share)
   (assign
-   set_cheated (+ (substr new_move 0 1))
+   set_cheated (logand new_move 1)
 
    (if set_cheated
        (c 2 SLASH_INFO)
diff --git a/src/channel_handler/game_handler.rs b/src/channel_handler/game_handler.rs
@@ -141,7 +141,7 @@ fn run_code(
     allocator: &mut AllocEncoder,
     code: NodePtr,
     env: NodePtr,
-    debug: bool,
+    _debug: bool,
 ) -> Result<NodePtr, Error> {
     run_program(allocator.allocator(), &chia_dialect(), code, env, 0)
         .into_gen()
@@ -269,7 +269,7 @@ impl GameHandler {
 
         Ok(MyTurnResult {
             waiting_driver: GameHandler::their_driver_from_nodeptr(pl[6]),
-            move_data: move_data,
+            move_data,
             validation_program: pl[1],
             validation_program_hash,
             state: pl[3],
@@ -378,8 +378,8 @@ impl MessageHandler {
     }
     pub fn run(
         &self,
-        allocator: &mut AllocEncoder,
-        inputs: &MessageInputs,
+        _allocator: &mut AllocEncoder,
+        _inputs: &MessageInputs,
     ) -> Result<ReadableUX, Error> {
         todo!();
     }
diff --git a/src/channel_handler/handler.rs b/src/channel_handler/handler.rs
@@ -515,7 +515,7 @@ impl ChannelHandler {
             self.create_conditions_and_signature_of_channel_coin(env, state_number_for_spend)?;
 
         let new_game_coins_on_chain: Vec<(PuzzleHash, Amount)> = self
-            .get_new_game_coins_on_chain(env, None, None, None)
+            .get_new_game_coins_on_chain(env, None, &[], None)
             .iter()
             .filter_map(|ngc| ngc.coin_string_up.as_ref().and_then(|c| c.to_parts()))
             .map(|(_, puzzle_hash, amount)| (puzzle_hash, amount))
@@ -1141,48 +1141,46 @@ impl ChannelHandler {
                 },
                 false,
             ))
-        } else {
-            if state_number == self.unroll_state_number {
-                // Timeout
-                let (curried_unroll_puzzle, unroll_puzzle_solution) = self
-                    .make_unroll_puzzle_solution(
-                        env,
-                        self.default_conditions_for_unroll_coin_spend.to_nodeptr(),
-                    )?;
-
-                Ok((
-                    TransactionBundle {
-                        puzzle: Puzzle::from_nodeptr(curried_unroll_puzzle),
-                        solution: unroll_puzzle_solution,
-                        signature: Aggsig::default(),
-                    },
-                    true,
-                ))
-            } else if state_number == self.current_state_number {
-                // Different timeout, construct the conditions based on the current
-                // state.  (different because we're not using the conditions we
-                // have cached).
-                let (conditions, _) = self.create_conditions_and_signature_of_channel_coin(
+        } else if state_number == self.unroll_state_number {
+            // Timeout
+            let (curried_unroll_puzzle, unroll_puzzle_solution) = self
+                .make_unroll_puzzle_solution(
                     env,
-                    self.current_state_number,
+                    self.default_conditions_for_unroll_coin_spend.to_nodeptr(),
                 )?;
-                let (curried_unroll_puzzle, unroll_puzzle_solution) =
-                    self.make_unroll_puzzle_solution(env, conditions)?;
-
-                Ok((
-                    TransactionBundle {
-                        puzzle: Puzzle::from_nodeptr(curried_unroll_puzzle),
-                        solution: unroll_puzzle_solution,
-                        signature: Aggsig::default(),
-                    },
-                    true,
-                ))
-            } else {
-                return Err(Error::StrErr(format!(
-                    "Unhandled relationship between state numbers {state_number} {}",
-                    self.unroll_state_number
-                )));
-            }
+
+            Ok((
+                TransactionBundle {
+                    puzzle: Puzzle::from_nodeptr(curried_unroll_puzzle),
+                    solution: unroll_puzzle_solution,
+                    signature: Aggsig::default(),
+                },
+                true,
+            ))
+        } else if state_number == self.current_state_number {
+            // Different timeout, construct the conditions based on the current
+            // state.  (different because we're not using the conditions we
+            // have cached).
+            let (conditions, _) = self.create_conditions_and_signature_of_channel_coin(
+                env,
+                self.current_state_number,
+            )?;
+            let (curried_unroll_puzzle, unroll_puzzle_solution) =
+                self.make_unroll_puzzle_solution(env, conditions)?;
+
+            Ok((
+                TransactionBundle {
+                    puzzle: Puzzle::from_nodeptr(curried_unroll_puzzle),
+                    solution: unroll_puzzle_solution,
+                    signature: Aggsig::default(),
+                },
+                true,
+            ))
+        } else {
+            Err(Error::StrErr(format!(
+                "Unhandled relationship between state numbers {state_number} {}",
+                self.unroll_state_number
+            )))
         }
     }
 
@@ -1221,7 +1219,7 @@ impl ChannelHandler {
             Some(CachedPotatoRegenerateLastHop::PotatoCreatedGame(
                 ids,
                 our_contrib,
-                their_contrib,
+                _their_contrib,
             )) => {
                 // Add amount contributed to vanilla balance
                 // Skip game when generating result.
@@ -1307,9 +1305,9 @@ impl ChannelHandler {
 
     pub fn get_new_game_coins_on_chain<R: Rng>(
         &self,
-        env: &mut ChannelHandlerEnv<R>,
+        _env: &mut ChannelHandlerEnv<R>,
         unroll_coin: Option<&CoinID>,
-        skip_game: Option<&GameID>,
+        skip_game: &[GameID],
         skip_coin_id: Option<&GameID>,
     ) -> Vec<OnChainGameCoin> {
         // It's ok to not have a proper coin id here when we only want
@@ -1318,7 +1316,7 @@ impl ChannelHandler {
 
         self.live_games
             .iter()
-            .filter(|game| skip_game != Some(&game.game_id))
+            .filter(|game| !skip_game.contains(&game.game_id))
             .map(|game| {
                 let coin = if skip_coin_id == Some(&game.game_id) {
                     None
@@ -1385,22 +1383,15 @@ impl ChannelHandler {
             return Err(Error::StrErr("Unconvertible state number".to_string()));
         };
 
-        let our_parity = self.unroll_state_number & 1;
-        let their_parity = state_number & 1;
-
-        let mut skip_game = None;
-        let mut skip_coin_id = None;
-        let mut contributed_adjustment = Amount::default();
-
         let disposition =
             self.get_cached_disposition_for_spent_result(env, unroll_coin, state_number)?;
 
         // return list of triples of game_id, coin_id, referee maker pulling from a list of pairs of (id, ref maker)
         let new_game_coins_on_chain = self.get_new_game_coins_on_chain(
             env,
             Some(&unroll_coin.to_coin_id()),
-            skip_game.as_ref(),
-            skip_coin_id.as_ref(),
+            &disposition.as_ref().map(|d| d.skip_game.clone()).unwrap_or_default(),
+            disposition.as_ref().and_then(|d| d.skip_coin_id.as_ref()),
         );
 
         // coin with = parent is the unroll coin id and whose puzzle hash is ref and amount is my vanilla amount.
diff --git a/src/channel_handler/types.rs b/src/channel_handler/types.rs
@@ -77,7 +77,7 @@ impl ReadableMove {
 impl ToClvm<NodePtr> for ReadableMove {
     fn to_clvm(
         &self,
-        encoder: &mut impl ClvmEncoder<Node = NodePtr>,
+        _encoder: &mut impl ClvmEncoder<Node = NodePtr>,
     ) -> Result<NodePtr, ToClvmError> {
         Ok(self.0)
     }
diff --git a/src/common/types.rs b/src/common/types.rs
@@ -466,8 +466,8 @@ pub struct RefereeID(usize);
 /// Error type
 #[derive(Debug)]
 pub enum Error {
-    ClvmError(EvalErr),
-    IoError(io::Error),
+    ClvmErr(EvalErr),
+    IoErr(io::Error),
     BasicError,
     SyntaxErr(SyntaxErr),
     EncodeErr(ToClvmError),
@@ -635,7 +635,7 @@ pub trait ErrToError {
 
 impl ErrToError for EvalErr {
     fn into_gen(self) -> Error {
-        Error::ClvmError(self)
+        Error::ClvmErr(self)
     }
 }
 
@@ -654,7 +654,7 @@ impl ErrToError for SyntaxErr {
 
 impl ErrToError for io::Error {
     fn into_gen(self) -> Error {
-        Error::IoError(self)
+        Error::IoErr(self)
     }
 }
 
@@ -711,37 +711,35 @@ fn parse_condition(allocator: &mut AllocEncoder, condition: NodePtr) -> Option<C
         }
         PublicKey::from_bytes(fixed)
     };
-    if exploded.len() > 2 {
-        if matches!(
-            (
-                allocator.allocator().sexp(exploded[0]),
-                allocator.allocator().sexp(exploded[1]),
-                allocator.allocator().sexp(exploded[2])
-            ),
-            (SExp::Atom, SExp::Atom, SExp::Atom)
-        ) {
-            let atoms: Vec<Vec<u8>> = exploded
-                .iter()
-                .take(3)
-                .map(|a| allocator.allocator().atom(*a).to_vec())
-                .collect();
-            if *atoms[0] == AGG_SIG_UNSAFE_ATOM {
-                if let Ok(pk) = public_key_from_bytes(&atoms[1]) {
-                    return Some(CoinCondition::AggSigUnsafe(pk, atoms[2].to_vec()));
-                }
-            } else if *atoms[0] == AGG_SIG_ME_ATOM {
-                if let Ok(pk) = public_key_from_bytes(&atoms[1]) {
-                    return Some(CoinCondition::AggSigMe(pk, atoms[2].to_vec()));
-                }
-            } else if *atoms[0] == CREATE_COIN_ATOM {
-                return Some(CoinCondition::CreateCoin(PuzzleHash::from_hash(
-                    Hash::from_slice(&atoms[1]),
-                )));
-            } else if *atoms[0] == REM_ATOM {
-                return Some(CoinCondition::Rem(
-                    atoms.iter().map(|a| a.to_vec()).collect(),
-                ));
+    if exploded.len() > 2 && matches!(
+        (
+            allocator.allocator().sexp(exploded[0]),
+            allocator.allocator().sexp(exploded[1]),
+            allocator.allocator().sexp(exploded[2])
+        ),
+        (SExp::Atom, SExp::Atom, SExp::Atom)
+    ) {
+        let atoms: Vec<Vec<u8>> = exploded
+            .iter()
+            .take(3)
+            .map(|a| allocator.allocator().atom(*a).to_vec())
+            .collect();
+        if *atoms[0] == AGG_SIG_UNSAFE_ATOM {
+            if let Ok(pk) = public_key_from_bytes(&atoms[1]) {
+                return Some(CoinCondition::AggSigUnsafe(pk, atoms[2].to_vec()));
+            }
+        } else if *atoms[0] == AGG_SIG_ME_ATOM {
+            if let Ok(pk) = public_key_from_bytes(&atoms[1]) {
+                return Some(CoinCondition::AggSigMe(pk, atoms[2].to_vec()));
             }
+        } else if *atoms[0] == CREATE_COIN_ATOM {
+            return Some(CoinCondition::CreateCoin(PuzzleHash::from_hash(
+                Hash::from_slice(&atoms[1]),
+            )));
+            } else if *atoms[0] == REM_ATOM {
+            return Some(CoinCondition::Rem(
+                atoms.iter().map(|a| a.to_vec()).collect(),
+            ));
         }
     }
 
diff --git a/src/referee/mod.rs b/src/referee/mod.rs
@@ -196,7 +196,7 @@ impl RefereeMaker {
             my_private_key: my_private_key.clone(),
             timeout: game_start_info.timeout.clone(),
             amount: game_start_info.amount.clone(),
-            nonce: nonce,
+            nonce,
 
             states: [state.clone(), state],
             is_my_turn: game_start_info.game_handler.is_my_turn(),
@@ -484,7 +484,7 @@ impl RefereeMaker {
 
             (|current_state: &RefereeMakerGameState| {
                 match &current_state.game_handler {
-                    GameHandler::MyTurnHandler(h) => {
+                    GameHandler::MyTurnHandler(_h) => {
                         // It is my turn
                         if current_state.mover_share != Amount::default() {
                             // And we have a mover share.
@@ -493,7 +493,7 @@ impl RefereeMaker {
 
                         (true, Amount::default())
                     }
-                    GameHandler::TheirTurnHandler(h) => {
+                    GameHandler::TheirTurnHandler(_h) => {
                         // Their turn
                         if current_state.mover_share != amount {
                             // There is some left over.

Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ impl ReadableMove {`
`77`	`77`	`impl ToClvm<NodePtr> for ReadableMove {`
`78`	`78`	`fn to_clvm(`
`79`	`79`	`&self,`
`80`		`- encoder: &mut impl ClvmEncoder<Node = NodePtr>,`
	`80`	`+ _encoder: &mut impl ClvmEncoder<Node = NodePtr>,`
`81`	`81`	`) -> Result<NodePtr, ToClvmError> {`
`82`	`82`	`Ok(self.0)`
`83`	`83`	`}`