Allow pushing some msats on channel open

Author: tnull

README.md

@@ -26,7 +26,7 @@ fn main() {
 
 	node.sync_wallets().unwrap();
 
-	node.connect_open_channel("NODE_ID@PEER_ADDR:PORT", 10000, false).unwrap();
+	node.connect_open_channel("NODE_ID@PEER_ADDR:PORT", 10000, None, false).unwrap();
 
 	let invoice = Invoice::from_str("INVOICE_STR").unwrap();
 	node.send_payment(invoice).unwrap();

src/lib.rs

@@ -44,7 +44,7 @@
 //!
 //! 	node.sync_wallets().unwrap();
 //!
-//! 	node.connect_open_channel("NODE_ID@PEER_ADDR:PORT", 10000, false).unwrap();
+//! 	node.connect_open_channel("NODE_ID@PEER_ADDR:PORT", 10000, None, false).unwrap();
 //!
 //! 	let invoice = Invoice::from_str("INVOICE_STR").unwrap();
 //! 	node.send_payment(invoice).unwrap();
@@ -841,11 +841,18 @@ impl Node {
 		self.channel_manager.list_channels()
 	}
 
-	/// Connect to a node and open a new channel. Disconnects and re-connects are handled automatically
+	/// Connect to a node and opens a new channel.
 	///
-	/// Returns a temporary channel id
+	/// Disconnects and reconnects are handled automatically.
+	///
+	/// If `push_to_counterparty_msat` is set, the given value will be pushed (read: sent) to the
+	/// channel counterparty on channel open. This can be useful to start out with the balance not
+	/// entirely shifted to one side, therefore allowing to receive payments from the getgo.
+	///
+	/// Returns a temporary channel id.
 	pub fn connect_open_channel(
-		&self, node_pubkey_and_address: &str, channel_amount_sats: u64, announce_channel: bool,
+		&self, node_pubkey_and_address: &str, channel_amount_sats: u64,
+		push_to_counterparty_msat: Option<u64>, announce_channel: bool,
 	) -> Result<(), Error> {
 		let runtime_lock = self.running.read().unwrap();
 		if runtime_lock.is_none() {
@@ -895,12 +902,13 @@ impl Node {
 			..Default::default()
 		};
 
+		let push_msat = push_to_counterparty_msat.unwrap_or(0);
 		let user_channel_id: u128 = rand::thread_rng().gen::<u128>();
 
 		match self.channel_manager.create_channel(
 			peer_info.pubkey,
 			channel_amount_sats,
-			0,
+			push_msat,
 			user_channel_id,
 			Some(user_config),
 		) {

src/test/functional_tests.rs

@@ -34,14 +34,15 @@ fn channel_full_cycle() {
 
 	println!("\nA -- connect_open_channel -> B");
 	let node_b_addr = format!("{}@{}", node_b.node_id(), node_b.listening_address().unwrap());
-	node_a.connect_open_channel(&node_b_addr, 50000, true).unwrap();
+	node_a.connect_open_channel(&node_b_addr, 80_000, Some(40_000 * 1000), true).unwrap();
 
 	let funding_txo = loop {
 		let details = node_a.list_channels();
 
 		if details.is_empty() || details[0].funding_txo.is_none() {
 			std::thread::sleep(Duration::from_secs(1));
 		} else {
+			assert_eq!(details[0].inbound_capacity_msat, 39000000);
 			break details[0].funding_txo.unwrap();
 		}
 	};
@@ -54,8 +55,8 @@ fn channel_full_cycle() {
 	node_b.sync_wallets().unwrap();
 
 	let node_a_balance = node_a.on_chain_balance().unwrap();
-	assert!(node_a_balance.get_spendable() < 50000);
-	assert!(node_a_balance.get_spendable() > 40000);
+	assert!(node_a_balance.get_spendable() < 20000);
+	assert!(node_a_balance.get_spendable() > 15000);
 	assert_eq!(node_b.on_chain_balance().unwrap().get_spendable(), 100000);
 
 	expect_event!(node_a, ChannelReady);
@@ -174,8 +175,8 @@ fn channel_full_cycle() {
 	node_a.sync_wallets().unwrap();
 	node_b.sync_wallets().unwrap();
 
-	assert!(node_a.on_chain_balance().unwrap().get_spendable() > 90000);
-	assert_eq!(node_b.on_chain_balance().unwrap().get_spendable(), 103234);
+	assert!(node_a.on_chain_balance().unwrap().get_spendable() > 50000);
+	assert_eq!(node_b.on_chain_balance().unwrap().get_spendable(), 143234);
 
 	node_a.stop().unwrap();
 	println!("\nA stopped");
@@ -214,7 +215,7 @@ fn channel_open_fails_when_funds_insufficient() {
 	let node_b_addr = format!("{}@{}", node_b.node_id(), node_b.listening_address().unwrap());
 	assert_eq!(
 		Err(Error::InsufficientFunds),
-		node_a.connect_open_channel(&node_b_addr, 120000, true)
+		node_a.connect_open_channel(&node_b_addr, 120000, None, true)
 	);
 }