[C#] Update auto-generated files

[ldk-java] / c_sharp / src / org / ldk / structs / ChainMonitor.cs

diff --git a/c_sharp/src/org/ldk/structs/ChainMonitor.cs b/c_sharp/src/org/ldk/structs/ChainMonitor.cs
index 9ed40b58ef1b9230ba786ca6caf4ae91cdd85931..074b1ca921cd46d8691a9505ace44032169470cb 100644 (file)
--- a/c_sharp/src/org/ldk/structs/ChainMonitor.cs
+++ b/c_sharp/src/org/ldk/structs/ChainMonitor.cs
@@ -14,8 +14,15 @@ namespace org { namespace ldk { namespace structs {
  * or used independently to monitor channels remotely. See the [module-level documentation] for
  * details.
  * 
+ * Note that `ChainMonitor` should regularly trigger rebroadcasts/fee bumps of pending claims from
+ * a force-closed channel. This is crucial in preventing certain classes of pinning attacks,
+ * detecting substantial mempool feerate changes between blocks, and ensuring reliability if
+ * broadcasting fails. We recommend invoking this every 30 seconds, or lower if running in an
+ * environment with spotty connections, like on mobile.
+ * 
  * [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
  * [module-level documentation]: crate::chain::chainmonitor
+ * [`rebroadcast_pending_claims`]: Self::rebroadcast_pending_claims
  */
 public class ChainMonitor : CommonBase {
        internal ChainMonitor(object _dummy, long ptr) : base(ptr) { }
@@ -33,7 +40,7 @@ public class ChainMonitor : CommonBase {
         * transactions relevant to the watched channels.
         */
        public static ChainMonitor of(org.ldk.structs.Option_FilterZ chain_source, org.ldk.structs.BroadcasterInterface broadcaster, org.ldk.structs.Logger logger, org.ldk.structs.FeeEstimator feeest, org.ldk.structs.Persist persister) {
-               long ret = bindings.ChainMonitor_new(chain_source.ptr, broadcaster == null ? 0 : broadcaster.ptr, logger == null ? 0 : logger.ptr, feeest == null ? 0 : feeest.ptr, persister == null ? 0 : persister.ptr);
+               long ret = bindings.ChainMonitor_new(chain_source.ptr, broadcaster.ptr, logger.ptr, feeest.ptr, persister.ptr);
                GC.KeepAlive(chain_source);
                GC.KeepAlive(broadcaster);
                GC.KeepAlive(logger);
@@ -158,6 +165,37 @@ public class ChainMonitor : CommonBase {
                return ret_hu_conv;
        }
 
+       /**
+        * Gets a [`Future`] that completes when an event is available either via
+        * [`chain::Watch::release_pending_monitor_events`] or
+        * [`EventsProvider::process_pending_events`].
+        * 
+        * Note that callbacks registered on the [`Future`] MUST NOT call back into this
+        * [`ChainMonitor`] and should instead register actions to be taken later.
+        * 
+        * [`EventsProvider::process_pending_events`]: crate::events::EventsProvider::process_pending_events
+        */
+       public Future get_update_future() {
+               long ret = bindings.ChainMonitor_get_update_future(this.ptr);
+               GC.KeepAlive(this);
+               if (ret >= 0 && ret <= 4096) { return null; }
+               org.ldk.structs.Future ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.Future(null, ret); }
+               if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(this); };
+               return ret_hu_conv;
+       }
+
+       /**
+        * Triggers rebroadcasts/fee-bumps of pending claims from a force-closed channel. This is
+        * crucial in preventing certain classes of pinning attacks, detecting substantial mempool
+        * feerate changes between blocks, and ensuring reliability if broadcasting fails. We recommend
+        * invoking this every 30 seconds, or lower if running in an environment with spotty
+        * connections, like on mobile.
+        */
+       public void rebroadcast_pending_claims() {
+               bindings.ChainMonitor_rebroadcast_pending_claims(this.ptr);
+               GC.KeepAlive(this);
+       }
+
        /**
         * Constructs a new Listen which calls the relevant methods on this_arg.
         * This copies the `inner` pointer in this_arg and thus the returned Listen must be freed before this_arg is