More parameterization which gives us the freedom to match things

src/channel_handler/mod.rs

@@ -140,6 +140,10 @@ impl ChannelHandler {
         }
     }
 
+    pub fn get_unroll_coin(&self) -> &ChannelHandlerUnrollSpendInfo {
+        &self.unroll
+    }
+
     fn make_curried_unroll_puzzle<R: Rng>(
         &self,
         env: &mut ChannelHandlerEnv<R>,
@@ -1023,9 +1027,9 @@ impl ChannelHandler {
     pub fn get_unroll_coin_transaction<R: Rng>(
         &self,
         env: &mut ChannelHandlerEnv<R>,
+        use_unroll: &ChannelHandlerUnrollSpendInfo,
     ) -> Result<ChannelCoinSpentResult, Error> {
         assert!(self.timeout.is_some());
-        let use_unroll = self.get_finished_unroll_coin();
 
         debug!("channel handler at {}", self.current_state_number);
 
@@ -1123,7 +1127,7 @@ impl ChannelHandler {
         match state_number.cmp(&self.current_state_number) {
             Ordering::Greater => Err(Error::StrErr(format!(
                 "Reply from the future onchain {} (me {}) vs {}",
-                state_number, self.current_state_number, self.unroll.coin.state_number
+                state_number, self.current_state_number, full_coin.coin.state_number
             ))),
             Ordering::Less => {
                 if our_parity == their_parity {
@@ -1132,7 +1136,7 @@ impl ChannelHandler {
                     ));
                 }
 
-                self.get_unroll_coin_transaction(env)
+                self.get_unroll_coin_transaction(env, &full_coin)
             }
             _ => {
                 // Timeout
@@ -1511,8 +1515,8 @@ impl ChannelHandler {
     pub fn get_unroll_target<R: Rng>(
         &self,
         env: &mut ChannelHandlerEnv<R>,
+        use_unroll: &ChannelHandlerUnrollSpendInfo,
     ) -> Result<UnrollTarget, Error> {
-        let use_unroll = self.get_finished_unroll_coin();
         let curried_unroll_puzzle = use_unroll
             .coin
             .make_curried_unroll_puzzle(env, &self.get_aggregate_unroll_public_key())?;

src/channel_handler/types.rs

@@ -446,7 +446,7 @@ pub struct HandshakeResult {
 }
 
 /// The channel handler can use these two items to produce a spend on chain.
-#[derive(Default)]
+#[derive(Default, Clone)]
 pub struct ChannelHandlerUnrollSpendInfo {
     /// Contains the half signature, puzzle and conditions needed to spend.
     pub coin: UnrollCoin,

src/potato_handler.rs

@@ -1510,7 +1510,8 @@ impl PotatoHandler {
         let (env, system_interface) = penv.env();
         let player_ch = self.channel_handler()?;
         // Channel coin
-        let pre_unroll_data = player_ch.get_unroll_coin_transaction(env)?;
+        let finished_unroll_coin = player_ch.get_unroll_coin();
+        let pre_unroll_data = player_ch.get_unroll_coin_transaction(env, &finished_unroll_coin)?;
         debug!(
             "unroll to on chain puzzle: {}",
             pre_unroll_data.transaction.puzzle.to_hex()
@@ -1610,7 +1611,8 @@ impl PotatoHandler {
         let ch = self.channel_handler()?;
         let unroll_target = if let HandshakeState::Finished(_hs) = &self.handshake_state {
             let (env, _) = penv.env();
-            ch.get_unroll_target(env)?
+            let use_unroll = ch.get_unroll_coin();
+            ch.get_unroll_target(env, use_unroll)?
         } else {
             return Err(Error::StrErr(
                 "go on chain before handshake finished".to_string(),

src/tests/simenv.rs

@@ -216,7 +216,8 @@ impl<'a, R: Rng> SimulatorEnvironment<'a, R> {
         unroll_coin: CoinString,
     ) -> Result<Vec<CoinString>, Error> {
         let player_ch = &mut self.parties.player(player).ch;
-        let pre_unroll_data = player_ch.get_unroll_coin_transaction(&mut self.env)?;
+        let finished_unroll_coin = player_ch.get_finished_unroll_coin();
+        let pre_unroll_data = player_ch.get_unroll_coin_transaction(&mut self.env, &finished_unroll_coin)?;
 
         let run_puzzle = pre_unroll_data
             .transaction
@@ -294,7 +295,8 @@ impl<'a, R: Rng> SimulatorEnvironment<'a, R> {
             &ReadableMove::from_nodeptr(readable),
             entropy,
         )?;
-        let post_unroll_data = player_ch.get_unroll_coin_transaction(&mut self.env)?;
+        let finished_unroll_coin = player_ch.get_finished_unroll_coin();
+        let post_unroll_data = player_ch.get_unroll_coin_transaction(&mut self.env, &finished_unroll_coin)?;
         debug!("post_unroll_data {post_unroll_data:?}");
         todo!();
     }
@@ -314,11 +316,12 @@ impl<'a, R: Rng> SimulatorEnvironment<'a, R> {
                 }
             }
             GameAction::GoOnChain(player) => {
+                let use_unroll = self.parties.player(*player).ch.get_finished_unroll_coin().clone();
                 let unroll_target = self
                     .parties
                     .player(*player)
                     .ch
-                    .get_unroll_target(&mut self.env)?;
+                    .get_unroll_target(&mut self.env, &use_unroll)?;
                 debug!(
                     "GO ON CHAIN: {} {:?} {:?}",
                     unroll_target.state_number, unroll_target.my_amount, unroll_target.their_amount