Implement WalletKeysManager

This implementation of `KeysInterface` allows to override the
shutdown/destination scripts and forwards any other calls to an inner
instance of `KeysManager` otherwise.

Author: tnull

src/wallet.rs

@@ -1,18 +1,29 @@
 use crate::logger::{
 	log_error, log_given_level, log_internal, log_trace, FilesystemLogger, Logger,
 };
+
 use crate::Error;
 
 use lightning::chain::chaininterface::{
 	BroadcasterInterface, ConfirmationTarget, FeeEstimator, FEERATE_FLOOR_SATS_PER_KW,
 };
 
+use lightning::chain::keysinterface::{
+	InMemorySigner, KeyMaterial, KeysInterface, KeysManager, Recipient, SpendableOutputDescriptor,
+};
+use lightning::ln::msgs::DecodeError;
+use lightning::ln::script::ShutdownScript;
+
 use bdk::blockchain::{Blockchain, EsploraBlockchain};
 use bdk::database::BatchDatabase;
 use bdk::wallet::AddressIndex;
 use bdk::{FeeRate, SignOptions, SyncOptions};
 
-use bitcoin::{Script, Transaction};
+use bitcoin::bech32::u5;
+use bitcoin::secp256k1::ecdh::SharedSecret;
+use bitcoin::secp256k1::ecdsa::RecoverableSignature;
+use bitcoin::secp256k1::{PublicKey, Scalar, Secp256k1, SecretKey, Signing};
+use bitcoin::{Script, Transaction, TxOut};
 
 use std::collections::HashMap;
 use std::sync::{Arc, Mutex, RwLock};
@@ -105,6 +116,11 @@ where
 		Ok(address_info.address)
 	}
 
+	#[cfg(any(test))]
+	pub(crate) fn get_balance(&self) -> Result<bdk::Balance, Error> {
+		Ok(self.wallet.lock().unwrap().get_balance()?)
+	}
+
 	fn estimate_fee_rate(&self, confirmation_target: ConfirmationTarget) -> FeeRate {
 		let mut locked_fee_rate_cache = self.fee_rate_cache.lock().unwrap();
 		let num_blocks = num_blocks_from_conf_target(confirmation_target);
@@ -199,3 +215,124 @@ fn fallback_fee_from_conf_target(confirmation_target: ConfirmationTarget) -> Fee
 
 	FeeRate::from_sat_per_kwu(sats_kwu as f32)
 }
+
+/// Similar to [`KeysManager`], but overrides the destination and shutdown scripts so they are
+/// directly spendable by the BDK wallet.
+pub struct WalletKeysManager<D>
+where
+	D: BatchDatabase,
+{
+	inner: KeysManager,
+	wallet: Arc<Wallet<D>>,
+}
+
+impl<D> WalletKeysManager<D>
+where
+	D: BatchDatabase,
+{
+	/// Constructs a `WalletKeysManager` that
+	///
+	/// See [`KeysManager::new`] for more information on `seed`, `starting_time_secs`, and
+	/// `starting_time_nanos`.
+	pub fn new(
+		seed: &[u8; 32], starting_time_secs: u64, starting_time_nanos: u32, wallet: Arc<Wallet<D>>,
+	) -> Self {
+		let inner = KeysManager::new(seed, starting_time_secs, starting_time_nanos);
+		Self { inner, wallet }
+	}
+
+	/// See [`KeysManager::spend_spendable_outputs`] for documentation on this method.
+	pub fn spend_spendable_outputs<C: Signing>(
+		&self, descriptors: &[&SpendableOutputDescriptor], outputs: Vec<TxOut>,
+		change_destination_script: Script, feerate_sat_per_1000_weight: u32,
+		secp_ctx: &Secp256k1<C>,
+	) -> Result<Transaction, ()> {
+		let only_non_static = &descriptors
+			.iter()
+			.filter(|desc| {
+				if let SpendableOutputDescriptor::StaticOutput { .. } = desc {
+					false
+				} else {
+					true
+				}
+			})
+			.cloned()
+			.collect::<Vec<_>>();
+		self.inner.spend_spendable_outputs(
+			only_non_static,
+			outputs,
+			change_destination_script,
+			feerate_sat_per_1000_weight,
+			secp_ctx,
+		)
+	}
+}
+
+impl<D> KeysInterface for WalletKeysManager<D>
+where
+	D: BatchDatabase,
+{
+	type Signer = InMemorySigner;
+
+	fn get_node_secret(&self, recipient: Recipient) -> Result<SecretKey, ()> {
+		self.inner.get_node_secret(recipient)
+	}
+
+	fn get_node_id(&self, recipient: Recipient) -> Result<PublicKey, ()> {
+		self.inner.get_node_id(recipient)
+	}
+
+	fn ecdh(
+		&self, recipient: Recipient, other_key: &PublicKey, tweak: Option<&Scalar>,
+	) -> Result<SharedSecret, ()> {
+		self.inner.ecdh(recipient, other_key, tweak)
+	}
+
+	fn get_inbound_payment_key_material(&self) -> KeyMaterial {
+		self.inner.get_inbound_payment_key_material()
+	}
+
+	fn get_destination_script(&self) -> Script {
+		let address =
+			self.wallet.get_new_address().expect("Failed to retrieve new address from wallet.");
+		address.script_pubkey()
+	}
+
+	fn get_shutdown_scriptpubkey(&self) -> ShutdownScript {
+		let address =
+			self.wallet.get_new_address().expect("Failed to retrieve new address from wallet.");
+		match address.payload {
+			bitcoin::util::address::Payload::WitnessProgram { version, program } => {
+				return ShutdownScript::new_witness_program(version, &program)
+					.expect("Invalid shutdown script.");
+			}
+			_ => panic!("Tried to use a non-witness address. This must not ever happen."),
+		}
+	}
+
+	fn generate_channel_keys_id(
+		&self, inbound: bool, channel_value_satoshis: u64, user_channel_id: u128,
+	) -> [u8; 32] {
+		self.inner.generate_channel_keys_id(inbound, channel_value_satoshis, user_channel_id)
+	}
+
+	fn derive_channel_signer(
+		&self, channel_value_satoshis: u64, channel_keys_id: [u8; 32],
+	) -> Self::Signer {
+		self.inner.derive_channel_signer(channel_value_satoshis, channel_keys_id)
+	}
+
+	fn get_secure_random_bytes(&self) -> [u8; 32] {
+		self.inner.get_secure_random_bytes()
+	}
+
+	fn read_chan_signer(&self, reader: &[u8]) -> Result<Self::Signer, DecodeError> {
+		self.inner.read_chan_signer(reader)
+	}
+
+	fn sign_invoice(
+		&self, hrp_bytes: &[u8], invoice_data: &[u5], recipient: Recipient,
+	) -> Result<RecoverableSignature, ()> {
+		self.inner.sign_invoice(hrp_bytes, invoice_data, recipient)
+	}
+}