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