f s/local/sent/ & s/remote/received/ where appropriate

Author: dunxen

lightning/src/ln/interactivetxs.rs

@@ -109,7 +109,7 @@ impl NegotiationContext {
 			.map(|(_, input_with_prevout)| input_with_prevout)
 	}
 
-	fn remote_tx_add_input(&mut self, msg: &msgs::TxAddInput) -> Result<(), AbortReason> {
+	fn received_tx_add_input(&mut self, msg: &msgs::TxAddInput) -> Result<(), AbortReason> {
 		// The interactive-txs spec calls for us to fail negotiation if the `prevtx` we receive is
 		// invalid. However, we would not need to account for this explicit negotiation failure
 		// mode here since `PeerManager` would already disconnect the peer if the `prevtx` is
@@ -187,7 +187,7 @@ impl NegotiationContext {
 		Ok(())
 	}
 
-	fn remote_tx_remove_input(&mut self, msg: &msgs::TxRemoveInput) -> Result<(), AbortReason> {
+	fn received_tx_remove_input(&mut self, msg: &msgs::TxRemoveInput) -> Result<(), AbortReason> {
 		if !self.is_serial_id_valid_for_counterparty(&msg.serial_id) {
 			return Err(AbortReason::IncorrectSerialIdParity);
 		}
@@ -203,7 +203,7 @@ impl NegotiationContext {
 		}
 	}
 
-	fn remote_tx_add_output(&mut self, msg: &msgs::TxAddOutput) -> Result<(), AbortReason> {
+	fn received_tx_add_output(&mut self, msg: &msgs::TxAddOutput) -> Result<(), AbortReason> {
 		// The receiving node:
 		//  - MUST fail the negotiation if:
 		//     - the serial_id has the wrong parity
@@ -260,7 +260,7 @@ impl NegotiationContext {
 		Ok(())
 	}
 
-	fn remote_tx_remove_output(&mut self, msg: &msgs::TxRemoveOutput) -> Result<(), AbortReason> {
+	fn received_tx_remove_output(&mut self, msg: &msgs::TxRemoveOutput) -> Result<(), AbortReason> {
 		if !self.is_serial_id_valid_for_counterparty(&msg.serial_id) {
 			return Err(AbortReason::IncorrectSerialIdParity);
 		}
@@ -275,7 +275,7 @@ impl NegotiationContext {
 		}
 	}
 
-	fn local_tx_add_input(&mut self, msg: &msgs::TxAddInput) {
+	fn sent_tx_add_input(&mut self, msg: &msgs::TxAddInput) {
 		let tx = msg.prevtx.as_transaction();
 		let input = TxIn {
 			previous_output: OutPoint { txid: tx.txid(), vout: msg.prevtx_out },
@@ -291,16 +291,16 @@ impl NegotiationContext {
 		);
 	}
 
-	fn local_tx_add_output(&mut self, msg: &msgs::TxAddOutput) {
+	fn sent_tx_add_output(&mut self, msg: &msgs::TxAddOutput) {
 		self.outputs
 			.insert(msg.serial_id, TxOut { value: msg.sats, script_pubkey: msg.script.clone() });
 	}
 
-	fn local_tx_remove_input(&mut self, msg: &msgs::TxRemoveInput) {
+	fn sent_tx_remove_input(&mut self, msg: &msgs::TxRemoveInput) {
 		self.inputs.remove(&msg.serial_id);
 	}
 
-	fn local_tx_remove_output(&mut self, msg: &msgs::TxRemoveOutput) {
+	fn sent_tx_remove_output(&mut self, msg: &msgs::TxRemoveOutput) {
 		self.outputs.remove(&msg.serial_id);
 	}
 
@@ -424,22 +424,22 @@ macro_rules! define_state {
 
 define_state!(
 	LOCAL_STATE,
-	LocalChange,
+	SentChange,
 	"We have sent a message to the counterparty that has affected our negotiation state."
 );
 define_state!(
 	LOCAL_STATE,
-	LocalTxComplete,
+	SentTxComplete,
 	"We have sent a `tx_complete` message and are awaiting the counterparty's."
 );
 define_state!(
 	REMOTE_STATE,
-	RemoteChange,
+	ReceivedChange,
 	"We have received a message from the counterparty that has affected our negotiation state."
 );
 define_state!(
 	REMOTE_STATE,
-	RemoteTxComplete,
+	ReceivedTxComplete,
 	"We have received a `tx_complete` message and the counterparty is awaiting ours."
 );
 define_state!(NegotiationComplete, Transaction, "We have exchanged consecutive `tx_complete` messages with the counterparty and the transaction negotiation is complete.");
@@ -458,22 +458,22 @@ trait StateTransition<NewState: State, TransitionData> {
 macro_rules! define_state_transitions {
 	(LOCAL_STATE, [$(DATA $data: ty, TRANSITION $transition: ident),+]) => {
 		$(
-			impl<S: LocalState> StateTransition<RemoteChange, $data> for S {
-				fn transition(self, data: $data) -> StateTransitionResult<RemoteChange> {
+			impl<S: LocalState> StateTransition<ReceivedChange, $data> for S {
+				fn transition(self, data: $data) -> StateTransitionResult<ReceivedChange> {
 					let mut context = self.into_negotiation_context();
 					let _ = context.$transition(data)?;
-					Ok(RemoteChange(context))
+					Ok(ReceivedChange(context))
 				}
 			}
 		 )*
 	};
 	(REMOTE_STATE, [$(DATA $data: ty, TRANSITION $transition: ident),+]) => {
 		$(
-			impl<S: RemoteState> StateTransition<LocalChange, $data> for S {
-				fn transition(self, data: $data) -> StateTransitionResult<LocalChange> {
+			impl<S: RemoteState> StateTransition<SentChange, $data> for S {
+				fn transition(self, data: $data) -> StateTransitionResult<SentChange> {
 					let mut context = self.into_negotiation_context();
 					let _ = context.$transition(data);
-					Ok(LocalChange(context))
+					Ok(SentChange(context))
 				}
 			}
 		 )*
@@ -497,29 +497,29 @@ macro_rules! define_state_transitions {
 }
 
 define_state_transitions!(LOCAL_STATE, [
-	DATA &msgs::TxAddInput, TRANSITION remote_tx_add_input,
-	DATA &msgs::TxRemoveInput, TRANSITION remote_tx_remove_input,
-	DATA &msgs::TxAddOutput, TRANSITION remote_tx_add_output,
-	DATA &msgs::TxRemoveOutput, TRANSITION remote_tx_remove_output
+	DATA &msgs::TxAddInput, TRANSITION received_tx_add_input,
+	DATA &msgs::TxRemoveInput, TRANSITION received_tx_remove_input,
+	DATA &msgs::TxAddOutput, TRANSITION received_tx_add_output,
+	DATA &msgs::TxRemoveOutput, TRANSITION received_tx_remove_output
 ]);
 define_state_transitions!(REMOTE_STATE, [
-	DATA &msgs::TxAddInput, TRANSITION local_tx_add_input,
-	DATA &msgs::TxRemoveInput, TRANSITION local_tx_remove_input,
-	DATA &msgs::TxAddOutput, TRANSITION local_tx_add_output,
-	DATA &msgs::TxRemoveOutput, TRANSITION local_tx_remove_output
+	DATA &msgs::TxAddInput, TRANSITION sent_tx_add_input,
+	DATA &msgs::TxRemoveInput, TRANSITION sent_tx_remove_input,
+	DATA &msgs::TxAddOutput, TRANSITION sent_tx_add_output,
+	DATA &msgs::TxRemoveOutput, TRANSITION sent_tx_remove_output
 ]);
-define_state_transitions!(TX_COMPLETE_AS_ACK, LocalChange, RemoteTxComplete);
-define_state_transitions!(TX_COMPLETE_AS_ACK, RemoteChange, LocalTxComplete);
-define_state_transitions!(TX_COMPLETE, LocalTxComplete);
-define_state_transitions!(TX_COMPLETE, RemoteTxComplete);
+define_state_transitions!(TX_COMPLETE_AS_ACK, SentChange, ReceivedTxComplete);
+define_state_transitions!(TX_COMPLETE_AS_ACK, ReceivedChange, SentTxComplete);
+define_state_transitions!(TX_COMPLETE, SentTxComplete);
+define_state_transitions!(TX_COMPLETE, ReceivedTxComplete);
 
 #[derive(Debug)]
 enum StateMachine {
 	Indeterminate,
-	LocalChange(LocalChange),
-	RemoteChange(RemoteChange),
-	LocalTxComplete(LocalTxComplete),
-	RemoteTxComplete(RemoteTxComplete),
+	SentChange(SentChange),
+	ReceivedChange(ReceivedChange),
+	SentTxComplete(SentTxComplete),
+	ReceivedTxComplete(ReceivedTxComplete),
 	NegotiationComplete(NegotiationComplete),
 	NegotiationAborted(NegotiationAborted),
 }
@@ -546,12 +546,12 @@ macro_rules! define_state_machine_transitions {
 	};
 	(LOCAL_OR_REMOTE_CHANGE, $to_local_transition: ident, $to_remote_transition: ident, $msg: ty) => {
 		define_state_machine_transitions!($to_local_transition, $msg, [
-			FROM RemoteChange, TO LocalChange,
-			FROM RemoteTxComplete, TO LocalChange
+			FROM ReceivedChange, TO SentChange,
+			FROM ReceivedTxComplete, TO SentChange
 		]);
 		define_state_machine_transitions!($to_remote_transition, $msg, [
-			FROM LocalChange, TO RemoteChange,
-			FROM LocalTxComplete, TO RemoteChange
+			FROM SentChange, TO ReceivedChange,
+			FROM SentTxComplete, TO ReceivedChange
 		]);
 	};
 }
@@ -573,43 +573,43 @@ impl StateMachine {
 			to_remote_value,
 		};
 		if is_initiator {
-			Self::RemoteChange(RemoteChange(context))
+			Self::ReceivedChange(ReceivedChange(context))
 		} else {
-			Self::LocalChange(LocalChange(context))
+			Self::SentChange(SentChange(context))
 		}
 	}
 
 	define_state_machine_transitions!(
 		LOCAL_OR_REMOTE_CHANGE,
-		local_tx_add_input,
-		remote_tx_add_input,
+		sent_tx_add_input,
+		received_tx_add_input,
 		&msgs::TxAddInput
 	);
 	define_state_machine_transitions!(
 		LOCAL_OR_REMOTE_CHANGE,
-		local_tx_add_output,
-		remote_tx_add_output,
+		sent_tx_add_output,
+		received_tx_add_output,
 		&msgs::TxAddOutput
 	);
 	define_state_machine_transitions!(
 		LOCAL_OR_REMOTE_CHANGE,
-		local_tx_remove_input,
-		remote_tx_remove_input,
+		sent_tx_remove_input,
+		received_tx_remove_input,
 		&msgs::TxRemoveInput
 	);
 	define_state_machine_transitions!(
 		LOCAL_OR_REMOTE_CHANGE,
-		local_tx_remove_output,
-		remote_tx_remove_output,
+		sent_tx_remove_output,
+		received_tx_remove_output,
 		&msgs::TxRemoveOutput
 	);
-	define_state_machine_transitions!(local_tx_complete, &msgs::TxComplete, [
-		FROM RemoteChange, TO LocalTxComplete,
-		FROM RemoteTxComplete, TO NegotiationComplete
+	define_state_machine_transitions!(sent_tx_complete, &msgs::TxComplete, [
+		FROM ReceivedChange, TO SentTxComplete,
+		FROM ReceivedTxComplete, TO NegotiationComplete
 	]);
-	define_state_machine_transitions!(remote_tx_complete, &msgs::TxComplete, [
-		FROM LocalChange, TO RemoteTxComplete,
-		FROM LocalTxComplete, TO NegotiationComplete
+	define_state_machine_transitions!(received_tx_complete, &msgs::TxComplete, [
+		FROM SentChange, TO ReceivedTxComplete,
+		FROM SentTxComplete, TO NegotiationComplete
 	]);
 }
 
@@ -711,7 +711,7 @@ impl InteractiveTxConstructor {
 				prevtx_out: input.previous_output.vout,
 				sequence: input.sequence.to_consensus_u32(),
 			};
-			let _ = do_state_transition!(self, local_tx_add_input, &msg)?;
+			let _ = do_state_transition!(self, sent_tx_add_input, &msg)?;
 			Ok(InteractiveTxMessageSend::TxAddInput(msg))
 		} else if let Some((serial_id, output)) = self.outputs_to_contribute.pop() {
 			let msg = msgs::TxAddOutput {
@@ -720,53 +720,53 @@ impl InteractiveTxConstructor {
 				sats: output.value,
 				script: output.script_pubkey,
 			};
-			let _ = do_state_transition!(self, local_tx_add_output, &msg)?;
+			let _ = do_state_transition!(self, sent_tx_add_output, &msg)?;
 			Ok(InteractiveTxMessageSend::TxAddOutput(msg))
 		} else {
 			let msg = msgs::TxComplete { channel_id: self.channel_id };
-			let _ = do_state_transition!(self, local_tx_complete, &msg)?;
+			let _ = do_state_transition!(self, sent_tx_complete, &msg)?;
 			Ok(InteractiveTxMessageSend::TxComplete(msg))
 		}
 	}
 
 	pub fn handle_tx_add_input(
 		&mut self, msg: &msgs::TxAddInput,
 	) -> Result<InteractiveTxMessageSend, AbortReason> {
-		let _ = do_state_transition!(self, remote_tx_add_input, msg)?;
+		let _ = do_state_transition!(self, received_tx_add_input, msg)?;
 		self.do_local_state_transition()
 	}
 
 	pub fn handle_tx_remove_input(
 		&mut self, msg: &msgs::TxRemoveInput,
 	) -> Result<InteractiveTxMessageSend, AbortReason> {
-		let _ = do_state_transition!(self, remote_tx_remove_input, msg)?;
+		let _ = do_state_transition!(self, received_tx_remove_input, msg)?;
 		self.do_local_state_transition()
 	}
 
 	pub fn handle_tx_add_output(
 		&mut self, msg: &msgs::TxAddOutput,
 	) -> Result<InteractiveTxMessageSend, AbortReason> {
-		let _ = do_state_transition!(self, remote_tx_add_output, msg)?;
+		let _ = do_state_transition!(self, received_tx_add_output, msg)?;
 		self.do_local_state_transition()
 	}
 
 	pub fn handle_tx_remove_output(
 		&mut self, msg: &msgs::TxRemoveOutput,
 	) -> Result<InteractiveTxMessageSend, AbortReason> {
-		let _ = do_state_transition!(self, remote_tx_remove_output, msg)?;
+		let _ = do_state_transition!(self, received_tx_remove_output, msg)?;
 		self.do_local_state_transition()
 	}
 
 	pub fn handle_tx_complete(
 		&mut self, msg: &msgs::TxComplete,
 	) -> Result<(Option<InteractiveTxMessageSend>, Option<Transaction>), AbortReason> {
-		let _ = do_state_transition!(self, remote_tx_complete, msg)?;
+		let _ = do_state_transition!(self, received_tx_complete, msg)?;
 		match &self.state_machine {
-			StateMachine::RemoteTxComplete(_) => {
+			StateMachine::ReceivedTxComplete(_) => {
 				let msg_send = self.do_local_state_transition()?;
 				let negotiated_tx = match &self.state_machine {
 					StateMachine::NegotiationComplete(s) => Some(s.0.clone()),
-					StateMachine::LocalChange(_) => None, // We either had an input or output to contribute.
+					StateMachine::SentChange(_) => None, // We either had an input or output to contribute.
 					_ => {
 						debug_assert!(false, "We cannot transition to any other states after receiving `tx_complete` and responding");
 						return Err(AbortReason::InvalidStateTransition);