Add HolderCommitmentPoint::Uninitialized

Author: alecchendev

lightning/src/ln/channel.rs

@@ -935,19 +935,14 @@ pub(crate) struct ShutdownResult {
 
 #[derive(Debug, Copy, Clone)]
 enum HolderCommitmentPoint {
+	Uninitialized { transaction_number: u64 },
 	PendingNext { transaction_number: u64, current: PublicKey },
 	Available { transaction_number: u64, current: PublicKey, next: PublicKey },
 }
 
-impl HolderCommitmentPoint {
-	pub fn new<SP: Deref>(signer: &ChannelSignerType<SP>, secp_ctx: &Secp256k1<secp256k1::All>) -> Self
-		where SP::Target: SignerProvider
-	{
-		HolderCommitmentPoint::Available {
-			transaction_number: INITIAL_COMMITMENT_NUMBER,
-			current: signer.as_ref().get_per_commitment_point(INITIAL_COMMITMENT_NUMBER, secp_ctx),
-			next: signer.as_ref().get_per_commitment_point(INITIAL_COMMITMENT_NUMBER - 1, secp_ctx),
-		}
+impl HolderCommitmentPoint where {
+	pub fn new() -> Self {
+		HolderCommitmentPoint::Uninitialized { transaction_number: INITIAL_COMMITMENT_NUMBER }
 	}
 
 	pub fn is_available(&self) -> bool {
@@ -956,20 +951,23 @@ impl HolderCommitmentPoint {
 
 	pub fn transaction_number(&self) -> u64 {
 		match self {
+			HolderCommitmentPoint::Uninitialized { transaction_number } => *transaction_number,
 			HolderCommitmentPoint::PendingNext { transaction_number, .. } => *transaction_number,
 			HolderCommitmentPoint::Available { transaction_number, .. } => *transaction_number,
 		}
 	}
 
-	pub fn current_point(&self) -> PublicKey {
+	pub fn current_point(&self) -> Option<PublicKey> {
 		match self {
-			HolderCommitmentPoint::PendingNext { current, .. } => *current,
-			HolderCommitmentPoint::Available { current, .. } => *current,
+			HolderCommitmentPoint::Uninitialized { .. } => None,
+			HolderCommitmentPoint::PendingNext { current, .. } => Some(*current),
+			HolderCommitmentPoint::Available { current, .. } => Some(*current),
 		}
 	}
 
 	pub fn next_point(&self) -> Option<PublicKey> {
 		match self {
+			HolderCommitmentPoint::Uninitialized { .. } => None,
 			HolderCommitmentPoint::PendingNext { .. } => None,
 			HolderCommitmentPoint::Available { next, .. } => Some(*next),
 		}
@@ -978,6 +976,13 @@ impl HolderCommitmentPoint {
 	pub fn advance<SP: Deref, L: Deref>(&mut self, signer: &ChannelSignerType<SP>, secp_ctx: &Secp256k1<secp256k1::All>, logger: &L)
 		where SP::Target: SignerProvider, L::Target: Logger
 	{
+		if let HolderCommitmentPoint::Uninitialized { transaction_number } = self {
+			let current = signer.as_ref().get_per_commitment_point(*transaction_number, secp_ctx); // TODO
+			log_trace!(logger, "Retrieved current per-commitment point {}", transaction_number);
+			*self = HolderCommitmentPoint::PendingNext { transaction_number: *transaction_number, current };
+			// TODO: handle error case when get_per_commitment_point becomes async
+		}
+
 		if let HolderCommitmentPoint::Available { transaction_number, next, .. } = self {
 			*self = HolderCommitmentPoint::PendingNext {
 				transaction_number: *transaction_number - 1,
@@ -986,9 +991,10 @@ impl HolderCommitmentPoint {
 		}
 
 		if let HolderCommitmentPoint::PendingNext { transaction_number, current } = self {
-			let next = signer.as_ref().get_per_commitment_point(*transaction_number - 1, secp_ctx);
+			let next = signer.as_ref().get_per_commitment_point(*transaction_number - 1, secp_ctx); // TODO
 			log_trace!(logger, "Retrieved next per-commitment point {}", *transaction_number - 1);
 			*self = HolderCommitmentPoint::Available { transaction_number: *transaction_number, current: *current, next };
+			// TODO: handle error case when get_per_commitment_point becomes async
 		}
 	}
 }
@@ -1614,7 +1620,8 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider  {
 		let value_to_self_msat = our_funding_satoshis * 1000 + msg_push_msat;
 
 		let holder_signer = ChannelSignerType::Ecdsa(holder_signer);
-		let holder_commitment_point = HolderCommitmentPoint::new(&holder_signer, &secp_ctx);
+		let mut holder_commitment_point = HolderCommitmentPoint::new();
+		holder_commitment_point.advance(&holder_signer, &secp_ctx, &&logger);
 
 		// TODO(dual_funding): Checks for `funding_feerate_sat_per_1000_weight`?
 
@@ -1843,7 +1850,8 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider  {
 		let temporary_channel_id = temporary_channel_id.unwrap_or_else(|| ChannelId::temporary_from_entropy_source(entropy_source));
 
 		let holder_signer = ChannelSignerType::Ecdsa(holder_signer);
-		let holder_commitment_point = HolderCommitmentPoint::new(&holder_signer, &secp_ctx);
+		let mut holder_commitment_point = HolderCommitmentPoint::new();
+		holder_commitment_point.advance(&holder_signer, &secp_ctx, logger);
 
 		Ok(Self {
 			user_id,
@@ -2567,7 +2575,8 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider  {
 	/// The result is a transaction which we can revoke broadcastership of (ie a "local" transaction)
 	/// TODO Some magic rust shit to compile-time check this?
 	fn build_holder_transaction_keys(&self) -> TxCreationKeys {
-		let per_commitment_point = self.holder_commitment_point.current_point();
+		let per_commitment_point = self.holder_commitment_point.current_point()
+			.expect("Should not build commitment transaction before retrieving first commitment point");
 		let delayed_payment_base = &self.get_holder_pubkeys().delayed_payment_basepoint;
 		let htlc_basepoint = &self.get_holder_pubkeys().htlc_basepoint;
 		let counterparty_pubkeys = self.get_counterparty_pubkeys();
@@ -5227,7 +5236,8 @@ impl<SP: Deref> Channel<SP> where
 		debug_assert!(self.context.holder_commitment_point.transaction_number() <= INITIAL_COMMITMENT_NUMBER + 2);
 		// TODO: handle non-available case when get_per_commitment_point becomes async
 		debug_assert!(self.context.holder_commitment_point.is_available());
-		let next_per_commitment_point = self.context.holder_commitment_point.current_point();
+		let next_per_commitment_point = self.context.holder_commitment_point.current_point()
+			.expect("TODO");
 		let per_commitment_secret = self.context.holder_signer.as_ref().release_commitment_secret(self.context.holder_commitment_point.transaction_number() + 2);
 		msgs::RevokeAndACK {
 			channel_id: self.context.channel_id,
@@ -6369,7 +6379,8 @@ impl<SP: Deref> Channel<SP> where
 		debug_assert!(self.context.holder_commitment_point.is_available());
 		msgs::ChannelReady {
 			channel_id: self.context.channel_id(),
-			next_per_commitment_point: self.context.holder_commitment_point.current_point(),
+			next_per_commitment_point: self.context.holder_commitment_point.current_point()
+				.expect("TODO"),
 			short_channel_id_alias: Some(self.context.outbound_scid_alias),
 		}
 	}
@@ -7432,7 +7443,7 @@ impl<SP: Deref> OutboundV1Channel<SP> where SP::Target: SignerProvider {
 		}
 
 		debug_assert!(self.context.holder_commitment_point.is_available());
-		let first_per_commitment_point = self.context.holder_commitment_point.current_point();
+		let first_per_commitment_point = self.context.holder_commitment_point.current_point().expect("TODO");
 		let keys = self.context.get_holder_pubkeys();
 
 		msgs::OpenChannel {
@@ -7831,7 +7842,7 @@ impl<SP: Deref> InboundV1Channel<SP> where SP::Target: SignerProvider {
 	/// [`msgs::AcceptChannel`]: crate::ln::msgs::AcceptChannel
 	fn generate_accept_channel_message(&self) -> msgs::AcceptChannel {
 		debug_assert!(self.context.holder_commitment_point.is_available());
-		let first_per_commitment_point = self.context.holder_commitment_point.current_point();
+		let first_per_commitment_point = self.context.holder_commitment_point.current_point().expect("TODO");
 		let keys = self.context.get_holder_pubkeys();
 
 		msgs::AcceptChannel {
@@ -8676,8 +8687,7 @@ impl<SP: Deref> Writeable for Channel<SP> where SP::Target: SignerProvider {
 			monitor_pending_update_adds = Some(&self.context.monitor_pending_update_adds);
 		}
 
-		// `current_point` will become optional when async signing is implemented.
-		let cur_holder_commitment_point = Some(self.context.holder_commitment_point.current_point());
+		let cur_holder_commitment_point = self.context.holder_commitment_point.current_point();
 		let next_holder_commitment_point = self.context.holder_commitment_point.next_point();
 
 		write_tlv_fields!(writer, {
@@ -9181,15 +9191,12 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, u32, &'c Ch
 			(Some(current), Some(next)) => HolderCommitmentPoint::Available {
 				transaction_number: cur_holder_commitment_transaction_number, current, next
 			},
-			(Some(current), _) => HolderCommitmentPoint::Available {
-				transaction_number: cur_holder_commitment_transaction_number, current,
-				next: holder_signer.get_per_commitment_point(cur_holder_commitment_transaction_number - 1, &secp_ctx),
-			},
-			(_, _) => HolderCommitmentPoint::Available {
-				transaction_number: cur_holder_commitment_transaction_number,
-				current: holder_signer.get_per_commitment_point(cur_holder_commitment_transaction_number, &secp_ctx),
-				next: holder_signer.get_per_commitment_point(cur_holder_commitment_transaction_number - 1, &secp_ctx),
+			(Some(current), _) => HolderCommitmentPoint::PendingNext {
+				transaction_number: cur_holder_commitment_transaction_number, current
 			},
+			(_, _) => HolderCommitmentPoint::Uninitialized {
+				transaction_number: cur_holder_commitment_transaction_number
+			}
 		};
 
 		Ok(Channel {