lightningdevkit/structs/DNSResolverMessage.mjs

Lightning Development Kit

import { DNSSECQuery } from '../structs/DNSSECQuery.mjs';
import { DNSSECProof } from '../structs/DNSSECProof.mjs';
import { Result_DNSResolverMessageDecodeErrorZ } from '../structs/Result_DNSResolverMessageDecodeErrorZ.mjs';
import { OnionMessageContents } from '../structs/OnionMessageContents.mjs';
import { CommonBase } from './CommonBase.mjs';
import * as bindings from '../bindings.mjs';
/**
 * An enum containing the possible onion messages which are used uses to request and receive
 * DNSSEC proofs.
 */
export class DNSResolverMessage extends CommonBase {
    constructor(_dummy, ptr) { super(ptr, bindings.DNSResolverMessage_free); }
    /* @internal */
    static constr_from_ptr(ptr) {
        const raw_ty = bindings.LDKDNSResolverMessage_ty_from_ptr(ptr);
        switch (raw_ty) {
            case 0: return new DNSResolverMessage_DNSSECQuery(ptr);
            case 1: return new DNSResolverMessage_DNSSECProof(ptr);
            default:
                throw new Error('oops, this should be unreachable'); // Unreachable without extending the (internal) bindings interface
        }
    }
    clone_ptr() {
        const ret = bindings.DNSResolverMessage_clone_ptr(this.ptr);
        return ret;
    }
    /**
     * Creates a copy of the DNSResolverMessage
     */
    clone() {
        const ret = bindings.DNSResolverMessage_clone(this.ptr);
        const ret_hu_conv = DNSResolverMessage.constr_from_ptr(ret);
        CommonBase.add_ref_from(ret_hu_conv, this);
        return ret_hu_conv;
    }
    /**
     * Utility method to constructs a new DNSSECQuery-variant DNSResolverMessage
     */
    static constructor_dnssecquery(a) {
        const ret = bindings.DNSResolverMessage_dnssecquery(CommonBase.get_ptr_of(a));
        const ret_hu_conv = DNSResolverMessage.constr_from_ptr(ret);
        CommonBase.add_ref_from(ret_hu_conv, ret_hu_conv);
        return ret_hu_conv;
    }
    /**
     * Utility method to constructs a new DNSSECProof-variant DNSResolverMessage
     */
    static constructor_dnssecproof(a) {
        const ret = bindings.DNSResolverMessage_dnssecproof(CommonBase.get_ptr_of(a));
        const ret_hu_conv = DNSResolverMessage.constr_from_ptr(ret);
        CommonBase.add_ref_from(ret_hu_conv, ret_hu_conv);
        return ret_hu_conv;
    }
    /**
     * Generates a non-cryptographic 64-bit hash of the DNSResolverMessage.
     */
    hash() {
        const ret = bindings.DNSResolverMessage_hash(this.ptr);
        return ret;
    }
    /**
     * Checks if two DNSResolverMessages contain equal inner contents.
     * This ignores pointers and is_owned flags and looks at the values in fields.
     */
    eq(b) {
        const ret = bindings.DNSResolverMessage_eq(this.ptr, CommonBase.get_ptr_of(b));
        return ret;
    }
    /**
     * Serialize the DNSResolverMessage object into a byte array which can be read by DNSResolverMessage_read
     */
    write() {
        const ret = bindings.DNSResolverMessage_write(this.ptr);
        const ret_conv = bindings.decodeUint8Array(ret);
        return ret_conv;
    }
    /**
     * Read a DNSResolverMessage from a byte array, created by DNSResolverMessage_write
     */
    static constructor_read(ser, arg) {
        const ret = bindings.DNSResolverMessage_read(bindings.encodeUint8Array(ser), arg);
        const ret_hu_conv = Result_DNSResolverMessageDecodeErrorZ.constr_from_ptr(ret);
        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.DNSResolverMessage_as_OnionMessageContents(this.ptr);
        const ret_hu_conv = new OnionMessageContents(null, ret);
        CommonBase.add_ref_from(ret_hu_conv, this);
        return ret_hu_conv;
    }
}
/** A DNSResolverMessage of type DNSSECQuery */
export class DNSResolverMessage_DNSSECQuery extends DNSResolverMessage {
    /* @internal */
    constructor(ptr) {
        super(null, ptr);
        const dnssec_query = bindings.LDKDNSResolverMessage_DNSSECQuery_get_dnssec_query(ptr);
        const dnssec_query_hu_conv = new DNSSECQuery(null, dnssec_query);
        CommonBase.add_ref_from(dnssec_query_hu_conv, this);
        this.dnssec_query = dnssec_query_hu_conv;
    }
}
/** A DNSResolverMessage of type DNSSECProof */
export class DNSResolverMessage_DNSSECProof extends DNSResolverMessage {
    /* @internal */
    constructor(ptr) {
        super(null, ptr);
        const dnssec_proof = bindings.LDKDNSResolverMessage_DNSSECProof_get_dnssec_proof(ptr);
        const dnssec_proof_hu_conv = new DNSSECProof(null, dnssec_proof);
        CommonBase.add_ref_from(dnssec_proof_hu_conv, this);
        this.dnssec_proof = dnssec_proof_hu_conv;
    }
}
//# sourceMappingURL=DNSResolverMessage.mjs.map