channelmonitor: Create new_stub so that channels can be stubbed to recover from peer storage.

Author: Aditya Sharma

lightning/src/chain/channelmonitor.rs

@@ -34,11 +34,12 @@ use bitcoin::secp256k1;
 use bitcoin::sighash::EcdsaSighashType;
 
 use crate::ln::channel::INITIAL_COMMITMENT_NUMBER;
+use crate::ln::features::Features;
 use crate::ln::{PaymentHash, PaymentPreimage, ChannelId};
 use crate::ln::msgs::DecodeError;
 use crate::ln::channel_keys::{DelayedPaymentKey, DelayedPaymentBasepoint, HtlcBasepoint, HtlcKey, RevocationKey, RevocationBasepoint};
 use crate::ln::chan_utils::{self,CommitmentTransaction, CounterpartyCommitmentSecrets, HTLCOutputInCommitment, HTLCClaim, ChannelTransactionParameters, HolderCommitmentTransaction, TxCreationKeys};
-use crate::ln::channelmanager::{HTLCSource, SentHTLCId};
+use crate::ln::channelmanager::{HTLCSource, SentHTLCId, StubChannel};
 use crate::chain;
 use crate::chain::{BestBlock, WatchedOutput};
 use crate::chain::chaininterface::{BroadcasterInterface, FeeEstimator, LowerBoundedFeeEstimator};
@@ -1340,6 +1341,102 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 		})
 	}
 
+	pub(crate) fn new_stub(secp_ctx: Secp256k1<secp256k1::All>, stub_channel: &StubChannel, best_block: BestBlock, keys: Signer) -> ChannelMonitor<Signer> {
+		let mut outputs_to_watch = new_hash_map();
+		outputs_to_watch.insert(stub_channel.funding_outpoint.get_txid(), vec![(stub_channel.funding_outpoint.index as u32, ScriptBuf::new())]);
+		let dummy_key = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
+		let dummy_sig = crate::crypto::utils::sign(&secp_ctx, &secp256k1::Message::from_slice(&[42; 32]).unwrap(), &SecretKey::from_slice(&[42; 32]).unwrap());
+
+		let holder_commitment_tx = HolderSignedTx {
+			txid: stub_channel.funding_outpoint.get_txid(),
+			revocation_key: RevocationKey(PublicKey::from_slice(&[0;32]).unwrap()),
+			a_htlc_key: HtlcKey(PublicKey::from_slice(&[0;32]).unwrap()),
+			b_htlc_key: HtlcKey(PublicKey::from_slice(&[0;32]).unwrap()),
+			delayed_payment_key: DelayedPaymentKey(PublicKey::from_slice(&[0;32]).unwrap()),
+			per_commitment_point: PublicKey::from_slice(&[0;32]).unwrap(),
+			htlc_outputs: Vec::new(), // There are never any HTLCs in the initial commitment transactions
+			to_self_value_sat: 0,
+			feerate_per_kw: 1,
+		};
+
+		let channel_parameters = ChannelTransactionParameters{
+			holder_pubkeys:keys.pubkeys().clone(),
+			is_outbound_from_holder: true,
+			holder_selected_contest_delay: 66,
+			counterparty_parameters: None,
+			funding_outpoint: Some(stub_channel.funding_outpoint),
+			channel_type_features: Features::only_static_remote_key(),
+		};
+
+		let dummy_tx_creation_keys = TxCreationKeys {
+			per_commitment_point: dummy_key.clone(),
+			revocation_key: RevocationKey::from_basepoint(&secp_ctx, &RevocationBasepoint::from(dummy_key), &dummy_key),
+			broadcaster_htlc_key: HtlcKey::from_basepoint(&secp_ctx, &HtlcBasepoint::from(dummy_key), &dummy_key),
+			countersignatory_htlc_key: HtlcKey::from_basepoint(&secp_ctx, &HtlcBasepoint::from(dummy_key), &dummy_key),
+			broadcaster_delayed_payment_key: DelayedPaymentKey::from_basepoint(&secp_ctx, &DelayedPaymentBasepoint::from(dummy_key), &dummy_key),
+		};
+		let mut counterparty_htlc_sigs = Vec::new();
+		let mut nondust_htlcs: Vec<(HTLCOutputInCommitment, Option<Box<HTLCSource>>)> = Vec::new();
+		let inner = CommitmentTransaction::new_with_auxiliary_htlc_data(0, 0, 0, dummy_key.clone(), dummy_key.clone(), dummy_tx_creation_keys, 0, &mut nondust_htlcs, &channel_parameters.as_counterparty_broadcastable());
+		let holder_commitment = HolderCommitmentTransaction::new(inner, dummy_sig, counterparty_htlc_sigs, &dummy_key, &PublicKey::from_slice(&[0;32]).unwrap());
+
+		let onchain_tx_handler = OnchainTxHandler::new(
+			1000, stub_channel.channel_keys_id, ScriptBuf::new(), keys,
+			channel_parameters, holder_commitment, secp_ctx
+		);
+
+		Self::from_impl(ChannelMonitorImpl{
+			latest_update_id: 0,
+			commitment_transaction_number_obscure_factor: core::u64::MAX,
+			destination_script: ScriptBuf::new(),
+			broadcasted_holder_revokable_script: None,
+			counterparty_payment_script: ScriptBuf::new(),
+			shutdown_script: None,
+			channel_keys_id: stub_channel.channel_keys_id,
+			holder_revocation_basepoint: RevocationBasepoint(PublicKey::from_slice(&[0;32]).unwrap()),
+			channel_id: stub_channel.channel_id,
+			funding_info: (stub_channel.funding_outpoint, ScriptBuf::new()),
+			current_counterparty_commitment_txid: None,
+			prev_counterparty_commitment_txid: None,
+			counterparty_commitment_params: CounterpartyCommitmentParameters {
+				counterparty_delayed_payment_base_key: DelayedPaymentBasepoint(PublicKey::from_slice(&[0;32]).unwrap()),
+				counterparty_htlc_base_key: HtlcBasepoint(PublicKey::from_slice(&[0;32]).unwrap()),
+				on_counterparty_tx_csv: 0,
+			},
+			funding_redeemscript: ScriptBuf::new(),
+			channel_value_satoshis: 0,
+			their_cur_per_commitment_points: None,
+			on_holder_tx_csv: 1,
+			commitment_secrets: stub_channel.commitment_secrets.clone(),
+			counterparty_claimable_outpoints: new_hash_map(),
+			counterparty_hash_commitment_number: new_hash_map(),
+			counterparty_commitment_txn_on_chain: new_hash_map(),
+			counterparty_fulfilled_htlcs: new_hash_map(),
+			prev_holder_signed_commitment_tx: None,
+			current_holder_commitment_tx: holder_commitment_tx,
+			current_counterparty_commitment_number: 1 << 48,
+			current_holder_commitment_number: 1,
+			payment_preimages: new_hash_map(),
+			peer_storage: Vec::new(),
+			pending_monitor_events: Vec::new(),
+			pending_events: Vec::new(),
+			is_processing_pending_events: false,
+			onchain_events_awaiting_threshold_conf: Vec::new(),
+			outputs_to_watch,
+			onchain_tx_handler,
+			lockdown_from_offchain: false,
+			holder_tx_signed: false,
+			funding_spend_seen: false,
+			funding_spend_confirmed: None,
+			confirmed_commitment_tx_counterparty_output: None,
+			htlcs_resolved_on_chain: Vec::new(),
+			spendable_txids_confirmed: Vec::new(),
+			best_block,
+			counterparty_node_id: Some(stub_channel.counterparty_node_id),
+			initial_counterparty_commitment_info: None,
+		})
+	}
+
 	#[cfg(test)]
 	fn provide_secret(&self, idx: u64, secret: [u8; 32]) -> Result<(), &'static str> {
 		self.inner.lock().unwrap().provide_secret(idx, secret)