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