fixup! smite-ir: implement RecvChannelReady operation

Author: NishantBansal2003

smite-ir/src/operation.rs

@@ -699,7 +699,7 @@ impl fmt::Display for Operation {
             Self::SendFundingCreated => write!(f, "SendFundingCreated"),
             Self::RecvAcceptChannel => write!(f, "RecvAcceptChannel"),
             Self::RecvFundingSigned => write!(f, "RecvFundingSigned"),
-            Self::RecvChannelReady => write!(f, "RecvChannelReady"),
+            Self::RecvChannelReady => write!(f, "RecvChannelReady()"),
             Self::BroadcastTransaction => write!(f, "BroadcastTransaction"),
         }
     }

smite-ir/src/tests.rs

@@ -549,7 +549,7 @@ fn display_build_and_recv_channel_ready_program() {
         format!("v3 = LoadShortChannelId({scid})"),
         "v4 = BuildChannelReady{include_alias=true}(v0, v2, v3)".into(),
         "SendMessage(v4)".into(),
-        "RecvChannelReady".into(),
+        "RecvChannelReady()".into(),
     ];
     assert_eq!(lines.len(), expected.len(), "line count mismatch");
     for (i, (got, want)) in lines.iter().zip(expected.iter()).enumerate() {

smite-scenarios/src/executor.rs

@@ -21,6 +21,11 @@ use smite_ir::operation::AcceptChannelField;
 use smite_ir::{Operation, Program, Variable};
 use std::collections::HashMap;
 
+/// Default maximum `minimum_depth` that Lightning implementations advertise in
+/// `accept_channel`. Once the funding transaction reaches this many
+/// confirmations the target is guaranteed to have sent its `channel_ready`.
+const MAX_MINIMUM_DEPTH: u32 = 8;
+
 /// Abstraction over bitcoin-cli operations, allowing mock implementations in tests.
 pub trait BitcoinRpc {
     /// Mines the given number of blocks.
@@ -372,7 +377,7 @@ impl<C: Connection, B: BitcoinRpc> Executor<C, B> {
                 }
 
                 Operation::RecvChannelReady => {
-                    if is_channel_ready_expected(&mut self.channel_states, &mut self.bitcoin_cli) {
+                    if is_channel_ready_expected(&self.channel_states, &mut self.bitcoin_cli) {
                         log::debug!("[{:?}] RecvChannelReady: waiting", start.elapsed());
                         recv_channel_ready(&mut self.conn, &mut self.channel_states)?;
                         log::debug!("[{:?}] RecvChannelReady: received", start.elapsed());
@@ -1038,7 +1043,7 @@ fn recv_channel_ready(
     let state = channel_states
         .get_mut(&cr.channel_id)
         .ok_or(ExecuteError::UnknownChannel(cr.channel_id))?;
-    *state.next_per_commitment_point_mut(false) = Some(cr.second_per_commitment_point);
+    *state.next_counterparty_per_commitment_point_mut() = Some(cr.second_per_commitment_point);
 
     Ok(())
 }
@@ -1047,18 +1052,16 @@ fn recv_channel_ready(
 ///
 /// A `channel_ready` is expected when a tracked channel is still at commitment
 /// number 0, the counterparty's next per-commitment point is unknown, and the
-/// funding transaction has at least 8 confirmations. Since Lightning
-/// implementations typically use a default maximum `minimum_depth` of 8 in
-/// `accept_channel`, reaching 8 confirmations guarantees the target has sent
-/// its `channel_ready`.
+/// funding transaction has at least [`MAX_MINIMUM_DEPTH`] confirmations.
 fn is_channel_ready_expected(
-    channel_states: &mut HashMap<ChannelId, ChannelState>,
+    channel_states: &HashMap<ChannelId, ChannelState>,
     bitcoin_cli: &mut impl BitcoinRpc,
 ) -> bool {
-    channel_states.values_mut().any(|state| {
+    channel_states.values().any(|state| {
         state.commitment.commitment_number == 0
-            && state.next_per_commitment_point_mut(false).is_none()
-            && bitcoin_cli.get_transaction_confirmations(state.config.funding_outpoint.txid) >= 8
+            && state.next_counterparty_per_commitment_point().is_none()
+            && bitcoin_cli.get_transaction_confirmations(state.config.funding_outpoint.txid)
+                >= MAX_MINIMUM_DEPTH
     })
 }
 
@@ -2841,7 +2844,7 @@ mod tests {
         // The target's next per-commitment point is still unknown and the queued
         // `channel_ready` remains untouched.
         let state = executor.channel_states.get_mut(&channel_id).unwrap();
-        assert!(state.next_per_commitment_point_mut(false).is_none());
+        assert!(state.next_counterparty_per_commitment_point().is_none());
         assert_eq!(executor.conn.recv_queue.len(), 1);
     }
 
@@ -2876,7 +2879,7 @@ mod tests {
         // point is now recorded.
         let state = executor.channel_states.get_mut(&channel_id).unwrap();
         assert_eq!(
-            *state.next_per_commitment_point_mut(false),
+            *state.next_counterparty_per_commitment_point(),
             Some(target_pcp)
         );
         assert!(executor.conn.recv_queue.is_empty());