+ public void block_disconnected(byte[] header, int height, org.ldk.structs.BroadcasterInterface broadcaster, org.ldk.structs.FeeEstimator fee_estimator, org.ldk.structs.Logger logger) {
+ bindings.ChannelMonitor_block_disconnected(this.ptr, InternalUtils.check_arr_len(header, 80), height, broadcaster.ptr, fee_estimator.ptr, logger.ptr);
+ Reference.reachabilityFence(this);
+ Reference.reachabilityFence(header);
+ Reference.reachabilityFence(height);
+ Reference.reachabilityFence(broadcaster);
+ Reference.reachabilityFence(fee_estimator);
+ Reference.reachabilityFence(logger);
+ if (this != null) { this.ptrs_to.add(broadcaster); };
+ if (this != null) { this.ptrs_to.add(fee_estimator); };
+ if (this != null) { this.ptrs_to.add(logger); };
+ }
+
+ /**
+ * Processes transactions confirmed in a block with the given header and height, returning new
+ * outputs to watch. See [`block_connected`] for details.
+ *
+ * Used instead of [`block_connected`] by clients that are notified of transactions rather than
+ * blocks. See [`chain::Confirm`] for calling expectations.
+ *
+ * [`block_connected`]: Self::block_connected
+ */
+ public TwoTuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ[] transactions_confirmed(byte[] header, TwoTuple_usizeTransactionZ[] txdata, int height, org.ldk.structs.BroadcasterInterface broadcaster, org.ldk.structs.FeeEstimator fee_estimator, org.ldk.structs.Logger logger) {
+ long[] ret = bindings.ChannelMonitor_transactions_confirmed(this.ptr, InternalUtils.check_arr_len(header, 80), txdata != null ? Arrays.stream(txdata).mapToLong(txdata_conv_28 -> txdata_conv_28 != null ? txdata_conv_28.ptr : 0).toArray() : null, height, broadcaster.ptr, fee_estimator.ptr, logger.ptr);
+ Reference.reachabilityFence(this);
+ Reference.reachabilityFence(header);
+ Reference.reachabilityFence(txdata);
+ Reference.reachabilityFence(height);
+ Reference.reachabilityFence(broadcaster);
+ Reference.reachabilityFence(fee_estimator);
+ Reference.reachabilityFence(logger);
+ int ret_conv_49_len = ret.length;
+ TwoTuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ[] ret_conv_49_arr = new TwoTuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ[ret_conv_49_len];
+ for (int x = 0; x < ret_conv_49_len; x++) {
+ long ret_conv_49 = ret[x];
+ TwoTuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ ret_conv_49_hu_conv = new TwoTuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ(null, ret_conv_49);
+ if (ret_conv_49_hu_conv != null) { ret_conv_49_hu_conv.ptrs_to.add(this); };
+ ret_conv_49_arr[x] = ret_conv_49_hu_conv;
+ }
+ if (this != null) { this.ptrs_to.add(broadcaster); };
+ if (this != null) { this.ptrs_to.add(fee_estimator); };
+ if (this != null) { this.ptrs_to.add(logger); };
+ return ret_conv_49_arr;
+ }
+
+ /**
+ * Processes a transaction that was reorganized out of the chain.
+ *
+ * Used instead of [`block_disconnected`] by clients that are notified of transactions rather
+ * than blocks. See [`chain::Confirm`] for calling expectations.
+ *
+ * [`block_disconnected`]: Self::block_disconnected
+ */
+ public void transaction_unconfirmed(byte[] txid, org.ldk.structs.BroadcasterInterface broadcaster, org.ldk.structs.FeeEstimator fee_estimator, org.ldk.structs.Logger logger) {
+ bindings.ChannelMonitor_transaction_unconfirmed(this.ptr, InternalUtils.check_arr_len(txid, 32), broadcaster.ptr, fee_estimator.ptr, logger.ptr);
+ Reference.reachabilityFence(this);
+ Reference.reachabilityFence(txid);
+ Reference.reachabilityFence(broadcaster);
+ Reference.reachabilityFence(fee_estimator);
+ Reference.reachabilityFence(logger);
+ if (this != null) { this.ptrs_to.add(broadcaster); };
+ if (this != null) { this.ptrs_to.add(fee_estimator); };
+ if (this != null) { this.ptrs_to.add(logger); };
+ }
+
+ /**
+ * Updates the monitor with the current best chain tip, returning new outputs to watch. See
+ * [`block_connected`] for details.
+ *
+ * Used instead of [`block_connected`] by clients that are notified of transactions rather than
+ * blocks. See [`chain::Confirm`] for calling expectations.
+ *
+ * [`block_connected`]: Self::block_connected
+ */
+ public TwoTuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ[] best_block_updated(byte[] header, int height, org.ldk.structs.BroadcasterInterface broadcaster, org.ldk.structs.FeeEstimator fee_estimator, org.ldk.structs.Logger logger) {
+ long[] ret = bindings.ChannelMonitor_best_block_updated(this.ptr, InternalUtils.check_arr_len(header, 80), height, broadcaster.ptr, fee_estimator.ptr, logger.ptr);
+ Reference.reachabilityFence(this);
+ Reference.reachabilityFence(header);
+ Reference.reachabilityFence(height);
+ Reference.reachabilityFence(broadcaster);
+ Reference.reachabilityFence(fee_estimator);
+ Reference.reachabilityFence(logger);
+ int ret_conv_49_len = ret.length;
+ TwoTuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ[] ret_conv_49_arr = new TwoTuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ[ret_conv_49_len];
+ for (int x = 0; x < ret_conv_49_len; x++) {
+ long ret_conv_49 = ret[x];
+ TwoTuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ ret_conv_49_hu_conv = new TwoTuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ(null, ret_conv_49);
+ if (ret_conv_49_hu_conv != null) { ret_conv_49_hu_conv.ptrs_to.add(this); };
+ ret_conv_49_arr[x] = ret_conv_49_hu_conv;
+ }
+ if (this != null) { this.ptrs_to.add(broadcaster); };
+ if (this != null) { this.ptrs_to.add(fee_estimator); };
+ if (this != null) { this.ptrs_to.add(logger); };
+ return ret_conv_49_arr;
+ }
+
+ /**
+ * Returns the set of txids that should be monitored for re-organization out of the chain.
+ */
+ public ThreeTuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ[] get_relevant_txids() {
+ long[] ret = bindings.ChannelMonitor_get_relevant_txids(this.ptr);
+ Reference.reachabilityFence(this);
+ int ret_conv_54_len = ret.length;
+ ThreeTuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ[] ret_conv_54_arr = new ThreeTuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ[ret_conv_54_len];
+ for (int c = 0; c < ret_conv_54_len; c++) {
+ long ret_conv_54 = ret[c];
+ ThreeTuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ ret_conv_54_hu_conv = new ThreeTuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ(null, ret_conv_54);
+ if (ret_conv_54_hu_conv != null) { ret_conv_54_hu_conv.ptrs_to.add(this); };
+ ret_conv_54_arr[c] = ret_conv_54_hu_conv;
+ }
+ return ret_conv_54_arr;
+ }
+
+ /**
+ * Gets the latest best block which was connected either via the [`chain::Listen`] or
+ * [`chain::Confirm`] interfaces.
+ */
+ public BestBlock current_best_block() {
+ long ret = bindings.ChannelMonitor_current_best_block(this.ptr);
+ Reference.reachabilityFence(this);
+ if (ret >= 0 && ret <= 4096) { return null; }
+ org.ldk.structs.BestBlock ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.BestBlock(null, ret); }
+ if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); };
+ return ret_hu_conv;
+ }
+
+ /**
+ * Triggers rebroadcasts/fee-bumps of pending claims from a force-closed channel. This is
+ * crucial in preventing certain classes of pinning attacks, detecting substantial mempool
+ * feerate changes between blocks, and ensuring reliability if broadcasting fails. We recommend
+ * invoking this every 30 seconds, or lower if running in an environment with spotty
+ * connections, like on mobile.
+ */
+ public void rebroadcast_pending_claims(org.ldk.structs.BroadcasterInterface broadcaster, org.ldk.structs.FeeEstimator fee_estimator, org.ldk.structs.Logger logger) {
+ bindings.ChannelMonitor_rebroadcast_pending_claims(this.ptr, broadcaster.ptr, fee_estimator.ptr, logger.ptr);
+ Reference.reachabilityFence(this);
+ Reference.reachabilityFence(broadcaster);
+ Reference.reachabilityFence(fee_estimator);
+ Reference.reachabilityFence(logger);
+ if (this != null) { this.ptrs_to.add(broadcaster); };
+ if (this != null) { this.ptrs_to.add(fee_estimator); };
+ if (this != null) { this.ptrs_to.add(logger); };
+ }
+
+ /**
+ * Returns the descriptors for relevant outputs (i.e., those that we can spend) within the
+ * transaction if they exist and the transaction has at least [`ANTI_REORG_DELAY`]
+ * confirmations. For [`SpendableOutputDescriptor::DelayedPaymentOutput`] descriptors to be
+ * returned, the transaction must have at least `max(ANTI_REORG_DELAY, to_self_delay)`
+ * confirmations.
+ *
+ * Descriptors returned by this method are primarily exposed via [`Event::SpendableOutputs`]
+ * once they are no longer under reorg risk. This method serves as a way to retrieve these
+ * descriptors at a later time, either for historical purposes, or to replay any
+ * missed/unhandled descriptors. For the purpose of gathering historical records, if the
+ * channel close has fully resolved (i.e., [`ChannelMonitor::get_claimable_balances`] returns
+ * an empty set), you can retrieve all spendable outputs by providing all descendant spending
+ * transactions starting from the channel's funding transaction and going down three levels.
+ *
+ * `tx` is a transaction we'll scan the outputs of. Any transaction can be provided. If any
+ * outputs which can be spent by us are found, at least one descriptor is returned.
+ *
+ * `confirmation_height` must be the height of the block in which `tx` was included in.
+ */
+ public SpendableOutputDescriptor[] get_spendable_outputs(byte[] tx, int confirmation_height) {
+ long[] ret = bindings.ChannelMonitor_get_spendable_outputs(this.ptr, tx, confirmation_height);
+ Reference.reachabilityFence(this);
+ Reference.reachabilityFence(tx);
+ Reference.reachabilityFence(confirmation_height);
+ int ret_conv_27_len = ret.length;
+ SpendableOutputDescriptor[] ret_conv_27_arr = new SpendableOutputDescriptor[ret_conv_27_len];
+ for (int b = 0; b < ret_conv_27_len; b++) {
+ long ret_conv_27 = ret[b];
+ org.ldk.structs.SpendableOutputDescriptor ret_conv_27_hu_conv = org.ldk.structs.SpendableOutputDescriptor.constr_from_ptr(ret_conv_27);
+ if (ret_conv_27_hu_conv != null) { ret_conv_27_hu_conv.ptrs_to.add(this); };
+ ret_conv_27_arr[b] = ret_conv_27_hu_conv;
+ }
+ return ret_conv_27_arr;
+ }
+
+ /**
+ * Gets the balances in this channel which are either claimable by us if we were to
+ * force-close the channel now or which are claimable on-chain (possibly awaiting
+ * confirmation).
+ *
+ * Any balances in the channel which are available on-chain (excluding on-chain fees) are
+ * included here until an [`Event::SpendableOutputs`] event has been generated for the
+ * balance, or until our counterparty has claimed the balance and accrued several
+ * confirmations on the claim transaction.
+ *
+ * Note that for `ChannelMonitors` which track a channel which went on-chain with versions of
+ * LDK prior to 0.0.111, not all or excess balances may be included.
+ *
+ * See [`Balance`] for additional details on the types of claimable balances which
+ * may be returned here and their meanings.
+ */
+ public Balance[] get_claimable_balances() {
+ long[] ret = bindings.ChannelMonitor_get_claimable_balances(this.ptr);
+ Reference.reachabilityFence(this);
+ int ret_conv_9_len = ret.length;
+ Balance[] ret_conv_9_arr = new Balance[ret_conv_9_len];
+ for (int j = 0; j < ret_conv_9_len; j++) {
+ long ret_conv_9 = ret[j];
+ org.ldk.structs.Balance ret_conv_9_hu_conv = org.ldk.structs.Balance.constr_from_ptr(ret_conv_9);
+ if (ret_conv_9_hu_conv != null) { ret_conv_9_hu_conv.ptrs_to.add(this); };
+ ret_conv_9_arr[j] = ret_conv_9_hu_conv;
+ }
+ return ret_conv_9_arr;