alexbosworth / lightning

Lightning client methods

Lightning

Methods for working with the Lightning Network

Selected Projects using Lightning

• bitpay.com crypto-rpc - https://github.com/bitpay/crypto-rpc
• channel.ninja - https://github.com/channelninja/channel.ninja
• coinos.io - https://github.com/coinos/coinos-server
• Galoy - https://github.com/GaloyMoney/galoy
• Lightning Poker - https://github.com/igreshev/lightning-poker
• Lightning Roulette - https://github.com/igreshev/lightning-roulette
• Lightning Shell - https://github.com/ibz/lightning-shell
• LNMarkets - https://github.com/lnmarkets/umbrel
• LNPingBot - https://github.com/swissrouting/lnpingbot
• MutinyWallet faucet - https://www.mutinywallet.com/
• p2plnbot - https://github.com/grunch/p2plnbot
• rekr - https://github.com/ryan-lingle/rekr
• stackernews - https://github.com/stackernews/stacker.news
• Suredbits API - https://github.com/Suredbits/sb-api-lnd
• Synonym Blocktank server - https://github.com/synonymdev/blocktank-server/
• Tarnhelm - https://github.com/bkiac/tarnhelm
• tbtcswaps - https://github.com/keep-community/tbtcswaps
• Thunderhub - https://github.com/apotdevin/thunderhub

LND Authentication

To connect to an LND node, authentication details are required.

Export credentials via CLI: balanceofsatoshis: npm install -g balanceofsatoshis and export via bos credentials --cleartext

Or export them manually:

Run base64 on the tls.cert and admin.macaroon files to get the encoded authentication data to create the LND connection. You can find these files in the LND directory. (~/.lnd or ~/Library/Application Support/Lnd)

base64 -w0 ~/.lnd/tls.cert
base64 -w0 ~/.lnd/data/chain/bitcoin/mainnet/admin.macaroon

You can then use these to interact with your LND node directly:

const {authenticatedLndGrpc} = require('lightning');

const {lnd} = authenticatedLndGrpc({
  cert: 'base64 encoded tls.cert file',
  macaroon: 'base64 encoded admin.macaroon file',
  socket: '127.0.0.1:10009',
});

To access unauthenticated methods like the wallet unlocker, use unauthenticatedLndGrpc instead.

Debugging

If you encounter any issues connecting and wish to view detailed information about the underlying grpc calls, you can run Node with these environment variables set:

GRPC_VERBOSITY=DEBUG GRPC_TRACE=all node YOURSCRIPTNAME.js

Methods

• addAdvertisedFeature: Add a new supported feature to the graph node announcement
• addExternalSocket: Add a new LN p2p network socket to node advertisement
• addPeer: Connect to a new peer
• authenticatedLndGrpc: Instantiate connection to authenticated lnd methods.
• beginGroupSigningSession: Start a new MuSig2 signing session
• broadcastChainTransaction: Publish an on-chain transaction to the network.
• cancelHodlInvoice: Cancel an open invoice.
• cancelPendingChannel: Cancel a pending channel.
• closeChannel: Close a channel out to the chain.
• changePassword: Update the wallet encryption passphrase.
• connectWatchtower: Connect a new watchtower.
• createChainAddress: Generate a chain address to receive on-chain funds.
• createHodlInvoice: Make a new off-chain invoice that will not automatically accept payment.
• createInvoice: Make a new off-chain invoice.
• createSeed: Generate a random wallet HD seed.
• createWallet: Make a new wallet.
• decodePaymentRequest: Get parsed details for a payment request.
• deleteChainTransaction Delete a broadcast chain transaction
• deleteFailedPayAttempts Remove failed payment paths from database.
• deleteFailedPayments Remove failed payments from the database.
• deleteForwardingReputations Clear pathfinding reputations of routing nodes and channels.
• deletePayment: Remove a past payment record.
• deletePayments: Remove all past payment records.
• diffieHellmanComputeSecret: Calculate a shared secret to enable symmetric encryption of data to another node.
• disableChannel: Signal disabled forwarding to a peer
• disconnectWatchtower: Remove a connected watchtower
• enableChannel: Signal forwarding enabled towards a peer.
• endGroupSigningSession: End a MuSig2 signing session
• fundPendingChannels: Provide a signed funding source for opening channels.
• fundPsbt: Make a PSBT with funds and change to setup a future on-chain spend.
• getAccessIds: List the access tokens granted permission to access the node.
• getAutopilot: Retrieve channel open autopilot configuration.
• getBackup: Get recovery details for a specific channel.
• getBackups: Get recovery details for all channels.
• getBlock: Get a block
• getBlockHeader: Get a block header
• getChainAddresses: Get a list of created chain addresses
• getChainBalance: Get the amount of on-chain funds.
• getChainFeeEstimate: Estimate a chain fee to send funds to an address.
• getChainFeeRate: Get an estimate for an on-chain fee rate.
• getChainTransaction: Get a wallet on-chain transaction.
• getChainTransactions: List past on-chain transactions.
• getChannel: Lookup network graph details about a channel.
• getChannelBalance: Calculate the total off-chain balance on the node.
• getChannels: List open channels on the node.
• getClosedChannels: List closed channels on the node.
• getConfiguration: Get the configuration file settings for the node and the log.
• getConnectedWatchtowers: List watchtowers that were added
• getEphemeralChannelIds: List other channel ids for channels
• getFailedPayments: List out past payments that failed.
• getFeeRates: List routing fee rates and routing policies of channels on the node.
• getForwardingConfidence: Calculate the pathfinding confidence score for routing a payment.
• getForwardingReputations: List the pathfinding reputations for payment routing.
• getForwards: List past forwards routed through the node.
• getHeight: Lookup the current best chain height.
• getIdentity: Derive the identity public key of the node.
• getInvoice: Lookup the status of an invoice.
• getInvoices: List details of all past open invoices and received payments.
• getLockedUtxos: List the UTXOs that are currently reserved and unavailable to coin selection.
• getMasterPublicKeys: List out master seed derived extended public keys and derivation paths.
• getMethods: List RPC methods and permissions required to use them.
• getNetworkCentrality: Calculate the graph centrality score of a node.
• getNetworkGraph: List all graph routing nodes and all channels.
• getNetworkInfo: Calculate network graph statistics.
• getNode: Retrieve graph details for a node and optionally list its channels.
• getPathfindingSettings: List out configuration options set for routing.
• getPayment: Lookup details about a past payment.
• getPayments: List details about past payment attempts and paid payment requests.
• getPeers: List details of connected nodes.
• getPendingChainBalance: Calculate the unconfirmed on-chain balance.
• getPendingChannels: List details of opening or closing channels.
• getPendingPayments: List out past pending payments.
• getPublicKey: Derive a public key at a given index.
• getRouteConfidence: Check a route to see the pathfinding confidence score that a payment would succeed.
• getRouteThroughHops: Calculate a route through specified nodes.
• getRouteToDestination: Calculate a route through the graph to a destination.
• getSettlementStatus: Lookup the status of a received payment output
• getSweepTransactions: List transactions that are sweeping funds on-chain.
• getTowerServerInfo: General information about a watchtower server running.
• getUtxos: List unspent transaction outputs in the on-chain wallet.
• getWalletInfo: Lookup general details about the node.
• getWalletStatus: Fetch the current state of the wallet.
• getWalletVersion: Retrieve the version and build tags of the node.
• grantAccess: Create an access credential macaroon to access the API.
• isDestinationPayable: Check if a destination can be paid
• lockUtxo: Lease a UTXO so it cannot be chosen to be spent.
• openChannel: Create a new channel to another node.
• openChannels: Open multiple channels in a single on-chain transaction batch.
• partiallySignPsbt: Add a partial signature to a PSBT
• pay: Make an off-chain payment.
• payViaPaymentDetails: Pay off-chain using details about a destination invoice.
• payViaPaymentRequest: Pay a payment request off-chain.
• payViaRoutes: Pay to a destination using a specified route or routes.
• prepareForChannelProposal: Prepare to receive a custom channel proposal.
• probeForRoute: Run a probe to find a route to pay to a destination.
• proposeChannel: Propose a new channel to a peer who has prepared for the channel proposal.
• recoverFundsFromChannel: Attempt to recover channel funds from a specific channel backup.
• recoverFundsFromChannels: Attempt to recover funds from multiple channels using a multiple channel backup.
• removeAdvertisedFeature: Remove a supported feature from the graph node announcement
• removeExternalSocket: Remove a LN p2p network socket from the node advertisement
• removePeer: Disconnect from a connected peer.
• requestChainFeeIncrease: Ask for a CPFP chain fee rate increase on a pending confirm UTXO.
• revokeAccess: Remove the access privileges of a previously issued access token macaroon credential.
• sendMessageToPeer: Send message to a connected peer.
• sendToChainAddress: Send funds on-chain to an address.
• sendToChainAddresses: Send funds on-chain to multiple chain addresses.
• sendToChainOutputScripts: Send funds on-chain to multiple chain destinations, specifying outputs scripts, not addresses.
• setAutopilot: Set the open channel autopilot configuration settings.
• settleHodlInvoice: Take incoming off-chain funds when an invoice has held funds from an incoming payment.
• signBytes: Use node keys to sign over an arbitrary set of bytes.
• signChainAddressMessage: Sign a message using the public key behind a chain address with ECDSA
• signMessage: Use the node identity key to generate a signed message that represents the public graph node identity.
• signPsbt: Sign inputs and finalize a partially signed transaction in the PSBT format to prepare it for broadcast.
• signTransaction: Generate signatures required for inputs on a transaction.
• stopDaemon: Send a shutdown request to cleanly kill the daemon.
• subscribeToBackups: Get notified on channel funds recovery backup file updates.
• subscribeToBlocks: Get notified when the Blockchain is updated.
• subscribeToChainAddress: Get notified when funds are sent to an on-chain address.
• subscribeToChainSpend: Get notified when a UTXO is spent.
• subscribeToChannels: Get notified when the set of active channels is updated.
• subscribeToForwardRequests: Get notified on requests to begin forward flows and interactively accept or reject or settle them.
• subscribeToForwards: Get notified on off-chain routed payment events.
• subscribeToGraph: Get notified of changes to the public routing graph nodes and channels.
• subscribeToInvoice: Get notified of status updates for incoming payments.
• subscribeToInvoices: Get notified of status updates on past created invoices.
• subscribeToOpenRequests: Get notified on requests to open an inbound channel and interactively accept or reject them.
• subscribeToPastPayment: Get notified of the current and ongoing status of a past off-chain payment.
• subscribeToPastPayments: Get notified of successful outgoing payments.
• subscribeToPayViaDetails: Make an off-chain payment using payment details and subscribe to the status of that payment.
• subscribeToPayViaRequest: Make an off-chain payment using a payment request and subscribe to the payment status.
• subscribeToPayViaRoutes: Start an off-chain payment using specific payment routes and subscribe to the payment result.
• subscribeToPayments: Subscribe to off-chain payments going out and being resolved
• subscribeToPeerMessages: Listen for incoming peer messages.
• subscribeToPeers: Listen to peer disconnect and connect events.
• subscribeToProbeForRoute: Start an off-chain probe to find a payable route and get notified on the status of the probe.
• subscribeToRpcRequests: Intercept all incoming and outgoing traffic to the RPC
• subscribeToTransactions: Get notified on on-chain transaction activity.
• subscribeToWalletStatus: Listen to updates to wallet state
• unauthenticatedLndGrpc: Create an lnd object for use with methods that do not require authentication credentials.
• unlockUtxo: Release a lease on a wallet UTXO to allow it to be selected for spending again.
• unlockWallet: Decrypt the wallet and start the daemon
• updateAlias: Update the advertised node alias
• updateChainTransaction: Edit the metadata of an on-chain transaction record.
• updateColor: Update the advertised node color
• updateConnectedWatchtower: Edit the settings on an added watchtower
• updateGroupSigningSession: Update a MuSig2 signing session with nonces and get a partial signature
• updatePathfindingSettings: Edit the configuration for routing calculations
• updateRoutingFees: Set the forwarding fees or other routing policies for a channel or all channels.
• verifyAccess: Confirm a macaroon has permission to access a given resource.
• verifyBackup: Check if a channel fund recovery backup file is valid.
• verifyBackups: Check if multiple channel fund recovery backups are valid.
• verifyBytesSignature: Check that a signature over arbitrary bytes is valid.
• verifyChainAddressMessage: Verify that a chain address message has a valid ECDSA signature
• verifyMessage: Check that a message from a node in the graph has a valid signature.

lightning's Issues

mtokens as string?

is there a reason why there are attributes like mtokens that are string?

I have not checked as the grpc, and not sure how the definition has been created (manually or programmatically from the protobuf?)

Typescript for subscribeToPayments

Added new method that has the same events as subscribeToPastPayment but encompasses all payments

Needs typescript definitions ping @bkiac

Add support for returning the full block in `subscribeToChainAddress`

This can be an optional argument like is_including_confirmed_block and then the raw confirmed block would be returned, on LND 0.15.1

Typescript for `openChannel`, `openChannels`

In release 6.2.0 support is added for base_fee_mtokens and fee_rate on openChannel and openChannels

base_fee_mtokens is a string for the mtokens to charge for base fee on routing to be set on channel open
fee_rate is a number which is the ppm fee to charge for routing to be set on channel open

ping @bkiac for typescript support on these fields

`paths` property on attempts in `GetPaymentsResult`

Description

We're looking at parsing/persisting payments data that we get back from this library in different ways and had a question about a new approach we're trying now.

We'd like to use the getPayments method to get info about distinct attempts related to a single payment (hash?). We noticed that for the getPayment method in its getPaymentResult object there is a paths property under the pending/payment property that would contain all the paths that a payment would take in the case of an MPP payment being done. Ideally we'd like to get this info from the getPayments call as well but we're not sure how this would be reflected within the attempts array in the GetPaymentsResult object.

Can there be more than one successful attempt in the attempts array in the case of an MPP attempt where parts of the MPP can succeed but the entire thing fails?

---

This was hard to phrase as a question, please do ask for clarification on any part of this that is unclear 😅

Tagging @jireva as well as the co-author of this

Migrate to TypeScript

I think it would be great to migrate the source code to TypeScript:

• type tests can be removed because the compiler would catch the errors
• JSDocs in a single file (the reason I'm copying the documentation from the JS files now is that it shows up in the context window on hover in IDEs)
  
• I find that TypeScript is generally easier to maintain; it would be easier for other developers to contribute to the project

The biggest blocker is getting the build, test, and publish process right. Then we can refactor incrementally.

We can keep the TypeScript rules lenient initially, so the development process doesn't have to change.

@alexbosworth, what do you think? I can set up an initial PR with the build tools, and after that, it should be straightforward to refactor individual files.

reconnect to a restarted lnd

I have a long lived node that is fetching the online status of a lnd.
if lnd restarts, trying to connect back to it using the saved {lnd} I have doesn't work:

    err: [
      503,
      "FailedToConnectToDaemon"
    ]

but even if I try to recreated the lnd object, I still have the same issue. any idea what could be wrong?

Type definitions on `GetPaymentResult`

I'm currently working on something that is pulling the type definitions from this library and I noticed there were some properties missing on the GetPaymentResult type that comes back in the method response.

Specifically it looks like these are missing from the "payment" property:

• fee
• paths

Does this look right, and would you be open to adding these to the type (I don't mind helping here)?

Not possible to pay sub-satoshi amount to zero-amount invoice

This works:

• pay({ lnd, request: invoice, mtokens: "1995" })

This errors with PaymentPathfindingFailedToFindPossibleRoute:

• pay({ lnd, request: invoice, mtokens: "995" })

Is this a feature or bug? 😅

Help request: Loading *.proto files fails on nextjs / serverless function

Hi!

I was hoping one of you could give me an advice, runnning lightning client as a serverless function fails in Nextjs, because of file not found. Do any of you have a tip/quickfix/hack to load the proto files?

Like copying them to the project and telling lighning where to find them?

I made a simple repo here to illustrate the issue: https://github.com/richard87/test-grpc

or the discussion about the root issue: vercel/next.js#8251

And feel free to close the issue, as its probably out of scope for the project!

[Feature Idea]: Add support for REST API endpoint

For LND methods, an opaque LND object is passed to execute the actual request and return a response

In addition to the gateway protocol LND and direct grpc LND, a REST LND could be passed which would translate the REST requests and responses back into gRPC style arguments so that the caller could use either endpoint at their discretion

Remove channel type data from channels

Since LND is breaking backwards compatibility with the channel type message with potentially no deprecation window, the results of channel type cannot be trusted in a backwards compatible way:
lightningnetwork/lnd#5890

To fix this issue, remove all references to what type of channel a channel is and wait for a future time when there is a reliable signal that can be used

Add types to `partiallySignPsbt`

There is a new method that needs types in lnd_methods/onchain - ping @bkiac

More examples?

Some context first:

I'm thinking of switching from lnService in favor or a more lightweight library on the server-side. The goal is to unify the API; as on the wallet-side I'm currently mostly using GRPC directly. Because lnService heavily changes variable name/ has specific ways to interpret GRPC responses, this is an overhead in the long run.

I guess this is the goal of this library, but I'm not too sure. some examples would be great to understand this better.

Change createChainAddress format argument to be optional

When calling createChainAddress currently the caller must specify which type of address to generate

Instead of specifying a format, createChainAddress could select its own default value, such as p2pwkh

deleteFailedPayAttempts / deleteFailedPayments not exposed at the root index.js level

not sure if this is intentional or not?

Add support for typescript stuff for `updateAlias` and `updateColor`

New methods added, support should be coming for this functionality in LND 0.15.0

Also addExternalSocket and removeExternalSocket

ping @bkiac

getState as probe?

Is the new getState call available as a probe or is it only exposed through the emitter interface? I would like to use it for a liveness check in Kubernetes so we would need to probe the node instead of listening for events. I would be happy to submit a PR if necessary.

Add type for `spending` in `signTransaction` for Taproot support

There is a new attribute for Taproot signing for specifying external inputs in a transaction to sign that needs types - ping @bkiac

Remove support for LND versions below 0.15.4

Since LND before 0.15.4 has issues syncing, usage of those versions would be limited

LND 0.14.5 can also be supported

[getForwards] add support for aliases

support returning aliases in get forwards results

Add types for `getMasterPublicKeys`

There is a new method that needs types in lnd_methods/onchain - ping @bkiac

some types are not in root/index.js voluntarily?

for instance to use getChainBalance, I need to import:

const { getChainBalance } = require("lightning/lnd_methods")

happy to do a PR for the missing types I see if that's helpful

[Question] Are there already plans to support cln-grpc?

Since version 0.11 core-lightning offers a grpc interface.
It would be very helpful for many tools if you could support this interface.

https://github.com/ElementsProject/lightning/blob/master/cln-grpc/proto/node.proto

Legacy address support for `getChainFeeEstimate` function

Just double-checking, is there support for legacy addresses with this function?

I tried calling it with 1lhuauzvup3wvkn4ptgcsqwxqknswujqnw and got back the error:

err: [
    503,
    "UnexpectedErrEstimatingFeeForChainSend",
    {
    "err": {
        "code": 2,
        "details": "decoded address is of unknown format",
        "metadata": {
        "content-type": [
            "application/grpc"
        ]
        }
    }
    }
]

Typescript for schnorr signing

5.18.0 adds type to signBytes arguments

type is a string that can be ecdsa or schnorr

This can be updated in typescript definitions, ping @bkiac

getPayment and getPayments should return the same payment details

currently getPayment has some missing attributes (like creation date)

Related info

TrackPaymentV2: https://api.lightning.community/#trackpaymentv2
ListPayments: https://api.lightning.community/#listpayments

[subscribeToForwardRequests] - add support for reject reasons

Add compatibility with reject reasons

GetTowerServerInfo is missing its types

The interfaces are not implemented and this method is not being exported. I forked the repo and I'm fixing it

Add method subscribeToPayments for all initiated payments

The method subscribeToPastPayments only shows settled payments, so subscribeToPayments would be showing payments that were currently going out as well

This will be supported in LND 0.16.0 via https://github.com/lightningnetwork/lnd/pull/6335/files

Method signature {lnd}, returns an emitter with confirmed, failed, paying events like subscribeToPastPayment

Adding support for lndconnect

It would be nice to be able to pass an LND connect URI for authenticating clients.

const lndConnect = 'lndconnect://1.2.3.4:10009?cert=MIICuDCCAl...&macaroon=0201036c6...'
const authenticatedClient = authenticatedLndGrpc({ lndConnect });

It could rely on an already existing library like LN-Zap/node-lndconnect.

Unimplemented error when trying to make payments

Hi, I am trying to make a payment (payViaPaymentRequest) using a btcpay server deployed on lunanode with a self signed certificate and I am getting UnexpectedPaymentError.

This is the code that is rising the error:

	try {
		payment = await payViaPaymentRequest({
		  	lnd,
	  		request: paymentData.request,
		});
	} catch (e) {
		console.error(e);
		return res.status(500).send({ error: 'Payment failed' });
	}

and this is the error:

        [
	  503,
	  'UnexpectedPaymentError',
	  {
	    err: Error: 12 UNIMPLEMENTED: 
	        at Object.callErrorFromStatus (/code/node_modules/@grpc/grpc-js/build/src/call.js:31:26)
	        at Object.onReceiveStatus (/code/node_modules/@grpc/grpc-js/build/src/client.js:331:49)
	        at Object.onReceiveStatus (/code/node_modules/@grpc/grpc-js/build/src/client-interceptors.js:299:181)
	        at /code/node_modules/@grpc/grpc-js/build/src/call-stream.js:160:78
	        at processTicksAndRejections (node:internal/process/task_queues:78:11) {
	      code: 12,
	      details: '',
	      metadata: [Metadata]
	    }
	  }
	]

If I try to get payments (getPayments) or get and create invoices (getInvoices, createInvoice) it works

Add getPendingPayments or allow to pass include_incomplete

Trying to create a fallback for this lightningnetwork/lnd#6249 we found that there is no way to get pending payments (and now we know that we can't trust in trackpayment response).

Do you prefer getPendingPayments or include include_incomplete in getPayments?

Let us know what you prefer to push a PR

thanks in advance

ps: also would be useful get the raw status https://github.com/alexbosworth/lightning/blob/master/lnd_responses/rpc_payment_as_payment.js#L206 because we delete failed attemps so is not possible to compare against track payment

open telemetry?

we have had some peek some days ago where we had thousands of request per minutes, and our app went offline for a brief period. to better understand how to properly scale the backend we would like to add open telemetry and a jaeger or jaeger-equivalent to trace all the internal queries and understand which one takes longer under heavy load.

if it something you'd like add to this repo, or be ok to merge a PR if we're doing one? I have not look at GRPC with open telemetry but I think we may have this ability to trace GRPC calls without the need to change something on the lnd side, but still something to investigate.

Add custom error messages for invalid cert

TLS certs are often a source of problems, so the cert being wrong could be checked somehow and give a custom error

[Question] Is there any way to terminate a subscription for the client side?

I'm working with the subscribeToInvoices method in some tests and am trying to figure out if there's a way to explicitly end the subscription when I'm done with using it.

Potential issue with result of getForwardingReputations

Forwarding reputations may be returning invalid results through the mapping from the result. That may be due to changes that happened as the API was developed and pathfinding methodology changed

Add support for `skip_temp_err` to `payViaRoutes`

When paying via routes in an MPP context, any error will cause the entire payment to no longer be accessible for new shards

In LND 0.15.1 there was a change in the API surface that allows for attaching new shards if the failure on the route is a temporary channel failure

Potentially this flag should be added to every invocation of the API since it in theory it is always safe, testing is needed to confirm that is in fact the case

Typescript for trusted funding

5.17.0 adds the following changes:

getChannels: Add support for is_trusted_funding and other_ids
getClosedChannels: Add support for other_ids
getEphemeralChannelIds: Add method to get other channel ids
openChannels: Add support for is_trusted_funding for instant opening
subscribeToChannels: Add support for is_trusted_funding, other_ids
subscribeToOpenRequests: Add support for is_trusted_funding

These can be updated in typescript definitions, ping @bkiac

is_trusted_funding is always a boolean or undefined
other ids is always an array of strings (standard format channel ids)

Typescript for locked utxos

Version 5.20.0 adds preparatory support for LND 0.15.1 new locked utxos fields:

getLockedUtxos:

• output_script: output script serialized as hex string
• tokens: value of the outpoint number

These values are undefined on LND 0.15.0 and below when not present in response

Need expanded definitions for method result

ping @bkiac

Two events with differing data fired

I am using subscribeToForwards to monitor forwards through my node and record the fee earned for accounting purposes.
While testing out on regtest, I found that each forward was generating two events, and both contained slightly different data.

{
  forward: {
    at: '2021-04-01T18:41:33.333Z',
    cltv_delta: 60,
    external_failure: undefined,
    fee: 1,
    fee_mtokens: '1000',
    in_channel: '454x1x0',
    in_payment: 1,
    internal_failure: undefined,
    is_confirmed: false,
    is_failed: false,
    is_receive: false,
    is_send: false,
    mtokens: '20000',
    out_channel: '555x1x0',
    out_payment: 1,
    timeout: 623,
    tokens: 20
  }
}
{
  forward: {
    at: '2021-04-01T18:41:33.436Z',
    cltv_delta: undefined,
    external_failure: undefined,
    fee: undefined,
    fee_mtokens: undefined,
    in_channel: '454x1x0',
    in_payment: 1,
    internal_failure: undefined,
    is_confirmed: true,
    is_failed: false,
    is_receive: false,
    is_send: false,
    mtokens: undefined,
    out_channel: '555x1x0',
    out_payment: 1,
    timeout: undefined,
    tokens: undefined
  }
}

As can be seen, the first event has the fee related info that I want, but the is_confirmed field is false, hence I do not want to use this data. I want to use the data (fee_mtokens specifically) from the event where the is_confirmed is true. However, all the forwards result in these two objects where in the second object, the is_confirmed is true but the fee data is undefined.

Missing types

lnd_methods are fully typed now, what other modules/methods are you planning to export that still need types? Since the project isn't written in TypeScript creating types for internal methods is unnecessary.

Add neutrinorpc methods support

There is an API subserver for Neutrino that could be supported https://github.com/lightningnetwork/lnd/blob/master/lnrpc/neutrinorpc/neutrino.proto

Dependency of node 12?

Trying to update ln-service give me this error:

$ yarn upgrade ln-service
yarn upgrade v1.21.1
[1/5] 🔍  Validating package.json...
[2/5] 🔍  Resolving packages...
warning ln-service > [email protected]: Development of this module has been stopped.
warning ln-service > lightning > [email protected]: Development of this module has been stopped.
[3/5] 🚚  Fetching packages...
error [email protected]: The engine "node" is incompatible with this module. Expected version ">=12.0.0". Got "10.16.3"
error Found incompatible module.

I'm running my code on the firebase function (ie: "serverless") which has not yet an engine for node 12 so I'm wondering if this is something that can be easily worked around

[getNodeInfo] add support for custom tlv records

show custom tlv records that are associated with nodes

Add support for typescript stuff for taproot in signTransaction

witness_script was made optional for signing spends that don't have a witness script

root_hash hex string was added for specifying taproot scripts root merkle tree hash

Change argument `confirmation_target` in `getChainFeeRate`

target confirmations is called confirmation_target but everywhere else the same concept is target_confirmations

These should be consolidated

Add support for reserved amount balance lookups

In LND 0.15.1 a new lookup API is possible to see how much of the on-chain balance is currently reserved for anchor channels and therefore is un-spendable

`pending` array missing from `getPayment` method return

For cases where the payment is pending, according to the function's documentation we should see a payment pending property with an array of the payments. This is usually missing from the return from my testing so far:

// Object returned from `getPayment` when payment is pending
{
  failed: undefined,
  is_confirmed: false,
  is_failed: false,
  is_pending: true,
  payment: undefined
}

[subscribeToForwards] - add support for subscription and final settle events

Add support for the new event types