_ Git - ldk-java/blob - c_sharp/src/org/ldk/structs/NetworkGraph.cs

   1 using org.ldk.impl;
   2 using org.ldk.enums;
   3 using org.ldk.util;
   4 using System;
   5
   6 namespace org { namespace ldk { namespace structs {
   7
   8
   9 /**
  10  * Represents the network as nodes and channels between them
  11  */
  12 public class NetworkGraph : CommonBase {
  13         internal NetworkGraph(object _dummy, long ptr) : base(ptr) { }
  14         ~NetworkGraph() {
  15                 if (ptr != 0) { bindings.NetworkGraph_free(ptr); }
  16         }
  17
  18         /**
  19          * Handles any network updates originating from [`Event`]s.
  20          *
  21          * [`Event`]: crate::events::Event
  22          */
  23         public void handle_network_update(org.ldk.structs.NetworkUpdate network_update) {
  24                 bindings.NetworkGraph_handle_network_update(this.ptr, network_update == null ? 0 : network_update.ptr);
  25                 GC.KeepAlive(this);
  26                 GC.KeepAlive(network_update);
  27         }
  28
  29         /**
  30          * Gets the genesis hash for this network graph.
  31          */
  32         public byte[] get_genesis_hash() {
  33                 byte[] ret = bindings.NetworkGraph_get_genesis_hash(this.ptr);
  34                 GC.KeepAlive(this);
  35                 return ret;
  36         }
  37
  38         /**
  39          * Serialize the NetworkGraph object into a byte array which can be read by NetworkGraph_read
  40          */
  41         public byte[] write() {
  42                 byte[] ret = bindings.NetworkGraph_write(this.ptr);
  43                 GC.KeepAlive(this);
  44                 return ret;
  45         }
  46
  47         /**
  48          * Read a NetworkGraph from a byte array, created by NetworkGraph_write
  49          */
  50         public static Result_NetworkGraphDecodeErrorZ read(byte[] ser, org.ldk.structs.Logger arg) {
  51                 long ret = bindings.NetworkGraph_read(ser, arg.ptr);
  52                 GC.KeepAlive(ser);
  53                 GC.KeepAlive(arg);
  54                 if (ret >= 0 && ret <= 4096) { return null; }
  55                 Result_NetworkGraphDecodeErrorZ ret_hu_conv = Result_NetworkGraphDecodeErrorZ.constr_from_ptr(ret);
  56                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(arg); };
  57                 return ret_hu_conv;
  58         }
  59
  60         /**
  61          * Creates a new, empty, network graph.
  62          */
  63         public static NetworkGraph of(Network network, org.ldk.structs.Logger logger) {
  64                 long ret = bindings.NetworkGraph_new(network, logger.ptr);
  65                 GC.KeepAlive(network);
  66                 GC.KeepAlive(logger);
  67                 if (ret >= 0 && ret <= 4096) { return null; }
  68                 org.ldk.structs.NetworkGraph ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.NetworkGraph(null, ret); }
  69                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
  70                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(logger); };
  71                 return ret_hu_conv;
  72         }
  73
  74         /**
  75          * Returns a read-only view of the network graph.
  76          */
  77         public ReadOnlyNetworkGraph read_only() {
  78                 long ret = bindings.NetworkGraph_read_only(this.ptr);
  79                 GC.KeepAlive(this);
  80                 if (ret >= 0 && ret <= 4096) { return null; }
  81                 org.ldk.structs.ReadOnlyNetworkGraph ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.ReadOnlyNetworkGraph(null, ret); }
  82                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(this); };
  83                 return ret_hu_conv;
  84         }
  85
  86         /**
  87          * The unix timestamp provided by the most recent rapid gossip sync.
  88          * It will be set by the rapid sync process after every sync completion.
  89          */
  90         public Option_u32Z get_last_rapid_gossip_sync_timestamp() {
  91                 long ret = bindings.NetworkGraph_get_last_rapid_gossip_sync_timestamp(this.ptr);
  92                 GC.KeepAlive(this);
  93                 if (ret >= 0 && ret <= 4096) { return null; }
  94                 org.ldk.structs.Option_u32Z ret_hu_conv = org.ldk.structs.Option_u32Z.constr_from_ptr(ret);
  95                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(this); };
  96                 return ret_hu_conv;
  97         }
  98
  99         /**
 100          * Update the unix timestamp provided by the most recent rapid gossip sync.
 101          * This should be done automatically by the rapid sync process after every sync completion.
 102          */
 103         public void set_last_rapid_gossip_sync_timestamp(int last_rapid_gossip_sync_timestamp) {
 104                 bindings.NetworkGraph_set_last_rapid_gossip_sync_timestamp(this.ptr, last_rapid_gossip_sync_timestamp);
 105                 GC.KeepAlive(this);
 106                 GC.KeepAlive(last_rapid_gossip_sync_timestamp);
 107         }
 108
 109         /**
 110          * For an already known node (from channel announcements), update its stored properties from a
 111          * given node announcement.
 112          *
 113          * You probably don't want to call this directly, instead relying on a P2PGossipSync's
 114          * RoutingMessageHandler implementation to call it indirectly. This may be useful to accept
 115          * routing messages from a source using a protocol other than the lightning P2P protocol.
 116          */
 117         public Result_NoneLightningErrorZ update_node_from_announcement(org.ldk.structs.NodeAnnouncement msg) {
 118                 long ret = bindings.NetworkGraph_update_node_from_announcement(this.ptr, msg == null ? 0 : msg.ptr);
 119                 GC.KeepAlive(this);
 120                 GC.KeepAlive(msg);
 121                 if (ret >= 0 && ret <= 4096) { return null; }
 122                 Result_NoneLightningErrorZ ret_hu_conv = Result_NoneLightningErrorZ.constr_from_ptr(ret);
 123                 if (this != null) { this.ptrs_to.AddLast(msg); };
 124                 return ret_hu_conv;
 125         }
 126
 127         /**
 128          * For an already known node (from channel announcements), update its stored properties from a
 129          * given node announcement without verifying the associated signatures. Because we aren't
 130          * given the associated signatures here we cannot relay the node announcement to any of our
 131          * peers.
 132          */
 133         public Result_NoneLightningErrorZ update_node_from_unsigned_announcement(org.ldk.structs.UnsignedNodeAnnouncement msg) {
 134                 long ret = bindings.NetworkGraph_update_node_from_unsigned_announcement(this.ptr, msg == null ? 0 : msg.ptr);
 135                 GC.KeepAlive(this);
 136                 GC.KeepAlive(msg);
 137                 if (ret >= 0 && ret <= 4096) { return null; }
 138                 Result_NoneLightningErrorZ ret_hu_conv = Result_NoneLightningErrorZ.constr_from_ptr(ret);
 139                 if (this != null) { this.ptrs_to.AddLast(msg); };
 140                 return ret_hu_conv;
 141         }
 142
 143         /**
 144          * Store or update channel info from a channel announcement.
 145          *
 146          * You probably don't want to call this directly, instead relying on a [`P2PGossipSync`]'s
 147          * [`RoutingMessageHandler`] implementation to call it indirectly. This may be useful to accept
 148          * routing messages from a source using a protocol other than the lightning P2P protocol.
 149          *
 150          * If a [`UtxoLookup`] object is provided via `utxo_lookup`, it will be called to verify
 151          * the corresponding UTXO exists on chain and is correctly-formatted.
 152          */
 153         public Result_NoneLightningErrorZ update_channel_from_announcement(org.ldk.structs.ChannelAnnouncement msg, org.ldk.structs.Option_UtxoLookupZ utxo_lookup) {
 154                 long ret = bindings.NetworkGraph_update_channel_from_announcement(this.ptr, msg == null ? 0 : msg.ptr, utxo_lookup.ptr);
 155                 GC.KeepAlive(this);
 156                 GC.KeepAlive(msg);
 157                 GC.KeepAlive(utxo_lookup);
 158                 if (ret >= 0 && ret <= 4096) { return null; }
 159                 Result_NoneLightningErrorZ ret_hu_conv = Result_NoneLightningErrorZ.constr_from_ptr(ret);
 160                 if (this != null) { this.ptrs_to.AddLast(msg); };
 161                 if (this != null) { this.ptrs_to.AddLast(utxo_lookup); };
 162                 return ret_hu_conv;
 163         }
 164
 165         /**
 166          * Store or update channel info from a channel announcement.
 167          *
 168          * You probably don't want to call this directly, instead relying on a [`P2PGossipSync`]'s
 169          * [`RoutingMessageHandler`] implementation to call it indirectly. This may be useful to accept
 170          * routing messages from a source using a protocol other than the lightning P2P protocol.
 171          *
 172          * This will skip verification of if the channel is actually on-chain.
 173          */
 174         public Result_NoneLightningErrorZ update_channel_from_announcement_no_lookup(org.ldk.structs.ChannelAnnouncement msg) {
 175                 long ret = bindings.NetworkGraph_update_channel_from_announcement_no_lookup(this.ptr, msg == null ? 0 : msg.ptr);
 176                 GC.KeepAlive(this);
 177                 GC.KeepAlive(msg);
 178                 if (ret >= 0 && ret <= 4096) { return null; }
 179                 Result_NoneLightningErrorZ ret_hu_conv = Result_NoneLightningErrorZ.constr_from_ptr(ret);
 180                 if (this != null) { this.ptrs_to.AddLast(msg); };
 181                 return ret_hu_conv;
 182         }
 183
 184         /**
 185          * Store or update channel info from a channel announcement without verifying the associated
 186          * signatures. Because we aren't given the associated signatures here we cannot relay the
 187          * channel announcement to any of our peers.
 188          *
 189          * If a [`UtxoLookup`] object is provided via `utxo_lookup`, it will be called to verify
 190          * the corresponding UTXO exists on chain and is correctly-formatted.
 191          */
 192         public Result_NoneLightningErrorZ update_channel_from_unsigned_announcement(org.ldk.structs.UnsignedChannelAnnouncement msg, org.ldk.structs.Option_UtxoLookupZ utxo_lookup) {
 193                 long ret = bindings.NetworkGraph_update_channel_from_unsigned_announcement(this.ptr, msg == null ? 0 : msg.ptr, utxo_lookup.ptr);
 194                 GC.KeepAlive(this);
 195                 GC.KeepAlive(msg);
 196                 GC.KeepAlive(utxo_lookup);
 197                 if (ret >= 0 && ret <= 4096) { return null; }
 198                 Result_NoneLightningErrorZ ret_hu_conv = Result_NoneLightningErrorZ.constr_from_ptr(ret);
 199                 if (this != null) { this.ptrs_to.AddLast(msg); };
 200                 if (this != null) { this.ptrs_to.AddLast(utxo_lookup); };
 201                 return ret_hu_conv;
 202         }
 203
 204         /**
 205          * Update channel from partial announcement data received via rapid gossip sync
 206          *
 207          * `timestamp: u64`: Timestamp emulating the backdated original announcement receipt (by the
 208          * rapid gossip sync server)
 209          *
 210          * All other parameters as used in [`msgs::UnsignedChannelAnnouncement`] fields.
 211          */
 212         public Result_NoneLightningErrorZ add_channel_from_partial_announcement(long short_channel_id, long timestamp, org.ldk.structs.ChannelFeatures features, byte[] node_id_1, byte[] node_id_2) {
 213                 long ret = bindings.NetworkGraph_add_channel_from_partial_announcement(this.ptr, short_channel_id, timestamp, features == null ? 0 : features.ptr, InternalUtils.check_arr_len(node_id_1, 33), InternalUtils.check_arr_len(node_id_2, 33));
 214                 GC.KeepAlive(this);
 215                 GC.KeepAlive(short_channel_id);
 216                 GC.KeepAlive(timestamp);
 217                 GC.KeepAlive(features);
 218                 GC.KeepAlive(node_id_1);
 219                 GC.KeepAlive(node_id_2);
 220                 if (ret >= 0 && ret <= 4096) { return null; }
 221                 Result_NoneLightningErrorZ ret_hu_conv = Result_NoneLightningErrorZ.constr_from_ptr(ret);
 222                 if (this != null) { this.ptrs_to.AddLast(features); };
 223                 return ret_hu_conv;
 224         }
 225
 226         /**
 227          * Marks a channel in the graph as failed permanently.
 228          *
 229          * The channel and any node for which this was their last channel are removed from the graph.
 230          */
 231         public void channel_failed_permanent(long short_channel_id) {
 232                 bindings.NetworkGraph_channel_failed_permanent(this.ptr, short_channel_id);
 233                 GC.KeepAlive(this);
 234                 GC.KeepAlive(short_channel_id);
 235         }
 236
 237         /**
 238          * Marks a node in the graph as permanently failed, effectively removing it and its channels
 239          * from local storage.
 240          */
 241         public void node_failed_permanent(byte[] node_id) {
 242                 bindings.NetworkGraph_node_failed_permanent(this.ptr, InternalUtils.check_arr_len(node_id, 33));
 243                 GC.KeepAlive(this);
 244                 GC.KeepAlive(node_id);
 245         }
 246
 247         /**
 248          * Removes information about channels that we haven't heard any updates about in some time.
 249          * This can be used regularly to prune the network graph of channels that likely no longer
 250          * exist.
 251          *
 252          * While there is no formal requirement that nodes regularly re-broadcast their channel
 253          * updates every two weeks, the non-normative section of BOLT 7 currently suggests that
 254          * pruning occur for updates which are at least two weeks old, which we implement here.
 255          *
 256          * Note that for users of the `lightning-background-processor` crate this method may be
 257          * automatically called regularly for you.
 258          *
 259          * This method will also cause us to stop tracking removed nodes and channels if they have been
 260          * in the map for a while so that these can be resynced from gossip in the future.
 261          *
 262          * This method is only available with the `std` feature. See
 263          * [`NetworkGraph::remove_stale_channels_and_tracking_with_time`] for `no-std` use.
 264          */
 265         public void remove_stale_channels_and_tracking() {
 266                 bindings.NetworkGraph_remove_stale_channels_and_tracking(this.ptr);
 267                 GC.KeepAlive(this);
 268         }
 269
 270         /**
 271          * Removes information about channels that we haven't heard any updates about in some time.
 272          * This can be used regularly to prune the network graph of channels that likely no longer
 273          * exist.
 274          *
 275          * While there is no formal requirement that nodes regularly re-broadcast their channel
 276          * updates every two weeks, the non-normative section of BOLT 7 currently suggests that
 277          * pruning occur for updates which are at least two weeks old, which we implement here.
 278          *
 279          * This method will also cause us to stop tracking removed nodes and channels if they have been
 280          * in the map for a while so that these can be resynced from gossip in the future.
 281          *
 282          * This function takes the current unix time as an argument. For users with the `std` feature
 283          * enabled, [`NetworkGraph::remove_stale_channels_and_tracking`] may be preferable.
 284          */
 285         public void remove_stale_channels_and_tracking_with_time(long current_time_unix) {
 286                 bindings.NetworkGraph_remove_stale_channels_and_tracking_with_time(this.ptr, current_time_unix);
 287                 GC.KeepAlive(this);
 288                 GC.KeepAlive(current_time_unix);
 289         }
 290
 291         /**
 292          * For an already known (from announcement) channel, update info about one of the directions
 293          * of the channel.
 294          *
 295          * You probably don't want to call this directly, instead relying on a P2PGossipSync's
 296          * RoutingMessageHandler implementation to call it indirectly. This may be useful to accept
 297          * routing messages from a source using a protocol other than the lightning P2P protocol.
 298          *
 299          * If built with `no-std`, any updates with a timestamp more than two weeks in the past or
 300          * materially in the future will be rejected.
 301          */
 302         public Result_NoneLightningErrorZ update_channel(org.ldk.structs.ChannelUpdate msg) {
 303                 long ret = bindings.NetworkGraph_update_channel(this.ptr, msg == null ? 0 : msg.ptr);
 304                 GC.KeepAlive(this);
 305                 GC.KeepAlive(msg);
 306                 if (ret >= 0 && ret <= 4096) { return null; }
 307                 Result_NoneLightningErrorZ ret_hu_conv = Result_NoneLightningErrorZ.constr_from_ptr(ret);
 308                 if (this != null) { this.ptrs_to.AddLast(msg); };
 309                 return ret_hu_conv;
 310         }
 311
 312         /**
 313          * For an already known (from announcement) channel, update info about one of the directions
 314          * of the channel without verifying the associated signatures. Because we aren't given the
 315          * associated signatures here we cannot relay the channel update to any of our peers.
 316          *
 317          * If built with `no-std`, any updates with a timestamp more than two weeks in the past or
 318          * materially in the future will be rejected.
 319          */
 320         public Result_NoneLightningErrorZ update_channel_unsigned(org.ldk.structs.UnsignedChannelUpdate msg) {
 321                 long ret = bindings.NetworkGraph_update_channel_unsigned(this.ptr, msg == null ? 0 : msg.ptr);
 322                 GC.KeepAlive(this);
 323                 GC.KeepAlive(msg);
 324                 if (ret >= 0 && ret <= 4096) { return null; }
 325                 Result_NoneLightningErrorZ ret_hu_conv = Result_NoneLightningErrorZ.constr_from_ptr(ret);
 326                 if (this != null) { this.ptrs_to.AddLast(msg); };
 327                 return ret_hu_conv;
 328         }
 329
 330 }
 331 } } }