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