X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Fmain%2Fjava%2Forg%2Fldk%2Fstructs%2FChannelMonitor.java;h=642c097ab91a335ea24955c7806620cf1b787f60;hb=2bb592fb946e316dba9f4d1123f8ac72ff4e9bf8;hp=e16b37978945913aca2d08b3ffd11f9bdad6485d;hpb=f8c25e52ce878136043ddc4dbfac6c6640f1d4f6;p=ldk-java diff --git a/src/main/java/org/ldk/structs/ChannelMonitor.java b/src/main/java/org/ldk/structs/ChannelMonitor.java index e16b3797..642c097a 100644 --- a/src/main/java/org/ldk/structs/ChannelMonitor.java +++ b/src/main/java/org/ldk/structs/ChannelMonitor.java @@ -4,6 +4,8 @@ import org.ldk.impl.bindings; import org.ldk.enums.*; import org.ldk.util.*; import java.util.Arrays; +import java.lang.ref.Reference; +import javax.annotation.Nullable; /** @@ -13,11 +15,6 @@ import java.util.Arrays; * You MUST ensure that no ChannelMonitors for a given channel anywhere contain out-of-date * information and are actively monitoring the chain. * - * Pending Events or updated HTLCs which have not yet been read out by - * get_and_clear_pending_monitor_events or get_and_clear_pending_events are serialized to disk and - * reloaded at deserialize-time. Thus, you must ensure that, when handling events, all events - * gotten are fully handled before re-serializing the new state. - * * Note that the deserializer is only implemented for (BlockHash, ChannelMonitor), which * tells you the last block hash which was block_connect()ed. You MUST rescan any blocks along * the \"reorg path\" (ie disconnecting blocks until you find a common ancestor from both the @@ -33,13 +30,21 @@ public class ChannelMonitor extends CommonBase { if (ptr != 0) { bindings.ChannelMonitor_free(ptr); } } + long clone_ptr() { + long ret = bindings.ChannelMonitor_clone_ptr(this.ptr); + Reference.reachabilityFence(this); + return ret; + } + /** * Creates a copy of the ChannelMonitor */ public ChannelMonitor clone() { long ret = bindings.ChannelMonitor_clone(this.ptr); - ChannelMonitor ret_hu_conv = new ChannelMonitor(null, ret); - ret_hu_conv.ptrs_to.add(this); + Reference.reachabilityFence(this); + if (ret >= 0 && ret <= 4096) { return null; } + org.ldk.structs.ChannelMonitor ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.ChannelMonitor(null, ret); } + if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); }; return ret_hu_conv; } @@ -48,6 +53,7 @@ public class ChannelMonitor extends CommonBase { */ public byte[] write() { byte[] ret = bindings.ChannelMonitor_write(this.ptr); + Reference.reachabilityFence(this); return ret; } @@ -57,13 +63,19 @@ public class ChannelMonitor extends CommonBase { * * panics if the given update is not the next update by update_id. */ - public Result_NoneMonitorUpdateErrorZ update_monitor(ChannelMonitorUpdate updates, BroadcasterInterface broadcaster, FeeEstimator fee_estimator, Logger logger) { - long ret = bindings.ChannelMonitor_update_monitor(this.ptr, updates == null ? 0 : updates.ptr & ~1, broadcaster == null ? 0 : broadcaster.ptr, fee_estimator == null ? 0 : fee_estimator.ptr, logger == null ? 0 : logger.ptr); - Result_NoneMonitorUpdateErrorZ ret_hu_conv = Result_NoneMonitorUpdateErrorZ.constr_from_ptr(ret); - this.ptrs_to.add(updates); - this.ptrs_to.add(broadcaster); - this.ptrs_to.add(fee_estimator); - this.ptrs_to.add(logger); + public Result_NoneNoneZ update_monitor(org.ldk.structs.ChannelMonitorUpdate updates, org.ldk.structs.BroadcasterInterface broadcaster, org.ldk.structs.FeeEstimator fee_estimator, org.ldk.structs.Logger logger) { + long ret = bindings.ChannelMonitor_update_monitor(this.ptr, updates == null ? 0 : updates.ptr, broadcaster.ptr, fee_estimator.ptr, logger.ptr); + Reference.reachabilityFence(this); + Reference.reachabilityFence(updates); + Reference.reachabilityFence(broadcaster); + Reference.reachabilityFence(fee_estimator); + Reference.reachabilityFence(logger); + if (ret >= 0 && ret <= 4096) { return null; } + Result_NoneNoneZ ret_hu_conv = Result_NoneNoneZ.constr_from_ptr(ret); + if (this != null) { this.ptrs_to.add(updates); }; + 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_hu_conv; } @@ -73,51 +85,38 @@ public class ChannelMonitor extends CommonBase { */ public long get_latest_update_id() { long ret = bindings.ChannelMonitor_get_latest_update_id(this.ptr); + Reference.reachabilityFence(this); return ret; } /** * Gets the funding transaction outpoint of the channel this ChannelMonitor is monitoring for. */ - public TwoTuple get_funding_txo() { + public TwoTuple_OutPointCVec_u8ZZ get_funding_txo() { long ret = bindings.ChannelMonitor_get_funding_txo(this.ptr); - long ret_a = bindings.LDKC2Tuple_OutPointScriptZ_get_a(ret); - OutPoint ret_a_hu_conv = new OutPoint(null, ret_a); - ret_a_hu_conv.ptrs_to.add(this);; - byte[] ret_b = bindings.LDKC2Tuple_OutPointScriptZ_get_b(ret); - TwoTuple ret_conv = new TwoTuple(ret_a_hu_conv, ret_b, () -> { - bindings.C2Tuple_OutPointScriptZ_free(ret); - }); - ret_a_hu_conv.ptrs_to.add(ret_conv); - return ret_conv; + Reference.reachabilityFence(this); + if (ret >= 0 && ret <= 4096) { return null; } + TwoTuple_OutPointCVec_u8ZZ ret_hu_conv = new TwoTuple_OutPointCVec_u8ZZ(null, ret); + if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); }; + return ret_hu_conv; } /** * Gets a list of txids, with their output scripts (in the order they appear in the * transaction), which we must learn about spends of via block_connected(). */ - public TwoTuple[]>[] get_outputs_to_watch() { + public TwoTuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ[] get_outputs_to_watch() { long[] ret = bindings.ChannelMonitor_get_outputs_to_watch(this.ptr); - TwoTuple[]>[] ret_conv_47_arr = new TwoTuple[ret.length]; - for (int v = 0; v < ret.length; v++) { - long ret_conv_47 = ret[v]; - byte[] ret_conv_47_a = bindings.LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(ret_conv_47); - long[] ret_conv_47_b = bindings.LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(ret_conv_47); - TwoTuple[] ret_conv_47_b_conv_27_arr = new TwoTuple[ret_conv_47_b.length]; - for (int b = 0; b < ret_conv_47_b.length; b++) { - long ret_conv_47_b_conv_27 = ret_conv_47_b[b]; - int ret_conv_47_b_conv_27_a = bindings.LDKC2Tuple_u32ScriptZ_get_a(ret_conv_47_b_conv_27); - byte[] ret_conv_47_b_conv_27_b = bindings.LDKC2Tuple_u32ScriptZ_get_b(ret_conv_47_b_conv_27); - TwoTuple ret_conv_47_b_conv_27_conv = new TwoTuple(ret_conv_47_b_conv_27_a, ret_conv_47_b_conv_27_b, () -> { - bindings.C2Tuple_u32ScriptZ_free(ret_conv_47_b_conv_27); - }); - ret_conv_47_b_conv_27_arr[b] = ret_conv_47_b_conv_27_conv; - }; - TwoTuple[]> ret_conv_47_conv = new TwoTuple[]>(ret_conv_47_a, ret_conv_47_b_conv_27_arr); - // Warning: We may not free the C tuple object! - ret_conv_47_arr[v] = ret_conv_47_conv; + Reference.reachabilityFence(this); + int ret_conv_52_len = ret.length; + TwoTuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ[] ret_conv_52_arr = new TwoTuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ[ret_conv_52_len]; + for (int a = 0; a < ret_conv_52_len; a++) { + long ret_conv_52 = ret[a]; + TwoTuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ ret_conv_52_hu_conv = new TwoTuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ(null, ret_conv_52); + if (ret_conv_52_hu_conv != null) { ret_conv_52_hu_conv.ptrs_to.add(this); }; + ret_conv_52_arr[a] = ret_conv_52_hu_conv; } - return ret_conv_47_arr; + return ret_conv_52_arr; } /** @@ -125,9 +124,13 @@ public class ChannelMonitor extends CommonBase { * calling `chain::Filter::register_output` and `chain::Filter::register_tx` until all outputs * have been registered. */ - public void load_outputs_to_watch(Filter filter) { - bindings.ChannelMonitor_load_outputs_to_watch(this.ptr, filter == null ? 0 : filter.ptr); - this.ptrs_to.add(filter); + public void load_outputs_to_watch(org.ldk.structs.Filter filter, org.ldk.structs.Logger logger) { + bindings.ChannelMonitor_load_outputs_to_watch(this.ptr, filter.ptr, logger.ptr); + Reference.reachabilityFence(this); + Reference.reachabilityFence(filter); + Reference.reachabilityFence(logger); + if (this != null) { this.ptrs_to.add(filter); }; + if (this != null) { this.ptrs_to.add(logger); }; } /** @@ -136,50 +139,171 @@ public class ChannelMonitor extends CommonBase { */ public MonitorEvent[] get_and_clear_pending_monitor_events() { long[] ret = bindings.ChannelMonitor_get_and_clear_pending_monitor_events(this.ptr); - MonitorEvent[] ret_conv_14_arr = new MonitorEvent[ret.length]; - for (int o = 0; o < ret.length; o++) { + Reference.reachabilityFence(this); + int ret_conv_14_len = ret.length; + MonitorEvent[] ret_conv_14_arr = new MonitorEvent[ret_conv_14_len]; + for (int o = 0; o < ret_conv_14_len; o++) { long ret_conv_14 = ret[o]; - MonitorEvent ret_conv_14_hu_conv = MonitorEvent.constr_from_ptr(ret_conv_14); - ret_conv_14_hu_conv.ptrs_to.add(this); + org.ldk.structs.MonitorEvent ret_conv_14_hu_conv = org.ldk.structs.MonitorEvent.constr_from_ptr(ret_conv_14); + if (ret_conv_14_hu_conv != null) { ret_conv_14_hu_conv.ptrs_to.add(this); }; ret_conv_14_arr[o] = ret_conv_14_hu_conv; } return ret_conv_14_arr; } /** - * Gets the list of pending events which were generated by previous actions, clearing the list - * in the process. + * Processes [`SpendableOutputs`] events produced from each [`ChannelMonitor`] upon maturity. + * + * For channels featuring anchor outputs, this method will also process [`BumpTransaction`] + * events produced from each [`ChannelMonitor`] while there is a balance to claim onchain + * within each channel. As the confirmation of a commitment transaction may be critical to the + * safety of funds, we recommend invoking this every 30 seconds, or lower if running in an + * environment with spotty connections, like on mobile. + * + * An [`EventHandler`] may safely call back to the provider, though this shouldn't be needed in + * order to handle these events. + * + * [`SpendableOutputs`]: crate::events::Event::SpendableOutputs + * [`BumpTransaction`]: crate::events::Event::BumpTransaction + */ + public void process_pending_events(org.ldk.structs.EventHandler handler) { + bindings.ChannelMonitor_process_pending_events(this.ptr, handler.ptr); + Reference.reachabilityFence(this); + Reference.reachabilityFence(handler); + if (this != null) { this.ptrs_to.add(handler); }; + } + + /** + * Gets the counterparty's initial commitment transaction. The returned commitment + * transaction is unsigned. This is intended to be called during the initial persistence of + * the monitor (inside an implementation of [`Persist::persist_new_channel`]), to allow for + * watchtowers in the persistence pipeline to have enough data to form justice transactions. + * + * This is similar to [`Self::counterparty_commitment_txs_from_update`], except + * that for the initial commitment transaction, we don't have a corresponding update. + * + * This will only return `Some` for channel monitors that have been created after upgrading + * to LDK 0.0.117+. + * + * [`Persist::persist_new_channel`]: crate::chain::chainmonitor::Persist::persist_new_channel + * + * Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None + */ + @Nullable + public CommitmentTransaction initial_counterparty_commitment_tx() { + long ret = bindings.ChannelMonitor_initial_counterparty_commitment_tx(this.ptr); + Reference.reachabilityFence(this); + if (ret >= 0 && ret <= 4096) { return null; } + org.ldk.structs.CommitmentTransaction ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.CommitmentTransaction(null, ret); } + if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); }; + return ret_hu_conv; + } + + /** + * Gets all of the counterparty commitment transactions provided by the given update. This + * may be empty if the update doesn't include any new counterparty commitments. Returned + * commitment transactions are unsigned. + * + * This is provided so that watchtower clients in the persistence pipeline are able to build + * justice transactions for each counterparty commitment upon each update. It's intended to be + * used within an implementation of [`Persist::update_persisted_channel`], which is provided + * with a monitor and an update. Once revoked, signing a justice transaction can be done using + * [`Self::sign_to_local_justice_tx`]. + * + * It is expected that a watchtower client may use this method to retrieve the latest counterparty + * commitment transaction(s), and then hold the necessary data until a later update in which + * the monitor has been updated with the corresponding revocation data, at which point the + * monitor can sign the justice transaction. * - * This is called by ChainMonitor::get_and_clear_pending_events() and is equivalent to - * EventsProvider::get_and_clear_pending_events() except that it requires &mut self as we do - * no internal locking in ChannelMonitors. + * This will only return a non-empty list for monitor updates that have been created after + * upgrading to LDK 0.0.117+. Note that no restriction lies on the monitors themselves, which + * may have been created prior to upgrading. + * + * [`Persist::update_persisted_channel`]: crate::chain::chainmonitor::Persist::update_persisted_channel */ - public Event[] get_and_clear_pending_events() { - long[] ret = bindings.ChannelMonitor_get_and_clear_pending_events(this.ptr); - Event[] ret_conv_7_arr = new Event[ret.length]; - for (int h = 0; h < ret.length; h++) { - long ret_conv_7 = ret[h]; - Event ret_conv_7_hu_conv = Event.constr_from_ptr(ret_conv_7); - ret_conv_7_hu_conv.ptrs_to.add(this); - ret_conv_7_arr[h] = ret_conv_7_hu_conv; + public CommitmentTransaction[] counterparty_commitment_txs_from_update(org.ldk.structs.ChannelMonitorUpdate update) { + long[] ret = bindings.ChannelMonitor_counterparty_commitment_txs_from_update(this.ptr, update == null ? 0 : update.ptr); + Reference.reachabilityFence(this); + Reference.reachabilityFence(update); + int ret_conv_23_len = ret.length; + CommitmentTransaction[] ret_conv_23_arr = new CommitmentTransaction[ret_conv_23_len]; + for (int x = 0; x < ret_conv_23_len; x++) { + long ret_conv_23 = ret[x]; + org.ldk.structs.CommitmentTransaction ret_conv_23_hu_conv = null; if (ret_conv_23 < 0 || ret_conv_23 > 4096) { ret_conv_23_hu_conv = new org.ldk.structs.CommitmentTransaction(null, ret_conv_23); } + if (ret_conv_23_hu_conv != null) { ret_conv_23_hu_conv.ptrs_to.add(this); }; + ret_conv_23_arr[x] = ret_conv_23_hu_conv; } - return ret_conv_7_arr; + if (this != null) { this.ptrs_to.add(update); }; + return ret_conv_23_arr; + } + + /** + * Wrapper around [`EcdsaChannelSigner::sign_justice_revoked_output`] to make + * signing the justice transaction easier for implementors of + * [`chain::chainmonitor::Persist`]. On success this method returns the provided transaction + * signing the input at `input_idx`. This method will only produce a valid signature for + * a transaction spending the `to_local` output of a commitment transaction, i.e. this cannot + * be used for revoked HTLC outputs. + * + * `Value` is the value of the output being spent by the input at `input_idx`, committed + * in the BIP 143 signature. + * + * This method will only succeed if this monitor has received the revocation secret for the + * provided `commitment_number`. If a commitment number is provided that does not correspond + * to the commitment transaction being revoked, this will return a signed transaction, but + * the signature will not be valid. + * + * [`EcdsaChannelSigner::sign_justice_revoked_output`]: crate::sign::ecdsa::EcdsaChannelSigner::sign_justice_revoked_output + * [`Persist`]: crate::chain::chainmonitor::Persist + */ + public Result_TransactionNoneZ sign_to_local_justice_tx(byte[] justice_tx, long input_idx, long value, long commitment_number) { + long ret = bindings.ChannelMonitor_sign_to_local_justice_tx(this.ptr, justice_tx, input_idx, value, commitment_number); + Reference.reachabilityFence(this); + Reference.reachabilityFence(justice_tx); + Reference.reachabilityFence(input_idx); + Reference.reachabilityFence(value); + Reference.reachabilityFence(commitment_number); + if (ret >= 0 && ret <= 4096) { return null; } + Result_TransactionNoneZ ret_hu_conv = Result_TransactionNoneZ.constr_from_ptr(ret); + return ret_hu_conv; } /** - * Used by ChannelManager deserialization to broadcast the latest holder state if its copy of - * the Channel was out-of-date. You may use it to get a broadcastable holder toxic tx in case of - * fallen-behind, i.e when receiving a channel_reestablish with a proof that our counterparty side knows - * a higher revocation secret than the holder commitment number we are aware of. Broadcasting these - * transactions are UNSAFE, as they allow counterparty side to punish you. Nevertheless you may want to - * broadcast them if counterparty don't close channel with his higher commitment transaction after a - * substantial amount of time (a month or even a year) to get back funds. Best may be to contact - * out-of-band the other node operator to coordinate with him if option is available to you. - * In any-case, choice is up to the user. + * Gets the `node_id` of the counterparty for this channel. + * + * Will be `None` for channels constructed on LDK versions prior to 0.0.110 and always `Some` + * otherwise. + * + * Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None */ - public byte[][] get_latest_holder_commitment_txn(Logger logger) { - byte[][] ret = bindings.ChannelMonitor_get_latest_holder_commitment_txn(this.ptr, logger == null ? 0 : logger.ptr); - this.ptrs_to.add(logger); + @Nullable + public byte[] get_counterparty_node_id() { + byte[] ret = bindings.ChannelMonitor_get_counterparty_node_id(this.ptr); + Reference.reachabilityFence(this); + return ret; + } + + /** + * Used by [`ChannelManager`] deserialization to broadcast the latest holder state if its copy + * of the channel state was out-of-date. + * + * You may also use this to broadcast the latest local commitment transaction, either because + * a monitor update failed or because we've fallen behind (i.e. we've received proof that our + * counterparty side knows a revocation secret we gave them that they shouldn't know). + * + * Broadcasting these transactions in the second case is UNSAFE, as they allow counterparty + * side to punish you. Nevertheless you may want to broadcast them if counterparty doesn't + * close channel with their commitment transaction after a substantial amount of time. Best + * may be to contact the other node operator out-of-band to coordinate other options available + * to you. + * + * [`ChannelManager`]: crate::ln::channelmanager::ChannelManager + */ + public byte[][] get_latest_holder_commitment_txn(org.ldk.structs.Logger logger) { + byte[][] ret = bindings.ChannelMonitor_get_latest_holder_commitment_txn(this.ptr, logger.ptr); + Reference.reachabilityFence(this); + Reference.reachabilityFence(logger); + if (this != null) { this.ptrs_to.add(logger); }; return ret; } @@ -196,45 +320,241 @@ public class ChannelMonitor extends CommonBase { * * [`get_outputs_to_watch`]: #method.get_outputs_to_watch */ - public TwoTuple[]>[] block_connected(byte[] header, TwoTuple[] txdata, int height, BroadcasterInterface broadcaster, FeeEstimator fee_estimator, Logger logger) { - long[] ret = bindings.ChannelMonitor_block_connected(this.ptr, header, Arrays.stream(txdata).mapToLong(txdata_conv_24 -> bindings.C2Tuple_usizeTransactionZ_new(txdata_conv_24.a, txdata_conv_24.b)).toArray(), height, broadcaster == null ? 0 : broadcaster.ptr, fee_estimator == null ? 0 : fee_estimator.ptr, logger == null ? 0 : logger.ptr); - TwoTuple[]>[] ret_conv_46_arr = new TwoTuple[ret.length]; - for (int u = 0; u < ret.length; u++) { - long ret_conv_46 = ret[u]; - byte[] ret_conv_46_a = bindings.LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(ret_conv_46); - long[] ret_conv_46_b = bindings.LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(ret_conv_46); - TwoTuple[] ret_conv_46_b_conv_26_arr = new TwoTuple[ret_conv_46_b.length]; - for (int a = 0; a < ret_conv_46_b.length; a++) { - long ret_conv_46_b_conv_26 = ret_conv_46_b[a]; - int ret_conv_46_b_conv_26_a = bindings.LDKC2Tuple_u32TxOutZ_get_a(ret_conv_46_b_conv_26); - long ret_conv_46_b_conv_26_b = bindings.TxOut_clone(bindings.LDKC2Tuple_u32TxOutZ_get_b(ret_conv_46_b_conv_26)); - TxOut ret_conv_46_b_conv_26_b_conv = new TxOut(null, ret_conv_46_b_conv_26_b);; - TwoTuple ret_conv_46_b_conv_26_conv = new TwoTuple(ret_conv_46_b_conv_26_a, ret_conv_46_b_conv_26_b_conv, () -> { - bindings.C2Tuple_u32TxOutZ_free(ret_conv_46_b_conv_26); - }); - ret_conv_46_b_conv_26_b_conv.ptrs_to.add(ret_conv_46_b_conv_26_conv); - ret_conv_46_b_conv_26_arr[a] = ret_conv_46_b_conv_26_conv; - }; - TwoTuple[]> ret_conv_46_conv = new TwoTuple[]>(ret_conv_46_a, ret_conv_46_b_conv_26_arr); - // Warning: We may not free the C tuple object! - ret_conv_46_arr[u] = ret_conv_46_conv; + public TwoTuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ[] block_connected(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_block_connected(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; } - /* TODO 2 TwoTuple */; - this.ptrs_to.add(broadcaster); - this.ptrs_to.add(fee_estimator); - this.ptrs_to.add(logger); - return ret_conv_46_arr; + 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; } /** * Determines if the disconnected block contained any transactions of interest and updates * appropriately. */ - public void block_disconnected(byte[] header, int height, BroadcasterInterface broadcaster, FeeEstimator fee_estimator, Logger logger) { - bindings.ChannelMonitor_block_disconnected(this.ptr, header, height, broadcaster == null ? 0 : broadcaster.ptr, fee_estimator == null ? 0 : fee_estimator.ptr, logger == null ? 0 : logger.ptr); - this.ptrs_to.add(broadcaster); - this.ptrs_to.add(fee_estimator); - this.ptrs_to.add(logger); + 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; } }