lightning 10.1.3 → 10.2.0

package/CHANGELOG.md

@@ -1,6 +1,11 @@
 # Versions
 
-## 10.1.3
+## 10.2.0
+
+- `deleteChainTransaction`: Add method to delete a chain transaction
+- `getChainTransaction`: Add method to get a chain transaction
+
+## 10.1.4
 
 - `getBlockHeader`: Add method to get the header portion of a block
 

package/README.md

@@ -110,6 +110,8 @@ variables set:
 - [createWallet](https://github.com/alexbosworth/ln-service#createwallet): Make a new wallet.
 - [decodePaymentRequest](https://github.com/alexbosworth/ln-service#decodepaymentrequest):
     Get parsed details for a payment request.
+- [deleteChainTransaction](https://github.com/alexbosworth/ln-service#deletechaintransaction)
+    Delete a broadcast chain transaction
 - [deleteFailedPayAttempts](https://github.com/alexbosworth/ln-service#deletefailedpayattempts)
     Remove failed payment paths from database.
 - [deleteFailedPayments](https://github.com/alexbosworth/ln-service#deletefailedpayments)
@@ -153,6 +155,8 @@ variables set:
     Estimate a chain fee to send funds to an address.
 - [getChainFeeRate](https://github.com/alexbosworth/ln-service#getchainfeerate): Get an estimate
     for an on-chain fee rate.
+- [getChainTransaction](https://github.com/alexbosworth/ln-service#getchaintransaction):
+    Get a wallet on-chain transaction.
 - [getChainTransactions](https://github.com/alexbosworth/ln-service#getchaintransactions): List
     past on-chain transactions.
 - [getChannel](https://github.com/alexbosworth/ln-service#getchannel): Lookup network graph

package/grpc/protos/walletkit.proto

@@ -7,6 +7,24 @@ package walletrpc;
 
 option go_package = "github.com/lightningnetwork/lnd/lnrpc/walletrpc";
 
+/*
+ * Comments in this file will be directly parsed into the API
+ * Documentation as descriptions of the associated method, message, or field.
+ * These descriptions should go right above the definition of the object, and
+ * can be in either block or // comment format.
+ *
+ * An RPC method can be matched to an lncli command by placing a line in the
+ * beginning of the description in exactly the following format:
+ * lncli: `methodname`
+ *
+ * Failure to specify the exact name of the command will cause documentation
+ * generation to fail.
+ *
+ * More information on how exactly the gRPC documentation is generated from
+ * this proto file can be found here:
+ * https://github.com/lightninglabs/lightning-api
+ */
+
 // WalletKit is a service that gives access to the core functionalities of the
 // daemon's wallet.
 service WalletKit {
@@ -18,7 +36,7 @@ service WalletKit {
     */
     rpc ListUnspent (ListUnspentRequest) returns (ListUnspentResponse);
 
-    /*
+    /* lncli: `wallet leaseoutput`
     LeaseOutput locks an output to the given ID, preventing it from being
     available for any future coin selection attempts. The absolute time of the
     lock's expiration is returned. The expiration of the lock can be extended by
@@ -27,14 +45,14 @@ service WalletKit {
     */
     rpc LeaseOutput (LeaseOutputRequest) returns (LeaseOutputResponse);
 
-    /*
+    /* lncli: `wallet releaseoutput`
     ReleaseOutput unlocks an output, allowing it to be available for coin
     selection if it remains unspent. The ID should match the one used to
     originally lock the output.
     */
     rpc ReleaseOutput (ReleaseOutputRequest) returns (ReleaseOutputResponse);
 
-    /*
+    /* lncli: `wallet listleases`
     ListLeases lists all currently locked utxos.
     */
     rpc ListLeases (ListLeasesRequest) returns (ListLeasesResponse);
@@ -57,14 +75,19 @@ service WalletKit {
     */
     rpc NextAddr (AddrRequest) returns (AddrResponse);
 
-    /*
+    /* lncli: `wallet gettx`
+    GetTransaction returns details for a transaction found in the wallet.
+    */
+    rpc GetTransaction (GetTransactionRequest) returns (lnrpc.Transaction);
+
+    /* lncli: `wallet accounts list`
     ListAccounts retrieves all accounts belonging to the wallet by default. A
     name and key scope filter can be provided to filter through all of the
     wallet accounts and return only those matching.
     */
     rpc ListAccounts (ListAccountsRequest) returns (ListAccountsResponse);
 
-    /*
+    /* lncli: `wallet requiredreserve`
     RequiredReserve returns the minimum amount of satoshis that should be kept
     in the wallet in order to fee bump anchor channels if necessary. The value
     scales with the number of public anchor channels but is capped at a maximum.
@@ -72,14 +95,14 @@ service WalletKit {
     rpc RequiredReserve (RequiredReserveRequest)
         returns (RequiredReserveResponse);
 
-    /*
+    /* lncli: `wallet addresses list`
     ListAddresses retrieves all the addresses along with their balance. An
     account name filter can be provided to filter through all of the
     wallet accounts and return the addresses of only those matching.
     */
     rpc ListAddresses (ListAddressesRequest) returns (ListAddressesResponse);
 
-    /*
+    /* lncli: `wallet addresses signmessage`
     SignMessageWithAddr returns the compact signature (base64 encoded) created
     with the private key of the provided address. This requires the address
     to be solely based on a public key lock (no scripts). Obviously the internal
@@ -96,7 +119,7 @@ service WalletKit {
     rpc SignMessageWithAddr (SignMessageWithAddrRequest)
         returns (SignMessageWithAddrResponse);
 
-    /*
+    /* lncli: `wallet addresses verifymessage`
     VerifyMessageWithAddr returns the validity and the recovered public key of
     the provided compact signature (base64 encoded). The verification is
     twofold. First the validity of the signature itself is checked and then
@@ -120,7 +143,7 @@ service WalletKit {
     rpc VerifyMessageWithAddr (VerifyMessageWithAddrRequest)
         returns (VerifyMessageWithAddrResponse);
 
-    /*
+    /* lncli: `wallet accounts import`
     ImportAccount imports an account backed by an account extended public key.
     The master key fingerprint denotes the fingerprint of the root key
     corresponding to the account public key (also known as the key with
@@ -147,7 +170,7 @@ service WalletKit {
     */
     rpc ImportAccount (ImportAccountRequest) returns (ImportAccountResponse);
 
-    /*
+    /* lncli: `wallet accounts import-pubkey`
     ImportPublicKey imports a public key as watch-only into the wallet. The
     public key is converted into a simple address of the given type and that
     address script is watched on chain. For Taproot keys, this will only watch
@@ -177,7 +200,7 @@ service WalletKit {
     rpc ImportTapscript (ImportTapscriptRequest)
         returns (ImportTapscriptResponse);
 
-    /*
+    /* lncli: `wallet publishtx`
     PublishTransaction attempts to publish the passed transaction to the
     network. Once this returns without an error, the wallet will continually
     attempt to re-broadcast the transaction on start up, until it enters the
@@ -185,6 +208,13 @@ service WalletKit {
     */
     rpc PublishTransaction (Transaction) returns (PublishResponse);
 
+    /* lncli: `wallet removetx`
+    RemoveTransaction attempts to remove the provided transaction from the
+    internal transaction store of the wallet.
+    */
+    rpc RemoveTransaction (GetTransactionRequest)
+        returns (RemoveTransactionResponse);
+
     /*
     SendOutputs is similar to the existing sendmany call in Bitcoind, and
     allows the caller to create a transaction that sends to several outputs at
@@ -199,7 +229,7 @@ service WalletKit {
     */
     rpc EstimateFee (EstimateFeeRequest) returns (EstimateFeeResponse);
 
-    /*
+    /* lncli: `pendingsweeps`
     PendingSweeps returns lists of on-chain outputs that lnd is currently
     attempting to sweep within its central batching engine. Outputs with similar
     fee rates are batched together in order to sweep them within a single
@@ -211,7 +241,7 @@ service WalletKit {
     */
     rpc PendingSweeps (PendingSweepsRequest) returns (PendingSweepsResponse);
 
-    /*
+    /* lncli: `wallet bumpfee`
     BumpFee bumps the fee of an arbitrary input within a transaction. This RPC
     takes a different approach than bitcoind's bumpfee command. lnd has a
     central batching engine in which inputs with similar fee rates are batched
@@ -240,14 +270,14 @@ service WalletKit {
     */
     rpc BumpFee (BumpFeeRequest) returns (BumpFeeResponse);
 
-    /*
+    /* lncli: `wallet listsweeps`
     ListSweeps returns a list of the sweep transactions our node has produced.
     Note that these sweeps may not be confirmed yet, as we record sweeps on
     broadcast, not confirmation.
     */
     rpc ListSweeps (ListSweepsRequest) returns (ListSweepsResponse);
 
-    /*
+    /* lncli: `wallet labeltx`
     LabelTransaction adds a label to a transaction. If the transaction already
     has a label the call will fail unless the overwrite bool is set. This will
     overwrite the exiting transaction label. Labels must not be empty, and
@@ -256,7 +286,7 @@ service WalletKit {
     rpc LabelTransaction (LabelTransactionRequest)
         returns (LabelTransactionResponse);
 
-    /*
+    /* lncli: `wallet psbt fund`
     FundPsbt creates a fully populated PSBT that contains enough inputs to fund
     the outputs specified in the template. There are two ways of specifying a
     template: Either by passing in a PSBT with at least one output declared or
@@ -293,7 +323,7 @@ service WalletKit {
     */
     rpc SignPsbt (SignPsbtRequest) returns (SignPsbtResponse);
 
-    /*
+    /* lncli: `wallet psbt finalize`
     FinalizePsbt expects a partial transaction with all inputs and outputs fully
     declared and tries to sign all inputs that belong to the wallet. Lnd must be
     the last signer of the transaction. That means, if there are any unsigned
@@ -538,6 +568,11 @@ message ListAddressesResponse {
     repeated AccountWithAddresses account_with_addresses = 1;
 }
 
+message GetTransactionRequest {
+    // The txid of the transaction.
+    string txid = 1;
+}
+
 message SignMessageWithAddrRequest {
     // The message to be signed. When using REST, this field must be encoded as
     // base64.
@@ -723,6 +758,7 @@ message Transaction {
     */
     string label = 2;
 }
+
 message PublishResponse {
     /*
     If blank, then no error occurred and the transaction was successfully
@@ -734,6 +770,11 @@ message PublishResponse {
     string publish_error = 1;
 }
 
+message RemoveTransactionResponse {
+    // The status of the remove transaction operation.
+    string status = 1;
+}
+
 message SendOutputsRequest {
     /*
     The number of satoshis per kilo weight that should be used when crafting

package/index.js

@@ -14,6 +14,7 @@ const {createInvoice} = require('./lnd_methods');
 const {createSeed} = require('./lnd_methods');
 const {createWallet} = require('./lnd_methods');
 const {decodePaymentRequest} = require('./lnd_methods');
+const {deleteChainTransaction} = require('./lnd_methods');
 const {deleteFailedPayAttempts} = require('./lnd_methods');
 const {deleteFailedPayments} = require('./lnd_methods');
 const {deleteForwardingReputations} = require('./lnd_methods');
@@ -37,6 +38,7 @@ const {getChainAddresses} = require('./lnd_methods');
 const {getChainBalance} = require('./lnd_methods');
 const {getChainFeeEstimate} = require('./lnd_methods');
 const {getChainFeeRate} = require('./lnd_methods');
+const {getChainTransaction} = require('./lnd_methods');
 const {getChainTransactions} = require('./lnd_methods');
 const {getChannel} = require('./lnd_methods');
 const {getChannelBalance} = require('./lnd_methods');
@@ -166,6 +168,7 @@ module.exports = {
   createSeed,
   createWallet,
   decodePaymentRequest,
+  deleteChainTransaction,
   deleteFailedPayAttempts,
   deleteFailedPayments,
   deleteForwardingReputations,
@@ -189,6 +192,7 @@ module.exports = {
   getChainBalance,
   getChainFeeEstimate,
   getChainFeeRate,
+  getChainTransaction,
   getChainTransactions,
   getChannel,
   getChannelBalance,

package/lnd_methods/generic/get_route_confidence.js

@@ -11,6 +11,7 @@ const decBase = 10;
 const defaultOdds = 950000;
 const fullConfidence = 1e6;
 const {isArray} = Array;
+const notFoundIndex = -1;
 const oddsDenominator = BigInt(1e6);
 const unimplemented = 'QueryProbabilityNotImplemented';
 
@@ -43,7 +44,7 @@ module.exports = ({from, hops, lnd}, cbk) => {
           return cbk([400, 'ExpectedArrayOfHopsToCalculateRoutingOdds']);
         }
 
-        if (!!hops.find(n => !n.channel || !n.public_key)) {
+        if (hops.findIndex(n => !n.public_key) !== notFoundIndex) {
           return cbk([400, 'ExpectedHopsWithEdges']);
         }
 

package/lnd_methods/index.js

@@ -13,6 +13,7 @@ const {createInvoice} = require('./invoices');
 const {createSeed} = require('./unauthenticated');
 const {createWallet} = require('./unauthenticated');
 const {decodePaymentRequest} = require('./offchain');
+const {deleteChainTransaction} = require('./onchain');
 const {deleteFailedPayAttempts} = require('./offchain');
 const {deleteFailedPayments} = require('./offchain');
 const {deleteForwardingReputations} = require('./offchain');
@@ -36,6 +37,7 @@ const {getChainAddresses} = require('./onchain');
 const {getChainBalance} = require('./onchain');
 const {getChainFeeEstimate} = require('./onchain');
 const {getChainFeeRate} = require('./onchain');
+const {getChainTransaction} = require('./onchain');
 const {getChainTransactions} = require('./onchain');
 const {getChannel} = require('./info');
 const {getChannelBalance} = require('./offchain');
@@ -164,6 +166,7 @@ module.exports = {
   createSeed,
   createWallet,
   decodePaymentRequest,
+  deleteChainTransaction,
   deleteFailedPayAttempts,
   deleteFailedPayments,
   deleteForwardingReputations,
@@ -187,6 +190,7 @@ module.exports = {
   getChainBalance,
   getChainFeeEstimate,
   getChainFeeRate,
+  getChainTransaction,
   getChainTransactions,
   getChannel,
   getChannelBalance,

package/lnd_methods/info/constants.json

@@ -19,6 +19,7 @@
   "prefAttachType": "preferential",
   "versions": {
     "0d5b0fefa4d9082f7964836f5e58c3a6bda8e471": "0.10.2-beta",
+    "13aa7f99248c7ee63989d3b62e0cbfe86d7b0964": "0.17.3-beta",
     "15c1eb13972f86a7c1e8cb084aa6d52700d685ff": "0.14.5-beta",
     "1a3194d302f33bb52823297d9d7f75cd37516053": "0.10.0-beta",
     "1e511be523eb8e97c4e2d9c89a7a263963a3929f": "0.14.2-beta",

package/lnd_methods/macaroon/methods.json

@@ -52,6 +52,10 @@
     "method": "DecodePayReq",
     "type": "default"
   },
+  "deleteChainTransaction": {
+    "method": "RemoveTransaction",
+    "type": "wallet"
+  },
   "deleteFailedPayAttempts": {
     "depends_on": ["deletePayment"],
     "method": "DeleteAllPayments",
@@ -145,6 +149,10 @@
     "method": "EstimateFee",
     "type": "wallet"
   },
+  "getChainTransaction": {
+    "method": "GetTransaction",
+    "type": "wallet"
+  },
   "getChainTransactions": {
     "method": "GetTransactions",
     "type": "default"

package/lnd_methods/onchain/delete_chain_transaction.js

@@ -0,0 +1,66 @@
+const asyncAuto = require('async/auto');
+const {returnResult} = require('asyncjs-util');
+
+const {isLnd} = require('./../../lnd_requests');
+
+const isHash = n => !!n && /^[0-9A-F]{64}$/i.test(n);
+const method = 'removeTransaction';
+const notSupported = /unknown.*walletrpc.WalletKit/;
+const statusSuccess = 'Successfully removed transaction';
+const type = 'wallet';
+
+/** Remove a chain transaction.
+
+  Requires `onchain:write` permission
+
+  This method is not supported on LND 0.17.3 and below
+
+  {
+    id: <Transaction Id Hex String>
+    lnd: <Authenticated LND API Object>
+  }
+
+  @returns via cbk or Promise
+*/
+module.exports = ({id, lnd}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!isHash(id)) {
+          return cbk([400, 'ExpectedIdentifyingTxHashOfChainTxToDelete']);
+        }
+
+        if (!isLnd({lnd, method, type})) {
+          return cbk([400, 'ExpectedLndToDeleteChainTransaction']);
+        }
+
+        return cbk();
+      },
+
+      // Delete the transaction
+      deleteTransaction: ['validate', ({}, cbk) => {
+        return lnd[type][method]({txid: id}, (err, res) => {
+          if (!!err && notSupported.test(err.details)) {
+            return cbk([501, 'RemoveChainTransactionMethodNotSupported']);
+          }
+
+          if (!!err) {
+            return cbk([503, 'UnexpectedDeleteChainTransactionError', {err}]);
+          }
+
+          if (!res) {
+            return cbk([503, 'ExpectedResponseDeletingChainTransaction']);
+          }
+
+          if (res.status !== statusSuccess) {
+            return cbk([503, 'UnexpectedResponseDeletingChainTransaction']);
+          }
+
+          return cbk();
+        });
+      }],
+    },
+    returnResult({reject, resolve}, cbk));
+  });
+};

package/lnd_methods/onchain/get_chain_transaction.js

@@ -0,0 +1,81 @@
+const asyncAuto = require('async/auto');
+const {returnResult} = require('asyncjs-util');
+
+const {isLnd} = require('./../../lnd_requests');
+const {rpcTxAsTransaction} = require('./../../lnd_responses');
+
+const isHash = n => !!n && /^[0-9A-F]{64}$/i.test(n);
+const method = 'getTransaction';
+const notSupported = /unknown.*walletrpc.WalletKit/;
+const type = 'wallet';
+
+/** Get a chain transaction.
+
+  Requires `onchain:read` permission
+
+  This method is not supported on LND 0.17.3 and below
+
+  {
+    id: <Transaction Id Hex String>
+    lnd: <Authenticated LND API Object>
+  }
+
+  @returns via cbk or Promise
+  {
+    [block_id]: <Block Hash String>
+    [confirmation_count]: <Confirmation Count Number>
+    [confirmation_height]: <Confirmation Block Height Number>
+    created_at: <Created ISO 8601 Date String>
+    [description]: <Transaction Label String>
+    [fee]: <Fees Paid Tokens Number>
+    id: <Transaction Id String>
+    inputs: [{
+      is_local: <Spent Outpoint is Local Bool>
+      transaction_id: <Transaction Id Hex String>
+      transaction_vout: <Transaction Output Index Number>
+    }]
+    is_confirmed: <Is Confirmed Bool>
+    is_outgoing: <Transaction Outbound Bool>
+    output_addresses: [<Address String>]
+    tokens: <Tokens Including Fee Number>
+    [transaction]: <Raw Transaction Hex String>
+  }
+*/
+module.exports = ({id, lnd}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!isHash(id)) {
+          return cbk([400, 'ExpectedIdentifyingTxHashOfChainTxToRetrieve']);
+        }
+
+        if (!isLnd({lnd, method, type})) {
+          return cbk([400, 'ExpectedLndToGetChainTransaction']);
+        }
+
+        return cbk();
+      },
+
+      // Get transaction
+      getTransaction: ['validate', ({}, cbk) => {
+        return lnd[type][method]({txid: id}, (err, res) => {
+          if (!!err && notSupported.test(err.details)) {
+            return cbk([501, 'GetChainTransactionMethodNotSupported']);
+          }
+
+          if (!!err) {
+            return cbk([503, 'UnexpectedGetChainTransactionError', {err}]);
+          }
+
+          try {
+            return cbk(null, rpcTxAsTransaction(res));
+          } catch (err) {
+            return cbk([503, err.message]);
+          }
+        });
+      }],
+    },
+    returnResult({reject, resolve, of: 'getTransaction'}, cbk));
+  });
+};

package/lnd_methods/onchain/index.js

@@ -1,6 +1,7 @@
 const broadcastChainTransaction = require('./broadcast_chain_transaction');
 const cancelPendingChannel = require('./cancel_pending_channel');
 const closeChannel = require('./close_channel');
+const deleteChainTransaction = require('./delete_chain_transaction');
 const fundPendingChannels = require('./fund_pending_channels');
 const fundPsbt = require('./fund_psbt');
 const getBlock = require('./get_block');
@@ -9,6 +10,7 @@ const getChainAddresses = require('./get_chain_addresses');
 const getChainBalance = require('./get_chain_balance');
 const getChainFeeEstimate = require('./get_chain_fee_estimate');
 const getChainFeeRate = require('./get_chain_fee_rate');
+const getChainTransaction = require('./get_chain_transaction');
 const getChainTransactions = require('./get_chain_transactions');
 const getLockedUtxos = require('./get_locked_utxos');
 const getMasterPublicKeys = require('./get_master_public_keys');
@@ -40,6 +42,7 @@ module.exports = {
   broadcastChainTransaction,
   cancelPendingChannel,
   closeChannel,
+  deleteChainTransaction,
   fundPendingChannels,
   fundPsbt,
   getBlock,
@@ -48,6 +51,7 @@ module.exports = {
   getChainBalance,
   getChainFeeEstimate,
   getChainFeeRate,
+  getChainTransaction,
   getChainTransactions,
   getLockedUtxos,
   getMasterPublicKeys,

package/package.json

@@ -7,11 +7,11 @@
     "url": "https://github.com/alexbosworth/lightning/issues"
   },
   "dependencies": {
-    "@grpc/grpc-js": "1.9.11",
+    "@grpc/grpc-js": "1.9.13",
     "@grpc/proto-loader": "0.7.10",
-    "@types/node": "20.9.2",
+    "@types/node": "20.10.4",
     "@types/request": "2.48.12",
-    "@types/ws": "8.5.9",
+    "@types/ws": "8.5.10",
     "async": "3.2.5",
     "asyncjs-util": "1.2.12",
     "bitcoinjs-lib": "6.1.5",
@@ -22,12 +22,12 @@
     "invoices": "3.0.0",
     "psbt": "3.0.0",
     "tiny-secp256k1": "2.2.3",
-    "type-fest": "4.8.1"
+    "type-fest": "4.8.3"
   },
   "description": "Lightning Network client library",
   "devDependencies": {
     "tsd": "0.29.0",
-    "typescript": "5.3.2"
+    "typescript": "5.3.3"
   },
   "engines": {
     "node": ">=18"
@@ -53,5 +53,5 @@
     "directory": "test/typescript"
   },
   "types": "index.d.ts",
-  "version": "10.1.3"
+  "version": "10.2.0"
 }

package/test/lnd_methods/generic/test_get_route_confidence.js

@@ -0,0 +1,143 @@
+const {deepStrictEqual} = require('node:assert').strict;
+const EventEmitter = require('events');
+const {rejects} = require('node:assert').strict;
+const test = require('node:test');
+
+const {getInfoResponse} = require('./../fixtures');
+const {getRouteConfidence} = require('./../../../');
+
+const makeLnd = ({err, res}) => {
+  return {
+    default: {
+      getInfo: ({}, cbk) => cbk(err, getInfoResponse),
+    },
+    router: {
+      queryMissionControl: ({}, cbk) => {
+        if (!!err) {
+          return cbk(err);
+        }
+
+        if (res !== undefined) {
+          return cbk(null, res);
+        }
+
+        return cbk(null, {
+          pairs: [{
+            history: {
+              fail_amt_msat: '1000',
+              fail_amt_sat: '1',
+              fail_time: '1',
+              success_amt_msat: '1000',
+              success_amt_sat: '1',
+              success_time: '1',
+            },
+            node_from: Buffer.alloc(33, 3),
+            node_to: Buffer.alloc(33, 2),
+          }],
+        });
+      },
+      queryProbability: ({}, cbk) => {
+        if (!!err) {
+          return cbk(err);
+        }
+
+        if (res !== undefined) {
+          return cbk(null, res);
+        }
+
+        return cbk(null, {history: {}, probability: 0.5});
+      },
+    },
+    wallet: {
+      deriveKey: ({}, cbk) => cbk('err'),
+    },
+  };
+};
+
+const tests = [
+  {
+    args: {},
+    description: 'Hops are required',
+    error: [400, 'ExpectedArrayOfHopsToCalculateRoutingOdds'],
+  },
+  {
+    args: {hops: [{}]},
+    description: 'Valid hops are required',
+    error: [400, 'ExpectedHopsWithEdges'],
+  },
+  {
+    args: {
+      from: Buffer.alloc(33, 1).toString('hex'),
+      hops: [{
+        forward_mtokens: '1',
+        public_key: Buffer.alloc(33, 2).toString('hex'),
+      }],
+      lnd: {
+        default: {
+          getInfo: ({}, cbk) => cbk(null, getInfoResponse),
+        },
+        router: {
+          queryMissionControl: ({}, cbk) => {
+            return cbk(null, {
+              pairs: [{
+                history: {
+                  fail_amt_msat: '1000',
+                  fail_amt_sat: '1',
+                  fail_time: '1',
+                  success_amt_msat: '1000',
+                  success_amt_sat: '1',
+                  success_time: '1',
+                },
+                node_from: Buffer.alloc(33, 3),
+                node_to: Buffer.alloc(33, 2),
+              }],
+            });
+          },
+          queryProbability: ({}, cbk) => cbk('err'),
+        },
+        wallet: {
+          deriveKey: ({}, cbk) => cbk('err'),
+        },
+      },
+    },
+    description: 'Get route confidence when confidence query returns err',
+    error: [503, 'UnexpectedErrorFromQueryProbability', {err: 'err'}],
+  },
+  {
+    args: {
+      from: Buffer.alloc(33, 1).toString('hex'),
+      hops: [{
+        forward_mtokens: '1',
+        public_key: Buffer.alloc(33, 2).toString('hex'),
+      }],
+      lnd: makeLnd({}),
+    },
+    description: 'Get route confidence from non self',
+    expected: {confidence: 950000},
+  },
+  {
+    args: {
+      hops: [{
+        forward_mtokens: '1',
+        public_key: Buffer.alloc(33, 2).toString('hex'),
+      }],
+      lnd: makeLnd({}),
+    },
+    description: 'Get route confidence',
+    expected: {confidence: 950000},
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async () => {
+    if (!!error) {
+      await rejects(getRouteConfidence(args), error, 'Got expected error');
+    } else {
+      const got = await getRouteConfidence(args);
+
+      deepStrictEqual(got, expected, 'Got expected result');
+    }
+
+    return;
+  });
+});

package/test/lnd_methods/offchain/test_is_destination_payable.js

@@ -0,0 +1,276 @@
+const {deepStrictEqual} = require('node:assert').strict;
+const EventEmitter = require('node:events');
+const {rejects} = require('node:assert').strict;
+const test = require('node:test');
+
+const {isDestinationPayable} = require('./../../../');
+
+const makePaymentData = overrides => {
+  const data = {
+    creation_date: '1',
+    creation_time_ns: '0',
+    failure_reason: 'FAILURE_REASON_TIMEOUT',
+    fee_msat: '1000',
+    fee_sat: '1',
+    htlcs: [{
+      attempt_time_ns: '1000000',
+      failure: {
+        channel_update: {
+          base_fee: '1000',
+          chain_hash: Buffer.alloc(32),
+          chan_id: '1',
+          channel_flags: 1,
+          extra_opaque_data: Buffer.alloc(1),
+          fee_rate: 1,
+          htlc_maximum_msat: '1000',
+          htlc_minimum_msat: '1000',
+          message_flags: 1,
+          signature: Buffer.alloc(71),
+          time_lock_delta: 1,
+          timestamp: 1,
+        },
+        code: 'UNREADABLE_FAILURE',
+        failure_source_index1: 1,
+        height: 1,
+        htlc_msat: '1000',
+      },
+      resolve_time_ns: '1000000',
+      route: {
+        hops: [{
+          amt_to_forward_msat: '1000',
+          chan_id: '1',
+          chan_capacity: 1,
+          expiry: 1,
+          fee_msat: '1000',
+          mpp_record: {
+            payment_addr: Buffer.alloc(32),
+            total_amt_msat: '1000',
+          },
+          pub_key: Buffer.alloc(33).toString('hex'),
+          tlv_payload: true,
+        }],
+        total_amt: '1',
+        total_amt_msat: '1000',
+        total_fees: '1',
+        total_fees_msat: '1000',
+        total_time_lock: 1,
+      },
+      status: 'FAILED',
+    }],
+    path: [Buffer.alloc(33).toString('hex'), Buffer.alloc(33).toString('hex')],
+    payment_hash: Buffer.alloc(32).toString('hex'),
+    payment_index: '1',
+    payment_preimage: Buffer.alloc(32).toString('hex'),
+    payment_request: 'lntb1500n1pdn4czkpp5ugdqer05qrrxuchrzkcue94th9w2xzasp9qm7d0yxcgp4uh4kn4qdpa2fjkzep6yprkcmmzv9kzqsmj09c8gmmrw4e8yetwvdujq5n9va6kcct5d9hkucqzysdlghdpua7uvjjkcfj49psxtlqzkp5pdncffdfk2cp3mp76thrl29qhqgzufm503pjj96586n5w6edgw3n66j4rxxs707y4zdjuhyt6qqe5weu4',
+    status: 'FAILED',
+    value: '1',
+    value_msat: '1000',
+    value_sat: '1',
+  };
+
+  Object.keys(overrides).forEach(k => data[k] = overrides[k]);
+
+  return data;
+};
+
+const makeLnd = args => {
+  return {
+    chain: {
+      registerBlockEpochNtfn: ({}) => {
+        const emitter = new EventEmitter();
+
+        emitter.cancel = () => {};
+
+        process.nextTick(() => emitter.emit('error', 'err'));
+
+        return emitter;
+      },
+    },
+    default: {
+      getInfo: ({}, cbk) => {
+        return cbk(null, {
+          alias: 'alias',
+          best_header_timestamp: 1,
+          block_hash: '00',
+          block_height: 1,
+          chains: [{chain: 'chain', network: 'network'}],
+          color: '#000000',
+          features: {'1': {is_known: true, is_required: false}},
+          identity_pubkey: Buffer.alloc(33).toString('hex'),
+          num_active_channels: 1,
+          num_peers: 1,
+          num_pending_channels: 1,
+          synced_to_chain: true,
+          uris: [],
+          version: 'version',
+        });
+      },
+    },
+    router: {
+      sendPaymentV2: ({}) => {
+        const data = args.data || makePaymentData({});
+        const emitter = new EventEmitter();
+
+        if (!!args.is_end) {
+          process.nextTick(() => emitter.emit('end'));
+        } else if (!!args.err) {
+          process.nextTick(() => emitter.emit('error', args.err));
+        } else {
+          process.nextTick(() => emitter.emit('data', data));
+        }
+
+        return emitter;
+      },
+    },
+  };
+};
+
+const makeArgs = overrides => {
+  const args = {
+    cltv_delta: 1,
+    destination: Buffer.alloc(33).toString('hex'),
+    features: [{bit: 1}],
+    id: Buffer.alloc(32).toString('hex'),
+    incoming_peer: Buffer.alloc(33).toString('hex'),
+    lnd: makeLnd({}),
+    max_fee: 1,
+    max_fee_mtokens: '1000',
+    messages: [{
+      type: '1',
+      value: Buffer.alloc(1).toString('hex'),
+    }],
+    mtokens: '1000',
+    outgoing_channel: '0x0x1',
+    pathfinding_timeout: 1,
+    routes: [[{
+      base_fee_mtokens: '1000',
+      channel: '0x0x1',
+      cltv_delta: 1,
+      fee_rate: 1,
+      public_key: Buffer.alloc(33).toString('hex'),
+    }]],
+    tokens: 1,
+  };
+
+  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
+
+  return args;
+};
+
+const makeExpectedPayment = ({}) => {
+  return {
+    failed: undefined,
+    is_confirmed: true,
+    is_failed: false,
+    is_pending: false,
+    payment: {
+      fee: 0,
+      fee_mtokens: '1',
+      hops: [{
+        channel: '0x0x1',
+        channel_capacity: 1,
+        fee: 0,
+        fee_mtokens: '1',
+        forward: 0,
+        forward_mtokens: '1',
+        public_key: 'b',
+        timeout: 1,
+      }],
+      id: '66687aadf862bd776c8fc18b8e9f8e20089714856ee233b3902a591d0d5f2925',
+      paths: [{
+        fee: 0,
+        fee_mtokens: '1',
+        hops: [{
+          channel: '0x0x1',
+          channel_capacity: 1,
+          fee: 0,
+          fee_mtokens: '1',
+          forward: 0,
+          forward_mtokens: '1',
+          public_key: 'b',
+          timeout: 1
+        }],
+        mtokens: '1',
+        safe_fee: 1,
+        safe_tokens: 1,
+        timeout: 1,
+        tokens: 0,
+      }],
+      mtokens: '1',
+      safe_fee: 1,
+      safe_tokens: 1,
+      secret: Buffer.alloc(32).toString('hex'),
+      timeout: 1,
+      tokens: 0,
+    },
+  };
+};
+
+const tests = [
+  {
+    args: makeArgs({destination: undefined}),
+    description: 'The payment destination is required',
+    error: [400, 'ExpectedDestinationToCheckPayability'],
+  },
+  {
+    args: makeArgs({lnd: undefined}),
+    description: 'LND is required',
+    error: [400, 'ExpectedAuthenticatedLndWithRouterToTestPayable'],
+  },
+  {
+    args: makeArgs({
+      lnd: {
+        chain: {
+          registerBlockEpochNtfn: ({}) => {
+            const emitter = new EventEmitter();
+
+            emitter.cancel = () => {};
+
+            process.nextTick(() => emitter.emit('error', 'err'));
+
+            return emitter;
+          },
+        },
+        default: {
+          getInfo: ({}, cbk) => {
+            return cbk('err');
+          },
+        },
+        router: {
+          sendPaymentV2: ({}) => {
+            const emitter = new EventEmitter();
+
+            process.nextTick(() => emitter.emit('error', 'err'));
+
+            return emitter;
+          },
+        },
+      },
+    }),
+    description: 'A payment attempt times out',
+    error: [
+      503,
+      'UnexpectedErrorCheckingPayability',
+      {err: [503, 'UnexpectedPaymentError', {err: 'err'}]},
+    ],
+  },
+  {
+    args: makeArgs({}),
+    description: 'A payment attempt times out',
+    expected: {is_payable: false},
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async () => {
+    if (!!error) {
+      await rejects(() => isDestinationPayable(args), error, 'Got error');
+    } else {
+      const payment = await isDestinationPayable(args);
+
+      deepStrictEqual(payment, expected, 'Got expected payment');
+    }
+
+    return;
+  });
+});

package/test/lnd_methods/onchain/test_delete_chain_transaction.js

@@ -0,0 +1,85 @@
+const {deepEqual} = require('node:assert').strict;
+const {rejects} = require('node:assert').strict;
+const test = require('node:test');
+
+const {deleteChainTransaction} = require('./../../../lnd_methods');
+
+const makeLnd = () => {
+  return {
+    wallet: {
+      removeTransaction: ({}, cbk) => {
+        return cbk(null, {status: 'Successfully removed transaction'});
+      },
+    },
+  };
+};
+
+const tests = [
+  {
+    args: {},
+    description: 'An id is required to delete a chain transaction',
+    error: [400, 'ExpectedIdentifyingTxHashOfChainTxToDelete'],
+  },
+  {
+    args: {id: Buffer.alloc(32).toString('hex')},
+    description: 'LND Object is required to delete a chain transaction',
+    error: [400, 'ExpectedLndToDeleteChainTransaction'],
+  },
+  {
+    args: {
+      id: Buffer.alloc(32).toString('hex'),
+      lnd: {wallet: {removeTransaction: ({}, cbk) => cbk('err')}},
+    },
+    description: 'Errors are passed back from remove transaction method',
+    error: [503, 'UnexpectedDeleteChainTransactionError', {err: 'err'}],
+  },
+  {
+    args: {
+      id: Buffer.alloc(32).toString('hex'),
+      lnd: {
+        wallet: {
+          removeTransaction: ({}, cbk) => cbk({
+            details: 'unknown walletrpc.WalletKit',
+          }),
+        },
+      },
+    },
+    description: 'Unsupported errors are returned',
+    error: [501, 'RemoveChainTransactionMethodNotSupported'],
+  },
+  {
+    args: {
+      id: Buffer.alloc(32).toString('hex'),
+      lnd: {wallet: {removeTransaction: ({}, cbk) => cbk()}},
+    },
+    description: 'A response is expected from remove transaction',
+    error: [503, 'ExpectedResponseDeletingChainTransaction'],
+  },
+  {
+    args: {
+      id: Buffer.alloc(32).toString('hex'),
+      lnd: {wallet: {removeTransaction: ({}, cbk) => cbk(null, {})}},
+    },
+    description: 'A success response is expected from remove transaction',
+    error: [503, 'UnexpectedResponseDeletingChainTransaction'],
+  },
+  {
+    args: {
+      id: Buffer.alloc(32).toString('hex'),
+      lnd: makeLnd({}),
+    },
+    description: 'Remove transaction returns successfully',
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async () => {
+    if (!!error) {
+      await rejects(() => deleteChainTransaction(args), error, 'Got err');
+    } else {
+      await deleteChainTransaction(args);
+    }
+
+    return;
+  });
+});

package/test/lnd_methods/onchain/test_get_chain_transaction.js

@@ -0,0 +1,124 @@
+const {deepStrictEqual} = require('node:assert').strict;
+const {rejects} = require('node:assert').strict;
+const test = require('node:test');
+
+const {getChainTransaction} = require('./../../../lnd_methods');
+
+const makeExpected = overrides => {
+  const transaction = {
+    block_id: Buffer.alloc(32).toString('hex'),
+    confirmation_count: 1,
+    confirmation_height: 1,
+    created_at: '1970-01-01T00:00:01.000Z',
+    description: undefined,
+    fee: 1,
+    id: Buffer.alloc(32).toString('hex'),
+    inputs: [],
+    is_confirmed: true,
+    is_outgoing: false,
+    output_addresses: ['address'],
+    tokens: 1,
+    transaction: undefined,
+  };
+
+  Object.keys(overrides).forEach(k => transaction[k] = overrides[k]);
+
+  return transaction;
+};
+
+const makeLnd = overrides => {
+  return {
+    wallet: {
+      getTransaction: ({}, cbk) => {
+        const transaction = {
+          amount: '1',
+          block_hash: Buffer.alloc(32).toString('hex'),
+          block_height: 1,
+          dest_addresses: ['address'],
+          num_confirmations: 1,
+          previous_outpoints: [],
+          time_stamp: '1',
+          total_fees: '1',
+          tx_hash: Buffer.alloc(32).toString('hex'),
+        };
+
+        Object.keys(overrides).forEach(k => transaction[k] = overrides[k]);
+
+        return cbk(null, transaction);
+      },
+    },
+  };
+};
+
+const tests = [
+  {
+    args: {},
+    description: 'An id is required to get a chain transaction',
+    error: [400, 'ExpectedIdentifyingTxHashOfChainTxToRetrieve'],
+  },
+  {
+    args: {id: Buffer.alloc(32).toString('hex')},
+    description: 'LND Object is required to get a chain transaction',
+    error: [400, 'ExpectedLndToGetChainTransaction'],
+  },
+  {
+    args: {
+      id: Buffer.alloc(32).toString('hex'),
+      lnd: {wallet: {getTransaction: ({}, cbk) => cbk('err')}},
+    },
+    description: 'Errors are passed back from get transaction method',
+    error: [503, 'UnexpectedGetChainTransactionError', {err: 'err'}],
+  },
+  {
+    args: {
+      id: Buffer.alloc(32).toString('hex'),
+      lnd: {
+        wallet: {
+          getTransaction: ({}, cbk) => cbk({
+            details: 'unknown walletrpc.WalletKit',
+          }),
+        },
+      },
+    },
+    description: 'Unsupported errors are returned',
+    error: [501, 'GetChainTransactionMethodNotSupported'],
+  },
+  {
+    args: {
+      id: Buffer.alloc(32).toString('hex'),
+      lnd: {wallet: {getTransaction: ({}, cbk) => cbk()}},
+    },
+    description: 'A response is expected from get transaction',
+    error: [503, 'ExpectedRpcTransactionToDeriveTransactionDetails'],
+  },
+  {
+    args: {
+      id: Buffer.alloc(32).toString('hex'),
+      lnd: makeLnd({amount: null}),
+    },
+    description: 'An amount is expected in a chain transaction',
+    error: [503, 'ExpectedTransactionAmountInChainTransaction'],
+  },
+  {
+    args: {
+      id: Buffer.alloc(32).toString('hex'),
+      lnd: makeLnd({}),
+    },
+    description: 'Get transaction returns normalized transaction',
+    expected: makeExpected({}),
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async () => {
+    if (!!error) {
+      await rejects(() => getChainTransaction(args), error, 'Got err');
+    } else {
+      const transaction = await getChainTransaction(args);
+
+      deepStrictEqual(transaction, expected, 'Got transaction');
+    }
+
+    return;
+  });
+});