X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;ds=sidebyside;f=src%2Fmain%2Fjava%2Forg%2Fldk%2Fstructs%2FNetworkGraph.java;h=fd6651282ca935ba6a57871d515ce8e6b9c29e17;hb=125fdf2b7111945df72dd4ee73f98bedccdd64c4;hp=5ee9a791df5ec1c013be1ffa3025608c0f716a89;hpb=40764e2a87c8cc70c5749a4d681f68842f975f59;p=ldk-java diff --git a/src/main/java/org/ldk/structs/NetworkGraph.java b/src/main/java/org/ldk/structs/NetworkGraph.java index 5ee9a791..fd665128 100644 --- a/src/main/java/org/ldk/structs/NetworkGraph.java +++ b/src/main/java/org/ldk/structs/NetworkGraph.java @@ -22,15 +22,26 @@ public class NetworkGraph extends CommonBase { /** * Handles any network updates originating from [`Event`]s. + * Note that this will skip applying any [`NetworkUpdate::ChannelUpdateMessage`] to avoid + * leaking possibly identifying information of the sender to the public network. * * [`Event`]: crate::events::Event */ public void handle_network_update(org.ldk.structs.NetworkUpdate network_update) { - bindings.NetworkGraph_handle_network_update(this.ptr, network_update == null ? 0 : network_update.ptr); + bindings.NetworkGraph_handle_network_update(this.ptr, network_update.ptr); Reference.reachabilityFence(this); Reference.reachabilityFence(network_update); } + /** + * Gets the chain hash for this network graph. + */ + public byte[] get_chain_hash() { + byte[] ret = bindings.NetworkGraph_get_chain_hash(this.ptr); + Reference.reachabilityFence(this); + return ret; + } + /** * Serialize the NetworkGraph object into a byte array which can be read by NetworkGraph_read */ @@ -111,7 +122,7 @@ public class NetworkGraph extends CommonBase { * routing messages from a source using a protocol other than the lightning P2P protocol. */ public Result_NoneLightningErrorZ update_node_from_announcement(org.ldk.structs.NodeAnnouncement msg) { - long ret = bindings.NetworkGraph_update_node_from_announcement(this.ptr, msg == null ? 0 : msg.ptr); + long ret = bindings.NetworkGraph_update_node_from_announcement(this.ptr, msg.ptr); Reference.reachabilityFence(this); Reference.reachabilityFence(msg); if (ret >= 0 && ret <= 4096) { return null; } @@ -127,7 +138,7 @@ public class NetworkGraph extends CommonBase { * peers. */ public Result_NoneLightningErrorZ update_node_from_unsigned_announcement(org.ldk.structs.UnsignedNodeAnnouncement msg) { - long ret = bindings.NetworkGraph_update_node_from_unsigned_announcement(this.ptr, msg == null ? 0 : msg.ptr); + long ret = bindings.NetworkGraph_update_node_from_unsigned_announcement(this.ptr, msg.ptr); Reference.reachabilityFence(this); Reference.reachabilityFence(msg); if (ret >= 0 && ret <= 4096) { return null; } @@ -139,15 +150,15 @@ public class NetworkGraph extends CommonBase { /** * Store or update channel info from a channel announcement. * - * You probably don't want to call this directly, instead relying on a P2PGossipSync's - * RoutingMessageHandler implementation to call it indirectly. This may be useful to accept + * You probably don't want to call this directly, instead relying on a [`P2PGossipSync`]'s + * [`RoutingMessageHandler`] implementation to call it indirectly. This may be useful to accept * routing messages from a source using a protocol other than the lightning P2P protocol. * * If a [`UtxoLookup`] object is provided via `utxo_lookup`, it will be called to verify * the corresponding UTXO exists on chain and is correctly-formatted. */ public Result_NoneLightningErrorZ update_channel_from_announcement(org.ldk.structs.ChannelAnnouncement msg, org.ldk.structs.Option_UtxoLookupZ utxo_lookup) { - long ret = bindings.NetworkGraph_update_channel_from_announcement(this.ptr, msg == null ? 0 : msg.ptr, utxo_lookup.ptr); + long ret = bindings.NetworkGraph_update_channel_from_announcement(this.ptr, msg.ptr, utxo_lookup.ptr); Reference.reachabilityFence(this); Reference.reachabilityFence(msg); Reference.reachabilityFence(utxo_lookup); @@ -158,6 +169,25 @@ public class NetworkGraph extends CommonBase { return ret_hu_conv; } + /** + * Store or update channel info from a channel announcement. + * + * You probably don't want to call this directly, instead relying on a [`P2PGossipSync`]'s + * [`RoutingMessageHandler`] implementation to call it indirectly. This may be useful to accept + * routing messages from a source using a protocol other than the lightning P2P protocol. + * + * This will skip verification of if the channel is actually on-chain. + */ + public Result_NoneLightningErrorZ update_channel_from_announcement_no_lookup(org.ldk.structs.ChannelAnnouncement msg) { + long ret = bindings.NetworkGraph_update_channel_from_announcement_no_lookup(this.ptr, msg.ptr); + Reference.reachabilityFence(this); + Reference.reachabilityFence(msg); + if (ret >= 0 && ret <= 4096) { return null; } + Result_NoneLightningErrorZ ret_hu_conv = Result_NoneLightningErrorZ.constr_from_ptr(ret); + if (this != null) { this.ptrs_to.add(msg); }; + return ret_hu_conv; + } + /** * Store or update channel info from a channel announcement without verifying the associated * signatures. Because we aren't given the associated signatures here we cannot relay the @@ -167,7 +197,7 @@ public class NetworkGraph extends CommonBase { * the corresponding UTXO exists on chain and is correctly-formatted. */ public Result_NoneLightningErrorZ update_channel_from_unsigned_announcement(org.ldk.structs.UnsignedChannelAnnouncement msg, org.ldk.structs.Option_UtxoLookupZ utxo_lookup) { - long ret = bindings.NetworkGraph_update_channel_from_unsigned_announcement(this.ptr, msg == null ? 0 : msg.ptr, utxo_lookup.ptr); + long ret = bindings.NetworkGraph_update_channel_from_unsigned_announcement(this.ptr, msg.ptr, utxo_lookup.ptr); Reference.reachabilityFence(this); Reference.reachabilityFence(msg); Reference.reachabilityFence(utxo_lookup); @@ -187,7 +217,7 @@ public class NetworkGraph extends CommonBase { * All other parameters as used in [`msgs::UnsignedChannelAnnouncement`] fields. */ 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) { - 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)); + 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)); Reference.reachabilityFence(this); Reference.reachabilityFence(short_channel_id); Reference.reachabilityFence(timestamp); @@ -269,15 +299,15 @@ public class NetworkGraph extends CommonBase { * For an already known (from announcement) channel, update info about one of the directions * of the channel. * - * You probably don't want to call this directly, instead relying on a P2PGossipSync's - * RoutingMessageHandler implementation to call it indirectly. This may be useful to accept + * You probably don't want to call this directly, instead relying on a [`P2PGossipSync`]'s + * [`RoutingMessageHandler`] implementation to call it indirectly. This may be useful to accept * routing messages from a source using a protocol other than the lightning P2P protocol. * * If built with `no-std`, any updates with a timestamp more than two weeks in the past or * materially in the future will be rejected. */ public Result_NoneLightningErrorZ update_channel(org.ldk.structs.ChannelUpdate msg) { - long ret = bindings.NetworkGraph_update_channel(this.ptr, msg == null ? 0 : msg.ptr); + long ret = bindings.NetworkGraph_update_channel(this.ptr, msg.ptr); Reference.reachabilityFence(this); Reference.reachabilityFence(msg); if (ret >= 0 && ret <= 4096) { return null; } @@ -295,7 +325,25 @@ public class NetworkGraph extends CommonBase { * materially in the future will be rejected. */ public Result_NoneLightningErrorZ update_channel_unsigned(org.ldk.structs.UnsignedChannelUpdate msg) { - long ret = bindings.NetworkGraph_update_channel_unsigned(this.ptr, msg == null ? 0 : msg.ptr); + long ret = bindings.NetworkGraph_update_channel_unsigned(this.ptr, msg.ptr); + Reference.reachabilityFence(this); + Reference.reachabilityFence(msg); + if (ret >= 0 && ret <= 4096) { return null; } + Result_NoneLightningErrorZ ret_hu_conv = Result_NoneLightningErrorZ.constr_from_ptr(ret); + if (this != null) { this.ptrs_to.add(msg); }; + return ret_hu_conv; + } + + /** + * For an already known (from announcement) channel, verify the given [`ChannelUpdate`]. + * + * This checks whether the update currently is applicable by [`Self::update_channel`]. + * + * If built with `no-std`, any updates with a timestamp more than two weeks in the past or + * materially in the future will be rejected. + */ + public Result_NoneLightningErrorZ verify_channel_update(org.ldk.structs.ChannelUpdate msg) { + long ret = bindings.NetworkGraph_verify_channel_update(this.ptr, msg.ptr); Reference.reachabilityFence(this); Reference.reachabilityFence(msg); if (ret >= 0 && ret <= 4096) { return null; }