Drop Node::onchain_balance from public API

We already have `Node::spendable_onchain_balance` and
`Node::total_onchain_balance` exposed, so the general `onchain_balance`
is kind of redudant. As it is also not exposed (and not easily
exposable) in bindings, we can make the bindings and Rust APIs more
homogeneous by dropping the call.

Plus, we probably should avoid exposing any BDK types in the public API
until BDK 1.0 landed and we made the switch, as many breaking changes
will be coming with it.

Author: tnull

src/lib.rs

@@ -1145,9 +1145,14 @@ impl<K: KVStore + Sync + Send + 'static> Node<K> {
 		Ok(funding_address)
 	}
 
-	/// Retrieve the current on-chain balance.
-	pub fn onchain_balance(&self) -> Result<bdk::Balance, Error> {
-		self.wallet.get_balance()
+	/// Retrieve the currently spendable on-chain balance in satoshis.
+	pub fn spendable_onchain_balance_sats(&self) -> Result<u64, Error> {
+		Ok(self.wallet.get_balance().map(|bal| bal.get_spendable())?)
+	}
+
+	/// Retrieve the current total on-chain balance in satoshis.
+	pub fn total_onchain_balance_sats(&self) -> Result<u64, Error> {
+		Ok(self.wallet.get_balance().map(|bal| bal.get_total())?)
 	}
 
 	/// Send an on-chain payment to the given address.
@@ -1177,16 +1182,6 @@ impl<K: KVStore + Sync + Send + 'static> Node<K> {
 		self.wallet.send_to_address(address, None)
 	}
 
-	/// Retrieve the currently spendable on-chain balance in satoshis.
-	pub fn spendable_onchain_balance_sats(&self) -> Result<u64, Error> {
-		Ok(self.wallet.get_balance().map(|bal| bal.get_spendable())?)
-	}
-
-	/// Retrieve the current total on-chain balance in satoshis.
-	pub fn total_onchain_balance_sats(&self) -> Result<u64, Error> {
-		Ok(self.wallet.get_balance().map(|bal| bal.get_total())?)
-	}
-
 	/// Retrieve a list of known channels.
 	pub fn list_channels(&self) -> Vec<ChannelDetails> {
 		self.channel_manager.list_channels().into_iter().map(|c| c.into()).collect()

src/test/functional_tests.rs

@@ -34,8 +34,8 @@ fn channel_full_cycle() {
 	);
 	node_a.sync_wallets().unwrap();
 	node_b.sync_wallets().unwrap();
-	assert_eq!(node_a.onchain_balance().unwrap().get_spendable(), premine_amount_sat);
-	assert_eq!(node_b.onchain_balance().unwrap().get_spendable(), premine_amount_sat);
+	assert_eq!(node_a.spendable_onchain_balance_sats().unwrap(), premine_amount_sat);
+	assert_eq!(node_b.spendable_onchain_balance_sats().unwrap(), premine_amount_sat);
 
 	// Check we haven't got any events yet
 	assert_eq!(node_a.next_event(), None);
@@ -77,12 +77,11 @@ fn channel_full_cycle() {
 	node_b.sync_wallets().unwrap();
 
 	let onchain_fee_buffer_sat = 1500;
-	let node_a_balance = node_a.onchain_balance().unwrap();
 	let node_a_upper_bound_sat = premine_amount_sat - funding_amount_sat;
 	let node_a_lower_bound_sat = premine_amount_sat - funding_amount_sat - onchain_fee_buffer_sat;
-	assert!(node_a_balance.get_spendable() < node_a_upper_bound_sat);
-	assert!(node_a_balance.get_spendable() > node_a_lower_bound_sat);
-	assert_eq!(node_b.onchain_balance().unwrap().get_spendable(), premine_amount_sat);
+	assert!(node_a.spendable_onchain_balance_sats().unwrap() < node_a_upper_bound_sat);
+	assert!(node_a.spendable_onchain_balance_sats().unwrap() > node_a_lower_bound_sat);
+	assert_eq!(node_b.spendable_onchain_balance_sats().unwrap(), premine_amount_sat);
 
 	expect_event!(node_a, ChannelReady);
 
@@ -215,10 +214,10 @@ fn channel_full_cycle() {
 	let node_a_upper_bound_sat =
 		(premine_amount_sat - funding_amount_sat) + (funding_amount_sat - sum_of_all_payments_sat);
 	let node_a_lower_bound_sat = node_a_upper_bound_sat - onchain_fee_buffer_sat;
-	assert!(node_a.onchain_balance().unwrap().get_spendable() > node_a_lower_bound_sat);
-	assert!(node_a.onchain_balance().unwrap().get_spendable() < node_a_upper_bound_sat);
+	assert!(node_a.spendable_onchain_balance_sats().unwrap() > node_a_lower_bound_sat);
+	assert!(node_a.spendable_onchain_balance_sats().unwrap() < node_a_upper_bound_sat);
 	let expected_final_amount_node_b_sat = premine_amount_sat + sum_of_all_payments_sat;
-	assert_eq!(node_b.onchain_balance().unwrap().get_spendable(), expected_final_amount_node_b_sat);
+	assert_eq!(node_b.spendable_onchain_balance_sats().unwrap(), expected_final_amount_node_b_sat);
 
 	// Check we handled all events
 	assert_eq!(node_a.next_event(), None);
@@ -260,8 +259,8 @@ fn channel_open_fails_when_funds_insufficient() {
 	);
 	node_a.sync_wallets().unwrap();
 	node_b.sync_wallets().unwrap();
-	assert_eq!(node_a.onchain_balance().unwrap().get_spendable(), premine_amount_sat);
-	assert_eq!(node_b.onchain_balance().unwrap().get_spendable(), premine_amount_sat);
+	assert_eq!(node_a.spendable_onchain_balance_sats().unwrap(), premine_amount_sat);
+	assert_eq!(node_b.spendable_onchain_balance_sats().unwrap(), premine_amount_sat);
 
 	println!("\nA -- connect_open_channel -> B");
 	assert_eq!(
@@ -302,13 +301,13 @@ fn start_stop_reinit() {
 	let expected_amount = Amount::from_sat(100000);
 
 	premine_and_distribute_funds(&bitcoind, &electrsd, vec![funding_address], expected_amount);
-	assert_eq!(node.onchain_balance().unwrap().get_total(), 0);
+	assert_eq!(node.total_onchain_balance_sats().unwrap(), 0);
 
 	node.start().unwrap();
 	assert_eq!(node.start(), Err(Error::AlreadyRunning));
 
 	node.sync_wallets().unwrap();
-	assert_eq!(node.onchain_balance().unwrap().get_spendable(), expected_amount.to_sat());
+	assert_eq!(node.spendable_onchain_balance_sats().unwrap(), expected_amount.to_sat());
 
 	node.stop().unwrap();
 	assert_eq!(node.stop(), Err(Error::NotRunning));
@@ -328,13 +327,13 @@ fn start_stop_reinit() {
 	reinitialized_node.start().unwrap();
 
 	assert_eq!(
-		reinitialized_node.onchain_balance().unwrap().get_spendable(),
+		reinitialized_node.spendable_onchain_balance_sats().unwrap(),
 		expected_amount.to_sat()
 	);
 
 	reinitialized_node.sync_wallets().unwrap();
 	assert_eq!(
-		reinitialized_node.onchain_balance().unwrap().get_spendable(),
+		reinitialized_node.spendable_onchain_balance_sats().unwrap(),
 		expected_amount.to_sat()
 	);
 
@@ -369,7 +368,7 @@ fn onchain_spend_receive() {
 
 	node_a.sync_wallets().unwrap();
 	node_b.sync_wallets().unwrap();
-	assert_eq!(node_b.onchain_balance().unwrap().get_spendable(), 100000);
+	assert_eq!(node_b.spendable_onchain_balance_sats().unwrap(), 100000);
 
 	assert_eq!(Err(Error::InsufficientFunds), node_a.send_to_onchain_address(&addr_b, 1000));
 
@@ -380,9 +379,9 @@ fn onchain_spend_receive() {
 	node_a.sync_wallets().unwrap();
 	node_b.sync_wallets().unwrap();
 
-	assert_eq!(node_a.onchain_balance().unwrap().get_spendable(), 1000);
-	assert!(node_b.onchain_balance().unwrap().get_spendable() > 98000);
-	assert!(node_b.onchain_balance().unwrap().get_spendable() < 100000);
+	assert_eq!(node_a.spendable_onchain_balance_sats().unwrap(), 1000);
+	assert!(node_b.spendable_onchain_balance_sats().unwrap() > 98000);
+	assert!(node_b.spendable_onchain_balance_sats().unwrap() < 100000);
 
 	let addr_b = node_b.new_funding_address().unwrap();
 	let txid = node_a.send_all_to_onchain_address(&addr_b).unwrap();
@@ -392,9 +391,9 @@ fn onchain_spend_receive() {
 	node_a.sync_wallets().unwrap();
 	node_b.sync_wallets().unwrap();
 
-	assert_eq!(node_a.onchain_balance().unwrap().get_total(), 0);
-	assert!(node_b.onchain_balance().unwrap().get_spendable() > 99000);
-	assert!(node_b.onchain_balance().unwrap().get_spendable() < 100000);
+	assert_eq!(node_a.total_onchain_balance_sats().unwrap(), 0);
+	assert!(node_b.spendable_onchain_balance_sats().unwrap() > 99000);
+	assert!(node_b.spendable_onchain_balance_sats().unwrap() < 100000);
 }
 
 #[test]