lightningdevkit/structs/OffersMessage.mjs

Lightning Development Kit

import { Bolt12Invoice } from '../structs/Bolt12Invoice.mjs';
import { InvoiceRequest } from '../structs/InvoiceRequest.mjs';
import { InvoiceError } from '../structs/InvoiceError.mjs';
import { OnionMessageContents } from '../structs/OnionMessageContents.mjs';
import { Result_OffersMessageDecodeErrorZ } from '../structs/Result_OffersMessageDecodeErrorZ.mjs';
import { CommonBase } from './CommonBase.mjs';
import * as bindings from '../bindings.mjs';
/**
 * Possible BOLT 12 Offers messages sent and received via an [`OnionMessage`].
 *
 * [`OnionMessage`]: crate::ln::msgs::OnionMessage
 */
export class OffersMessage extends CommonBase {
    constructor(_dummy, ptr) { super(ptr, bindings.OffersMessage_free); }
    /* @internal */
    static constr_from_ptr(ptr) {
        const raw_ty = bindings.LDKOffersMessage_ty_from_ptr(ptr);
        switch (raw_ty) {
            case 0: return new OffersMessage_InvoiceRequest(ptr);
            case 1: return new OffersMessage_Invoice(ptr);
            case 2: return new OffersMessage_InvoiceError(ptr);
            default:
                throw new Error('oops, this should be unreachable'); // Unreachable without extending the (internal) bindings interface
        }
    }
    clone_ptr() {
        const ret = bindings.OffersMessage_clone_ptr(this.ptr);
        return ret;
    }
    /**
     * Creates a copy of the OffersMessage
     */
    clone() {
        const ret = bindings.OffersMessage_clone(this.ptr);
        const ret_hu_conv = OffersMessage.constr_from_ptr(ret);
        CommonBase.add_ref_from(ret_hu_conv, this);
        return ret_hu_conv;
    }
    /**
     * Utility method to constructs a new InvoiceRequest-variant OffersMessage
     */
    static constructor_invoice_request(a) {
        const ret = bindings.OffersMessage_invoice_request(CommonBase.get_ptr_of(a));
        const ret_hu_conv = OffersMessage.constr_from_ptr(ret);
        CommonBase.add_ref_from(ret_hu_conv, ret_hu_conv);
        return ret_hu_conv;
    }
    /**
     * Utility method to constructs a new Invoice-variant OffersMessage
     */
    static constructor_invoice(a) {
        const ret = bindings.OffersMessage_invoice(CommonBase.get_ptr_of(a));
        const ret_hu_conv = OffersMessage.constr_from_ptr(ret);
        CommonBase.add_ref_from(ret_hu_conv, ret_hu_conv);
        return ret_hu_conv;
    }
    /**
     * Utility method to constructs a new InvoiceError-variant OffersMessage
     */
    static constructor_invoice_error(a) {
        const ret = bindings.OffersMessage_invoice_error(CommonBase.get_ptr_of(a));
        const ret_hu_conv = OffersMessage.constr_from_ptr(ret);
        CommonBase.add_ref_from(ret_hu_conv, ret_hu_conv);
        return ret_hu_conv;
    }
    /**
     * Constructs a new OnionMessageContents which calls the relevant methods on this_arg.
     * This copies the `inner` pointer in this_arg and thus the returned OnionMessageContents must be freed before this_arg is
     */
    as_OnionMessageContents() {
        const ret = bindings.OffersMessage_as_OnionMessageContents(this.ptr);
        const ret_hu_conv = new OnionMessageContents(null, ret);
        CommonBase.add_ref_from(ret_hu_conv, this);
        return ret_hu_conv;
    }
    /**
     * Serialize the OffersMessage object into a byte array which can be read by OffersMessage_read
     */
    write() {
        const ret = bindings.OffersMessage_write(this.ptr);
        const ret_conv = bindings.decodeUint8Array(ret);
        return ret_conv;
    }
    /**
     * Read a OffersMessage from a byte array, created by OffersMessage_write
     */
    static constructor_read(ser, arg_a, arg_b) {
        const ret = bindings.OffersMessage_read(bindings.encodeUint8Array(ser), arg_a, CommonBase.get_ptr_of(arg_b));
        const ret_hu_conv = Result_OffersMessageDecodeErrorZ.constr_from_ptr(ret);
        CommonBase.add_ref_from(ret_hu_conv, arg_b);
        return ret_hu_conv;
    }
}
/** A OffersMessage of type InvoiceRequest */
export class OffersMessage_InvoiceRequest extends OffersMessage {
    /* @internal */
    constructor(ptr) {
        super(null, ptr);
        const invoice_request = bindings.LDKOffersMessage_InvoiceRequest_get_invoice_request(ptr);
        const invoice_request_hu_conv = new InvoiceRequest(null, invoice_request);
        CommonBase.add_ref_from(invoice_request_hu_conv, this);
        this.invoice_request = invoice_request_hu_conv;
    }
}
/** A OffersMessage of type Invoice */
export class OffersMessage_Invoice extends OffersMessage {
    /* @internal */
    constructor(ptr) {
        super(null, ptr);
        const invoice = bindings.LDKOffersMessage_Invoice_get_invoice(ptr);
        const invoice_hu_conv = new Bolt12Invoice(null, invoice);
        CommonBase.add_ref_from(invoice_hu_conv, this);
        this.invoice = invoice_hu_conv;
    }
}
/** A OffersMessage of type InvoiceError */
export class OffersMessage_InvoiceError extends OffersMessage {
    /* @internal */
    constructor(ptr) {
        super(null, ptr);
        const invoice_error = bindings.LDKOffersMessage_InvoiceError_get_invoice_error(ptr);
        const invoice_error_hu_conv = new InvoiceError(null, invoice_error);
        CommonBase.add_ref_from(invoice_error_hu_conv, this);
        this.invoice_error = invoice_error_hu_conv;
    }
}
//# sourceMappingURL=OffersMessage.mjs.map