1 package org.ldk.structs;
3 import org.ldk.impl.bindings;
4 import org.ldk.enums.*;
6 import java.util.Arrays;
7 import java.lang.ref.Reference;
8 import javax.annotation.Nullable;
12 * Represents the network as nodes and channels between them
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 {
20 if (ptr != 0) { bindings.NetworkGraph_free(ptr); }
24 * Handles any network updates originating from [`Event`]s.
26 * [`Event`]: crate::events::Event
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);
35 * Gets the genesis hash for this network graph.
37 public byte[] get_genesis_hash() {
38 byte[] ret = bindings.NetworkGraph_get_genesis_hash(this.ptr);
39 Reference.reachabilityFence(this);
44 * Serialize the NetworkGraph object into a byte array which can be read by NetworkGraph_read
46 public byte[] write() {
47 byte[] ret = bindings.NetworkGraph_write(this.ptr);
48 Reference.reachabilityFence(this);
53 * Read a NetworkGraph from a byte array, created by NetworkGraph_write
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); };
66 * Creates a new, empty, network graph.
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); };
80 * Returns a read-only view of the network graph.
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); };
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.
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); };
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.
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);
115 * For an already known node (from channel announcements), update its stored properties from a
116 * given node announcement.
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.
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); };
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
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); };
149 * Store or update channel info from a channel announcement.
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.
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.
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); };
171 * Store or update channel info from a channel announcement.
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.
177 * This will skip verification of if the channel is actually on-chain.
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); };
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.
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.
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); };
210 * Update channel from partial announcement data received via rapid gossip sync
212 * `timestamp: u64`: Timestamp emulating the backdated original announcement receipt (by the
213 * rapid gossip sync server)
215 * All other parameters as used in [`msgs::UnsignedChannelAnnouncement`] fields.
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); };
232 * Marks a channel in the graph as failed permanently.
234 * The channel and any node for which this was their last channel are removed from the graph.
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);
243 * Marks a node in the graph as permanently failed, effectively removing it and its channels
244 * from local storage.
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);
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
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.
261 * Note that for users of the `lightning-background-processor` crate this method may be
262 * automatically called regularly for you.
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.
267 * This method is only available with the `std` feature. See
268 * [`NetworkGraph::remove_stale_channels_and_tracking_with_time`] for `no-std` use.
270 public void remove_stale_channels_and_tracking() {
271 bindings.NetworkGraph_remove_stale_channels_and_tracking(this.ptr);
272 Reference.reachabilityFence(this);
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
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.
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.
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.
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);
297 * For an already known (from announcement) channel, update info about one of the directions
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.
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.
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); };
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.
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.
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); };