]> git.bitcoin.ninja Git - ldk-c-bindings/commitdiff
Update auto-generated C bindings for 0.0.109
authorMatt Corallo <git@bluematt.me>
Fri, 1 Jul 2022 20:29:21 +0000 (20:29 +0000)
committerMatt Corallo <git@bluematt.me>
Fri, 1 Jul 2022 20:29:21 +0000 (20:29 +0000)
14 files changed:
lightning-c-bindings/include/ldk_rust_types.h
lightning-c-bindings/include/lightning.h
lightning-c-bindings/include/lightningpp.hpp
lightning-c-bindings/src/c_types/derived.rs
lightning-c-bindings/src/lightning/chain/keysinterface.rs
lightning-c-bindings/src/lightning/ln/chan_utils.rs
lightning-c-bindings/src/lightning/ln/channelmanager.rs
lightning-c-bindings/src/lightning/ln/features.rs
lightning-c-bindings/src/lightning/routing/gossip.rs
lightning-c-bindings/src/lightning/routing/router.rs
lightning-c-bindings/src/lightning/routing/scoring.rs
lightning-c-bindings/src/lightning/util/config.rs
lightning-c-bindings/src/lightning/util/events.rs
lightning-c-bindings/src/lightning_background_processor.rs

index 93201e0c99f7dbf0ab4e9c3c3684947e26208d94..83c8f74e2a628e21a0407b3f090f3da23f01aefc 100644 (file)
@@ -96,6 +96,8 @@ struct nativeRoutingFeesOpaque;
 typedef struct nativeRoutingFeesOpaque LDKnativeRoutingFees;
 struct nativeNodeAnnouncementInfoOpaque;
 typedef struct nativeNodeAnnouncementInfoOpaque LDKnativeNodeAnnouncementInfo;
+struct nativeNodeAliasOpaque;
+typedef struct nativeNodeAliasOpaque LDKnativeNodeAlias;
 struct nativeNodeInfoOpaque;
 typedef struct nativeNodeInfoOpaque LDKnativeNodeInfo;
 struct nativeDelayedPaymentOutputDescriptorOpaque;
index c1538b8d1f2eb7ded7d9eae47843ff9f9a1fec97..113624298d2b7d464f57213da9827a7c8cc3d21f 100644 (file)
@@ -1,7 +1,7 @@
 #ifndef LDK_C_BINDINGS_H
 #define LDK_C_BINDINGS_H
 
-/* Generated with cbindgen:0.20.0 */
+/* Generated with cbindgen:0.24.3 */
 
 /* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */
 
@@ -2790,13 +2790,13 @@ typedef enum LDKEvent_Tag {
     * Indicates a request to open a new channel by a peer.
     *
     * To accept the request, call [`ChannelManager::accept_inbound_channel`]. To reject the
-    * request, call [`ChannelManager::force_close_channel`].
+    * request, call [`ChannelManager::force_close_without_broadcasting_txn`].
     *
     * The event is only triggered when a new open channel request is received and the
     * [`UserConfig::manually_accept_inbound_channels`] config flag is set to true.
     *
     * [`ChannelManager::accept_inbound_channel`]: crate::ln::channelmanager::ChannelManager::accept_inbound_channel
-    * [`ChannelManager::force_close_channel`]: crate::ln::channelmanager::ChannelManager::force_close_channel
+    * [`ChannelManager::force_close_without_broadcasting_txn`]: crate::ln::channelmanager::ChannelManager::force_close_without_broadcasting_txn
     * [`UserConfig::manually_accept_inbound_channels`]: crate::util::config::UserConfig::manually_accept_inbound_channels
     */
    LDKEvent_OpenChannelRequest,
@@ -3130,10 +3130,10 @@ typedef struct LDKEvent_LDKOpenChannelRequest_Body {
     *
     * When responding to the request, the `temporary_channel_id` should be passed
     * back to the ChannelManager through [`ChannelManager::accept_inbound_channel`] to accept,
-    * or through [`ChannelManager::force_close_channel`] to reject.
+    * or through [`ChannelManager::force_close_without_broadcasting_txn`] to reject.
     *
     * [`ChannelManager::accept_inbound_channel`]: crate::ln::channelmanager::ChannelManager::accept_inbound_channel
-    * [`ChannelManager::force_close_channel`]: crate::ln::channelmanager::ChannelManager::force_close_channel
+    * [`ChannelManager::force_close_without_broadcasting_txn`]: crate::ln::channelmanager::ChannelManager::force_close_without_broadcasting_txn
     */
    struct LDKThirtyTwoBytes temporary_channel_id;
    /**
@@ -3141,11 +3141,11 @@ typedef struct LDKEvent_LDKOpenChannelRequest_Body {
     *
     * When responding to the request, the `counterparty_node_id` should be passed
     * back to the `ChannelManager` through [`ChannelManager::accept_inbound_channel`] to
-    * accept the request, or through [`ChannelManager::force_close_channel`] to reject the
+    * accept the request, or through [`ChannelManager::force_close_without_broadcasting_txn`] to reject the
     * request.
     *
     * [`ChannelManager::accept_inbound_channel`]: crate::ln::channelmanager::ChannelManager::accept_inbound_channel
-    * [`ChannelManager::force_close_channel`]: crate::ln::channelmanager::ChannelManager::force_close_channel
+    * [`ChannelManager::force_close_without_broadcasting_txn`]: crate::ln::channelmanager::ChannelManager::force_close_without_broadcasting_txn
     */
    struct LDKPublicKey counterparty_node_id;
    /**
@@ -4415,6 +4415,83 @@ typedef struct LDKCResult_FixedPenaltyScorerDecodeErrorZ {
    bool result_ok;
 } LDKCResult_FixedPenaltyScorerDecodeErrorZ;
 
+/**
+ * A tuple of 2 elements. See the individual fields for the types contained.
+ */
+typedef struct LDKC2Tuple_u64u64Z {
+   /**
+    * The element at position 0
+    */
+   uint64_t a;
+   /**
+    * The element at position 1
+    */
+   uint64_t b;
+} LDKC2Tuple_u64u64Z;
+
+/**
+ * An enum which can either contain a crate::c_types::derived::C2Tuple_u64u64Z or not
+ */
+typedef enum LDKCOption_C2Tuple_u64u64ZZ_Tag {
+   /**
+    * When we're in this state, this COption_C2Tuple_u64u64ZZ contains a crate::c_types::derived::C2Tuple_u64u64Z
+    */
+   LDKCOption_C2Tuple_u64u64ZZ_Some,
+   /**
+    * When we're in this state, this COption_C2Tuple_u64u64ZZ contains nothing
+    */
+   LDKCOption_C2Tuple_u64u64ZZ_None,
+   /**
+    * Must be last for serialization purposes
+    */
+   LDKCOption_C2Tuple_u64u64ZZ_Sentinel,
+} LDKCOption_C2Tuple_u64u64ZZ_Tag;
+
+typedef struct LDKCOption_C2Tuple_u64u64ZZ {
+   LDKCOption_C2Tuple_u64u64ZZ_Tag tag;
+   union {
+      struct {
+         struct LDKC2Tuple_u64u64Z some;
+      };
+   };
+} LDKCOption_C2Tuple_u64u64ZZ;
+
+
+
+/**
+ * Represents the compressed public key of a node
+ */
+typedef struct MUST_USE_STRUCT LDKNodeId {
+   /**
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    */
+   LDKnativeNodeId *inner;
+   /**
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
+    */
+   bool is_owned;
+} LDKNodeId;
+
+/**
+ * A dynamically-allocated array of crate::lightning::routing::gossip::NodeIds of arbitrary size.
+ * This corresponds to std::vector in C++
+ */
+typedef struct LDKCVec_NodeIdZ {
+   /**
+    * The elements in the array.
+    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    */
+   struct LDKNodeId *data;
+   /**
+    * The number of elements pointed to by `data`.
+    */
+   uintptr_t datalen;
+} LDKCVec_NodeIdZ;
+
 
 
 /**
@@ -4795,26 +4872,6 @@ typedef struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ {
    bool result_ok;
 } LDKCResult_ChannelTypeFeaturesDecodeErrorZ;
 
-
-
-/**
- * Represents the compressed public key of a node
- */
-typedef struct MUST_USE_STRUCT LDKNodeId {
-   /**
-    * A pointer to the opaque Rust object.
-    * Nearly everywhere, inner must be non-null, however in places where
-    * the Rust equivalent takes an Option, it may be set to null to indicate None.
-    */
-   LDKnativeNodeId *inner;
-   /**
-    * Indicates that this is the only struct which contains the same pointer.
-    * Rust functions which take ownership of an object provided via an argument require
-    * this to be true and invalidate the object pointed to by inner.
-    */
-   bool is_owned;
-} LDKNodeId;
-
 /**
  * The contents of CResult_NodeIdDecodeErrorZ
  */
@@ -5391,6 +5448,62 @@ typedef struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ {
    bool result_ok;
 } LDKCResult_NodeAnnouncementInfoDecodeErrorZ;
 
+
+
+/**
+ * A user-defined name for a node, which may be used when displaying the node in a graph.
+ *
+ * Since node aliases are provided by third parties, they are a potential avenue for injection
+ * attacks. Care must be taken when processing.
+ */
+typedef struct MUST_USE_STRUCT LDKNodeAlias {
+   /**
+    * A pointer to the opaque Rust object.
+    * Nearly everywhere, inner must be non-null, however in places where
+    * the Rust equivalent takes an Option, it may be set to null to indicate None.
+    */
+   LDKnativeNodeAlias *inner;
+   /**
+    * Indicates that this is the only struct which contains the same pointer.
+    * Rust functions which take ownership of an object provided via an argument require
+    * this to be true and invalidate the object pointed to by inner.
+    */
+   bool is_owned;
+} LDKNodeAlias;
+
+/**
+ * The contents of CResult_NodeAliasDecodeErrorZ
+ */
+typedef union LDKCResult_NodeAliasDecodeErrorZPtr {
+   /**
+    * A pointer to the contents in the success state.
+    * Reading from this pointer when `result_ok` is not set is undefined.
+    */
+   struct LDKNodeAlias *result;
+   /**
+    * A pointer to the contents in the error state.
+    * Reading from this pointer when `result_ok` is set is undefined.
+    */
+   struct LDKDecodeError *err;
+} LDKCResult_NodeAliasDecodeErrorZPtr;
+
+/**
+ * A CResult_NodeAliasDecodeErrorZ represents the result of a fallible operation,
+ * containing a crate::lightning::routing::gossip::NodeAlias on success and a crate::lightning::ln::msgs::DecodeError on failure.
+ * `result_ok` indicates the overall state, and the contents are provided via `contents`.
+ */
+typedef struct LDKCResult_NodeAliasDecodeErrorZ {
+   /**
+    * The contents of this CResult_NodeAliasDecodeErrorZ, accessible via either
+    * `err` or `result` depending on the state of `result_ok`.
+    */
+   union LDKCResult_NodeAliasDecodeErrorZPtr contents;
+   /**
+    * Whether this CResult_NodeAliasDecodeErrorZ represents a success state.
+    */
+   bool result_ok;
+} LDKCResult_NodeAliasDecodeErrorZ;
+
 /**
  * A dynamically-allocated array of u64s of arbitrary size.
  * This corresponds to std::vector in C++
@@ -6845,6 +6958,22 @@ typedef struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ {
    bool result_ok;
 } LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ;
 
+/**
+ * A dynamically-allocated array of crate::c_types::ThirtyTwoBytess of arbitrary size.
+ * This corresponds to std::vector in C++
+ */
+typedef struct LDKCVec_ThirtyTwoBytesZ {
+   /**
+    * The elements in the array.
+    * If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+    */
+   struct LDKThirtyTwoBytes *data;
+   /**
+    * The number of elements pointed to by `data`.
+    */
+   uintptr_t datalen;
+} LDKCVec_ThirtyTwoBytesZ;
+
 /**
  * A tuple of 2 elements. See the individual fields for the types contained.
  */
@@ -7369,7 +7498,9 @@ typedef struct LDKKeysInterface {
     */
    void *this_arg;
    /**
-    * Get node secret key (aka node_id or network_key) based on the provided [`Recipient`].
+    * Get node secret key based on the provided [`Recipient`].
+    *
+    * The node_id/network_key is the public key that corresponds to this secret key.
     *
     * This method must return the same value each time it is called with a given `Recipient`
     * parameter.
@@ -12216,6 +12347,10 @@ typedef struct LDKEffectiveCapacity_LDKTotal_Body {
     * The funding amount denominated in millisatoshi.
     */
    uint64_t capacity_msat;
+   /**
+    * The maximum HTLC amount denominated in millisatoshi.
+    */
+   struct LDKCOption_u64Z htlc_maximum_msat;
 } LDKEffectiveCapacity_LDKTotal_Body;
 
 typedef struct MUST_USE_STRUCT LDKEffectiveCapacity {
@@ -12700,6 +12835,8 @@ extern const uint64_t UNKNOWN_CHANNEL_CAPACITY_MSAT;
 
 extern const uint32_t DEFAULT_MAX_TOTAL_CLTV_EXPIRY_DELTA;
 
+extern const uint8_t DEFAULT_MAX_MPP_PATH_COUNT;
+
 extern const uint64_t MAX_TIMESTAMP;
 
 extern const uint64_t DEFAULT_EXPIRY_TIME;
@@ -13831,6 +13968,48 @@ void CResult_FixedPenaltyScorerDecodeErrorZ_free(struct LDKCResult_FixedPenaltyS
  */
 struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_clone(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR orig);
 
+/**
+ * Creates a new tuple which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
+ */
+struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_clone(const struct LDKC2Tuple_u64u64Z *NONNULL_PTR orig);
+
+/**
+ * Creates a new C2Tuple_u64u64Z from the contained elements.
+ */
+struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_new(uint64_t a, uint64_t b);
+
+/**
+ * Frees any resources used by the C2Tuple_u64u64Z.
+ */
+void C2Tuple_u64u64Z_free(struct LDKC2Tuple_u64u64Z _res);
+
+/**
+ * Constructs a new COption_C2Tuple_u64u64ZZ containing a crate::c_types::derived::C2Tuple_u64u64Z
+ */
+struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_some(struct LDKC2Tuple_u64u64Z o);
+
+/**
+ * Constructs a new COption_C2Tuple_u64u64ZZ containing nothing
+ */
+struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_none(void);
+
+/**
+ * Frees any resources associated with the crate::c_types::derived::C2Tuple_u64u64Z, if we are in the Some state
+ */
+void COption_C2Tuple_u64u64ZZ_free(struct LDKCOption_C2Tuple_u64u64ZZ _res);
+
+/**
+ * Creates a new COption_C2Tuple_u64u64ZZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
+ */
+struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_clone(const struct LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR orig);
+
+/**
+ * Frees the buffer pointed to by `data` if `datalen` is non-0.
+ */
+void CVec_NodeIdZ_free(struct LDKCVec_NodeIdZ _res);
+
 /**
  * Creates a new CResult_ProbabilisticScorerDecodeErrorZ in the success state.
  */
@@ -14235,6 +14414,32 @@ void CResult_NodeAnnouncementInfoDecodeErrorZ_free(struct LDKCResult_NodeAnnounc
  */
 struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR orig);
 
+/**
+ * Creates a new CResult_NodeAliasDecodeErrorZ in the success state.
+ */
+struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_ok(struct LDKNodeAlias o);
+
+/**
+ * Creates a new CResult_NodeAliasDecodeErrorZ in the error state.
+ */
+struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_err(struct LDKDecodeError e);
+
+/**
+ * Checks if the given object is currently in the success state
+ */
+bool CResult_NodeAliasDecodeErrorZ_is_ok(const struct LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR o);
+
+/**
+ * Frees any resources used by the CResult_NodeAliasDecodeErrorZ.
+ */
+void CResult_NodeAliasDecodeErrorZ_free(struct LDKCResult_NodeAliasDecodeErrorZ _res);
+
+/**
+ * Creates a new CResult_NodeAliasDecodeErrorZ which has the same data as `orig`
+ * but with all dynamically-allocated buffers duplicated in new buffers.
+ */
+struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_clone(const struct LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR orig);
+
 /**
  * Frees the buffer pointed to by `data` if `datalen` is non-0.
  */
@@ -14888,6 +15093,11 @@ void CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(struct LDKCRe
  */
 struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR orig);
 
+/**
+ * Frees the buffer pointed to by `data` if `datalen` is non-0.
+ */
+void CVec_ThirtyTwoBytesZ_free(struct LDKCVec_ThirtyTwoBytesZ _res);
+
 /**
  * Creates a new tuple which has the same data as `orig`
  * but with all dynamically-allocated buffers duplicated in new buffers.
@@ -17569,20 +17779,20 @@ void ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_chan
  *
  * If this option is set, channels may be created that will not be readable by LDK versions
  * prior to 0.0.106, causing [`ChannelManager`]'s read method to return a
- * [`DecodeError:InvalidValue`].
+ * [`DecodeError::InvalidValue`].
  *
  * Note that setting this to true does *not* prevent us from opening channels with
  * counterparties that do not support the `scid_alias` option; we will simply fall back to a
  * private channel without that option.
  *
  * Ignored if the channel is negotiated to be announced, see
- * [`ChannelConfig::announced_channel`] and
+ * [`ChannelHandshakeConfig::announced_channel`] and
  * [`ChannelHandshakeLimits::force_announced_channel_preference`] for more.
  *
  * Default value: false. This value is likely to change to true in the future.
  *
  * [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
- * [`DecodeError:InvalidValue`]: crate::ln::msgs::DecodeError::InvalidValue
+ * [`DecodeError::InvalidValue`]: crate::ln::msgs::DecodeError::InvalidValue
  */
 bool ChannelHandshakeConfig_get_negotiate_scid_privacy(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
 
@@ -17594,27 +17804,87 @@ bool ChannelHandshakeConfig_get_negotiate_scid_privacy(const struct LDKChannelHa
  *
  * If this option is set, channels may be created that will not be readable by LDK versions
  * prior to 0.0.106, causing [`ChannelManager`]'s read method to return a
- * [`DecodeError:InvalidValue`].
+ * [`DecodeError::InvalidValue`].
  *
  * Note that setting this to true does *not* prevent us from opening channels with
  * counterparties that do not support the `scid_alias` option; we will simply fall back to a
  * private channel without that option.
  *
  * Ignored if the channel is negotiated to be announced, see
- * [`ChannelConfig::announced_channel`] and
+ * [`ChannelHandshakeConfig::announced_channel`] and
  * [`ChannelHandshakeLimits::force_announced_channel_preference`] for more.
  *
  * Default value: false. This value is likely to change to true in the future.
  *
  * [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
- * [`DecodeError:InvalidValue`]: crate::ln::msgs::DecodeError::InvalidValue
+ * [`DecodeError::InvalidValue`]: crate::ln::msgs::DecodeError::InvalidValue
  */
 void ChannelHandshakeConfig_set_negotiate_scid_privacy(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
 
+/**
+ * Set to announce the channel publicly and notify all nodes that they can route via this
+ * channel.
+ *
+ * This should only be set to true for nodes which expect to be online reliably.
+ *
+ * As the node which funds a channel picks this value this will only apply for new outbound
+ * channels unless [`ChannelHandshakeLimits::force_announced_channel_preference`] is set.
+ *
+ * Default value: false.
+ */
+bool ChannelHandshakeConfig_get_announced_channel(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
+
+/**
+ * Set to announce the channel publicly and notify all nodes that they can route via this
+ * channel.
+ *
+ * This should only be set to true for nodes which expect to be online reliably.
+ *
+ * As the node which funds a channel picks this value this will only apply for new outbound
+ * channels unless [`ChannelHandshakeLimits::force_announced_channel_preference`] is set.
+ *
+ * Default value: false.
+ */
+void ChannelHandshakeConfig_set_announced_channel(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
+
+/**
+ * When set, we commit to an upfront shutdown_pubkey at channel open. If our counterparty
+ * supports it, they will then enforce the mutual-close output to us matches what we provided
+ * at intialization, preventing us from closing to an alternate pubkey.
+ *
+ * This is set to true by default to provide a slight increase in security, though ultimately
+ * any attacker who is able to take control of a channel can just as easily send the funds via
+ * lightning payments, so we never require that our counterparties support this option.
+ *
+ * The upfront key committed is provided from [`KeysInterface::get_shutdown_scriptpubkey`].
+ *
+ * Default value: true.
+ *
+ * [`KeysInterface::get_shutdown_scriptpubkey`]: crate::chain::keysinterface::KeysInterface::get_shutdown_scriptpubkey
+ */
+bool ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
+
+/**
+ * When set, we commit to an upfront shutdown_pubkey at channel open. If our counterparty
+ * supports it, they will then enforce the mutual-close output to us matches what we provided
+ * at intialization, preventing us from closing to an alternate pubkey.
+ *
+ * This is set to true by default to provide a slight increase in security, though ultimately
+ * any attacker who is able to take control of a channel can just as easily send the funds via
+ * lightning payments, so we never require that our counterparties support this option.
+ *
+ * The upfront key committed is provided from [`KeysInterface::get_shutdown_scriptpubkey`].
+ *
+ * Default value: true.
+ *
+ * [`KeysInterface::get_shutdown_scriptpubkey`]: crate::chain::keysinterface::KeysInterface::get_shutdown_scriptpubkey
+ */
+void ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
+
 /**
  * Constructs a new ChannelHandshakeConfig given each field
  */
-MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_new(uint32_t minimum_depth_arg, uint16_t our_to_self_delay_arg, uint64_t our_htlc_minimum_msat_arg, uint8_t max_inbound_htlc_value_in_flight_percent_of_channel_arg, bool negotiate_scid_privacy_arg);
+MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_new(uint32_t minimum_depth_arg, uint16_t our_to_self_delay_arg, uint64_t our_htlc_minimum_msat_arg, uint8_t max_inbound_htlc_value_in_flight_percent_of_channel_arg, bool negotiate_scid_privacy_arg, bool announced_channel_arg, bool commit_upfront_shutdown_pubkey_arg);
 
 /**
  * Creates a copy of the ChannelHandshakeConfig
@@ -17793,10 +18063,10 @@ void ChannelHandshakeLimits_set_trust_own_funding_0conf(struct LDKChannelHandsha
 
 /**
  * Set to force an incoming channel to match our announced channel preference in
- * [`ChannelConfig::announced_channel`].
+ * [`ChannelHandshakeConfig::announced_channel`].
  *
  * For a node which is not online reliably, this should be set to true and
- * [`ChannelConfig::announced_channel`] set to false, ensuring that no announced (aka public)
+ * [`ChannelHandshakeConfig::announced_channel`] set to false, ensuring that no announced (aka public)
  * channels will ever be opened.
  *
  * Default value: true.
@@ -17805,10 +18075,10 @@ bool ChannelHandshakeLimits_get_force_announced_channel_preference(const struct
 
 /**
  * Set to force an incoming channel to match our announced channel preference in
- * [`ChannelConfig::announced_channel`].
+ * [`ChannelHandshakeConfig::announced_channel`].
  *
  * For a node which is not online reliably, this should be set to true and
- * [`ChannelConfig::announced_channel`] set to false, ensuring that no announced (aka public)
+ * [`ChannelHandshakeConfig::announced_channel`] set to false, ensuring that no announced (aka public)
  * channels will ever be opened.
  *
  * Default value: true.
@@ -17955,66 +18225,6 @@ uint16_t ChannelConfig_get_cltv_expiry_delta(const struct LDKChannelConfig *NONN
  */
 void ChannelConfig_set_cltv_expiry_delta(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint16_t val);
 
-/**
- * Set to announce the channel publicly and notify all nodes that they can route via this
- * channel.
- *
- * This should only be set to true for nodes which expect to be online reliably.
- *
- * As the node which funds a channel picks this value this will only apply for new outbound
- * channels unless [`ChannelHandshakeLimits::force_announced_channel_preference`] is set.
- *
- * This cannot be changed after the initial channel handshake.
- *
- * Default value: false.
- */
-bool ChannelConfig_get_announced_channel(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
-
-/**
- * Set to announce the channel publicly and notify all nodes that they can route via this
- * channel.
- *
- * This should only be set to true for nodes which expect to be online reliably.
- *
- * As the node which funds a channel picks this value this will only apply for new outbound
- * channels unless [`ChannelHandshakeLimits::force_announced_channel_preference`] is set.
- *
- * This cannot be changed after the initial channel handshake.
- *
- * Default value: false.
- */
-void ChannelConfig_set_announced_channel(struct LDKChannelConfig *NONNULL_PTR this_ptr, bool val);
-
-/**
- * When set, we commit to an upfront shutdown_pubkey at channel open. If our counterparty
- * supports it, they will then enforce the mutual-close output to us matches what we provided
- * at intialization, preventing us from closing to an alternate pubkey.
- *
- * This is set to true by default to provide a slight increase in security, though ultimately
- * any attacker who is able to take control of a channel can just as easily send the funds via
- * lightning payments, so we never require that our counterparties support this option.
- *
- * This cannot be changed after a channel has been initialized.
- *
- * Default value: true.
- */
-bool ChannelConfig_get_commit_upfront_shutdown_pubkey(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
-
-/**
- * When set, we commit to an upfront shutdown_pubkey at channel open. If our counterparty
- * supports it, they will then enforce the mutual-close output to us matches what we provided
- * at intialization, preventing us from closing to an alternate pubkey.
- *
- * This is set to true by default to provide a slight increase in security, though ultimately
- * any attacker who is able to take control of a channel can just as easily send the funds via
- * lightning payments, so we never require that our counterparties support this option.
- *
- * This cannot be changed after a channel has been initialized.
- *
- * Default value: true.
- */
-void ChannelConfig_set_commit_upfront_shutdown_pubkey(struct LDKChannelConfig *NONNULL_PTR this_ptr, bool val);
-
 /**
  * Limit our total exposure to in-flight HTLCs which are burned to fees as they are too
  * small to claim on-chain.
@@ -18108,7 +18318,7 @@ void ChannelConfig_set_force_close_avoidance_max_fee_satoshis(struct LDKChannelC
 /**
  * Constructs a new ChannelConfig given each field
  */
-MUST_USE_RES struct LDKChannelConfig ChannelConfig_new(uint32_t forwarding_fee_proportional_millionths_arg, uint32_t forwarding_fee_base_msat_arg, uint16_t cltv_expiry_delta_arg, bool announced_channel_arg, bool commit_upfront_shutdown_pubkey_arg, uint64_t max_dust_htlc_exposure_msat_arg, uint64_t force_close_avoidance_max_fee_satoshis_arg);
+MUST_USE_RES struct LDKChannelConfig ChannelConfig_new(uint32_t forwarding_fee_proportional_millionths_arg, uint32_t forwarding_fee_base_msat_arg, uint16_t cltv_expiry_delta_arg, uint64_t max_dust_htlc_exposure_msat_arg, uint64_t force_close_avoidance_max_fee_satoshis_arg);
 
 /**
  * Creates a copy of the ChannelConfig
@@ -18136,34 +18346,34 @@ struct LDKCResult_ChannelConfigDecodeErrorZ ChannelConfig_read(struct LDKu8slice
 void UserConfig_free(struct LDKUserConfig this_obj);
 
 /**
- * Channel config that we propose to our counterparty.
+ * Channel handshake config that we propose to our counterparty.
  */
-struct LDKChannelHandshakeConfig UserConfig_get_own_channel_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
+struct LDKChannelHandshakeConfig UserConfig_get_channel_handshake_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
 
 /**
- * Channel config that we propose to our counterparty.
+ * Channel handshake config that we propose to our counterparty.
  */
-void UserConfig_set_own_channel_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeConfig val);
+void UserConfig_set_channel_handshake_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeConfig val);
 
 /**
- * Limits applied to our counterparty's proposed channel config settings.
+ * Limits applied to our counterparty's proposed channel handshake config settings.
  */
-struct LDKChannelHandshakeLimits UserConfig_get_peer_channel_config_limits(const struct LDKUserConfig *NONNULL_PTR this_ptr);
+struct LDKChannelHandshakeLimits UserConfig_get_channel_handshake_limits(const struct LDKUserConfig *NONNULL_PTR this_ptr);
 
 /**
- * Limits applied to our counterparty's proposed channel config settings.
+ * Limits applied to our counterparty's proposed channel handshake config settings.
  */
-void UserConfig_set_peer_channel_config_limits(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeLimits val);
+void UserConfig_set_channel_handshake_limits(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeLimits val);
 
 /**
  * Channel config which affects behavior during channel lifetime.
  */
-struct LDKChannelConfig UserConfig_get_channel_options(const struct LDKUserConfig *NONNULL_PTR this_ptr);
+struct LDKChannelConfig UserConfig_get_channel_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
 
 /**
  * Channel config which affects behavior during channel lifetime.
  */
-void UserConfig_set_channel_options(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
+void UserConfig_set_channel_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
 
 /**
  * If this is set to false, we will reject any HTLCs which were to be forwarded over private
@@ -18171,7 +18381,7 @@ void UserConfig_set_channel_options(struct LDKUserConfig *NONNULL_PTR this_ptr,
  * node which is not online reliably.
  *
  * For nodes which are not online reliably, you should set all channels to *not* be announced
- * (using [`ChannelConfig::announced_channel`] and
+ * (using [`ChannelHandshakeConfig::announced_channel`] and
  * [`ChannelHandshakeLimits::force_announced_channel_preference`]) and set this to false to
  * ensure you are not exposed to any forwarding risk.
  *
@@ -18191,7 +18401,7 @@ bool UserConfig_get_accept_forwards_to_priv_channels(const struct LDKUserConfig
  * node which is not online reliably.
  *
  * For nodes which are not online reliably, you should set all channels to *not* be announced
- * (using [`ChannelConfig::announced_channel`] and
+ * (using [`ChannelHandshakeConfig::announced_channel`] and
  * [`ChannelHandshakeLimits::force_announced_channel_preference`]) and set this to false to
  * ensure you are not exposed to any forwarding risk.
  *
@@ -18254,7 +18464,7 @@ void UserConfig_set_manually_accept_inbound_channels(struct LDKUserConfig *NONNU
 /**
  * Constructs a new UserConfig given each field
  */
-MUST_USE_RES struct LDKUserConfig UserConfig_new(struct LDKChannelHandshakeConfig own_channel_config_arg, struct LDKChannelHandshakeLimits peer_channel_config_limits_arg, struct LDKChannelConfig channel_options_arg, bool accept_forwards_to_priv_channels_arg, bool accept_inbound_channels_arg, bool manually_accept_inbound_channels_arg);
+MUST_USE_RES struct LDKUserConfig UserConfig_new(struct LDKChannelHandshakeConfig channel_handshake_config_arg, struct LDKChannelHandshakeLimits channel_handshake_limits_arg, struct LDKChannelConfig channel_config_arg, bool accept_forwards_to_priv_channels_arg, bool accept_inbound_channels_arg, bool manually_accept_inbound_channels_arg);
 
 /**
  * Creates a copy of the UserConfig
@@ -20052,10 +20262,28 @@ struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_maximum_msat(const struct
  */
 void ChannelDetails_set_inbound_htlc_maximum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
 
+/**
+ * Set of configurable parameters that affect channel operation.
+ *
+ * This field is only `None` for `ChannelDetails` objects serialized prior to LDK 0.0.109.
+ *
+ * Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
+ */
+struct LDKChannelConfig ChannelDetails_get_config(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+
+/**
+ * Set of configurable parameters that affect channel operation.
+ *
+ * This field is only `None` for `ChannelDetails` objects serialized prior to LDK 0.0.109.
+ *
+ * Note that val (or a relevant inner pointer) may be NULL or all-0s to represent None
+ */
+void ChannelDetails_set_config(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
+
 /**
  * Constructs a new ChannelDetails given each field
  */
-MUST_USE_RES struct LDKChannelDetails ChannelDetails_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKChannelCounterparty counterparty_arg, struct LDKOutPoint funding_txo_arg, struct LDKChannelTypeFeatures channel_type_arg, struct LDKCOption_u64Z short_channel_id_arg, struct LDKCOption_u64Z outbound_scid_alias_arg, struct LDKCOption_u64Z inbound_scid_alias_arg, uint64_t channel_value_satoshis_arg, struct LDKCOption_u64Z unspendable_punishment_reserve_arg, uint64_t user_channel_id_arg, uint64_t balance_msat_arg, uint64_t outbound_capacity_msat_arg, uint64_t next_outbound_htlc_limit_msat_arg, uint64_t inbound_capacity_msat_arg, struct LDKCOption_u32Z confirmations_required_arg, struct LDKCOption_u16Z force_close_spend_delay_arg, bool is_outbound_arg, bool is_channel_ready_arg, bool is_usable_arg, bool is_public_arg, struct LDKCOption_u64Z inbound_htlc_minimum_msat_arg, struct LDKCOption_u64Z inbound_htlc_maximum_msat_arg);
+MUST_USE_RES struct LDKChannelDetails ChannelDetails_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKChannelCounterparty counterparty_arg, struct LDKOutPoint funding_txo_arg, struct LDKChannelTypeFeatures channel_type_arg, struct LDKCOption_u64Z short_channel_id_arg, struct LDKCOption_u64Z outbound_scid_alias_arg, struct LDKCOption_u64Z inbound_scid_alias_arg, uint64_t channel_value_satoshis_arg, struct LDKCOption_u64Z unspendable_punishment_reserve_arg, uint64_t user_channel_id_arg, uint64_t balance_msat_arg, uint64_t outbound_capacity_msat_arg, uint64_t next_outbound_htlc_limit_msat_arg, uint64_t inbound_capacity_msat_arg, struct LDKCOption_u32Z confirmations_required_arg, struct LDKCOption_u16Z force_close_spend_delay_arg, bool is_outbound_arg, bool is_channel_ready_arg, bool is_usable_arg, bool is_public_arg, struct LDKCOption_u64Z inbound_htlc_minimum_msat_arg, struct LDKCOption_u64Z inbound_htlc_maximum_msat_arg, struct LDKChannelConfig config_arg);
 
 /**
  * Creates a copy of the ChannelDetails
@@ -20273,18 +20501,34 @@ MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_close_channel(const
 MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_close_channel_with_target_feerate(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32], struct LDKPublicKey counterparty_node_id, uint32_t target_feerate_sats_per_1000_weight);
 
 /**
- * Force closes a channel, immediately broadcasting the latest local commitment transaction to
- * the chain and rejecting new HTLCs on the given channel. Fails if `channel_id` is unknown to
+ * Force closes a channel, immediately broadcasting the latest local transaction(s) and
+ * rejecting new HTLCs on the given channel. Fails if `channel_id` is unknown to
  * the manager, or if the `counterparty_node_id` isn't the counterparty of the corresponding
  * channel.
  */
-MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_force_close_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32], struct LDKPublicKey counterparty_node_id);
+MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_force_close_broadcasting_latest_txn(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32], struct LDKPublicKey counterparty_node_id);
+
+/**
+ * Force closes a channel, rejecting new HTLCs on the given channel but skips broadcasting
+ * the latest local transaction(s). Fails if `channel_id` is unknown to the manager, or if the
+ * `counterparty_node_id` isn't the counterparty of the corresponding channel.
+ *
+ * You can always get the latest local transaction(s) to broadcast from
+ * [`ChannelMonitor::get_latest_holder_commitment_txn`].
+ */
+MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_force_close_without_broadcasting_txn(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32], struct LDKPublicKey counterparty_node_id);
 
 /**
  * Force close all channels, immediately broadcasting the latest local commitment transaction
  * for each to the chain and rejecting new HTLCs on each.
  */
-void ChannelManager_force_close_all_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
+void ChannelManager_force_close_all_channels_broadcasting_latest_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
+
+/**
+ * Force close all channels rejecting new HTLCs on each but without broadcasting the latest
+ * local transaction(s).
+ */
+void ChannelManager_force_close_all_channels_without_broadcasting_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
 
 /**
  * Sends a payment along a given route.
@@ -20389,6 +20633,9 @@ MUST_USE_RES struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ
  * Returns an [`APIError::APIMisuseError`] if the funding_transaction spent non-SegWit outputs
  * or if no output was found which matches the parameters in [`Event::FundingGenerationReady`].
  *
+ * Returns [`APIError::APIMisuseError`] if the funding transaction is not final for propagation
+ * across the p2p network.
+ *
  * Returns [`APIError::ChannelUnavailable`] if a funding transaction has already been provided
  * for the channel or if the channel has been closed as indicated by [`Event::ChannelClosed`].
  *
@@ -20404,6 +20651,11 @@ MUST_USE_RES struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ
  * not currently support replacing a funding transaction on an existing channel. Instead,
  * create a new channel with a conflicting funding transaction.
  *
+ * Note to keep the miner incentives aligned in moving the blockchain forward, we recommend
+ * the wallet software generating the funding transaction to apply anti-fee sniping as
+ * implemented by Bitcoin Core wallet. See <https://bitcoinops.org/en/topics/fee-sniping/>
+ * for more details.
+ *
  * [`Event::FundingGenerationReady`]: crate::util::events::Event::FundingGenerationReady
  * [`Event::ChannelClosed`]: crate::util::events::Event::ChannelClosed
  */
@@ -20431,6 +20683,32 @@ MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_funding_transaction_
  */
 void ChannelManager_broadcast_node_announcement(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThreeBytes rgb, struct LDKThirtyTwoBytes alias, struct LDKCVec_NetAddressZ addresses);
 
+/**
+ * Atomically updates the [`ChannelConfig`] for the given channels.
+ *
+ * Once the updates are applied, each eligible channel (advertised with a known short channel
+ * ID and a change in [`forwarding_fee_proportional_millionths`], [`forwarding_fee_base_msat`],
+ * or [`cltv_expiry_delta`]) has a [`BroadcastChannelUpdate`] event message generated
+ * containing the new [`ChannelUpdate`] message which should be broadcast to the network.
+ *
+ * Returns [`ChannelUnavailable`] when a channel is not found or an incorrect
+ * `counterparty_node_id` is provided.
+ *
+ * Returns [`APIMisuseError`] when a [`cltv_expiry_delta`] update is to be applied with a value
+ * below [`MIN_CLTV_EXPIRY_DELTA`].
+ *
+ * If an error is returned, none of the updates should be considered applied.
+ *
+ * [`forwarding_fee_proportional_millionths`]: ChannelConfig::forwarding_fee_proportional_millionths
+ * [`forwarding_fee_base_msat`]: ChannelConfig::forwarding_fee_base_msat
+ * [`cltv_expiry_delta`]: ChannelConfig::cltv_expiry_delta
+ * [`BroadcastChannelUpdate`]: events::MessageSendEvent::BroadcastChannelUpdate
+ * [`ChannelUpdate`]: msgs::ChannelUpdate
+ * [`ChannelUnavailable`]: APIError::ChannelUnavailable
+ * [`APIMisuseError`]: APIError::APIMisuseError
+ */
+MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_update_channel_config(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPublicKey counterparty_node_id, struct LDKCVec_ThirtyTwoBytesZ channel_ids, const struct LDKChannelConfig *NONNULL_PTR config);
+
 /**
  * Processes HTLCs which are pending waiting on random forward delay.
  *
@@ -20447,6 +20725,8 @@ void ChannelManager_process_pending_htlc_forwards(const struct LDKChannelManager
  *  * Broadcasting `ChannelUpdate` messages if we've been disconnected from our peer for more
  *    than a minute, informing the network that they should no longer attempt to route over
  *    the channel.
+ *  * Expiring a channel's previous `ChannelConfig` if necessary to only allow forwarding HTLCs
+ *    with the current `ChannelConfig`.
  *
  * Note that this may cause reentrancy through `chain::Watch::update_channel` calls or feerate
  * estimate fetches.
@@ -25915,7 +26195,7 @@ struct LDKEffectiveCapacity EffectiveCapacity_maximum_htlc(uint64_t amount_msat)
 /**
  * Utility method to constructs a new Total-variant EffectiveCapacity
  */
-struct LDKEffectiveCapacity EffectiveCapacity_total(uint64_t capacity_msat);
+struct LDKEffectiveCapacity EffectiveCapacity_total(uint64_t capacity_msat, struct LDKCOption_u64Z htlc_maximum_msat);
 
 /**
  * Utility method to constructs a new Infinite-variant EffectiveCapacity
@@ -26033,14 +26313,14 @@ void NodeAnnouncementInfo_set_rgb(struct LDKNodeAnnouncementInfo *NONNULL_PTR th
  * May be invalid or malicious (eg control chars),
  * should not be exposed to the user.
  */
-const uint8_t (*NodeAnnouncementInfo_get_alias(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[32];
+struct LDKNodeAlias NodeAnnouncementInfo_get_alias(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
 
 /**
  * Moniker assigned to the node.
  * May be invalid or malicious (eg control chars),
  * should not be exposed to the user.
  */
-void NodeAnnouncementInfo_set_alias(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
+void NodeAnnouncementInfo_set_alias(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAlias val);
 
 /**
  * Internet-level addresses via which one can connect to the node
@@ -26070,7 +26350,7 @@ void NodeAnnouncementInfo_set_announcement_message(struct LDKNodeAnnouncementInf
 /**
  * Constructs a new NodeAnnouncementInfo given each field
  */
-MUST_USE_RES struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_new(struct LDKNodeFeatures features_arg, uint32_t last_update_arg, struct LDKThreeBytes rgb_arg, struct LDKThirtyTwoBytes alias_arg, struct LDKCVec_NetAddressZ addresses_arg, struct LDKNodeAnnouncement announcement_message_arg);
+MUST_USE_RES struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_new(struct LDKNodeFeatures features_arg, uint32_t last_update_arg, struct LDKThreeBytes rgb_arg, struct LDKNodeAlias alias_arg, struct LDKCVec_NetAddressZ addresses_arg, struct LDKNodeAnnouncement announcement_message_arg);
 
 /**
  * Creates a copy of the NodeAnnouncementInfo
@@ -26087,6 +26367,35 @@ struct LDKCVec_u8Z NodeAnnouncementInfo_write(const struct LDKNodeAnnouncementIn
  */
 struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ NodeAnnouncementInfo_read(struct LDKu8slice ser);
 
+/**
+ * Frees any resources used by the NodeAlias, if is_owned is set and inner is non-NULL.
+ */
+void NodeAlias_free(struct LDKNodeAlias this_obj);
+
+const uint8_t (*NodeAlias_get_a(const struct LDKNodeAlias *NONNULL_PTR this_ptr))[32];
+
+void NodeAlias_set_a(struct LDKNodeAlias *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
+
+/**
+ * Constructs a new NodeAlias given each field
+ */
+MUST_USE_RES struct LDKNodeAlias NodeAlias_new(struct LDKThirtyTwoBytes a_arg);
+
+/**
+ * Creates a copy of the NodeAlias
+ */
+struct LDKNodeAlias NodeAlias_clone(const struct LDKNodeAlias *NONNULL_PTR orig);
+
+/**
+ * Serialize the NodeAlias object into a byte array which can be read by NodeAlias_read
+ */
+struct LDKCVec_u8Z NodeAlias_write(const struct LDKNodeAlias *NONNULL_PTR obj);
+
+/**
+ * Read a NodeAlias from a byte array, created by NodeAlias_write
+ */
+struct LDKCResult_NodeAliasDecodeErrorZ NodeAlias_read(struct LDKu8slice ser);
+
 /**
  * Frees any resources used by the NodeInfo, if is_owned is set and inner is non-NULL.
  */
@@ -26622,18 +26931,32 @@ void PaymentParameters_set_expiry_time(struct LDKPaymentParameters *NONNULL_PTR
 
 /**
  * The maximum total CLTV delta we accept for the route.
+ * Defaults to [`DEFAULT_MAX_TOTAL_CLTV_EXPIRY_DELTA`].
  */
 uint32_t PaymentParameters_get_max_total_cltv_expiry_delta(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
 
 /**
  * The maximum total CLTV delta we accept for the route.
+ * Defaults to [`DEFAULT_MAX_TOTAL_CLTV_EXPIRY_DELTA`].
  */
 void PaymentParameters_set_max_total_cltv_expiry_delta(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint32_t val);
 
+/**
+ * The maximum number of paths that may be used by MPP payments.
+ * Defaults to [`DEFAULT_MAX_MPP_PATH_COUNT`].
+ */
+uint8_t PaymentParameters_get_max_mpp_path_count(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
+
+/**
+ * The maximum number of paths that may be used by MPP payments.
+ * Defaults to [`DEFAULT_MAX_MPP_PATH_COUNT`].
+ */
+void PaymentParameters_set_max_mpp_path_count(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint8_t val);
+
 /**
  * Constructs a new PaymentParameters given each field
  */
-MUST_USE_RES struct LDKPaymentParameters PaymentParameters_new(struct LDKPublicKey payee_pubkey_arg, struct LDKInvoiceFeatures features_arg, struct LDKCVec_RouteHintZ route_hints_arg, struct LDKCOption_u64Z expiry_time_arg, uint32_t max_total_cltv_expiry_delta_arg);
+MUST_USE_RES struct LDKPaymentParameters PaymentParameters_new(struct LDKPublicKey payee_pubkey_arg, struct LDKInvoiceFeatures features_arg, struct LDKCVec_RouteHintZ route_hints_arg, struct LDKCOption_u64Z expiry_time_arg, uint32_t max_total_cltv_expiry_delta_arg, uint8_t max_mpp_path_count_arg);
 
 /**
  * Creates a copy of the PaymentParameters
@@ -27091,9 +27414,24 @@ uint64_t ProbabilisticScoringParameters_get_amount_penalty_multiplier_msat(const
 void ProbabilisticScoringParameters_set_amount_penalty_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
 
 /**
- * Constructs a new ProbabilisticScoringParameters given each field
+ * This penalty is applied when `htlc_maximum_msat` is equal to or larger than half of the
+ * channel's capacity, which makes us prefer nodes with a smaller `htlc_maximum_msat`. We
+ * treat such nodes preferentially as this makes balance discovery attacks harder to execute,
+ * thereby creating an incentive to restrict `htlc_maximum_msat` and improve privacy.
+ *
+ * Default value: 250 msat
  */
-MUST_USE_RES struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_new(uint64_t base_penalty_msat_arg, uint64_t liquidity_penalty_multiplier_msat_arg, uint64_t liquidity_offset_half_life_arg, uint64_t amount_penalty_multiplier_msat_arg);
+uint64_t ProbabilisticScoringParameters_get_anti_probing_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
+
+/**
+ * This penalty is applied when `htlc_maximum_msat` is equal to or larger than half of the
+ * channel's capacity, which makes us prefer nodes with a smaller `htlc_maximum_msat`. We
+ * treat such nodes preferentially as this makes balance discovery attacks harder to execute,
+ * thereby creating an incentive to restrict `htlc_maximum_msat` and improve privacy.
+ *
+ * Default value: 250 msat
+ */
+void ProbabilisticScoringParameters_set_anti_probing_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
 
 /**
  * Creates a copy of the ProbabilisticScoringParameters
@@ -27114,6 +27452,34 @@ MUST_USE_RES struct LDKProbabilisticScorer ProbabilisticScorer_new(struct LDKPro
  */
 void ProbabilisticScorer_debug_log_liquidity_stats(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
 
+/**
+ * Query the estimated minimum and maximum liquidity available for sending a payment over the
+ * channel with `scid` towards the given `target` node.
+ */
+MUST_USE_RES struct LDKCOption_C2Tuple_u64u64ZZ ProbabilisticScorer_estimated_channel_liquidity_range(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg, uint64_t scid, const struct LDKNodeId *NONNULL_PTR target);
+
+/**
+ * Marks the node with the given `node_id` as banned, i.e.,
+ * it will be avoided during path finding.
+ */
+void ProbabilisticScorer_add_banned(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
+
+/**
+ * Removes the node with the given `node_id` from the list of nodes to avoid.
+ */
+void ProbabilisticScorer_remove_banned(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
+
+/**
+ * Clears the list of nodes that are avoided during path finding.
+ */
+void ProbabilisticScorer_clear_banned(struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
+
+/**
+ * Marks all nodes in the given list as banned, i.e.,
+ * they will be avoided during path finding.
+ */
+void ProbabilisticScoringParameters_add_banned_from_list(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_arg, struct LDKCVec_NodeIdZ node_ids);
+
 /**
  * Creates a "default" ProbabilisticScoringParameters. See struct and individual field documentaiton for details on which values are used.
  */
@@ -27213,7 +27579,7 @@ struct LDKGossipSync GossipSync_none(void);
  *
  * # Rapid Gossip Sync
  *
- * If rapid gossip sync is meant to run at startup, pass a [`RapidGossipSync`] to `gossip_sync`
+ * If rapid gossip sync is meant to run at startup, pass [`RapidGossipSync`] via `gossip_sync`
  * to indicate that the [`BackgroundProcessor`] should not prune the [`NetworkGraph`] instance
  * until the [`RapidGossipSync`] instance completes its first sync.
  *
index d63c217d3a16cfc44577918a56fe4f0a9231c1aa..1b383c094ef84d04f9c2694795496e86f793b4b0 100644 (file)
@@ -67,6 +67,7 @@ class DirectedChannelInfo;
 class EffectiveCapacity;
 class RoutingFees;
 class NodeAnnouncementInfo;
+class NodeAlias;
 class NodeInfo;
 class DelayedPaymentOutputDescriptor;
 class StaticPaymentOutputDescriptor;
@@ -189,6 +190,7 @@ class ChainMonitor;
 class CVec_SpendableOutputDescriptorZ;
 class CResult_LockedChannelMonitorNoneZ;
 class CResult_PhantomRouteHintsDecodeErrorZ;
+class COption_C2Tuple_u64u64ZZ;
 class CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ;
 class CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ;
 class CResult_HTLCUpdateDecodeErrorZ;
@@ -214,8 +216,8 @@ class CResult_ChannelReestablishDecodeErrorZ;
 class CResult_CommitmentSignedDecodeErrorZ;
 class CVec_UpdateAddHTLCZ;
 class CResult_UnsignedNodeAnnouncementDecodeErrorZ;
-class CResult_InitFeaturesDecodeErrorZ;
 class COption_u32Z;
+class CResult_InitFeaturesDecodeErrorZ;
 class CResult_StaticPaymentOutputDescriptorDecodeErrorZ;
 class CResult_PaymentIdPaymentSendFailureZ;
 class CResult_ReplyChannelRangeDecodeErrorZ;
@@ -231,9 +233,9 @@ class CVec_TransactionOutputsZ;
 class CResult_ErrorMessageDecodeErrorZ;
 class CResult_OpenChannelDecodeErrorZ;
 class CVec_CVec_u8ZZ;
-class CResult_ProbabilisticScorerDecodeErrorZ;
 class CResult_SecretKeyErrorZ;
 class CResult_ShutdownScriptDecodeErrorZ;
+class CResult_ProbabilisticScorerDecodeErrorZ;
 class CResult_QueryChannelRangeDecodeErrorZ;
 class CResult_TxCreationKeysDecodeErrorZ;
 class C2Tuple_usizeTransactionZ;
@@ -259,12 +261,14 @@ class CVec_UpdateFailMalformedHTLCZ;
 class CResult_FundingSignedDecodeErrorZ;
 class CResult_NetworkGraphDecodeErrorZ;
 class CVec_RouteHopZ;
+class CResult_NonePaymentSendFailureZ;
 class CResult_NodeInfoDecodeErrorZ;
-class CVec_C2Tuple_BlockHashChannelMonitorZZ;
 class CResult_RouteLightningErrorZ;
 class CResult_ChannelPublicKeysDecodeErrorZ;
+class CVec_NodeIdZ;
 class CVec_u8Z;
-class CResult_NonePaymentSendFailureZ;
+class CVec_C2Tuple_BlockHashChannelMonitorZZ;
+class CVec_ThirtyTwoBytesZ;
 class CResult_ClosingSignedDecodeErrorZ;
 class CResult_HolderCommitmentTransactionDecodeErrorZ;
 class CVec_CResult_NoneAPIErrorZZ;
@@ -344,6 +348,7 @@ class CVec_PublicKeyZ;
 class CVec_C2Tuple_usizeTransactionZZ;
 class CVec_PhantomRouteHintsZ;
 class COption_MonitorEventZ;
+class C2Tuple_u64u64Z;
 class COption_TypeZ;
 class CResult_COption_TypeZDecodeErrorZ;
 class C2Tuple_u32TxOutZ;
@@ -368,13 +373,14 @@ class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ;
 class CResult_NoneNoneZ;
 class CResult_RouteParametersDecodeErrorZ;
 class COption_ClosureReasonZ;
+class CResult_NodeAliasDecodeErrorZ;
 class CVec_APIErrorZ;
 class CResult_PrivateRouteCreationErrorZ;
 class CResult_boolPeerHandleErrorZ;
-class CResult_ChannelUpdateDecodeErrorZ;
 class CVec_UpdateFulfillHTLCZ;
 class CResult_AnnouncementSignaturesDecodeErrorZ;
 class CResult_UpdateFulfillHTLCDecodeErrorZ;
+class CResult_ChannelUpdateDecodeErrorZ;
 class CResult_NodeFeaturesDecodeErrorZ;
 class CVec_u5Z;
 class CResult_InMemorySignerDecodeErrorZ;
@@ -1560,6 +1566,21 @@ public:
        const LDKNodeAnnouncementInfo* operator &() const { return &self; }
        const LDKNodeAnnouncementInfo* operator ->() const { return &self; }
 };
+class NodeAlias {
+private:
+       LDKNodeAlias self;
+public:
+       NodeAlias(const NodeAlias&) = delete;
+       NodeAlias(NodeAlias&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAlias)); }
+       NodeAlias(LDKNodeAlias&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAlias)); }
+       operator LDKNodeAlias() && { LDKNodeAlias res = self; memset(&self, 0, sizeof(LDKNodeAlias)); return res; }
+       ~NodeAlias() { NodeAlias_free(self); }
+       NodeAlias& operator=(NodeAlias&& o) { NodeAlias_free(self); self = o.self; memset(&o, 0, sizeof(NodeAlias)); return *this; }
+       LDKNodeAlias* operator &() { return &self; }
+       LDKNodeAlias* operator ->() { return &self; }
+       const LDKNodeAlias* operator &() const { return &self; }
+       const LDKNodeAlias* operator ->() const { return &self; }
+};
 class NodeInfo {
 private:
        LDKNodeInfo self;
@@ -1844,7 +1865,9 @@ public:
        const LDKKeysInterface* operator &() const { return &self; }
        const LDKKeysInterface* operator ->() const { return &self; }
        /**
-        *  Get node secret key (aka node_id or network_key) based on the provided [`Recipient`].
+        *  Get node secret key based on the provided [`Recipient`].
+        * 
+        *  The node_id/network_key is the public key that corresponds to this secret key.
         * 
         *  This method must return the same value each time it is called with a given `Recipient`
         *  parameter.
@@ -3923,6 +3946,21 @@ public:
        const LDKCResult_PhantomRouteHintsDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_PhantomRouteHintsDecodeErrorZ* operator ->() const { return &self; }
 };
+class COption_C2Tuple_u64u64ZZ {
+private:
+       LDKCOption_C2Tuple_u64u64ZZ self;
+public:
+       COption_C2Tuple_u64u64ZZ(const COption_C2Tuple_u64u64ZZ&) = delete;
+       COption_C2Tuple_u64u64ZZ(COption_C2Tuple_u64u64ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_u64u64ZZ)); }
+       COption_C2Tuple_u64u64ZZ(LDKCOption_C2Tuple_u64u64ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_u64u64ZZ)); }
+       operator LDKCOption_C2Tuple_u64u64ZZ() && { LDKCOption_C2Tuple_u64u64ZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_u64u64ZZ)); return res; }
+       ~COption_C2Tuple_u64u64ZZ() { COption_C2Tuple_u64u64ZZ_free(self); }
+       COption_C2Tuple_u64u64ZZ& operator=(COption_C2Tuple_u64u64ZZ&& o) { COption_C2Tuple_u64u64ZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_C2Tuple_u64u64ZZ)); return *this; }
+       LDKCOption_C2Tuple_u64u64ZZ* operator &() { return &self; }
+       LDKCOption_C2Tuple_u64u64ZZ* operator ->() { return &self; }
+       const LDKCOption_C2Tuple_u64u64ZZ* operator &() const { return &self; }
+       const LDKCOption_C2Tuple_u64u64ZZ* operator ->() const { return &self; }
+};
 class CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {
 private:
        LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ self;
@@ -4298,21 +4336,6 @@ public:
        const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator ->() const { return &self; }
 };
-class CResult_InitFeaturesDecodeErrorZ {
-private:
-       LDKCResult_InitFeaturesDecodeErrorZ self;
-public:
-       CResult_InitFeaturesDecodeErrorZ(const CResult_InitFeaturesDecodeErrorZ&) = delete;
-       CResult_InitFeaturesDecodeErrorZ(CResult_InitFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InitFeaturesDecodeErrorZ)); }
-       CResult_InitFeaturesDecodeErrorZ(LDKCResult_InitFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InitFeaturesDecodeErrorZ)); }
-       operator LDKCResult_InitFeaturesDecodeErrorZ() && { LDKCResult_InitFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InitFeaturesDecodeErrorZ)); return res; }
-       ~CResult_InitFeaturesDecodeErrorZ() { CResult_InitFeaturesDecodeErrorZ_free(self); }
-       CResult_InitFeaturesDecodeErrorZ& operator=(CResult_InitFeaturesDecodeErrorZ&& o) { CResult_InitFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InitFeaturesDecodeErrorZ)); return *this; }
-       LDKCResult_InitFeaturesDecodeErrorZ* operator &() { return &self; }
-       LDKCResult_InitFeaturesDecodeErrorZ* operator ->() { return &self; }
-       const LDKCResult_InitFeaturesDecodeErrorZ* operator &() const { return &self; }
-       const LDKCResult_InitFeaturesDecodeErrorZ* operator ->() const { return &self; }
-};
 class COption_u32Z {
 private:
        LDKCOption_u32Z self;
@@ -4328,6 +4351,21 @@ public:
        const LDKCOption_u32Z* operator &() const { return &self; }
        const LDKCOption_u32Z* operator ->() const { return &self; }
 };
+class CResult_InitFeaturesDecodeErrorZ {
+private:
+       LDKCResult_InitFeaturesDecodeErrorZ self;
+public:
+       CResult_InitFeaturesDecodeErrorZ(const CResult_InitFeaturesDecodeErrorZ&) = delete;
+       CResult_InitFeaturesDecodeErrorZ(CResult_InitFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InitFeaturesDecodeErrorZ)); }
+       CResult_InitFeaturesDecodeErrorZ(LDKCResult_InitFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InitFeaturesDecodeErrorZ)); }
+       operator LDKCResult_InitFeaturesDecodeErrorZ() && { LDKCResult_InitFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InitFeaturesDecodeErrorZ)); return res; }
+       ~CResult_InitFeaturesDecodeErrorZ() { CResult_InitFeaturesDecodeErrorZ_free(self); }
+       CResult_InitFeaturesDecodeErrorZ& operator=(CResult_InitFeaturesDecodeErrorZ&& o) { CResult_InitFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InitFeaturesDecodeErrorZ)); return *this; }
+       LDKCResult_InitFeaturesDecodeErrorZ* operator &() { return &self; }
+       LDKCResult_InitFeaturesDecodeErrorZ* operator ->() { return &self; }
+       const LDKCResult_InitFeaturesDecodeErrorZ* operator &() const { return &self; }
+       const LDKCResult_InitFeaturesDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_StaticPaymentOutputDescriptorDecodeErrorZ {
 private:
        LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ self;
@@ -4553,21 +4591,6 @@ public:
        const LDKCVec_CVec_u8ZZ* operator &() const { return &self; }
        const LDKCVec_CVec_u8ZZ* operator ->() const { return &self; }
 };
-class CResult_ProbabilisticScorerDecodeErrorZ {
-private:
-       LDKCResult_ProbabilisticScorerDecodeErrorZ self;
-public:
-       CResult_ProbabilisticScorerDecodeErrorZ(const CResult_ProbabilisticScorerDecodeErrorZ&) = delete;
-       CResult_ProbabilisticScorerDecodeErrorZ(CResult_ProbabilisticScorerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ProbabilisticScorerDecodeErrorZ)); }
-       CResult_ProbabilisticScorerDecodeErrorZ(LDKCResult_ProbabilisticScorerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ProbabilisticScorerDecodeErrorZ)); }
-       operator LDKCResult_ProbabilisticScorerDecodeErrorZ() && { LDKCResult_ProbabilisticScorerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ProbabilisticScorerDecodeErrorZ)); return res; }
-       ~CResult_ProbabilisticScorerDecodeErrorZ() { CResult_ProbabilisticScorerDecodeErrorZ_free(self); }
-       CResult_ProbabilisticScorerDecodeErrorZ& operator=(CResult_ProbabilisticScorerDecodeErrorZ&& o) { CResult_ProbabilisticScorerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ProbabilisticScorerDecodeErrorZ)); return *this; }
-       LDKCResult_ProbabilisticScorerDecodeErrorZ* operator &() { return &self; }
-       LDKCResult_ProbabilisticScorerDecodeErrorZ* operator ->() { return &self; }
-       const LDKCResult_ProbabilisticScorerDecodeErrorZ* operator &() const { return &self; }
-       const LDKCResult_ProbabilisticScorerDecodeErrorZ* operator ->() const { return &self; }
-};
 class CResult_SecretKeyErrorZ {
 private:
        LDKCResult_SecretKeyErrorZ self;
@@ -4598,6 +4621,21 @@ public:
        const LDKCResult_ShutdownScriptDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_ShutdownScriptDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_ProbabilisticScorerDecodeErrorZ {
+private:
+       LDKCResult_ProbabilisticScorerDecodeErrorZ self;
+public:
+       CResult_ProbabilisticScorerDecodeErrorZ(const CResult_ProbabilisticScorerDecodeErrorZ&) = delete;
+       CResult_ProbabilisticScorerDecodeErrorZ(CResult_ProbabilisticScorerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ProbabilisticScorerDecodeErrorZ)); }
+       CResult_ProbabilisticScorerDecodeErrorZ(LDKCResult_ProbabilisticScorerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ProbabilisticScorerDecodeErrorZ)); }
+       operator LDKCResult_ProbabilisticScorerDecodeErrorZ() && { LDKCResult_ProbabilisticScorerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ProbabilisticScorerDecodeErrorZ)); return res; }
+       ~CResult_ProbabilisticScorerDecodeErrorZ() { CResult_ProbabilisticScorerDecodeErrorZ_free(self); }
+       CResult_ProbabilisticScorerDecodeErrorZ& operator=(CResult_ProbabilisticScorerDecodeErrorZ&& o) { CResult_ProbabilisticScorerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ProbabilisticScorerDecodeErrorZ)); return *this; }
+       LDKCResult_ProbabilisticScorerDecodeErrorZ* operator &() { return &self; }
+       LDKCResult_ProbabilisticScorerDecodeErrorZ* operator ->() { return &self; }
+       const LDKCResult_ProbabilisticScorerDecodeErrorZ* operator &() const { return &self; }
+       const LDKCResult_ProbabilisticScorerDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_QueryChannelRangeDecodeErrorZ {
 private:
        LDKCResult_QueryChannelRangeDecodeErrorZ self;
@@ -4973,6 +5011,21 @@ public:
        const LDKCVec_RouteHopZ* operator &() const { return &self; }
        const LDKCVec_RouteHopZ* operator ->() const { return &self; }
 };
+class CResult_NonePaymentSendFailureZ {
+private:
+       LDKCResult_NonePaymentSendFailureZ self;
+public:
+       CResult_NonePaymentSendFailureZ(const CResult_NonePaymentSendFailureZ&) = delete;
+       CResult_NonePaymentSendFailureZ(CResult_NonePaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); }
+       CResult_NonePaymentSendFailureZ(LDKCResult_NonePaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); }
+       operator LDKCResult_NonePaymentSendFailureZ() && { LDKCResult_NonePaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); return res; }
+       ~CResult_NonePaymentSendFailureZ() { CResult_NonePaymentSendFailureZ_free(self); }
+       CResult_NonePaymentSendFailureZ& operator=(CResult_NonePaymentSendFailureZ&& o) { CResult_NonePaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); return *this; }
+       LDKCResult_NonePaymentSendFailureZ* operator &() { return &self; }
+       LDKCResult_NonePaymentSendFailureZ* operator ->() { return &self; }
+       const LDKCResult_NonePaymentSendFailureZ* operator &() const { return &self; }
+       const LDKCResult_NonePaymentSendFailureZ* operator ->() const { return &self; }
+};
 class CResult_NodeInfoDecodeErrorZ {
 private:
        LDKCResult_NodeInfoDecodeErrorZ self;
@@ -4988,21 +5041,6 @@ public:
        const LDKCResult_NodeInfoDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_NodeInfoDecodeErrorZ* operator ->() const { return &self; }
 };
-class CVec_C2Tuple_BlockHashChannelMonitorZZ {
-private:
-       LDKCVec_C2Tuple_BlockHashChannelMonitorZZ self;
-public:
-       CVec_C2Tuple_BlockHashChannelMonitorZZ(const CVec_C2Tuple_BlockHashChannelMonitorZZ&) = delete;
-       CVec_C2Tuple_BlockHashChannelMonitorZZ(CVec_C2Tuple_BlockHashChannelMonitorZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_BlockHashChannelMonitorZZ)); }
-       CVec_C2Tuple_BlockHashChannelMonitorZZ(LDKCVec_C2Tuple_BlockHashChannelMonitorZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_BlockHashChannelMonitorZZ)); }
-       operator LDKCVec_C2Tuple_BlockHashChannelMonitorZZ() && { LDKCVec_C2Tuple_BlockHashChannelMonitorZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_BlockHashChannelMonitorZZ)); return res; }
-       ~CVec_C2Tuple_BlockHashChannelMonitorZZ() { CVec_C2Tuple_BlockHashChannelMonitorZZ_free(self); }
-       CVec_C2Tuple_BlockHashChannelMonitorZZ& operator=(CVec_C2Tuple_BlockHashChannelMonitorZZ&& o) { CVec_C2Tuple_BlockHashChannelMonitorZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_BlockHashChannelMonitorZZ)); return *this; }
-       LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator &() { return &self; }
-       LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator ->() { return &self; }
-       const LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator &() const { return &self; }
-       const LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator ->() const { return &self; }
-};
 class CResult_RouteLightningErrorZ {
 private:
        LDKCResult_RouteLightningErrorZ self;
@@ -5033,6 +5071,21 @@ public:
        const LDKCResult_ChannelPublicKeysDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_ChannelPublicKeysDecodeErrorZ* operator ->() const { return &self; }
 };
+class CVec_NodeIdZ {
+private:
+       LDKCVec_NodeIdZ self;
+public:
+       CVec_NodeIdZ(const CVec_NodeIdZ&) = delete;
+       CVec_NodeIdZ(CVec_NodeIdZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_NodeIdZ)); }
+       CVec_NodeIdZ(LDKCVec_NodeIdZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_NodeIdZ)); }
+       operator LDKCVec_NodeIdZ() && { LDKCVec_NodeIdZ res = self; memset(&self, 0, sizeof(LDKCVec_NodeIdZ)); return res; }
+       ~CVec_NodeIdZ() { CVec_NodeIdZ_free(self); }
+       CVec_NodeIdZ& operator=(CVec_NodeIdZ&& o) { CVec_NodeIdZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_NodeIdZ)); return *this; }
+       LDKCVec_NodeIdZ* operator &() { return &self; }
+       LDKCVec_NodeIdZ* operator ->() { return &self; }
+       const LDKCVec_NodeIdZ* operator &() const { return &self; }
+       const LDKCVec_NodeIdZ* operator ->() const { return &self; }
+};
 class CVec_u8Z {
 private:
        LDKCVec_u8Z self;
@@ -5048,20 +5101,35 @@ public:
        const LDKCVec_u8Z* operator &() const { return &self; }
        const LDKCVec_u8Z* operator ->() const { return &self; }
 };
-class CResult_NonePaymentSendFailureZ {
+class CVec_C2Tuple_BlockHashChannelMonitorZZ {
 private:
-       LDKCResult_NonePaymentSendFailureZ self;
+       LDKCVec_C2Tuple_BlockHashChannelMonitorZZ self;
 public:
-       CResult_NonePaymentSendFailureZ(const CResult_NonePaymentSendFailureZ&) = delete;
-       CResult_NonePaymentSendFailureZ(CResult_NonePaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); }
-       CResult_NonePaymentSendFailureZ(LDKCResult_NonePaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); }
-       operator LDKCResult_NonePaymentSendFailureZ() && { LDKCResult_NonePaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); return res; }
-       ~CResult_NonePaymentSendFailureZ() { CResult_NonePaymentSendFailureZ_free(self); }
-       CResult_NonePaymentSendFailureZ& operator=(CResult_NonePaymentSendFailureZ&& o) { CResult_NonePaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); return *this; }
-       LDKCResult_NonePaymentSendFailureZ* operator &() { return &self; }
-       LDKCResult_NonePaymentSendFailureZ* operator ->() { return &self; }
-       const LDKCResult_NonePaymentSendFailureZ* operator &() const { return &self; }
-       const LDKCResult_NonePaymentSendFailureZ* operator ->() const { return &self; }
+       CVec_C2Tuple_BlockHashChannelMonitorZZ(const CVec_C2Tuple_BlockHashChannelMonitorZZ&) = delete;
+       CVec_C2Tuple_BlockHashChannelMonitorZZ(CVec_C2Tuple_BlockHashChannelMonitorZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_BlockHashChannelMonitorZZ)); }
+       CVec_C2Tuple_BlockHashChannelMonitorZZ(LDKCVec_C2Tuple_BlockHashChannelMonitorZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_BlockHashChannelMonitorZZ)); }
+       operator LDKCVec_C2Tuple_BlockHashChannelMonitorZZ() && { LDKCVec_C2Tuple_BlockHashChannelMonitorZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_BlockHashChannelMonitorZZ)); return res; }
+       ~CVec_C2Tuple_BlockHashChannelMonitorZZ() { CVec_C2Tuple_BlockHashChannelMonitorZZ_free(self); }
+       CVec_C2Tuple_BlockHashChannelMonitorZZ& operator=(CVec_C2Tuple_BlockHashChannelMonitorZZ&& o) { CVec_C2Tuple_BlockHashChannelMonitorZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_BlockHashChannelMonitorZZ)); return *this; }
+       LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator &() { return &self; }
+       LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator ->() { return &self; }
+       const LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator &() const { return &self; }
+       const LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator ->() const { return &self; }
+};
+class CVec_ThirtyTwoBytesZ {
+private:
+       LDKCVec_ThirtyTwoBytesZ self;
+public:
+       CVec_ThirtyTwoBytesZ(const CVec_ThirtyTwoBytesZ&) = delete;
+       CVec_ThirtyTwoBytesZ(CVec_ThirtyTwoBytesZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ThirtyTwoBytesZ)); }
+       CVec_ThirtyTwoBytesZ(LDKCVec_ThirtyTwoBytesZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ThirtyTwoBytesZ)); }
+       operator LDKCVec_ThirtyTwoBytesZ() && { LDKCVec_ThirtyTwoBytesZ res = self; memset(&self, 0, sizeof(LDKCVec_ThirtyTwoBytesZ)); return res; }
+       ~CVec_ThirtyTwoBytesZ() { CVec_ThirtyTwoBytesZ_free(self); }
+       CVec_ThirtyTwoBytesZ& operator=(CVec_ThirtyTwoBytesZ&& o) { CVec_ThirtyTwoBytesZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ThirtyTwoBytesZ)); return *this; }
+       LDKCVec_ThirtyTwoBytesZ* operator &() { return &self; }
+       LDKCVec_ThirtyTwoBytesZ* operator ->() { return &self; }
+       const LDKCVec_ThirtyTwoBytesZ* operator &() const { return &self; }
+       const LDKCVec_ThirtyTwoBytesZ* operator ->() const { return &self; }
 };
 class CResult_ClosingSignedDecodeErrorZ {
 private:
@@ -6248,6 +6316,21 @@ public:
        const LDKCOption_MonitorEventZ* operator &() const { return &self; }
        const LDKCOption_MonitorEventZ* operator ->() const { return &self; }
 };
+class C2Tuple_u64u64Z {
+private:
+       LDKC2Tuple_u64u64Z self;
+public:
+       C2Tuple_u64u64Z(const C2Tuple_u64u64Z&) = delete;
+       C2Tuple_u64u64Z(C2Tuple_u64u64Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u64u64Z)); }
+       C2Tuple_u64u64Z(LDKC2Tuple_u64u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u64u64Z)); }
+       operator LDKC2Tuple_u64u64Z() && { LDKC2Tuple_u64u64Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_u64u64Z)); return res; }
+       ~C2Tuple_u64u64Z() { C2Tuple_u64u64Z_free(self); }
+       C2Tuple_u64u64Z& operator=(C2Tuple_u64u64Z&& o) { C2Tuple_u64u64Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u64u64Z)); return *this; }
+       LDKC2Tuple_u64u64Z* operator &() { return &self; }
+       LDKC2Tuple_u64u64Z* operator ->() { return &self; }
+       const LDKC2Tuple_u64u64Z* operator &() const { return &self; }
+       const LDKC2Tuple_u64u64Z* operator ->() const { return &self; }
+};
 class COption_TypeZ {
 private:
        LDKCOption_TypeZ self;
@@ -6608,6 +6691,21 @@ public:
        const LDKCOption_ClosureReasonZ* operator &() const { return &self; }
        const LDKCOption_ClosureReasonZ* operator ->() const { return &self; }
 };
+class CResult_NodeAliasDecodeErrorZ {
+private:
+       LDKCResult_NodeAliasDecodeErrorZ self;
+public:
+       CResult_NodeAliasDecodeErrorZ(const CResult_NodeAliasDecodeErrorZ&) = delete;
+       CResult_NodeAliasDecodeErrorZ(CResult_NodeAliasDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAliasDecodeErrorZ)); }
+       CResult_NodeAliasDecodeErrorZ(LDKCResult_NodeAliasDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAliasDecodeErrorZ)); }
+       operator LDKCResult_NodeAliasDecodeErrorZ() && { LDKCResult_NodeAliasDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAliasDecodeErrorZ)); return res; }
+       ~CResult_NodeAliasDecodeErrorZ() { CResult_NodeAliasDecodeErrorZ_free(self); }
+       CResult_NodeAliasDecodeErrorZ& operator=(CResult_NodeAliasDecodeErrorZ&& o) { CResult_NodeAliasDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAliasDecodeErrorZ)); return *this; }
+       LDKCResult_NodeAliasDecodeErrorZ* operator &() { return &self; }
+       LDKCResult_NodeAliasDecodeErrorZ* operator ->() { return &self; }
+       const LDKCResult_NodeAliasDecodeErrorZ* operator &() const { return &self; }
+       const LDKCResult_NodeAliasDecodeErrorZ* operator ->() const { return &self; }
+};
 class CVec_APIErrorZ {
 private:
        LDKCVec_APIErrorZ self;
@@ -6653,21 +6751,6 @@ public:
        const LDKCResult_boolPeerHandleErrorZ* operator &() const { return &self; }
        const LDKCResult_boolPeerHandleErrorZ* operator ->() const { return &self; }
 };
-class CResult_ChannelUpdateDecodeErrorZ {
-private:
-       LDKCResult_ChannelUpdateDecodeErrorZ self;
-public:
-       CResult_ChannelUpdateDecodeErrorZ(const CResult_ChannelUpdateDecodeErrorZ&) = delete;
-       CResult_ChannelUpdateDecodeErrorZ(CResult_ChannelUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelUpdateDecodeErrorZ)); }
-       CResult_ChannelUpdateDecodeErrorZ(LDKCResult_ChannelUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelUpdateDecodeErrorZ)); }
-       operator LDKCResult_ChannelUpdateDecodeErrorZ() && { LDKCResult_ChannelUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelUpdateDecodeErrorZ)); return res; }
-       ~CResult_ChannelUpdateDecodeErrorZ() { CResult_ChannelUpdateDecodeErrorZ_free(self); }
-       CResult_ChannelUpdateDecodeErrorZ& operator=(CResult_ChannelUpdateDecodeErrorZ&& o) { CResult_ChannelUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelUpdateDecodeErrorZ)); return *this; }
-       LDKCResult_ChannelUpdateDecodeErrorZ* operator &() { return &self; }
-       LDKCResult_ChannelUpdateDecodeErrorZ* operator ->() { return &self; }
-       const LDKCResult_ChannelUpdateDecodeErrorZ* operator &() const { return &self; }
-       const LDKCResult_ChannelUpdateDecodeErrorZ* operator ->() const { return &self; }
-};
 class CVec_UpdateFulfillHTLCZ {
 private:
        LDKCVec_UpdateFulfillHTLCZ self;
@@ -6713,6 +6796,21 @@ public:
        const LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator &() const { return &self; }
        const LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator ->() const { return &self; }
 };
+class CResult_ChannelUpdateDecodeErrorZ {
+private:
+       LDKCResult_ChannelUpdateDecodeErrorZ self;
+public:
+       CResult_ChannelUpdateDecodeErrorZ(const CResult_ChannelUpdateDecodeErrorZ&) = delete;
+       CResult_ChannelUpdateDecodeErrorZ(CResult_ChannelUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelUpdateDecodeErrorZ)); }
+       CResult_ChannelUpdateDecodeErrorZ(LDKCResult_ChannelUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelUpdateDecodeErrorZ)); }
+       operator LDKCResult_ChannelUpdateDecodeErrorZ() && { LDKCResult_ChannelUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelUpdateDecodeErrorZ)); return res; }
+       ~CResult_ChannelUpdateDecodeErrorZ() { CResult_ChannelUpdateDecodeErrorZ_free(self); }
+       CResult_ChannelUpdateDecodeErrorZ& operator=(CResult_ChannelUpdateDecodeErrorZ&& o) { CResult_ChannelUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelUpdateDecodeErrorZ)); return *this; }
+       LDKCResult_ChannelUpdateDecodeErrorZ* operator &() { return &self; }
+       LDKCResult_ChannelUpdateDecodeErrorZ* operator ->() { return &self; }
+       const LDKCResult_ChannelUpdateDecodeErrorZ* operator &() const { return &self; }
+       const LDKCResult_ChannelUpdateDecodeErrorZ* operator ->() const { return &self; }
+};
 class CResult_NodeFeaturesDecodeErrorZ {
 private:
        LDKCResult_NodeFeaturesDecodeErrorZ self;
index c5515a5f14068b57bad504f46b720fc2c7f055c3..dd62ebe8f08fae0ffa3aaf55d346add79d2822a9 100644 (file)
@@ -3951,6 +3951,131 @@ impl Clone for CResult_FixedPenaltyScorerDecodeErrorZ {
 /// but with all dynamically-allocated buffers duplicated in new buffers.
 pub extern "C" fn CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig: &CResult_FixedPenaltyScorerDecodeErrorZ) -> CResult_FixedPenaltyScorerDecodeErrorZ { Clone::clone(&orig) }
 #[repr(C)]
+/// A tuple of 2 elements. See the individual fields for the types contained.
+pub struct C2Tuple_u64u64Z {
+       /// The element at position 0
+       pub a: u64,
+       /// The element at position 1
+       pub b: u64,
+}
+impl From<(u64, u64)> for C2Tuple_u64u64Z {
+       fn from (tup: (u64, u64)) -> Self {
+               Self {
+                       a: tup.0,
+                       b: tup.1,
+               }
+       }
+}
+impl C2Tuple_u64u64Z {
+       #[allow(unused)] pub(crate) fn to_rust(mut self) -> (u64, u64) {
+               (self.a, self.b)
+       }
+}
+impl Clone for C2Tuple_u64u64Z {
+       fn clone(&self) -> Self {
+               Self {
+                       a: Clone::clone(&self.a),
+                       b: Clone::clone(&self.b),
+               }
+       }
+}
+#[no_mangle]
+/// Creates a new tuple which has the same data as `orig`
+/// but with all dynamically-allocated buffers duplicated in new buffers.
+pub extern "C" fn C2Tuple_u64u64Z_clone(orig: &C2Tuple_u64u64Z) -> C2Tuple_u64u64Z { Clone::clone(&orig) }
+/// Creates a new C2Tuple_u64u64Z from the contained elements.
+#[no_mangle]
+pub extern "C" fn C2Tuple_u64u64Z_new(a: u64, b: u64) -> C2Tuple_u64u64Z {
+       C2Tuple_u64u64Z { a, b, }
+}
+
+#[no_mangle]
+/// Frees any resources used by the C2Tuple_u64u64Z.
+pub extern "C" fn C2Tuple_u64u64Z_free(_res: C2Tuple_u64u64Z) { }
+#[repr(C)]
+#[derive(Clone)]
+/// An enum which can either contain a crate::c_types::derived::C2Tuple_u64u64Z or not
+pub enum COption_C2Tuple_u64u64ZZ {
+       /// When we're in this state, this COption_C2Tuple_u64u64ZZ contains a crate::c_types::derived::C2Tuple_u64u64Z
+       Some(crate::c_types::derived::C2Tuple_u64u64Z),
+       /// When we're in this state, this COption_C2Tuple_u64u64ZZ contains nothing
+       None
+}
+impl COption_C2Tuple_u64u64ZZ {
+       #[allow(unused)] pub(crate) fn is_some(&self) -> bool {
+               if let Self::None = self { false } else { true }
+       }
+       #[allow(unused)] pub(crate) fn is_none(&self) -> bool {
+               !self.is_some()
+       }
+       #[allow(unused)] pub(crate) fn take(mut self) -> crate::c_types::derived::C2Tuple_u64u64Z {
+               if let Self::Some(v) = self { v } else { unreachable!() }
+       }
+}
+#[no_mangle]
+/// Constructs a new COption_C2Tuple_u64u64ZZ containing a crate::c_types::derived::C2Tuple_u64u64Z
+pub extern "C" fn COption_C2Tuple_u64u64ZZ_some(o: crate::c_types::derived::C2Tuple_u64u64Z) -> COption_C2Tuple_u64u64ZZ {
+       COption_C2Tuple_u64u64ZZ::Some(o)
+}
+#[no_mangle]
+/// Constructs a new COption_C2Tuple_u64u64ZZ containing nothing
+pub extern "C" fn COption_C2Tuple_u64u64ZZ_none() -> COption_C2Tuple_u64u64ZZ {
+       COption_C2Tuple_u64u64ZZ::None
+}
+#[no_mangle]
+/// Frees any resources associated with the crate::c_types::derived::C2Tuple_u64u64Z, if we are in the Some state
+pub extern "C" fn COption_C2Tuple_u64u64ZZ_free(_res: COption_C2Tuple_u64u64ZZ) { }
+#[no_mangle]
+/// Creates a new COption_C2Tuple_u64u64ZZ which has the same data as `orig`
+/// but with all dynamically-allocated buffers duplicated in new buffers.
+pub extern "C" fn COption_C2Tuple_u64u64ZZ_clone(orig: &COption_C2Tuple_u64u64ZZ) -> COption_C2Tuple_u64u64ZZ { Clone::clone(&orig) }
+#[repr(C)]
+/// A dynamically-allocated array of crate::lightning::routing::gossip::NodeIds of arbitrary size.
+/// This corresponds to std::vector in C++
+pub struct CVec_NodeIdZ {
+       /// The elements in the array.
+       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+       pub data: *mut crate::lightning::routing::gossip::NodeId,
+       /// The number of elements pointed to by `data`.
+       pub datalen: usize
+}
+impl CVec_NodeIdZ {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::lightning::routing::gossip::NodeId> {
+               if self.datalen == 0 { return Vec::new(); }
+               let ret = unsafe { Box::from_raw(core::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
+               self.data = core::ptr::null_mut();
+               self.datalen = 0;
+               ret
+       }
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::lightning::routing::gossip::NodeId] {
+               unsafe { core::slice::from_raw_parts_mut(self.data, self.datalen) }
+       }
+}
+impl From<Vec<crate::lightning::routing::gossip::NodeId>> for CVec_NodeIdZ {
+       fn from(v: Vec<crate::lightning::routing::gossip::NodeId>) -> Self {
+               let datalen = v.len();
+               let data = Box::into_raw(v.into_boxed_slice());
+               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
+       }
+}
+#[no_mangle]
+/// Frees the buffer pointed to by `data` if `datalen` is non-0.
+pub extern "C" fn CVec_NodeIdZ_free(_res: CVec_NodeIdZ) { }
+impl Drop for CVec_NodeIdZ {
+       fn drop(&mut self) {
+               if self.datalen == 0 { return; }
+               unsafe { Box::from_raw(core::slice::from_raw_parts_mut(self.data, self.datalen)) };
+       }
+}
+impl Clone for CVec_NodeIdZ {
+       fn clone(&self) -> Self {
+               let mut res = Vec::new();
+               if self.datalen == 0 { return Self::from(res); }
+               res.extend_from_slice(unsafe { core::slice::from_raw_parts_mut(self.data, self.datalen) });
+               Self::from(res)
+       }
+}
+#[repr(C)]
 /// The contents of CResult_ProbabilisticScorerDecodeErrorZ
 pub union CResult_ProbabilisticScorerDecodeErrorZPtr {
        /// A pointer to the contents in the success state.
@@ -5490,6 +5615,102 @@ impl Clone for CResult_NodeAnnouncementInfoDecodeErrorZ {
 /// but with all dynamically-allocated buffers duplicated in new buffers.
 pub extern "C" fn CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig: &CResult_NodeAnnouncementInfoDecodeErrorZ) -> CResult_NodeAnnouncementInfoDecodeErrorZ { Clone::clone(&orig) }
 #[repr(C)]
+/// The contents of CResult_NodeAliasDecodeErrorZ
+pub union CResult_NodeAliasDecodeErrorZPtr {
+       /// A pointer to the contents in the success state.
+       /// Reading from this pointer when `result_ok` is not set is undefined.
+       pub result: *mut crate::lightning::routing::gossip::NodeAlias,
+       /// A pointer to the contents in the error state.
+       /// Reading from this pointer when `result_ok` is set is undefined.
+       pub err: *mut crate::lightning::ln::msgs::DecodeError,
+}
+#[repr(C)]
+/// A CResult_NodeAliasDecodeErrorZ represents the result of a fallible operation,
+/// containing a crate::lightning::routing::gossip::NodeAlias on success and a crate::lightning::ln::msgs::DecodeError on failure.
+/// `result_ok` indicates the overall state, and the contents are provided via `contents`.
+pub struct CResult_NodeAliasDecodeErrorZ {
+       /// The contents of this CResult_NodeAliasDecodeErrorZ, accessible via either
+       /// `err` or `result` depending on the state of `result_ok`.
+       pub contents: CResult_NodeAliasDecodeErrorZPtr,
+       /// Whether this CResult_NodeAliasDecodeErrorZ represents a success state.
+       pub result_ok: bool,
+}
+#[no_mangle]
+/// Creates a new CResult_NodeAliasDecodeErrorZ in the success state.
+pub extern "C" fn CResult_NodeAliasDecodeErrorZ_ok(o: crate::lightning::routing::gossip::NodeAlias) -> CResult_NodeAliasDecodeErrorZ {
+       CResult_NodeAliasDecodeErrorZ {
+               contents: CResult_NodeAliasDecodeErrorZPtr {
+                       result: Box::into_raw(Box::new(o)),
+               },
+               result_ok: true,
+       }
+}
+#[no_mangle]
+/// Creates a new CResult_NodeAliasDecodeErrorZ in the error state.
+pub extern "C" fn CResult_NodeAliasDecodeErrorZ_err(e: crate::lightning::ln::msgs::DecodeError) -> CResult_NodeAliasDecodeErrorZ {
+       CResult_NodeAliasDecodeErrorZ {
+               contents: CResult_NodeAliasDecodeErrorZPtr {
+                       err: Box::into_raw(Box::new(e)),
+               },
+               result_ok: false,
+       }
+}
+/// Checks if the given object is currently in the success state
+#[no_mangle]
+pub extern "C" fn CResult_NodeAliasDecodeErrorZ_is_ok(o: &CResult_NodeAliasDecodeErrorZ) -> bool {
+       o.result_ok
+}
+#[no_mangle]
+/// Frees any resources used by the CResult_NodeAliasDecodeErrorZ.
+pub extern "C" fn CResult_NodeAliasDecodeErrorZ_free(_res: CResult_NodeAliasDecodeErrorZ) { }
+impl Drop for CResult_NodeAliasDecodeErrorZ {
+       fn drop(&mut self) {
+               if self.result_ok {
+                       if unsafe { !(self.contents.result as *mut ()).is_null() } {
+                               let _ = unsafe { Box::from_raw(self.contents.result) };
+                       }
+               } else {
+                       if unsafe { !(self.contents.err as *mut ()).is_null() } {
+                               let _ = unsafe { Box::from_raw(self.contents.err) };
+                       }
+               }
+       }
+}
+impl From<crate::c_types::CResultTempl<crate::lightning::routing::gossip::NodeAlias, crate::lightning::ln::msgs::DecodeError>> for CResult_NodeAliasDecodeErrorZ {
+       fn from(mut o: crate::c_types::CResultTempl<crate::lightning::routing::gossip::NodeAlias, crate::lightning::ln::msgs::DecodeError>) -> Self {
+               let contents = if o.result_ok {
+                       let result = unsafe { o.contents.result };
+                       unsafe { o.contents.result = core::ptr::null_mut() };
+                       CResult_NodeAliasDecodeErrorZPtr { result }
+               } else {
+                       let err = unsafe { o.contents.err };
+                       unsafe { o.contents.err = core::ptr::null_mut(); }
+                       CResult_NodeAliasDecodeErrorZPtr { err }
+               };
+               Self {
+                       contents,
+                       result_ok: o.result_ok,
+               }
+       }
+}
+impl Clone for CResult_NodeAliasDecodeErrorZ {
+       fn clone(&self) -> Self {
+               if self.result_ok {
+                       Self { result_ok: true, contents: CResult_NodeAliasDecodeErrorZPtr {
+                               result: Box::into_raw(Box::new(<crate::lightning::routing::gossip::NodeAlias>::clone(unsafe { &*self.contents.result })))
+                       } }
+               } else {
+                       Self { result_ok: false, contents: CResult_NodeAliasDecodeErrorZPtr {
+                               err: Box::into_raw(Box::new(<crate::lightning::ln::msgs::DecodeError>::clone(unsafe { &*self.contents.err })))
+                       } }
+               }
+       }
+}
+#[no_mangle]
+/// Creates a new CResult_NodeAliasDecodeErrorZ which has the same data as `orig`
+/// but with all dynamically-allocated buffers duplicated in new buffers.
+pub extern "C" fn CResult_NodeAliasDecodeErrorZ_clone(orig: &CResult_NodeAliasDecodeErrorZ) -> CResult_NodeAliasDecodeErrorZ { Clone::clone(&orig) }
+#[repr(C)]
 /// A dynamically-allocated array of u64s of arbitrary size.
 /// This corresponds to std::vector in C++
 pub struct CVec_u64Z {
@@ -7976,6 +8197,52 @@ impl Clone for CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ {
 /// but with all dynamically-allocated buffers duplicated in new buffers.
 pub extern "C" fn CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig: &CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ) -> CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ { Clone::clone(&orig) }
 #[repr(C)]
+/// A dynamically-allocated array of crate::c_types::ThirtyTwoBytess of arbitrary size.
+/// This corresponds to std::vector in C++
+pub struct CVec_ThirtyTwoBytesZ {
+       /// The elements in the array.
+       /// If datalen is non-0 this must be a valid, non-NULL pointer allocated by malloc().
+       pub data: *mut crate::c_types::ThirtyTwoBytes,
+       /// The number of elements pointed to by `data`.
+       pub datalen: usize
+}
+impl CVec_ThirtyTwoBytesZ {
+       #[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<crate::c_types::ThirtyTwoBytes> {
+               if self.datalen == 0 { return Vec::new(); }
+               let ret = unsafe { Box::from_raw(core::slice::from_raw_parts_mut(self.data, self.datalen)) }.into();
+               self.data = core::ptr::null_mut();
+               self.datalen = 0;
+               ret
+       }
+       #[allow(unused)] pub(crate) fn as_slice(&self) -> &[crate::c_types::ThirtyTwoBytes] {
+               unsafe { core::slice::from_raw_parts_mut(self.data, self.datalen) }
+       }
+}
+impl From<Vec<crate::c_types::ThirtyTwoBytes>> for CVec_ThirtyTwoBytesZ {
+       fn from(v: Vec<crate::c_types::ThirtyTwoBytes>) -> Self {
+               let datalen = v.len();
+               let data = Box::into_raw(v.into_boxed_slice());
+               Self { datalen, data: unsafe { (*data).as_mut_ptr() } }
+       }
+}
+#[no_mangle]
+/// Frees the buffer pointed to by `data` if `datalen` is non-0.
+pub extern "C" fn CVec_ThirtyTwoBytesZ_free(_res: CVec_ThirtyTwoBytesZ) { }
+impl Drop for CVec_ThirtyTwoBytesZ {
+       fn drop(&mut self) {
+               if self.datalen == 0 { return; }
+               unsafe { Box::from_raw(core::slice::from_raw_parts_mut(self.data, self.datalen)) };
+       }
+}
+impl Clone for CVec_ThirtyTwoBytesZ {
+       fn clone(&self) -> Self {
+               let mut res = Vec::new();
+               if self.datalen == 0 { return Self::from(res); }
+               res.extend_from_slice(unsafe { core::slice::from_raw_parts_mut(self.data, self.datalen) });
+               Self::from(res)
+       }
+}
+#[repr(C)]
 /// A tuple of 2 elements. See the individual fields for the types contained.
 pub struct C2Tuple_PaymentHashPaymentSecretZ {
        /// The element at position 0
index 2a0ea4f690989322f93145047344d16d6934f209..181f868d3a7ffe4c125f575b207ae01239331bc1 100644 (file)
@@ -1042,7 +1042,9 @@ pub struct KeysInterface {
        /// An opaque pointer which is passed to your function implementations as an argument.
        /// This has no meaning in the LDK, and can be NULL or any other value.
        pub this_arg: *mut c_void,
-       /// Get node secret key (aka node_id or network_key) based on the provided [`Recipient`].
+       /// Get node secret key based on the provided [`Recipient`].
+       ///
+       /// The node_id/network_key is the public key that corresponds to this secret key.
        ///
        /// This method must return the same value each time it is called with a given `Recipient`
        /// parameter.
index d3a1e7fdedf21ac044cffca8bc4d97608c304b50..a648cdf7a81bc772f297b38bac2c5e67906fe17f 100644 (file)
@@ -943,7 +943,7 @@ pub extern "C" fn ChannelTransactionParameters_set_funding_outpoint(this_ptr: &m
 #[no_mangle]
 pub extern "C" fn ChannelTransactionParameters_get_opt_anchors(this_ptr: &ChannelTransactionParameters) -> crate::c_types::derived::COption_NoneZ {
        let mut inner_val = &mut this_ptr.get_native_mut_ref().opt_anchors;
-       let mut local_inner_val = if inner_val.is_none() { crate::c_types::derived::COption_NoneZ::None } else { crate::c_types::derived::COption_NoneZ::Some /* { () /**/ } */};
+       let mut local_inner_val = if inner_val.is_none() { crate::c_types::derived::COption_NoneZ::None } else { crate::c_types::derived::COption_NoneZ::Some /*  { () /**/ } */ };
        local_inner_val
 }
 /// Are anchors used for this channel.  Boolean is serialization backwards-compatible
index ef3153ac9dea3a5d4d82272dc7a50c131c062f89..e0d04cf708ae9a0dab5336905b1e838ffbf5d217 100644 (file)
@@ -1074,10 +1074,31 @@ pub extern "C" fn ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr: &mut Ch
        let mut local_val = if val.is_some() { Some( { val.take() }) } else { None };
        unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.inbound_htlc_maximum_msat = local_val;
 }
+/// Set of configurable parameters that affect channel operation.
+///
+/// This field is only `None` for `ChannelDetails` objects serialized prior to LDK 0.0.109.
+///
+/// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
+#[no_mangle]
+pub extern "C" fn ChannelDetails_get_config(this_ptr: &ChannelDetails) -> crate::lightning::util::config::ChannelConfig {
+       let mut inner_val = &mut this_ptr.get_native_mut_ref().config;
+       let mut local_inner_val = crate::lightning::util::config::ChannelConfig { inner: unsafe { (if inner_val.is_none() { core::ptr::null() } else { ObjOps::nonnull_ptr_to_inner( { (inner_val.as_ref().unwrap()) }) } as *const lightning::util::config::ChannelConfig<>) as *mut _ }, is_owned: false };
+       local_inner_val
+}
+/// Set of configurable parameters that affect channel operation.
+///
+/// This field is only `None` for `ChannelDetails` objects serialized prior to LDK 0.0.109.
+///
+/// Note that val (or a relevant inner pointer) may be NULL or all-0s to represent None
+#[no_mangle]
+pub extern "C" fn ChannelDetails_set_config(this_ptr: &mut ChannelDetails, mut val: crate::lightning::util::config::ChannelConfig) {
+       let mut local_val = if val.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(val.take_inner()) } }) };
+       unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.config = local_val;
+}
 /// Constructs a new ChannelDetails given each field
 #[must_use]
 #[no_mangle]
-pub extern "C" fn ChannelDetails_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut counterparty_arg: crate::lightning::ln::channelmanager::ChannelCounterparty, mut funding_txo_arg: crate::lightning::chain::transaction::OutPoint, mut channel_type_arg: crate::lightning::ln::features::ChannelTypeFeatures, mut short_channel_id_arg: crate::c_types::derived::COption_u64Z, mut outbound_scid_alias_arg: crate::c_types::derived::COption_u64Z, mut inbound_scid_alias_arg: crate::c_types::derived::COption_u64Z, mut channel_value_satoshis_arg: u64, mut unspendable_punishment_reserve_arg: crate::c_types::derived::COption_u64Z, mut user_channel_id_arg: u64, mut balance_msat_arg: u64, mut outbound_capacity_msat_arg: u64, mut next_outbound_htlc_limit_msat_arg: u64, mut inbound_capacity_msat_arg: u64, mut confirmations_required_arg: crate::c_types::derived::COption_u32Z, mut force_close_spend_delay_arg: crate::c_types::derived::COption_u16Z, mut is_outbound_arg: bool, mut is_channel_ready_arg: bool, mut is_usable_arg: bool, mut is_public_arg: bool, mut inbound_htlc_minimum_msat_arg: crate::c_types::derived::COption_u64Z, mut inbound_htlc_maximum_msat_arg: crate::c_types::derived::COption_u64Z) -> ChannelDetails {
+pub extern "C" fn ChannelDetails_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut counterparty_arg: crate::lightning::ln::channelmanager::ChannelCounterparty, mut funding_txo_arg: crate::lightning::chain::transaction::OutPoint, mut channel_type_arg: crate::lightning::ln::features::ChannelTypeFeatures, mut short_channel_id_arg: crate::c_types::derived::COption_u64Z, mut outbound_scid_alias_arg: crate::c_types::derived::COption_u64Z, mut inbound_scid_alias_arg: crate::c_types::derived::COption_u64Z, mut channel_value_satoshis_arg: u64, mut unspendable_punishment_reserve_arg: crate::c_types::derived::COption_u64Z, mut user_channel_id_arg: u64, mut balance_msat_arg: u64, mut outbound_capacity_msat_arg: u64, mut next_outbound_htlc_limit_msat_arg: u64, mut inbound_capacity_msat_arg: u64, mut confirmations_required_arg: crate::c_types::derived::COption_u32Z, mut force_close_spend_delay_arg: crate::c_types::derived::COption_u16Z, mut is_outbound_arg: bool, mut is_channel_ready_arg: bool, mut is_usable_arg: bool, mut is_public_arg: bool, mut inbound_htlc_minimum_msat_arg: crate::c_types::derived::COption_u64Z, mut inbound_htlc_maximum_msat_arg: crate::c_types::derived::COption_u64Z, mut config_arg: crate::lightning::util::config::ChannelConfig) -> ChannelDetails {
        let mut local_funding_txo_arg = if funding_txo_arg.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(funding_txo_arg.take_inner()) } }) };
        let mut local_channel_type_arg = if channel_type_arg.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(channel_type_arg.take_inner()) } }) };
        let mut local_short_channel_id_arg = if short_channel_id_arg.is_some() { Some( { short_channel_id_arg.take() }) } else { None };
@@ -1088,6 +1109,7 @@ pub extern "C" fn ChannelDetails_new(mut channel_id_arg: crate::c_types::ThirtyT
        let mut local_force_close_spend_delay_arg = if force_close_spend_delay_arg.is_some() { Some( { force_close_spend_delay_arg.take() }) } else { None };
        let mut local_inbound_htlc_minimum_msat_arg = if inbound_htlc_minimum_msat_arg.is_some() { Some( { inbound_htlc_minimum_msat_arg.take() }) } else { None };
        let mut local_inbound_htlc_maximum_msat_arg = if inbound_htlc_maximum_msat_arg.is_some() { Some( { inbound_htlc_maximum_msat_arg.take() }) } else { None };
+       let mut local_config_arg = if config_arg.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(config_arg.take_inner()) } }) };
        ChannelDetails { inner: ObjOps::heap_alloc(nativeChannelDetails {
                channel_id: channel_id_arg.data,
                counterparty: *unsafe { Box::from_raw(counterparty_arg.take_inner()) },
@@ -1111,6 +1133,7 @@ pub extern "C" fn ChannelDetails_new(mut channel_id_arg: crate::c_types::ThirtyT
                is_public: is_public_arg,
                inbound_htlc_minimum_msat: local_inbound_htlc_minimum_msat_arg,
                inbound_htlc_maximum_msat: local_inbound_htlc_maximum_msat_arg,
+               config: local_config_arg,
        }), is_owned: true }
 }
 impl Clone for ChannelDetails {
@@ -1644,14 +1667,28 @@ pub extern "C" fn ChannelManager_close_channel_with_target_feerate(this_arg: &cr
        local_ret
 }
 
-/// Force closes a channel, immediately broadcasting the latest local commitment transaction to
-/// the chain and rejecting new HTLCs on the given channel. Fails if `channel_id` is unknown to
+/// Force closes a channel, immediately broadcasting the latest local transaction(s) and
+/// rejecting new HTLCs on the given channel. Fails if `channel_id` is unknown to
 /// the manager, or if the `counterparty_node_id` isn't the counterparty of the corresponding
 /// channel.
 #[must_use]
 #[no_mangle]
-pub extern "C" fn ChannelManager_force_close_channel(this_arg: &crate::lightning::ln::channelmanager::ChannelManager, channel_id: *const [u8; 32], mut counterparty_node_id: crate::c_types::PublicKey) -> crate::c_types::derived::CResult_NoneAPIErrorZ {
-       let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.force_close_channel(unsafe { &*channel_id}, &counterparty_node_id.into_rust());
+pub extern "C" fn ChannelManager_force_close_broadcasting_latest_txn(this_arg: &crate::lightning::ln::channelmanager::ChannelManager, channel_id: *const [u8; 32], mut counterparty_node_id: crate::c_types::PublicKey) -> crate::c_types::derived::CResult_NoneAPIErrorZ {
+       let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.force_close_broadcasting_latest_txn(unsafe { &*channel_id}, &counterparty_node_id.into_rust());
+       let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { () /*o*/ }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::util::errors::APIError::native_into(e) }).into() };
+       local_ret
+}
+
+/// Force closes a channel, rejecting new HTLCs on the given channel but skips broadcasting
+/// the latest local transaction(s). Fails if `channel_id` is unknown to the manager, or if the
+/// `counterparty_node_id` isn't the counterparty of the corresponding channel.
+///
+/// You can always get the latest local transaction(s) to broadcast from
+/// [`ChannelMonitor::get_latest_holder_commitment_txn`].
+#[must_use]
+#[no_mangle]
+pub extern "C" fn ChannelManager_force_close_without_broadcasting_txn(this_arg: &crate::lightning::ln::channelmanager::ChannelManager, channel_id: *const [u8; 32], mut counterparty_node_id: crate::c_types::PublicKey) -> crate::c_types::derived::CResult_NoneAPIErrorZ {
+       let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.force_close_without_broadcasting_txn(unsafe { &*channel_id}, &counterparty_node_id.into_rust());
        let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { () /*o*/ }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::util::errors::APIError::native_into(e) }).into() };
        local_ret
 }
@@ -1659,8 +1696,15 @@ pub extern "C" fn ChannelManager_force_close_channel(this_arg: &crate::lightning
 /// Force close all channels, immediately broadcasting the latest local commitment transaction
 /// for each to the chain and rejecting new HTLCs on each.
 #[no_mangle]
-pub extern "C" fn ChannelManager_force_close_all_channels(this_arg: &crate::lightning::ln::channelmanager::ChannelManager) {
-       unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.force_close_all_channels()
+pub extern "C" fn ChannelManager_force_close_all_channels_broadcasting_latest_txn(this_arg: &crate::lightning::ln::channelmanager::ChannelManager) {
+       unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.force_close_all_channels_broadcasting_latest_txn()
+}
+
+/// Force close all channels rejecting new HTLCs on each but without broadcasting the latest
+/// local transaction(s).
+#[no_mangle]
+pub extern "C" fn ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg: &crate::lightning::ln::channelmanager::ChannelManager) {
+       unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.force_close_all_channels_without_broadcasting_txn()
 }
 
 /// Sends a payment along a given route.
@@ -1780,6 +1824,9 @@ pub extern "C" fn ChannelManager_send_spontaneous_payment(this_arg: &crate::ligh
 /// Returns an [`APIError::APIMisuseError`] if the funding_transaction spent non-SegWit outputs
 /// or if no output was found which matches the parameters in [`Event::FundingGenerationReady`].
 ///
+/// Returns [`APIError::APIMisuseError`] if the funding transaction is not final for propagation
+/// across the p2p network.
+///
 /// Returns [`APIError::ChannelUnavailable`] if a funding transaction has already been provided
 /// for the channel or if the channel has been closed as indicated by [`Event::ChannelClosed`].
 ///
@@ -1795,6 +1842,11 @@ pub extern "C" fn ChannelManager_send_spontaneous_payment(this_arg: &crate::ligh
 /// not currently support replacing a funding transaction on an existing channel. Instead,
 /// create a new channel with a conflicting funding transaction.
 ///
+/// Note to keep the miner incentives aligned in moving the blockchain forward, we recommend
+/// the wallet software generating the funding transaction to apply anti-fee sniping as
+/// implemented by Bitcoin Core wallet. See <https://bitcoinops.org/en/topics/fee-sniping/>
+/// for more details.
+///
 /// [`Event::FundingGenerationReady`]: crate::util::events::Event::FundingGenerationReady
 /// [`Event::ChannelClosed`]: crate::util::events::Event::ChannelClosed
 #[must_use]
@@ -1829,6 +1881,37 @@ pub extern "C" fn ChannelManager_broadcast_node_announcement(this_arg: &crate::l
        unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.broadcast_node_announcement(rgb.data, alias.data, local_addresses)
 }
 
+/// Atomically updates the [`ChannelConfig`] for the given channels.
+///
+/// Once the updates are applied, each eligible channel (advertised with a known short channel
+/// ID and a change in [`forwarding_fee_proportional_millionths`], [`forwarding_fee_base_msat`],
+/// or [`cltv_expiry_delta`]) has a [`BroadcastChannelUpdate`] event message generated
+/// containing the new [`ChannelUpdate`] message which should be broadcast to the network.
+///
+/// Returns [`ChannelUnavailable`] when a channel is not found or an incorrect
+/// `counterparty_node_id` is provided.
+///
+/// Returns [`APIMisuseError`] when a [`cltv_expiry_delta`] update is to be applied with a value
+/// below [`MIN_CLTV_EXPIRY_DELTA`].
+///
+/// If an error is returned, none of the updates should be considered applied.
+///
+/// [`forwarding_fee_proportional_millionths`]: ChannelConfig::forwarding_fee_proportional_millionths
+/// [`forwarding_fee_base_msat`]: ChannelConfig::forwarding_fee_base_msat
+/// [`cltv_expiry_delta`]: ChannelConfig::cltv_expiry_delta
+/// [`BroadcastChannelUpdate`]: events::MessageSendEvent::BroadcastChannelUpdate
+/// [`ChannelUpdate`]: msgs::ChannelUpdate
+/// [`ChannelUnavailable`]: APIError::ChannelUnavailable
+/// [`APIMisuseError`]: APIError::APIMisuseError
+#[must_use]
+#[no_mangle]
+pub extern "C" fn ChannelManager_update_channel_config(this_arg: &crate::lightning::ln::channelmanager::ChannelManager, mut counterparty_node_id: crate::c_types::PublicKey, mut channel_ids: crate::c_types::derived::CVec_ThirtyTwoBytesZ, config: &crate::lightning::util::config::ChannelConfig) -> crate::c_types::derived::CResult_NoneAPIErrorZ {
+       let mut local_channel_ids = Vec::new(); for mut item in channel_ids.into_rust().drain(..) { local_channel_ids.push( { item.data }); };
+       let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.update_channel_config(&counterparty_node_id.into_rust(), &local_channel_ids.iter().map(|a| *a).collect::<Vec<_>>()[..], config.get_native_ref());
+       let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { () /*o*/ }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::util::errors::APIError::native_into(e) }).into() };
+       local_ret
+}
+
 /// Processes HTLCs which are pending waiting on random forward delay.
 ///
 /// Should only really ever be called in response to a PendingHTLCsForwardable event.
@@ -1845,6 +1928,8 @@ pub extern "C" fn ChannelManager_process_pending_htlc_forwards(this_arg: &crate:
 ///  * Broadcasting `ChannelUpdate` messages if we've been disconnected from our peer for more
 ///    than a minute, informing the network that they should no longer attempt to route over
 ///    the channel.
+///  * Expiring a channel's previous `ChannelConfig` if necessary to only allow forwarding HTLCs
+///    with the current `ChannelConfig`.
 ///
 /// Note that this may cause reentrancy through `chain::Watch::update_channel` calls or feerate
 /// estimate fetches.
index 84bfe3756ccc35eb24b4cf98ddd7cd03f4117a42..6ddd9e1212caebb15d281975ac66ca172dd47089 100644 (file)
 //! supports a feature if it advertises the feature (as either required or optional) to its peers.
 //! And the implementation can interpret a feature if the feature is known to it.
 //!
+//! The following features are currently required in the LDK:
+//! - `VariableLengthOnion` - requires/supports variable-length routing onion payloads
+//!     (see [BOLT-4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md) for more information).
+//! - `StaticRemoteKey` - requires/supports static key for remote output
+//!     (see [BOLT-3](https://github.com/lightning/bolts/blob/master/03-transactions.md) for more information).
+//!
+//! The following features are currently supported in the LDK:
+//! - `DataLossProtect` - requires/supports that a node which has somehow fallen behind, e.g., has been restored from an old backup,
+//!     can detect that it has fallen behind
+//!     (see [BOLT-2](https://github.com/lightning/bolts/blob/master/02-peer-protocol.md) for more information).
+//! - `InitialRoutingSync` - requires/supports that the sending node needs a complete routing information dump
+//!     (see [BOLT-7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#initial-sync) for more information).
+//! - `UpfrontShutdownScript` - commits to a shutdown scriptpubkey when opening a channel
+//!     (see [BOLT-2](https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#the-open_channel-message) for more information).
+//! - `GossipQueries` - requires/supports more sophisticated gossip control
+//!     (see [BOLT-7](https://github.com/lightning/bolts/blob/master/07-routing-gossip.md) for more information).
+//! - `PaymentSecret` - requires/supports that a node supports payment_secret field
+//!     (see [BOLT-4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md) for more information).
+//! - `BasicMPP` - requires/supports that a node can receive basic multi-part payments
+//!     (see [BOLT-4](https://github.com/lightning/bolts/blob/master/04-onion-routing.md#basic-multi-part-payments) for more information).
+//! - `ShutdownAnySegwit` - requires/supports that future segwit versions are allowed in `shutdown`
+//!     (see [BOLT-2](https://github.com/lightning/bolts/blob/master/02-peer-protocol.md) for more information).
+//! - `ChannelType` - node supports the channel_type field in open/accept
+//!     (see [BOLT-2](https://github.com/lightning/bolts/blob/master/02-peer-protocol.md) for more information).
+//! - `SCIDPrivacy` - supply channel aliases for routing
+//!     (see [BOLT-2](https://github.com/lightning/bolts/blob/master/02-peer-protocol.md) for more information).
+//! - `Keysend` - send funds to a node without an invoice
+//!     (see the [`Keysend` feature assignment proposal](https://github.com/lightning/bolts/issues/605#issuecomment-606679798) for more information).
+//!
 //! [BOLT #9]: https://github.com/lightning/bolts/blob/master/09-features.md
 //! [messages]: crate::ln::msgs
 
index c5636ebc93c1c65a873f2f3f17795dc7eea36da2..6b67812cd32f26a0f82b5afc6a85bfb056c717b5 100644 (file)
@@ -1167,6 +1167,8 @@ pub enum EffectiveCapacity {
        Total {
                /// The funding amount denominated in millisatoshi.
                capacity_msat: u64,
+               /// The maximum HTLC amount denominated in millisatoshi.
+               htlc_maximum_msat: crate::c_types::derived::COption_u64Z,
        },
        /// A capacity sufficient to route any payment, typically used for private channels provided by
        /// an invoice.
@@ -1194,10 +1196,13 @@ impl EffectiveCapacity {
                                        amount_msat: amount_msat_nonref,
                                }
                        },
-                       EffectiveCapacity::Total {ref capacity_msat, } => {
+                       EffectiveCapacity::Total {ref capacity_msat, ref htlc_maximum_msat, } => {
                                let mut capacity_msat_nonref = (*capacity_msat).clone();
+                               let mut htlc_maximum_msat_nonref = (*htlc_maximum_msat).clone();
+                               let mut local_htlc_maximum_msat_nonref = if htlc_maximum_msat_nonref.is_some() { Some( { htlc_maximum_msat_nonref.take() }) } else { None };
                                nativeEffectiveCapacity::Total {
                                        capacity_msat: capacity_msat_nonref,
+                                       htlc_maximum_msat: local_htlc_maximum_msat_nonref,
                                }
                        },
                        EffectiveCapacity::Infinite => nativeEffectiveCapacity::Infinite,
@@ -1217,9 +1222,11 @@ impl EffectiveCapacity {
                                        amount_msat: amount_msat,
                                }
                        },
-                       EffectiveCapacity::Total {mut capacity_msat, } => {
+                       EffectiveCapacity::Total {mut capacity_msat, mut htlc_maximum_msat, } => {
+                               let mut local_htlc_maximum_msat = if htlc_maximum_msat.is_some() { Some( { htlc_maximum_msat.take() }) } else { None };
                                nativeEffectiveCapacity::Total {
                                        capacity_msat: capacity_msat,
+                                       htlc_maximum_msat: local_htlc_maximum_msat,
                                }
                        },
                        EffectiveCapacity::Infinite => nativeEffectiveCapacity::Infinite,
@@ -1241,10 +1248,13 @@ impl EffectiveCapacity {
                                        amount_msat: amount_msat_nonref,
                                }
                        },
-                       nativeEffectiveCapacity::Total {ref capacity_msat, } => {
+                       nativeEffectiveCapacity::Total {ref capacity_msat, ref htlc_maximum_msat, } => {
                                let mut capacity_msat_nonref = (*capacity_msat).clone();
+                               let mut htlc_maximum_msat_nonref = (*htlc_maximum_msat).clone();
+                               let mut local_htlc_maximum_msat_nonref = if htlc_maximum_msat_nonref.is_none() { crate::c_types::derived::COption_u64Z::None } else { crate::c_types::derived::COption_u64Z::Some( { htlc_maximum_msat_nonref.unwrap() }) };
                                EffectiveCapacity::Total {
                                        capacity_msat: capacity_msat_nonref,
+                                       htlc_maximum_msat: local_htlc_maximum_msat_nonref,
                                }
                        },
                        nativeEffectiveCapacity::Infinite => EffectiveCapacity::Infinite,
@@ -1264,9 +1274,11 @@ impl EffectiveCapacity {
                                        amount_msat: amount_msat,
                                }
                        },
-                       nativeEffectiveCapacity::Total {mut capacity_msat, } => {
+                       nativeEffectiveCapacity::Total {mut capacity_msat, mut htlc_maximum_msat, } => {
+                               let mut local_htlc_maximum_msat = if htlc_maximum_msat.is_none() { crate::c_types::derived::COption_u64Z::None } else { crate::c_types::derived::COption_u64Z::Some( { htlc_maximum_msat.unwrap() }) };
                                EffectiveCapacity::Total {
                                        capacity_msat: capacity_msat,
+                                       htlc_maximum_msat: local_htlc_maximum_msat,
                                }
                        },
                        nativeEffectiveCapacity::Infinite => EffectiveCapacity::Infinite,
@@ -1298,9 +1310,10 @@ pub extern "C" fn EffectiveCapacity_maximum_htlc(amount_msat: u64) -> EffectiveC
 }
 #[no_mangle]
 /// Utility method to constructs a new Total-variant EffectiveCapacity
-pub extern "C" fn EffectiveCapacity_total(capacity_msat: u64) -> EffectiveCapacity {
+pub extern "C" fn EffectiveCapacity_total(capacity_msat: u64, htlc_maximum_msat: crate::c_types::derived::COption_u64Z) -> EffectiveCapacity {
        EffectiveCapacity::Total {
                capacity_msat,
+               htlc_maximum_msat,
        }
 }
 #[no_mangle]
@@ -1552,16 +1565,16 @@ pub extern "C" fn NodeAnnouncementInfo_set_rgb(this_ptr: &mut NodeAnnouncementIn
 /// May be invalid or malicious (eg control chars),
 /// should not be exposed to the user.
 #[no_mangle]
-pub extern "C" fn NodeAnnouncementInfo_get_alias(this_ptr: &NodeAnnouncementInfo) -> *const [u8; 32] {
+pub extern "C" fn NodeAnnouncementInfo_get_alias(this_ptr: &NodeAnnouncementInfo) -> crate::lightning::routing::gossip::NodeAlias {
        let mut inner_val = &mut this_ptr.get_native_mut_ref().alias;
-       inner_val
+       crate::lightning::routing::gossip::NodeAlias { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::routing::gossip::NodeAlias<>) as *mut _) }, is_owned: false }
 }
 /// Moniker assigned to the node.
 /// May be invalid or malicious (eg control chars),
 /// should not be exposed to the user.
 #[no_mangle]
-pub extern "C" fn NodeAnnouncementInfo_set_alias(this_ptr: &mut NodeAnnouncementInfo, mut val: crate::c_types::ThirtyTwoBytes) {
-       unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.alias = val.data;
+pub extern "C" fn NodeAnnouncementInfo_set_alias(this_ptr: &mut NodeAnnouncementInfo, mut val: crate::lightning::routing::gossip::NodeAlias) {
+       unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.alias = *unsafe { Box::from_raw(val.take_inner()) };
 }
 /// Internet-level addresses via which one can connect to the node
 #[no_mangle]
@@ -1595,14 +1608,14 @@ pub extern "C" fn NodeAnnouncementInfo_set_announcement_message(this_ptr: &mut N
 /// Constructs a new NodeAnnouncementInfo given each field
 #[must_use]
 #[no_mangle]
-pub extern "C" fn NodeAnnouncementInfo_new(mut features_arg: crate::lightning::ln::features::NodeFeatures, mut last_update_arg: u32, mut rgb_arg: crate::c_types::ThreeBytes, mut alias_arg: crate::c_types::ThirtyTwoBytes, mut addresses_arg: crate::c_types::derived::CVec_NetAddressZ, mut announcement_message_arg: crate::lightning::ln::msgs::NodeAnnouncement) -> NodeAnnouncementInfo {
+pub extern "C" fn NodeAnnouncementInfo_new(mut features_arg: crate::lightning::ln::features::NodeFeatures, mut last_update_arg: u32, mut rgb_arg: crate::c_types::ThreeBytes, mut alias_arg: crate::lightning::routing::gossip::NodeAlias, mut addresses_arg: crate::c_types::derived::CVec_NetAddressZ, mut announcement_message_arg: crate::lightning::ln::msgs::NodeAnnouncement) -> NodeAnnouncementInfo {
        let mut local_addresses_arg = Vec::new(); for mut item in addresses_arg.into_rust().drain(..) { local_addresses_arg.push( { item.into_native() }); };
        let mut local_announcement_message_arg = if announcement_message_arg.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(announcement_message_arg.take_inner()) } }) };
        NodeAnnouncementInfo { inner: ObjOps::heap_alloc(nativeNodeAnnouncementInfo {
                features: *unsafe { Box::from_raw(features_arg.take_inner()) },
                last_update: last_update_arg,
                rgb: rgb_arg.data,
-               alias: alias_arg.data,
+               alias: *unsafe { Box::from_raw(alias_arg.take_inner()) },
                addresses: local_addresses_arg,
                announcement_message: local_announcement_message_arg,
        }), is_owned: true }
@@ -1643,6 +1656,112 @@ pub extern "C" fn NodeAnnouncementInfo_read(ser: crate::c_types::u8slice) -> cra
        local_res
 }
 
+use lightning::routing::gossip::NodeAlias as nativeNodeAliasImport;
+pub(crate) type nativeNodeAlias = nativeNodeAliasImport;
+
+/// A user-defined name for a node, which may be used when displaying the node in a graph.
+///
+/// Since node aliases are provided by third parties, they are a potential avenue for injection
+/// attacks. Care must be taken when processing.
+#[must_use]
+#[repr(C)]
+pub struct NodeAlias {
+       /// A pointer to the opaque Rust object.
+
+       /// Nearly everywhere, inner must be non-null, however in places where
+       /// the Rust equivalent takes an Option, it may be set to null to indicate None.
+       pub inner: *mut nativeNodeAlias,
+       /// Indicates that this is the only struct which contains the same pointer.
+
+       /// Rust functions which take ownership of an object provided via an argument require
+       /// this to be true and invalidate the object pointed to by inner.
+       pub is_owned: bool,
+}
+
+impl Drop for NodeAlias {
+       fn drop(&mut self) {
+               if self.is_owned && !<*mut nativeNodeAlias>::is_null(self.inner) {
+                       let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
+               }
+       }
+}
+/// Frees any resources used by the NodeAlias, if is_owned is set and inner is non-NULL.
+#[no_mangle]
+pub extern "C" fn NodeAlias_free(this_obj: NodeAlias) { }
+#[allow(unused)]
+/// Used only if an object of this type is returned as a trait impl by a method
+pub(crate) extern "C" fn NodeAlias_free_void(this_ptr: *mut c_void) {
+       unsafe { let _ = Box::from_raw(this_ptr as *mut nativeNodeAlias); }
+}
+#[allow(unused)]
+impl NodeAlias {
+       pub(crate) fn get_native_ref(&self) -> &'static nativeNodeAlias {
+               unsafe { &*ObjOps::untweak_ptr(self.inner) }
+       }
+       pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeNodeAlias {
+               unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
+       }
+       /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
+       pub(crate) fn take_inner(mut self) -> *mut nativeNodeAlias {
+               assert!(self.is_owned);
+               let ret = ObjOps::untweak_ptr(self.inner);
+               self.inner = core::ptr::null_mut();
+               ret
+       }
+}
+#[no_mangle]
+pub extern "C" fn NodeAlias_get_a(this_ptr: &NodeAlias) -> *const [u8; 32] {
+       let mut inner_val = &mut this_ptr.get_native_mut_ref().0;
+       inner_val
+}
+#[no_mangle]
+pub extern "C" fn NodeAlias_set_a(this_ptr: &mut NodeAlias, mut val: crate::c_types::ThirtyTwoBytes) {
+       unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.0 = val.data;
+}
+/// Constructs a new NodeAlias given each field
+#[must_use]
+#[no_mangle]
+pub extern "C" fn NodeAlias_new(mut a_arg: crate::c_types::ThirtyTwoBytes) -> NodeAlias {
+       NodeAlias { inner: ObjOps::heap_alloc(lightning::routing::gossip::NodeAlias (
+               a_arg.data,
+       )), is_owned: true }
+}
+impl Clone for NodeAlias {
+       fn clone(&self) -> Self {
+               Self {
+                       inner: if <*mut nativeNodeAlias>::is_null(self.inner) { core::ptr::null_mut() } else {
+                               ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
+                       is_owned: true,
+               }
+       }
+}
+#[allow(unused)]
+/// Used only if an object of this type is returned as a trait impl by a method
+pub(crate) extern "C" fn NodeAlias_clone_void(this_ptr: *const c_void) -> *mut c_void {
+       Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeNodeAlias)).clone() })) as *mut c_void
+}
+#[no_mangle]
+/// Creates a copy of the NodeAlias
+pub extern "C" fn NodeAlias_clone(orig: &NodeAlias) -> NodeAlias {
+       orig.clone()
+}
+#[no_mangle]
+/// Serialize the NodeAlias object into a byte array which can be read by NodeAlias_read
+pub extern "C" fn NodeAlias_write(obj: &crate::lightning::routing::gossip::NodeAlias) -> crate::c_types::derived::CVec_u8Z {
+       crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
+}
+#[no_mangle]
+pub(crate) extern "C" fn NodeAlias_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
+       crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeNodeAlias) })
+}
+#[no_mangle]
+/// Read a NodeAlias from a byte array, created by NodeAlias_write
+pub extern "C" fn NodeAlias_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_NodeAliasDecodeErrorZ {
+       let res: Result<lightning::routing::gossip::NodeAlias, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
+       let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::routing::gossip::NodeAlias { inner: ObjOps::heap_alloc(o), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: ObjOps::heap_alloc(e), is_owned: true } }).into() };
+       local_res
+}
+
 use lightning::routing::gossip::NodeInfo as nativeNodeInfoImport;
 pub(crate) type nativeNodeInfo = nativeNodeInfoImport;
 
index ee8d9e0e3156690b1fd54b11358da42626d4862f..62dd22623b0843012c18103955ff3b3855db98e1 100644 (file)
@@ -533,6 +533,10 @@ pub extern "C" fn RouteParameters_read(ser: crate::c_types::u8slice) -> crate::c
 
 #[no_mangle]
 pub static DEFAULT_MAX_TOTAL_CLTV_EXPIRY_DELTA: u32 = lightning::routing::router::DEFAULT_MAX_TOTAL_CLTV_EXPIRY_DELTA;
+/// Maximum number of paths we allow an MPP payment to have.
+
+#[no_mangle]
+pub static DEFAULT_MAX_MPP_PATH_COUNT: u8 = lightning::routing::router::DEFAULT_MAX_MPP_PATH_COUNT;
 
 use lightning::routing::router::PaymentParameters as nativePaymentParametersImport;
 pub(crate) type nativePaymentParameters = nativePaymentParametersImport;
@@ -649,20 +653,35 @@ pub extern "C" fn PaymentParameters_set_expiry_time(this_ptr: &mut PaymentParame
        unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.expiry_time = local_val;
 }
 /// The maximum total CLTV delta we accept for the route.
+/// Defaults to [`DEFAULT_MAX_TOTAL_CLTV_EXPIRY_DELTA`].
 #[no_mangle]
 pub extern "C" fn PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr: &PaymentParameters) -> u32 {
        let mut inner_val = &mut this_ptr.get_native_mut_ref().max_total_cltv_expiry_delta;
        *inner_val
 }
 /// The maximum total CLTV delta we accept for the route.
+/// Defaults to [`DEFAULT_MAX_TOTAL_CLTV_EXPIRY_DELTA`].
 #[no_mangle]
 pub extern "C" fn PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr: &mut PaymentParameters, mut val: u32) {
        unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.max_total_cltv_expiry_delta = val;
 }
+/// The maximum number of paths that may be used by MPP payments.
+/// Defaults to [`DEFAULT_MAX_MPP_PATH_COUNT`].
+#[no_mangle]
+pub extern "C" fn PaymentParameters_get_max_mpp_path_count(this_ptr: &PaymentParameters) -> u8 {
+       let mut inner_val = &mut this_ptr.get_native_mut_ref().max_mpp_path_count;
+       *inner_val
+}
+/// The maximum number of paths that may be used by MPP payments.
+/// Defaults to [`DEFAULT_MAX_MPP_PATH_COUNT`].
+#[no_mangle]
+pub extern "C" fn PaymentParameters_set_max_mpp_path_count(this_ptr: &mut PaymentParameters, mut val: u8) {
+       unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.max_mpp_path_count = val;
+}
 /// Constructs a new PaymentParameters given each field
 #[must_use]
 #[no_mangle]
-pub extern "C" fn PaymentParameters_new(mut payee_pubkey_arg: crate::c_types::PublicKey, mut features_arg: crate::lightning::ln::features::InvoiceFeatures, mut route_hints_arg: crate::c_types::derived::CVec_RouteHintZ, mut expiry_time_arg: crate::c_types::derived::COption_u64Z, mut max_total_cltv_expiry_delta_arg: u32) -> PaymentParameters {
+pub extern "C" fn PaymentParameters_new(mut payee_pubkey_arg: crate::c_types::PublicKey, mut features_arg: crate::lightning::ln::features::InvoiceFeatures, mut route_hints_arg: crate::c_types::derived::CVec_RouteHintZ, mut expiry_time_arg: crate::c_types::derived::COption_u64Z, mut max_total_cltv_expiry_delta_arg: u32, mut max_mpp_path_count_arg: u8) -> PaymentParameters {
        let mut local_features_arg = if features_arg.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(features_arg.take_inner()) } }) };
        let mut local_route_hints_arg = Vec::new(); for mut item in route_hints_arg.into_rust().drain(..) { local_route_hints_arg.push( { *unsafe { Box::from_raw(item.take_inner()) } }); };
        let mut local_expiry_time_arg = if expiry_time_arg.is_some() { Some( { expiry_time_arg.take() }) } else { None };
@@ -672,6 +691,7 @@ pub extern "C" fn PaymentParameters_new(mut payee_pubkey_arg: crate::c_types::Pu
                route_hints: local_route_hints_arg,
                expiry_time: local_expiry_time_arg,
                max_total_cltv_expiry_delta: max_total_cltv_expiry_delta_arg,
+               max_mpp_path_count: max_mpp_path_count_arg,
        }), is_owned: true }
 }
 impl Clone for PaymentParameters {
index 16b8c4aee10e6981e87f980b8a5003803d5565d6..7b1f824098c44e644875e1ad727e83f728e14b90 100644 (file)
@@ -771,16 +771,26 @@ pub extern "C" fn ProbabilisticScoringParameters_get_amount_penalty_multiplier_m
 pub extern "C" fn ProbabilisticScoringParameters_set_amount_penalty_multiplier_msat(this_ptr: &mut ProbabilisticScoringParameters, mut val: u64) {
        unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.amount_penalty_multiplier_msat = val;
 }
-/// Constructs a new ProbabilisticScoringParameters given each field
-#[must_use]
+/// This penalty is applied when `htlc_maximum_msat` is equal to or larger than half of the
+/// channel's capacity, which makes us prefer nodes with a smaller `htlc_maximum_msat`. We
+/// treat such nodes preferentially as this makes balance discovery attacks harder to execute,
+/// thereby creating an incentive to restrict `htlc_maximum_msat` and improve privacy.
+///
+/// Default value: 250 msat
 #[no_mangle]
-pub extern "C" fn ProbabilisticScoringParameters_new(mut base_penalty_msat_arg: u64, mut liquidity_penalty_multiplier_msat_arg: u64, mut liquidity_offset_half_life_arg: u64, mut amount_penalty_multiplier_msat_arg: u64) -> ProbabilisticScoringParameters {
-       ProbabilisticScoringParameters { inner: ObjOps::heap_alloc(nativeProbabilisticScoringParameters {
-               base_penalty_msat: base_penalty_msat_arg,
-               liquidity_penalty_multiplier_msat: liquidity_penalty_multiplier_msat_arg,
-               liquidity_offset_half_life: core::time::Duration::from_secs(liquidity_offset_half_life_arg),
-               amount_penalty_multiplier_msat: amount_penalty_multiplier_msat_arg,
-       }), is_owned: true }
+pub extern "C" fn ProbabilisticScoringParameters_get_anti_probing_penalty_msat(this_ptr: &ProbabilisticScoringParameters) -> u64 {
+       let mut inner_val = &mut this_ptr.get_native_mut_ref().anti_probing_penalty_msat;
+       *inner_val
+}
+/// This penalty is applied when `htlc_maximum_msat` is equal to or larger than half of the
+/// channel's capacity, which makes us prefer nodes with a smaller `htlc_maximum_msat`. We
+/// treat such nodes preferentially as this makes balance discovery attacks harder to execute,
+/// thereby creating an incentive to restrict `htlc_maximum_msat` and improve privacy.
+///
+/// Default value: 250 msat
+#[no_mangle]
+pub extern "C" fn ProbabilisticScoringParameters_set_anti_probing_penalty_msat(this_ptr: &mut ProbabilisticScoringParameters, mut val: u64) {
+       unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.anti_probing_penalty_msat = val;
 }
 impl Clone for ProbabilisticScoringParameters {
        fn clone(&self) -> Self {
@@ -819,6 +829,43 @@ pub extern "C" fn ProbabilisticScorer_debug_log_liquidity_stats(this_arg: &crate
        unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.debug_log_liquidity_stats()
 }
 
+/// Query the estimated minimum and maximum liquidity available for sending a payment over the
+/// channel with `scid` towards the given `target` node.
+#[must_use]
+#[no_mangle]
+pub extern "C" fn ProbabilisticScorer_estimated_channel_liquidity_range(this_arg: &crate::lightning::routing::scoring::ProbabilisticScorer, mut scid: u64, target: &crate::lightning::routing::gossip::NodeId) -> crate::c_types::derived::COption_C2Tuple_u64u64ZZ {
+       let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.estimated_channel_liquidity_range(scid, target.get_native_ref());
+       let mut local_ret = if ret.is_none() { crate::c_types::derived::COption_C2Tuple_u64u64ZZ::None } else { crate::c_types::derived::COption_C2Tuple_u64u64ZZ::Some( { let (mut orig_ret_0_0, mut orig_ret_0_1) = (ret.unwrap()); let mut local_ret_0 = (orig_ret_0_0, orig_ret_0_1).into(); local_ret_0 }) };
+       local_ret
+}
+
+/// Marks the node with the given `node_id` as banned, i.e.,
+/// it will be avoided during path finding.
+#[no_mangle]
+pub extern "C" fn ProbabilisticScorer_add_banned(this_arg: &mut crate::lightning::routing::scoring::ProbabilisticScorer, node_id: &crate::lightning::routing::gossip::NodeId) {
+       unsafe { &mut (*ObjOps::untweak_ptr(this_arg.inner as *mut crate::lightning::routing::scoring::nativeProbabilisticScorer)) }.add_banned(node_id.get_native_ref())
+}
+
+/// Removes the node with the given `node_id` from the list of nodes to avoid.
+#[no_mangle]
+pub extern "C" fn ProbabilisticScorer_remove_banned(this_arg: &mut crate::lightning::routing::scoring::ProbabilisticScorer, node_id: &crate::lightning::routing::gossip::NodeId) {
+       unsafe { &mut (*ObjOps::untweak_ptr(this_arg.inner as *mut crate::lightning::routing::scoring::nativeProbabilisticScorer)) }.remove_banned(node_id.get_native_ref())
+}
+
+/// Clears the list of nodes that are avoided during path finding.
+#[no_mangle]
+pub extern "C" fn ProbabilisticScorer_clear_banned(this_arg: &mut crate::lightning::routing::scoring::ProbabilisticScorer) {
+       unsafe { &mut (*ObjOps::untweak_ptr(this_arg.inner as *mut crate::lightning::routing::scoring::nativeProbabilisticScorer)) }.clear_banned()
+}
+
+/// Marks all nodes in the given list as banned, i.e.,
+/// they will be avoided during path finding.
+#[no_mangle]
+pub extern "C" fn ProbabilisticScoringParameters_add_banned_from_list(this_arg: &mut crate::lightning::routing::scoring::ProbabilisticScoringParameters, mut node_ids: crate::c_types::derived::CVec_NodeIdZ) {
+       let mut local_node_ids = Vec::new(); for mut item in node_ids.into_rust().drain(..) { local_node_ids.push( { *unsafe { Box::from_raw(item.take_inner()) } }); };
+       unsafe { &mut (*ObjOps::untweak_ptr(this_arg.inner as *mut crate::lightning::routing::scoring::nativeProbabilisticScoringParameters)) }.add_banned_from_list(local_node_ids)
+}
+
 /// Creates a "default" ProbabilisticScoringParameters. See struct and individual field documentaiton for details on which values are used.
 #[must_use]
 #[no_mangle]
index e43312b9f139fef866d5cc0704dc5c0daf44333b..aaed7c4f49978f09db1bdadd3aef72f8f3e5baa8 100644 (file)
@@ -229,20 +229,20 @@ pub extern "C" fn ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_pe
 ///
 /// If this option is set, channels may be created that will not be readable by LDK versions
 /// prior to 0.0.106, causing [`ChannelManager`]'s read method to return a
-/// [`DecodeError:InvalidValue`].
+/// [`DecodeError::InvalidValue`].
 ///
 /// Note that setting this to true does *not* prevent us from opening channels with
 /// counterparties that do not support the `scid_alias` option; we will simply fall back to a
 /// private channel without that option.
 ///
 /// Ignored if the channel is negotiated to be announced, see
-/// [`ChannelConfig::announced_channel`] and
+/// [`ChannelHandshakeConfig::announced_channel`] and
 /// [`ChannelHandshakeLimits::force_announced_channel_preference`] for more.
 ///
 /// Default value: false. This value is likely to change to true in the future.
 ///
 /// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
-/// [`DecodeError:InvalidValue`]: crate::ln::msgs::DecodeError::InvalidValue
+/// [`DecodeError::InvalidValue`]: crate::ln::msgs::DecodeError::InvalidValue
 #[no_mangle]
 pub extern "C" fn ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr: &ChannelHandshakeConfig) -> bool {
        let mut inner_val = &mut this_ptr.get_native_mut_ref().negotiate_scid_privacy;
@@ -255,34 +255,98 @@ pub extern "C" fn ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr: &C
 ///
 /// If this option is set, channels may be created that will not be readable by LDK versions
 /// prior to 0.0.106, causing [`ChannelManager`]'s read method to return a
-/// [`DecodeError:InvalidValue`].
+/// [`DecodeError::InvalidValue`].
 ///
 /// Note that setting this to true does *not* prevent us from opening channels with
 /// counterparties that do not support the `scid_alias` option; we will simply fall back to a
 /// private channel without that option.
 ///
 /// Ignored if the channel is negotiated to be announced, see
-/// [`ChannelConfig::announced_channel`] and
+/// [`ChannelHandshakeConfig::announced_channel`] and
 /// [`ChannelHandshakeLimits::force_announced_channel_preference`] for more.
 ///
 /// Default value: false. This value is likely to change to true in the future.
 ///
 /// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
-/// [`DecodeError:InvalidValue`]: crate::ln::msgs::DecodeError::InvalidValue
+/// [`DecodeError::InvalidValue`]: crate::ln::msgs::DecodeError::InvalidValue
 #[no_mangle]
 pub extern "C" fn ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr: &mut ChannelHandshakeConfig, mut val: bool) {
        unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.negotiate_scid_privacy = val;
 }
+/// Set to announce the channel publicly and notify all nodes that they can route via this
+/// channel.
+///
+/// This should only be set to true for nodes which expect to be online reliably.
+///
+/// As the node which funds a channel picks this value this will only apply for new outbound
+/// channels unless [`ChannelHandshakeLimits::force_announced_channel_preference`] is set.
+///
+/// Default value: false.
+#[no_mangle]
+pub extern "C" fn ChannelHandshakeConfig_get_announced_channel(this_ptr: &ChannelHandshakeConfig) -> bool {
+       let mut inner_val = &mut this_ptr.get_native_mut_ref().announced_channel;
+       *inner_val
+}
+/// Set to announce the channel publicly and notify all nodes that they can route via this
+/// channel.
+///
+/// This should only be set to true for nodes which expect to be online reliably.
+///
+/// As the node which funds a channel picks this value this will only apply for new outbound
+/// channels unless [`ChannelHandshakeLimits::force_announced_channel_preference`] is set.
+///
+/// Default value: false.
+#[no_mangle]
+pub extern "C" fn ChannelHandshakeConfig_set_announced_channel(this_ptr: &mut ChannelHandshakeConfig, mut val: bool) {
+       unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.announced_channel = val;
+}
+/// When set, we commit to an upfront shutdown_pubkey at channel open. If our counterparty
+/// supports it, they will then enforce the mutual-close output to us matches what we provided
+/// at intialization, preventing us from closing to an alternate pubkey.
+///
+/// This is set to true by default to provide a slight increase in security, though ultimately
+/// any attacker who is able to take control of a channel can just as easily send the funds via
+/// lightning payments, so we never require that our counterparties support this option.
+///
+/// The upfront key committed is provided from [`KeysInterface::get_shutdown_scriptpubkey`].
+///
+/// Default value: true.
+///
+/// [`KeysInterface::get_shutdown_scriptpubkey`]: crate::chain::keysinterface::KeysInterface::get_shutdown_scriptpubkey
+#[no_mangle]
+pub extern "C" fn ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(this_ptr: &ChannelHandshakeConfig) -> bool {
+       let mut inner_val = &mut this_ptr.get_native_mut_ref().commit_upfront_shutdown_pubkey;
+       *inner_val
+}
+/// When set, we commit to an upfront shutdown_pubkey at channel open. If our counterparty
+/// supports it, they will then enforce the mutual-close output to us matches what we provided
+/// at intialization, preventing us from closing to an alternate pubkey.
+///
+/// This is set to true by default to provide a slight increase in security, though ultimately
+/// any attacker who is able to take control of a channel can just as easily send the funds via
+/// lightning payments, so we never require that our counterparties support this option.
+///
+/// The upfront key committed is provided from [`KeysInterface::get_shutdown_scriptpubkey`].
+///
+/// Default value: true.
+///
+/// [`KeysInterface::get_shutdown_scriptpubkey`]: crate::chain::keysinterface::KeysInterface::get_shutdown_scriptpubkey
+#[no_mangle]
+pub extern "C" fn ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(this_ptr: &mut ChannelHandshakeConfig, mut val: bool) {
+       unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.commit_upfront_shutdown_pubkey = val;
+}
 /// Constructs a new ChannelHandshakeConfig given each field
 #[must_use]
 #[no_mangle]
-pub extern "C" fn ChannelHandshakeConfig_new(mut minimum_depth_arg: u32, mut our_to_self_delay_arg: u16, mut our_htlc_minimum_msat_arg: u64, mut max_inbound_htlc_value_in_flight_percent_of_channel_arg: u8, mut negotiate_scid_privacy_arg: bool) -> ChannelHandshakeConfig {
+pub extern "C" fn ChannelHandshakeConfig_new(mut minimum_depth_arg: u32, mut our_to_self_delay_arg: u16, mut our_htlc_minimum_msat_arg: u64, mut max_inbound_htlc_value_in_flight_percent_of_channel_arg: u8, mut negotiate_scid_privacy_arg: bool, mut announced_channel_arg: bool, mut commit_upfront_shutdown_pubkey_arg: bool) -> ChannelHandshakeConfig {
        ChannelHandshakeConfig { inner: ObjOps::heap_alloc(nativeChannelHandshakeConfig {
                minimum_depth: minimum_depth_arg,
                our_to_self_delay: our_to_self_delay_arg,
                our_htlc_minimum_msat: our_htlc_minimum_msat_arg,
                max_inbound_htlc_value_in_flight_percent_of_channel: max_inbound_htlc_value_in_flight_percent_of_channel_arg,
                negotiate_scid_privacy: negotiate_scid_privacy_arg,
+               announced_channel: announced_channel_arg,
+               commit_upfront_shutdown_pubkey: commit_upfront_shutdown_pubkey_arg,
        }), is_owned: true }
 }
 impl Clone for ChannelHandshakeConfig {
@@ -540,10 +604,10 @@ pub extern "C" fn ChannelHandshakeLimits_set_trust_own_funding_0conf(this_ptr: &
        unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.trust_own_funding_0conf = val;
 }
 /// Set to force an incoming channel to match our announced channel preference in
-/// [`ChannelConfig::announced_channel`].
+/// [`ChannelHandshakeConfig::announced_channel`].
 ///
 /// For a node which is not online reliably, this should be set to true and
-/// [`ChannelConfig::announced_channel`] set to false, ensuring that no announced (aka public)
+/// [`ChannelHandshakeConfig::announced_channel`] set to false, ensuring that no announced (aka public)
 /// channels will ever be opened.
 ///
 /// Default value: true.
@@ -553,10 +617,10 @@ pub extern "C" fn ChannelHandshakeLimits_get_force_announced_channel_preference(
        *inner_val
 }
 /// Set to force an incoming channel to match our announced channel preference in
-/// [`ChannelConfig::announced_channel`].
+/// [`ChannelHandshakeConfig::announced_channel`].
 ///
 /// For a node which is not online reliably, this should be set to true and
-/// [`ChannelConfig::announced_channel`] set to false, ensuring that no announced (aka public)
+/// [`ChannelHandshakeConfig::announced_channel`] set to false, ensuring that no announced (aka public)
 /// channels will ever be opened.
 ///
 /// Default value: true.
@@ -782,68 +846,6 @@ pub extern "C" fn ChannelConfig_get_cltv_expiry_delta(this_ptr: &ChannelConfig)
 pub extern "C" fn ChannelConfig_set_cltv_expiry_delta(this_ptr: &mut ChannelConfig, mut val: u16) {
        unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.cltv_expiry_delta = val;
 }
-/// Set to announce the channel publicly and notify all nodes that they can route via this
-/// channel.
-///
-/// This should only be set to true for nodes which expect to be online reliably.
-///
-/// As the node which funds a channel picks this value this will only apply for new outbound
-/// channels unless [`ChannelHandshakeLimits::force_announced_channel_preference`] is set.
-///
-/// This cannot be changed after the initial channel handshake.
-///
-/// Default value: false.
-#[no_mangle]
-pub extern "C" fn ChannelConfig_get_announced_channel(this_ptr: &ChannelConfig) -> bool {
-       let mut inner_val = &mut this_ptr.get_native_mut_ref().announced_channel;
-       *inner_val
-}
-/// Set to announce the channel publicly and notify all nodes that they can route via this
-/// channel.
-///
-/// This should only be set to true for nodes which expect to be online reliably.
-///
-/// As the node which funds a channel picks this value this will only apply for new outbound
-/// channels unless [`ChannelHandshakeLimits::force_announced_channel_preference`] is set.
-///
-/// This cannot be changed after the initial channel handshake.
-///
-/// Default value: false.
-#[no_mangle]
-pub extern "C" fn ChannelConfig_set_announced_channel(this_ptr: &mut ChannelConfig, mut val: bool) {
-       unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.announced_channel = val;
-}
-/// When set, we commit to an upfront shutdown_pubkey at channel open. If our counterparty
-/// supports it, they will then enforce the mutual-close output to us matches what we provided
-/// at intialization, preventing us from closing to an alternate pubkey.
-///
-/// This is set to true by default to provide a slight increase in security, though ultimately
-/// any attacker who is able to take control of a channel can just as easily send the funds via
-/// lightning payments, so we never require that our counterparties support this option.
-///
-/// This cannot be changed after a channel has been initialized.
-///
-/// Default value: true.
-#[no_mangle]
-pub extern "C" fn ChannelConfig_get_commit_upfront_shutdown_pubkey(this_ptr: &ChannelConfig) -> bool {
-       let mut inner_val = &mut this_ptr.get_native_mut_ref().commit_upfront_shutdown_pubkey;
-       *inner_val
-}
-/// When set, we commit to an upfront shutdown_pubkey at channel open. If our counterparty
-/// supports it, they will then enforce the mutual-close output to us matches what we provided
-/// at intialization, preventing us from closing to an alternate pubkey.
-///
-/// This is set to true by default to provide a slight increase in security, though ultimately
-/// any attacker who is able to take control of a channel can just as easily send the funds via
-/// lightning payments, so we never require that our counterparties support this option.
-///
-/// This cannot be changed after a channel has been initialized.
-///
-/// Default value: true.
-#[no_mangle]
-pub extern "C" fn ChannelConfig_set_commit_upfront_shutdown_pubkey(this_ptr: &mut ChannelConfig, mut val: bool) {
-       unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.commit_upfront_shutdown_pubkey = val;
-}
 /// Limit our total exposure to in-flight HTLCs which are burned to fees as they are too
 /// small to claim on-chain.
 ///
@@ -939,13 +941,11 @@ pub extern "C" fn ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_
 /// Constructs a new ChannelConfig given each field
 #[must_use]
 #[no_mangle]
-pub extern "C" fn ChannelConfig_new(mut forwarding_fee_proportional_millionths_arg: u32, mut forwarding_fee_base_msat_arg: u32, mut cltv_expiry_delta_arg: u16, mut announced_channel_arg: bool, mut commit_upfront_shutdown_pubkey_arg: bool, mut max_dust_htlc_exposure_msat_arg: u64, mut force_close_avoidance_max_fee_satoshis_arg: u64) -> ChannelConfig {
+pub extern "C" fn ChannelConfig_new(mut forwarding_fee_proportional_millionths_arg: u32, mut forwarding_fee_base_msat_arg: u32, mut cltv_expiry_delta_arg: u16, mut max_dust_htlc_exposure_msat_arg: u64, mut force_close_avoidance_max_fee_satoshis_arg: u64) -> ChannelConfig {
        ChannelConfig { inner: ObjOps::heap_alloc(nativeChannelConfig {
                forwarding_fee_proportional_millionths: forwarding_fee_proportional_millionths_arg,
                forwarding_fee_base_msat: forwarding_fee_base_msat_arg,
                cltv_expiry_delta: cltv_expiry_delta_arg,
-               announced_channel: announced_channel_arg,
-               commit_upfront_shutdown_pubkey: commit_upfront_shutdown_pubkey_arg,
                max_dust_htlc_exposure_msat: max_dust_htlc_exposure_msat_arg,
                force_close_avoidance_max_fee_satoshis: force_close_avoidance_max_fee_satoshis_arg,
        }), is_owned: true }
@@ -1045,45 +1045,45 @@ impl UserConfig {
                ret
        }
 }
-/// Channel config that we propose to our counterparty.
+/// Channel handshake config that we propose to our counterparty.
 #[no_mangle]
-pub extern "C" fn UserConfig_get_own_channel_config(this_ptr: &UserConfig) -> crate::lightning::util::config::ChannelHandshakeConfig {
-       let mut inner_val = &mut this_ptr.get_native_mut_ref().own_channel_config;
+pub extern "C" fn UserConfig_get_channel_handshake_config(this_ptr: &UserConfig) -> crate::lightning::util::config::ChannelHandshakeConfig {
+       let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_handshake_config;
        crate::lightning::util::config::ChannelHandshakeConfig { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::util::config::ChannelHandshakeConfig<>) as *mut _) }, is_owned: false }
 }
-/// Channel config that we propose to our counterparty.
+/// Channel handshake config that we propose to our counterparty.
 #[no_mangle]
-pub extern "C" fn UserConfig_set_own_channel_config(this_ptr: &mut UserConfig, mut val: crate::lightning::util::config::ChannelHandshakeConfig) {
-       unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.own_channel_config = *unsafe { Box::from_raw(val.take_inner()) };
+pub extern "C" fn UserConfig_set_channel_handshake_config(this_ptr: &mut UserConfig, mut val: crate::lightning::util::config::ChannelHandshakeConfig) {
+       unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_handshake_config = *unsafe { Box::from_raw(val.take_inner()) };
 }
-/// Limits applied to our counterparty's proposed channel config settings.
+/// Limits applied to our counterparty's proposed channel handshake config settings.
 #[no_mangle]
-pub extern "C" fn UserConfig_get_peer_channel_config_limits(this_ptr: &UserConfig) -> crate::lightning::util::config::ChannelHandshakeLimits {
-       let mut inner_val = &mut this_ptr.get_native_mut_ref().peer_channel_config_limits;
+pub extern "C" fn UserConfig_get_channel_handshake_limits(this_ptr: &UserConfig) -> crate::lightning::util::config::ChannelHandshakeLimits {
+       let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_handshake_limits;
        crate::lightning::util::config::ChannelHandshakeLimits { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::util::config::ChannelHandshakeLimits<>) as *mut _) }, is_owned: false }
 }
-/// Limits applied to our counterparty's proposed channel config settings.
+/// Limits applied to our counterparty's proposed channel handshake config settings.
 #[no_mangle]
-pub extern "C" fn UserConfig_set_peer_channel_config_limits(this_ptr: &mut UserConfig, mut val: crate::lightning::util::config::ChannelHandshakeLimits) {
-       unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.peer_channel_config_limits = *unsafe { Box::from_raw(val.take_inner()) };
+pub extern "C" fn UserConfig_set_channel_handshake_limits(this_ptr: &mut UserConfig, mut val: crate::lightning::util::config::ChannelHandshakeLimits) {
+       unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_handshake_limits = *unsafe { Box::from_raw(val.take_inner()) };
 }
 /// Channel config which affects behavior during channel lifetime.
 #[no_mangle]
-pub extern "C" fn UserConfig_get_channel_options(this_ptr: &UserConfig) -> crate::lightning::util::config::ChannelConfig {
-       let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_options;
+pub extern "C" fn UserConfig_get_channel_config(this_ptr: &UserConfig) -> crate::lightning::util::config::ChannelConfig {
+       let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_config;
        crate::lightning::util::config::ChannelConfig { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::util::config::ChannelConfig<>) as *mut _) }, is_owned: false }
 }
 /// Channel config which affects behavior during channel lifetime.
 #[no_mangle]
-pub extern "C" fn UserConfig_set_channel_options(this_ptr: &mut UserConfig, mut val: crate::lightning::util::config::ChannelConfig) {
-       unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_options = *unsafe { Box::from_raw(val.take_inner()) };
+pub extern "C" fn UserConfig_set_channel_config(this_ptr: &mut UserConfig, mut val: crate::lightning::util::config::ChannelConfig) {
+       unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_config = *unsafe { Box::from_raw(val.take_inner()) };
 }
 /// If this is set to false, we will reject any HTLCs which were to be forwarded over private
 /// channels. This prevents us from taking on HTLC-forwarding risk when we intend to run as a
 /// node which is not online reliably.
 ///
 /// For nodes which are not online reliably, you should set all channels to *not* be announced
-/// (using [`ChannelConfig::announced_channel`] and
+/// (using [`ChannelHandshakeConfig::announced_channel`] and
 /// [`ChannelHandshakeLimits::force_announced_channel_preference`]) and set this to false to
 /// ensure you are not exposed to any forwarding risk.
 ///
@@ -1104,7 +1104,7 @@ pub extern "C" fn UserConfig_get_accept_forwards_to_priv_channels(this_ptr: &Use
 /// node which is not online reliably.
 ///
 /// For nodes which are not online reliably, you should set all channels to *not* be announced
-/// (using [`ChannelConfig::announced_channel`] and
+/// (using [`ChannelHandshakeConfig::announced_channel`] and
 /// [`ChannelHandshakeLimits::force_announced_channel_preference`]) and set this to false to
 /// ensure you are not exposed to any forwarding risk.
 ///
@@ -1170,11 +1170,11 @@ pub extern "C" fn UserConfig_set_manually_accept_inbound_channels(this_ptr: &mut
 /// Constructs a new UserConfig given each field
 #[must_use]
 #[no_mangle]
-pub extern "C" fn UserConfig_new(mut own_channel_config_arg: crate::lightning::util::config::ChannelHandshakeConfig, mut peer_channel_config_limits_arg: crate::lightning::util::config::ChannelHandshakeLimits, mut channel_options_arg: crate::lightning::util::config::ChannelConfig, mut accept_forwards_to_priv_channels_arg: bool, mut accept_inbound_channels_arg: bool, mut manually_accept_inbound_channels_arg: bool) -> UserConfig {
+pub extern "C" fn UserConfig_new(mut channel_handshake_config_arg: crate::lightning::util::config::ChannelHandshakeConfig, mut channel_handshake_limits_arg: crate::lightning::util::config::ChannelHandshakeLimits, mut channel_config_arg: crate::lightning::util::config::ChannelConfig, mut accept_forwards_to_priv_channels_arg: bool, mut accept_inbound_channels_arg: bool, mut manually_accept_inbound_channels_arg: bool) -> UserConfig {
        UserConfig { inner: ObjOps::heap_alloc(nativeUserConfig {
-               own_channel_config: *unsafe { Box::from_raw(own_channel_config_arg.take_inner()) },
-               peer_channel_config_limits: *unsafe { Box::from_raw(peer_channel_config_limits_arg.take_inner()) },
-               channel_options: *unsafe { Box::from_raw(channel_options_arg.take_inner()) },
+               channel_handshake_config: *unsafe { Box::from_raw(channel_handshake_config_arg.take_inner()) },
+               channel_handshake_limits: *unsafe { Box::from_raw(channel_handshake_limits_arg.take_inner()) },
+               channel_config: *unsafe { Box::from_raw(channel_config_arg.take_inner()) },
                accept_forwards_to_priv_channels: accept_forwards_to_priv_channels_arg,
                accept_inbound_channels: accept_inbound_channels_arg,
                manually_accept_inbound_channels: manually_accept_inbound_channels_arg,
index 3458271bdef41c94e1dbd0eb733e3e7154ca20f0..42d334bde4c1d6169e2bd8cc23c700b60cb41538 100644 (file)
@@ -680,33 +680,33 @@ pub enum Event {
        /// Indicates a request to open a new channel by a peer.
        ///
        /// To accept the request, call [`ChannelManager::accept_inbound_channel`]. To reject the
-       /// request, call [`ChannelManager::force_close_channel`].
+       /// request, call [`ChannelManager::force_close_without_broadcasting_txn`].
        ///
        /// The event is only triggered when a new open channel request is received and the
        /// [`UserConfig::manually_accept_inbound_channels`] config flag is set to true.
        ///
        /// [`ChannelManager::accept_inbound_channel`]: crate::ln::channelmanager::ChannelManager::accept_inbound_channel
-       /// [`ChannelManager::force_close_channel`]: crate::ln::channelmanager::ChannelManager::force_close_channel
+       /// [`ChannelManager::force_close_without_broadcasting_txn`]: crate::ln::channelmanager::ChannelManager::force_close_without_broadcasting_txn
        /// [`UserConfig::manually_accept_inbound_channels`]: crate::util::config::UserConfig::manually_accept_inbound_channels
        OpenChannelRequest {
                /// The temporary channel ID of the channel requested to be opened.
                ///
                /// When responding to the request, the `temporary_channel_id` should be passed
                /// back to the ChannelManager through [`ChannelManager::accept_inbound_channel`] to accept,
-               /// or through [`ChannelManager::force_close_channel`] to reject.
+               /// or through [`ChannelManager::force_close_without_broadcasting_txn`] to reject.
                ///
                /// [`ChannelManager::accept_inbound_channel`]: crate::ln::channelmanager::ChannelManager::accept_inbound_channel
-               /// [`ChannelManager::force_close_channel`]: crate::ln::channelmanager::ChannelManager::force_close_channel
+               /// [`ChannelManager::force_close_without_broadcasting_txn`]: crate::ln::channelmanager::ChannelManager::force_close_without_broadcasting_txn
                temporary_channel_id: crate::c_types::ThirtyTwoBytes,
                /// The node_id of the counterparty requesting to open the channel.
                ///
                /// When responding to the request, the `counterparty_node_id` should be passed
                /// back to the `ChannelManager` through [`ChannelManager::accept_inbound_channel`] to
-               /// accept the request, or through [`ChannelManager::force_close_channel`] to reject the
+               /// accept the request, or through [`ChannelManager::force_close_without_broadcasting_txn`] to reject the
                /// request.
                ///
                /// [`ChannelManager::accept_inbound_channel`]: crate::ln::channelmanager::ChannelManager::accept_inbound_channel
-               /// [`ChannelManager::force_close_channel`]: crate::ln::channelmanager::ChannelManager::force_close_channel
+               /// [`ChannelManager::force_close_without_broadcasting_txn`]: crate::ln::channelmanager::ChannelManager::force_close_without_broadcasting_txn
                counterparty_node_id: crate::c_types::PublicKey,
                /// The channel value of the requested channel.
                funding_satoshis: u64,
index b41229dca1459581acfecc61c666cbecfb943ae9..4c19172817aff45935b9e3d046a69563d5d1f6e8 100644 (file)
@@ -193,7 +193,7 @@ pub extern "C" fn GossipSync_none() -> GossipSync {
 ///
 /// # Rapid Gossip Sync
 ///
-/// If rapid gossip sync is meant to run at startup, pass a [`RapidGossipSync`] to `gossip_sync`
+/// If rapid gossip sync is meant to run at startup, pass [`RapidGossipSync`] via `gossip_sync`
 /// to indicate that the [`BackgroundProcessor`] should not prune the [`NetworkGraph`] instance
 /// until the [`RapidGossipSync`] instance completes its first sync.
 ///