X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=c_sharp%2Fsrc%2Forg%2Fldk%2Fstructs%2FChannelMonitor.cs;fp=c_sharp%2Fsrc%2Forg%2Fldk%2Fstructs%2FChannelMonitor.cs;h=a435ba6a8f6e3c94b603ed483081e40a90b4ff83;hb=8de7213fbf663ff60322896282dad51e8ab2f001;hp=19300a5941a8564c96a4836dd6889442341743f8;hpb=afc50e5d491a11364849383b75a8f939df703bac;p=ldk-java diff --git a/c_sharp/src/org/ldk/structs/ChannelMonitor.cs b/c_sharp/src/org/ldk/structs/ChannelMonitor.cs index 19300a59..a435ba6a 100644 --- a/c_sharp/src/org/ldk/structs/ChannelMonitor.cs +++ b/c_sharp/src/org/ldk/structs/ChannelMonitor.cs @@ -47,9 +47,11 @@ public class ChannelMonitor : CommonBase { * Serialize the ChannelMonitor object into a byte array which can be read by ChannelMonitor_read */ public byte[] write() { - byte[] ret = bindings.ChannelMonitor_write(this.ptr); + long ret = bindings.ChannelMonitor_write(this.ptr); GC.KeepAlive(this); - return ret; + if (ret >= 0 && ret <= 4096) { return null; } + byte[] ret_conv = InternalUtils.decodeUint8Array(ret); + return ret_conv; } /** @@ -87,11 +89,11 @@ public class ChannelMonitor : CommonBase { /** * Gets the funding transaction outpoint of the channel this ChannelMonitor is monitoring for. */ - public TwoTuple_OutPointScriptZ get_funding_txo() { + public TwoTuple_OutPointCVec_u8ZZ get_funding_txo() { long ret = bindings.ChannelMonitor_get_funding_txo(this.ptr); GC.KeepAlive(this); if (ret >= 0 && ret <= 4096) { return null; } - TwoTuple_OutPointScriptZ ret_hu_conv = new TwoTuple_OutPointScriptZ(null, ret); + TwoTuple_OutPointCVec_u8ZZ ret_hu_conv = new TwoTuple_OutPointCVec_u8ZZ(null, ret); if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(this); }; return ret_hu_conv; } @@ -100,18 +102,20 @@ public class ChannelMonitor : CommonBase { * 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_TxidCVec_C2Tuple_u32ScriptZZZ[] get_outputs_to_watch() { - long[] ret = bindings.ChannelMonitor_get_outputs_to_watch(this.ptr); + public TwoTuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ[] get_outputs_to_watch() { + long ret = bindings.ChannelMonitor_get_outputs_to_watch(this.ptr); GC.KeepAlive(this); - int ret_conv_40_len = ret.Length; - TwoTuple_TxidCVec_C2Tuple_u32ScriptZZZ[] ret_conv_40_arr = new TwoTuple_TxidCVec_C2Tuple_u32ScriptZZZ[ret_conv_40_len]; - for (int o = 0; o < ret_conv_40_len; o++) { - long ret_conv_40 = ret[o]; - TwoTuple_TxidCVec_C2Tuple_u32ScriptZZZ ret_conv_40_hu_conv = new TwoTuple_TxidCVec_C2Tuple_u32ScriptZZZ(null, ret_conv_40); - if (ret_conv_40_hu_conv != null) { ret_conv_40_hu_conv.ptrs_to.AddLast(this); }; - ret_conv_40_arr[o] = ret_conv_40_hu_conv; + if (ret >= 0 && ret <= 4096) { return null; } + int ret_conv_52_len = InternalUtils.getArrayLength(ret); + 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 = InternalUtils.getU64ArrayElem(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.AddLast(this); }; + ret_conv_52_arr[a] = ret_conv_52_hu_conv; } - return ret_conv_40_arr; + bindings.free_buffer(ret); + return ret_conv_52_arr; } /** @@ -131,16 +135,18 @@ public class ChannelMonitor : CommonBase { * ChannelManager via [`chain::Watch::release_pending_monitor_events`]. */ public MonitorEvent[] get_and_clear_pending_monitor_events() { - long[] ret = bindings.ChannelMonitor_get_and_clear_pending_monitor_events(this.ptr); + long ret = bindings.ChannelMonitor_get_and_clear_pending_monitor_events(this.ptr); GC.KeepAlive(this); - int ret_conv_14_len = ret.Length; + if (ret >= 0 && ret <= 4096) { return null; } + int ret_conv_14_len = InternalUtils.getArrayLength(ret); 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]; + long ret_conv_14 = InternalUtils.getU64ArrayElem(ret, o); 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.AddLast(this); }; ret_conv_14_arr[o] = ret_conv_14_hu_conv; } + bindings.free_buffer(ret); return ret_conv_14_arr; } @@ -166,6 +172,102 @@ public class ChannelMonitor : CommonBase { if (this != null) { this.ptrs_to.AddLast(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 + */ + public CommitmentTransaction initial_counterparty_commitment_tx() { + long ret = bindings.ChannelMonitor_initial_counterparty_commitment_tx(this.ptr); + GC.KeepAlive(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.AddLast(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 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 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); + GC.KeepAlive(this); + GC.KeepAlive(update); + if (ret >= 0 && ret <= 4096) { return null; } + int ret_conv_23_len = InternalUtils.getArrayLength(ret); + 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 = InternalUtils.getU64ArrayElem(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.AddLast(this); }; + ret_conv_23_arr[x] = ret_conv_23_hu_conv; + } + bindings.free_buffer(ret); + if (this != null) { this.ptrs_to.AddLast(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::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, InternalUtils.encodeUint8Array(justice_tx), input_idx, value, commitment_number); + GC.KeepAlive(this); + GC.KeepAlive(justice_tx); + GC.KeepAlive(input_idx); + GC.KeepAlive(value); + GC.KeepAlive(commitment_number); + if (ret >= 0 && ret <= 4096) { return null; } + Result_TransactionNoneZ ret_hu_conv = Result_TransactionNoneZ.constr_from_ptr(ret); + return ret_hu_conv; + } + /** * Gets the `node_id` of the counterparty for this channel. * @@ -175,34 +277,44 @@ public class ChannelMonitor : CommonBase { * Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None */ public byte[] get_counterparty_node_id() { - byte[] ret = bindings.ChannelMonitor_get_counterparty_node_id(this.ptr); + long ret = bindings.ChannelMonitor_get_counterparty_node_id(this.ptr); GC.KeepAlive(this); - return ret; + if (ret >= 0 && ret <= 4096) { return null; } + byte[] ret_conv = InternalUtils.decodeUint8Array(ret); + return ret_conv; } /** - * Used by ChannelManager deserialization to broadcast the latest holder state if its copy of - * the Channel was out-of-date. + * 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 with [`ChannelMonitorUpdateStatus::PermanentFailure`] 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). + * 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. In any-case, the choice is up to you. + * to you. * - * [`ChannelMonitorUpdateStatus::PermanentFailure`]: super::ChannelMonitorUpdateStatus::PermanentFailure + * [`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); + long ret = bindings.ChannelMonitor_get_latest_holder_commitment_txn(this.ptr, logger.ptr); GC.KeepAlive(this); GC.KeepAlive(logger); + if (ret >= 0 && ret <= 4096) { return null; } + int ret_conv_8_len = InternalUtils.getArrayLength(ret); + byte[][] ret_conv_8_arr = new byte[ret_conv_8_len][]; + for (int i = 0; i < ret_conv_8_len; i++) { + long ret_conv_8 = InternalUtils.getU64ArrayElem(ret, i); + byte[] ret_conv_8_conv = InternalUtils.decodeUint8Array(ret_conv_8); + ret_conv_8_arr[i] = ret_conv_8_conv; + } + bindings.free_buffer(ret); if (this != null) { this.ptrs_to.AddLast(logger); }; - return ret; + return ret_conv_8_arr; } /** @@ -218,8 +330,8 @@ public class ChannelMonitor : CommonBase { * * [`get_outputs_to_watch`]: #method.get_outputs_to_watch */ - public TwoTuple_TxidCVec_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 ? InternalUtils.mapArray(txdata, txdata_conv_28 => txdata_conv_28 != null ? txdata_conv_28.ptr : 0) : null, height, broadcaster.ptr, fee_estimator.ptr, logger.ptr); + 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.encodeUint8Array(InternalUtils.check_arr_len(header, 80)), InternalUtils.encodeUint64Array(InternalUtils.mapArray(txdata, txdata_conv_28 => txdata_conv_28 != null ? txdata_conv_28.ptr : 0)), height, broadcaster.ptr, fee_estimator.ptr, logger.ptr); GC.KeepAlive(this); GC.KeepAlive(header); GC.KeepAlive(txdata); @@ -227,18 +339,20 @@ public class ChannelMonitor : CommonBase { GC.KeepAlive(broadcaster); GC.KeepAlive(fee_estimator); GC.KeepAlive(logger); - int ret_conv_39_len = ret.Length; - TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ[] ret_conv_39_arr = new TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ[ret_conv_39_len]; - for (int n = 0; n < ret_conv_39_len; n++) { - long ret_conv_39 = ret[n]; - TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ ret_conv_39_hu_conv = new TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ(null, ret_conv_39); - if (ret_conv_39_hu_conv != null) { ret_conv_39_hu_conv.ptrs_to.AddLast(this); }; - ret_conv_39_arr[n] = ret_conv_39_hu_conv; + if (ret >= 0 && ret <= 4096) { return null; } + int ret_conv_49_len = InternalUtils.getArrayLength(ret); + 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 = InternalUtils.getU64ArrayElem(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.AddLast(this); }; + ret_conv_49_arr[x] = ret_conv_49_hu_conv; } + bindings.free_buffer(ret); if (this != null) { this.ptrs_to.AddLast(broadcaster); }; if (this != null) { this.ptrs_to.AddLast(fee_estimator); }; if (this != null) { this.ptrs_to.AddLast(logger); }; - return ret_conv_39_arr; + return ret_conv_49_arr; } /** @@ -246,7 +360,7 @@ public class ChannelMonitor : CommonBase { * appropriately. */ 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); + bindings.ChannelMonitor_block_disconnected(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(header, 80)), height, broadcaster.ptr, fee_estimator.ptr, logger.ptr); GC.KeepAlive(this); GC.KeepAlive(header); GC.KeepAlive(height); @@ -267,8 +381,8 @@ public class ChannelMonitor : CommonBase { * * [`block_connected`]: Self::block_connected */ - public TwoTuple_TxidCVec_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 ? InternalUtils.mapArray(txdata, txdata_conv_28 => txdata_conv_28 != null ? txdata_conv_28.ptr : 0) : null, height, broadcaster.ptr, fee_estimator.ptr, logger.ptr); + 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.encodeUint8Array(InternalUtils.check_arr_len(header, 80)), InternalUtils.encodeUint64Array(InternalUtils.mapArray(txdata, txdata_conv_28 => txdata_conv_28 != null ? txdata_conv_28.ptr : 0)), height, broadcaster.ptr, fee_estimator.ptr, logger.ptr); GC.KeepAlive(this); GC.KeepAlive(header); GC.KeepAlive(txdata); @@ -276,18 +390,20 @@ public class ChannelMonitor : CommonBase { GC.KeepAlive(broadcaster); GC.KeepAlive(fee_estimator); GC.KeepAlive(logger); - int ret_conv_39_len = ret.Length; - TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ[] ret_conv_39_arr = new TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ[ret_conv_39_len]; - for (int n = 0; n < ret_conv_39_len; n++) { - long ret_conv_39 = ret[n]; - TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ ret_conv_39_hu_conv = new TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ(null, ret_conv_39); - if (ret_conv_39_hu_conv != null) { ret_conv_39_hu_conv.ptrs_to.AddLast(this); }; - ret_conv_39_arr[n] = ret_conv_39_hu_conv; + if (ret >= 0 && ret <= 4096) { return null; } + int ret_conv_49_len = InternalUtils.getArrayLength(ret); + 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 = InternalUtils.getU64ArrayElem(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.AddLast(this); }; + ret_conv_49_arr[x] = ret_conv_49_hu_conv; } + bindings.free_buffer(ret); if (this != null) { this.ptrs_to.AddLast(broadcaster); }; if (this != null) { this.ptrs_to.AddLast(fee_estimator); }; if (this != null) { this.ptrs_to.AddLast(logger); }; - return ret_conv_39_arr; + return ret_conv_49_arr; } /** @@ -299,7 +415,7 @@ public class ChannelMonitor : CommonBase { * [`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); + bindings.ChannelMonitor_transaction_unconfirmed(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(txid, 32)), broadcaster.ptr, fee_estimator.ptr, logger.ptr); GC.KeepAlive(this); GC.KeepAlive(txid); GC.KeepAlive(broadcaster); @@ -319,43 +435,47 @@ public class ChannelMonitor : CommonBase { * * [`block_connected`]: Self::block_connected */ - public TwoTuple_TxidCVec_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); + 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.encodeUint8Array(InternalUtils.check_arr_len(header, 80)), height, broadcaster.ptr, fee_estimator.ptr, logger.ptr); GC.KeepAlive(this); GC.KeepAlive(header); GC.KeepAlive(height); GC.KeepAlive(broadcaster); GC.KeepAlive(fee_estimator); GC.KeepAlive(logger); - int ret_conv_39_len = ret.Length; - TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ[] ret_conv_39_arr = new TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ[ret_conv_39_len]; - for (int n = 0; n < ret_conv_39_len; n++) { - long ret_conv_39 = ret[n]; - TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ ret_conv_39_hu_conv = new TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ(null, ret_conv_39); - if (ret_conv_39_hu_conv != null) { ret_conv_39_hu_conv.ptrs_to.AddLast(this); }; - ret_conv_39_arr[n] = ret_conv_39_hu_conv; + if (ret >= 0 && ret <= 4096) { return null; } + int ret_conv_49_len = InternalUtils.getArrayLength(ret); + 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 = InternalUtils.getU64ArrayElem(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.AddLast(this); }; + ret_conv_49_arr[x] = ret_conv_49_hu_conv; } + bindings.free_buffer(ret); if (this != null) { this.ptrs_to.AddLast(broadcaster); }; if (this != null) { this.ptrs_to.AddLast(fee_estimator); }; if (this != null) { this.ptrs_to.AddLast(logger); }; - return ret_conv_39_arr; + return ret_conv_49_arr; } /** * Returns the set of txids that should be monitored for re-organization out of the chain. */ - public TwoTuple_TxidCOption_BlockHashZZ[] get_relevant_txids() { - long[] ret = bindings.ChannelMonitor_get_relevant_txids(this.ptr); + public TwoTuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ[] get_relevant_txids() { + long ret = bindings.ChannelMonitor_get_relevant_txids(this.ptr); GC.KeepAlive(this); - int ret_conv_34_len = ret.Length; - TwoTuple_TxidCOption_BlockHashZZ[] ret_conv_34_arr = new TwoTuple_TxidCOption_BlockHashZZ[ret_conv_34_len]; - for (int i = 0; i < ret_conv_34_len; i++) { - long ret_conv_34 = ret[i]; - TwoTuple_TxidCOption_BlockHashZZ ret_conv_34_hu_conv = new TwoTuple_TxidCOption_BlockHashZZ(null, ret_conv_34); - if (ret_conv_34_hu_conv != null) { ret_conv_34_hu_conv.ptrs_to.AddLast(this); }; - ret_conv_34_arr[i] = ret_conv_34_hu_conv; + if (ret >= 0 && ret <= 4096) { return null; } + int ret_conv_49_len = InternalUtils.getArrayLength(ret); + TwoTuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ[] ret_conv_49_arr = new TwoTuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ[ret_conv_49_len]; + for (int x = 0; x < ret_conv_49_len; x++) { + long ret_conv_49 = InternalUtils.getU64ArrayElem(ret, x); + TwoTuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ ret_conv_49_hu_conv = new TwoTuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ(null, ret_conv_49); + if (ret_conv_49_hu_conv != null) { ret_conv_49_hu_conv.ptrs_to.AddLast(this); }; + ret_conv_49_arr[x] = ret_conv_49_hu_conv; } - return ret_conv_34_arr; + bindings.free_buffer(ret); + return ret_conv_49_arr; } /** @@ -389,6 +509,44 @@ public class ChannelMonitor : CommonBase { if (this != null) { this.ptrs_to.AddLast(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, InternalUtils.encodeUint8Array(tx), confirmation_height); + GC.KeepAlive(this); + GC.KeepAlive(tx); + GC.KeepAlive(confirmation_height); + if (ret >= 0 && ret <= 4096) { return null; } + int ret_conv_27_len = InternalUtils.getArrayLength(ret); + 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 = InternalUtils.getU64ArrayElem(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.AddLast(this); }; + ret_conv_27_arr[b] = ret_conv_27_hu_conv; + } + bindings.free_buffer(ret); + 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 @@ -400,23 +558,24 @@ public class ChannelMonitor : CommonBase { * 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, balances may not be fully captured if our counterparty broadcasted - * a revoked state. + * 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); + long ret = bindings.ChannelMonitor_get_claimable_balances(this.ptr); GC.KeepAlive(this); - int ret_conv_9_len = ret.Length; + if (ret >= 0 && ret <= 4096) { return null; } + int ret_conv_9_len = InternalUtils.getArrayLength(ret); 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]; + long ret_conv_9 = InternalUtils.getU64ArrayElem(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.AddLast(this); }; ret_conv_9_arr[j] = ret_conv_9_hu_conv; } + bindings.free_buffer(ret); return ret_conv_9_arr; }