Add BumpTransactionEventHandler instance to node test harness

diff --git a/lightning/src/ln/functional_test_utils.rs b/lightning/src/ln/functional_test_utils.rs
index 024690d00daad73da84072674bcc2094d32df149..220557e4ca3ecfbde2ab1c7dd9a443a6787b8925 100644 (file)
--- a/lightning/src/ln/functional_test_utils.rs
+++ b/lightning/src/ln/functional_test_utils.rs
@@ -15,6 +15,7 @@ use crate::sign::EntropySource;
 use crate::chain::channelmonitor::ChannelMonitor;
 use crate::chain::transaction::OutPoint;
 use crate::events::{ClosureReason, Event, HTLCDestination, MessageSendEvent, MessageSendEventsProvider, PathFailure, PaymentPurpose, PaymentFailureReason};
 use crate::chain::channelmonitor::ChannelMonitor;
 use crate::chain::transaction::OutPoint;
 use crate::events::{ClosureReason, Event, HTLCDestination, MessageSendEvent, MessageSendEventsProvider, PathFailure, PaymentPurpose, PaymentFailureReason};

+use crate::events::bump_transaction::{BumpTransactionEventHandler, Wallet, WalletSource};

 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
 use crate::ln::channelmanager::{AChannelManager, ChainParameters, ChannelManager, ChannelManagerReadArgs, RAACommitmentOrder, PaymentSendFailure, RecipientOnionFields, PaymentId, MIN_CLTV_EXPIRY_DELTA};
 use crate::routing::gossip::{P2PGossipSync, NetworkGraph, NetworkUpdate};
 use crate::ln::{PaymentPreimage, PaymentHash, PaymentSecret};
 use crate::ln::channelmanager::{AChannelManager, ChainParameters, ChannelManager, ChannelManagerReadArgs, RAACommitmentOrder, PaymentSendFailure, RecipientOnionFields, PaymentId, MIN_CLTV_EXPIRY_DELTA};
 use crate::routing::gossip::{P2PGossipSync, NetworkGraph, NetworkUpdate};


@@ -32,13 +33,11 @@ use crate::util::ser::{ReadableArgs, Writeable};
 
 use bitcoin::blockdata::block::{Block, BlockHeader};
 use bitcoin::blockdata::transaction::{Transaction, TxOut};
 
 use bitcoin::blockdata::block::{Block, BlockHeader};
 use bitcoin::blockdata::transaction::{Transaction, TxOut};

-use bitcoin::network::constants::Network;
-

 use bitcoin::hash_types::BlockHash;
 use bitcoin::hashes::sha256::Hash as Sha256;
 use bitcoin::hashes::Hash as _;
 use bitcoin::hash_types::BlockHash;
 use bitcoin::hashes::sha256::Hash as Sha256;
 use bitcoin::hashes::Hash as _;

-
-use bitcoin::secp256k1::PublicKey;
+use bitcoin::network::constants::Network;
+use bitcoin::secp256k1::{PublicKey, SecretKey};

 
 use crate::io;
 use crate::prelude::*;
 
 use crate::io;
 use crate::prelude::*;


@@ -289,6 +288,19 @@ fn do_connect_block<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, block: Block, sk
        }
        call_claimable_balances(node);
        node.node.test_process_background_events();
        }
        call_claimable_balances(node);
        node.node.test_process_background_events();

+
+       for tx in &block.txdata {
+               for input in &tx.input {
+                       node.wallet_source.remove_utxo(input.previous_output);
+               }
+               let wallet_script = node.wallet_source.get_change_script().unwrap();
+               for (idx, output) in tx.output.iter().enumerate() {
+                       if output.script_pubkey == wallet_script {
+                               let outpoint = bitcoin::OutPoint { txid: tx.txid(), vout: idx as u32 };
+                               node.wallet_source.add_utxo(outpoint, output.value);
+                       }
+               }
+       }

 }
 
 pub fn disconnect_blocks<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, count: u32) {
 }
 
 pub fn disconnect_blocks<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, count: u32) {


@@ -375,6 +387,13 @@ pub struct Node<'a, 'b: 'a, 'c: 'b> {
        pub blocks: Arc<Mutex<Vec<(Block, u32)>>>,
        pub connect_style: Rc<RefCell<ConnectStyle>>,
        pub override_init_features: Rc<RefCell<Option<InitFeatures>>>,
        pub blocks: Arc<Mutex<Vec<(Block, u32)>>>,
        pub connect_style: Rc<RefCell<ConnectStyle>>,
        pub override_init_features: Rc<RefCell<Option<InitFeatures>>>,

+       pub wallet_source: Arc<test_utils::TestWalletSource>,
+       pub bump_tx_handler: BumpTransactionEventHandler<
+               &'c test_utils::TestBroadcaster,
+               Arc<Wallet<Arc<test_utils::TestWalletSource>, &'c test_utils::TestLogger>>,
+               &'b test_utils::TestKeysInterface,
+               &'c test_utils::TestLogger,
+       >,

 }
 impl<'a, 'b, 'c> Node<'a, 'b, 'c> {
        pub fn best_block_hash(&self) -> BlockHash {
 }
 impl<'a, 'b, 'c> Node<'a, 'b, 'c> {
        pub fn best_block_hash(&self) -> BlockHash {


@@ -2622,6 +2641,7 @@ pub fn create_network<'a, 'b: 'a, 'c: 'b>(node_count: usize, cfgs: &'b Vec<NodeC
 
        for i in 0..node_count {
                let gossip_sync = P2PGossipSync::new(cfgs[i].network_graph.as_ref(), None, cfgs[i].logger);
 
        for i in 0..node_count {
                let gossip_sync = P2PGossipSync::new(cfgs[i].network_graph.as_ref(), None, cfgs[i].logger);

+               let wallet_source = Arc::new(test_utils::TestWalletSource::new(SecretKey::from_slice(&[i as u8 + 1; 32]).unwrap()));

                nodes.push(Node{
                        chain_source: cfgs[i].chain_source, tx_broadcaster: cfgs[i].tx_broadcaster,
                        fee_estimator: cfgs[i].fee_estimator, router: &cfgs[i].router,
                nodes.push(Node{
                        chain_source: cfgs[i].chain_source, tx_broadcaster: cfgs[i].tx_broadcaster,
                        fee_estimator: cfgs[i].fee_estimator, router: &cfgs[i].router,


@@ -2632,6 +2652,11 @@ pub fn create_network<'a, 'b: 'a, 'c: 'b>(node_count: usize, cfgs: &'b Vec<NodeC
                        blocks: Arc::clone(&cfgs[i].tx_broadcaster.blocks),
                        connect_style: Rc::clone(&connect_style),
                        override_init_features: Rc::clone(&cfgs[i].override_init_features),
                        blocks: Arc::clone(&cfgs[i].tx_broadcaster.blocks),
                        connect_style: Rc::clone(&connect_style),
                        override_init_features: Rc::clone(&cfgs[i].override_init_features),

+                       wallet_source: Arc::clone(&wallet_source),
+                       bump_tx_handler: BumpTransactionEventHandler::new(
+                               cfgs[i].tx_broadcaster, Arc::new(Wallet::new(Arc::clone(&wallet_source), cfgs[i].logger)),
+                               &cfgs[i].keys_manager, cfgs[i].logger,
+                       ),

                })
        }
 
                })
        }
 

diff --git a/lightning/src/util/test_utils.rs b/lightning/src/util/test_utils.rs
index 212f1f4b60a392f6ad605fe599f200b3c543b778..bf5aa02bb41e310f92d06253487ca39d6c2ed8df 100644 (file)
--- a/lightning/src/util/test_utils.rs
+++ b/lightning/src/util/test_utils.rs
@@ -18,6 +18,7 @@ use crate::chain::channelmonitor::MonitorEvent;
 use crate::chain::transaction::OutPoint;
 use crate::sign;
 use crate::events;
 use crate::chain::transaction::OutPoint;
 use crate::sign;
 use crate::events;

+use crate::events::bump_transaction::{WalletSource, Utxo};

 use crate::ln::channelmanager;
 use crate::ln::features::{ChannelFeatures, InitFeatures, NodeFeatures};
 use crate::ln::{msgs, wire};
 use crate::ln::channelmanager;
 use crate::ln::features::{ChannelFeatures, InitFeatures, NodeFeatures};
 use crate::ln::{msgs, wire};


@@ -32,6 +33,7 @@ use crate::util::enforcing_trait_impls::{EnforcingSigner, EnforcementState};
 use crate::util::logger::{Logger, Level, Record};
 use crate::util::ser::{Readable, ReadableArgs, Writer, Writeable};
 
 use crate::util::logger::{Logger, Level, Record};
 use crate::util::ser::{Readable, ReadableArgs, Writer, Writeable};
 

+use bitcoin::EcdsaSighashType;

 use bitcoin::blockdata::constants::ChainHash;
 use bitcoin::blockdata::constants::genesis_block;
 use bitcoin::blockdata::transaction::{Transaction, TxOut};
 use bitcoin::blockdata::constants::ChainHash;
 use bitcoin::blockdata::constants::genesis_block;
 use bitcoin::blockdata::transaction::{Transaction, TxOut};


@@ -40,6 +42,7 @@ use bitcoin::blockdata::opcodes;
 use bitcoin::blockdata::block::Block;
 use bitcoin::network::constants::Network;
 use bitcoin::hash_types::{BlockHash, Txid};
 use bitcoin::blockdata::block::Block;
 use bitcoin::network::constants::Network;
 use bitcoin::hash_types::{BlockHash, Txid};

+use bitcoin::util::sighash::SighashCache;

 
 use bitcoin::secp256k1::{SecretKey, PublicKey, Secp256k1, ecdsa::Signature, Scalar};
 use bitcoin::secp256k1::ecdh::SharedSecret;
 
 use bitcoin::secp256k1::{SecretKey, PublicKey, Secp256k1, ecdsa::Signature, Scalar};
 use bitcoin::secp256k1::ecdh::SharedSecret;


@@ -1067,3 +1070,65 @@ impl Drop for TestScorer {
                }
        }
 }
                }
        }
 }

+
+pub struct TestWalletSource {
+       secret_key: SecretKey,
+       utxos: RefCell<Vec<Utxo>>,
+       secp: Secp256k1<bitcoin::secp256k1::All>,
+}
+
+impl TestWalletSource {
+       pub fn new(secret_key: SecretKey) -> Self {
+               Self {
+                       secret_key,
+                       utxos: RefCell::new(Vec::new()),
+                       secp: Secp256k1::new(),
+               }
+       }
+
+       pub fn add_utxo(&self, outpoint: bitcoin::OutPoint, value: u64) -> TxOut {
+               let public_key = bitcoin::PublicKey::new(self.secret_key.public_key(&self.secp));
+               let utxo = Utxo::new_p2pkh(outpoint, value, &public_key.pubkey_hash());
+               self.utxos.borrow_mut().push(utxo.clone());
+               utxo.output
+       }
+
+       pub fn add_custom_utxo(&self, utxo: Utxo) -> TxOut {
+               let output = utxo.output.clone();
+               self.utxos.borrow_mut().push(utxo);
+               output
+       }
+
+       pub fn remove_utxo(&self, outpoint: bitcoin::OutPoint) {
+               self.utxos.borrow_mut().retain(|utxo| utxo.outpoint != outpoint);
+       }
+}
+
+impl WalletSource for TestWalletSource {
+    fn list_confirmed_utxos(&self) -> Result<Vec<Utxo>, ()> {
+               Ok(self.utxos.borrow().clone())
+    }
+
+    fn get_change_script(&self) -> Result<Script, ()> {
+               let public_key = bitcoin::PublicKey::new(self.secret_key.public_key(&self.secp));
+               Ok(Script::new_p2pkh(&public_key.pubkey_hash()))
+    }
+
+    fn sign_tx(&self, tx: &mut Transaction) -> Result<(), ()> {
+               let utxos = self.utxos.borrow();
+               for i in 0..tx.input.len() {
+                       if let Some(utxo) = utxos.iter().find(|utxo| utxo.outpoint == tx.input[i].previous_output) {
+                               let sighash = SighashCache::new(&*tx)
+                                       .legacy_signature_hash(i, &utxo.output.script_pubkey, EcdsaSighashType::All as u32)
+                                       .map_err(|_| ())?;
+                               let sig = self.secp.sign_ecdsa(&sighash.as_hash().into(), &self.secret_key);
+                               let bitcoin_sig = bitcoin::EcdsaSig { sig, hash_ty: EcdsaSighashType::All }.to_vec();
+                               tx.input[i].script_sig = Builder::new()
+                                       .push_slice(&bitcoin_sig)
+                                       .push_slice(&self.secret_key.public_key(&self.secp).serialize())
+                                       .into_script();
+                       }
+               }
+               Ok(())
+    }
+}