X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=c_sharp%2Fsrc%2Forg%2Fldk%2Fstructs%2FBolt12Invoice.cs;h=e498a962a10bf29f8dd5a2aeda3d8dcd6d79e846;hb=152d721883552dd92925833d15687d7d64d01c35;hp=85311e31607feb4f03b7ebb68ed457e75aa09e86;hpb=7811d2191440c55034e1abfbf3be442d4b25481b;p=ldk-java diff --git a/c_sharp/src/org/ldk/structs/Bolt12Invoice.cs b/c_sharp/src/org/ldk/structs/Bolt12Invoice.cs index 85311e31..e498a962 100644 --- a/c_sharp/src/org/ldk/structs/Bolt12Invoice.cs +++ b/c_sharp/src/org/ldk/structs/Bolt12Invoice.cs @@ -41,8 +41,102 @@ public class Bolt12Invoice : CommonBase { } /** - * A complete description of the purpose of the originating offer or refund. Intended to be - * displayed to the user but with the caveat that it has not been verified in any way. + * The chains that may be used when paying a requested invoice. + * + * From [`Offer::chains`]; `None` if the invoice was created in response to a [`Refund`]. + * + * [`Offer::chains`]: crate::offers::offer::Offer::chains + */ + public Option_CVec_ThirtyTwoBytesZZ offer_chains() { + long ret = bindings.Bolt12Invoice_offer_chains(this.ptr); + GC.KeepAlive(this); + if (ret >= 0 && ret <= 4096) { return null; } + org.ldk.structs.Option_CVec_ThirtyTwoBytesZZ ret_hu_conv = org.ldk.structs.Option_CVec_ThirtyTwoBytesZZ.constr_from_ptr(ret); + if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(this); }; + return ret_hu_conv; + } + + /** + * The chain that must be used when paying the invoice; selected from [`offer_chains`] if the + * invoice originated from an offer. + * + * From [`InvoiceRequest::chain`] or [`Refund::chain`]. + * + * [`offer_chains`]: Self::offer_chains + * [`InvoiceRequest::chain`]: crate::offers::invoice_request::InvoiceRequest::chain + */ + public byte[] chain() { + long ret = bindings.Bolt12Invoice_chain(this.ptr); + GC.KeepAlive(this); + if (ret >= 0 && ret <= 4096) { return null; } + byte[] ret_conv = InternalUtils.decodeUint8Array(ret); + return ret_conv; + } + + /** + * Opaque bytes set by the originating [`Offer`]. + * + * From [`Offer::metadata`]; `None` if the invoice was created in response to a [`Refund`] or + * if the [`Offer`] did not set it. + * + * [`Offer`]: crate::offers::offer::Offer + * [`Offer::metadata`]: crate::offers::offer::Offer::metadata + */ + public Option_CVec_u8ZZ metadata() { + long ret = bindings.Bolt12Invoice_metadata(this.ptr); + GC.KeepAlive(this); + if (ret >= 0 && ret <= 4096) { return null; } + org.ldk.structs.Option_CVec_u8ZZ ret_hu_conv = org.ldk.structs.Option_CVec_u8ZZ.constr_from_ptr(ret); + if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(this); }; + return ret_hu_conv; + } + + /** + * The minimum amount required for a successful payment of a single item. + * + * From [`Offer::amount`]; `None` if the invoice was created in response to a [`Refund`] or if + * the [`Offer`] did not set it. + * + * [`Offer`]: crate::offers::offer::Offer + * [`Offer::amount`]: crate::offers::offer::Offer::amount + */ + public Option_AmountZ amount() { + long ret = bindings.Bolt12Invoice_amount(this.ptr); + GC.KeepAlive(this); + if (ret >= 0 && ret <= 4096) { return null; } + org.ldk.structs.Option_AmountZ ret_hu_conv = org.ldk.structs.Option_AmountZ.constr_from_ptr(ret); + if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(this); }; + return ret_hu_conv; + } + + /** + * Features pertaining to the originating [`Offer`]. + * + * From [`Offer::offer_features`]; `None` if the invoice was created in response to a + * [`Refund`]. + * + * [`Offer`]: crate::offers::offer::Offer + * [`Offer::offer_features`]: crate::offers::offer::Offer::offer_features + * + * Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None + */ + public OfferFeatures offer_features() { + long ret = bindings.Bolt12Invoice_offer_features(this.ptr); + GC.KeepAlive(this); + if (ret >= 0 && ret <= 4096) { return null; } + org.ldk.structs.OfferFeatures ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.OfferFeatures(null, ret); } + if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(this); }; + return ret_hu_conv; + } + + /** + * A complete description of the purpose of the originating offer or refund. + * + * From [`Offer::description`] or [`Refund::description`]. + * + * [`Offer::description`]: crate::offers::offer::Offer::description + * + * Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None */ public PrintableString description() { long ret = bindings.Bolt12Invoice_description(this.ptr); @@ -53,6 +147,151 @@ public class Bolt12Invoice : CommonBase { return ret_hu_conv; } + /** + * Duration since the Unix epoch when an invoice should no longer be requested. + * + * From [`Offer::absolute_expiry`] or [`Refund::absolute_expiry`]. + * + * [`Offer::absolute_expiry`]: crate::offers::offer::Offer::absolute_expiry + */ + public Option_u64Z absolute_expiry() { + long ret = bindings.Bolt12Invoice_absolute_expiry(this.ptr); + GC.KeepAlive(this); + if (ret >= 0 && ret <= 4096) { return null; } + org.ldk.structs.Option_u64Z ret_hu_conv = org.ldk.structs.Option_u64Z.constr_from_ptr(ret); + if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(this); }; + return ret_hu_conv; + } + + /** + * The issuer of the offer or refund. + * + * From [`Offer::issuer`] or [`Refund::issuer`]. + * + * [`Offer::issuer`]: crate::offers::offer::Offer::issuer + * + * Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None + */ + public PrintableString issuer() { + long ret = bindings.Bolt12Invoice_issuer(this.ptr); + GC.KeepAlive(this); + if (ret >= 0 && ret <= 4096) { return null; } + org.ldk.structs.PrintableString ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.PrintableString(null, ret); } + if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(this); }; + return ret_hu_conv; + } + + /** + * Paths to the recipient originating from publicly reachable nodes. + * + * From [`Offer::paths`] or [`Refund::paths`]. + * + * [`Offer::paths`]: crate::offers::offer::Offer::paths + */ + public BlindedPath[] message_paths() { + long ret = bindings.Bolt12Invoice_message_paths(this.ptr); + GC.KeepAlive(this); + if (ret >= 0 && ret <= 4096) { return null; } + int ret_conv_13_len = InternalUtils.getArrayLength(ret); + BlindedPath[] ret_conv_13_arr = new BlindedPath[ret_conv_13_len]; + for (int n = 0; n < ret_conv_13_len; n++) { + long ret_conv_13 = InternalUtils.getU64ArrayElem(ret, n); + org.ldk.structs.BlindedPath ret_conv_13_hu_conv = null; if (ret_conv_13 < 0 || ret_conv_13 > 4096) { ret_conv_13_hu_conv = new org.ldk.structs.BlindedPath(null, ret_conv_13); } + if (ret_conv_13_hu_conv != null) { ret_conv_13_hu_conv.ptrs_to.AddLast(this); }; + ret_conv_13_arr[n] = ret_conv_13_hu_conv; + } + bindings.free_buffer(ret); + return ret_conv_13_arr; + } + + /** + * The quantity of items supported. + * + * From [`Offer::supported_quantity`]; `None` if the invoice was created in response to a + * [`Refund`]. + * + * [`Offer::supported_quantity`]: crate::offers::offer::Offer::supported_quantity + */ + public Option_QuantityZ supported_quantity() { + long ret = bindings.Bolt12Invoice_supported_quantity(this.ptr); + GC.KeepAlive(this); + if (ret >= 0 && ret <= 4096) { return null; } + org.ldk.structs.Option_QuantityZ ret_hu_conv = org.ldk.structs.Option_QuantityZ.constr_from_ptr(ret); + if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(this); }; + return ret_hu_conv; + } + + /** + * An unpredictable series of bytes from the payer. + * + * From [`InvoiceRequest::payer_metadata`] or [`Refund::payer_metadata`]. + */ + public byte[] payer_metadata() { + long ret = bindings.Bolt12Invoice_payer_metadata(this.ptr); + GC.KeepAlive(this); + if (ret >= 0 && ret <= 4096) { return null; } + byte[] ret_conv = InternalUtils.decodeUint8Array(ret); + return ret_conv; + } + + /** + * Features pertaining to requesting an invoice. + * + * From [`InvoiceRequest::invoice_request_features`] or [`Refund::features`]. + */ + public InvoiceRequestFeatures invoice_request_features() { + long ret = bindings.Bolt12Invoice_invoice_request_features(this.ptr); + GC.KeepAlive(this); + if (ret >= 0 && ret <= 4096) { return null; } + org.ldk.structs.InvoiceRequestFeatures ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.InvoiceRequestFeatures(null, ret); } + if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(this); }; + return ret_hu_conv; + } + + /** + * The quantity of items requested or refunded for. + * + * From [`InvoiceRequest::quantity`] or [`Refund::quantity`]. + */ + public Option_u64Z quantity() { + long ret = bindings.Bolt12Invoice_quantity(this.ptr); + GC.KeepAlive(this); + if (ret >= 0 && ret <= 4096) { return null; } + org.ldk.structs.Option_u64Z ret_hu_conv = org.ldk.structs.Option_u64Z.constr_from_ptr(ret); + if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(this); }; + return ret_hu_conv; + } + + /** + * A possibly transient pubkey used to sign the invoice request or to send an invoice for a + * refund in case there are no [`message_paths`]. + * + * [`message_paths`]: Self::message_paths + */ + public byte[] payer_id() { + long ret = bindings.Bolt12Invoice_payer_id(this.ptr); + GC.KeepAlive(this); + if (ret >= 0 && ret <= 4096) { return null; } + byte[] ret_conv = InternalUtils.decodeUint8Array(ret); + return ret_conv; + } + + /** + * A payer-provided note reflected back in the invoice. + * + * From [`InvoiceRequest::payer_note`] or [`Refund::payer_note`]. + * + * Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None + */ + public PrintableString payer_note() { + long ret = bindings.Bolt12Invoice_payer_note(this.ptr); + GC.KeepAlive(this); + if (ret >= 0 && ret <= 4096) { return null; } + org.ldk.structs.PrintableString ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.PrintableString(null, ret); } + if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(this); }; + return ret_hu_conv; + } + /** * Duration since the Unix epoch when the invoice was created. */ @@ -85,9 +324,11 @@ public class Bolt12Invoice : CommonBase { * SHA256 hash of the payment preimage that will be given in return for paying the invoice. */ public byte[] payment_hash() { - byte[] ret = bindings.Bolt12Invoice_payment_hash(this.ptr); + long ret = bindings.Bolt12Invoice_payment_hash(this.ptr); GC.KeepAlive(this); - return ret; + if (ret >= 0 && ret <= 4096) { return null; } + byte[] ret_conv = InternalUtils.decodeUint8Array(ret); + return ret_conv; } /** @@ -102,8 +343,8 @@ public class Bolt12Invoice : CommonBase { /** * Features pertaining to paying an invoice. */ - public Bolt12InvoiceFeatures features() { - long ret = bindings.Bolt12Invoice_features(this.ptr); + public Bolt12InvoiceFeatures invoice_features() { + long ret = bindings.Bolt12Invoice_invoice_features(this.ptr); GC.KeepAlive(this); if (ret >= 0 && ret <= 4096) { return null; } org.ldk.structs.Bolt12InvoiceFeatures ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.Bolt12InvoiceFeatures(null, ret); } @@ -115,38 +356,70 @@ public class Bolt12Invoice : CommonBase { * The public key corresponding to the key used to sign the invoice. */ public byte[] signing_pubkey() { - byte[] ret = bindings.Bolt12Invoice_signing_pubkey(this.ptr); + long ret = bindings.Bolt12Invoice_signing_pubkey(this.ptr); GC.KeepAlive(this); - return ret; + if (ret >= 0 && ret <= 4096) { return null; } + byte[] ret_conv = InternalUtils.decodeUint8Array(ret); + return ret_conv; + } + + /** + * Signature of the invoice verified using [`Bolt12Invoice::signing_pubkey`]. + */ + public byte[] signature() { + long ret = bindings.Bolt12Invoice_signature(this.ptr); + GC.KeepAlive(this); + if (ret >= 0 && ret <= 4096) { return null; } + byte[] ret_conv = InternalUtils.decodeUint8Array(ret); + return ret_conv; } /** * Hash that was used for signing the invoice. */ public byte[] signable_hash() { - byte[] ret = bindings.Bolt12Invoice_signable_hash(this.ptr); + long ret = bindings.Bolt12Invoice_signable_hash(this.ptr); GC.KeepAlive(this); - return ret; + if (ret >= 0 && ret <= 4096) { return null; } + byte[] ret_conv = InternalUtils.decodeUint8Array(ret); + return ret_conv; } /** - * Verifies that the invoice was for a request or refund created using the given key. + * Verifies that the invoice was for a request or refund created using the given key. Returns + * the associated [`PaymentId`] to use when sending the payment. */ - public bool verify(org.ldk.structs.ExpandedKey key) { - bool ret = bindings.Bolt12Invoice_verify(this.ptr, key == null ? 0 : key.ptr); + public Result_ThirtyTwoBytesNoneZ verify(org.ldk.structs.ExpandedKey key) { + long ret = bindings.Bolt12Invoice_verify(this.ptr, key.ptr); GC.KeepAlive(this); GC.KeepAlive(key); + if (ret >= 0 && ret <= 4096) { return null; } + Result_ThirtyTwoBytesNoneZ ret_hu_conv = Result_ThirtyTwoBytesNoneZ.constr_from_ptr(ret); if (this != null) { this.ptrs_to.AddLast(key); }; + return ret_hu_conv; + } + + /** + * Generates a non-cryptographic 64-bit hash of the Bolt12Invoice. + */ + public long hash() { + long ret = bindings.Bolt12Invoice_hash(this.ptr); + GC.KeepAlive(this); return ret; } + public override int GetHashCode() { + return (int)this.hash(); + } /** * Serialize the Bolt12Invoice object into a byte array which can be read by Bolt12Invoice_read */ public byte[] write() { - byte[] ret = bindings.Bolt12Invoice_write(this.ptr); + long ret = bindings.Bolt12Invoice_write(this.ptr); GC.KeepAlive(this); - return ret; + if (ret >= 0 && ret <= 4096) { return null; } + byte[] ret_conv = InternalUtils.decodeUint8Array(ret); + return ret_conv; } }