WIP, interim updates, starting to construct TransactionBundle for simulator

Author: prozacchiwawa

src/referee.rs

@@ -649,46 +649,46 @@ impl RefereeMaker {
         agg_sig_me_additional_data: &Hash,
     ) -> Result<(TransactionBundle, CoinString), Error> {
         let puzzle_reveal = {
-            let previous_args = {
-                let previous_state = self.previous_state();
-                let puzzle_hash = curry_referee_puzzle_hash(
-                    allocator,
-                    &self.referee_coin_puzzle_hash,
-                    &RefereePuzzleArgs {
-                        // XXX check polarity
-                        mover_puzzle_hash: self.my_identity.puzzle_hash.clone(),
-                        waiter_puzzle_hash: self.their_referee_puzzle_hash.clone(),
-                        timeout: self.timeout.clone(),
-                        amount: self.amount.clone(),
-                        referee_coin_puzzle_hash: self.referee_coin_puzzle_hash.clone(),
-                        game_move: previous_state.game_move.clone(),
-                        nonce: self.nonce,
-                        previous_validation_info_hash: previous_state
-                            .previous_validation_program_hash
-                            .clone(),
-                    },
-                )?;
-                let inner_conditions =
-                    // XXX puzzle_reveal
-                    (CREATE_COIN, (puzzle_hash.clone(), (self.amount.clone(), ()))).to_clvm(allocator).into_gen()?;
-                let (solution, sig) =
-                    standard_solution(allocator, &self.my_identity.private_key, inner_conditions)?;
-                let args_list: Vec<Node> = [
-                    previous_state.game_move.move_made.to_clvm(allocator).into_gen()?,
-                    previous_state
-                        .game_move.validation_info_hash
-                        .to_clvm(allocator)
-                        .into_gen()?,
-                    previous_state.game_move.mover_share.to_clvm(allocator).into_gen()?,
-                    previous_state.game_move.max_move_size.to_clvm(allocator).into_gen()?,
-                    puzzle_hash.to_clvm(allocator).into_gen()?,
-                    solution,
-                ]
+            let previous_state = self.previous_state();
+            let puzzle_hash = curry_referee_puzzle_hash(
+                allocator,
+                &self.referee_coin_puzzle_hash,
+                &RefereePuzzleArgs {
+                    // XXX check polarity
+                    mover_puzzle_hash: self.my_identity.puzzle_hash.clone(),
+                    waiter_puzzle_hash: self.their_referee_puzzle_hash.clone(),
+                    timeout: self.timeout.clone(),
+                    amount: self.amount.clone(),
+                    referee_coin_puzzle_hash: self.referee_coin_puzzle_hash.clone(),
+                    game_move: previous_state.game_move.clone(),
+                    nonce: self.nonce,
+                    previous_validation_info_hash: previous_state
+                        .previous_validation_program_hash
+                        .clone(),
+                },
+            )?;
+
+            let inner_conditions =
+            // XXX puzzle_reveal
+                (CREATE_COIN, (puzzle_hash.clone(), (self.amount.clone(), ()))).to_clvm(allocator).into_gen()?;
+            let (solution, sig) =
+                standard_solution(allocator, &self.my_identity.private_key, inner_conditions)?;
+            let args_list: Vec<Node> = [
+                previous_state.game_move.move_made.to_clvm(allocator).into_gen()?,
+                previous_state
+                    .game_move.validation_info_hash
+                    .to_clvm(allocator)
+                    .into_gen()?,
+                previous_state.game_move.mover_share.to_clvm(allocator).into_gen()?,
+                previous_state.game_move.max_move_size.to_clvm(allocator).into_gen()?,
+                puzzle_hash.to_clvm(allocator).into_gen()?,
+                solution,
+            ]
                 .into_iter()
                 .map(|n| Node(n))
                 .collect();
-                args_list.to_clvm(allocator).into_gen()?
-            };
+
+            let previous_args = args_list.to_clvm(allocator).into_gen()?;
 
             if let Some((bundle, cs_out)) = self.get_transaction(
                 allocator,
@@ -850,6 +850,7 @@ impl RefereeMaker {
             )
         };
 
+        // Retrieve evidence from their turn handler.
         let result = handler.call_their_turn_driver(
             allocator,
             &TheirTurnInputs {
@@ -868,6 +869,30 @@ impl RefereeMaker {
 
         match result {
             TheirTurnResult::MakeMove(handler, readable_move, message) => {
+                // Mover puzzle turns the given solution into coin conditions
+                // that pay the game's amount to us.  It checks whether the
+                // originally curried mover puzzle hash is the sha256tree of the
+                // mover puzzle.
+                //
+                // This referee expects the mover puzzle to be a standard-like
+                // puzzle or at least take standard coin arguments including the
+                // list of conditions it produces itself.
+                //
+                // In case this succeeds, we'll direct the result to our mover
+                // puzzle, which sets our identity for the game and is a value-
+                // holding coin spendable by us.
+
+                // let validator_move_args = ValidatorMoveArgs {
+                //     game_move: details.clone(),
+                //     mover_puzzle: self.identity.puzzle.clone(),
+                //     solution: 
+                // };
+
+                // let validator_result = self.run_validator_for_their_move(
+                //     allocator,
+                //     validator_move_args
+                // );
+
                 // XXX check for slashing.
                 self.update_for_their_turn_move(
                     allocator,
@@ -907,12 +932,31 @@ impl RefereeMaker {
         }
     }
 
-    fn target_puzzle_hash_for_slash(
+    // It me.
+    fn target_puzzle_hash_for_slash(&self) -> PuzzleHash {
+        self.my_identity.puzzle_hash.clone()
+    }
+
+    fn slashing_coin_solution(
         &self,
         allocator: &mut AllocEncoder,
-    ) -> Result<PuzzleHash, Error> {
-        let target_inner_puzzle = puzzle_for_pk(allocator, &self.my_identity.public_key)?;
-        puzzle_hash_for_pk(allocator, &self.my_identity.public_key)
+        state: NodePtr,
+        validation_program: Puzzle,
+        slash_solution: NodePtr,
+        coin_solution_after_slash: NodePtr
+    ) -> Result<NodePtr, Error> {
+        (
+            Node(state.clone()),
+            (
+                validation_program.clone(),
+                (
+                    self.target_puzzle_hash_for_slash(),
+                    (Node(slash_solution), (Node(coin_solution_after_slash), ())),
+                ),
+            ),
+        )
+            .to_clvm(allocator)
+            .into_gen()
     }
 
     fn make_slash_for_their_turn(
@@ -938,23 +982,19 @@ impl RefereeMaker {
                 current_state.validation_program.clone(),
             )
         };
+
         let reward_amount = self.amount.clone() - current_mover_share;
         if reward_amount == Amount::default() {
             return Ok(TheirTurnCoinSpentResult::Slash(SlashOutcome::NoReward));
         }
 
-        let slashing_coin_solution = (
-            Node(state.clone()),
-            (
-                Node(validation_program.clone()),
-                (
-                    self.target_puzzle_hash_for_slash(allocator)?,
-                    (Node(slash_solution), (Node(solution), ())),
-                ),
-            ),
-        )
-            .to_clvm(allocator)
-            .into_gen()?;
+        let slashing_coin_solution = self.slashing_coin_solution(
+            allocator,
+            state,
+            Puzzle::from_nodeptr(validation_program),
+            slash_solution,
+            solution
+        )?;
 
         let coin_string_of_output_coin =
             CoinString::from_parts(&coin_string.to_coin_id(), &new_puzzle_hash, &reward_amount);
@@ -1069,7 +1109,7 @@ impl RefereeMaker {
         let slash_conditions = (
             CREATE_COIN,
             (
-                self.target_puzzle_hash_for_slash(allocator)?,
+                self.target_puzzle_hash_for_slash(),
                 (self.amount.clone(), ()),
             ),
         )

src/tests/simulator.rs

@@ -1,16 +1,20 @@
+use clvmr::allocator::NodePtr;
+
 use pyo3::prelude::*;
-use pyo3::types::PyNone;
+use pyo3::types::{PyNone, PyBytes, PyTuple};
 
 use indoc::indoc;
 
-use crate::common::types::{ErrToError, Error};
+use crate::common::types::{ErrToError, Error, Puzzle, Amount, Hash, CoinString, CoinID, PuzzleHash, Aggsig, SpecificTransactionBundle};
 
 // Allow simulator from rust.
 struct Simulator {
     evloop: PyObject,
     sim: PyObject,
     client: PyObject,
     guard: PyObject,
+    make_spend: PyObject,
+    chia_rs_coin: PyObject,
 }
 
 #[cfg(test)]
@@ -20,15 +24,23 @@ impl ErrToError for PyErr {
     }
 }
 
+pub struct CoinSpend {
+    coin: CoinString,
+    puzzle_reveal: Puzzle,
+    solution: NodePtr
+}
+
+pub struct SpendBundle {
+    coin_spends: Vec<CoinSpend>,
+    aggregated_signature: Aggsig
+}
+
 impl Drop for Simulator {
     fn drop(&mut self) {
         Python::with_gil(|py| -> PyResult<_> {
             let none = PyNone::get(py);
-            let exit_task = self
-                .guard
-                .call_method1(py, "__aexit__", (none, none, none))?;
-            self.evloop
-                .call_method1(py, "run_until_complete", (exit_task,))?;
+            let exit_task = self.guard.call_method1(py, "__aexit__", (none, none, none))?;
+            self.evloop.call_method1(py, "run_until_complete", (exit_task,))?;
             Ok(())
         })
         .expect("should shutdown");
@@ -43,12 +55,14 @@ impl Simulator {
                 indoc! {"
                import asyncio
                import chia.clvm.spend_sim
+               from chia.types.coin_spend import make_spend
+               from chia_rs import Coin
 
                def start():
                    evloop = asyncio.new_event_loop()
                    sac_gen = chia.clvm.spend_sim.sim_and_client()
                    (sim, client) = evloop.run_until_complete(sac_gen.__aenter__())
-                   return (evloop, sim, client, sac_gen)
+                   return (evloop, sim, client, sac_gen, make_spend, Coin)
             "},
                 "tmod.py",
                 "tmod",
@@ -59,24 +73,67 @@ impl Simulator {
                 sim: evloop.get_item(1)?.extract()?,
                 client: evloop.get_item(2)?.extract()?,
                 guard: evloop.get_item(3)?.extract()?,
+                make_spend: evloop.get_item(4)?.extract()?,
+                chia_rs_coin: evloop.get_item(5)?.extract()?,
             })
         })
         .expect("should work")
     }
 
+    fn async_call<ArgT>(&self, py: Python<'_>, name: &str, args: ArgT) -> PyResult<PyObject>
+    where
+        ArgT: IntoPy<Py<PyTuple>>
+    {
+        let task = self.sim.call_method1(py, name, args)?;
+        let res = self.evloop.call_method1(py, "run_until_complete", (task,))?;
+        Ok(res.into())
+    }
+
     pub fn farm_block(&self) {
         Python::with_gil(|py| -> PyResult<_> {
-            let farm_task = self.sim.call_method0(py, "farm_block")?;
-            self.evloop
-                .call_method1(py, "run_until_complete", (farm_task,))?;
+            self.async_call(py, "farm_block", ())?;
             Ok(())
         })
         .expect("should farm");
     }
+
+    pub fn get_my_coins(&self) -> PyResult<Vec<CoinString>> {
+        todo!();
+    }
+
+    pub fn make_coin(&self, coin_string: &CoinString) -> PyResult<PyObject> {
+        let (parent_id, puzzle_hash, amount) =
+            if let Some(parts) = coin_string.to_parts() {
+                parts
+            } else {
+                todo!();
+            };
+
+        Python::with_gil(|py| -> PyResult<_> {
+            let parent_parent_coin = PyBytes::new(py, &parent_id.bytes());
+            let puzzle_hash_data = PyBytes::new(py, &puzzle_hash.bytes());
+            let amt: u64 = amount.into();
+            self.chia_rs_coin.call1(py, (parent_parent_coin, puzzle_hash_data, amt))
+        })
+    }
+
+    fn make_coin_spend(
+        &self,
+        parent_coin: &CoinString,
+        puzzle_reveal: Puzzle,
+        solution: NodePtr
+    ) -> PyResult<CoinSpend> {
+        todo!();
+    }
+
+    pub fn perform_spend(&self, tx: &[SpecificTransactionBundle]) -> PyResult<()> {
+        todo!();
+    }
 }
 
 #[test]
 fn test_sim() {
     let s = Simulator::new();
     s.farm_block();
+    let c = s.make_coin(&CoinString::from_parts(&CoinID::default(), &PuzzleHash::default(), &Amount::default()));
 }