wip

proto/lnd/invoices.client.ts

@@ -0,0 +1,119 @@
+// @generated by protobuf-ts 2.5.0 with parameter long_type_string
+// @generated from protobuf file "invoices.proto" (package "invoicesrpc", syntax proto3)
+// tslint:disable
+import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
+import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
+import { Invoices } from "./invoices";
+import type { SettleInvoiceResp } from "./invoices";
+import type { SettleInvoiceMsg } from "./invoices";
+import type { AddHoldInvoiceResp } from "./invoices";
+import type { AddHoldInvoiceRequest } from "./invoices";
+import type { CancelInvoiceResp } from "./invoices";
+import type { CancelInvoiceMsg } from "./invoices";
+import type { UnaryCall } from "@protobuf-ts/runtime-rpc";
+import { stackIntercept } from "@protobuf-ts/runtime-rpc";
+import type { Invoice } from "./rpc";
+import type { SubscribeSingleInvoiceRequest } from "./invoices";
+import type { ServerStreamingCall } from "@protobuf-ts/runtime-rpc";
+import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
+/**
+ * Invoices is a service that can be used to create, accept, settle and cancel
+ * invoices.
+ *
+ * @generated from protobuf service invoicesrpc.Invoices
+ */
+export interface IInvoicesClient {
+    /**
+     *
+     * SubscribeSingleInvoice returns a uni-directional stream (server -> client)
+     * to notify the client of state transitions of the specified invoice.
+     * Initially the current invoice state is always sent out.
+     *
+     * @generated from protobuf rpc: SubscribeSingleInvoice(invoicesrpc.SubscribeSingleInvoiceRequest) returns (stream lnrpc.Invoice);
+     */
+    subscribeSingleInvoice(input: SubscribeSingleInvoiceRequest, options?: RpcOptions): ServerStreamingCall<SubscribeSingleInvoiceRequest, Invoice>;
+    /**
+     *
+     * CancelInvoice cancels a currently open invoice. If the invoice is already
+     * canceled, this call will succeed. If the invoice is already settled, it will
+     * fail.
+     *
+     * @generated from protobuf rpc: CancelInvoice(invoicesrpc.CancelInvoiceMsg) returns (invoicesrpc.CancelInvoiceResp);
+     */
+    cancelInvoice(input: CancelInvoiceMsg, options?: RpcOptions): UnaryCall<CancelInvoiceMsg, CancelInvoiceResp>;
+    /**
+     *
+     * AddHoldInvoice creates a hold invoice. It ties the invoice to the hash
+     * supplied in the request.
+     *
+     * @generated from protobuf rpc: AddHoldInvoice(invoicesrpc.AddHoldInvoiceRequest) returns (invoicesrpc.AddHoldInvoiceResp);
+     */
+    addHoldInvoice(input: AddHoldInvoiceRequest, options?: RpcOptions): UnaryCall<AddHoldInvoiceRequest, AddHoldInvoiceResp>;
+    /**
+     *
+     * SettleInvoice settles an accepted invoice. If the invoice is already
+     * settled, this call will succeed.
+     *
+     * @generated from protobuf rpc: SettleInvoice(invoicesrpc.SettleInvoiceMsg) returns (invoicesrpc.SettleInvoiceResp);
+     */
+    settleInvoice(input: SettleInvoiceMsg, options?: RpcOptions): UnaryCall<SettleInvoiceMsg, SettleInvoiceResp>;
+}
+/**
+ * Invoices is a service that can be used to create, accept, settle and cancel
+ * invoices.
+ *
+ * @generated from protobuf service invoicesrpc.Invoices
+ */
+export class InvoicesClient implements IInvoicesClient, ServiceInfo {
+    typeName = Invoices.typeName;
+    methods = Invoices.methods;
+    options = Invoices.options;
+    constructor(private readonly _transport: RpcTransport) {
+    }
+    /**
+     *
+     * SubscribeSingleInvoice returns a uni-directional stream (server -> client)
+     * to notify the client of state transitions of the specified invoice.
+     * Initially the current invoice state is always sent out.
+     *
+     * @generated from protobuf rpc: SubscribeSingleInvoice(invoicesrpc.SubscribeSingleInvoiceRequest) returns (stream lnrpc.Invoice);
+     */
+    subscribeSingleInvoice(input: SubscribeSingleInvoiceRequest, options?: RpcOptions): ServerStreamingCall<SubscribeSingleInvoiceRequest, Invoice> {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept<SubscribeSingleInvoiceRequest, Invoice>("serverStreaming", this._transport, method, opt, input);
+    }
+    /**
+     *
+     * CancelInvoice cancels a currently open invoice. If the invoice is already
+     * canceled, this call will succeed. If the invoice is already settled, it will
+     * fail.
+     *
+     * @generated from protobuf rpc: CancelInvoice(invoicesrpc.CancelInvoiceMsg) returns (invoicesrpc.CancelInvoiceResp);
+     */
+    cancelInvoice(input: CancelInvoiceMsg, options?: RpcOptions): UnaryCall<CancelInvoiceMsg, CancelInvoiceResp> {
+        const method = this.methods[1], opt = this._transport.mergeOptions(options);
+        return stackIntercept<CancelInvoiceMsg, CancelInvoiceResp>("unary", this._transport, method, opt, input);
+    }
+    /**
+     *
+     * AddHoldInvoice creates a hold invoice. It ties the invoice to the hash
+     * supplied in the request.
+     *
+     * @generated from protobuf rpc: AddHoldInvoice(invoicesrpc.AddHoldInvoiceRequest) returns (invoicesrpc.AddHoldInvoiceResp);
+     */
+    addHoldInvoice(input: AddHoldInvoiceRequest, options?: RpcOptions): UnaryCall<AddHoldInvoiceRequest, AddHoldInvoiceResp> {
+        const method = this.methods[2], opt = this._transport.mergeOptions(options);
+        return stackIntercept<AddHoldInvoiceRequest, AddHoldInvoiceResp>("unary", this._transport, method, opt, input);
+    }
+    /**
+     *
+     * SettleInvoice settles an accepted invoice. If the invoice is already
+     * settled, this call will succeed.
+     *
+     * @generated from protobuf rpc: SettleInvoice(invoicesrpc.SettleInvoiceMsg) returns (invoicesrpc.SettleInvoiceResp);
+     */
+    settleInvoice(input: SettleInvoiceMsg, options?: RpcOptions): UnaryCall<SettleInvoiceMsg, SettleInvoiceResp> {
+        const method = this.methods[3], opt = this._transport.mergeOptions(options);
+        return stackIntercept<SettleInvoiceMsg, SettleInvoiceResp>("unary", this._transport, method, opt, input);
+    }
+}

proto/lnd/invoices.ts

@@ -0,0 +1,513 @@
+// @generated by protobuf-ts 2.5.0 with parameter long_type_string
+// @generated from protobuf file "invoices.proto" (package "invoicesrpc", syntax proto3)
+// tslint:disable
+import { Invoice } from "./rpc";
+import { ServiceType } from "@protobuf-ts/runtime-rpc";
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import { WireType } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import type { PartialMessage } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MESSAGE_TYPE } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+import { RouteHint } from "./rpc";
+/**
+ * @generated from protobuf message invoicesrpc.CancelInvoiceMsg
+ */
+export interface CancelInvoiceMsg {
+    /**
+     * Hash corresponding to the (hold) invoice to cancel.
+     *
+     * @generated from protobuf field: bytes payment_hash = 1;
+     */
+    paymentHash: Uint8Array;
+}
+/**
+ * @generated from protobuf message invoicesrpc.CancelInvoiceResp
+ */
+export interface CancelInvoiceResp {
+}
+/**
+ * @generated from protobuf message invoicesrpc.AddHoldInvoiceRequest
+ */
+export interface AddHoldInvoiceRequest {
+    /**
+     *
+     * An optional memo to attach along with the invoice. Used for record keeping
+     * purposes for the invoice's creator, and will also be set in the description
+     * field of the encoded payment request if the description_hash field is not
+     * being used.
+     *
+     * @generated from protobuf field: string memo = 1;
+     */
+    memo: string;
+    /**
+     * The hash of the preimage
+     *
+     * @generated from protobuf field: bytes hash = 2;
+     */
+    hash: Uint8Array;
+    /**
+     *
+     * The value of this invoice in satoshis
+     *
+     * The fields value and value_msat are mutually exclusive.
+     *
+     * @generated from protobuf field: int64 value = 3;
+     */
+    value: string;
+    /**
+     *
+     * The value of this invoice in millisatoshis
+     *
+     * The fields value and value_msat are mutually exclusive.
+     *
+     * @generated from protobuf field: int64 value_msat = 10;
+     */
+    valueMsat: string;
+    /**
+     *
+     * Hash (SHA-256) of a description of the payment. Used if the description of
+     * payment (memo) is too long to naturally fit within the description field
+     * of an encoded payment request.
+     *
+     * @generated from protobuf field: bytes description_hash = 4;
+     */
+    descriptionHash: Uint8Array;
+    /**
+     * Payment request expiry time in seconds. Default is 3600 (1 hour).
+     *
+     * @generated from protobuf field: int64 expiry = 5;
+     */
+    expiry: string;
+    /**
+     * Fallback on-chain address.
+     *
+     * @generated from protobuf field: string fallback_addr = 6;
+     */
+    fallbackAddr: string;
+    /**
+     * Delta to use for the time-lock of the CLTV extended to the final hop.
+     *
+     * @generated from protobuf field: uint64 cltv_expiry = 7;
+     */
+    cltvExpiry: string;
+    /**
+     *
+     * Route hints that can each be individually used to assist in reaching the
+     * invoice's destination.
+     *
+     * @generated from protobuf field: repeated lnrpc.RouteHint route_hints = 8;
+     */
+    routeHints: RouteHint[];
+    /**
+     * Whether this invoice should include routing hints for private channels.
+     *
+     * @generated from protobuf field: bool private = 9;
+     */
+    private: boolean;
+}
+/**
+ * @generated from protobuf message invoicesrpc.AddHoldInvoiceResp
+ */
+export interface AddHoldInvoiceResp {
+    /**
+     *
+     * A bare-bones invoice for a payment within the Lightning Network.  With the
+     * details of the invoice, the sender has all the data necessary to send a
+     * payment to the recipient.
+     *
+     * @generated from protobuf field: string payment_request = 1;
+     */
+    paymentRequest: string;
+}
+/**
+ * @generated from protobuf message invoicesrpc.SettleInvoiceMsg
+ */
+export interface SettleInvoiceMsg {
+    /**
+     * Externally discovered pre-image that should be used to settle the hold
+     * invoice.
+     *
+     * @generated from protobuf field: bytes preimage = 1;
+     */
+    preimage: Uint8Array;
+}
+/**
+ * @generated from protobuf message invoicesrpc.SettleInvoiceResp
+ */
+export interface SettleInvoiceResp {
+}
+/**
+ * @generated from protobuf message invoicesrpc.SubscribeSingleInvoiceRequest
+ */
+export interface SubscribeSingleInvoiceRequest {
+    /**
+     * Hash corresponding to the (hold) invoice to subscribe to.
+     *
+     * @generated from protobuf field: bytes r_hash = 2;
+     */
+    rHash: Uint8Array;
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class CancelInvoiceMsg$Type extends MessageType<CancelInvoiceMsg> {
+    constructor() {
+        super("invoicesrpc.CancelInvoiceMsg", [
+            { no: 1, name: "payment_hash", kind: "scalar", T: 12 /*ScalarType.BYTES*/ }
+        ]);
+    }
+    create(value?: PartialMessage<CancelInvoiceMsg>): CancelInvoiceMsg {
+        const message = { paymentHash: new Uint8Array(0) };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<CancelInvoiceMsg>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: CancelInvoiceMsg): CancelInvoiceMsg {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* bytes payment_hash */ 1:
+                    message.paymentHash = reader.bytes();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: CancelInvoiceMsg, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* bytes payment_hash = 1; */
+        if (message.paymentHash.length)
+            writer.tag(1, WireType.LengthDelimited).bytes(message.paymentHash);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message invoicesrpc.CancelInvoiceMsg
+ */
+export const CancelInvoiceMsg = new CancelInvoiceMsg$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CancelInvoiceResp$Type extends MessageType<CancelInvoiceResp> {
+    constructor() {
+        super("invoicesrpc.CancelInvoiceResp", []);
+    }
+    create(value?: PartialMessage<CancelInvoiceResp>): CancelInvoiceResp {
+        const message = {};
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<CancelInvoiceResp>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: CancelInvoiceResp): CancelInvoiceResp {
+        return target ?? this.create();
+    }
+    internalBinaryWrite(message: CancelInvoiceResp, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message invoicesrpc.CancelInvoiceResp
+ */
+export const CancelInvoiceResp = new CancelInvoiceResp$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class AddHoldInvoiceRequest$Type extends MessageType<AddHoldInvoiceRequest> {
+    constructor() {
+        super("invoicesrpc.AddHoldInvoiceRequest", [
+            { no: 1, name: "memo", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "hash", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 3, name: "value", kind: "scalar", T: 3 /*ScalarType.INT64*/ },
+            { no: 10, name: "value_msat", kind: "scalar", T: 3 /*ScalarType.INT64*/ },
+            { no: 4, name: "description_hash", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 5, name: "expiry", kind: "scalar", T: 3 /*ScalarType.INT64*/ },
+            { no: 6, name: "fallback_addr", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 7, name: "cltv_expiry", kind: "scalar", T: 4 /*ScalarType.UINT64*/ },
+            { no: 8, name: "route_hints", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => RouteHint },
+            { no: 9, name: "private", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value?: PartialMessage<AddHoldInvoiceRequest>): AddHoldInvoiceRequest {
+        const message = { memo: "", hash: new Uint8Array(0), value: "0", valueMsat: "0", descriptionHash: new Uint8Array(0), expiry: "0", fallbackAddr: "", cltvExpiry: "0", routeHints: [], private: false };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<AddHoldInvoiceRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AddHoldInvoiceRequest): AddHoldInvoiceRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string memo */ 1:
+                    message.memo = reader.string();
+                    break;
+                case /* bytes hash */ 2:
+                    message.hash = reader.bytes();
+                    break;
+                case /* int64 value */ 3:
+                    message.value = reader.int64().toString();
+                    break;
+                case /* int64 value_msat */ 10:
+                    message.valueMsat = reader.int64().toString();
+                    break;
+                case /* bytes description_hash */ 4:
+                    message.descriptionHash = reader.bytes();
+                    break;
+                case /* int64 expiry */ 5:
+                    message.expiry = reader.int64().toString();
+                    break;
+                case /* string fallback_addr */ 6:
+                    message.fallbackAddr = reader.string();
+                    break;
+                case /* uint64 cltv_expiry */ 7:
+                    message.cltvExpiry = reader.uint64().toString();
+                    break;
+                case /* repeated lnrpc.RouteHint route_hints */ 8:
+                    message.routeHints.push(RouteHint.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* bool private */ 9:
+                    message.private = reader.bool();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: AddHoldInvoiceRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string memo = 1; */
+        if (message.memo !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.memo);
+        /* bytes hash = 2; */
+        if (message.hash.length)
+            writer.tag(2, WireType.LengthDelimited).bytes(message.hash);
+        /* int64 value = 3; */
+        if (message.value !== "0")
+            writer.tag(3, WireType.Varint).int64(message.value);
+        /* int64 value_msat = 10; */
+        if (message.valueMsat !== "0")
+            writer.tag(10, WireType.Varint).int64(message.valueMsat);
+        /* bytes description_hash = 4; */
+        if (message.descriptionHash.length)
+            writer.tag(4, WireType.LengthDelimited).bytes(message.descriptionHash);
+        /* int64 expiry = 5; */
+        if (message.expiry !== "0")
+            writer.tag(5, WireType.Varint).int64(message.expiry);
+        /* string fallback_addr = 6; */
+        if (message.fallbackAddr !== "")
+            writer.tag(6, WireType.LengthDelimited).string(message.fallbackAddr);
+        /* uint64 cltv_expiry = 7; */
+        if (message.cltvExpiry !== "0")
+            writer.tag(7, WireType.Varint).uint64(message.cltvExpiry);
+        /* repeated lnrpc.RouteHint route_hints = 8; */
+        for (let i = 0; i < message.routeHints.length; i++)
+            RouteHint.internalBinaryWrite(message.routeHints[i], writer.tag(8, WireType.LengthDelimited).fork(), options).join();
+        /* bool private = 9; */
+        if (message.private !== false)
+            writer.tag(9, WireType.Varint).bool(message.private);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message invoicesrpc.AddHoldInvoiceRequest
+ */
+export const AddHoldInvoiceRequest = new AddHoldInvoiceRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class AddHoldInvoiceResp$Type extends MessageType<AddHoldInvoiceResp> {
+    constructor() {
+        super("invoicesrpc.AddHoldInvoiceResp", [
+            { no: 1, name: "payment_request", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<AddHoldInvoiceResp>): AddHoldInvoiceResp {
+        const message = { paymentRequest: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<AddHoldInvoiceResp>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AddHoldInvoiceResp): AddHoldInvoiceResp {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string payment_request */ 1:
+                    message.paymentRequest = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: AddHoldInvoiceResp, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string payment_request = 1; */
+        if (message.paymentRequest !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.paymentRequest);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message invoicesrpc.AddHoldInvoiceResp
+ */
+export const AddHoldInvoiceResp = new AddHoldInvoiceResp$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class SettleInvoiceMsg$Type extends MessageType<SettleInvoiceMsg> {
+    constructor() {
+        super("invoicesrpc.SettleInvoiceMsg", [
+            { no: 1, name: "preimage", kind: "scalar", T: 12 /*ScalarType.BYTES*/ }
+        ]);
+    }
+    create(value?: PartialMessage<SettleInvoiceMsg>): SettleInvoiceMsg {
+        const message = { preimage: new Uint8Array(0) };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<SettleInvoiceMsg>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SettleInvoiceMsg): SettleInvoiceMsg {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* bytes preimage */ 1:
+                    message.preimage = reader.bytes();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: SettleInvoiceMsg, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* bytes preimage = 1; */
+        if (message.preimage.length)
+            writer.tag(1, WireType.LengthDelimited).bytes(message.preimage);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message invoicesrpc.SettleInvoiceMsg
+ */
+export const SettleInvoiceMsg = new SettleInvoiceMsg$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class SettleInvoiceResp$Type extends MessageType<SettleInvoiceResp> {
+    constructor() {
+        super("invoicesrpc.SettleInvoiceResp", []);
+    }
+    create(value?: PartialMessage<SettleInvoiceResp>): SettleInvoiceResp {
+        const message = {};
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<SettleInvoiceResp>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SettleInvoiceResp): SettleInvoiceResp {
+        return target ?? this.create();
+    }
+    internalBinaryWrite(message: SettleInvoiceResp, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message invoicesrpc.SettleInvoiceResp
+ */
+export const SettleInvoiceResp = new SettleInvoiceResp$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class SubscribeSingleInvoiceRequest$Type extends MessageType<SubscribeSingleInvoiceRequest> {
+    constructor() {
+        super("invoicesrpc.SubscribeSingleInvoiceRequest", [
+            { no: 2, name: "r_hash", kind: "scalar", T: 12 /*ScalarType.BYTES*/ }
+        ]);
+    }
+    create(value?: PartialMessage<SubscribeSingleInvoiceRequest>): SubscribeSingleInvoiceRequest {
+        const message = { rHash: new Uint8Array(0) };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<SubscribeSingleInvoiceRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SubscribeSingleInvoiceRequest): SubscribeSingleInvoiceRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* bytes r_hash */ 2:
+                    message.rHash = reader.bytes();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: SubscribeSingleInvoiceRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* bytes r_hash = 2; */
+        if (message.rHash.length)
+            writer.tag(2, WireType.LengthDelimited).bytes(message.rHash);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message invoicesrpc.SubscribeSingleInvoiceRequest
+ */
+export const SubscribeSingleInvoiceRequest = new SubscribeSingleInvoiceRequest$Type();
+/**
+ * @generated ServiceType for protobuf service invoicesrpc.Invoices
+ */
+export const Invoices = new ServiceType("invoicesrpc.Invoices", [
+    { name: "SubscribeSingleInvoice", serverStreaming: true, options: {}, I: SubscribeSingleInvoiceRequest, O: Invoice },
+    { name: "CancelInvoice", options: {}, I: CancelInvoiceMsg, O: CancelInvoiceResp },
+    { name: "AddHoldInvoice", options: {}, I: AddHoldInvoiceRequest, O: AddHoldInvoiceResp },
+    { name: "SettleInvoice", options: {}, I: SettleInvoiceMsg, O: SettleInvoiceResp }
+]);

proto/lnd/router.client.ts

@@ -0,0 +1,418 @@
+// @generated by protobuf-ts 2.5.0 with parameter long_type_string
+// @generated from protobuf file "router.proto" (package "routerrpc", syntax proto3)
+// tslint:disable
+import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
+import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
+import { Router } from "./router";
+import type { UpdateChanStatusResponse } from "./router";
+import type { UpdateChanStatusRequest } from "./router";
+import type { ForwardHtlcInterceptRequest } from "./router";
+import type { ForwardHtlcInterceptResponse } from "./router";
+import type { DuplexStreamingCall } from "@protobuf-ts/runtime-rpc";
+import type { PaymentStatus } from "./router";
+import type { HtlcEvent } from "./router";
+import type { SubscribeHtlcEventsRequest } from "./router";
+import type { BuildRouteResponse } from "./router";
+import type { BuildRouteRequest } from "./router";
+import type { QueryProbabilityResponse } from "./router";
+import type { QueryProbabilityRequest } from "./router";
+import type { SetMissionControlConfigResponse } from "./router";
+import type { SetMissionControlConfigRequest } from "./router";
+import type { GetMissionControlConfigResponse } from "./router";
+import type { GetMissionControlConfigRequest } from "./router";
+import type { XImportMissionControlResponse } from "./router";
+import type { XImportMissionControlRequest } from "./router";
+import type { QueryMissionControlResponse } from "./router";
+import type { QueryMissionControlRequest } from "./router";
+import type { ResetMissionControlResponse } from "./router";
+import type { ResetMissionControlRequest } from "./router";
+import type { HTLCAttempt } from "./rpc";
+import type { SendToRouteResponse } from "./router";
+import type { SendToRouteRequest } from "./router";
+import type { RouteFeeResponse } from "./router";
+import type { RouteFeeRequest } from "./router";
+import type { UnaryCall } from "@protobuf-ts/runtime-rpc";
+import type { TrackPaymentRequest } from "./router";
+import { stackIntercept } from "@protobuf-ts/runtime-rpc";
+import type { Payment } from "./rpc";
+import type { SendPaymentRequest } from "./router";
+import type { ServerStreamingCall } from "@protobuf-ts/runtime-rpc";
+import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
+/**
+ * Router is a service that offers advanced interaction with the router
+ * subsystem of the daemon.
+ *
+ * @generated from protobuf service routerrpc.Router
+ */
+export interface IRouterClient {
+    /**
+     *
+     * SendPaymentV2 attempts to route a payment described by the passed
+     * PaymentRequest to the final destination. The call returns a stream of
+     * payment updates.
+     *
+     * @generated from protobuf rpc: SendPaymentV2(routerrpc.SendPaymentRequest) returns (stream lnrpc.Payment);
+     */
+    sendPaymentV2(input: SendPaymentRequest, options?: RpcOptions): ServerStreamingCall<SendPaymentRequest, Payment>;
+    /**
+     *
+     * TrackPaymentV2 returns an update stream for the payment identified by the
+     * payment hash.
+     *
+     * @generated from protobuf rpc: TrackPaymentV2(routerrpc.TrackPaymentRequest) returns (stream lnrpc.Payment);
+     */
+    trackPaymentV2(input: TrackPaymentRequest, options?: RpcOptions): ServerStreamingCall<TrackPaymentRequest, Payment>;
+    /**
+     *
+     * EstimateRouteFee allows callers to obtain a lower bound w.r.t how much it
+     * may cost to send an HTLC to the target end destination.
+     *
+     * @generated from protobuf rpc: EstimateRouteFee(routerrpc.RouteFeeRequest) returns (routerrpc.RouteFeeResponse);
+     */
+    estimateRouteFee(input: RouteFeeRequest, options?: RpcOptions): UnaryCall<RouteFeeRequest, RouteFeeResponse>;
+    /**
+     *
+     * Deprecated, use SendToRouteV2. SendToRoute attempts to make a payment via
+     * the specified route. This method differs from SendPayment in that it
+     * allows users to specify a full route manually. This can be used for
+     * things like rebalancing, and atomic swaps. It differs from the newer
+     * SendToRouteV2 in that it doesn't return the full HTLC information.
+     *
+     * @deprecated
+     * @generated from protobuf rpc: SendToRoute(routerrpc.SendToRouteRequest) returns (routerrpc.SendToRouteResponse);
+     */
+    sendToRoute(input: SendToRouteRequest, options?: RpcOptions): UnaryCall<SendToRouteRequest, SendToRouteResponse>;
+    /**
+     *
+     * SendToRouteV2 attempts to make a payment via the specified route. This
+     * method differs from SendPayment in that it allows users to specify a full
+     * route manually. This can be used for things like rebalancing, and atomic
+     * swaps.
+     *
+     * @generated from protobuf rpc: SendToRouteV2(routerrpc.SendToRouteRequest) returns (lnrpc.HTLCAttempt);
+     */
+    sendToRouteV2(input: SendToRouteRequest, options?: RpcOptions): UnaryCall<SendToRouteRequest, HTLCAttempt>;
+    /**
+     *
+     * ResetMissionControl clears all mission control state and starts with a clean
+     * slate.
+     *
+     * @generated from protobuf rpc: ResetMissionControl(routerrpc.ResetMissionControlRequest) returns (routerrpc.ResetMissionControlResponse);
+     */
+    resetMissionControl(input: ResetMissionControlRequest, options?: RpcOptions): UnaryCall<ResetMissionControlRequest, ResetMissionControlResponse>;
+    /**
+     *
+     * QueryMissionControl exposes the internal mission control state to callers.
+     * It is a development feature.
+     *
+     * @generated from protobuf rpc: QueryMissionControl(routerrpc.QueryMissionControlRequest) returns (routerrpc.QueryMissionControlResponse);
+     */
+    queryMissionControl(input: QueryMissionControlRequest, options?: RpcOptions): UnaryCall<QueryMissionControlRequest, QueryMissionControlResponse>;
+    /**
+     *
+     * XImportMissionControl is an experimental API that imports the state provided
+     * to the internal mission control's state, using all results which are more
+     * recent than our existing values. These values will only be imported
+     * in-memory, and will not be persisted across restarts.
+     *
+     * @generated from protobuf rpc: XImportMissionControl(routerrpc.XImportMissionControlRequest) returns (routerrpc.XImportMissionControlResponse);
+     */
+    xImportMissionControl(input: XImportMissionControlRequest, options?: RpcOptions): UnaryCall<XImportMissionControlRequest, XImportMissionControlResponse>;
+    /**
+     *
+     * GetMissionControlConfig returns mission control's current config.
+     *
+     * @generated from protobuf rpc: GetMissionControlConfig(routerrpc.GetMissionControlConfigRequest) returns (routerrpc.GetMissionControlConfigResponse);
+     */
+    getMissionControlConfig(input: GetMissionControlConfigRequest, options?: RpcOptions): UnaryCall<GetMissionControlConfigRequest, GetMissionControlConfigResponse>;
+    /**
+     *
+     * SetMissionControlConfig will set mission control's config, if the config
+     * provided is valid.
+     *
+     * @generated from protobuf rpc: SetMissionControlConfig(routerrpc.SetMissionControlConfigRequest) returns (routerrpc.SetMissionControlConfigResponse);
+     */
+    setMissionControlConfig(input: SetMissionControlConfigRequest, options?: RpcOptions): UnaryCall<SetMissionControlConfigRequest, SetMissionControlConfigResponse>;
+    /**
+     *
+     * QueryProbability returns the current success probability estimate for a
+     * given node pair and amount.
+     *
+     * @generated from protobuf rpc: QueryProbability(routerrpc.QueryProbabilityRequest) returns (routerrpc.QueryProbabilityResponse);
+     */
+    queryProbability(input: QueryProbabilityRequest, options?: RpcOptions): UnaryCall<QueryProbabilityRequest, QueryProbabilityResponse>;
+    /**
+     *
+     * BuildRoute builds a fully specified route based on a list of hop public
+     * keys. It retrieves the relevant channel policies from the graph in order to
+     * calculate the correct fees and time locks.
+     *
+     * @generated from protobuf rpc: BuildRoute(routerrpc.BuildRouteRequest) returns (routerrpc.BuildRouteResponse);
+     */
+    buildRoute(input: BuildRouteRequest, options?: RpcOptions): UnaryCall<BuildRouteRequest, BuildRouteResponse>;
+    /**
+     *
+     * SubscribeHtlcEvents creates a uni-directional stream from the server to
+     * the client which delivers a stream of htlc events.
+     *
+     * @generated from protobuf rpc: SubscribeHtlcEvents(routerrpc.SubscribeHtlcEventsRequest) returns (stream routerrpc.HtlcEvent);
+     */
+    subscribeHtlcEvents(input: SubscribeHtlcEventsRequest, options?: RpcOptions): ServerStreamingCall<SubscribeHtlcEventsRequest, HtlcEvent>;
+    /**
+     *
+     * Deprecated, use SendPaymentV2. SendPayment attempts to route a payment
+     * described by the passed PaymentRequest to the final destination. The call
+     * returns a stream of payment status updates.
+     *
+     * @deprecated
+     * @generated from protobuf rpc: SendPayment(routerrpc.SendPaymentRequest) returns (stream routerrpc.PaymentStatus);
+     */
+    sendPayment(input: SendPaymentRequest, options?: RpcOptions): ServerStreamingCall<SendPaymentRequest, PaymentStatus>;
+    /**
+     *
+     * Deprecated, use TrackPaymentV2. TrackPayment returns an update stream for
+     * the payment identified by the payment hash.
+     *
+     * @deprecated
+     * @generated from protobuf rpc: TrackPayment(routerrpc.TrackPaymentRequest) returns (stream routerrpc.PaymentStatus);
+     */
+    trackPayment(input: TrackPaymentRequest, options?: RpcOptions): ServerStreamingCall<TrackPaymentRequest, PaymentStatus>;
+    /**
+     * *
+     * HtlcInterceptor dispatches a bi-directional streaming RPC in which
+     * Forwarded HTLC requests are sent to the client and the client responds with
+     * a boolean that tells LND if this htlc should be intercepted.
+     * In case of interception, the htlc can be either settled, cancelled or
+     * resumed later by using the ResolveHoldForward endpoint.
+     *
+     * @generated from protobuf rpc: HtlcInterceptor(stream routerrpc.ForwardHtlcInterceptResponse) returns (stream routerrpc.ForwardHtlcInterceptRequest);
+     */
+    htlcInterceptor(options?: RpcOptions): DuplexStreamingCall<ForwardHtlcInterceptResponse, ForwardHtlcInterceptRequest>;
+    /**
+     *
+     * UpdateChanStatus attempts to manually set the state of a channel
+     * (enabled, disabled, or auto). A manual "disable" request will cause the
+     * channel to stay disabled until a subsequent manual request of either
+     * "enable" or "auto".
+     *
+     * @generated from protobuf rpc: UpdateChanStatus(routerrpc.UpdateChanStatusRequest) returns (routerrpc.UpdateChanStatusResponse);
+     */
+    updateChanStatus(input: UpdateChanStatusRequest, options?: RpcOptions): UnaryCall<UpdateChanStatusRequest, UpdateChanStatusResponse>;
+}
+/**
+ * Router is a service that offers advanced interaction with the router
+ * subsystem of the daemon.
+ *
+ * @generated from protobuf service routerrpc.Router
+ */
+export class RouterClient implements IRouterClient, ServiceInfo {
+    typeName = Router.typeName;
+    methods = Router.methods;
+    options = Router.options;
+    constructor(private readonly _transport: RpcTransport) {
+    }
+    /**
+     *
+     * SendPaymentV2 attempts to route a payment described by the passed
+     * PaymentRequest to the final destination. The call returns a stream of
+     * payment updates.
+     *
+     * @generated from protobuf rpc: SendPaymentV2(routerrpc.SendPaymentRequest) returns (stream lnrpc.Payment);
+     */
+    sendPaymentV2(input: SendPaymentRequest, options?: RpcOptions): ServerStreamingCall<SendPaymentRequest, Payment> {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept<SendPaymentRequest, Payment>("serverStreaming", this._transport, method, opt, input);
+    }
+    /**
+     *
+     * TrackPaymentV2 returns an update stream for the payment identified by the
+     * payment hash.
+     *
+     * @generated from protobuf rpc: TrackPaymentV2(routerrpc.TrackPaymentRequest) returns (stream lnrpc.Payment);
+     */
+    trackPaymentV2(input: TrackPaymentRequest, options?: RpcOptions): ServerStreamingCall<TrackPaymentRequest, Payment> {
+        const method = this.methods[1], opt = this._transport.mergeOptions(options);
+        return stackIntercept<TrackPaymentRequest, Payment>("serverStreaming", this._transport, method, opt, input);
+    }
+    /**
+     *
+     * EstimateRouteFee allows callers to obtain a lower bound w.r.t how much it
+     * may cost to send an HTLC to the target end destination.
+     *
+     * @generated from protobuf rpc: EstimateRouteFee(routerrpc.RouteFeeRequest) returns (routerrpc.RouteFeeResponse);
+     */
+    estimateRouteFee(input: RouteFeeRequest, options?: RpcOptions): UnaryCall<RouteFeeRequest, RouteFeeResponse> {
+        const method = this.methods[2], opt = this._transport.mergeOptions(options);
+        return stackIntercept<RouteFeeRequest, RouteFeeResponse>("unary", this._transport, method, opt, input);
+    }
+    /**
+     *
+     * Deprecated, use SendToRouteV2. SendToRoute attempts to make a payment via
+     * the specified route. This method differs from SendPayment in that it
+     * allows users to specify a full route manually. This can be used for
+     * things like rebalancing, and atomic swaps. It differs from the newer
+     * SendToRouteV2 in that it doesn't return the full HTLC information.
+     *
+     * @deprecated
+     * @generated from protobuf rpc: SendToRoute(routerrpc.SendToRouteRequest) returns (routerrpc.SendToRouteResponse);
+     */
+    sendToRoute(input: SendToRouteRequest, options?: RpcOptions): UnaryCall<SendToRouteRequest, SendToRouteResponse> {
+        const method = this.methods[3], opt = this._transport.mergeOptions(options);
+        return stackIntercept<SendToRouteRequest, SendToRouteResponse>("unary", this._transport, method, opt, input);
+    }
+    /**
+     *
+     * SendToRouteV2 attempts to make a payment via the specified route. This
+     * method differs from SendPayment in that it allows users to specify a full
+     * route manually. This can be used for things like rebalancing, and atomic
+     * swaps.
+     *
+     * @generated from protobuf rpc: SendToRouteV2(routerrpc.SendToRouteRequest) returns (lnrpc.HTLCAttempt);
+     */
+    sendToRouteV2(input: SendToRouteRequest, options?: RpcOptions): UnaryCall<SendToRouteRequest, HTLCAttempt> {
+        const method = this.methods[4], opt = this._transport.mergeOptions(options);
+        return stackIntercept<SendToRouteRequest, HTLCAttempt>("unary", this._transport, method, opt, input);
+    }
+    /**
+     *
+     * ResetMissionControl clears all mission control state and starts with a clean
+     * slate.
+     *
+     * @generated from protobuf rpc: ResetMissionControl(routerrpc.ResetMissionControlRequest) returns (routerrpc.ResetMissionControlResponse);
+     */
+    resetMissionControl(input: ResetMissionControlRequest, options?: RpcOptions): UnaryCall<ResetMissionControlRequest, ResetMissionControlResponse> {
+        const method = this.methods[5], opt = this._transport.mergeOptions(options);
+        return stackIntercept<ResetMissionControlRequest, ResetMissionControlResponse>("unary", this._transport, method, opt, input);
+    }
+    /**
+     *
+     * QueryMissionControl exposes the internal mission control state to callers.
+     * It is a development feature.
+     *
+     * @generated from protobuf rpc: QueryMissionControl(routerrpc.QueryMissionControlRequest) returns (routerrpc.QueryMissionControlResponse);
+     */
+    queryMissionControl(input: QueryMissionControlRequest, options?: RpcOptions): UnaryCall<QueryMissionControlRequest, QueryMissionControlResponse> {
+        const method = this.methods[6], opt = this._transport.mergeOptions(options);
+        return stackIntercept<QueryMissionControlRequest, QueryMissionControlResponse>("unary", this._transport, method, opt, input);
+    }
+    /**
+     *
+     * XImportMissionControl is an experimental API that imports the state provided
+     * to the internal mission control's state, using all results which are more
+     * recent than our existing values. These values will only be imported
+     * in-memory, and will not be persisted across restarts.
+     *
+     * @generated from protobuf rpc: XImportMissionControl(routerrpc.XImportMissionControlRequest) returns (routerrpc.XImportMissionControlResponse);
+     */
+    xImportMissionControl(input: XImportMissionControlRequest, options?: RpcOptions): UnaryCall<XImportMissionControlRequest, XImportMissionControlResponse> {
+        const method = this.methods[7], opt = this._transport.mergeOptions(options);
+        return stackIntercept<XImportMissionControlRequest, XImportMissionControlResponse>("unary", this._transport, method, opt, input);
+    }
+    /**
+     *
+     * GetMissionControlConfig returns mission control's current config.
+     *
+     * @generated from protobuf rpc: GetMissionControlConfig(routerrpc.GetMissionControlConfigRequest) returns (routerrpc.GetMissionControlConfigResponse);
+     */
+    getMissionControlConfig(input: GetMissionControlConfigRequest, options?: RpcOptions): UnaryCall<GetMissionControlConfigRequest, GetMissionControlConfigResponse> {
+        const method = this.methods[8], opt = this._transport.mergeOptions(options);
+        return stackIntercept<GetMissionControlConfigRequest, GetMissionControlConfigResponse>("unary", this._transport, method, opt, input);
+    }
+    /**
+     *
+     * SetMissionControlConfig will set mission control's config, if the config
+     * provided is valid.
+     *
+     * @generated from protobuf rpc: SetMissionControlConfig(routerrpc.SetMissionControlConfigRequest) returns (routerrpc.SetMissionControlConfigResponse);
+     */
+    setMissionControlConfig(input: SetMissionControlConfigRequest, options?: RpcOptions): UnaryCall<SetMissionControlConfigRequest, SetMissionControlConfigResponse> {
+        const method = this.methods[9], opt = this._transport.mergeOptions(options);
+        return stackIntercept<SetMissionControlConfigRequest, SetMissionControlConfigResponse>("unary", this._transport, method, opt, input);
+    }
+    /**
+     *
+     * QueryProbability returns the current success probability estimate for a
+     * given node pair and amount.
+     *
+     * @generated from protobuf rpc: QueryProbability(routerrpc.QueryProbabilityRequest) returns (routerrpc.QueryProbabilityResponse);
+     */
+    queryProbability(input: QueryProbabilityRequest, options?: RpcOptions): UnaryCall<QueryProbabilityRequest, QueryProbabilityResponse> {
+        const method = this.methods[10], opt = this._transport.mergeOptions(options);
+        return stackIntercept<QueryProbabilityRequest, QueryProbabilityResponse>("unary", this._transport, method, opt, input);
+    }
+    /**
+     *
+     * BuildRoute builds a fully specified route based on a list of hop public
+     * keys. It retrieves the relevant channel policies from the graph in order to
+     * calculate the correct fees and time locks.
+     *
+     * @generated from protobuf rpc: BuildRoute(routerrpc.BuildRouteRequest) returns (routerrpc.BuildRouteResponse);
+     */
+    buildRoute(input: BuildRouteRequest, options?: RpcOptions): UnaryCall<BuildRouteRequest, BuildRouteResponse> {
+        const method = this.methods[11], opt = this._transport.mergeOptions(options);
+        return stackIntercept<BuildRouteRequest, BuildRouteResponse>("unary", this._transport, method, opt, input);
+    }
+    /**
+     *
+     * SubscribeHtlcEvents creates a uni-directional stream from the server to
+     * the client which delivers a stream of htlc events.
+     *
+     * @generated from protobuf rpc: SubscribeHtlcEvents(routerrpc.SubscribeHtlcEventsRequest) returns (stream routerrpc.HtlcEvent);
+     */
+    subscribeHtlcEvents(input: SubscribeHtlcEventsRequest, options?: RpcOptions): ServerStreamingCall<SubscribeHtlcEventsRequest, HtlcEvent> {
+        const method = this.methods[12], opt = this._transport.mergeOptions(options);
+        return stackIntercept<SubscribeHtlcEventsRequest, HtlcEvent>("serverStreaming", this._transport, method, opt, input);
+    }
+    /**
+     *
+     * Deprecated, use SendPaymentV2. SendPayment attempts to route a payment
+     * described by the passed PaymentRequest to the final destination. The call
+     * returns a stream of payment status updates.
+     *
+     * @deprecated
+     * @generated from protobuf rpc: SendPayment(routerrpc.SendPaymentRequest) returns (stream routerrpc.PaymentStatus);
+     */
+    sendPayment(input: SendPaymentRequest, options?: RpcOptions): ServerStreamingCall<SendPaymentRequest, PaymentStatus> {
+        const method = this.methods[13], opt = this._transport.mergeOptions(options);
+        return stackIntercept<SendPaymentRequest, PaymentStatus>("serverStreaming", this._transport, method, opt, input);
+    }
+    /**
+     *
+     * Deprecated, use TrackPaymentV2. TrackPayment returns an update stream for
+     * the payment identified by the payment hash.
+     *
+     * @deprecated
+     * @generated from protobuf rpc: TrackPayment(routerrpc.TrackPaymentRequest) returns (stream routerrpc.PaymentStatus);
+     */
+    trackPayment(input: TrackPaymentRequest, options?: RpcOptions): ServerStreamingCall<TrackPaymentRequest, PaymentStatus> {
+        const method = this.methods[14], opt = this._transport.mergeOptions(options);
+        return stackIntercept<TrackPaymentRequest, PaymentStatus>("serverStreaming", this._transport, method, opt, input);
+    }
+    /**
+     * *
+     * HtlcInterceptor dispatches a bi-directional streaming RPC in which
+     * Forwarded HTLC requests are sent to the client and the client responds with
+     * a boolean that tells LND if this htlc should be intercepted.
+     * In case of interception, the htlc can be either settled, cancelled or
+     * resumed later by using the ResolveHoldForward endpoint.
+     *
+     * @generated from protobuf rpc: HtlcInterceptor(stream routerrpc.ForwardHtlcInterceptResponse) returns (stream routerrpc.ForwardHtlcInterceptRequest);
+     */
+    htlcInterceptor(options?: RpcOptions): DuplexStreamingCall<ForwardHtlcInterceptResponse, ForwardHtlcInterceptRequest> {
+        const method = this.methods[15], opt = this._transport.mergeOptions(options);
+        return stackIntercept<ForwardHtlcInterceptResponse, ForwardHtlcInterceptRequest>("duplex", this._transport, method, opt);
+    }
+    /**
+     *
+     * UpdateChanStatus attempts to manually set the state of a channel
+     * (enabled, disabled, or auto). A manual "disable" request will cause the
+     * channel to stay disabled until a subsequent manual request of either
+     * "enable" or "auto".
+     *
+     * @generated from protobuf rpc: UpdateChanStatus(routerrpc.UpdateChanStatusRequest) returns (routerrpc.UpdateChanStatusResponse);
+     */
+    updateChanStatus(input: UpdateChanStatusRequest, options?: RpcOptions): UnaryCall<UpdateChanStatusRequest, UpdateChanStatusResponse> {
+        const method = this.methods[16], opt = this._transport.mergeOptions(options);
+        return stackIntercept<UpdateChanStatusRequest, UpdateChanStatusResponse>("unary", this._transport, method, opt, input);
+    }
+}