+ static { LDKBumpTransactionEvent.init(); }
+ public static native LDKBumpTransactionEvent LDKBumpTransactionEvent_ref_from_ptr(long ptr);
+ public static class LDKEvent {
+ private LDKEvent() {}
+ public final static class FundingGenerationReady extends LDKEvent {
+ public byte[] temporary_channel_id;
+ public byte[] counterparty_node_id;
+ public long channel_value_satoshis;
+ public byte[] output_script;
+ public byte[] user_channel_id;
+ FundingGenerationReady(byte[] temporary_channel_id, byte[] counterparty_node_id, long channel_value_satoshis, byte[] output_script, byte[] user_channel_id) { this.temporary_channel_id = temporary_channel_id; this.counterparty_node_id = counterparty_node_id; this.channel_value_satoshis = channel_value_satoshis; this.output_script = output_script; this.user_channel_id = user_channel_id; }
+ }
+ public final static class PaymentClaimable extends LDKEvent {
+ public byte[] receiver_node_id;
+ public byte[] payment_hash;
+ public long onion_fields;
+ public long amount_msat;
+ public long counterparty_skimmed_fee_msat;
+ public long purpose;
+ public long via_channel_id;
+ public long via_user_channel_id;
+ public long claim_deadline;
+ PaymentClaimable(byte[] receiver_node_id, byte[] payment_hash, long onion_fields, long amount_msat, long counterparty_skimmed_fee_msat, long purpose, long via_channel_id, long via_user_channel_id, long claim_deadline) { this.receiver_node_id = receiver_node_id; this.payment_hash = payment_hash; this.onion_fields = onion_fields; this.amount_msat = amount_msat; this.counterparty_skimmed_fee_msat = counterparty_skimmed_fee_msat; this.purpose = purpose; this.via_channel_id = via_channel_id; this.via_user_channel_id = via_user_channel_id; this.claim_deadline = claim_deadline; }
+ }
+ public final static class PaymentClaimed extends LDKEvent {
+ public byte[] receiver_node_id;
+ public byte[] payment_hash;
+ public long amount_msat;
+ public long purpose;
+ public long[] htlcs;
+ public long sender_intended_total_msat;
+ PaymentClaimed(byte[] receiver_node_id, byte[] payment_hash, long amount_msat, long purpose, long[] htlcs, long sender_intended_total_msat) { this.receiver_node_id = receiver_node_id; this.payment_hash = payment_hash; this.amount_msat = amount_msat; this.purpose = purpose; this.htlcs = htlcs; this.sender_intended_total_msat = sender_intended_total_msat; }
+ }
+ public final static class ConnectionNeeded extends LDKEvent {
+ public byte[] node_id;
+ public long[] addresses;
+ ConnectionNeeded(byte[] node_id, long[] addresses) { this.node_id = node_id; this.addresses = addresses; }
+ }
+ public final static class InvoiceRequestFailed extends LDKEvent {
+ public byte[] payment_id;
+ InvoiceRequestFailed(byte[] payment_id) { this.payment_id = payment_id; }
+ }
+ public final static class PaymentSent extends LDKEvent {
+ public long payment_id;
+ public byte[] payment_preimage;
+ public byte[] payment_hash;
+ public long fee_paid_msat;
+ PaymentSent(long payment_id, byte[] payment_preimage, byte[] payment_hash, long fee_paid_msat) { this.payment_id = payment_id; this.payment_preimage = payment_preimage; this.payment_hash = payment_hash; this.fee_paid_msat = fee_paid_msat; }
+ }
+ public final static class PaymentFailed extends LDKEvent {
+ public byte[] payment_id;
+ public byte[] payment_hash;
+ public long reason;
+ PaymentFailed(byte[] payment_id, byte[] payment_hash, long reason) { this.payment_id = payment_id; this.payment_hash = payment_hash; this.reason = reason; }
+ }
+ public final static class PaymentPathSuccessful extends LDKEvent {
+ public byte[] payment_id;
+ public long payment_hash;
+ public long path;
+ PaymentPathSuccessful(byte[] payment_id, long payment_hash, long path) { this.payment_id = payment_id; this.payment_hash = payment_hash; this.path = path; }
+ }
+ public final static class PaymentPathFailed extends LDKEvent {
+ public long payment_id;
+ public byte[] payment_hash;
+ public boolean payment_failed_permanently;
+ public long failure;
+ public long path;
+ public long short_channel_id;
+ PaymentPathFailed(long payment_id, byte[] payment_hash, boolean payment_failed_permanently, long failure, long path, long short_channel_id) { this.payment_id = payment_id; this.payment_hash = payment_hash; this.payment_failed_permanently = payment_failed_permanently; this.failure = failure; this.path = path; this.short_channel_id = short_channel_id; }
+ }
+ public final static class ProbeSuccessful extends LDKEvent {
+ public byte[] payment_id;
+ public byte[] payment_hash;
+ public long path;
+ ProbeSuccessful(byte[] payment_id, byte[] payment_hash, long path) { this.payment_id = payment_id; this.payment_hash = payment_hash; this.path = path; }
+ }
+ public final static class ProbeFailed extends LDKEvent {
+ public byte[] payment_id;
+ public byte[] payment_hash;
+ public long path;
+ public long short_channel_id;
+ ProbeFailed(byte[] payment_id, byte[] payment_hash, long path, long short_channel_id) { this.payment_id = payment_id; this.payment_hash = payment_hash; this.path = path; this.short_channel_id = short_channel_id; }
+ }
+ public final static class PendingHTLCsForwardable extends LDKEvent {
+ public long time_forwardable;
+ PendingHTLCsForwardable(long time_forwardable) { this.time_forwardable = time_forwardable; }
+ }
+ public final static class HTLCIntercepted extends LDKEvent {
+ public byte[] intercept_id;
+ public long requested_next_hop_scid;
+ public byte[] payment_hash;
+ public long inbound_amount_msat;
+ public long expected_outbound_amount_msat;
+ HTLCIntercepted(byte[] intercept_id, long requested_next_hop_scid, byte[] payment_hash, long inbound_amount_msat, long expected_outbound_amount_msat) { this.intercept_id = intercept_id; this.requested_next_hop_scid = requested_next_hop_scid; this.payment_hash = payment_hash; this.inbound_amount_msat = inbound_amount_msat; this.expected_outbound_amount_msat = expected_outbound_amount_msat; }
+ }
+ public final static class SpendableOutputs extends LDKEvent {
+ public long[] outputs;
+ public long channel_id;
+ SpendableOutputs(long[] outputs, long channel_id) { this.outputs = outputs; this.channel_id = channel_id; }
+ }
+ public final static class PaymentForwarded extends LDKEvent {
+ public long prev_channel_id;
+ public long next_channel_id;
+ public long fee_earned_msat;
+ public boolean claim_from_onchain_tx;
+ public long outbound_amount_forwarded_msat;
+ PaymentForwarded(long prev_channel_id, long next_channel_id, long fee_earned_msat, boolean claim_from_onchain_tx, long outbound_amount_forwarded_msat) { this.prev_channel_id = prev_channel_id; this.next_channel_id = next_channel_id; this.fee_earned_msat = fee_earned_msat; this.claim_from_onchain_tx = claim_from_onchain_tx; this.outbound_amount_forwarded_msat = outbound_amount_forwarded_msat; }
+ }
+ public final static class ChannelPending extends LDKEvent {
+ public byte[] channel_id;
+ public byte[] user_channel_id;
+ public long former_temporary_channel_id;
+ public byte[] counterparty_node_id;
+ public long funding_txo;
+ ChannelPending(byte[] channel_id, byte[] user_channel_id, long former_temporary_channel_id, byte[] counterparty_node_id, long funding_txo) { this.channel_id = channel_id; this.user_channel_id = user_channel_id; this.former_temporary_channel_id = former_temporary_channel_id; this.counterparty_node_id = counterparty_node_id; this.funding_txo = funding_txo; }
+ }
+ public final static class ChannelReady extends LDKEvent {
+ public byte[] channel_id;
+ public byte[] user_channel_id;
+ public byte[] counterparty_node_id;
+ public long channel_type;
+ ChannelReady(byte[] channel_id, byte[] user_channel_id, byte[] counterparty_node_id, long channel_type) { this.channel_id = channel_id; this.user_channel_id = user_channel_id; this.counterparty_node_id = counterparty_node_id; this.channel_type = channel_type; }
+ }
+ public final static class ChannelClosed extends LDKEvent {
+ public byte[] channel_id;
+ public byte[] user_channel_id;
+ public long reason;
+ public byte[] counterparty_node_id;
+ public long channel_capacity_sats;
+ public long channel_funding_txo;
+ ChannelClosed(byte[] channel_id, byte[] user_channel_id, long reason, byte[] counterparty_node_id, long channel_capacity_sats, long channel_funding_txo) { this.channel_id = channel_id; this.user_channel_id = user_channel_id; this.reason = reason; this.counterparty_node_id = counterparty_node_id; this.channel_capacity_sats = channel_capacity_sats; this.channel_funding_txo = channel_funding_txo; }
+ }
+ public final static class DiscardFunding extends LDKEvent {
+ public byte[] channel_id;
+ public byte[] transaction;
+ DiscardFunding(byte[] channel_id, byte[] transaction) { this.channel_id = channel_id; this.transaction = transaction; }
+ }
+ public final static class OpenChannelRequest extends LDKEvent {
+ public byte[] temporary_channel_id;
+ public byte[] counterparty_node_id;
+ public long funding_satoshis;
+ public long push_msat;
+ public long channel_type;
+ OpenChannelRequest(byte[] temporary_channel_id, byte[] counterparty_node_id, long funding_satoshis, long push_msat, long channel_type) { this.temporary_channel_id = temporary_channel_id; this.counterparty_node_id = counterparty_node_id; this.funding_satoshis = funding_satoshis; this.push_msat = push_msat; this.channel_type = channel_type; }
+ }
+ public final static class HTLCHandlingFailed extends LDKEvent {
+ public byte[] prev_channel_id;
+ public long failed_next_destination;
+ HTLCHandlingFailed(byte[] prev_channel_id, long failed_next_destination) { this.prev_channel_id = prev_channel_id; this.failed_next_destination = failed_next_destination; }
+ }
+ public final static class BumpTransaction extends LDKEvent {
+ public long bump_transaction;
+ BumpTransaction(long bump_transaction) { this.bump_transaction = bump_transaction; }
+ }
+ static native void init();
+ }
+ static { LDKEvent.init(); }
+ public static native LDKEvent LDKEvent_ref_from_ptr(long ptr);
+ public static class LDKCOption_EventZ {
+ private LDKCOption_EventZ() {}
+ public final static class Some extends LDKCOption_EventZ {
+ public long some;
+ Some(long some) { this.some = some; }
+ }
+ public final static class None extends LDKCOption_EventZ {
+ None() { }
+ }
+ static native void init();
+ }
+ static { LDKCOption_EventZ.init(); }
+ public static native LDKCOption_EventZ LDKCOption_EventZ_ref_from_ptr(long ptr);
+ // struct LDKCOption_EventZ CResult_COption_EventZDecodeErrorZ_get_ok(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_COption_EventZDecodeErrorZ_get_ok(long owner);
+ // struct LDKDecodeError CResult_COption_EventZDecodeErrorZ_get_err(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_COption_EventZDecodeErrorZ_get_err(long owner);
+ public static class LDKBolt11ParseError {
+ private LDKBolt11ParseError() {}
+ public final static class Bech32Error extends LDKBolt11ParseError {
+ public long bech32_error;
+ Bech32Error(long bech32_error) { this.bech32_error = bech32_error; }
+ }
+ public final static class ParseAmountError extends LDKBolt11ParseError {
+ public int parse_amount_error;
+ ParseAmountError(int parse_amount_error) { this.parse_amount_error = parse_amount_error; }
+ }
+ public final static class MalformedSignature extends LDKBolt11ParseError {
+ public org.ldk.enums.Secp256k1Error malformed_signature;
+ MalformedSignature(org.ldk.enums.Secp256k1Error malformed_signature) { this.malformed_signature = malformed_signature; }
+ }
+ public final static class BadPrefix extends LDKBolt11ParseError {
+ BadPrefix() { }
+ }
+ public final static class UnknownCurrency extends LDKBolt11ParseError {
+ UnknownCurrency() { }
+ }
+ public final static class UnknownSiPrefix extends LDKBolt11ParseError {
+ UnknownSiPrefix() { }
+ }
+ public final static class MalformedHRP extends LDKBolt11ParseError {
+ MalformedHRP() { }
+ }
+ public final static class TooShortDataPart extends LDKBolt11ParseError {
+ TooShortDataPart() { }
+ }
+ public final static class UnexpectedEndOfTaggedFields extends LDKBolt11ParseError {
+ UnexpectedEndOfTaggedFields() { }
+ }
+ public final static class DescriptionDecodeError extends LDKBolt11ParseError {
+ public int description_decode_error;
+ DescriptionDecodeError(int description_decode_error) { this.description_decode_error = description_decode_error; }
+ }
+ public final static class PaddingError extends LDKBolt11ParseError {
+ PaddingError() { }
+ }
+ public final static class IntegerOverflowError extends LDKBolt11ParseError {
+ IntegerOverflowError() { }
+ }
+ public final static class InvalidSegWitProgramLength extends LDKBolt11ParseError {
+ InvalidSegWitProgramLength() { }
+ }
+ public final static class InvalidPubKeyHashLength extends LDKBolt11ParseError {
+ InvalidPubKeyHashLength() { }
+ }
+ public final static class InvalidScriptHashLength extends LDKBolt11ParseError {
+ InvalidScriptHashLength() { }
+ }
+ public final static class InvalidRecoveryId extends LDKBolt11ParseError {
+ InvalidRecoveryId() { }
+ }
+ public final static class InvalidSliceLength extends LDKBolt11ParseError {
+ public java.lang.String invalid_slice_length;
+ InvalidSliceLength(java.lang.String invalid_slice_length) { this.invalid_slice_length = invalid_slice_length; }
+ }
+ public final static class Skip extends LDKBolt11ParseError {
+ Skip() { }
+ }
+ static native void init();
+ }
+ static { LDKBolt11ParseError.init(); }
+ public static native LDKBolt11ParseError LDKBolt11ParseError_ref_from_ptr(long ptr);
+ // enum LDKSiPrefix CResult_SiPrefixBolt11ParseErrorZ_get_ok(LDKCResult_SiPrefixBolt11ParseErrorZ *NONNULL_PTR owner);
+ public static native SiPrefix CResult_SiPrefixBolt11ParseErrorZ_get_ok(long owner);
+ // struct LDKBolt11ParseError CResult_SiPrefixBolt11ParseErrorZ_get_err(LDKCResult_SiPrefixBolt11ParseErrorZ *NONNULL_PTR owner);
+ public static native long CResult_SiPrefixBolt11ParseErrorZ_get_err(long owner);
+ public static class LDKParseOrSemanticError {
+ private LDKParseOrSemanticError() {}
+ public final static class ParseError extends LDKParseOrSemanticError {
+ public long parse_error;
+ ParseError(long parse_error) { this.parse_error = parse_error; }
+ }
+ public final static class SemanticError extends LDKParseOrSemanticError {
+ public org.ldk.enums.Bolt11SemanticError semantic_error;
+ SemanticError(org.ldk.enums.Bolt11SemanticError semantic_error) { this.semantic_error = semantic_error; }
+ }
+ static native void init();
+ }
+ static { LDKParseOrSemanticError.init(); }
+ public static native LDKParseOrSemanticError LDKParseOrSemanticError_ref_from_ptr(long ptr);
+ // struct LDKBolt11Invoice CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_ok(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
+ public static native long CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_ok(long owner);
+ // struct LDKParseOrSemanticError CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_err(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
+ public static native long CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_err(long owner);
+ // struct LDKSignedRawBolt11Invoice CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_ok(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ *NONNULL_PTR owner);
+ public static native long CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_ok(long owner);
+ // struct LDKBolt11ParseError CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_err(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ *NONNULL_PTR owner);
+ public static native long CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_err(long owner);
+ // struct LDKRawBolt11Invoice C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_a(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ *NONNULL_PTR owner);
+ public static native long C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_a(long owner);
+ // struct LDKThirtyTwoBytes C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_b(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ *NONNULL_PTR owner);
+ public static native byte[] C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_b(long owner);
+ // struct LDKBolt11InvoiceSignature C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_c(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ *NONNULL_PTR owner);
+ public static native long C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_c(long owner);
+ // struct LDKPayeePubKey CResult_PayeePubKeySecp256k1ErrorZ_get_ok(LDKCResult_PayeePubKeySecp256k1ErrorZ *NONNULL_PTR owner);
+ public static native long CResult_PayeePubKeySecp256k1ErrorZ_get_ok(long owner);
+ // enum LDKSecp256k1Error CResult_PayeePubKeySecp256k1ErrorZ_get_err(LDKCResult_PayeePubKeySecp256k1ErrorZ *NONNULL_PTR owner);
+ public static native Secp256k1Error CResult_PayeePubKeySecp256k1ErrorZ_get_err(long owner);
+ // struct LDKPositiveTimestamp CResult_PositiveTimestampCreationErrorZ_get_ok(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
+ public static native long CResult_PositiveTimestampCreationErrorZ_get_ok(long owner);
+ // enum LDKCreationError CResult_PositiveTimestampCreationErrorZ_get_err(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
+ public static native CreationError CResult_PositiveTimestampCreationErrorZ_get_err(long owner);
+ // void CResult_NoneBolt11SemanticErrorZ_get_ok(LDKCResult_NoneBolt11SemanticErrorZ *NONNULL_PTR owner);
+ public static native void CResult_NoneBolt11SemanticErrorZ_get_ok(long owner);
+ // enum LDKBolt11SemanticError CResult_NoneBolt11SemanticErrorZ_get_err(LDKCResult_NoneBolt11SemanticErrorZ *NONNULL_PTR owner);
+ public static native Bolt11SemanticError CResult_NoneBolt11SemanticErrorZ_get_err(long owner);
+ // struct LDKBolt11Invoice CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_ok(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ *NONNULL_PTR owner);
+ public static native long CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_ok(long owner);
+ // enum LDKBolt11SemanticError CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_err(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ *NONNULL_PTR owner);
+ public static native Bolt11SemanticError CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_err(long owner);
+ // struct LDKDescription CResult_DescriptionCreationErrorZ_get_ok(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
+ public static native long CResult_DescriptionCreationErrorZ_get_ok(long owner);
+ // enum LDKCreationError CResult_DescriptionCreationErrorZ_get_err(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
+ public static native CreationError CResult_DescriptionCreationErrorZ_get_err(long owner);
+ // struct LDKPrivateRoute CResult_PrivateRouteCreationErrorZ_get_ok(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
+ public static native long CResult_PrivateRouteCreationErrorZ_get_ok(long owner);
+ // enum LDKCreationError CResult_PrivateRouteCreationErrorZ_get_err(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
+ public static native CreationError CResult_PrivateRouteCreationErrorZ_get_err(long owner);
+ // struct LDKOutPoint CResult_OutPointDecodeErrorZ_get_ok(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_OutPointDecodeErrorZ_get_ok(long owner);
+ // struct LDKDecodeError CResult_OutPointDecodeErrorZ_get_err(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_OutPointDecodeErrorZ_get_err(long owner);
+ // struct LDKBigSize CResult_BigSizeDecodeErrorZ_get_ok(LDKCResult_BigSizeDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_BigSizeDecodeErrorZ_get_ok(long owner);
+ // struct LDKDecodeError CResult_BigSizeDecodeErrorZ_get_err(LDKCResult_BigSizeDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_BigSizeDecodeErrorZ_get_err(long owner);
+ // struct LDKHostname CResult_HostnameDecodeErrorZ_get_ok(LDKCResult_HostnameDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_HostnameDecodeErrorZ_get_ok(long owner);
+ // struct LDKDecodeError CResult_HostnameDecodeErrorZ_get_err(LDKCResult_HostnameDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_HostnameDecodeErrorZ_get_err(long owner);
+ // struct LDKTransactionU16LenLimited CResult_TransactionU16LenLimitedNoneZ_get_ok(LDKCResult_TransactionU16LenLimitedNoneZ *NONNULL_PTR owner);
+ public static native long CResult_TransactionU16LenLimitedNoneZ_get_ok(long owner);
+ // void CResult_TransactionU16LenLimitedNoneZ_get_err(LDKCResult_TransactionU16LenLimitedNoneZ *NONNULL_PTR owner);
+ public static native void CResult_TransactionU16LenLimitedNoneZ_get_err(long owner);
+ // struct LDKTransactionU16LenLimited CResult_TransactionU16LenLimitedDecodeErrorZ_get_ok(LDKCResult_TransactionU16LenLimitedDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_TransactionU16LenLimitedDecodeErrorZ_get_ok(long owner);
+ // struct LDKDecodeError CResult_TransactionU16LenLimitedDecodeErrorZ_get_err(LDKCResult_TransactionU16LenLimitedDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_TransactionU16LenLimitedDecodeErrorZ_get_err(long owner);
+ // struct LDKUntrustedString CResult_UntrustedStringDecodeErrorZ_get_ok(LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_UntrustedStringDecodeErrorZ_get_ok(long owner);
+ // struct LDKDecodeError CResult_UntrustedStringDecodeErrorZ_get_err(LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_UntrustedStringDecodeErrorZ_get_err(long owner);
+ // struct LDKThirtyTwoBytes C2Tuple__u832u16Z_get_a(LDKC2Tuple__u832u16Z *NONNULL_PTR owner);
+ public static native byte[] C2Tuple__u832u16Z_get_a(long owner);
+ // uint16_t C2Tuple__u832u16Z_get_b(LDKC2Tuple__u832u16Z *NONNULL_PTR owner);
+ public static native short C2Tuple__u832u16Z_get_b(long owner);
+ // struct LDKPaymentRelay CResult_PaymentRelayDecodeErrorZ_get_ok(LDKCResult_PaymentRelayDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_PaymentRelayDecodeErrorZ_get_ok(long owner);
+ // struct LDKDecodeError CResult_PaymentRelayDecodeErrorZ_get_err(LDKCResult_PaymentRelayDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_PaymentRelayDecodeErrorZ_get_err(long owner);
+ // struct LDKPaymentConstraints CResult_PaymentConstraintsDecodeErrorZ_get_ok(LDKCResult_PaymentConstraintsDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_PaymentConstraintsDecodeErrorZ_get_ok(long owner);
+ // struct LDKDecodeError CResult_PaymentConstraintsDecodeErrorZ_get_err(LDKCResult_PaymentConstraintsDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_PaymentConstraintsDecodeErrorZ_get_err(long owner);
+ // struct LDKThirtyTwoBytes C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_get_a(LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ *NONNULL_PTR owner);
+ public static native byte[] C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_get_a(long owner);
+ // struct LDKRecipientOnionFields C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_get_b(LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ *NONNULL_PTR owner);
+ public static native long C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_get_b(long owner);
+ // struct LDKRouteParameters C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_get_c(LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ *NONNULL_PTR owner);
+ public static native long C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_get_c(long owner);
+ // struct LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_get_ok(LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ *NONNULL_PTR owner);
+ public static native long CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_get_ok(long owner);
+ // void CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_get_err(LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ *NONNULL_PTR owner);
+ public static native void CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_get_err(long owner);
+ // struct LDKStr CResult_StrSecp256k1ErrorZ_get_ok(LDKCResult_StrSecp256k1ErrorZ *NONNULL_PTR owner);
+ public static native String CResult_StrSecp256k1ErrorZ_get_ok(long owner);
+ // enum LDKSecp256k1Error CResult_StrSecp256k1ErrorZ_get_err(LDKCResult_StrSecp256k1ErrorZ *NONNULL_PTR owner);
+ public static native Secp256k1Error CResult_StrSecp256k1ErrorZ_get_err(long owner);
+ // struct LDKPublicKey C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_get_a(LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ *NONNULL_PTR owner);
+ public static native byte[] C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_get_a(long owner);
+ // struct LDKOnionMessage C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_get_b(LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ *NONNULL_PTR owner);
+ public static native long C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_get_b(long owner);
+ // struct LDKCOption_CVec_SocketAddressZZ C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_get_c(LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ *NONNULL_PTR owner);
+ public static native long C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_get_c(long owner);
+ public static class LDKSendError {
+ private LDKSendError() {}
+ public final static class Secp256k1 extends LDKSendError {
+ public org.ldk.enums.Secp256k1Error secp256k1;
+ Secp256k1(org.ldk.enums.Secp256k1Error secp256k1) { this.secp256k1 = secp256k1; }
+ }
+ public final static class TooBigPacket extends LDKSendError {
+ TooBigPacket() { }
+ }
+ public final static class TooFewBlindedHops extends LDKSendError {
+ TooFewBlindedHops() { }
+ }
+ public final static class InvalidFirstHop extends LDKSendError {
+ public byte[] invalid_first_hop;
+ InvalidFirstHop(byte[] invalid_first_hop) { this.invalid_first_hop = invalid_first_hop; }
+ }
+ public final static class PathNotFound extends LDKSendError {
+ PathNotFound() { }
+ }
+ public final static class InvalidMessage extends LDKSendError {
+ InvalidMessage() { }
+ }
+ public final static class BufferFull extends LDKSendError {
+ BufferFull() { }
+ }
+ public final static class GetNodeIdFailed extends LDKSendError {
+ GetNodeIdFailed() { }
+ }
+ public final static class BlindedPathAdvanceFailed extends LDKSendError {
+ BlindedPathAdvanceFailed() { }
+ }
+ static native void init();
+ }
+ static { LDKSendError.init(); }
+ public static native LDKSendError LDKSendError_ref_from_ptr(long ptr);
+ // struct LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_get_ok(LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ *NONNULL_PTR owner);
+ public static native long CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_get_ok(long owner);
+ // struct LDKSendError CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_get_err(LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ *NONNULL_PTR owner);
+ public static native long CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_get_err(long owner);
+ public static class LDKParsedOnionMessageContents {
+ private LDKParsedOnionMessageContents() {}
+ public final static class Offers extends LDKParsedOnionMessageContents {
+ public long offers;
+ Offers(long offers) { this.offers = offers; }
+ }
+ public final static class Custom extends LDKParsedOnionMessageContents {
+ public long custom;
+ Custom(long custom) { this.custom = custom; }
+ }
+ static native void init();
+ }
+ static { LDKParsedOnionMessageContents.init(); }
+ public static native LDKParsedOnionMessageContents LDKParsedOnionMessageContents_ref_from_ptr(long ptr);
+ public static class LDKPeeledOnion {
+ private LDKPeeledOnion() {}
+ public final static class Forward extends LDKPeeledOnion {
+ public byte[] _0;
+ public long _1;
+ Forward(byte[] _0, long _1) { this._0 = _0; this._1 = _1; }
+ }
+ public final static class Receive extends LDKPeeledOnion {
+ public long _0;
+ public byte[] _1;
+ public long _2;
+ Receive(long _0, byte[] _1, long _2) { this._0 = _0; this._1 = _1; this._2 = _2; }
+ }
+ static native void init();
+ }
+ static { LDKPeeledOnion.init(); }
+ public static native LDKPeeledOnion LDKPeeledOnion_ref_from_ptr(long ptr);
+ // struct LDKPeeledOnion CResult_PeeledOnionNoneZ_get_ok(LDKCResult_PeeledOnionNoneZ *NONNULL_PTR owner);
+ public static native long CResult_PeeledOnionNoneZ_get_ok(long owner);
+ // void CResult_PeeledOnionNoneZ_get_err(LDKCResult_PeeledOnionNoneZ *NONNULL_PTR owner);
+ public static native void CResult_PeeledOnionNoneZ_get_err(long owner);
+ public static class LDKSendSuccess {
+ private LDKSendSuccess() {}
+ public final static class Buffered extends LDKSendSuccess {
+ Buffered() { }
+ }
+ public final static class BufferedAwaitingConnection extends LDKSendSuccess {
+ public byte[] buffered_awaiting_connection;
+ BufferedAwaitingConnection(byte[] buffered_awaiting_connection) { this.buffered_awaiting_connection = buffered_awaiting_connection; }
+ }
+ static native void init();
+ }
+ static { LDKSendSuccess.init(); }
+ public static native LDKSendSuccess LDKSendSuccess_ref_from_ptr(long ptr);
+ // struct LDKSendSuccess CResult_SendSuccessSendErrorZ_get_ok(LDKCResult_SendSuccessSendErrorZ *NONNULL_PTR owner);
+ public static native long CResult_SendSuccessSendErrorZ_get_ok(long owner);
+ // struct LDKSendError CResult_SendSuccessSendErrorZ_get_err(LDKCResult_SendSuccessSendErrorZ *NONNULL_PTR owner);
+ public static native long CResult_SendSuccessSendErrorZ_get_err(long owner);
+ // struct LDKBlindedPath CResult_BlindedPathNoneZ_get_ok(LDKCResult_BlindedPathNoneZ *NONNULL_PTR owner);
+ public static native long CResult_BlindedPathNoneZ_get_ok(long owner);
+ // void CResult_BlindedPathNoneZ_get_err(LDKCResult_BlindedPathNoneZ *NONNULL_PTR owner);
+ public static native void CResult_BlindedPathNoneZ_get_err(long owner);
+ // struct LDKC2Tuple_BlindedPayInfoBlindedPathZ CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_ok(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ *NONNULL_PTR owner);
+ public static native long CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_ok(long owner);
+ // void CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_err(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ *NONNULL_PTR owner);
+ public static native void CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_err(long owner);
+ // struct LDKBlindedPath CResult_BlindedPathDecodeErrorZ_get_ok(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_BlindedPathDecodeErrorZ_get_ok(long owner);
+ // struct LDKDecodeError CResult_BlindedPathDecodeErrorZ_get_err(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_BlindedPathDecodeErrorZ_get_err(long owner);
+ // struct LDKBlindedHop CResult_BlindedHopDecodeErrorZ_get_ok(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_BlindedHopDecodeErrorZ_get_ok(long owner);
+ // struct LDKDecodeError CResult_BlindedHopDecodeErrorZ_get_err(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_BlindedHopDecodeErrorZ_get_err(long owner);
+ // struct LDKInvoiceError CResult_InvoiceErrorDecodeErrorZ_get_ok(LDKCResult_InvoiceErrorDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_InvoiceErrorDecodeErrorZ_get_ok(long owner);
+ // struct LDKDecodeError CResult_InvoiceErrorDecodeErrorZ_get_err(LDKCResult_InvoiceErrorDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_InvoiceErrorDecodeErrorZ_get_err(long owner);
+ // struct LDKDelayedPaymentBasepoint CResult_DelayedPaymentBasepointDecodeErrorZ_get_ok(LDKCResult_DelayedPaymentBasepointDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_DelayedPaymentBasepointDecodeErrorZ_get_ok(long owner);
+ // struct LDKDecodeError CResult_DelayedPaymentBasepointDecodeErrorZ_get_err(LDKCResult_DelayedPaymentBasepointDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_DelayedPaymentBasepointDecodeErrorZ_get_err(long owner);
+ // struct LDKDelayedPaymentKey CResult_DelayedPaymentKeyDecodeErrorZ_get_ok(LDKCResult_DelayedPaymentKeyDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_DelayedPaymentKeyDecodeErrorZ_get_ok(long owner);
+ // struct LDKDecodeError CResult_DelayedPaymentKeyDecodeErrorZ_get_err(LDKCResult_DelayedPaymentKeyDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_DelayedPaymentKeyDecodeErrorZ_get_err(long owner);
+ // struct LDKHtlcBasepoint CResult_HtlcBasepointDecodeErrorZ_get_ok(LDKCResult_HtlcBasepointDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_HtlcBasepointDecodeErrorZ_get_ok(long owner);
+ // struct LDKDecodeError CResult_HtlcBasepointDecodeErrorZ_get_err(LDKCResult_HtlcBasepointDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_HtlcBasepointDecodeErrorZ_get_err(long owner);
+ // struct LDKHtlcKey CResult_HtlcKeyDecodeErrorZ_get_ok(LDKCResult_HtlcKeyDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_HtlcKeyDecodeErrorZ_get_ok(long owner);
+ // struct LDKDecodeError CResult_HtlcKeyDecodeErrorZ_get_err(LDKCResult_HtlcKeyDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_HtlcKeyDecodeErrorZ_get_err(long owner);
+ // struct LDKRevocationBasepoint CResult_RevocationBasepointDecodeErrorZ_get_ok(LDKCResult_RevocationBasepointDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_RevocationBasepointDecodeErrorZ_get_ok(long owner);
+ // struct LDKDecodeError CResult_RevocationBasepointDecodeErrorZ_get_err(LDKCResult_RevocationBasepointDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_RevocationBasepointDecodeErrorZ_get_err(long owner);
+ // struct LDKRevocationKey CResult_RevocationKeyDecodeErrorZ_get_ok(LDKCResult_RevocationKeyDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_RevocationKeyDecodeErrorZ_get_ok(long owner);
+ // struct LDKDecodeError CResult_RevocationKeyDecodeErrorZ_get_err(LDKCResult_RevocationKeyDecodeErrorZ *NONNULL_PTR owner);
+ public static native long CResult_RevocationKeyDecodeErrorZ_get_err(long owner);
+ public interface LDKFilter {
+ void register_tx(byte[] txid, byte[] script_pubkey);
+ void register_output(long output);
+ }
+ public static native long LDKFilter_new(LDKFilter impl);
+ // void Filter_register_tx LDKFilter *NONNULL_PTR this_arg, const uint8_t (*txid)[32], struct LDKu8slice script_pubkey
+ public static native void Filter_register_tx(long this_arg, byte[] txid, byte[] script_pubkey);
+ // void Filter_register_output LDKFilter *NONNULL_PTR this_arg, struct LDKWatchedOutput output
+ public static native void Filter_register_output(long this_arg, long output);
+ public static class LDKCOption_FilterZ {
+ private LDKCOption_FilterZ() {}
+ public final static class Some extends LDKCOption_FilterZ {
+ public long some;
+ Some(long some) { this.some = some; }
+ }
+ public final static class None extends LDKCOption_FilterZ {
+ None() { }
+ }
+ static native void init();
+ }
+ static { LDKCOption_FilterZ.init(); }
+ public static native LDKCOption_FilterZ LDKCOption_FilterZ_ref_from_ptr(long ptr);
+ // struct LDKLockedChannelMonitor CResult_LockedChannelMonitorNoneZ_get_ok(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
+ public static native long CResult_LockedChannelMonitorNoneZ_get_ok(long owner);
+ // void CResult_LockedChannelMonitorNoneZ_get_err(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
+ public static native void CResult_LockedChannelMonitorNoneZ_get_err(long owner);
+ // struct LDKOutPoint C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR owner);
+ public static native long C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(long owner);
+ // struct LDKCVec_MonitorUpdateIdZ C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR owner);
+ public static native long[] C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(long owner);
+ public interface LDKKVStore {
+ long read(String primary_namespace, String secondary_namespace, String key);
+ long write(String primary_namespace, String secondary_namespace, String key, byte[] buf);
+ long remove(String primary_namespace, String secondary_namespace, String key, boolean lazy);
+ long list(String primary_namespace, String secondary_namespace);
+ }
+ public static native long LDKKVStore_new(LDKKVStore impl);
+ // LDKCResult_CVec_u8ZIOErrorZ KVStore_read LDKKVStore *NONNULL_PTR this_arg, struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key
+ public static native long KVStore_read(long this_arg, String primary_namespace, String secondary_namespace, String key);
+ // LDKCResult_NoneIOErrorZ KVStore_write LDKKVStore *NONNULL_PTR this_arg, struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, struct LDKu8slice buf
+ public static native long KVStore_write(long this_arg, String primary_namespace, String secondary_namespace, String key, byte[] buf);
+ // LDKCResult_NoneIOErrorZ KVStore_remove LDKKVStore *NONNULL_PTR this_arg, struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, bool lazy
+ public static native long KVStore_remove(long this_arg, String primary_namespace, String secondary_namespace, String key, boolean lazy);
+ // LDKCResult_CVec_StrZIOErrorZ KVStore_list LDKKVStore *NONNULL_PTR this_arg, struct LDKStr primary_namespace, struct LDKStr secondary_namespace
+ public static native long KVStore_list(long this_arg, String primary_namespace, String secondary_namespace);
+ public interface LDKPersister {
+ long persist_manager(long channel_manager);
+ long persist_graph(long network_graph);
+ long persist_scorer(long scorer);
+ }
+ public static native long LDKPersister_new(LDKPersister impl);
+ // LDKCResult_NoneIOErrorZ Persister_persist_manager LDKPersister *NONNULL_PTR this_arg, const struct LDKChannelManager *NONNULL_PTR channel_manager
+ public static native long Persister_persist_manager(long this_arg, long channel_manager);
+ // LDKCResult_NoneIOErrorZ Persister_persist_graph LDKPersister *NONNULL_PTR this_arg, const struct LDKNetworkGraph *NONNULL_PTR network_graph
+ public static native long Persister_persist_graph(long this_arg, long network_graph);
+ // LDKCResult_NoneIOErrorZ Persister_persist_scorer LDKPersister *NONNULL_PTR this_arg, const struct LDKWriteableScore *NONNULL_PTR scorer
+ public static native long Persister_persist_scorer(long this_arg, long scorer);
+ public interface LDKPersist {
+ ChannelMonitorUpdateStatus persist_new_channel(long channel_id, long data, long update_id);
+ ChannelMonitorUpdateStatus update_persisted_channel(long channel_id, long update, long data, long update_id);
+ }
+ public static native long LDKPersist_new(LDKPersist impl);
+ // LDKChannelMonitorUpdateStatus Persist_persist_new_channel LDKPersist *NONNULL_PTR this_arg, struct LDKOutPoint channel_id, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id
+ public static native ChannelMonitorUpdateStatus Persist_persist_new_channel(long this_arg, long channel_id, long data, long update_id);
+ // LDKChannelMonitorUpdateStatus Persist_update_persisted_channel LDKPersist *NONNULL_PTR this_arg, struct LDKOutPoint channel_id, struct LDKChannelMonitorUpdate update, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id
+ public static native ChannelMonitorUpdateStatus Persist_update_persisted_channel(long this_arg, long channel_id, long update, long data, long update_id);
+ public interface LDKFutureCallback {
+ void call();
+ }
+ public static native long LDKFutureCallback_new(LDKFutureCallback impl);
+ // void FutureCallback_call LDKFutureCallback *NONNULL_PTR this_arg
+ public static native void FutureCallback_call(long this_arg);
+ public interface LDKListen {
+ void filtered_block_connected(byte[] header, long[] txdata, int height);
+ void block_connected(byte[] block, int height);
+ void block_disconnected(byte[] header, int height);
+ }
+ public static native long LDKListen_new(LDKListen impl);
+ // void Listen_filtered_block_connected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
+ public static native void Listen_filtered_block_connected(long this_arg, byte[] header, long[] txdata, int height);
+ // void Listen_block_connected LDKListen *NONNULL_PTR this_arg, struct LDKu8slice block, uint32_t height
+ public static native void Listen_block_connected(long this_arg, byte[] block, int height);
+ // void Listen_block_disconnected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
+ public static native void Listen_block_disconnected(long this_arg, byte[] header, int height);
+ public interface LDKConfirm {
+ void transactions_confirmed(byte[] header, long[] txdata, int height);
+ void transaction_unconfirmed(byte[] txid);
+ void best_block_updated(byte[] header, int height);
+ long[] get_relevant_txids();
+ }
+ public static native long LDKConfirm_new(LDKConfirm impl);
+ // void Confirm_transactions_confirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
+ public static native void Confirm_transactions_confirmed(long this_arg, byte[] header, long[] txdata, int height);
+ // void Confirm_transaction_unconfirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*txid)[32]
+ public static native void Confirm_transaction_unconfirmed(long this_arg, byte[] txid);
+ // void Confirm_best_block_updated LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
+ public static native void Confirm_best_block_updated(long this_arg, byte[] header, int height);
+ // LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ Confirm_get_relevant_txids LDKConfirm *NONNULL_PTR this_arg
+ public static native long[] Confirm_get_relevant_txids(long this_arg);
+ public interface LDKEventHandler {
+ void handle_event(long event);
+ }
+ public static native long LDKEventHandler_new(LDKEventHandler impl);
+ // void EventHandler_handle_event LDKEventHandler *NONNULL_PTR this_arg, struct LDKEvent event
+ public static native void EventHandler_handle_event(long this_arg, long event);
+ public interface LDKEventsProvider {
+ void process_pending_events(long handler);
+ }
+ public static native long LDKEventsProvider_new(LDKEventsProvider impl);
+ // void EventsProvider_process_pending_events LDKEventsProvider *NONNULL_PTR this_arg, struct LDKEventHandler handler
+ public static native void EventsProvider_process_pending_events(long this_arg, long handler);
+ public static class LDKFailureCode {
+ private LDKFailureCode() {}
+ public final static class TemporaryNodeFailure extends LDKFailureCode {
+ TemporaryNodeFailure() { }
+ }
+ public final static class RequiredNodeFeatureMissing extends LDKFailureCode {
+ RequiredNodeFeatureMissing() { }
+ }
+ public final static class IncorrectOrUnknownPaymentDetails extends LDKFailureCode {
+ IncorrectOrUnknownPaymentDetails() { }
+ }
+ public final static class InvalidOnionPayload extends LDKFailureCode {
+ public long invalid_onion_payload;
+ InvalidOnionPayload(long invalid_onion_payload) { this.invalid_onion_payload = invalid_onion_payload; }
+ }
+ static native void init();
+ }
+ static { LDKFailureCode.init(); }
+ public static native LDKFailureCode LDKFailureCode_ref_from_ptr(long ptr);
+ public interface LDKMessageSendEventsProvider {
+ long[] get_and_clear_pending_msg_events();
+ }
+ public static native long LDKMessageSendEventsProvider_new(LDKMessageSendEventsProvider impl);
+ // LDKCVec_MessageSendEventZ MessageSendEventsProvider_get_and_clear_pending_msg_events LDKMessageSendEventsProvider *NONNULL_PTR this_arg
+ public static native long[] MessageSendEventsProvider_get_and_clear_pending_msg_events(long this_arg);
+ public interface LDKChannelMessageHandler {
+ void handle_open_channel(byte[] their_node_id, long msg);
+ void handle_open_channel_v2(byte[] their_node_id, long msg);
+ void handle_accept_channel(byte[] their_node_id, long msg);
+ void handle_accept_channel_v2(byte[] their_node_id, long msg);
+ void handle_funding_created(byte[] their_node_id, long msg);
+ void handle_funding_signed(byte[] their_node_id, long msg);
+ void handle_channel_ready(byte[] their_node_id, long msg);
+ void handle_shutdown(byte[] their_node_id, long msg);
+ void handle_closing_signed(byte[] their_node_id, long msg);
+ void handle_stfu(byte[] their_node_id, long msg);
+ void handle_splice(byte[] their_node_id, long msg);
+ void handle_splice_ack(byte[] their_node_id, long msg);
+ void handle_splice_locked(byte[] their_node_id, long msg);
+ void handle_tx_add_input(byte[] their_node_id, long msg);
+ void handle_tx_add_output(byte[] their_node_id, long msg);
+ void handle_tx_remove_input(byte[] their_node_id, long msg);
+ void handle_tx_remove_output(byte[] their_node_id, long msg);
+ void handle_tx_complete(byte[] their_node_id, long msg);
+ void handle_tx_signatures(byte[] their_node_id, long msg);
+ void handle_tx_init_rbf(byte[] their_node_id, long msg);
+ void handle_tx_ack_rbf(byte[] their_node_id, long msg);
+ void handle_tx_abort(byte[] their_node_id, long msg);
+ void handle_update_add_htlc(byte[] their_node_id, long msg);
+ void handle_update_fulfill_htlc(byte[] their_node_id, long msg);
+ void handle_update_fail_htlc(byte[] their_node_id, long msg);
+ void handle_update_fail_malformed_htlc(byte[] their_node_id, long msg);
+ void handle_commitment_signed(byte[] their_node_id, long msg);
+ void handle_revoke_and_ack(byte[] their_node_id, long msg);
+ void handle_update_fee(byte[] their_node_id, long msg);
+ void handle_announcement_signatures(byte[] their_node_id, long msg);
+ void peer_disconnected(byte[] their_node_id);
+ long peer_connected(byte[] their_node_id, long msg, boolean inbound);
+ void handle_channel_reestablish(byte[] their_node_id, long msg);
+ void handle_channel_update(byte[] their_node_id, long msg);
+ void handle_error(byte[] their_node_id, long msg);
+ long provided_node_features();
+ long provided_init_features(byte[] their_node_id);
+ long get_chain_hashes();
+ }
+ public static native long LDKChannelMessageHandler_new(LDKChannelMessageHandler impl, LDKMessageSendEventsProvider MessageSendEventsProvider);
+ public static native long LDKChannelMessageHandler_get_MessageSendEventsProvider(long arg);
+ // void ChannelMessageHandler_handle_open_channel LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKOpenChannel *NONNULL_PTR msg
+ public static native void ChannelMessageHandler_handle_open_channel(long this_arg, byte[] their_node_id, long msg);
+ // void ChannelMessageHandler_handle_open_channel_v2 LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKOpenChannelV2 *NONNULL_PTR msg
+ public static native void ChannelMessageHandler_handle_open_channel_v2(long this_arg, byte[] their_node_id, long msg);
+ // void ChannelMessageHandler_handle_accept_channel LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAcceptChannel *NONNULL_PTR msg
+ public static native void ChannelMessageHandler_handle_accept_channel(long this_arg, byte[] their_node_id, long msg);
+ // void ChannelMessageHandler_handle_accept_channel_v2 LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAcceptChannelV2 *NONNULL_PTR msg
+ public static native void ChannelMessageHandler_handle_accept_channel_v2(long this_arg, byte[] their_node_id, long msg);
+ // void ChannelMessageHandler_handle_funding_created LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg
+ public static native void ChannelMessageHandler_handle_funding_created(long this_arg, byte[] their_node_id, long msg);
+ // void ChannelMessageHandler_handle_funding_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg
+ public static native void ChannelMessageHandler_handle_funding_signed(long this_arg, byte[] their_node_id, long msg);
+ // void ChannelMessageHandler_handle_channel_ready LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg
+ public static native void ChannelMessageHandler_handle_channel_ready(long this_arg, byte[] their_node_id, long msg);
+ // void ChannelMessageHandler_handle_shutdown LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKShutdown *NONNULL_PTR msg
+ public static native void ChannelMessageHandler_handle_shutdown(long this_arg, byte[] their_node_id, long msg);
+ // void ChannelMessageHandler_handle_closing_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg
+ public static native void ChannelMessageHandler_handle_closing_signed(long this_arg, byte[] their_node_id, long msg);
+ // void ChannelMessageHandler_handle_stfu LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKStfu *NONNULL_PTR msg
+ public static native void ChannelMessageHandler_handle_stfu(long this_arg, byte[] their_node_id, long msg);
+ // void ChannelMessageHandler_handle_splice LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKSplice *NONNULL_PTR msg
+ public static native void ChannelMessageHandler_handle_splice(long this_arg, byte[] their_node_id, long msg);
+ // void ChannelMessageHandler_handle_splice_ack LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKSpliceAck *NONNULL_PTR msg
+ public static native void ChannelMessageHandler_handle_splice_ack(long this_arg, byte[] their_node_id, long msg);
+ // void ChannelMessageHandler_handle_splice_locked LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKSpliceLocked *NONNULL_PTR msg
+ public static native void ChannelMessageHandler_handle_splice_locked(long this_arg, byte[] their_node_id, long msg);
+ // void ChannelMessageHandler_handle_tx_add_input LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxAddInput *NONNULL_PTR msg
+ public static native void ChannelMessageHandler_handle_tx_add_input(long this_arg, byte[] their_node_id, long msg);
+ // void ChannelMessageHandler_handle_tx_add_output LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxAddOutput *NONNULL_PTR msg
+ public static native void ChannelMessageHandler_handle_tx_add_output(long this_arg, byte[] their_node_id, long msg);
+ // void ChannelMessageHandler_handle_tx_remove_input LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxRemoveInput *NONNULL_PTR msg
+ public static native void ChannelMessageHandler_handle_tx_remove_input(long this_arg, byte[] their_node_id, long msg);
+ // void ChannelMessageHandler_handle_tx_remove_output LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxRemoveOutput *NONNULL_PTR msg
+ public static native void ChannelMessageHandler_handle_tx_remove_output(long this_arg, byte[] their_node_id, long msg);
+ // void ChannelMessageHandler_handle_tx_complete LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxComplete *NONNULL_PTR msg
+ public static native void ChannelMessageHandler_handle_tx_complete(long this_arg, byte[] their_node_id, long msg);
+ // void ChannelMessageHandler_handle_tx_signatures LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxSignatures *NONNULL_PTR msg
+ public static native void ChannelMessageHandler_handle_tx_signatures(long this_arg, byte[] their_node_id, long msg);
+ // void ChannelMessageHandler_handle_tx_init_rbf LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxInitRbf *NONNULL_PTR msg
+ public static native void ChannelMessageHandler_handle_tx_init_rbf(long this_arg, byte[] their_node_id, long msg);
+ // void ChannelMessageHandler_handle_tx_ack_rbf LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxAckRbf *NONNULL_PTR msg
+ public static native void ChannelMessageHandler_handle_tx_ack_rbf(long this_arg, byte[] their_node_id, long msg);
+ // void ChannelMessageHandler_handle_tx_abort LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKTxAbort *NONNULL_PTR msg
+ public static native void ChannelMessageHandler_handle_tx_abort(long this_arg, byte[] their_node_id, long msg);
+ // void ChannelMessageHandler_handle_update_add_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg
+ public static native void ChannelMessageHandler_handle_update_add_htlc(long this_arg, byte[] their_node_id, long msg);
+ // void ChannelMessageHandler_handle_update_fulfill_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg
+ public static native void ChannelMessageHandler_handle_update_fulfill_htlc(long this_arg, byte[] their_node_id, long msg);
+ // void ChannelMessageHandler_handle_update_fail_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg
+ public static native void ChannelMessageHandler_handle_update_fail_htlc(long this_arg, byte[] their_node_id, long msg);
+ // void ChannelMessageHandler_handle_update_fail_malformed_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg
+ public static native void ChannelMessageHandler_handle_update_fail_malformed_htlc(long this_arg, byte[] their_node_id, long msg);
+ // void ChannelMessageHandler_handle_commitment_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg
+ public static native void ChannelMessageHandler_handle_commitment_signed(long this_arg, byte[] their_node_id, long msg);
+ // void ChannelMessageHandler_handle_revoke_and_ack LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg
+ public static native void ChannelMessageHandler_handle_revoke_and_ack(long this_arg, byte[] their_node_id, long msg);
+ // void ChannelMessageHandler_handle_update_fee LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg
+ public static native void ChannelMessageHandler_handle_update_fee(long this_arg, byte[] their_node_id, long msg);
+ // void ChannelMessageHandler_handle_announcement_signatures LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg
+ public static native void ChannelMessageHandler_handle_announcement_signatures(long this_arg, byte[] their_node_id, long msg);
+ // void ChannelMessageHandler_peer_disconnected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
+ public static native void ChannelMessageHandler_peer_disconnected(long this_arg, byte[] their_node_id);
+ // LDKCResult_NoneNoneZ ChannelMessageHandler_peer_connected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg, bool inbound
+ public static native long ChannelMessageHandler_peer_connected(long this_arg, byte[] their_node_id, long msg, boolean inbound);
+ // void ChannelMessageHandler_handle_channel_reestablish LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg
+ public static native void ChannelMessageHandler_handle_channel_reestablish(long this_arg, byte[] their_node_id, long msg);
+ // void ChannelMessageHandler_handle_channel_update LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg
+ public static native void ChannelMessageHandler_handle_channel_update(long this_arg, byte[] their_node_id, long msg);
+ // void ChannelMessageHandler_handle_error LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg
+ public static native void ChannelMessageHandler_handle_error(long this_arg, byte[] their_node_id, long msg);
+ // LDKNodeFeatures ChannelMessageHandler_provided_node_features LDKChannelMessageHandler *NONNULL_PTR this_arg
+ public static native long ChannelMessageHandler_provided_node_features(long this_arg);
+ // LDKInitFeatures ChannelMessageHandler_provided_init_features LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
+ public static native long ChannelMessageHandler_provided_init_features(long this_arg, byte[] their_node_id);
+ // LDKCOption_CVec_ThirtyTwoBytesZZ ChannelMessageHandler_get_chain_hashes LDKChannelMessageHandler *NONNULL_PTR this_arg
+ public static native long ChannelMessageHandler_get_chain_hashes(long this_arg);
+ public interface LDKOffersMessageHandler {
+ long handle_message(long message);
+ long[] release_pending_messages();
+ }
+ public static native long LDKOffersMessageHandler_new(LDKOffersMessageHandler impl);
+ // LDKCOption_OffersMessageZ OffersMessageHandler_handle_message LDKOffersMessageHandler *NONNULL_PTR this_arg, struct LDKOffersMessage message
+ public static native long OffersMessageHandler_handle_message(long this_arg, long message);
+ // LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ OffersMessageHandler_release_pending_messages LDKOffersMessageHandler *NONNULL_PTR this_arg
+ public static native long[] OffersMessageHandler_release_pending_messages(long this_arg);
+ public interface LDKRoutingMessageHandler {
+ long handle_node_announcement(long msg);
+ long handle_channel_announcement(long msg);
+ long handle_channel_update(long msg);
+ long get_next_channel_announcement(long starting_point);
+ long get_next_node_announcement(long starting_point);
+ long peer_connected(byte[] their_node_id, long init, boolean inbound);
+ long handle_reply_channel_range(byte[] their_node_id, long msg);
+ long handle_reply_short_channel_ids_end(byte[] their_node_id, long msg);
+ long handle_query_channel_range(byte[] their_node_id, long msg);
+ long handle_query_short_channel_ids(byte[] their_node_id, long msg);
+ boolean processing_queue_high();
+ long provided_node_features();
+ long provided_init_features(byte[] their_node_id);
+ }
+ public static native long LDKRoutingMessageHandler_new(LDKRoutingMessageHandler impl, LDKMessageSendEventsProvider MessageSendEventsProvider);
+ public static native long LDKRoutingMessageHandler_get_MessageSendEventsProvider(long arg);
+ // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg
+ public static native long RoutingMessageHandler_handle_node_announcement(long this_arg, long msg);
+ // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg
+ public static native long RoutingMessageHandler_handle_channel_announcement(long this_arg, long msg);
+ // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_update LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg
+ public static native long RoutingMessageHandler_handle_channel_update(long this_arg, long msg);
+ // LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler_get_next_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, uint64_t starting_point
+ public static native long RoutingMessageHandler_get_next_channel_announcement(long this_arg, long starting_point);
+ // LDKNodeAnnouncement RoutingMessageHandler_get_next_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKNodeId starting_point
+ public static native long RoutingMessageHandler_get_next_node_announcement(long this_arg, long starting_point);
+ // LDKCResult_NoneNoneZ RoutingMessageHandler_peer_connected LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound
+ public static native long RoutingMessageHandler_peer_connected(long this_arg, byte[] their_node_id, long init, boolean inbound);
+ // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg
+ public static native long RoutingMessageHandler_handle_reply_channel_range(long this_arg, byte[] their_node_id, long msg);
+ // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_short_channel_ids_end LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg
+ public static native long RoutingMessageHandler_handle_reply_short_channel_ids_end(long this_arg, byte[] their_node_id, long msg);
+ // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg
+ public static native long RoutingMessageHandler_handle_query_channel_range(long this_arg, byte[] their_node_id, long msg);
+ // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_short_channel_ids LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg
+ public static native long RoutingMessageHandler_handle_query_short_channel_ids(long this_arg, byte[] their_node_id, long msg);
+ // bool RoutingMessageHandler_processing_queue_high LDKRoutingMessageHandler *NONNULL_PTR this_arg
+ public static native boolean RoutingMessageHandler_processing_queue_high(long this_arg);
+ // LDKNodeFeatures RoutingMessageHandler_provided_node_features LDKRoutingMessageHandler *NONNULL_PTR this_arg
+ public static native long RoutingMessageHandler_provided_node_features(long this_arg);
+ // LDKInitFeatures RoutingMessageHandler_provided_init_features LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
+ public static native long RoutingMessageHandler_provided_init_features(long this_arg, byte[] their_node_id);
+ public interface LDKOnionMessageHandler {
+ long[] get_and_clear_connections_needed();
+ void handle_onion_message(byte[] peer_node_id, long msg);
+ long next_onion_message_for_peer(byte[] peer_node_id);
+ long peer_connected(byte[] their_node_id, long init, boolean inbound);
+ void peer_disconnected(byte[] their_node_id);
+ void timer_tick_occurred();
+ long provided_node_features();
+ long provided_init_features(byte[] their_node_id);
+ }
+ public static native long LDKOnionMessageHandler_new(LDKOnionMessageHandler impl);
+ // LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ OnionMessageHandler_get_and_clear_connections_needed LDKOnionMessageHandler *NONNULL_PTR this_arg
+ public static native long[] OnionMessageHandler_get_and_clear_connections_needed(long this_arg);
+ // void OnionMessageHandler_handle_onion_message LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey peer_node_id, const struct LDKOnionMessage *NONNULL_PTR msg
+ public static native void OnionMessageHandler_handle_onion_message(long this_arg, byte[] peer_node_id, long msg);
+ // LDKOnionMessage OnionMessageHandler_next_onion_message_for_peer LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey peer_node_id
+ public static native long OnionMessageHandler_next_onion_message_for_peer(long this_arg, byte[] peer_node_id);
+ // LDKCResult_NoneNoneZ OnionMessageHandler_peer_connected LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound
+ public static native long OnionMessageHandler_peer_connected(long this_arg, byte[] their_node_id, long init, boolean inbound);
+ // void OnionMessageHandler_peer_disconnected LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
+ public static native void OnionMessageHandler_peer_disconnected(long this_arg, byte[] their_node_id);
+ // void OnionMessageHandler_timer_tick_occurred LDKOnionMessageHandler *NONNULL_PTR this_arg
+ public static native void OnionMessageHandler_timer_tick_occurred(long this_arg);
+ // LDKNodeFeatures OnionMessageHandler_provided_node_features LDKOnionMessageHandler *NONNULL_PTR this_arg
+ public static native long OnionMessageHandler_provided_node_features(long this_arg);
+ // LDKInitFeatures OnionMessageHandler_provided_init_features LDKOnionMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
+ public static native long OnionMessageHandler_provided_init_features(long this_arg, byte[] their_node_id);
+ public interface LDKCustomMessageReader {
+ long read(short message_type, byte[] buffer);
+ }
+ public static native long LDKCustomMessageReader_new(LDKCustomMessageReader impl);
+ // LDKCResult_COption_TypeZDecodeErrorZ CustomMessageReader_read LDKCustomMessageReader *NONNULL_PTR this_arg, uint16_t message_type, struct LDKu8slice buffer
+ public static native long CustomMessageReader_read(long this_arg, short message_type, byte[] buffer);
+ public interface LDKCustomMessageHandler {
+ long handle_custom_message(long msg, byte[] sender_node_id);
+ long[] get_and_clear_pending_msg();
+ long provided_node_features();
+ long provided_init_features(byte[] their_node_id);
+ }
+ public static native long LDKCustomMessageHandler_new(LDKCustomMessageHandler impl, LDKCustomMessageReader CustomMessageReader);
+ public static native long LDKCustomMessageHandler_get_CustomMessageReader(long arg);
+ // LDKCResult_NoneLightningErrorZ CustomMessageHandler_handle_custom_message LDKCustomMessageHandler *NONNULL_PTR this_arg, struct LDKType msg, struct LDKPublicKey sender_node_id
+ public static native long CustomMessageHandler_handle_custom_message(long this_arg, long msg, byte[] sender_node_id);
+ // LDKCVec_C2Tuple_PublicKeyTypeZZ CustomMessageHandler_get_and_clear_pending_msg LDKCustomMessageHandler *NONNULL_PTR this_arg
+ public static native long[] CustomMessageHandler_get_and_clear_pending_msg(long this_arg);
+ // LDKNodeFeatures CustomMessageHandler_provided_node_features LDKCustomMessageHandler *NONNULL_PTR this_arg
+ public static native long CustomMessageHandler_provided_node_features(long this_arg);
+ // LDKInitFeatures CustomMessageHandler_provided_init_features LDKCustomMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id
+ public static native long CustomMessageHandler_provided_init_features(long this_arg, byte[] their_node_id);
+ public interface LDKCustomOnionMessageHandler {
+ long handle_custom_message(long msg);
+ long read_custom_message(long message_type, byte[] buffer);
+ long[] release_pending_custom_messages();
+ }
+ public static native long LDKCustomOnionMessageHandler_new(LDKCustomOnionMessageHandler impl);
+ // LDKCOption_OnionMessageContentsZ CustomOnionMessageHandler_handle_custom_message LDKCustomOnionMessageHandler *NONNULL_PTR this_arg, struct LDKOnionMessageContents msg
+ public static native long CustomOnionMessageHandler_handle_custom_message(long this_arg, long msg);
+ // LDKCResult_COption_OnionMessageContentsZDecodeErrorZ CustomOnionMessageHandler_read_custom_message LDKCustomOnionMessageHandler *NONNULL_PTR this_arg, uint64_t message_type, struct LDKu8slice buffer
+ public static native long CustomOnionMessageHandler_read_custom_message(long this_arg, long message_type, byte[] buffer);
+ // LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ CustomOnionMessageHandler_release_pending_custom_messages LDKCustomOnionMessageHandler *NONNULL_PTR this_arg
+ public static native long[] CustomOnionMessageHandler_release_pending_custom_messages(long this_arg);
+ public interface LDKSocketDescriptor {
+ long send_data(byte[] data, boolean resume_read);
+ void disconnect_socket();
+ boolean eq(long other_arg);
+ long hash();
+ }
+ public static native long LDKSocketDescriptor_new(LDKSocketDescriptor impl);
+ // uintptr_t SocketDescriptor_send_data LDKSocketDescriptor *NONNULL_PTR this_arg, struct LDKu8slice data, bool resume_read
+ public static native long SocketDescriptor_send_data(long this_arg, byte[] data, boolean resume_read);
+ // void SocketDescriptor_disconnect_socket LDKSocketDescriptor *NONNULL_PTR this_arg
+ public static native void SocketDescriptor_disconnect_socket(long this_arg);
+ // uint64_t SocketDescriptor_hash LDKSocketDescriptor *NONNULL_PTR this_arg
+ public static native long SocketDescriptor_hash(long this_arg);
+ public static class LDKEffectiveCapacity {
+ private LDKEffectiveCapacity() {}
+ public final static class ExactLiquidity extends LDKEffectiveCapacity {
+ public long liquidity_msat;
+ ExactLiquidity(long liquidity_msat) { this.liquidity_msat = liquidity_msat; }
+ }
+ public final static class AdvertisedMaxHTLC extends LDKEffectiveCapacity {
+ public long amount_msat;
+ AdvertisedMaxHTLC(long amount_msat) { this.amount_msat = amount_msat; }
+ }
+ public final static class Total extends LDKEffectiveCapacity {
+ public long capacity_msat;
+ public long htlc_maximum_msat;
+ Total(long capacity_msat, long htlc_maximum_msat) { this.capacity_msat = capacity_msat; this.htlc_maximum_msat = htlc_maximum_msat; }
+ }
+ public final static class Infinite extends LDKEffectiveCapacity {
+ Infinite() { }
+ }
+ public final static class HintMaxHTLC extends LDKEffectiveCapacity {
+ public long amount_msat;
+ HintMaxHTLC(long amount_msat) { this.amount_msat = amount_msat; }
+ }
+ public final static class Unknown extends LDKEffectiveCapacity {
+ Unknown() { }
+ }
+ static native void init();
+ }
+ static { LDKEffectiveCapacity.init(); }
+ public static native LDKEffectiveCapacity LDKEffectiveCapacity_ref_from_ptr(long ptr);
+ public static class LDKPayee {
+ private LDKPayee() {}
+ public final static class Blinded extends LDKPayee {
+ public long[] route_hints;
+ public long features;
+ Blinded(long[] route_hints, long features) { this.route_hints = route_hints; this.features = features; }
+ }
+ public final static class Clear extends LDKPayee {
+ public byte[] node_id;
+ public long[] route_hints;
+ public long features;
+ public int final_cltv_expiry_delta;
+ Clear(byte[] node_id, long[] route_hints, long features, int final_cltv_expiry_delta) { this.node_id = node_id; this.route_hints = route_hints; this.features = features; this.final_cltv_expiry_delta = final_cltv_expiry_delta; }
+ }
+ static native void init();
+ }
+ static { LDKPayee.init(); }
+ public static native LDKPayee LDKPayee_ref_from_ptr(long ptr);
+ public interface LDKScore {
+ byte[] write();
+ }
+ public static native long LDKScore_new(LDKScore impl, LDKScoreLookUp ScoreLookUp, LDKScoreUpdate ScoreUpdate);
+ public static native long LDKScore_get_ScoreLookUp(long arg);
+ public static native long LDKScore_get_ScoreUpdate(long arg);
+ // LDKCVec_u8Z Score_write LDKScore *NONNULL_PTR this_arg
+ public static native byte[] Score_write(long this_arg);
+ public interface LDKCoinSelectionSource {
+ long select_confirmed_utxos(byte[] claim_id, long[] must_spend, long[] must_pay_to, int target_feerate_sat_per_1000_weight);
+ long sign_psbt(byte[] psbt);
+ }
+ public static native long LDKCoinSelectionSource_new(LDKCoinSelectionSource impl);
+ // LDKCResult_CoinSelectionNoneZ CoinSelectionSource_select_confirmed_utxos LDKCoinSelectionSource *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes claim_id, struct LDKCVec_InputZ must_spend, struct LDKCVec_TxOutZ must_pay_to, uint32_t target_feerate_sat_per_1000_weight
+ public static native long CoinSelectionSource_select_confirmed_utxos(long this_arg, byte[] claim_id, long[] must_spend, long[] must_pay_to, int target_feerate_sat_per_1000_weight);
+ // LDKCResult_TransactionNoneZ CoinSelectionSource_sign_psbt LDKCoinSelectionSource *NONNULL_PTR this_arg, struct LDKCVec_u8Z psbt
+ public static native long CoinSelectionSource_sign_psbt(long this_arg, byte[] psbt);
+ public interface LDKWalletSource {
+ long list_confirmed_utxos();
+ long get_change_script();
+ long sign_psbt(byte[] psbt);
+ }
+ public static native long LDKWalletSource_new(LDKWalletSource impl);
+ // LDKCResult_CVec_UtxoZNoneZ WalletSource_list_confirmed_utxos LDKWalletSource *NONNULL_PTR this_arg
+ public static native long WalletSource_list_confirmed_utxos(long this_arg);
+ // LDKCResult_CVec_u8ZNoneZ WalletSource_get_change_script LDKWalletSource *NONNULL_PTR this_arg
+ public static native long WalletSource_get_change_script(long this_arg);
+ // LDKCResult_TransactionNoneZ WalletSource_sign_psbt LDKWalletSource *NONNULL_PTR this_arg, struct LDKCVec_u8Z psbt
+ public static native long WalletSource_sign_psbt(long this_arg, byte[] psbt);
+ public static class LDKGossipSync {
+ private LDKGossipSync() {}
+ public final static class P2P extends LDKGossipSync {
+ public long p2p;
+ P2P(long p2p) { this.p2p = p2p; }
+ }
+ public final static class Rapid extends LDKGossipSync {
+ public long rapid;
+ Rapid(long rapid) { this.rapid = rapid; }
+ }
+ public final static class None extends LDKGossipSync {
+ None() { }
+ }
+ static native void init();
+ }
+ static { LDKGossipSync.init(); }
+ public static native LDKGossipSync LDKGossipSync_ref_from_ptr(long ptr);
+ public static class LDKFallback {
+ private LDKFallback() {}
+ public final static class SegWitProgram extends LDKFallback {
+ public byte version;
+ public byte[] program;
+ SegWitProgram(byte version, byte[] program) { this.version = version; this.program = program; }
+ }
+ public final static class PubKeyHash extends LDKFallback {
+ public byte[] pub_key_hash;
+ PubKeyHash(byte[] pub_key_hash) { this.pub_key_hash = pub_key_hash; }
+ }
+ public final static class ScriptHash extends LDKFallback {
+ public byte[] script_hash;
+ ScriptHash(byte[] script_hash) { this.script_hash = script_hash; }
+ }
+ static native void init();
+ }
+ static { LDKFallback.init(); }
+ public static native LDKFallback LDKFallback_ref_from_ptr(long ptr);
+ // struct LDKStr _ldk_get_compiled_version(void);
+ public static native String _ldk_get_compiled_version();
+ // struct LDKStr _ldk_c_bindings_get_compiled_version(void);
+ public static native String _ldk_c_bindings_get_compiled_version();
+ // struct LDKSixteenBytes U128_le_bytes(struct LDKU128 val);
+ public static native byte[] U128_le_bytes(byte[] val);
+ // struct LDKU128 U128_new(struct LDKSixteenBytes le_bytes);
+ public static native byte[] U128_new(byte[] le_bytes);
+ // struct LDKWitnessProgram WitnessProgram_new(struct LDKWitnessVersion version, struct LDKCVec_u8Z program);
+ public static native long WitnessProgram_new(byte version, byte[] program);
+ // struct LDKWitnessVersion WitnessProgram_get_version(const struct LDKWitnessProgram *NONNULL_PTR prog);
+ public static native byte WitnessProgram_get_version(long prog);
+ // struct LDKu8slice WitnessProgram_get_program(const struct LDKWitnessProgram *NONNULL_PTR prog);
+ public static native byte[] WitnessProgram_get_program(long prog);
+ // uint64_t WitnessProgram_clone_ptr(LDKWitnessProgram *NONNULL_PTR arg);
+ public static native long WitnessProgram_clone_ptr(long arg);
+ // struct LDKWitnessProgram WitnessProgram_clone(const struct LDKWitnessProgram *NONNULL_PTR orig);
+ public static native long WitnessProgram_clone(long orig);
+ // void WitnessProgram_free(struct LDKWitnessProgram o);
+ public static native void WitnessProgram_free(long o);
+ // struct LDKBigEndianScalar BigEndianScalar_new(struct LDKThirtyTwoBytes big_endian_bytes);
+ public static native long BigEndianScalar_new(byte[] big_endian_bytes);
+ // uint64_t Bech32Error_clone_ptr(LDKBech32Error *NONNULL_PTR arg);
+ public static native long Bech32Error_clone_ptr(long arg);
+ // struct LDKBech32Error Bech32Error_clone(const struct LDKBech32Error *NONNULL_PTR orig);
+ public static native long Bech32Error_clone(long orig);
+ // void Bech32Error_free(struct LDKBech32Error o);
+ public static native void Bech32Error_free(long o);
+ // void Transaction_free(struct LDKTransaction _res);
+ public static native void Transaction_free(byte[] _res);
+ // void Witness_free(struct LDKWitness _res);
+ public static native void Witness_free(byte[] _res);
+ // struct LDKTxIn TxIn_new(struct LDKWitness witness, struct LDKCVec_u8Z script_sig, uint32_t sequence, struct LDKThirtyTwoBytes previous_txid, uint32_t previous_vout);
+ public static native long TxIn_new(byte[] witness, byte[] script_sig, int sequence, byte[] previous_txid, int previous_vout);
+ // struct LDKWitness TxIn_get_witness(const struct LDKTxIn *NONNULL_PTR txin);
+ public static native byte[] TxIn_get_witness(long txin);
+ // struct LDKu8slice TxIn_get_script_sig(const struct LDKTxIn *NONNULL_PTR txin);
+ public static native byte[] TxIn_get_script_sig(long txin);
+ // uint32_t TxIn_get_sequence(const struct LDKTxIn *NONNULL_PTR txin);
+ public static native int TxIn_get_sequence(long txin);
+ // struct LDKThirtyTwoBytes TxIn_get_previous_txid(const struct LDKTxIn *NONNULL_PTR txin);
+ public static native byte[] TxIn_get_previous_txid(long txin);
+ // uint32_t TxIn_get_previous_vout(const struct LDKTxIn *NONNULL_PTR txin);
+ public static native int TxIn_get_previous_vout(long txin);
+ // void TxIn_free(struct LDKTxIn _res);
+ public static native void TxIn_free(long _res);
+ // struct LDKTxOut TxOut_new(struct LDKCVec_u8Z script_pubkey, uint64_t value);
+ public static native long TxOut_new(byte[] script_pubkey, long value);
+ // struct LDKu8slice TxOut_get_script_pubkey(const struct LDKTxOut *NONNULL_PTR txout);
+ public static native byte[] TxOut_get_script_pubkey(long txout);
+ // uint64_t TxOut_get_value(const struct LDKTxOut *NONNULL_PTR txout);
+ public static native long TxOut_get_value(long txout);
+ // void TxOut_free(struct LDKTxOut _res);
+ public static native void TxOut_free(long _res);
+ // uint64_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg);
+ public static native long TxOut_clone_ptr(long arg);
+ // struct LDKTxOut TxOut_clone(const struct LDKTxOut *NONNULL_PTR orig);
+ public static native long TxOut_clone(long orig);
+ // void Str_free(struct LDKStr _res);
+ public static native void Str_free(String _res);
+ // struct LDKCOption_u64Z COption_u64Z_some(uint64_t o);
+ public static native long COption_u64Z_some(long o);
+ // struct LDKCOption_u64Z COption_u64Z_none(void);
+ public static native long COption_u64Z_none();
+ // void COption_u64Z_free(struct LDKCOption_u64Z _res);
+ public static native void COption_u64Z_free(long _res);
+ // uint64_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg);
+ public static native long COption_u64Z_clone_ptr(long arg);
+ // struct LDKCOption_u64Z COption_u64Z_clone(const struct LDKCOption_u64Z *NONNULL_PTR orig);
+ public static native long COption_u64Z_clone(long orig);
+ // void CVec_BlindedPathZ_free(struct LDKCVec_BlindedPathZ _res);
+ public static native void CVec_BlindedPathZ_free(long[] _res);
+ // struct LDKCResult_RefundBolt12ParseErrorZ CResult_RefundBolt12ParseErrorZ_ok(struct LDKRefund o);
+ public static native long CResult_RefundBolt12ParseErrorZ_ok(long o);
+ // struct LDKCResult_RefundBolt12ParseErrorZ CResult_RefundBolt12ParseErrorZ_err(struct LDKBolt12ParseError e);
+ public static native long CResult_RefundBolt12ParseErrorZ_err(long e);
+ // bool CResult_RefundBolt12ParseErrorZ_is_ok(const struct LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_RefundBolt12ParseErrorZ_is_ok(long o);
+ // void CResult_RefundBolt12ParseErrorZ_free(struct LDKCResult_RefundBolt12ParseErrorZ _res);
+ public static native void CResult_RefundBolt12ParseErrorZ_free(long _res);
+ // uint64_t CResult_RefundBolt12ParseErrorZ_clone_ptr(LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR arg);
+ public static native long CResult_RefundBolt12ParseErrorZ_clone_ptr(long arg);
+ // struct LDKCResult_RefundBolt12ParseErrorZ CResult_RefundBolt12ParseErrorZ_clone(const struct LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR orig);
+ public static native long CResult_RefundBolt12ParseErrorZ_clone(long orig);
+ // struct LDKCResult_RetryDecodeErrorZ CResult_RetryDecodeErrorZ_ok(struct LDKRetry o);
+ public static native long CResult_RetryDecodeErrorZ_ok(long o);
+ // struct LDKCResult_RetryDecodeErrorZ CResult_RetryDecodeErrorZ_err(struct LDKDecodeError e);
+ public static native long CResult_RetryDecodeErrorZ_err(long e);
+ // bool CResult_RetryDecodeErrorZ_is_ok(const struct LDKCResult_RetryDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_RetryDecodeErrorZ_is_ok(long o);
+ // void CResult_RetryDecodeErrorZ_free(struct LDKCResult_RetryDecodeErrorZ _res);
+ public static native void CResult_RetryDecodeErrorZ_free(long _res);
+ // uint64_t CResult_RetryDecodeErrorZ_clone_ptr(LDKCResult_RetryDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_RetryDecodeErrorZ_clone_ptr(long arg);
+ // struct LDKCResult_RetryDecodeErrorZ CResult_RetryDecodeErrorZ_clone(const struct LDKCResult_RetryDecodeErrorZ *NONNULL_PTR orig);
+ public static native long CResult_RetryDecodeErrorZ_clone(long orig);
+ // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void);
+ public static native long CResult_NoneAPIErrorZ_ok();
+ // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_err(struct LDKAPIError e);
+ public static native long CResult_NoneAPIErrorZ_err(long e);
+ // bool CResult_NoneAPIErrorZ_is_ok(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_NoneAPIErrorZ_is_ok(long o);
+ // void CResult_NoneAPIErrorZ_free(struct LDKCResult_NoneAPIErrorZ _res);
+ public static native void CResult_NoneAPIErrorZ_free(long _res);
+ // uint64_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg);
+ public static native long CResult_NoneAPIErrorZ_clone_ptr(long arg);
+ // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_clone(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR orig);
+ public static native long CResult_NoneAPIErrorZ_clone(long orig);
+ // void CVec_CResult_NoneAPIErrorZZ_free(struct LDKCVec_CResult_NoneAPIErrorZZ _res);
+ public static native void CVec_CResult_NoneAPIErrorZZ_free(long[] _res);
+ // void CVec_APIErrorZ_free(struct LDKCVec_APIErrorZ _res);
+ public static native void CVec_APIErrorZ_free(long[] _res);
+ // struct LDKCOption_ThirtyTwoBytesZ COption_ThirtyTwoBytesZ_some(struct LDKThirtyTwoBytes o);
+ public static native long COption_ThirtyTwoBytesZ_some(byte[] o);
+ // struct LDKCOption_ThirtyTwoBytesZ COption_ThirtyTwoBytesZ_none(void);
+ public static native long COption_ThirtyTwoBytesZ_none();
+ // void COption_ThirtyTwoBytesZ_free(struct LDKCOption_ThirtyTwoBytesZ _res);
+ public static native void COption_ThirtyTwoBytesZ_free(long _res);
+ // uint64_t COption_ThirtyTwoBytesZ_clone_ptr(LDKCOption_ThirtyTwoBytesZ *NONNULL_PTR arg);
+ public static native long COption_ThirtyTwoBytesZ_clone_ptr(long arg);
+ // struct LDKCOption_ThirtyTwoBytesZ COption_ThirtyTwoBytesZ_clone(const struct LDKCOption_ThirtyTwoBytesZ *NONNULL_PTR orig);
+ public static native long COption_ThirtyTwoBytesZ_clone(long orig);
+ // void CVec_u8Z_free(struct LDKCVec_u8Z _res);
+ public static native void CVec_u8Z_free(byte[] _res);
+ // struct LDKCOption_CVec_u8ZZ COption_CVec_u8ZZ_some(struct LDKCVec_u8Z o);
+ public static native long COption_CVec_u8ZZ_some(byte[] o);
+ // struct LDKCOption_CVec_u8ZZ COption_CVec_u8ZZ_none(void);
+ public static native long COption_CVec_u8ZZ_none();
+ // void COption_CVec_u8ZZ_free(struct LDKCOption_CVec_u8ZZ _res);
+ public static native void COption_CVec_u8ZZ_free(long _res);
+ // uint64_t COption_CVec_u8ZZ_clone_ptr(LDKCOption_CVec_u8ZZ *NONNULL_PTR arg);
+ public static native long COption_CVec_u8ZZ_clone_ptr(long arg);
+ // struct LDKCOption_CVec_u8ZZ COption_CVec_u8ZZ_clone(const struct LDKCOption_CVec_u8ZZ *NONNULL_PTR orig);
+ public static native long COption_CVec_u8ZZ_clone(long orig);
+ // struct LDKCResult_RecipientOnionFieldsDecodeErrorZ CResult_RecipientOnionFieldsDecodeErrorZ_ok(struct LDKRecipientOnionFields o);
+ public static native long CResult_RecipientOnionFieldsDecodeErrorZ_ok(long o);
+ // struct LDKCResult_RecipientOnionFieldsDecodeErrorZ CResult_RecipientOnionFieldsDecodeErrorZ_err(struct LDKDecodeError e);
+ public static native long CResult_RecipientOnionFieldsDecodeErrorZ_err(long e);
+ // bool CResult_RecipientOnionFieldsDecodeErrorZ_is_ok(const struct LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_RecipientOnionFieldsDecodeErrorZ_is_ok(long o);
+ // void CResult_RecipientOnionFieldsDecodeErrorZ_free(struct LDKCResult_RecipientOnionFieldsDecodeErrorZ _res);
+ public static native void CResult_RecipientOnionFieldsDecodeErrorZ_free(long _res);
+ // uint64_t CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr(LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr(long arg);
+ // struct LDKCResult_RecipientOnionFieldsDecodeErrorZ CResult_RecipientOnionFieldsDecodeErrorZ_clone(const struct LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR orig);
+ public static native long CResult_RecipientOnionFieldsDecodeErrorZ_clone(long orig);
+ // uint64_t C2Tuple_u64CVec_u8ZZ_clone_ptr(LDKC2Tuple_u64CVec_u8ZZ *NONNULL_PTR arg);
+ public static native long C2Tuple_u64CVec_u8ZZ_clone_ptr(long arg);
+ // struct LDKC2Tuple_u64CVec_u8ZZ C2Tuple_u64CVec_u8ZZ_clone(const struct LDKC2Tuple_u64CVec_u8ZZ *NONNULL_PTR orig);
+ public static native long C2Tuple_u64CVec_u8ZZ_clone(long orig);
+ // struct LDKC2Tuple_u64CVec_u8ZZ C2Tuple_u64CVec_u8ZZ_new(uint64_t a, struct LDKCVec_u8Z b);
+ public static native long C2Tuple_u64CVec_u8ZZ_new(long a, byte[] b);
+ // void C2Tuple_u64CVec_u8ZZ_free(struct LDKC2Tuple_u64CVec_u8ZZ _res);
+ public static native void C2Tuple_u64CVec_u8ZZ_free(long _res);
+ // void CVec_C2Tuple_u64CVec_u8ZZZ_free(struct LDKCVec_C2Tuple_u64CVec_u8ZZZ _res);
+ public static native void CVec_C2Tuple_u64CVec_u8ZZZ_free(long[] _res);
+ // struct LDKCResult_RecipientOnionFieldsNoneZ CResult_RecipientOnionFieldsNoneZ_ok(struct LDKRecipientOnionFields o);
+ public static native long CResult_RecipientOnionFieldsNoneZ_ok(long o);
+ // struct LDKCResult_RecipientOnionFieldsNoneZ CResult_RecipientOnionFieldsNoneZ_err(void);
+ public static native long CResult_RecipientOnionFieldsNoneZ_err();
+ // bool CResult_RecipientOnionFieldsNoneZ_is_ok(const struct LDKCResult_RecipientOnionFieldsNoneZ *NONNULL_PTR o);
+ public static native boolean CResult_RecipientOnionFieldsNoneZ_is_ok(long o);
+ // void CResult_RecipientOnionFieldsNoneZ_free(struct LDKCResult_RecipientOnionFieldsNoneZ _res);
+ public static native void CResult_RecipientOnionFieldsNoneZ_free(long _res);
+ // uint64_t CResult_RecipientOnionFieldsNoneZ_clone_ptr(LDKCResult_RecipientOnionFieldsNoneZ *NONNULL_PTR arg);
+ public static native long CResult_RecipientOnionFieldsNoneZ_clone_ptr(long arg);
+ // struct LDKCResult_RecipientOnionFieldsNoneZ CResult_RecipientOnionFieldsNoneZ_clone(const struct LDKCResult_RecipientOnionFieldsNoneZ *NONNULL_PTR orig);
+ public static native long CResult_RecipientOnionFieldsNoneZ_clone(long orig);
+ // void CVec_ThirtyTwoBytesZ_free(struct LDKCVec_ThirtyTwoBytesZ _res);
+ public static native void CVec_ThirtyTwoBytesZ_free(byte[][] _res);
+ // struct LDKCOption_CVec_ThirtyTwoBytesZZ COption_CVec_ThirtyTwoBytesZZ_some(struct LDKCVec_ThirtyTwoBytesZ o);
+ public static native long COption_CVec_ThirtyTwoBytesZZ_some(byte[][] o);
+ // struct LDKCOption_CVec_ThirtyTwoBytesZZ COption_CVec_ThirtyTwoBytesZZ_none(void);
+ public static native long COption_CVec_ThirtyTwoBytesZZ_none();
+ // void COption_CVec_ThirtyTwoBytesZZ_free(struct LDKCOption_CVec_ThirtyTwoBytesZZ _res);
+ public static native void COption_CVec_ThirtyTwoBytesZZ_free(long _res);
+ // uint64_t COption_CVec_ThirtyTwoBytesZZ_clone_ptr(LDKCOption_CVec_ThirtyTwoBytesZZ *NONNULL_PTR arg);
+ public static native long COption_CVec_ThirtyTwoBytesZZ_clone_ptr(long arg);
+ // struct LDKCOption_CVec_ThirtyTwoBytesZZ COption_CVec_ThirtyTwoBytesZZ_clone(const struct LDKCOption_CVec_ThirtyTwoBytesZZ *NONNULL_PTR orig);
+ public static native long COption_CVec_ThirtyTwoBytesZZ_clone(long orig);
+ // struct LDKCResult_ThirtyTwoBytesNoneZ CResult_ThirtyTwoBytesNoneZ_ok(struct LDKThirtyTwoBytes o);
+ public static native long CResult_ThirtyTwoBytesNoneZ_ok(byte[] o);
+ // struct LDKCResult_ThirtyTwoBytesNoneZ CResult_ThirtyTwoBytesNoneZ_err(void);
+ public static native long CResult_ThirtyTwoBytesNoneZ_err();
+ // bool CResult_ThirtyTwoBytesNoneZ_is_ok(const struct LDKCResult_ThirtyTwoBytesNoneZ *NONNULL_PTR o);
+ public static native boolean CResult_ThirtyTwoBytesNoneZ_is_ok(long o);
+ // void CResult_ThirtyTwoBytesNoneZ_free(struct LDKCResult_ThirtyTwoBytesNoneZ _res);
+ public static native void CResult_ThirtyTwoBytesNoneZ_free(long _res);
+ // uint64_t CResult_ThirtyTwoBytesNoneZ_clone_ptr(LDKCResult_ThirtyTwoBytesNoneZ *NONNULL_PTR arg);
+ public static native long CResult_ThirtyTwoBytesNoneZ_clone_ptr(long arg);
+ // struct LDKCResult_ThirtyTwoBytesNoneZ CResult_ThirtyTwoBytesNoneZ_clone(const struct LDKCResult_ThirtyTwoBytesNoneZ *NONNULL_PTR orig);
+ public static native long CResult_ThirtyTwoBytesNoneZ_clone(long orig);
+ // struct LDKCResult_BlindedPayInfoDecodeErrorZ CResult_BlindedPayInfoDecodeErrorZ_ok(struct LDKBlindedPayInfo o);
+ public static native long CResult_BlindedPayInfoDecodeErrorZ_ok(long o);
+ // struct LDKCResult_BlindedPayInfoDecodeErrorZ CResult_BlindedPayInfoDecodeErrorZ_err(struct LDKDecodeError e);
+ public static native long CResult_BlindedPayInfoDecodeErrorZ_err(long e);
+ // bool CResult_BlindedPayInfoDecodeErrorZ_is_ok(const struct LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_BlindedPayInfoDecodeErrorZ_is_ok(long o);
+ // void CResult_BlindedPayInfoDecodeErrorZ_free(struct LDKCResult_BlindedPayInfoDecodeErrorZ _res);
+ public static native void CResult_BlindedPayInfoDecodeErrorZ_free(long _res);
+ // uint64_t CResult_BlindedPayInfoDecodeErrorZ_clone_ptr(LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_BlindedPayInfoDecodeErrorZ_clone_ptr(long arg);
+ // struct LDKCResult_BlindedPayInfoDecodeErrorZ CResult_BlindedPayInfoDecodeErrorZ_clone(const struct LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR orig);
+ public static native long CResult_BlindedPayInfoDecodeErrorZ_clone(long orig);
+ // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKDelayedPaymentOutputDescriptor o);
+ public static native long CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(long o);
+ // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
+ public static native long CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(long e);
+ // bool CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(long o);
+ // void CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res);
+ public static native void CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(long _res);
+ // uint64_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(long arg);
+ // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
+ public static native long CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(long orig);
+ // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKStaticPaymentOutputDescriptor o);
+ public static native long CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(long o);
+ // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
+ public static native long CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(long e);
+ // bool CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(long o);
+ // void CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res);
+ public static native void CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(long _res);
+ // uint64_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(long arg);
+ // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
+ public static native long CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(long orig);
+ // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_ok(struct LDKSpendableOutputDescriptor o);
+ public static native long CResult_SpendableOutputDescriptorDecodeErrorZ_ok(long o);
+ // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
+ public static native long CResult_SpendableOutputDescriptorDecodeErrorZ_err(long e);
+ // bool CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(long o);
+ // void CResult_SpendableOutputDescriptorDecodeErrorZ_free(struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res);
+ public static native void CResult_SpendableOutputDescriptorDecodeErrorZ_free(long _res);
+ // uint64_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(long arg);
+ // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
+ public static native long CResult_SpendableOutputDescriptorDecodeErrorZ_clone(long orig);
+ // void CVec_SpendableOutputDescriptorZ_free(struct LDKCVec_SpendableOutputDescriptorZ _res);
+ public static native void CVec_SpendableOutputDescriptorZ_free(long[] _res);
+ // void CVec_TxOutZ_free(struct LDKCVec_TxOutZ _res);
+ public static native void CVec_TxOutZ_free(long[] _res);
+ // struct LDKCOption_u32Z COption_u32Z_some(uint32_t o);
+ public static native long COption_u32Z_some(int o);
+ // struct LDKCOption_u32Z COption_u32Z_none(void);
+ public static native long COption_u32Z_none();
+ // void COption_u32Z_free(struct LDKCOption_u32Z _res);
+ public static native void COption_u32Z_free(long _res);
+ // uint64_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg);
+ public static native long COption_u32Z_clone_ptr(long arg);
+ // struct LDKCOption_u32Z COption_u32Z_clone(const struct LDKCOption_u32Z *NONNULL_PTR orig);
+ public static native long COption_u32Z_clone(long orig);
+ // uint64_t C2Tuple_CVec_u8Zu64Z_clone_ptr(LDKC2Tuple_CVec_u8Zu64Z *NONNULL_PTR arg);
+ public static native long C2Tuple_CVec_u8Zu64Z_clone_ptr(long arg);
+ // struct LDKC2Tuple_CVec_u8Zu64Z C2Tuple_CVec_u8Zu64Z_clone(const struct LDKC2Tuple_CVec_u8Zu64Z *NONNULL_PTR orig);
+ public static native long C2Tuple_CVec_u8Zu64Z_clone(long orig);
+ // struct LDKC2Tuple_CVec_u8Zu64Z C2Tuple_CVec_u8Zu64Z_new(struct LDKCVec_u8Z a, uint64_t b);
+ public static native long C2Tuple_CVec_u8Zu64Z_new(byte[] a, long b);
+ // void C2Tuple_CVec_u8Zu64Z_free(struct LDKC2Tuple_CVec_u8Zu64Z _res);
+ public static native void C2Tuple_CVec_u8Zu64Z_free(long _res);
+ // struct LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ CResult_C2Tuple_CVec_u8Zu64ZNoneZ_ok(struct LDKC2Tuple_CVec_u8Zu64Z o);
+ public static native long CResult_C2Tuple_CVec_u8Zu64ZNoneZ_ok(long o);
+ // struct LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ CResult_C2Tuple_CVec_u8Zu64ZNoneZ_err(void);
+ public static native long CResult_C2Tuple_CVec_u8Zu64ZNoneZ_err();
+ // bool CResult_C2Tuple_CVec_u8Zu64ZNoneZ_is_ok(const struct LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ *NONNULL_PTR o);
+ public static native boolean CResult_C2Tuple_CVec_u8Zu64ZNoneZ_is_ok(long o);
+ // void CResult_C2Tuple_CVec_u8Zu64ZNoneZ_free(struct LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ _res);
+ public static native void CResult_C2Tuple_CVec_u8Zu64ZNoneZ_free(long _res);
+ // uint64_t CResult_C2Tuple_CVec_u8Zu64ZNoneZ_clone_ptr(LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ *NONNULL_PTR arg);
+ public static native long CResult_C2Tuple_CVec_u8Zu64ZNoneZ_clone_ptr(long arg);
+ // struct LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ CResult_C2Tuple_CVec_u8Zu64ZNoneZ_clone(const struct LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ *NONNULL_PTR orig);
+ public static native long CResult_C2Tuple_CVec_u8Zu64ZNoneZ_clone(long orig);
+ // struct LDKCResult_ChannelDerivationParametersDecodeErrorZ CResult_ChannelDerivationParametersDecodeErrorZ_ok(struct LDKChannelDerivationParameters o);
+ public static native long CResult_ChannelDerivationParametersDecodeErrorZ_ok(long o);
+ // struct LDKCResult_ChannelDerivationParametersDecodeErrorZ CResult_ChannelDerivationParametersDecodeErrorZ_err(struct LDKDecodeError e);
+ public static native long CResult_ChannelDerivationParametersDecodeErrorZ_err(long e);
+ // bool CResult_ChannelDerivationParametersDecodeErrorZ_is_ok(const struct LDKCResult_ChannelDerivationParametersDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_ChannelDerivationParametersDecodeErrorZ_is_ok(long o);
+ // void CResult_ChannelDerivationParametersDecodeErrorZ_free(struct LDKCResult_ChannelDerivationParametersDecodeErrorZ _res);
+ public static native void CResult_ChannelDerivationParametersDecodeErrorZ_free(long _res);
+ // uint64_t CResult_ChannelDerivationParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelDerivationParametersDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_ChannelDerivationParametersDecodeErrorZ_clone_ptr(long arg);
+ // struct LDKCResult_ChannelDerivationParametersDecodeErrorZ CResult_ChannelDerivationParametersDecodeErrorZ_clone(const struct LDKCResult_ChannelDerivationParametersDecodeErrorZ *NONNULL_PTR orig);
+ public static native long CResult_ChannelDerivationParametersDecodeErrorZ_clone(long orig);
+ // struct LDKCResult_HTLCDescriptorDecodeErrorZ CResult_HTLCDescriptorDecodeErrorZ_ok(struct LDKHTLCDescriptor o);
+ public static native long CResult_HTLCDescriptorDecodeErrorZ_ok(long o);
+ // struct LDKCResult_HTLCDescriptorDecodeErrorZ CResult_HTLCDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
+ public static native long CResult_HTLCDescriptorDecodeErrorZ_err(long e);
+ // bool CResult_HTLCDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_HTLCDescriptorDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_HTLCDescriptorDecodeErrorZ_is_ok(long o);
+ // void CResult_HTLCDescriptorDecodeErrorZ_free(struct LDKCResult_HTLCDescriptorDecodeErrorZ _res);
+ public static native void CResult_HTLCDescriptorDecodeErrorZ_free(long _res);
+ // uint64_t CResult_HTLCDescriptorDecodeErrorZ_clone_ptr(LDKCResult_HTLCDescriptorDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_HTLCDescriptorDecodeErrorZ_clone_ptr(long arg);
+ // struct LDKCResult_HTLCDescriptorDecodeErrorZ CResult_HTLCDescriptorDecodeErrorZ_clone(const struct LDKCResult_HTLCDescriptorDecodeErrorZ *NONNULL_PTR orig);
+ public static native long CResult_HTLCDescriptorDecodeErrorZ_clone(long orig);
+ // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_ok(void);
+ public static native long CResult_NoneNoneZ_ok();
+ // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_err(void);
+ public static native long CResult_NoneNoneZ_err();
+ // bool CResult_NoneNoneZ_is_ok(const struct LDKCResult_NoneNoneZ *NONNULL_PTR o);
+ public static native boolean CResult_NoneNoneZ_is_ok(long o);
+ // void CResult_NoneNoneZ_free(struct LDKCResult_NoneNoneZ _res);
+ public static native void CResult_NoneNoneZ_free(long _res);
+ // uint64_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg);
+ public static native long CResult_NoneNoneZ_clone_ptr(long arg);
+ // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_clone(const struct LDKCResult_NoneNoneZ *NONNULL_PTR orig);
+ public static native long CResult_NoneNoneZ_clone(long orig);
+ // struct LDKCResult_PublicKeyNoneZ CResult_PublicKeyNoneZ_ok(struct LDKPublicKey o);
+ public static native long CResult_PublicKeyNoneZ_ok(byte[] o);
+ // struct LDKCResult_PublicKeyNoneZ CResult_PublicKeyNoneZ_err(void);
+ public static native long CResult_PublicKeyNoneZ_err();
+ // bool CResult_PublicKeyNoneZ_is_ok(const struct LDKCResult_PublicKeyNoneZ *NONNULL_PTR o);
+ public static native boolean CResult_PublicKeyNoneZ_is_ok(long o);
+ // void CResult_PublicKeyNoneZ_free(struct LDKCResult_PublicKeyNoneZ _res);
+ public static native void CResult_PublicKeyNoneZ_free(long _res);
+ // uint64_t CResult_PublicKeyNoneZ_clone_ptr(LDKCResult_PublicKeyNoneZ *NONNULL_PTR arg);
+ public static native long CResult_PublicKeyNoneZ_clone_ptr(long arg);
+ // struct LDKCResult_PublicKeyNoneZ CResult_PublicKeyNoneZ_clone(const struct LDKCResult_PublicKeyNoneZ *NONNULL_PTR orig);
+ public static native long CResult_PublicKeyNoneZ_clone(long orig);
+ // struct LDKCOption_BigEndianScalarZ COption_BigEndianScalarZ_some(struct LDKBigEndianScalar o);
+ public static native long COption_BigEndianScalarZ_some(long o);
+ // struct LDKCOption_BigEndianScalarZ COption_BigEndianScalarZ_none(void);
+ public static native long COption_BigEndianScalarZ_none();
+ // void COption_BigEndianScalarZ_free(struct LDKCOption_BigEndianScalarZ _res);
+ public static native void COption_BigEndianScalarZ_free(long _res);
+ // uint64_t COption_BigEndianScalarZ_clone_ptr(LDKCOption_BigEndianScalarZ *NONNULL_PTR arg);
+ public static native long COption_BigEndianScalarZ_clone_ptr(long arg);
+ // struct LDKCOption_BigEndianScalarZ COption_BigEndianScalarZ_clone(const struct LDKCOption_BigEndianScalarZ *NONNULL_PTR orig);
+ public static native long COption_BigEndianScalarZ_clone(long orig);
+ // void CVec_U5Z_free(struct LDKCVec_U5Z _res);
+ public static native void CVec_U5Z_free(byte[] _res);
+ // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_ok(struct LDKRecoverableSignature o);
+ public static native long CResult_RecoverableSignatureNoneZ_ok(byte[] o);
+ // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_err(void);
+ public static native long CResult_RecoverableSignatureNoneZ_err();
+ // bool CResult_RecoverableSignatureNoneZ_is_ok(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR o);
+ public static native boolean CResult_RecoverableSignatureNoneZ_is_ok(long o);
+ // void CResult_RecoverableSignatureNoneZ_free(struct LDKCResult_RecoverableSignatureNoneZ _res);
+ public static native void CResult_RecoverableSignatureNoneZ_free(long _res);
+ // uint64_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg);
+ public static native long CResult_RecoverableSignatureNoneZ_clone_ptr(long arg);
+ // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_clone(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR orig);
+ public static native long CResult_RecoverableSignatureNoneZ_clone(long orig);
+ // struct LDKCResult_SchnorrSignatureNoneZ CResult_SchnorrSignatureNoneZ_ok(struct LDKSchnorrSignature o);
+ public static native long CResult_SchnorrSignatureNoneZ_ok(byte[] o);
+ // struct LDKCResult_SchnorrSignatureNoneZ CResult_SchnorrSignatureNoneZ_err(void);
+ public static native long CResult_SchnorrSignatureNoneZ_err();
+ // bool CResult_SchnorrSignatureNoneZ_is_ok(const struct LDKCResult_SchnorrSignatureNoneZ *NONNULL_PTR o);
+ public static native boolean CResult_SchnorrSignatureNoneZ_is_ok(long o);
+ // void CResult_SchnorrSignatureNoneZ_free(struct LDKCResult_SchnorrSignatureNoneZ _res);
+ public static native void CResult_SchnorrSignatureNoneZ_free(long _res);
+ // uint64_t CResult_SchnorrSignatureNoneZ_clone_ptr(LDKCResult_SchnorrSignatureNoneZ *NONNULL_PTR arg);
+ public static native long CResult_SchnorrSignatureNoneZ_clone_ptr(long arg);
+ // struct LDKCResult_SchnorrSignatureNoneZ CResult_SchnorrSignatureNoneZ_clone(const struct LDKCResult_SchnorrSignatureNoneZ *NONNULL_PTR orig);
+ public static native long CResult_SchnorrSignatureNoneZ_clone(long orig);
+ // struct LDKCResult_ECDSASignatureNoneZ CResult_ECDSASignatureNoneZ_ok(struct LDKECDSASignature o);
+ public static native long CResult_ECDSASignatureNoneZ_ok(byte[] o);
+ // struct LDKCResult_ECDSASignatureNoneZ CResult_ECDSASignatureNoneZ_err(void);
+ public static native long CResult_ECDSASignatureNoneZ_err();
+ // bool CResult_ECDSASignatureNoneZ_is_ok(const struct LDKCResult_ECDSASignatureNoneZ *NONNULL_PTR o);
+ public static native boolean CResult_ECDSASignatureNoneZ_is_ok(long o);
+ // void CResult_ECDSASignatureNoneZ_free(struct LDKCResult_ECDSASignatureNoneZ _res);
+ public static native void CResult_ECDSASignatureNoneZ_free(long _res);
+ // uint64_t CResult_ECDSASignatureNoneZ_clone_ptr(LDKCResult_ECDSASignatureNoneZ *NONNULL_PTR arg);
+ public static native long CResult_ECDSASignatureNoneZ_clone_ptr(long arg);
+ // struct LDKCResult_ECDSASignatureNoneZ CResult_ECDSASignatureNoneZ_clone(const struct LDKCResult_ECDSASignatureNoneZ *NONNULL_PTR orig);
+ public static native long CResult_ECDSASignatureNoneZ_clone(long orig);
+ // struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ CResult_WriteableEcdsaChannelSignerDecodeErrorZ_ok(struct LDKWriteableEcdsaChannelSigner o);
+ public static native long CResult_WriteableEcdsaChannelSignerDecodeErrorZ_ok(long o);
+ // struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ CResult_WriteableEcdsaChannelSignerDecodeErrorZ_err(struct LDKDecodeError e);
+ public static native long CResult_WriteableEcdsaChannelSignerDecodeErrorZ_err(long e);
+ // bool CResult_WriteableEcdsaChannelSignerDecodeErrorZ_is_ok(const struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_WriteableEcdsaChannelSignerDecodeErrorZ_is_ok(long o);
+ // void CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ _res);
+ public static native void CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(long _res);
+ // uint64_t CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr(long arg);
+ // struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(const struct LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR orig);
+ public static native long CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(long orig);
+ // struct LDKCResult_CVec_u8ZNoneZ CResult_CVec_u8ZNoneZ_ok(struct LDKCVec_u8Z o);
+ public static native long CResult_CVec_u8ZNoneZ_ok(byte[] o);
+ // struct LDKCResult_CVec_u8ZNoneZ CResult_CVec_u8ZNoneZ_err(void);
+ public static native long CResult_CVec_u8ZNoneZ_err();
+ // bool CResult_CVec_u8ZNoneZ_is_ok(const struct LDKCResult_CVec_u8ZNoneZ *NONNULL_PTR o);
+ public static native boolean CResult_CVec_u8ZNoneZ_is_ok(long o);
+ // void CResult_CVec_u8ZNoneZ_free(struct LDKCResult_CVec_u8ZNoneZ _res);
+ public static native void CResult_CVec_u8ZNoneZ_free(long _res);
+ // uint64_t CResult_CVec_u8ZNoneZ_clone_ptr(LDKCResult_CVec_u8ZNoneZ *NONNULL_PTR arg);
+ public static native long CResult_CVec_u8ZNoneZ_clone_ptr(long arg);
+ // struct LDKCResult_CVec_u8ZNoneZ CResult_CVec_u8ZNoneZ_clone(const struct LDKCResult_CVec_u8ZNoneZ *NONNULL_PTR orig);
+ public static native long CResult_CVec_u8ZNoneZ_clone(long orig);
+ // struct LDKCResult_ShutdownScriptNoneZ CResult_ShutdownScriptNoneZ_ok(struct LDKShutdownScript o);
+ public static native long CResult_ShutdownScriptNoneZ_ok(long o);
+ // struct LDKCResult_ShutdownScriptNoneZ CResult_ShutdownScriptNoneZ_err(void);
+ public static native long CResult_ShutdownScriptNoneZ_err();
+ // bool CResult_ShutdownScriptNoneZ_is_ok(const struct LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR o);
+ public static native boolean CResult_ShutdownScriptNoneZ_is_ok(long o);
+ // void CResult_ShutdownScriptNoneZ_free(struct LDKCResult_ShutdownScriptNoneZ _res);
+ public static native void CResult_ShutdownScriptNoneZ_free(long _res);
+ // uint64_t CResult_ShutdownScriptNoneZ_clone_ptr(LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR arg);
+ public static native long CResult_ShutdownScriptNoneZ_clone_ptr(long arg);
+ // struct LDKCResult_ShutdownScriptNoneZ CResult_ShutdownScriptNoneZ_clone(const struct LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR orig);
+ public static native long CResult_ShutdownScriptNoneZ_clone(long orig);
+ // struct LDKCOption_u16Z COption_u16Z_some(uint16_t o);
+ public static native long COption_u16Z_some(short o);
+ // struct LDKCOption_u16Z COption_u16Z_none(void);
+ public static native long COption_u16Z_none();
+ // void COption_u16Z_free(struct LDKCOption_u16Z _res);
+ public static native void COption_u16Z_free(long _res);
+ // uint64_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg);
+ public static native long COption_u16Z_clone_ptr(long arg);
+ // struct LDKCOption_u16Z COption_u16Z_clone(const struct LDKCOption_u16Z *NONNULL_PTR orig);
+ public static native long COption_u16Z_clone(long orig);
+ // struct LDKCOption_boolZ COption_boolZ_some(bool o);
+ public static native long COption_boolZ_some(boolean o);
+ // struct LDKCOption_boolZ COption_boolZ_none(void);
+ public static native long COption_boolZ_none();
+ // void COption_boolZ_free(struct LDKCOption_boolZ _res);
+ public static native void COption_boolZ_free(long _res);
+ // uint64_t COption_boolZ_clone_ptr(LDKCOption_boolZ *NONNULL_PTR arg);
+ public static native long COption_boolZ_clone_ptr(long arg);
+ // struct LDKCOption_boolZ COption_boolZ_clone(const struct LDKCOption_boolZ *NONNULL_PTR orig);
+ public static native long COption_boolZ_clone(long orig);
+ // struct LDKCResult_WitnessNoneZ CResult_WitnessNoneZ_ok(struct LDKWitness o);
+ public static native long CResult_WitnessNoneZ_ok(byte[] o);
+ // struct LDKCResult_WitnessNoneZ CResult_WitnessNoneZ_err(void);
+ public static native long CResult_WitnessNoneZ_err();
+ // bool CResult_WitnessNoneZ_is_ok(const struct LDKCResult_WitnessNoneZ *NONNULL_PTR o);
+ public static native boolean CResult_WitnessNoneZ_is_ok(long o);
+ // void CResult_WitnessNoneZ_free(struct LDKCResult_WitnessNoneZ _res);
+ public static native void CResult_WitnessNoneZ_free(long _res);
+ // uint64_t CResult_WitnessNoneZ_clone_ptr(LDKCResult_WitnessNoneZ *NONNULL_PTR arg);
+ public static native long CResult_WitnessNoneZ_clone_ptr(long arg);
+ // struct LDKCResult_WitnessNoneZ CResult_WitnessNoneZ_clone(const struct LDKCResult_WitnessNoneZ *NONNULL_PTR orig);
+ public static native long CResult_WitnessNoneZ_clone(long orig);
+ // void CVec_ECDSASignatureZ_free(struct LDKCVec_ECDSASignatureZ _res);
+ public static native void CVec_ECDSASignatureZ_free(byte[][] _res);
+ // uint64_t C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone_ptr(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ *NONNULL_PTR arg);
+ public static native long C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone_ptr(long arg);
+ // struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone(const struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ *NONNULL_PTR orig);
+ public static native long C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone(long orig);
+ // struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_new(struct LDKECDSASignature a, struct LDKCVec_ECDSASignatureZ b);
+ public static native long C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_new(byte[] a, byte[][] b);
+ // void C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_free(struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ _res);
+ public static native void C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_free(long _res);
+ // struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_ok(struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ o);
+ public static native long CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_ok(long o);
+ // struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_err(void);
+ public static native long CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_err();
+ // bool CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_is_ok(const struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ *NONNULL_PTR o);
+ public static native boolean CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_is_ok(long o);
+ // void CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_free(struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ _res);
+ public static native void CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_free(long _res);
+ // uint64_t CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ *NONNULL_PTR arg);
+ public static native long CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone_ptr(long arg);
+ // struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone(const struct LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ *NONNULL_PTR orig);
+ public static native long CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone(long orig);
+ // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_ok(struct LDKInMemorySigner o);
+ public static native long CResult_InMemorySignerDecodeErrorZ_ok(long o);
+ // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_err(struct LDKDecodeError e);
+ public static native long CResult_InMemorySignerDecodeErrorZ_err(long e);
+ // bool CResult_InMemorySignerDecodeErrorZ_is_ok(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_InMemorySignerDecodeErrorZ_is_ok(long o);
+ // void CResult_InMemorySignerDecodeErrorZ_free(struct LDKCResult_InMemorySignerDecodeErrorZ _res);
+ public static native void CResult_InMemorySignerDecodeErrorZ_free(long _res);
+ // uint64_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_InMemorySignerDecodeErrorZ_clone_ptr(long arg);
+ // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_clone(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR orig);
+ public static native long CResult_InMemorySignerDecodeErrorZ_clone(long orig);
+ // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_ok(struct LDKTransaction o);
+ public static native long CResult_TransactionNoneZ_ok(byte[] o);
+ // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_err(void);
+ public static native long CResult_TransactionNoneZ_err();
+ // bool CResult_TransactionNoneZ_is_ok(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR o);
+ public static native boolean CResult_TransactionNoneZ_is_ok(long o);
+ // void CResult_TransactionNoneZ_free(struct LDKCResult_TransactionNoneZ _res);
+ public static native void CResult_TransactionNoneZ_free(long _res);
+ // uint64_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg);
+ public static native long CResult_TransactionNoneZ_clone_ptr(long arg);
+ // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_clone(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR orig);
+ public static native long CResult_TransactionNoneZ_clone(long orig);
+ // struct LDKCOption_WriteableScoreZ COption_WriteableScoreZ_some(struct LDKWriteableScore o);
+ public static native long COption_WriteableScoreZ_some(long o);
+ // struct LDKCOption_WriteableScoreZ COption_WriteableScoreZ_none(void);
+ public static native long COption_WriteableScoreZ_none();
+ // void COption_WriteableScoreZ_free(struct LDKCOption_WriteableScoreZ _res);
+ public static native void COption_WriteableScoreZ_free(long _res);
+ // struct LDKCResult_NoneIOErrorZ CResult_NoneIOErrorZ_ok(void);
+ public static native long CResult_NoneIOErrorZ_ok();
+ // struct LDKCResult_NoneIOErrorZ CResult_NoneIOErrorZ_err(enum LDKIOError e);
+ public static native long CResult_NoneIOErrorZ_err(IOError e);
+ // bool CResult_NoneIOErrorZ_is_ok(const struct LDKCResult_NoneIOErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_NoneIOErrorZ_is_ok(long o);
+ // void CResult_NoneIOErrorZ_free(struct LDKCResult_NoneIOErrorZ _res);
+ public static native void CResult_NoneIOErrorZ_free(long _res);
+ // uint64_t CResult_NoneIOErrorZ_clone_ptr(LDKCResult_NoneIOErrorZ *NONNULL_PTR arg);
+ public static native long CResult_NoneIOErrorZ_clone_ptr(long arg);
+ // struct LDKCResult_NoneIOErrorZ CResult_NoneIOErrorZ_clone(const struct LDKCResult_NoneIOErrorZ *NONNULL_PTR orig);
+ public static native long CResult_NoneIOErrorZ_clone(long orig);
+ // void CVec_ChannelDetailsZ_free(struct LDKCVec_ChannelDetailsZ _res);
+ public static native void CVec_ChannelDetailsZ_free(long[] _res);
+ // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_ok(struct LDKRoute o);
+ public static native long CResult_RouteLightningErrorZ_ok(long o);
+ // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_err(struct LDKLightningError e);
+ public static native long CResult_RouteLightningErrorZ_err(long e);
+ // bool CResult_RouteLightningErrorZ_is_ok(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_RouteLightningErrorZ_is_ok(long o);
+ // void CResult_RouteLightningErrorZ_free(struct LDKCResult_RouteLightningErrorZ _res);
+ public static native void CResult_RouteLightningErrorZ_free(long _res);
+ // uint64_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg);
+ public static native long CResult_RouteLightningErrorZ_clone_ptr(long arg);
+ // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_clone(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR orig);
+ public static native long CResult_RouteLightningErrorZ_clone(long orig);
+ // uint64_t C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr(LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR arg);
+ public static native long C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr(long arg);
+ // struct LDKC2Tuple_BlindedPayInfoBlindedPathZ C2Tuple_BlindedPayInfoBlindedPathZ_clone(const struct LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR orig);
+ public static native long C2Tuple_BlindedPayInfoBlindedPathZ_clone(long orig);
+ // struct LDKC2Tuple_BlindedPayInfoBlindedPathZ C2Tuple_BlindedPayInfoBlindedPathZ_new(struct LDKBlindedPayInfo a, struct LDKBlindedPath b);
+ public static native long C2Tuple_BlindedPayInfoBlindedPathZ_new(long a, long b);
+ // void C2Tuple_BlindedPayInfoBlindedPathZ_free(struct LDKC2Tuple_BlindedPayInfoBlindedPathZ _res);
+ public static native void C2Tuple_BlindedPayInfoBlindedPathZ_free(long _res);
+ // void CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(struct LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ _res);
+ public static native void CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(long[] _res);
+ // struct LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_ok(struct LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ o);
+ public static native long CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_ok(long[] o);
+ // struct LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_err(void);
+ public static native long CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_err();
+ // bool CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_is_ok(const struct LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ *NONNULL_PTR o);
+ public static native boolean CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_is_ok(long o);
+ // void CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_free(struct LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ _res);
+ public static native void CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_free(long _res);
+ // uint64_t CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_clone_ptr(LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ *NONNULL_PTR arg);
+ public static native long CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_clone_ptr(long arg);
+ // struct LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_clone(const struct LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ *NONNULL_PTR orig);
+ public static native long CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_clone(long orig);
+ // void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
+ public static native void CVec_PublicKeyZ_free(byte[][] _res);
+ // struct LDKCResult_OnionMessagePathNoneZ CResult_OnionMessagePathNoneZ_ok(struct LDKOnionMessagePath o);
+ public static native long CResult_OnionMessagePathNoneZ_ok(long o);
+ // struct LDKCResult_OnionMessagePathNoneZ CResult_OnionMessagePathNoneZ_err(void);
+ public static native long CResult_OnionMessagePathNoneZ_err();
+ // bool CResult_OnionMessagePathNoneZ_is_ok(const struct LDKCResult_OnionMessagePathNoneZ *NONNULL_PTR o);
+ public static native boolean CResult_OnionMessagePathNoneZ_is_ok(long o);
+ // void CResult_OnionMessagePathNoneZ_free(struct LDKCResult_OnionMessagePathNoneZ _res);
+ public static native void CResult_OnionMessagePathNoneZ_free(long _res);
+ // uint64_t CResult_OnionMessagePathNoneZ_clone_ptr(LDKCResult_OnionMessagePathNoneZ *NONNULL_PTR arg);
+ public static native long CResult_OnionMessagePathNoneZ_clone_ptr(long arg);
+ // struct LDKCResult_OnionMessagePathNoneZ CResult_OnionMessagePathNoneZ_clone(const struct LDKCResult_OnionMessagePathNoneZ *NONNULL_PTR orig);
+ public static native long CResult_OnionMessagePathNoneZ_clone(long orig);
+ // struct LDKCResult_CVec_BlindedPathZNoneZ CResult_CVec_BlindedPathZNoneZ_ok(struct LDKCVec_BlindedPathZ o);
+ public static native long CResult_CVec_BlindedPathZNoneZ_ok(long[] o);
+ // struct LDKCResult_CVec_BlindedPathZNoneZ CResult_CVec_BlindedPathZNoneZ_err(void);
+ public static native long CResult_CVec_BlindedPathZNoneZ_err();
+ // bool CResult_CVec_BlindedPathZNoneZ_is_ok(const struct LDKCResult_CVec_BlindedPathZNoneZ *NONNULL_PTR o);
+ public static native boolean CResult_CVec_BlindedPathZNoneZ_is_ok(long o);
+ // void CResult_CVec_BlindedPathZNoneZ_free(struct LDKCResult_CVec_BlindedPathZNoneZ _res);
+ public static native void CResult_CVec_BlindedPathZNoneZ_free(long _res);
+ // uint64_t CResult_CVec_BlindedPathZNoneZ_clone_ptr(LDKCResult_CVec_BlindedPathZNoneZ *NONNULL_PTR arg);
+ public static native long CResult_CVec_BlindedPathZNoneZ_clone_ptr(long arg);
+ // struct LDKCResult_CVec_BlindedPathZNoneZ CResult_CVec_BlindedPathZNoneZ_clone(const struct LDKCResult_CVec_BlindedPathZNoneZ *NONNULL_PTR orig);
+ public static native long CResult_CVec_BlindedPathZNoneZ_clone(long orig);
+ // struct LDKCResult_InFlightHtlcsDecodeErrorZ CResult_InFlightHtlcsDecodeErrorZ_ok(struct LDKInFlightHtlcs o);
+ public static native long CResult_InFlightHtlcsDecodeErrorZ_ok(long o);
+ // struct LDKCResult_InFlightHtlcsDecodeErrorZ CResult_InFlightHtlcsDecodeErrorZ_err(struct LDKDecodeError e);
+ public static native long CResult_InFlightHtlcsDecodeErrorZ_err(long e);
+ // bool CResult_InFlightHtlcsDecodeErrorZ_is_ok(const struct LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR o);
+ public static native boolean CResult_InFlightHtlcsDecodeErrorZ_is_ok(long o);
+ // void CResult_InFlightHtlcsDecodeErrorZ_free(struct LDKCResult_InFlightHtlcsDecodeErrorZ _res);
+ public static native void CResult_InFlightHtlcsDecodeErrorZ_free(long _res);
+ // uint64_t CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR arg);
+ public static native long CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(long arg);
+ // struct LDKCResult_InFlightHtlcsDecodeErrorZ CResult_InFlightHtlcsDecodeErrorZ_clone(const struct LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR orig);
+ public static native long CResult_InFlightHtlcsDecodeErrorZ_clone(long orig);