wip

proto/autogenerated/debug.txt

@@ -0,0 +1,134 @@
+([]*main.Method) (len=3 cap=4) {
+ (*main.Method)(0xc00029e730)({
+  in: (main.MethodMessage) {
+   name: (string) (len=5) "Empty",
+   hasZeroFields: (bool) true
+  },
+  name: (string) (len=6) "Health",
+  out: (main.MethodMessage) {
+   name: (string) (len=5) "Empty",
+   hasZeroFields: (bool) true
+  },
+  opts: (*main.methodOptions)(0xc000039b60)({
+   authType: (*main.supportedAuth)(0xc0003a2b40)({
+    id: (string) (len=7) "no_auth",
+    name: (string) (len=6) "NoAuth",
+    encrypted: (bool) false,
+    context: (map[string]string) {
+    }
+   }),
+   method: (string) (len=3) "get",
+   route: (main.decodedRoute) {
+    route: (string) (len=7) "/health",
+    params: ([]string) <nil>
+   },
+   query: ([]string) <nil>
+  })
+ }),
+ (*main.Method)(0xc00029e780)({
+  in: (main.MethodMessage) {
+   name: (string) (len=25) "EncryptionExchangeRequest",
+   hasZeroFields: (bool) false
+  },
+  name: (string) (len=18) "EncryptionExchange",
+  out: (main.MethodMessage) {
+   name: (string) (len=5) "Empty",
+   hasZeroFields: (bool) true
+  },
+  opts: (*main.methodOptions)(0xc000039ce0)({
+   authType: (*main.supportedAuth)(0xc0003a2c00)({
+    id: (string) (len=7) "no_auth",
+    name: (string) (len=6) "NoAuth",
+    encrypted: (bool) false,
+    context: (map[string]string) {
+    }
+   }),
+   method: (string) (len=4) "post",
+   route: (main.decodedRoute) {
+    route: (string) (len=24) "/api/encryption/exchange",
+    params: ([]string) <nil>
+   },
+   query: ([]string) <nil>
+  })
+ }),
+ (*main.Method)(0xc00029e7d0)({
+  in: (main.MethodMessage) {
+   name: (string) (len=5) "Empty",
+   hasZeroFields: (bool) true
+  },
+  name: (string) (len=10) "LndGetInfo",
+  out: (main.MethodMessage) {
+   name: (string) (len=18) "LndGetInfoResponse",
+   hasZeroFields: (bool) false
+  },
+  opts: (*main.methodOptions)(0xc000039e60)({
+   authType: (*main.supportedAuth)(0xc0003a2cc0)({
+    id: (string) (len=7) "no_auth",
+    name: (string) (len=6) "NoAuth",
+    encrypted: (bool) false,
+    context: (map[string]string) {
+    }
+   }),
+   method: (string) (len=3) "get",
+   route: (main.decodedRoute) {
+    route: (string) (len=16) "/api/lnd/getinfo",
+    params: ([]string) <nil>
+   },
+   query: ([]string) <nil>
+  })
+ })
+}
+
+([]*main.Enum) <nil>
+
+(map[string]*main.Message) (len=3) {
+ (string) (len=25) "EncryptionExchangeRequest": (*main.Message)(0xc000238f40)({
+  fullName: (string) (len=25) "EncryptionExchangeRequest",
+  name: (string) (len=25) "EncryptionExchangeRequest",
+  fields: ([]*main.Field) (len=2 cap=2) {
+   (*main.Field)(0xc0003a2390)({
+    name: (string) (len=10) "public_key",
+    kind: (string) (len=6) "string",
+    isMap: (bool) false,
+    isArray: (bool) false,
+    isEnum: (bool) false,
+    isMessage: (bool) false,
+    isOptional: (bool) false
+   }),
+   (*main.Field)(0xc0003a23c0)({
+    name: (string) (len=9) "device_id",
+    kind: (string) (len=6) "string",
+    isMap: (bool) false,
+    isArray: (bool) false,
+    isEnum: (bool) false,
+    isMessage: (bool) false,
+    isOptional: (bool) false
+   })
+  }
+ }),
+ (string) (len=18) "LndGetInfoResponse": (*main.Message)(0xc000238f80)({
+  fullName: (string) (len=18) "LndGetInfoResponse",
+  name: (string) (len=18) "LndGetInfoResponse",
+  fields: ([]*main.Field) (len=1 cap=1) {
+   (*main.Field)(0xc0003a23f0)({
+    name: (string) (len=5) "alias",
+    kind: (string) (len=6) "string",
+    isMap: (bool) false,
+    isArray: (bool) false,
+    isEnum: (bool) false,
+    isMessage: (bool) false,
+    isOptional: (bool) false
+   })
+  }
+ }),
+ (string) (len=5) "Empty": (*main.Message)(0xc000238f00)({
+  fullName: (string) (len=5) "Empty",
+  name: (string) (len=5) "Empty",
+  fields: ([]*main.Field) <nil>
+ })
+}
+
+parsing file: structs 3
+parsing file: methods 2
+-> [{no_auth NoAuth false map[]} {guest Guest false map[token:string]} {admin Admin true map[pub:string]}] 
+

proto/autogenerated/ts/express_server.ts

@@ -0,0 +1,60 @@
+// This file was autogenerated from a .proto file, DO NOT EDIT!
+
+import express, { Response } from 'express'
+import * as Types from './types'
+export type Logger = { log: (v: any) => void, error: (v: any) => void }
+export type ServerOptions = {
+    allowNotImplementedMethods?: number
+    logger?: Logger
+    throwErrors?: true
+    NoAuthAuthGuard: (authorizationHeader?: string) => Promise<Types.NoAuthContext>
+    GuestAuthGuard: (authorizationHeader?: string) => Promise<Types.GuestContext>
+    AdminAuthGuard: (authorizationHeader?: string) => Promise<Types.AdminContext>
+    encryptionCallback: (ctx: Types.AuthContext, body: any) => Promise<string>
+}
+const logErrorAndReturnResponse = (error: Error, response: string, res: Response, logger: Logger) => { logger.error(error.message || error); res.json({ status: 'ERROR', reason: response }) }
+export default (methods: Types.ServerMethods, opts: ServerOptions) => {
+    const logger = opts.logger || { log: console.log, error: console.error }
+    const app = express()
+    if (!opts.allowNotImplementedMethods && !methods.Health) throw new Error('method: Health is not implemented')
+    app.get('/health', async (req, res) => {
+        try {
+            if (!methods.Health) throw new Error('method: Health is not implemented')
+            const authContext = await opts.NoAuthAuthGuard(req.headers['authorization'])
+            const query = req.query
+            const params = req.params
+            await methods.Health({ ...authContext, ...query, ...params })
+            res.json({ status: 'OK' })
+        } catch (ex) { const e = ex as any; logErrorAndReturnResponse(e, e.message || e, res, logger); if (opts.throwErrors) throw e }
+    })
+    if (!opts.allowNotImplementedMethods && !methods.EncryptionExchange) throw new Error('method: EncryptionExchange is not implemented')
+    app.post('/api/encryption/exchange', async (req, res) => {
+        try {
+            if (!methods.EncryptionExchange) throw new Error('method: EncryptionExchange is not implemented')
+            const authContext = await opts.NoAuthAuthGuard(req.headers['authorization'])
+            const request = req.body
+            const error = Types.EncryptionExchangeRequestValidate(request)
+            if (error !== null) return logErrorAndReturnResponse(error, 'invalid request body', res, logger)
+            const query = req.query
+            const params = req.params
+            await methods.EncryptionExchange({ ...authContext, ...query, ...params }, request)
+            res.json({ status: 'OK' })
+        } catch (ex) { const e = ex as any; logErrorAndReturnResponse(e, e.message || e, res, logger); if (opts.throwErrors) throw e }
+    })
+    if (!opts.allowNotImplementedMethods && !methods.LndGetInfo) throw new Error('method: LndGetInfo is not implemented')
+    app.get('/api/lnd/getinfo', async (req, res) => {
+        try {
+            if (!methods.LndGetInfo) throw new Error('method: LndGetInfo is not implemented')
+            const authContext = await opts.NoAuthAuthGuard(req.headers['authorization'])
+            const query = req.query
+            const params = req.params
+            const response = await methods.LndGetInfo({ ...authContext, ...query, ...params })
+            res.json({ status: 'OK', result: response })
+        } catch (ex) { const e = ex as any; logErrorAndReturnResponse(e, e.message || e, res, logger); if (opts.throwErrors) throw e }
+    })
+    var server: { close: () => void } | undefined
+    return {
+        Close: () => { if (!server) { throw new Error('tried closing server before starting') } else server.close() },
+        Listen: (port: number) => { server = app.listen(port, () => logger.log('Example app listening on port ' + port)) }
+    }
+}

proto/autogenerated/ts/http_client.ts

@@ -0,0 +1,44 @@
+// This file was autogenerated from a .proto file, DO NOT EDIT!
+import axios from 'axios'
+import * as Types from './types'
+export type ResultError = { status: 'ERROR', reason: string }
+
+export type ClientParams = {
+    baseUrl: string
+    retrieveNoAuthAuth: () => Promise<string | null>
+    retrieveGuestAuth: () => Promise<string | null>
+    retrieveAdminAuth: () => Promise<string | null>
+}
+export default (params: ClientParams) => ({
+    Health: async (): Promise<ResultError | { status: 'OK' }> => {
+        const auth = await params.retrieveNoAuthAuth()
+        if (auth === null) throw new Error('retrieveNoAuthAuth() returned null')
+        const { data } = await axios.get(params.baseUrl + '/health', { headers: { 'authorization': auth } })
+        if (data.status === 'ERROR' && typeof data.reason === 'string') return data
+        if (data.status === 'OK') { 
+            return data
+        }
+        return { status: 'ERROR', reason: 'invalid response' }
+    },
+    EncryptionExchange: async (request: Types.EncryptionExchangeRequest): Promise<ResultError | { status: 'OK' }> => {
+        const auth = await params.retrieveNoAuthAuth()
+        if (auth === null) throw new Error('retrieveNoAuthAuth() returned null')
+        const { data } = await axios.post(params.baseUrl + '/api/encryption/exchange', request, { headers: { 'authorization': auth } })
+        if (data.status === 'ERROR' && typeof data.reason === 'string') return data
+        if (data.status === 'OK') { 
+            return data
+        }
+        return { status: 'ERROR', reason: 'invalid response' }
+    },
+    LndGetInfo: async (): Promise<ResultError | { status: 'OK', result: Types.Empty }> => {
+        const auth = await params.retrieveNoAuthAuth()
+        if (auth === null) throw new Error('retrieveNoAuthAuth() returned null')
+        const { data } = await axios.get(params.baseUrl + '/api/lnd/getinfo', { headers: { 'authorization': auth } })
+        if (data.status === 'ERROR' && typeof data.reason === 'string') return data
+        if (data.status === 'OK') { 
+            const error = Types.LndGetInfoResponseValidate(data.result)
+            if (error === null) { return data } else return { status: 'ERROR', reason: error.message }
+        }
+        return { status: 'ERROR', reason: 'invalid response' }
+    },
+})

proto/autogenerated/ts/types.ts

@@ -0,0 +1,92 @@
+// This file was autogenerated from a .proto file, DO NOT EDIT!
+
+export type NoAuthContext = {
+}
+export type GuestContext = {
+    token: string
+}
+export type AdminContext = {
+    pub: string
+}
+export type AuthContext = NoAuthContext | GuestContext | AdminContext
+
+export type Health_Query = {
+}
+export type Health_RouteParams = {
+}
+export type Health_Context = Health_Query & Health_RouteParams & NoAuthContext
+export type EncryptionExchange_Query = {
+}
+export type EncryptionExchange_RouteParams = {
+}
+export type EncryptionExchange_Context = EncryptionExchange_Query & EncryptionExchange_RouteParams & NoAuthContext
+export type LndGetInfo_Query = {
+}
+export type LndGetInfo_RouteParams = {
+}
+export type LndGetInfo_Context = LndGetInfo_Query & LndGetInfo_RouteParams & NoAuthContext
+export type ServerMethods = {
+    Health?: (ctx: Health_Context) => Promise<void>
+    EncryptionExchange?: (ctx: EncryptionExchange_Context, req: EncryptionExchangeRequest) => Promise<void>
+    LndGetInfo?: (ctx: LndGetInfo_Context) => Promise<LndGetInfoResponse>
+}
+
+
+export type OptionsBaseMessage = {
+    allOptionalsAreSet?: true
+}
+
+export type LndGetInfoResponse = {
+    alias: string
+}
+export const LndGetInfoResponseOptionalFields: [] = []
+export type LndGetInfoResponseOptions = OptionsBaseMessage & {
+    checkOptionalsAreSet?: []
+    alias_CustomCheck?: (v: string) => boolean
+}
+export const LndGetInfoResponseValidate = (o?: LndGetInfoResponse, opts: LndGetInfoResponseOptions = {}, path: string = 'LndGetInfoResponse::root.'): Error | null => {
+    if (opts.checkOptionalsAreSet && opts.allOptionalsAreSet) return new Error(path + ': only one of checkOptionalsAreSet or allOptionalNonDefault can be set for each message')
+    if (typeof o !== 'object' || o === null) return new Error(path + ': object is not an instance of an object or is null')
+
+    if (typeof o.alias !== 'string') return new Error(`${path}.alias: is not a string`)
+    if (opts.alias_CustomCheck && !opts.alias_CustomCheck(o.alias)) return new Error(`${path}.alias: custom check failed`)
+
+    return null
+}
+
+export type Empty = {
+}
+export const EmptyOptionalFields: [] = []
+export type EmptyOptions = OptionsBaseMessage & {
+    checkOptionalsAreSet?: []
+}
+export const EmptyValidate = (o?: Empty, opts: EmptyOptions = {}, path: string = 'Empty::root.'): Error | null => {
+    if (opts.checkOptionalsAreSet && opts.allOptionalsAreSet) return new Error(path + ': only one of checkOptionalsAreSet or allOptionalNonDefault can be set for each message')
+    if (typeof o !== 'object' || o === null) return new Error(path + ': object is not an instance of an object or is null')
+
+    return null
+}
+
+export type EncryptionExchangeRequest = {
+    public_key: string
+    device_id: string
+}
+export const EncryptionExchangeRequestOptionalFields: [] = []
+export type EncryptionExchangeRequestOptions = OptionsBaseMessage & {
+    checkOptionalsAreSet?: []
+    public_key_CustomCheck?: (v: string) => boolean
+    device_id_CustomCheck?: (v: string) => boolean
+}
+export const EncryptionExchangeRequestValidate = (o?: EncryptionExchangeRequest, opts: EncryptionExchangeRequestOptions = {}, path: string = 'EncryptionExchangeRequest::root.'): Error | null => {
+    if (opts.checkOptionalsAreSet && opts.allOptionalsAreSet) return new Error(path + ': only one of checkOptionalsAreSet or allOptionalNonDefault can be set for each message')
+    if (typeof o !== 'object' || o === null) return new Error(path + ': object is not an instance of an object or is null')
+
+    if (typeof o.public_key !== 'string') return new Error(`${path}.public_key: is not a string`)
+    if (opts.public_key_CustomCheck && !opts.public_key_CustomCheck(o.public_key)) return new Error(`${path}.public_key: custom check failed`)
+
+    if (typeof o.device_id !== 'string') return new Error(`${path}.device_id: is not a string`)
+    if (opts.device_id_CustomCheck && !opts.device_id_CustomCheck(o.device_id)) return new Error(`${path}.device_id: custom check failed`)
+
+    return null
+}
+

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);
+    }
+}

proto/others/invoices.proto

@@ -0,0 +1,122 @@
+syntax = "proto3";
+
+import "rpc.proto";
+
+package invoicesrpc;
+
+option go_package = "github.com/lightningnetwork/lnd/lnrpc/invoicesrpc";
+
+// Invoices is a service that can be used to create, accept, settle and cancel
+// invoices.
+service Invoices {
+    /*
+    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.
+    */
+    rpc SubscribeSingleInvoice (SubscribeSingleInvoiceRequest)
+        returns (stream lnrpc.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.
+    */
+    rpc CancelInvoice (CancelInvoiceMsg) returns (CancelInvoiceResp);
+
+    /*
+    AddHoldInvoice creates a hold invoice. It ties the invoice to the hash
+    supplied in the request.
+    */
+    rpc AddHoldInvoice (AddHoldInvoiceRequest) returns (AddHoldInvoiceResp);
+
+    /*
+    SettleInvoice settles an accepted invoice. If the invoice is already
+    settled, this call will succeed.
+    */
+    rpc SettleInvoice (SettleInvoiceMsg) returns (SettleInvoiceResp);
+}
+
+message CancelInvoiceMsg {
+    // Hash corresponding to the (hold) invoice to cancel.
+    bytes payment_hash = 1;
+}
+message CancelInvoiceResp {
+}
+
+message 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.
+    */
+    string memo = 1;
+
+    // The hash of the preimage
+    bytes hash = 2;
+
+    /*
+    The value of this invoice in satoshis
+
+    The fields value and value_msat are mutually exclusive.
+    */
+    int64 value = 3;
+
+    /*
+    The value of this invoice in millisatoshis
+
+    The fields value and value_msat are mutually exclusive.
+    */
+    int64 value_msat = 10;
+
+    /*
+    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.
+    */
+    bytes description_hash = 4;
+
+    // Payment request expiry time in seconds. Default is 3600 (1 hour).
+    int64 expiry = 5;
+
+    // Fallback on-chain address.
+    string fallback_addr = 6;
+
+    // Delta to use for the time-lock of the CLTV extended to the final hop.
+    uint64 cltv_expiry = 7;
+
+    /*
+    Route hints that can each be individually used to assist in reaching the
+    invoice's destination.
+    */
+    repeated lnrpc.RouteHint route_hints = 8;
+
+    // Whether this invoice should include routing hints for private channels.
+    bool private = 9;
+}
+
+message 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.
+    */
+    string payment_request = 1;
+}
+
+message SettleInvoiceMsg {
+    // Externally discovered pre-image that should be used to settle the hold
+    // invoice.
+    bytes preimage = 1;
+}
+
+message SettleInvoiceResp {
+}
+
+message SubscribeSingleInvoiceRequest {
+    reserved 1;
+
+    // Hash corresponding to the (hold) invoice to subscribe to.
+    bytes r_hash = 2;
+}

proto/others/router.proto

@@ -0,0 +1,798 @@
+syntax = "proto3";
+
+import "rpc.proto";
+
+package routerrpc;
+
+option go_package = "github.com/lightningnetwork/lnd/lnrpc/routerrpc";
+
+// Router is a service that offers advanced interaction with the router
+// subsystem of the daemon.
+service Router {
+    /*
+    SendPaymentV2 attempts to route a payment described by the passed
+    PaymentRequest to the final destination. The call returns a stream of
+    payment updates.
+    */
+    rpc SendPaymentV2 (SendPaymentRequest) returns (stream lnrpc.Payment);
+
+    /*
+    TrackPaymentV2 returns an update stream for the payment identified by the
+    payment hash.
+    */
+    rpc TrackPaymentV2 (TrackPaymentRequest) returns (stream lnrpc.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.
+    */
+    rpc EstimateRouteFee (RouteFeeRequest) returns (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.
+    */
+    rpc SendToRoute (SendToRouteRequest) returns (SendToRouteResponse) {
+        option deprecated = true;
+    }
+
+    /*
+    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.
+    */
+    rpc SendToRouteV2 (SendToRouteRequest) returns (lnrpc.HTLCAttempt);
+
+    /*
+    ResetMissionControl clears all mission control state and starts with a clean
+    slate.
+    */
+    rpc ResetMissionControl (ResetMissionControlRequest)
+        returns (ResetMissionControlResponse);
+
+    /*
+    QueryMissionControl exposes the internal mission control state to callers.
+    It is a development feature.
+    */
+    rpc QueryMissionControl (QueryMissionControlRequest)
+        returns (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.
+    */
+    rpc XImportMissionControl (XImportMissionControlRequest)
+        returns (XImportMissionControlResponse);
+
+    /*
+    GetMissionControlConfig returns mission control's current config.
+    */
+    rpc GetMissionControlConfig (GetMissionControlConfigRequest)
+        returns (GetMissionControlConfigResponse);
+
+    /*
+    SetMissionControlConfig will set mission control's config, if the config
+    provided is valid.
+    */
+    rpc SetMissionControlConfig (SetMissionControlConfigRequest)
+        returns (SetMissionControlConfigResponse);
+
+    /*
+    QueryProbability returns the current success probability estimate for a
+    given node pair and amount.
+    */
+    rpc QueryProbability (QueryProbabilityRequest)
+        returns (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.
+    */
+    rpc BuildRoute (BuildRouteRequest) returns (BuildRouteResponse);
+
+    /*
+    SubscribeHtlcEvents creates a uni-directional stream from the server to
+    the client which delivers a stream of htlc events.
+    */
+    rpc SubscribeHtlcEvents (SubscribeHtlcEventsRequest)
+        returns (stream 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.
+    */
+    rpc SendPayment (SendPaymentRequest) returns (stream PaymentStatus) {
+        option deprecated = true;
+    }
+
+    /*
+    Deprecated, use TrackPaymentV2. TrackPayment returns an update stream for
+    the payment identified by the payment hash.
+    */
+    rpc TrackPayment (TrackPaymentRequest) returns (stream PaymentStatus) {
+        option deprecated = true;
+    }
+
+    /**
+    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.
+    */
+    rpc HtlcInterceptor (stream ForwardHtlcInterceptResponse)
+        returns (stream 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".
+    */
+    rpc UpdateChanStatus (UpdateChanStatusRequest)
+        returns (UpdateChanStatusResponse);
+}
+
+message SendPaymentRequest {
+    // The identity pubkey of the payment recipient
+    bytes dest = 1;
+
+    /*
+    Number of satoshis to send.
+
+    The fields amt and amt_msat are mutually exclusive.
+    */
+    int64 amt = 2;
+
+    /*
+    Number of millisatoshis to send.
+
+    The fields amt and amt_msat are mutually exclusive.
+    */
+    int64 amt_msat = 12;
+
+    // The hash to use within the payment's HTLC
+    bytes payment_hash = 3;
+
+    /*
+    The CLTV delta from the current height that should be used to set the
+    timelock for the final hop.
+    */
+    int32 final_cltv_delta = 4;
+
+    // An optional payment addr to be included within the last hop of the route.
+    bytes payment_addr = 20;
+
+    /*
+    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. The amount in the payment request may be zero. In
+    that case it is required to set the amt field as well. If no payment request
+    is specified, the following fields are required: dest, amt and payment_hash.
+    */
+    string payment_request = 5;
+
+    /*
+    An upper limit on the amount of time we should spend when attempting to
+    fulfill the payment. This is expressed in seconds. If we cannot make a
+    successful payment within this time frame, an error will be returned.
+    This field must be non-zero.
+    */
+    int32 timeout_seconds = 6;
+
+    /*
+    The maximum number of satoshis that will be paid as a fee of the payment.
+    If this field is left to the default value of 0, only zero-fee routes will
+    be considered. This usually means single hop routes connecting directly to
+    the destination. To send the payment without a fee limit, use max int here.
+
+    The fields fee_limit_sat and fee_limit_msat are mutually exclusive.
+    */
+    int64 fee_limit_sat = 7;
+
+    /*
+    The maximum number of millisatoshis that will be paid as a fee of the
+    payment. If this field is left to the default value of 0, only zero-fee
+    routes will be considered. This usually means single hop routes connecting
+    directly to the destination. To send the payment without a fee limit, use
+    max int here.
+
+    The fields fee_limit_sat and fee_limit_msat are mutually exclusive.
+    */
+    int64 fee_limit_msat = 13;
+
+    /*
+    Deprecated, use outgoing_chan_ids. The channel id of the channel that must
+    be taken to the first hop. If zero, any channel may be used (unless
+    outgoing_chan_ids are set).
+    */
+    uint64 outgoing_chan_id = 8 [jstype = JS_STRING, deprecated = true];
+
+    /*
+    The channel ids of the channels are allowed for the first hop. If empty,
+    any channel may be used.
+    */
+    repeated uint64 outgoing_chan_ids = 19;
+
+    /*
+    The pubkey of the last hop of the route. If empty, any hop may be used.
+    */
+    bytes last_hop_pubkey = 14;
+
+    /*
+    An optional maximum total time lock for the route. This should not exceed
+    lnd's `--max-cltv-expiry` setting. If zero, then the value of
+    `--max-cltv-expiry` is enforced.
+    */
+    int32 cltv_limit = 9;
+
+    /*
+    Optional route hints to reach the destination through private channels.
+    */
+    repeated lnrpc.RouteHint route_hints = 10;
+
+    /*
+    An optional field that can be used to pass an arbitrary set of TLV records
+    to a peer which understands the new records. This can be used to pass
+    application specific data during the payment attempt. Record types are
+    required to be in the custom range >= 65536. When using REST, the values
+    must be encoded as base64.
+    */
+    map<uint64, bytes> dest_custom_records = 11;
+
+    // If set, circular payments to self are permitted.
+    bool allow_self_payment = 15;
+
+    /*
+    Features assumed to be supported by the final node. All transitive feature
+    dependencies must also be set properly. For a given feature bit pair, either
+    optional or remote may be set, but not both. If this field is nil or empty,
+    the router will try to load destination features from the graph as a
+    fallback.
+    */
+    repeated lnrpc.FeatureBit dest_features = 16;
+
+    /*
+    The maximum number of partial payments that may be use to complete the full
+    amount.
+    */
+    uint32 max_parts = 17;
+
+    /*
+    If set, only the final payment update is streamed back. Intermediate updates
+    that show which htlcs are still in flight are suppressed.
+    */
+    bool no_inflight_updates = 18;
+
+    /*
+    The largest payment split that should be attempted when making a payment if
+    splitting is necessary. Setting this value will effectively cause lnd to
+    split more aggressively, vs only when it thinks it needs to. Note that this
+    value is in milli-satoshis.
+    */
+    uint64 max_shard_size_msat = 21;
+
+    /*
+    If set, an AMP-payment will be attempted.
+    */
+    bool amp = 22;
+}
+
+message TrackPaymentRequest {
+    // The hash of the payment to look up.
+    bytes payment_hash = 1;
+
+    /*
+    If set, only the final payment update is streamed back. Intermediate updates
+    that show which htlcs are still in flight are suppressed.
+    */
+    bool no_inflight_updates = 2;
+}
+
+message RouteFeeRequest {
+    /*
+    The destination once wishes to obtain a routing fee quote to.
+    */
+    bytes dest = 1;
+
+    /*
+    The amount one wishes to send to the target destination.
+    */
+    int64 amt_sat = 2;
+}
+
+message RouteFeeResponse {
+    /*
+    A lower bound of the estimated fee to the target destination within the
+    network, expressed in milli-satoshis.
+    */
+    int64 routing_fee_msat = 1;
+
+    /*
+    An estimate of the worst case time delay that can occur. Note that callers
+    will still need to factor in the final CLTV delta of the last hop into this
+    value.
+    */
+    int64 time_lock_delay = 2;
+}
+
+message SendToRouteRequest {
+    // The payment hash to use for the HTLC.
+    bytes payment_hash = 1;
+
+    // Route that should be used to attempt to complete the payment.
+    lnrpc.Route route = 2;
+}
+
+message SendToRouteResponse {
+    // The preimage obtained by making the payment.
+    bytes preimage = 1;
+
+    // The failure message in case the payment failed.
+    lnrpc.Failure failure = 2;
+}
+
+message ResetMissionControlRequest {
+}
+
+message ResetMissionControlResponse {
+}
+
+message QueryMissionControlRequest {
+}
+
+// QueryMissionControlResponse contains mission control state.
+message QueryMissionControlResponse {
+    reserved 1;
+
+    // Node pair-level mission control state.
+    repeated PairHistory pairs = 2;
+}
+
+message XImportMissionControlRequest {
+    // Node pair-level mission control state to be imported.
+    repeated PairHistory pairs = 1;
+}
+
+message XImportMissionControlResponse {
+}
+
+// PairHistory contains the mission control state for a particular node pair.
+message PairHistory {
+    // The source node pubkey of the pair.
+    bytes node_from = 1;
+
+    // The destination node pubkey of the pair.
+    bytes node_to = 2;
+
+    reserved 3, 4, 5, 6;
+
+    PairData history = 7;
+}
+
+message PairData {
+    // Time of last failure.
+    int64 fail_time = 1;
+
+    /*
+    Lowest amount that failed to forward rounded to whole sats. This may be
+    set to zero if the failure is independent of amount.
+    */
+    int64 fail_amt_sat = 2;
+
+    /*
+    Lowest amount that failed to forward in millisats. This may be
+    set to zero if the failure is independent of amount.
+    */
+    int64 fail_amt_msat = 4;
+
+    reserved 3;
+
+    // Time of last success.
+    int64 success_time = 5;
+
+    // Highest amount that we could successfully forward rounded to whole sats.
+    int64 success_amt_sat = 6;
+
+    // Highest amount that we could successfully forward in millisats.
+    int64 success_amt_msat = 7;
+}
+
+message GetMissionControlConfigRequest {
+}
+
+message GetMissionControlConfigResponse {
+    /*
+    Mission control's currently active config.
+    */
+    MissionControlConfig config = 1;
+}
+
+message SetMissionControlConfigRequest {
+    /*
+    The config to set for mission control. Note that all values *must* be set,
+    because the full config will be applied.
+    */
+    MissionControlConfig config = 1;
+}
+
+message SetMissionControlConfigResponse {
+}
+
+message MissionControlConfig {
+    /*
+    The amount of time mission control will take to restore a penalized node
+    or channel back to 50% success probability, expressed in seconds. Setting
+    this value to a higher value will penalize failures for longer, making
+    mission control less likely to route through nodes and channels that we
+    have previously recorded failures for.
+    */
+    uint64 half_life_seconds = 1;
+
+    /*
+    The probability of success mission control should assign to hop in a route
+    where it has no other information available. Higher values will make mission
+    control more willing to try hops that we have no information about, lower
+    values will discourage trying these hops.
+    */
+    float hop_probability = 2;
+
+    /*
+    The importance that mission control should place on historical results,
+    expressed as a value in [0;1]. Setting this value to 1 will ignore all
+    historical payments and just use the hop probability to assess the
+    probability of success for each hop. A zero value ignores hop probability
+    completely and relies entirely on historical results, unless none are
+    available.
+    */
+    float weight = 3;
+
+    /*
+    The maximum number of payment results that mission control will store.
+    */
+    uint32 maximum_payment_results = 4;
+
+    /*
+    The minimum time that must have passed since the previously recorded failure
+    before we raise the failure amount.
+    */
+    uint64 minimum_failure_relax_interval = 5;
+}
+
+message QueryProbabilityRequest {
+    // The source node pubkey of the pair.
+    bytes from_node = 1;
+
+    // The destination node pubkey of the pair.
+    bytes to_node = 2;
+
+    // The amount for which to calculate a probability.
+    int64 amt_msat = 3;
+}
+
+message QueryProbabilityResponse {
+    // The success probability for the requested pair.
+    double probability = 1;
+
+    // The historical data for the requested pair.
+    PairData history = 2;
+}
+
+message BuildRouteRequest {
+    /*
+    The amount to send expressed in msat. If set to zero, the minimum routable
+    amount is used.
+    */
+    int64 amt_msat = 1;
+
+    /*
+    CLTV delta from the current height that should be used for the timelock
+    of the final hop
+    */
+    int32 final_cltv_delta = 2;
+
+    /*
+    The channel id of the channel that must be taken to the first hop. If zero,
+    any channel may be used.
+    */
+    uint64 outgoing_chan_id = 3 [jstype = JS_STRING];
+
+    /*
+    A list of hops that defines the route. This does not include the source hop
+    pubkey.
+    */
+    repeated bytes hop_pubkeys = 4;
+
+    // An optional payment addr to be included within the last hop of the route.
+    bytes payment_addr = 5;
+}
+
+message BuildRouteResponse {
+    /*
+    Fully specified route that can be used to execute the payment.
+    */
+    lnrpc.Route route = 1;
+}
+
+message SubscribeHtlcEventsRequest {
+}
+
+/*
+HtlcEvent contains the htlc event that was processed. These are served on a
+best-effort basis; events are not persisted, delivery is not guaranteed
+(in the event of a crash in the switch, forward events may be lost) and
+some events may be replayed upon restart. Events consumed from this package
+should be de-duplicated by the htlc's unique combination of incoming and
+outgoing channel id and htlc id. [EXPERIMENTAL]
+*/
+message HtlcEvent {
+    /*
+    The short channel id that the incoming htlc arrived at our node on. This
+    value is zero for sends.
+    */
+    uint64 incoming_channel_id = 1;
+
+    /*
+    The short channel id that the outgoing htlc left our node on. This value
+    is zero for receives.
+    */
+    uint64 outgoing_channel_id = 2;
+
+    /*
+    Incoming id is the index of the incoming htlc in the incoming channel.
+    This value is zero for sends.
+    */
+    uint64 incoming_htlc_id = 3;
+
+    /*
+    Outgoing id is the index of the outgoing htlc in the outgoing channel.
+    This value is zero for receives.
+    */
+    uint64 outgoing_htlc_id = 4;
+
+    /*
+    The time in unix nanoseconds that the event occurred.
+    */
+    uint64 timestamp_ns = 5;
+
+    enum EventType {
+        UNKNOWN = 0;
+        SEND = 1;
+        RECEIVE = 2;
+        FORWARD = 3;
+    }
+
+    /*
+    The event type indicates whether the htlc was part of a send, receive or
+    forward.
+    */
+    EventType event_type = 6;
+
+    oneof event {
+        ForwardEvent forward_event = 7;
+        ForwardFailEvent forward_fail_event = 8;
+        SettleEvent settle_event = 9;
+        LinkFailEvent link_fail_event = 10;
+    }
+}
+
+message HtlcInfo {
+    // The timelock on the incoming htlc.
+    uint32 incoming_timelock = 1;
+
+    // The timelock on the outgoing htlc.
+    uint32 outgoing_timelock = 2;
+
+    // The amount of the incoming htlc.
+    uint64 incoming_amt_msat = 3;
+
+    // The amount of the outgoing htlc.
+    uint64 outgoing_amt_msat = 4;
+}
+
+message ForwardEvent {
+    // Info contains details about the htlc that was forwarded.
+    HtlcInfo info = 1;
+}
+
+message ForwardFailEvent {
+}
+
+message SettleEvent {
+}
+
+message LinkFailEvent {
+    // Info contains details about the htlc that we failed.
+    HtlcInfo info = 1;
+
+    // FailureCode is the BOLT error code for the failure.
+    lnrpc.Failure.FailureCode wire_failure = 2;
+
+    /*
+    FailureDetail provides additional information about the reason for the
+    failure. This detail enriches the information provided by the wire message
+    and may be 'no detail' if the wire message requires no additional metadata.
+    */
+    FailureDetail failure_detail = 3;
+
+    // A string representation of the link failure.
+    string failure_string = 4;
+}
+
+enum FailureDetail {
+    UNKNOWN = 0;
+    NO_DETAIL = 1;
+    ONION_DECODE = 2;
+    LINK_NOT_ELIGIBLE = 3;
+    ON_CHAIN_TIMEOUT = 4;
+    HTLC_EXCEEDS_MAX = 5;
+    INSUFFICIENT_BALANCE = 6;
+    INCOMPLETE_FORWARD = 7;
+    HTLC_ADD_FAILED = 8;
+    FORWARDS_DISABLED = 9;
+    INVOICE_CANCELED = 10;
+    INVOICE_UNDERPAID = 11;
+    INVOICE_EXPIRY_TOO_SOON = 12;
+    INVOICE_NOT_OPEN = 13;
+    MPP_INVOICE_TIMEOUT = 14;
+    ADDRESS_MISMATCH = 15;
+    SET_TOTAL_MISMATCH = 16;
+    SET_TOTAL_TOO_LOW = 17;
+    SET_OVERPAID = 18;
+    UNKNOWN_INVOICE = 19;
+    INVALID_KEYSEND = 20;
+    MPP_IN_PROGRESS = 21;
+    CIRCULAR_ROUTE = 22;
+}
+
+enum PaymentState {
+    /*
+    Payment is still in flight.
+    */
+    IN_FLIGHT = 0;
+
+    /*
+    Payment completed successfully.
+    */
+    SUCCEEDED = 1;
+
+    /*
+    There are more routes to try, but the payment timeout was exceeded.
+    */
+    FAILED_TIMEOUT = 2;
+
+    /*
+    All possible routes were tried and failed permanently. Or were no
+    routes to the destination at all.
+    */
+    FAILED_NO_ROUTE = 3;
+
+    /*
+    A non-recoverable error has occured.
+    */
+    FAILED_ERROR = 4;
+
+    /*
+    Payment details incorrect (unknown hash, invalid amt or
+    invalid final cltv delta)
+    */
+    FAILED_INCORRECT_PAYMENT_DETAILS = 5;
+
+    /*
+    Insufficient local balance.
+    */
+    FAILED_INSUFFICIENT_BALANCE = 6;
+}
+
+message PaymentStatus {
+    // Current state the payment is in.
+    PaymentState state = 1;
+
+    /*
+    The pre-image of the payment when state is SUCCEEDED.
+    */
+    bytes preimage = 2;
+
+    reserved 3;
+
+    /*
+    The HTLCs made in attempt to settle the payment [EXPERIMENTAL].
+    */
+    repeated lnrpc.HTLCAttempt htlcs = 4;
+}
+
+message CircuitKey {
+    /// The id of the channel that the is part of this circuit.
+    uint64 chan_id = 1;
+
+    /// The index of the incoming htlc in the incoming channel.
+    uint64 htlc_id = 2;
+}
+
+message ForwardHtlcInterceptRequest {
+    /*
+    The key of this forwarded htlc. It defines the incoming channel id and
+    the index in this channel.
+    */
+    CircuitKey incoming_circuit_key = 1;
+
+    // The incoming htlc amount.
+    uint64 incoming_amount_msat = 5;
+
+    // The incoming htlc expiry.
+    uint32 incoming_expiry = 6;
+
+    /*
+    The htlc payment hash. This value is not guaranteed to be unique per
+    request.
+    */
+    bytes payment_hash = 2;
+
+    // The requested outgoing channel id for this forwarded htlc. Because of
+    // non-strict forwarding, this isn't necessarily the channel over which the
+    // packet will be forwarded eventually. A different channel to the same peer
+    // may be selected as well.
+    uint64 outgoing_requested_chan_id = 7;
+
+    // The outgoing htlc amount.
+    uint64 outgoing_amount_msat = 3;
+
+    // The outgoing htlc expiry.
+    uint32 outgoing_expiry = 4;
+
+    // Any custom records that were present in the payload.
+    map<uint64, bytes> custom_records = 8;
+
+    // The onion blob for the next hop
+    bytes onion_blob = 9;
+}
+
+/**
+ForwardHtlcInterceptResponse enables the caller to resolve a previously hold
+forward. The caller can choose either to:
+- `Resume`: Execute the default behavior (usually forward).
+- `Reject`: Fail the htlc backwards.
+- `Settle`: Settle this htlc with a given preimage.
+*/
+message ForwardHtlcInterceptResponse {
+    /**
+    The key of this forwarded htlc. It defines the incoming channel id and
+    the index in this channel.
+    */
+    CircuitKey incoming_circuit_key = 1;
+
+    // The resolve action for this intercepted htlc.
+    ResolveHoldForwardAction action = 2;
+
+    // The preimage in case the resolve action is Settle.
+    bytes preimage = 3;
+}
+
+enum ResolveHoldForwardAction {
+    SETTLE = 0;
+    FAIL = 1;
+    RESUME = 2;
+}
+
+message UpdateChanStatusRequest {
+    lnrpc.ChannelPoint chan_point = 1;
+
+    ChanStatusAction action = 2;
+}
+
+enum ChanStatusAction {
+    ENABLE = 0;
+    DISABLE = 1;
+    AUTO = 2;
+}
+
+message UpdateChanStatusResponse {
+}

proto/service/methods.proto

@@ -0,0 +1,80 @@
+syntax = "proto3";
+
+package methods;
+
+import "google/protobuf/descriptor.proto";
+import "structs.proto";
+
+option go_package = "github.com/shocknet/lightning.pub";
+option (file_options) = {
+    supported_http_methods:["post", "get"];
+    supported_auths:[
+        {
+            id: "no_auth"
+            name: "NoAuth"
+            context:[] 
+        },
+        {
+            id: "guest" 
+            name: "Guest", 
+            context:{
+                key:"token", 
+                value:"string"
+            }
+        },
+        {
+            id: "admin", 
+            name: "Admin", 
+            encrypted:true, 
+            context:{
+                key:"pub", 
+                value:"string"
+            }
+        }
+    ];
+};
+
+message MethodQueryOptions {
+    repeated string items = 1;
+}
+
+extend google.protobuf.MethodOptions {  // TODO: move this stuff to dep repo?
+    string auth_type = 50003;
+    string http_method = 50004;
+    string http_route = 50005;
+    MethodQueryOptions query = 50006;
+
+}
+
+message ProtoFileOptions {
+    message SupportedAuth {
+        string id = 1;
+        string name = 2;
+        bool encrypted = 3;
+        map<string,string> context = 4;
+    }
+    repeated SupportedAuth supported_auths = 1;
+    repeated string supported_http_methods = 2;
+}
+
+extend google.protobuf.FileOptions {
+    ProtoFileOptions file_options = 50004;
+}
+
+service LightningPub {
+    rpc Health(structs.Empty) returns (structs.Empty){
+        option (auth_type)  = "NoAuth";
+        option (http_method) = "get";
+        option (http_route) = "/health";
+    };
+    rpc EncryptionExchange(structs.EncryptionExchangeRequest) returns (structs.Empty){
+        option (auth_type)  = "NoAuth";
+        option (http_method) = "post";
+        option (http_route) = "/api/encryption/exchange";
+    };
+    rpc LndGetInfo(structs.Empty) returns (structs.LndGetInfoResponse){
+        option (auth_type)  = "NoAuth";
+        option (http_method) = "get";
+        option (http_route) = "/api/lnd/getinfo";
+    };
+}

proto/service/structs.proto

@@ -0,0 +1,17 @@
+syntax = "proto3";
+
+package structs;
+
+option go_package = "github.com/shocknet/lightning.pub";
+
+message Empty {}
+
+
+message EncryptionExchangeRequest {
+    string public_key = 1;
+    string device_id = 2;
+}
+
+message LndGetInfoResponse {
+    string alias = 1;
+}