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

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