+ if (ptr != 0) { bindings.ChannelManager_free(ptr); }
+ }
+
+ /**
+ * Constructs a new ChannelManager to hold several channels and route between them.
+ *
+ * This is the main \"logic hub\" for all channel-related actions, and implements
+ * ChannelMessageHandler.
+ *
+ * Non-proportional fees are fixed according to our risk using the provided fee estimator.
+ *
+ * panics if channel_value_satoshis is >= `MAX_FUNDING_SATOSHIS`!
+ *
+ * Users need to notify the new ChannelManager when a new block is connected or
+ * disconnected using its `block_connected` and `block_disconnected` methods, starting
+ * from after `params.latest_hash`.
+ */
+ public static ChannelManager of(FeeEstimator fee_est, Watch chain_monitor, BroadcasterInterface tx_broadcaster, Logger logger, KeysInterface keys_manager, UserConfig config, ChainParameters params) {
+ long ret = bindings.ChannelManager_new(fee_est == null ? 0 : fee_est.ptr, chain_monitor == null ? 0 : chain_monitor.ptr, tx_broadcaster == null ? 0 : tx_broadcaster.ptr, logger == null ? 0 : logger.ptr, keys_manager == null ? 0 : keys_manager.ptr, config == null ? 0 : config.ptr & ~1, params == null ? 0 : params.ptr & ~1);
+ Reference.reachabilityFence(fee_est);
+ Reference.reachabilityFence(chain_monitor);
+ Reference.reachabilityFence(tx_broadcaster);
+ Reference.reachabilityFence(logger);
+ Reference.reachabilityFence(keys_manager);
+ Reference.reachabilityFence(config);
+ Reference.reachabilityFence(params);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ ChannelManager ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new ChannelManager(null, ret); }
+ ret_hu_conv.ptrs_to.add(ret_hu_conv);
+ ret_hu_conv.ptrs_to.add(fee_est);
+ ret_hu_conv.ptrs_to.add(chain_monitor);
+ ret_hu_conv.ptrs_to.add(tx_broadcaster);
+ ret_hu_conv.ptrs_to.add(logger);
+ ret_hu_conv.ptrs_to.add(keys_manager);
+ return ret_hu_conv;
+ }
+
+ /**
+ * Gets the current configuration applied to all new channels, as
+ */
+ public UserConfig get_current_default_configuration() {
+ long ret = bindings.ChannelManager_get_current_default_configuration(this.ptr);
+ Reference.reachabilityFence(this);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ UserConfig ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new UserConfig(null, ret); }
+ ret_hu_conv.ptrs_to.add(this);
+ return ret_hu_conv;
+ }
+
+ /**
+ * Creates a new outbound channel to the given remote node and with the given value.
+ *
+ * `user_channel_id` will be provided back as in
+ * [`Event::FundingGenerationReady::user_channel_id`] to allow tracking of which events
+ * correspond with which `create_channel` call. Note that the `user_channel_id` defaults to 0
+ * for inbound channels, so you may wish to avoid using 0 for `user_channel_id` here.
+ * `user_channel_id` has no meaning inside of LDK, it is simply copied to events and otherwise
+ * ignored.
+ *
+ * Raises [`APIError::APIMisuseError`] when `channel_value_satoshis` > 2**24 or `push_msat` is
+ * greater than `channel_value_satoshis * 1k` or `channel_value_satoshis < 1000`.
+ *
+ * Note that we do not check if you are currently connected to the given peer. If no
+ * connection is available, the outbound `open_channel` message may fail to send, resulting in
+ * the channel eventually being silently forgotten (dropped on reload).
+ *
+ * Returns the new Channel's temporary `channel_id`. This ID will appear as
+ * [`Event::FundingGenerationReady::temporary_channel_id`] and in
+ * [`ChannelDetails::channel_id`] until after
+ * [`ChannelManager::funding_transaction_generated`] is called, swapping the Channel's ID for
+ * one derived from the funding transaction's TXID. If the counterparty rejects the channel
+ * immediately, this temporary ID will appear in [`Event::ChannelClosed::channel_id`].
+ *
+ * [`Event::FundingGenerationReady::user_channel_id`]: events::Event::FundingGenerationReady::user_channel_id
+ * [`Event::FundingGenerationReady::temporary_channel_id`]: events::Event::FundingGenerationReady::temporary_channel_id
+ * [`Event::ChannelClosed::channel_id`]: events::Event::ChannelClosed::channel_id
+ *
+ * Note that override_config (or a relevant inner pointer) may be NULL or all-0s to represent None
+ */
+ public Result__u832APIErrorZ create_channel(byte[] their_network_key, long channel_value_satoshis, long push_msat, long user_channel_id, @Nullable UserConfig override_config) {
+ long ret = bindings.ChannelManager_create_channel(this.ptr, InternalUtils.check_arr_len(their_network_key, 33), channel_value_satoshis, push_msat, user_channel_id, override_config == null ? 0 : override_config.ptr & ~1);
+ Reference.reachabilityFence(this);
+ Reference.reachabilityFence(their_network_key);
+ Reference.reachabilityFence(channel_value_satoshis);
+ Reference.reachabilityFence(push_msat);
+ Reference.reachabilityFence(user_channel_id);
+ Reference.reachabilityFence(override_config);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ Result__u832APIErrorZ ret_hu_conv = Result__u832APIErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;
+ }
+
+ /**
+ * Gets the list of open channels, in random order. See ChannelDetail field documentation for
+ * more information.
+ */
+ public ChannelDetails[] list_channels() {
+ long[] ret = bindings.ChannelManager_list_channels(this.ptr);
+ Reference.reachabilityFence(this);
+ int ret_conv_16_len = ret.length;
+ ChannelDetails[] ret_conv_16_arr = new ChannelDetails[ret_conv_16_len];
+ for (int q = 0; q < ret_conv_16_len; q++) {
+ long ret_conv_16 = ret[q];
+ ChannelDetails ret_conv_16_hu_conv = null; if (ret_conv_16 < 0 || ret_conv_16 > 4096) { ret_conv_16_hu_conv = new ChannelDetails(null, ret_conv_16); }
+ ret_conv_16_hu_conv.ptrs_to.add(this);
+ ret_conv_16_arr[q] = ret_conv_16_hu_conv;
+ }
+ return ret_conv_16_arr;
+ }
+
+ /**
+ * Gets the list of usable channels, in random order. Useful as an argument to
+ * get_route to ensure non-announced channels are used.
+ *
+ * These are guaranteed to have their [`ChannelDetails::is_usable`] value set to true, see the
+ * documentation for [`ChannelDetails::is_usable`] for more info on exactly what the criteria
+ * are.
+ */
+ public ChannelDetails[] list_usable_channels() {
+ long[] ret = bindings.ChannelManager_list_usable_channels(this.ptr);
+ Reference.reachabilityFence(this);
+ int ret_conv_16_len = ret.length;
+ ChannelDetails[] ret_conv_16_arr = new ChannelDetails[ret_conv_16_len];
+ for (int q = 0; q < ret_conv_16_len; q++) {
+ long ret_conv_16 = ret[q];
+ ChannelDetails ret_conv_16_hu_conv = null; if (ret_conv_16 < 0 || ret_conv_16 > 4096) { ret_conv_16_hu_conv = new ChannelDetails(null, ret_conv_16); }
+ ret_conv_16_hu_conv.ptrs_to.add(this);
+ ret_conv_16_arr[q] = ret_conv_16_hu_conv;
+ }
+ return ret_conv_16_arr;
+ }
+
+ /**
+ * Begins the process of closing a channel. After this call (plus some timeout), no new HTLCs
+ * will be accepted on the given channel, and after additional timeout/the closing of all
+ * pending HTLCs, the channel will be closed on chain.
+ *
+ * If we are the channel initiator, we will pay between our [`Background`] and
+ * [`ChannelConfig::force_close_avoidance_max_fee_satoshis`] plus our [`Normal`] fee
+ * estimate.
+ * If our counterparty is the channel initiator, we will require a channel closing
+ * transaction feerate of at least our [`Background`] feerate or the feerate which
+ * would appear on a force-closure transaction, whichever is lower. We will allow our
+ * counterparty to pay as much fee as they'd like, however.
+ *
+ * May generate a SendShutdown message event on success, which should be relayed.
+ *
+ * [`ChannelConfig::force_close_avoidance_max_fee_satoshis`]: crate::util::config::ChannelConfig::force_close_avoidance_max_fee_satoshis
+ * [`Background`]: crate::chain::chaininterface::ConfirmationTarget::Background
+ * [`Normal`]: crate::chain::chaininterface::ConfirmationTarget::Normal
+ */
+ public Result_NoneAPIErrorZ close_channel(byte[] channel_id) {
+ long ret = bindings.ChannelManager_close_channel(this.ptr, InternalUtils.check_arr_len(channel_id, 32));
+ Reference.reachabilityFence(this);
+ Reference.reachabilityFence(channel_id);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ Result_NoneAPIErrorZ ret_hu_conv = Result_NoneAPIErrorZ.constr_from_ptr(ret);
+ return ret_hu_conv;