Update update_fee API signature

to use APIError
unwrap send_update_fee
add is_outbound() accessor

Author: yuntai

src/ln/channel.rs

@@ -1893,31 +1893,34 @@ impl Channel {
 
 	}
 
-	pub fn send_update_fee(&mut self, feerate_per_kw: u64) -> Result<Option<msgs::UpdateFee>, HandleError> {
+	/// Adds a pending update to this channel. See the doc for send_htlc for
+	/// further details on the optionness of the return value.
+	/// You MUST call send_commitment prior to any other calls on this Channel
+	fn send_update_fee(&mut self, feerate_per_kw: u64) -> Option<msgs::UpdateFee> {
 		if !self.channel_outbound {
-			return Err(HandleError{err: "Cannot send fee from inbound channel", action: None});
+			panic!("Cannot send fee from inbound channel");
 		}
 
-		if (self.channel_state & (ChannelState::ChannelFunded as u32 | BOTH_SIDES_SHUTDOWN_MASK)) != (ChannelState::ChannelFunded as u32) {
-			return Err(HandleError{err: "Cannot update fee until channel is fully established and we haven't started shutting down", action: None});
+		if !self.is_usable() {
+			panic!("Cannot update fee until channel is fully established and we haven't started shutting down");
 		}
 
 		if (self.channel_state & (ChannelState::AwaitingRemoteRevoke as u32)) == (ChannelState::AwaitingRemoteRevoke as u32) {
 			self.holding_cell_update_fee = Some(feerate_per_kw);
-			return Ok(None);
+			return None;
 		}
 
 		debug_assert!(self.pending_update_fee.is_none());
 		self.pending_update_fee = Some(feerate_per_kw);
 
-		Ok(Some(msgs::UpdateFee {
+		Some(msgs::UpdateFee {
 			channel_id: self.channel_id,
 			feerate_per_kw: feerate_per_kw as u32,
-		}))
+		})
 	}
 
 	pub fn send_update_fee_and_commit(&mut self, feerate_per_kw: u64) -> Result<Option<(msgs::UpdateFee, msgs::CommitmentSigned, ChannelMonitor)>, HandleError> {
-		match self.send_update_fee(feerate_per_kw)? {
+		match self.send_update_fee(feerate_per_kw) {
 			Some(update_fee) => {
 				let (commitment_signed, monitor_update) = self.send_commitment_no_status_check()?;
 				Ok(Some((update_fee, commitment_signed, monitor_update)))
@@ -2348,6 +2351,10 @@ impl Channel {
 		self.announce_publicly
 	}
 
+	pub fn is_outbound(&self) -> bool {
+		self.channel_outbound
+	}
+
 	/// Gets the fee we'd want to charge for adding an HTLC output to this Channel
 	/// Allowed in any state (including after shutdown)
 	pub fn get_our_fee_base_msat(&self, fee_estimator: &FeeEstimator) -> u32 {

src/ln/channelmanager.rs

@@ -1930,15 +1930,21 @@ impl ChannelManager {
 		res
 	}
 
-	pub fn update_fee(&self, channel_id: [u8;32], feerate_per_kw: u64) -> Result<(), HandleError> {
+	/// Begin Update fee process. Allowed only on an outbound channel.
+	/// If successful, will generate a UpdateHTLCs event, so you should probably poll
+	/// PeerManager::process_events afterwards.
+	pub fn update_fee(&self, channel_id: [u8;32], feerate_per_kw: u64) -> Result<(), APIError> {
 		let mut channel_state = self.channel_state.lock().unwrap();
 		match channel_state.by_id.get_mut(&channel_id) {
-			None => return Err(HandleError{err: "Failed to find corresponding channel", action: None}),
+			None => return Err(APIError::APIMisuseError{err: "Failed to find corresponding channel"}),
 			Some(chan) => {
 				if !chan.is_usable() {
-					return Err(HandleError{err: "Got an announcement_signatures before we were ready for it", action: None});
+					return Err(APIError::APIMisuseError{err: "Channel is not in usuable state"});
+				}
+				if !chan.is_outbound() {
+					return Err(APIError::APIMisuseError{err: "update_fee cannot be sent for an inbound channel"});
 				}
-				if let Some((update_fee, commitment_signed, chan_monitor)) = chan.send_update_fee_and_commit(feerate_per_kw)? {
+				if let Some((update_fee, commitment_signed, chan_monitor)) = chan.send_update_fee_and_commit(feerate_per_kw).map_err(|e| APIError::APIMisuseError{err: e.err})? {
 					if let Err(_e) = self.monitor.add_update_monitor(chan_monitor.get_funding_txo().unwrap(), chan_monitor) {
 						unimplemented!();
 					}