X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;ds=sidebyside;f=c_sharp%2Fsrc%2Forg%2Fldk%2Fstructs%2FConfirm.cs;h=01eae0baaaa3fc9312d2d4f09779b815ef299897;hb=8de7213fbf663ff60322896282dad51e8ab2f001;hp=767eea914fe7f984e29d8fc2ba96ab979788acf0;hpb=afc50e5d491a11364849383b75a8f939df703bac;p=ldk-java diff --git a/c_sharp/src/org/ldk/structs/Confirm.cs b/c_sharp/src/org/ldk/structs/Confirm.cs index 767eea91..01eae0ba 100644 --- a/c_sharp/src/org/ldk/structs/Confirm.cs +++ b/c_sharp/src/org/ldk/structs/Confirm.cs @@ -1,3 +1,4 @@ + using org.ldk.impl; using org.ldk.enums; using org.ldk.util; @@ -5,6 +6,67 @@ using System; namespace org { namespace ldk { namespace structs { + + +/** An implementation of Confirm */ +public interface ConfirmInterface { + /**Notifies LDK of transactions confirmed in a block with a given header and height. + * + * Must be called for any transactions registered by [`Filter::register_tx`] or any + * transactions spending an output registered by [`Filter::register_output`]. Such transactions + * appearing in the same block do not need to be included in the same call; instead, multiple + * calls with additional transactions may be made so long as they are made in [chain order]. + * + * May be called before or after [`best_block_updated`] for the corresponding block. However, + * in the event of a chain reorganization, it must not be called with a `header` that is no + * longer in the chain as of the last call to [`best_block_updated`]. + * + * [chain order]: Confirm#order + * [`best_block_updated`]: Self::best_block_updated + */ + void transactions_confirmed(byte[] header, TwoTuple_usizeTransactionZ[] txdata, int height); + /**Notifies LDK of a transaction that is no longer confirmed as result of a chain reorganization. + * + * Must be called for any transaction returned by [`get_relevant_txids`] if it has been + * reorganized out of the best chain or if it is no longer confirmed in the block with the + * given block hash. Once called, the given transaction will not be returned + * by [`get_relevant_txids`], unless it has been reconfirmed via [`transactions_confirmed`]. + * + * [`get_relevant_txids`]: Self::get_relevant_txids + * [`transactions_confirmed`]: Self::transactions_confirmed + */ + void transaction_unconfirmed(byte[] txid); + /**Notifies LDK of an update to the best header connected at the given height. + * + * Must be called whenever a new chain tip becomes available. May be skipped for intermediary + * blocks. + */ + void best_block_updated(byte[] header, int height); + /**Returns transactions that must be monitored for reorganization out of the chain along + * with the hash of the block as part of which it had been previously confirmed. + * + * Note that the returned `Option` might be `None` for channels created with LDK + * 0.0.112 and prior, in which case you need to manually track previous confirmations. + * + * Will include any transactions passed to [`transactions_confirmed`] that have insufficient + * confirmations to be safe from a chain reorganization. Will not include any transactions + * passed to [`transaction_unconfirmed`], unless later reconfirmed. + * + * Must be called to determine the subset of transactions that must be monitored for + * reorganization. Will be idempotent between calls but may change as a result of calls to the + * other interface methods. Thus, this is useful to determine which transactions must be + * given to [`transaction_unconfirmed`]. + * + * If any of the returned transactions are confirmed in a block other than the one with the + * given hash, they need to be unconfirmed and reconfirmed via [`transaction_unconfirmed`] and + * [`transactions_confirmed`], respectively. + * + * [`transactions_confirmed`]: Self::transactions_confirmed + * [`transaction_unconfirmed`]: Self::transaction_unconfirmed + */ + TwoTuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ[] get_relevant_txids(); +} + /** * The `Confirm` trait is used to notify LDK when relevant transactions have been confirmed on * chain or unconfirmed during a chain reorganization. @@ -44,114 +106,63 @@ namespace org { namespace ldk { namespace structs { * [`get_relevant_txids`]: Self::get_relevant_txids */ public class Confirm : CommonBase { - internal readonly bindings.LDKConfirm bindings_instance; + internal bindings.LDKConfirm bindings_instance; + internal long instance_idx; + internal Confirm(object _dummy, long ptr) : base(ptr) { bindings_instance = null; } - private Confirm(bindings.LDKConfirm arg) : base(bindings.LDKConfirm_new(arg)) { - this.ptrs_to.AddLast(arg); - this.bindings_instance = arg; - } ~Confirm() { if (ptr != 0) { bindings.Confirm_free(ptr); } } - public interface ConfirmInterface { - /** - * Notifies LDK of transactions confirmed in a block with a given header and height. - * - * Must be called for any transactions registered by [`Filter::register_tx`] or any - * transactions spending an output registered by [`Filter::register_output`]. Such transactions - * appearing in the same block do not need to be included in the same call; instead, multiple - * calls with additional transactions may be made so long as they are made in [chain order]. - * - * May be called before or after [`best_block_updated`] for the corresponding block. However, - * in the event of a chain reorganization, it must not be called with a `header` that is no - * longer in the chain as of the last call to [`best_block_updated`]. - * - * [chain order]: Confirm#order - * [`best_block_updated`]: Self::best_block_updated - */ - void transactions_confirmed(byte[] _header, TwoTuple_usizeTransactionZ[] _txdata, int _height); - /** - * Notifies LDK of a transaction that is no longer confirmed as result of a chain reorganization. - * - * Must be called for any transaction returned by [`get_relevant_txids`] if it has been - * reorganized out of the best chain or if it is no longer confirmed in the block with the - * given block hash. Once called, the given transaction will not be returned - * by [`get_relevant_txids`], unless it has been reconfirmed via [`transactions_confirmed`]. - * - * [`get_relevant_txids`]: Self::get_relevant_txids - * [`transactions_confirmed`]: Self::transactions_confirmed - */ - void transaction_unconfirmed(byte[] _txid); - /** - * Notifies LDK of an update to the best header connected at the given height. - * - * Must be called whenever a new chain tip becomes available. May be skipped for intermediary - * blocks. - */ - void best_block_updated(byte[] _header, int _height); - /** - * Returns transactions that must be monitored for reorganization out of the chain along - * with the hash of the block as part of which it had been previously confirmed. - * - * Note that the returned `Option` might be `None` for channels created with LDK - * 0.0.112 and prior, in which case you need to manually track previous confirmations. - * - * Will include any transactions passed to [`transactions_confirmed`] that have insufficient - * confirmations to be safe from a chain reorganization. Will not include any transactions - * passed to [`transaction_unconfirmed`], unless later reconfirmed. - * - * Must be called to determine the subset of transactions that must be monitored for - * reorganization. Will be idempotent between calls but may change as a result of calls to the - * other interface methods. Thus, this is useful to determine which transactions must be - * given to [`transaction_unconfirmed`]. - * - * If any of the returned transactions are confirmed in a block other than the one with the - * given hash, they need to be unconfirmed and reconfirmed via [`transaction_unconfirmed`] and - * [`transactions_confirmed`], respectively. - * - * [`transactions_confirmed`]: Self::transactions_confirmed - * [`transaction_unconfirmed`]: Self::transaction_unconfirmed - */ - TwoTuple_TxidCOption_BlockHashZZ[] get_relevant_txids(); - } private class LDKConfirmHolder { internal Confirm held; } private class LDKConfirmImpl : bindings.LDKConfirm { internal LDKConfirmImpl(ConfirmInterface arg, LDKConfirmHolder impl_holder) { this.arg = arg; this.impl_holder = impl_holder; } private ConfirmInterface arg; private LDKConfirmHolder impl_holder; - public void transactions_confirmed(byte[] _header, long[] _txdata, int _height) { - int _txdata_conv_28_len = _txdata.Length; + public void transactions_confirmed(long _header, long _txdata, int _height) { + byte[] _header_conv = InternalUtils.decodeUint8Array(_header); + int _txdata_conv_28_len = InternalUtils.getArrayLength(_txdata); TwoTuple_usizeTransactionZ[] _txdata_conv_28_arr = new TwoTuple_usizeTransactionZ[_txdata_conv_28_len]; for (int c = 0; c < _txdata_conv_28_len; c++) { - long _txdata_conv_28 = _txdata[c]; + long _txdata_conv_28 = InternalUtils.getU64ArrayElem(_txdata, c); TwoTuple_usizeTransactionZ _txdata_conv_28_hu_conv = new TwoTuple_usizeTransactionZ(null, _txdata_conv_28); if (_txdata_conv_28_hu_conv != null) { _txdata_conv_28_hu_conv.ptrs_to.AddLast(this); }; _txdata_conv_28_arr[c] = _txdata_conv_28_hu_conv; } - arg.transactions_confirmed(_header, _txdata_conv_28_arr, _height); + bindings.free_buffer(_txdata); + arg.transactions_confirmed(_header_conv, _txdata_conv_28_arr, _height); GC.KeepAlive(arg); } - public void transaction_unconfirmed(byte[] _txid) { - arg.transaction_unconfirmed(_txid); + public void transaction_unconfirmed(long _txid) { + byte[] _txid_conv = InternalUtils.decodeUint8Array(_txid); + arg.transaction_unconfirmed(_txid_conv); GC.KeepAlive(arg); } - public void best_block_updated(byte[] _header, int _height) { - arg.best_block_updated(_header, _height); + public void best_block_updated(long _header, int _height) { + byte[] _header_conv = InternalUtils.decodeUint8Array(_header); + arg.best_block_updated(_header_conv, _height); GC.KeepAlive(arg); } - public long[] get_relevant_txids() { - TwoTuple_TxidCOption_BlockHashZZ[] ret = arg.get_relevant_txids(); + public long get_relevant_txids() { + TwoTuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ[] ret = arg.get_relevant_txids(); GC.KeepAlive(arg); - long[] result = ret != null ? InternalUtils.mapArray(ret, ret_conv_34 => ret_conv_34 == null ? 0 : ret_conv_34.clone_ptr()) : null; + long result = InternalUtils.encodeUint64Array(InternalUtils.mapArray(ret, ret_conv_49 => ret_conv_49 == null ? 0 : ret_conv_49.clone_ptr())); return result; } } + + /** Creates a new instance of Confirm from a given implementation */ public static Confirm new_impl(ConfirmInterface arg) { LDKConfirmHolder impl_holder = new LDKConfirmHolder(); - impl_holder.held = new Confirm(new LDKConfirmImpl(arg, impl_holder)); + LDKConfirmImpl impl = new LDKConfirmImpl(arg, impl_holder); + long[] ptr_idx = bindings.LDKConfirm_new(impl); + + impl_holder.held = new Confirm(null, ptr_idx[0]); + impl_holder.held.instance_idx = ptr_idx[1]; + impl_holder.held.bindings_instance = impl; return impl_holder.held; } + /** * Notifies LDK of transactions confirmed in a block with a given header and height. * @@ -168,7 +179,7 @@ public class Confirm : CommonBase { * [`best_block_updated`]: Self::best_block_updated */ public void transactions_confirmed(byte[] header, TwoTuple_usizeTransactionZ[] txdata, int height) { - bindings.Confirm_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); + bindings.Confirm_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); GC.KeepAlive(this); GC.KeepAlive(header); GC.KeepAlive(txdata); @@ -187,7 +198,7 @@ public class Confirm : CommonBase { * [`transactions_confirmed`]: Self::transactions_confirmed */ public void transaction_unconfirmed(byte[] txid) { - bindings.Confirm_transaction_unconfirmed(this.ptr, InternalUtils.check_arr_len(txid, 32)); + bindings.Confirm_transaction_unconfirmed(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(txid, 32))); GC.KeepAlive(this); GC.KeepAlive(txid); } @@ -199,7 +210,7 @@ public class Confirm : CommonBase { * blocks. */ public void best_block_updated(byte[] header, int height) { - bindings.Confirm_best_block_updated(this.ptr, InternalUtils.check_arr_len(header, 80), height); + bindings.Confirm_best_block_updated(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(header, 80)), height); GC.KeepAlive(this); GC.KeepAlive(header); GC.KeepAlive(height); @@ -228,18 +239,20 @@ public class Confirm : CommonBase { * [`transactions_confirmed`]: Self::transactions_confirmed * [`transaction_unconfirmed`]: Self::transaction_unconfirmed */ - public TwoTuple_TxidCOption_BlockHashZZ[] get_relevant_txids() { - long[] ret = bindings.Confirm_get_relevant_txids(this.ptr); + public TwoTuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ[] get_relevant_txids() { + long ret = bindings.Confirm_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; } }