X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Fmain%2Fjava%2Forg%2Fldk%2Fbatteries%2FChannelManagerConstructor.java;h=bfa33991c13a31402731543d4dcf860d2d4b469d;hb=2b5de78f9d131e8ee25bc9abf869aec5328b9ef3;hp=920eb0523a537d6fd5bf0750588e9ea679c14860;hpb=5cdb34f643d09f21c147c9d0b2f8888609e43429;p=ldk-java diff --git a/src/main/java/org/ldk/batteries/ChannelManagerConstructor.java b/src/main/java/org/ldk/batteries/ChannelManagerConstructor.java index 920eb052..bfa33991 100644 --- a/src/main/java/org/ldk/batteries/ChannelManagerConstructor.java +++ b/src/main/java/org/ldk/batteries/ChannelManagerConstructor.java @@ -45,7 +45,7 @@ public class ChannelManagerConstructor { * After doing so (and syncing the blockchain on the channel manager as well), you should call chain_sync_completed() * and then continue to normal application operation. */ - public final TwoTuple_BlockHashChannelMonitorZ[] channel_monitors; + public final TwoTuple_ThirtyTwoBytesChannelMonitorZ[] channel_monitors; /** * A PeerManager which is constructed to pass messages and handle connections to peers. * @@ -54,8 +54,8 @@ public class ChannelManagerConstructor { public PeerManager peer_manager = null; /** * A NioPeerHandler which manages a background thread to handle socket events and pass them to the peer_manager. - * - * This is `null` until `chain_sync_completed` is called. + * + * This is `null` until `chain_sync_completed` is called. */ public NioPeerHandler nio_peer_handler = null; @@ -78,16 +78,17 @@ public class ChannelManagerConstructor { */ private final ProbabilisticScorer prob_scorer; private final Logger logger; - private final KeysManager keys_manager; + private final EntropySource entropy_source; + private final NodeSigner node_signer; /** * Exposes the `ProbabilisticScorer` wrapped inside a lock. Don't forget to `close` this lock when you're done with * it so normal scoring operation can continue. */ public class ScorerWrapper implements AutoCloseable { - private final Score lock; + private final ScoreUpdate lock; public final ProbabilisticScorer prob_scorer; - private ScorerWrapper(Score lock, ProbabilisticScorer prob_scorer) { + private ScorerWrapper(ScoreUpdate lock, ProbabilisticScorer prob_scorer) { this.lock = lock; this.prob_scorer = prob_scorer; } @Override public void close() throws Exception { @@ -99,7 +100,7 @@ public class ChannelManagerConstructor { * you're done with it. */ public ScorerWrapper get_locked_scorer() { - return new ScorerWrapper(this.scorer.as_LockableScore().lock(), this.prob_scorer); + return new ScorerWrapper(this.scorer.as_LockableScore().write_lock(), this.prob_scorer); } /** @@ -132,29 +133,32 @@ public class ChannelManagerConstructor { * @param router_wrapper If provided, routes will be fetched by calling the given router rather than an LDK `DefaultRouter`. */ public ChannelManagerConstructor(byte[] channel_manager_serialized, byte[][] channel_monitors_serialized, UserConfig config, - KeysManager keys_manager, FeeEstimator fee_estimator, ChainMonitor chain_monitor, + EntropySource entropy_source, NodeSigner node_signer, SignerProvider signer_provider, + FeeEstimator fee_estimator, ChainMonitor chain_monitor, @Nullable Filter filter, byte[] net_graph_serialized, - ProbabilisticScoringParameters scoring_params, byte[] probabilistic_scorer_bytes, - @Nullable RouterWrapper router_wrapper, + ProbabilisticScoringDecayParameters scoring_decay_params, + ProbabilisticScoringFeeParameters scoring_fee_params, + byte[] probabilistic_scorer_bytes, @Nullable RouterWrapper router_wrapper, BroadcasterInterface tx_broadcaster, Logger logger) throws InvalidSerializedDataException { - this.keys_manager = keys_manager; - EntropySource entropy_source = keys_manager.as_EntropySource(); + this.entropy_source = entropy_source; + this.node_signer = node_signer; Result_NetworkGraphDecodeErrorZ graph_res = NetworkGraph.read(net_graph_serialized, logger); if (!graph_res.is_ok()) { throw new InvalidSerializedDataException("Serialized Network Graph was corrupt"); } this.net_graph = ((Result_NetworkGraphDecodeErrorZ.Result_NetworkGraphDecodeErrorZ_OK)graph_res).res; - assert(scoring_params != null); + assert(scoring_decay_params != null); assert(probabilistic_scorer_bytes != null); - Result_ProbabilisticScorerDecodeErrorZ scorer_res = ProbabilisticScorer.read(probabilistic_scorer_bytes, scoring_params, net_graph, logger); + Result_ProbabilisticScorerDecodeErrorZ scorer_res = ProbabilisticScorer.read(probabilistic_scorer_bytes, scoring_decay_params, net_graph, logger); if (!scorer_res.is_ok()) { throw new InvalidSerializedDataException("Serialized ProbabilisticScorer was corrupt"); } this.prob_scorer = ((Result_ProbabilisticScorerDecodeErrorZ.Result_ProbabilisticScorerDecodeErrorZ_OK)scorer_res).res; this.scorer = MultiThreadedLockableScore.of(this.prob_scorer.as_Score()); - DefaultRouter default_router = DefaultRouter.of(this.net_graph, logger, entropy_source.get_secure_random_bytes(), scorer.as_LockableScore()); + assert(scoring_fee_params != null); + DefaultRouter default_router = DefaultRouter.of(this.net_graph, logger, entropy_source.get_secure_random_bytes(), scorer.as_LockableScore(), scoring_fee_params); Router router; if (router_wrapper != null) { router = Router.new_impl(new Router.RouterInterface() { @@ -170,28 +174,28 @@ public class ChannelManagerConstructor { } final ChannelMonitor[] monitors = new ChannelMonitor[channel_monitors_serialized.length]; - this.channel_monitors = new TwoTuple_BlockHashChannelMonitorZ[monitors.length]; + this.channel_monitors = new TwoTuple_ThirtyTwoBytesChannelMonitorZ[monitors.length]; HashSet monitor_funding_set = new HashSet(); for (int i = 0; i < monitors.length; i++) { - Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ res = UtilMethods.C2Tuple_BlockHashChannelMonitorZ_read(channel_monitors_serialized[i], entropy_source, keys_manager.as_SignerProvider()); - if (res instanceof Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ.Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_Err) { + Result_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ res = UtilMethods.C2Tuple_ThirtyTwoBytesChannelMonitorZ_read(channel_monitors_serialized[i], entropy_source, signer_provider); + if (res instanceof Result_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ.Result_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_Err) { throw new InvalidSerializedDataException("Serialized ChannelMonitor was corrupt"); } - byte[] block_hash = ((Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ.Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_OK)res).res.get_a(); - monitors[i] = ((Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ.Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_OK) res).res.get_b(); - this.channel_monitors[i] = TwoTuple_BlockHashChannelMonitorZ.of(block_hash, monitors[i]); + byte[] block_hash = ((Result_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ.Result_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_OK)res).res.get_a(); + monitors[i] = ((Result_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ.Result_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_OK) res).res.get_b(); + this.channel_monitors[i] = TwoTuple_ThirtyTwoBytesChannelMonitorZ.of(block_hash, monitors[i]); if (!monitor_funding_set.add(monitors[i].get_funding_txo().get_a())) throw new InvalidSerializedDataException("Set of ChannelMonitors contained duplicates (ie the same funding_txo was set on multiple monitors)"); } - Result_C2Tuple_BlockHashChannelManagerZDecodeErrorZ res = - UtilMethods.C2Tuple_BlockHashChannelManagerZ_read(channel_manager_serialized, keys_manager.as_EntropySource(), - keys_manager.as_NodeSigner(), keys_manager.as_SignerProvider(), fee_estimator, chain_monitor.as_Watch(), + Result_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ res = + UtilMethods.C2Tuple_ThirtyTwoBytesChannelManagerZ_read(channel_manager_serialized, entropy_source, + node_signer, signer_provider, fee_estimator, chain_monitor.as_Watch(), tx_broadcaster, router, logger, config, monitors); if (!res.is_ok()) { throw new InvalidSerializedDataException("Serialized ChannelManager was corrupt"); } - this.channel_manager = ((Result_C2Tuple_BlockHashChannelManagerZDecodeErrorZ.Result_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_OK)res).res.get_b(); - this.channel_manager_latest_block_hash = ((Result_C2Tuple_BlockHashChannelManagerZDecodeErrorZ.Result_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_OK)res).res.get_a(); + this.channel_manager = ((Result_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ.Result_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_OK)res).res.get_b(); + this.channel_manager_latest_block_hash = ((Result_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ.Result_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_OK)res).res.get_a(); this.chain_monitor = chain_monitor; this.logger = logger; if (filter != null) { @@ -207,19 +211,21 @@ public class ChannelManagerConstructor { * @param router_wrapper If provided, routes will be fetched by calling the given router rather than an LDK `DefaultRouter`. */ public ChannelManagerConstructor(Network network, UserConfig config, byte[] current_blockchain_tip_hash, int current_blockchain_tip_height, - KeysManager keys_manager, FeeEstimator fee_estimator, ChainMonitor chain_monitor, - NetworkGraph net_graph, ProbabilisticScoringParameters scoring_params, + EntropySource entropy_source, NodeSigner node_signer, SignerProvider signer_provider, + FeeEstimator fee_estimator, ChainMonitor chain_monitor, + NetworkGraph net_graph, ProbabilisticScoringDecayParameters scoring_decay_params, + ProbabilisticScoringFeeParameters scoring_fee_params, @Nullable RouterWrapper router_wrapper, BroadcasterInterface tx_broadcaster, Logger logger) { - this.keys_manager = keys_manager; - EntropySource entropy_source = keys_manager.as_EntropySource(); - + this.entropy_source = entropy_source; + this.node_signer = node_signer; this.net_graph = net_graph; - assert(scoring_params != null); - this.prob_scorer = ProbabilisticScorer.of(scoring_params, net_graph, logger); + assert(scoring_decay_params != null); + this.prob_scorer = ProbabilisticScorer.of(scoring_decay_params, net_graph, logger); this.scorer = MultiThreadedLockableScore.of(this.prob_scorer.as_Score()); - DefaultRouter default_router = DefaultRouter.of(this.net_graph, logger, entropy_source.get_secure_random_bytes(), scorer.as_LockableScore()); + assert(scoring_fee_params != null); + DefaultRouter default_router = DefaultRouter.of(this.net_graph, logger, entropy_source.get_secure_random_bytes(), scorer.as_LockableScore(), scoring_fee_params); Router router; if (router_wrapper != null) { router = Router.new_impl(new Router.RouterInterface() { @@ -233,13 +239,13 @@ public class ChannelManagerConstructor { } else { router = default_router.as_Router(); } - channel_monitors = new TwoTuple_BlockHashChannelMonitorZ[0]; + channel_monitors = new TwoTuple_ThirtyTwoBytesChannelMonitorZ[0]; channel_manager_latest_block_hash = null; this.chain_monitor = chain_monitor; BestBlock block = BestBlock.of(current_blockchain_tip_hash, current_blockchain_tip_height); ChainParameters params = ChainParameters.of(network, block); channel_manager = ChannelManager.of(fee_estimator, chain_monitor.as_Watch(), tx_broadcaster, router, logger, - keys_manager.as_EntropySource(), keys_manager.as_NodeSigner(), keys_manager.as_SignerProvider(), config, params); + entropy_source, node_signer, signer_provider, config, params, (int) (System.currentTimeMillis() / 1000)); this.logger = logger; } @@ -270,17 +276,23 @@ public class ChannelManagerConstructor { */ public void chain_sync_completed(EventHandler event_handler, boolean use_p2p_graph_sync) { if (background_processor != null) { return; } - for (TwoTuple_BlockHashChannelMonitorZ monitor: channel_monitors) { + for (TwoTuple_ThirtyTwoBytesChannelMonitorZ monitor: channel_monitors) { this.chain_monitor.as_Watch().watch_channel(monitor.get_b().get_funding_txo().get_a(), monitor.get_b()); } org.ldk.structs.EventHandler ldk_handler = org.ldk.structs.EventHandler.new_impl(event_handler::handle_event); final IgnoringMessageHandler ignoring_handler = IgnoringMessageHandler.of(); P2PGossipSync graph_msg_handler = P2PGossipSync.of(net_graph, Option_UtxoLookupZ.none(), logger); + RoutingMessageHandler routing_msg_handler; + if (use_p2p_graph_sync) + routing_msg_handler = graph_msg_handler.as_RoutingMessageHandler(); + else + routing_msg_handler = ignoring_handler.as_RoutingMessageHandler(); + OnionMessenger messenger = OnionMessenger.of(this.entropy_source, this.node_signer, this.logger, DefaultMessageRouter.of().as_MessageRouter(), channel_manager.as_OffersMessageHandler(), IgnoringMessageHandler.of().as_CustomOnionMessageHandler()); this.peer_manager = PeerManager.of(channel_manager.as_ChannelMessageHandler(), - ignoring_handler.as_RoutingMessageHandler(), ignoring_handler.as_OnionMessageHandler(), - (int)(System.currentTimeMillis() / 1000), this.keys_manager.as_EntropySource().get_secure_random_bytes(), - logger, ignoring_handler.as_CustomMessageHandler(), keys_manager.as_NodeSigner()); + routing_msg_handler, messenger.as_OnionMessageHandler(), + ignoring_handler.as_CustomMessageHandler(), (int)(System.currentTimeMillis() / 1000), + this.entropy_source.get_secure_random_bytes(), logger, this.node_signer); try { this.nio_peer_handler = new NioPeerHandler(peer_manager); @@ -290,29 +302,29 @@ public class ChannelManagerConstructor { GossipSync gossip_sync; if (use_p2p_graph_sync) - gossip_sync = GossipSync.none(); - else gossip_sync = GossipSync.p2_p(graph_msg_handler); + else + gossip_sync = GossipSync.none(); Option_WriteableScoreZ writeable_score = Option_WriteableScoreZ.some(scorer.as_WriteableScore()); background_processor = BackgroundProcessor.start(Persister.new_impl(new Persister.PersisterInterface() { @Override - public Result_NoneErrorZ persist_manager(ChannelManager channel_manager) { + public Result_NoneIOErrorZ persist_manager(ChannelManager channel_manager) { event_handler.persist_manager(channel_manager.write()); - return Result_NoneErrorZ.ok(); + return Result_NoneIOErrorZ.ok(); } @Override - public Result_NoneErrorZ persist_graph(NetworkGraph network_graph) { + public Result_NoneIOErrorZ persist_graph(NetworkGraph network_graph) { event_handler.persist_network_graph(network_graph.write()); - return Result_NoneErrorZ.ok(); + return Result_NoneIOErrorZ.ok(); } @Override - public Result_NoneErrorZ persist_scorer(WriteableScore scorer) { + public Result_NoneIOErrorZ persist_scorer(WriteableScore scorer) { event_handler.persist_scorer(scorer.write()); - return Result_NoneErrorZ.ok(); + return Result_NoneIOErrorZ.ok(); } }), ldk_handler, this.chain_monitor, this.channel_manager, gossip_sync, peer_manager, this.logger, writeable_score); }