Merge pull request #93 from tnull/2023-01-update-to-v0.0.113

Update to LDK release 0.0.113

diff --combined src/cli.rs
index 030109ecf792d353cf41b6adae34f58d3a05f946,8135d1e691a928c2d8d2c2edd88fff49b817fe62..b4b7a1c769b8f617e35ad76470d2dbe87f950bb7
--- 1/src/cli.rs
--- 2/src/cli.rs
+++ b/src/cli.rs
@@@ -15,7 -15,7 +15,7 @@@ use lightning::onion_message::{CustomOn
  use lightning::routing::gossip::NodeId;
  use lightning::util::config::{ChannelHandshakeConfig, ChannelHandshakeLimits, UserConfig};
  use lightning::util::events::EventHandler;
- use lightning::util::ser::{MaybeReadableArgs, Writeable, Writer};
+ use lightning::util::ser::{Writeable, Writer};
  use lightning_invoice::payment::PaymentError;
  use lightning_invoice::{utils, Currency, Invoice};
  use std::env;
@@@ -50,13 -50,7 +50,7 @@@ impl CustomOnionMessageContents for Use
                self.tlv_type
        }
  }
- impl MaybeReadableArgs<u64> for UserOnionMessageContents {
-       fn read<R: std::io::Read>(_r: &mut R, _args: u64) -> Result<Option<Self>, DecodeError> {
-               // UserOnionMessageContents is only ever passed to `send_onion_message`, never to an
-               // `OnionMessageHandler`, thus it does not need to implement the read side here.
-               unreachable!();
-       }
- }
+ 
  impl Writeable for UserOnionMessageContents {
        fn write<W: Writer>(&self, w: &mut W) -> Result<(), std::io::Error> {
                w.write_all(&self.data)
@@@ -256,32 -250,6 +250,32 @@@ pub(crate) async fn poll_for_user_input
                                                println!("SUCCESS: connected to peer {}", pubkey);
                                        }
                                }
 +                              "disconnectpeer" => {
 +                                      let peer_pubkey = words.next();
 +                                      if peer_pubkey.is_none() {
 +                                              println!("ERROR: disconnectpeer requires peer public key: `disconnectpeer <peer_pubkey>`");
 +                                              continue;
 +                                      }
 +
 +                                      let peer_pubkey =
 +                                              match bitcoin::secp256k1::PublicKey::from_str(peer_pubkey.unwrap()) {
 +                                                      Ok(pubkey) => pubkey,
 +                                                      Err(e) => {
 +                                                              println!("ERROR: {}", e.to_string());
 +                                                              continue;
 +                                                      }
 +                                              };
 +
 +                                      if do_disconnect_peer(
 +                                              peer_pubkey,
 +                                              peer_manager.clone(),
 +                                              channel_manager.clone(),
 +                                      )
 +                                      .is_ok()
 +                                      {
 +                                              println!("SUCCESS: disconnected from peer {}", peer_pubkey);
 +                                      }
 +                              }
                                "listchannels" => list_channels(&channel_manager, &network_graph),
                                "listpayments" => {
                                        list_payments(inbound_payments.clone(), outbound_payments.clone())
@@@ -455,7 -423,6 +449,7 @@@ fn help() 
        println!("      listchannels");
        println!("\n  Peers:");
        println!("      connectpeer pubkey@host:port");
 +      println!("      disconnectpeer <peer_pubkey>");
        println!("      listpeers");
        println!("\n  Payments:");
        println!("      sendpayment <invoice>");
@@@ -614,29 -581,6 +608,29 @@@ pub(crate) async fn do_connect_peer
        }
  }
  
 +fn do_disconnect_peer(
 +      pubkey: bitcoin::secp256k1::PublicKey, peer_manager: Arc<PeerManager>,
 +      channel_manager: Arc<ChannelManager>,
 +) -> Result<(), ()> {
 +      //check for open channels with peer
 +      for channel in channel_manager.list_channels() {
 +              if channel.counterparty.node_id == pubkey {
 +                      println!("Error: Node has an active channel with this peer, close any channels first");
 +                      return Err(());
 +              }
 +      }
 +
 +      //check the pubkey matches a valid connected peer
 +      let peers = peer_manager.get_peer_node_ids();
 +      if !peers.contains(&pubkey) {
 +              println!("Error: Could not find peer {}", pubkey);
 +              return Err(());
 +      }
 +
 +      peer_manager.disconnect_by_node_id(pubkey, false);
 +      Ok(())
 +}
 +
  fn open_channel(
        peer_pubkey: PublicKey, channel_amt_sat: u64, announced_channel: bool,
        channel_manager: Arc<ChannelManager>,