Give evidence a distinct type based on how it's used in the onchain referee as opposed to the coin solution. Create an object that represents the dynamic arguments to the onchain referee

Author: prozacchiwawa

src/channel_handler/game_handler.rs

@@ -18,7 +18,7 @@ use clvmr::allocator::NodePtr;
 use clvmr::NO_UNKNOWN_OPS;
 use clvmr::{run_program, ChiaDialect};
 
-use crate::channel_handler::types::{ReadableMove, ReadableUX};
+use crate::channel_handler::types::{ReadableMove, ReadableUX, Evidence};
 use crate::common::types::{
     atom_from_clvm, u64_from_atom, usize_from_atom, Aggsig, AllocEncoder, Amount, Error, Hash,
     IntoErr, Node,
@@ -151,7 +151,7 @@ fn run_code(
 #[derive(Debug, Clone)]
 pub enum TheirTurnResult {
     MakeMove(GameHandler, NodePtr, Vec<u8>),
-    Slash(NodePtr, Aggsig),
+    Slash(Evidence, Aggsig),
 }
 
 impl GameHandler {
@@ -355,7 +355,7 @@ impl GameHandler {
             }
             let sig_bytes = allocator.allocator().atom(pl[2]).to_vec();
             Ok(TheirTurnResult::Slash(
-                pl[1],
+                Evidence::from_nodeptr(pl[1]),
                 Aggsig::from_slice(&sig_bytes)?,
             ))
         } else {

src/channel_handler/types.rs

@@ -225,3 +225,29 @@ pub enum CachedPotatoRegenerateLastHop {
     PotatoAccept(PotatoAcceptCachedData),
     PotatoMoveHappening(PotatoMoveCachedData),
 }
+
+#[derive(Debug, Clone)]
+pub struct Evidence(NodePtr);
+
+impl Evidence {
+    pub fn from_nodeptr(n: NodePtr) -> Evidence {
+        Evidence(n)
+    }
+
+    pub fn nil(allocator: &mut AllocEncoder) -> Evidence {
+        Evidence(allocator.allocator().null())
+    }
+
+    pub fn to_nodeptr(&self) -> NodePtr {
+        self.0
+    }
+}
+
+impl ToClvm<NodePtr> for Evidence {
+    fn to_clvm(
+        &self,
+        _encoder: &mut impl ClvmEncoder<Node = NodePtr>,
+    ) -> Result<NodePtr, ToClvmError> {
+        Ok(self.0)
+    }
+}

src/referee.rs

@@ -11,7 +11,7 @@ use crate::channel_handler::game_handler::{
     chia_dialect, GameHandler, MessageHandler, MessageInputs, MyTurnInputs, TheirTurnInputs,
     TheirTurnResult,
 };
-use crate::channel_handler::types::{GameStartInfo, ReadableMove, ReadableUX};
+use crate::channel_handler::types::{GameStartInfo, ReadableMove, ReadableUX, Evidence};
 use crate::common::constants::CREATE_COIN;
 use crate::common::standard_coin::{
     curry_and_treehash, private_to_public_key, puzzle_for_pk, puzzle_hash_for_pk, sign_agg_sig_me,
@@ -223,6 +223,34 @@ struct RefereeMakerGameState {
     pub previous_validation_program_hash: Hash,
 }
 
+struct OnChainRefereeMove {
+    // Details
+    detauls: GameMoveDetails,
+    mover_puzzle: Puzzle,
+    mover_coin_spend_solution: NodePtr,
+}
+
+struct OnChainRefereeSlash {
+    previous_state: NodePtr,
+    previous_validation_program: Program,
+    mover_coin_puzzle: Puzzle,
+    mover_coin_spend_solution: NodePtr,
+    slash_evidence: Evidence,
+}
+
+// onchain referee solution
+//
+// This represents the whole solution for the on chain referee.
+//
+// It is a solution itself, but the referee coin uses the mover puzzle as a
+// puzzle for a coin that represents the user's identity ... most likely a
+// standard puzzle.
+enum OnChainRefereeSolution {
+    Timeout,
+    Move(OnChainRefereeMove),
+    Slash(OnChainRefereeSlash)
+}
+
 // XXX break out state so we can have a previous state and easily swap them.
 // Referee coin has two inner puzzles.
 // Throughout channel handler, the one that's ours is the standard format puzzle
@@ -947,15 +975,15 @@ impl RefereeMaker {
         state: NodePtr,
         validation_program: Puzzle,
         slash_solution: NodePtr,
-        coin_solution_after_slash: NodePtr
+        evidence: Evidence
     ) -> Result<NodePtr, Error> {
         (
             Node(state.clone()),
             (
                 validation_program.clone(),
                 (
                     self.target_puzzle_hash_for_slash(),
-                    (Node(slash_solution), (Node(coin_solution_after_slash), ())),
+                    (Node(slash_solution), (Node(evidence.to_nodeptr()), ())),
                 ),
             ),
         )
@@ -970,7 +998,7 @@ impl RefereeMaker {
         new_puzzle: &Puzzle,
         new_puzzle_hash: &PuzzleHash,
         slash_solution: NodePtr,
-        solution: NodePtr,
+        evidence: Evidence,
         sig: &Aggsig,
     ) -> Result<TheirTurnCoinSpentResult, Error> {
         // Probably readable_info overlaps solution.
@@ -997,7 +1025,7 @@ impl RefereeMaker {
             state,
             Puzzle::from_nodeptr(validation_program),
             slash_solution,
-            solution
+            evidence
         )?;
 
         let coin_string_of_output_coin =
@@ -1171,14 +1199,16 @@ impl RefereeMaker {
             Node(state.clone()),
             (
                 Node(validation_program.clone()),
-                (new_puzzle_hash.clone(), (Node(slash_solution), (0, ()))),
+                // No evidence here.
+                (new_puzzle_hash.clone(), ((), (0, ()))),
             ),
         )
             .to_clvm(allocator)
             .into_gen()?;
 
         // Ultimately each of these cases returns some kind of
         // TheirTurnCoinSpentResult.
+        let nil_evidence = Evidence::nil(allocator);
         match full_slash_result {
             Ok(_) => {
                 // result is NodePtr containing solution and aggsig.
@@ -1191,7 +1221,7 @@ impl RefereeMaker {
                     &new_puzzle,
                     &new_puzzle_hash,
                     full_slash_solution,
-                    slash_solution,
+                    nil_evidence,
                     &slash_aggsig,
                 )
             }
@@ -1216,15 +1246,17 @@ impl RefereeMaker {
                         run_debug: self.run_debug,
                     },
                 )? {
-                    TheirTurnResult::Slash(solution, sig) => self.make_slash_for_their_turn(
-                        allocator,
-                        coin_string,
-                        &new_puzzle,
-                        &new_puzzle_hash,
-                        full_slash_solution,
-                        solution,
-                        &(slash_aggsig + sig),
-                    ),
+                    TheirTurnResult::Slash(evidence, sig) => {
+                        self.make_slash_for_their_turn(
+                            allocator,
+                            coin_string,
+                            &new_puzzle,
+                            &new_puzzle_hash,
+                            full_slash_solution,
+                            evidence,
+                            &(slash_aggsig + sig),
+                        )
+                    }
                     TheirTurnResult::MakeMove(game_handler, readable_move, message) => {
                         // Otherwise accept move by updating our state
                         self.accept_this_move(

src/tests/game_handler.rs

@@ -45,10 +45,10 @@ fn test_game_handler_their_move_slash() {
             },
         )
         .expect("should run");
-    if let TheirTurnResult::Slash(solution, aggsig) = result {
+    if let TheirTurnResult::Slash(evidence, aggsig) = result {
         // Good, check more
         assert_eq!(aggsig, default_aggsig);
-        assert_eq!(disassemble(allocator.allocator(), solution, None), "(1337 () () () 0x0000000000000000000000000000000000000000000000000000000000000000 () ())");
+        assert_eq!(disassemble(allocator.allocator(), evidence.to_nodeptr(), None), "(1337 () () () 0x0000000000000000000000000000000000000000000000000000000000000000 () ())");
     } else {
         assert!(false);
     }

src/tests/simulator.rs

@@ -15,8 +15,8 @@ use crate::common::constants::{AGG_SIG_ME_ADDITIONAL_DATA, CREATE_COIN, DEFAULT_
 use crate::common::standard_coin::{sign_agg_sig_me, standard_solution_partial, ChiaIdentity, calculate_synthetic_secret_key, private_to_public_key, calculate_synthetic_public_key, agg_sig_me_message};
 use crate::common::types::{ErrToError, Error, Puzzle, Amount, Hash, CoinString, CoinID, PuzzleHash, PrivateKey, Aggsig, Node, SpecificTransactionBundle, AllocEncoder, TransactionBundle, ToQuotedProgram, Sha256tree, Timeout, GameID};
 
-use crate::channel_handler::types::GameStartInfo;
-
+use crate::channel_handler::types::{GameStartInfo, ReadableMove};
+use crate::referee::GameMoveDetails;
 use crate::tests::referee::{RefereeTest, make_debug_game_handler};
 
 // Allow simulator from rust.
@@ -384,4 +384,26 @@ fn test_referee_can_slash_on_chain() {
         their_validation_program_hash,
         &game_start_info,
     );
+
+    let readable_move = assemble(allocator.allocator(), "(0 . 0)").expect("should assemble");
+    let my_move_wire_data = reftest.my_referee
+        .my_turn_make_move(
+            &mut rng,
+            &mut allocator,
+            &ReadableMove::from_nodeptr(readable_move),
+        )
+        .expect("should move");
+
+    assert!(my_move_wire_data.details.move_made.is_empty());
+    let mut off_chain_slash_gives_error = reftest.my_referee.clone();
+    let their_move_result = off_chain_slash_gives_error.their_turn_move_off_chain(
+        &mut allocator,
+        &GameMoveDetails {
+            move_made: vec![1],
+            validation_info_hash: my_move_wire_data.details.validation_info_hash.clone(),
+            max_move_size: 100,
+            mover_share: Amount::default(),
+        },
+    );
+    eprintln!("their_move_result {their_move_result:?}");
 }