lightning 6.8.0 → 7.0.0

package/CHANGELOG.md

@@ -1,6 +1,14 @@
 # Versions
 
-## 6.8.0
+## 7.0.0
+
+- `getAddresses`: Add method to get the list of chain addresses
+
+### Breaking Changes
+
+- Incorrect TypeScript settings for probe and fee rates was corrected
+
+## 6.8.1
 
 - `subscribeToRpcRequests`: add `max_tokens_per_vbyte` to RPC close requests
 

package/README.md

@@ -106,7 +106,6 @@ 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.
-- [createWallet](https://github.com/alexbosworth/ln-service#createwallet): Make a new wallet.
 - [deleteFailedPayAttempts](https://github.com/alexbosworth/ln-service#deletefailedpayattempts)
     Remove failed payment paths from database.
 - [deleteFailedPayments](https://github.com/alexbosworth/ln-service#deletefailedpayments)

package/grpc/protos/router.proto

@@ -94,8 +94,8 @@ service Router {
         returns (SetMissionControlConfigResponse);
 
     /*
-    QueryProbability returns the current success probability estimate for a
-    given node pair and amount.
+    Deprecated. QueryProbability returns the current success probability
+    estimate for a given node pair and amount.
     */
     rpc QueryProbability (QueryProbabilityRequest)
         returns (QueryProbabilityResponse);

package/grpc/protos/walletkit.proto

@@ -64,6 +64,21 @@ service WalletKit {
     */
     rpc ListAccounts (ListAccountsRequest) returns (ListAccountsResponse);
 
+    /*
+    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.
+    */
+    rpc RequiredReserve (RequiredReserveRequest)
+        returns (RequiredReserveResponse);
+
+    /*
+    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);
+
     /*
     ImportAccount imports an account backed by an account extended public key.
     The master key fingerprint denotes the fingerprint of the root key
@@ -92,7 +107,11 @@ service WalletKit {
     rpc ImportAccount (ImportAccountRequest) returns (ImportAccountResponse);
 
     /*
-    ImportPublicKey imports a public key as watch-only into the wallet.
+    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
+    the BIP-0086 style output script. Use ImportTapscript for more advanced key
+    spend or script spend outputs.
 
     NOTE: Events (deposits/spends) for a key will only be detected by lnd if
     they happen after the import. Rescans to detect past events will be
@@ -101,6 +120,22 @@ service WalletKit {
     rpc ImportPublicKey (ImportPublicKeyRequest)
         returns (ImportPublicKeyResponse);
 
+    /*
+    ImportTapscript imports a Taproot script and internal key and adds the
+    resulting Taproot output key as a watch-only output script into the wallet.
+    For BIP-0086 style Taproot keys (no root hash commitment and no script spend
+    path) use ImportPublicKey.
+
+    NOTE: Events (deposits/spends) for a key will only be detected by lnd if
+    they happen after the import. Rescans to detect past events will be
+    supported later on.
+
+    NOTE: Taproot keys imported through this RPC currently _cannot_ be used for
+    funding PSBTs. Only tracking the balance and UTXOs is currently supported.
+    */
+    rpc ImportTapscript (ImportTapscriptRequest)
+        returns (ImportTapscriptResponse);
+
     /*
     PublishTransaction attempts to publish the passed transaction to the
     network. Once this returns without an error, the wallet will continually
@@ -340,14 +375,7 @@ message Account {
     // The name used to identify the account.
     string name = 1;
 
-    /*
-    The type of addresses the account supports.
-    AddressType                       | External Branch | Internal Branch
-    ---------------------------------------------------------------------
-    WITNESS_PUBKEY_HASH               | P2WPKH          | P2WPKH
-    NESTED_WITNESS_PUBKEY_HASH        | NP2WPKH         | NP2WPKH
-    HYBRID_NESTED_WITNESS_PUBKEY_HASH | NP2WPKH         | P2WPKH
-    */
+    // The type of addresses the account supports.
     AddressType address_type = 2;
 
     /*
@@ -389,6 +417,50 @@ message Account {
     // Whether the wallet stores private keys for the account.
     bool watch_only = 8;
 }
+
+message AddressProperty {
+    /*
+    The address encoded using the appropriate format depending on the
+    address type (base58, bech32, bech32m).
+
+    Note that lnd's internal/custom keys for channels and other
+    functionality are derived from the same scope. Since they
+    aren't really used as addresses and will never have an
+    on-chain balance, we'll show the public key instead (only if
+    the show_custom_accounts flag is provided).
+    */
+    string address = 1;
+
+    // Denotes if the address is a change address.
+    bool is_internal = 2;
+
+    // The balance of the address.
+    int64 balance = 3;
+}
+
+message AccountWithAddresses {
+    // The name used to identify the account.
+    string name = 1;
+
+    // The type of addresses the account supports.
+    AddressType address_type = 2;
+
+    /*
+    The derivation path corresponding to the account public key. This will
+    always be empty for the default imported account in which single public keys
+    are imported into.
+    */
+    string derivation_path = 3;
+
+    /*
+    List of address, its type internal/external & balance.
+    Note that the order of addresses will be random and not according to the
+    derivation index, since that information is not stored by the underlying
+    wallet.
+    */
+    repeated AddressProperty addresses = 4;
+}
+
 message ListAccountsRequest {
     // An optional filter to only return accounts matching this name.
     string name = 1;
@@ -396,10 +468,35 @@ message ListAccountsRequest {
     // An optional filter to only return accounts matching this address type.
     AddressType address_type = 2;
 }
+
 message ListAccountsResponse {
     repeated Account accounts = 1;
 }
 
+message RequiredReserveRequest {
+    // The number of additional channels the user would like to open.
+    uint32 additional_public_channels = 1;
+}
+
+message RequiredReserveResponse {
+    // The amount of reserve required.
+    int64 required_reserve = 1;
+}
+
+message ListAddressesRequest {
+    // An optional filter to only return addresses matching this account.
+    string account_name = 1;
+
+    // An optional flag to return LND's custom accounts (Purpose=1017)
+    // public key along with other addresses.
+    bool show_custom_accounts = 2;
+}
+
+message ListAddressesResponse {
+    // A list of all the accounts and their addresses.
+    repeated AccountWithAddresses account_with_addresses = 1;
+}
+
 message ImportAccountRequest {
     // A name to identify the account with.
     string name = 1;
@@ -464,6 +561,77 @@ message ImportPublicKeyRequest {
 message ImportPublicKeyResponse {
 }
 
+message ImportTapscriptRequest {
+    /*
+    The internal public key, serialized as 32-byte x-only public key.
+    */
+    bytes internal_public_key = 1;
+
+    oneof script {
+        /*
+        The full script tree with all individual leaves is known and the root
+        hash can be constructed from the full tree directly.
+        */
+        TapscriptFullTree full_tree = 2;
+
+        /*
+        Only a single script leaf is known. To construct the root hash, the full
+        inclusion proof must also be provided.
+        */
+        TapscriptPartialReveal partial_reveal = 3;
+
+        /*
+        Only the root hash of the Taproot script tree (or other form of Taproot
+        commitment) is known.
+        */
+        bytes root_hash_only = 4;
+
+        /*
+        Only the final, tweaked Taproot key is known and no additional
+        information about the internal key or type of tweak that was used to
+        derive it. When this is set, the wallet treats the key in
+        internal_public_key as the Taproot key directly. This can be useful for
+        tracking arbitrary Taproot outputs without the goal of ever being able
+        to spend from them through the internal wallet.
+        */
+        bool full_key_only = 5;
+    }
+}
+
+message TapscriptFullTree {
+    /*
+    The complete, ordered list of all tap leaves of the tree.
+    */
+    repeated TapLeaf all_leaves = 1;
+}
+
+message TapLeaf {
+    // The leaf version. Should be 0xc0 (192) in case of a SegWit v1 script.
+    uint32 leaf_version = 1;
+
+    // The script of the tap leaf.
+    bytes script = 2;
+}
+
+message TapscriptPartialReveal {
+    // The tap leaf that is known and will be revealed.
+    TapLeaf revealed_leaf = 1;
+
+    // The BIP-0341 serialized inclusion proof that is required to prove that
+    // the revealed leaf is part of the tree. This contains 0..n blocks of 32
+    // bytes. If the tree only contained a single leaf (which is the revealed
+    // leaf), this can be empty.
+    bytes full_inclusion_proof = 2;
+}
+
+message ImportTapscriptResponse {
+    /*
+    The resulting pay-to-Taproot address that represents the imported internal
+    key with the script committed to it.
+    */
+    string p2tr_address = 1;
+}
+
 message Transaction {
     /*
     The raw serialized transaction.
@@ -867,6 +1035,9 @@ message SignPsbtRequest {
 message SignPsbtResponse {
     // The signed transaction in PSBT format.
     bytes signed_psbt = 1;
+
+    // The indices of signed inputs.
+    repeated uint32 signed_inputs = 2;
 }
 
 message FinalizePsbtRequest {

package/index.js

@@ -33,6 +33,7 @@ const {getAutopilot} = require('./lnd_methods');
 const {getBackup} = require('./lnd_methods');
 const {getBackups} = require('./lnd_methods');
 const {getBlock} = require('./lnd_methods');
+const {getChainAddresses} = require('./lnd_methods');
 const {getChainBalance} = require('./lnd_methods');
 const {getChainFeeEstimate} = require('./lnd_methods');
 const {getChainFeeRate} = require('./lnd_methods');
@@ -184,6 +185,7 @@ module.exports = {
   getBackup,
   getBackups,
   getBlock,
+  getChainAddresses,
   getChainBalance,
   getChainFeeEstimate,
   getChainFeeRate,

package/lnd_methods/index.js

@@ -31,6 +31,7 @@ const {getAutopilot} = require('./info');
 const {getBackup} = require('./offchain');
 const {getBackups} = require('./offchain');
 const {getBlock} = require('./onchain');
+const {getChainAddresses} = require('./onchain');
 const {getChainBalance} = require('./onchain');
 const {getChainFeeEstimate} = require('./onchain');
 const {getChainFeeRate} = require('./onchain');
@@ -178,6 +179,7 @@ module.exports = {
   getBackup,
   getBackups,
   getBlock,
+  getChainAddresses,
   getChainBalance,
   getChainFeeEstimate,
   getChainFeeRate,

package/lnd_methods/invoices/create_hodl_invoice.js

@@ -50,7 +50,7 @@ const type = 'invoices';
     created_at: <ISO 8601 Date String>
     description: <Description String>
     id: <Payment Hash Hex String>
-    mtokens: <Millitokens Number>
+    mtokens: <Millitokens Number String>
     request: <BOLT 11 Encoded Payment Request String>
     [secret]: <Hex Encoded Payment Secret String>
     tokens: <Tokens Number>

package/lnd_methods/invoices/subscribe_to_invoice.js

@@ -69,13 +69,6 @@ const updateEvent = 'invoice_updated';
     received: <Received Tokens Number>
     received_mtokens: <Received Millitokens String>
     request: <Bolt 11 Invoice String>
-    routes: [[{
-      base_fee_mtokens: <Base Routing Fee In Millitokens Number>
-      channel: <Standard Format Channel Id String>
-      cltv_delta: <CLTV Blocks Delta Number>
-      fee_rate: <Fee Rate In Millitokens Per Million Number>
-      public_key: <Public Key Hex String>
-    }]]
     secret: <Secret Preimage Hex String>
     tokens: <Tokens Number>
   }

package/lnd_methods/macaroon/subscribe_to_rpc_requests.d.ts

@@ -46,6 +46,8 @@ export type SubscribeToRpcRequestsCloseChannelRequestEvent =
     address?: string;
     /** Is Force Close Bool */
     is_force_close?: boolean;
+    /** Max Tokens Per VByte Number */
+    max_tokens_per_vbyte?: number;
     /** Confirmation Target Number */
     target_confirmations?: number;
     /** Tokens Per Virtual Byte Number */

package/lnd_methods/offchain/decode_payment_request.d.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   AuthenticatedLightningArgs,
   AuthenticatedLightningMethod,
 } from '../../typescript';
@@ -8,6 +8,21 @@ export type DecodePaymentRequestArgs = AuthenticatedLightningArgs<{
   request: string;
 }>;
 
+export type DecodePaymentRouteEdge = {
+  /** Base Routing Fee In Millitokens */
+  base_fee_mtokens?: string;
+  /** Standard Format Channel Id */
+  channel?: string;
+  /** CLTV Blocks Delta */
+  cltv_delta?: number;
+  /** Fees Charged in Millitokens Per Million */
+  fee_rate?: number;
+  /** Forward Edge Public Key Hex */
+  public_key: string;
+};
+
+export type DecodePaymentRoutes = DecodePaymentRouteEdge[][];
+
 export type DecodePaymentRequestResult = {
   /** Fallback Chain Address */
   chain_address: string;
@@ -37,18 +52,7 @@ export type DecodePaymentRequestResult = {
   mtokens: string;
   /** Payment Identifier Hex Encoded */
   payment?: string;
-  routes: {
-    /** Base Routing Fee In Millitokens */
-    base_fee_mtokens?: string;
-    /** Standard Format Channel Id */
-    channel?: string;
-    /** CLTV Blocks Delta */
-    cltv_delta?: number;
-    /** Fees Charged in Millitokens Per Million */
-    fee_rate?: number;
-    /** Forward Edge Public Key Hex */
-    public_key: string;
-  }[][];
+  routes: DecodePaymentRoutes;
   /** Requested Tokens Rounded Up */
   safe_tokens: number;
   /** Requested Tokens Rounded Down */

package/lnd_methods/offchain/get_fee_rates.d.ts

@@ -7,6 +7,8 @@ export type GetFeeRatesResult = {
     base_fee: number;
     /** Base Flat Fee Millitokens */
     base_fee_mtokens: string;
+    /** Fee Rate in Millitokens Per Million Number */
+    fee_rate: number;
     /** Standard Format Channel Id */
     id: string;
     /** Channel Funding Transaction Id Hex */

package/lnd_methods/offchain/probe_for_route.d.ts

@@ -1,70 +1,73 @@
-import {
+import type {MergeExclusive} from 'type-fest';
+import type {
   AuthenticatedLightningArgs,
   AuthenticatedLightningMethod,
 } from '../../typescript';
+import type {DecodePaymentRouteEdge} from './decode_payment_request';
 
-export type ProbeForRouteArgs = AuthenticatedLightningArgs<{
-  /** Final CLTV Delta Number */
-  cltv_delta?: number;
-  /** Destination Public Key Hex String */
-  destination: string;
-  features?: {
-    /** Feature Bit Number */
-    bit: number;
-  }[];
-  ignore?: {
-    /** Channel Id String */
-    channel?: string;
-    /** Public Key Hex String */
-    from_public_key: string;
-    /** To Public Key Hex String */
-    to_public_key?: string;
-  }[];
-  /** Incoming Peer Public Key Hex String */
-  incoming_peer?: string;
-  /** Adjust Probe For Past Routing Failures Bool */
-  is_ignoring_past_failures?: boolean;
-  /** Maximum Fee Tokens Number */
-  max_fee?: number;
-  /** Maximum Fee Millitokens to Pay String */
-  max_fee_mtokens?: string;
-  /** Maximum Height of Payment Timeout Number */
-  max_timeout_height?: number;
-  messages?: {
-    /** Message To Final Destination Type Number String */
-    type: string;
-    /** Message To Final Destination Raw Value Hex Encoded String */
-    value: string;
-  }[];
-  /** Millitokens to Pay String */
-  mtokens?: string;
-  /** Outgoing Channel Id String */
-  outgoing_channel?: string;
-  /** Time to Spend On A Path Milliseconds Number */
-  path_timeout_ms?: number;
-  /** Payment Identifier Hex String */
-  payment?: string;
-  /** Probe Timeout Milliseconds Number */
-  probe_timeout_ms?: number;
-  routes?: {
-    /** Base Routing Fee In Millitokens Number */
-    base_fee_mtokens?: number;
-    /** Channel Capacity Tokens Number */
-    channel_capacity?: number;
-    /** Standard Format Channel Id String */
-    channel?: string;
-    /** CLTV Blocks Delta Number */
+export type ProbeForRouteRouteEdge = DecodePaymentRouteEdge & {
+  /** Channel Capacity Tokens Number */
+  channel_capacity?: number;
+};
+
+export type ProbeForRouteRoutes = ProbeForRouteRouteEdge[][];
+
+export type ProbeForRouteArgs = AuthenticatedLightningArgs<
+  {
+    /** Final CLTV Delta Number */
     cltv_delta?: number;
-    /** Fee Rate In Millitokens Per Million Number */
-    fee_rate?: number;
-    /** Forward Edge Public Key Hex String */
-    public_key: string;
-  }[][];
-  /** Tokens Number */
-  tokens: number;
-  /** Total Millitokens Across Paths String */
-  total_mtokens?: string;
-}>;
+    /** Destination Public Key Hex String */
+    destination: string;
+    features?: {
+      /** Feature Bit Number */
+      bit: number;
+    }[];
+    ignore?: {
+      /** Channel Id String */
+      channel?: string;
+      /** Public Key Hex String */
+      from_public_key: string;
+      /** To Public Key Hex String */
+      to_public_key?: string;
+    }[];
+    /** Incoming Peer Public Key Hex String */
+    incoming_peer?: string;
+    /** Adjust Probe For Past Routing Failures Bool */
+    is_ignoring_past_failures?: boolean;
+    /** Maximum Fee Tokens Number */
+    max_fee?: number;
+    /** Maximum Fee Millitokens to Pay String */
+    max_fee_mtokens?: string;
+    /** Maximum Height of Payment Timeout Number */
+    max_timeout_height?: number;
+    messages?: {
+      /** Message To Final Destination Type Number String */
+      type: string;
+      /** Message To Final Destination Raw Value Hex Encoded String */
+      value: string;
+    }[];
+    /** Outgoing Channel Id String */
+    outgoing_channel?: string;
+    /** Time to Spend On A Path Milliseconds Number */
+    path_timeout_ms?: number;
+    /** Payment Identifier Hex String */
+    payment?: string;
+    /** Probe Timeout Milliseconds Number */
+    probe_timeout_ms?: number;
+    routes?: ProbeForRouteRoutes;
+    /** Total Millitokens Across Paths String */
+    total_mtokens?: string;
+  } & MergeExclusive<
+    {
+      /** Millitokens to Pay String */
+      mtokens: string;
+    },
+    {
+      /** Tokens Number */
+      tokens: number;
+    }
+  >
+>;
 
 export type ProbeForRouteResult = {
   route?: {

package/lnd_methods/offchain/probe_for_route.js

@@ -47,7 +47,7 @@ const isHex = n => !(n.length % 2) && /^[0-9A-F]*$/i.test(n);
     [payment]: <Payment Identifier Hex String>
     [probe_timeout_ms]: <Probe Timeout Milliseconds Number>
     [routes]: [[{
-      [base_fee_mtokens]: <Base Routing Fee In Millitokens Number>
+      [base_fee_mtokens]: <Base Routing Fee In Millitokens String>
       [channel_capacity]: <Channel Capacity Tokens Number>
       [channel]: <Standard Format Channel Id String>
       [cltv_delta]: <CLTV Blocks Delta Number>

package/lnd_methods/onchain/get_block.d.ts

@@ -0,0 +1,37 @@
+import type {MergeExclusive} from 'type-fest';
+import {
+  AuthenticatedLightningArgs,
+  AuthenticatedLightningMethod,
+} from '../../typescript';
+
+export type GetBlockArgs = AuthenticatedLightningArgs<
+  MergeExclusive<
+    {
+      /** Block Height Number */
+      height: number;
+    },
+    {
+      /** Block Hash Hex String */
+      id: string;
+    }
+  >
+>;
+
+export type GetBlockResult = {
+  /** Raw Block Bytes Hex String */
+  block: string;
+};
+
+/**
+ * Get a block in the chain
+ *
+ * This method requires LND built with `chainkit` build tag
+ *
+ * Requires `onchain:read` permission
+ *
+ * This method is not supported on LND 0.15.5 and below
+ */
+export const getBlock: AuthenticatedLightningMethod<
+  GetBlockArgs,
+  GetBlockResult
+>;

package/lnd_methods/onchain/get_chain_addresses.js

@@ -0,0 +1,83 @@
+const asyncAuto = require('async/auto');
+const {returnResult} = require('asyncjs-util');
+
+const {isLnd} = require('./../../lnd_requests');
+const {rpcAddressesAsAddresses} = require('./../../lnd_responses');
+
+const err404 = 'unknown method ListAddresses for service walletrpc.WalletKit';
+const {isArray} = Array;
+const method = 'listAddresses';
+const type = 'wallet';
+const unsupportedErrorMessage = 'unknown service walletrpc.WalletKit';
+
+/** Get the wallet chain addresses
+
+  Requires `onchain:read` permission
+
+  This method is not supported on LND 0.15.5 and below
+
+  {
+    lnd: <Authenticated LND API Object>
+  }
+
+  @returns via cbk or Promise
+  {
+    addresses: [{
+      address: <Chain Address String>
+      is_change: <Is Internal Change Address Bool>
+      tokens: <Balance of Funds Controlled by Output Script Tokens Number>
+    }]
+  }
+*/
+module.exports = ({lnd}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!isLnd({lnd, method, type})) {
+          return cbk([400, 'ExpectedAuthenticatedLndToGetChainAddresses']);
+        }
+
+        return cbk();
+      },
+
+      // Get the list of accounts with addresses
+      getAddresses: ['validate', ({}, cbk) => {
+        return lnd[type][method]({}, (err, res) => {
+          // LND 0.15.5 and below do not support listing account addresses
+          if (!!err && err.details === err404) {
+            return cbk([501, 'BackingLndDoesNotSupportGettingChainAddresses']);
+          }
+
+          if (!!err) {
+            return cbk([503, 'UnexpectedErrorListingAccountAddresses', {err}]);
+          }
+
+          if (!res) {
+            return cbk([503, 'ExpectedResponseForGetAccountAddressesRequest']);
+          }
+
+          if (!isArray(res.account_with_addresses)) {
+            return cbk([503, 'ExpectedSetOfAccountAddressesInAddrsResponse']);
+          }
+
+          return cbk(null, res.account_with_addresses);
+        });
+      }],
+
+      // Map the accounts to a list of addresses
+      addresses: ['getAddresses', ({getAddresses}, cbk) => {
+        try {
+          const {addresses} = rpcAddressesAsAddresses({
+            accounts: getAddresses,
+          });
+
+          return cbk(null, {addresses});
+        } catch (err) {
+          return cbk([503, err.message]);
+        }
+      }],
+    },
+    returnResult({reject, resolve, of: 'addresses'}, cbk));
+  });
+};

package/lnd_methods/onchain/index.d.ts

@@ -3,6 +3,7 @@ export * from './cancel_pending_channel';
 export * from './close_channel';
 export * from './fund_pending_channels';
 export * from './fund_psbt';
+export * from './get_block';
 export * from './get_chain_balance';
 export * from './get_chain_fee_estimate';
 export * from './get_chain_fee_rate';

package/lnd_methods/onchain/index.js

@@ -4,6 +4,7 @@ const closeChannel = require('./close_channel');
 const fundPendingChannels = require('./fund_pending_channels');
 const fundPsbt = require('./fund_psbt');
 const getBlock = require('./get_block');
+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');
@@ -39,6 +40,7 @@ module.exports = {
   fundPendingChannels,
   fundPsbt,
   getBlock,
+  getChainAddresses,
   getChainBalance,
   getChainFeeEstimate,
   getChainFeeRate,

package/lnd_methods/onchain/propose_channel.js

@@ -129,7 +129,6 @@ module.exports = (args, cbk) => {
             channelOpen.cancel();
 
             return cbk(null, {});
-            break;
 
           case 'confirmation':
             break;

package/lnd_responses/index.js

@@ -15,6 +15,7 @@ const pendingFromPayment = require('./pending_from_payment');
 const policyFromChannelUpdate = require('./policy_from_channel_update');
 const routesFromQueryRoutes = require('./routes_from_query_routes');
 const routingFailureFromHtlc = require('./routing_failure_from_htlc');
+const rpcAddressesAsAddresses = require('./rpc_addresses_as_addresses');
 const rpcAttemptHtlcAsAttempt = require('./rpc_attempt_htlc_as_attempt');
 const rpcChannelAsChannel = require('./rpc_channel_as_channel');
 const rpcChannelAsOldRpcChannel = require('./rpc_channel_as_old_rpc_channel');
@@ -60,6 +61,7 @@ module.exports = {
   policyFromChannelUpdate,
   routesFromQueryRoutes,
   routingFailureFromHtlc,
+  rpcAddressesAsAddresses,
   rpcAttemptHtlcAsAttempt,
   rpcChannelAsChannel,
   rpcChannelAsOldRpcChannel,

package/lnd_responses/rpc_addresses_as_addresses.js

@@ -0,0 +1,62 @@
+const flatten = arr => [].concat(...arr);
+const {isArray} = Array;
+const isBoolean = n => n === false || n === true;
+
+/** Derive a list of addresses from a list of accounts with addresses
+
+  {
+    accounts: [{
+      addresses: [{
+        address: <Chain Address String>
+        balance: <Balance Tokens Number String>
+        is_internal: <Is Change Address Bool>
+      }]
+    }]
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    addresses: [{
+      address: <Chain Address String>
+      is_change: <Is Internal Change Address Bool>
+      tokens: <Balance of Funds Controlled by Output Script Tokens Number>
+    }]
+  }
+*/
+module.exports = ({accounts}) => {
+  if (!isArray(accounts)) {
+    throw new Error('ExpectedArrayOfAccountsWithAddresses');
+  }
+
+  // Map the accounts addresses to a list of addresses
+  const addresses = flatten(accounts.map(account => {
+    if (!isArray(account.addresses)) {
+      throw new Error('ExpectedArrayOfAddressesInAccountWithAddresses');
+    }
+
+    return account.addresses.map(accountAddress => {
+      if (!accountAddress.address) {
+        throw new Error('ExpectedChainAddressInAccountAddress');
+      }
+
+      if (!accountAddress.balance) {
+        throw new Error('ExpectedBalanceTotalForAccountAddress');
+      }
+
+      if (!isBoolean(accountAddress.is_internal)) {
+        throw new Error('ExpectedInternalAddressMarkerInAccountAddress');
+      }
+
+      return {
+        address: accountAddress.address,
+        is_change: accountAddress.is_internal,
+        tokens: Number(accountAddress.balance),
+      };
+    });
+  }));
+
+  return {addresses};
+};

package/package.json

@@ -7,12 +7,12 @@
     "url": "https://github.com/alexbosworth/lightning/issues"
   },
   "dependencies": {
-    "@grpc/grpc-js": "1.8.0",
+    "@grpc/grpc-js": "1.8.1",
     "@grpc/proto-loader": "0.7.4",
     "@types/express": "4.17.15",
-    "@types/node": "18.11.16",
+    "@types/node": "18.11.18",
     "@types/request": "2.48.8",
-    "@types/ws": "8.5.3",
+    "@types/ws": "8.5.4",
     "async": "3.2.4",
     "asyncjs-util": "1.2.10",
     "bitcoinjs-lib": "6.1.0",
@@ -26,7 +26,7 @@
     "invoices": "2.2.2",
     "psbt": "2.7.1",
     "tiny-secp256k1": "2.2.1",
-    "type-fest": "3.4.0"
+    "type-fest": "3.5.1"
   },
   "description": "Lightning Network client library",
   "devDependencies": {
@@ -59,5 +59,5 @@
     "directory": "test/typescript"
   },
   "types": "index.d.ts",
-  "version": "6.8.0"
+  "version": "7.0.0"
 }

package/test/lnd_methods/onchain/test_get_chain_addresses.js

@@ -0,0 +1,75 @@
+const {test} = require('@alexbosworth/tap');
+
+const {getChainAddresses} = require('./../../../lnd_methods');
+
+const makeLnd = ({err, res}) => {
+  return {
+    wallet: {
+      listAddresses: ({}, cbk) => {
+        if (res !== undefined) {
+          return cbk(null, res);
+        }
+
+        return cbk(err, {account_with_addresses: []});
+      },
+    },
+  };
+};
+
+const tests = [
+  {
+    args: {},
+    description: 'LND Object is required to get chain addresses',
+    error: [400, 'ExpectedAuthenticatedLndToGetChainAddresses'],
+  },
+  {
+    args: {lnd: makeLnd({err: 'err'})},
+    description: 'LND errors are passed back',
+    error: [503, 'UnexpectedErrorListingAccountAddresses', {err: 'err'}],
+  },
+  {
+    args: {
+      lnd: makeLnd({
+        err: {
+          details: 'unknown method ListAddresses for service walletrpc.WalletKit',
+        },
+      }),
+    },
+    description: 'Unknown method is handled',
+    error: [501, 'BackingLndDoesNotSupportGettingChainAddresses'],
+  },
+  {
+    args: {lnd: makeLnd({res: null})},
+    description: 'A response is expected',
+    error: [503, 'ExpectedResponseForGetAccountAddressesRequest'],
+  },
+  {
+    args: {lnd: makeLnd({res: {}})},
+    description: 'A response with accounts is expected',
+    error: [503, 'ExpectedSetOfAccountAddressesInAddrsResponse'],
+  },
+  {
+    args: {lnd: makeLnd({res: {account_with_addresses: [{}]}})},
+    description: 'A valid response with accounts is expected',
+    error: [503, 'ExpectedArrayOfAddressesInAccountWithAddresses'],
+  },
+  {
+    args: {lnd: makeLnd({})},
+    description: 'Get a list of chain addresses',
+    expected: {addresses: []},
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async ({end, rejects, strictSame}) => {
+    if (!!error) {
+      await rejects(() => getChainAddresses(args), error, 'Got error');
+    } else {
+      const res = await getChainAddresses(args);
+
+      strictSame(res, expected, 'Got expected result');
+    }
+
+    return end();
+  });
+});

package/test/lnd_methods/onchain/test_propose_channel.js

@@ -0,0 +1,190 @@
+const EventEmitter = require('events');
+
+const {test} = require('@alexbosworth/tap');
+
+const {proposeChannel} = require('./../../../lnd_methods');
+
+const makeLnd = ({err, data}) => {
+  const lnd = {
+    default: {
+      openChannel: ({}) => {
+        const emitter = new EventEmitter();
+
+        emitter.cancel = () => {};
+
+        process.nextTick(() => {
+          if (!!err) {
+            return emitter.emit('error', err);
+          }
+
+          emitter.emit('data', {update: 'chan_close'});
+          emitter.emit('data', {update: 'confirmation'});
+          emitter.emit('data', {update: 'unknown'});
+          emitter.emit('end', {});
+
+          if (!!data) {
+            emitter.emit('data', data);
+          } else {
+            emitter.emit('data', {
+              chan_pending: {
+                output_index: 0,
+                txid: Buffer.from('01020304', 'hex'),
+              },
+              update: 'chan_pending',
+            });
+            emitter.emit('error', 'err');
+            emitter.emit('status', {});
+            emitter.emit('data', {
+              chan_pending: {
+                output_index: 0,
+                txid: Buffer.from('01020304', 'hex'),
+              },
+              update: 'chan_pending',
+            });
+            emitter.emit('data', {update: 'chan_open'});
+          }
+        });
+
+
+        return emitter;
+      },
+      connectPeer: ({}, cbk) => cbk(null, {}),
+      listPeers: ({}, cbk) => cbk(null, {
+        peers: [{
+          address: 'address',
+          bytes_recv: '0',
+          bytes_sent: '0',
+          features: {},
+          inbound: false,
+          ping_time: '0',
+          pub_key: Buffer.alloc(33).toString('hex'),
+          sat_recv: '0',
+          sat_sent: '0',
+          sync_type: 'ACTIVE_SYNC',
+        }],
+      }),
+    },
+    wallet: {
+      deriveKey: ({}, cbk) => cbk(null, {
+        key_loc: {key_index: 0},
+        raw_key_bytes: Buffer.alloc(1),
+      }),
+    },
+  };
+
+  return lnd;
+};
+
+const makeArgs = overrides => {
+  const args = {
+    capacity: 1e6,
+    chain_fee_tokens_per_vbyte: 1,
+    close_address: 'close_address',
+    id: Buffer.alloc(32).toString('hex'),
+    key_index: 0,
+    lnd: makeLnd({}),
+    give_tokens: 1,
+    partner_public_key: Buffer.alloc(33).toString('hex'),
+    remote_key: Buffer.alloc(33, 2).toString('hex'),
+    transaction_id: Buffer.alloc(32).toString('hex'),
+    transaction_vout: 0,
+  };
+
+  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
+
+  return args;
+};
+
+const makeStatus = details => {
+  return makeArgs({
+    lnd: {
+      default: {
+        openChannel: ({}) => {
+          const emitter = new EventEmitter();
+
+          process.nextTick(() => emitter.emit('status', {details}));
+
+          return emitter;
+        },
+      },
+      wallet: {
+        deriveKey: ({}, cbk) => cbk(null, {
+          key_loc: {key_index: 0},
+          raw_key_bytes: Buffer.alloc(1),
+        }),
+      },
+    },
+  });
+};
+
+const tests = [
+  {
+    args: makeArgs({capacity: undefined}),
+    description: 'Channel capacity is required',
+    error: [400, 'ExpectedCapacityTokensToProposeChannelOpen'],
+  },
+  {
+    args: makeArgs({id: undefined}),
+    description: 'Pending channel id is required',
+    error: [400, 'ExpectedPendingChannelIdToProposeChannelOpen'],
+  },
+  {
+    args: makeArgs({key_index: undefined}),
+    description: 'Key index is required',
+    error: [400, 'ExpectedMultiSigKeyIndexToProposeChannelOpen'],
+  },
+  {
+    args: makeArgs({lnd: undefined}),
+    description: 'LND is required',
+    error: [400, 'ExpectedLndToProposeChannelOpen'],
+  },
+  {
+    args: makeArgs({partner_public_key: undefined}),
+    description: 'A public key is required',
+    error: [400, 'ExpectedPartnerPublicKeyToProposeChannelOpen'],
+  },
+  {
+    args: makeArgs({remote_key: undefined}),
+    description: 'The remote multisig key is required',
+    error: [400, 'ExpectedRemoteMultiSigKeyToProposeChannelOpen'],
+  },
+  {
+    args: makeArgs({transaction_id: undefined}),
+    description: 'The transaction id is required',
+    error: [400, 'ExpectedFundingTransactionIdToProposeChanOpen'],
+  },
+  {
+    args: makeArgs({transaction_vout: undefined}),
+    description: 'The transaction output index is required',
+    error: [400, 'ExpectedFundingTransactionVoutToProposeChanOpen'],
+  },
+  {
+    args: makeArgs({lnd: makeLnd({err: 'err'})}),
+    description: 'An error is encountered',
+    error: [503, 'UnexpectedErrorProposingChannelToPeer'],
+  },
+  {
+    args: makeArgs({}),
+    description: 'A channel is proposed',
+    expected: {},
+  },
+  {
+    args: makeArgs({give_tokens: undefined}),
+    description: 'A channel is proposed with no gift',
+    expected: {},
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async ({end, rejects, strictSame}) => {
+    if (!!error) {
+      await rejects(proposeChannel(args), error, 'Got expected error');
+    } else {
+      const res = await proposeChannel(args);
+
+      strictSame(res, expected, 'Got expected result');
+    }
+
+    return end();
+  });
+});

package/test/lnd_responses/test_rpc_addresses_as_addresses.js

@@ -0,0 +1,82 @@
+const {test} = require('@alexbosworth/tap');
+
+const {rpcAddressesAsAddresses} = require('./../../lnd_responses');
+
+const makeAddress = overrides => {
+  const args = {address: 'address', balance: '0', is_internal: false};
+
+  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
+
+  return args;
+};
+
+const makeArgs = overrides => {
+  const args = {accounts: [{addresses: [makeAddress({})]}]};
+
+  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
+
+  return args;
+};
+
+const makeExpected = overrides => {
+  const expected = {
+    addresses: [{address: 'address', is_change: false, tokens: 0}],
+  };
+
+  Object.keys(overrides).forEach(k => expected[k] = overrides[k]);
+
+  return expected;
+};
+
+const tests = [
+  {
+    args: makeArgs({accounts: undefined}),
+    description: 'Accounts with addresses are expected',
+    error: 'ExpectedArrayOfAccountsWithAddresses',
+  },
+  {
+    args: makeArgs({accounts: [{addresses: undefined}]}),
+    description: 'Accounts with addresses are expected',
+    error: 'ExpectedArrayOfAddressesInAccountWithAddresses',
+  },
+  {
+    args: makeArgs({
+      accounts: [{addresses: [makeAddress({address: undefined})]}],
+    }),
+    description: 'Accounts with address are expected',
+    error: 'ExpectedChainAddressInAccountAddress',
+  },
+  {
+    args: makeArgs({
+      accounts: [{addresses: [makeAddress({balance: undefined})]}],
+    }),
+    description: 'Accounts with balances are expected',
+    error: 'ExpectedBalanceTotalForAccountAddress',
+  },
+  {
+    args: makeArgs({
+      accounts: [{addresses: [makeAddress({is_internal: undefined})]}],
+    }),
+    description: 'Accounts with internal markers are expected',
+    error: 'ExpectedInternalAddressMarkerInAccountAddress',
+  },
+  {
+    args: makeArgs({}),
+    description: 'RPC addresses are mapped to addresses',
+    expected: makeExpected({}),
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, ({end, strictSame, throws}) => {
+    if (!!error) {
+      throws(() => rpcAddressesAsAddresses(args), new Error(error), 'Got err');
+    } else {
+      const res = rpcAddressesAsAddresses(args);
+
+      strictSame(res, expected, 'Got expected result');
+    }
+
+    return end();
+  });
+});

package/test/typescript/get_block.test-d.ts

@@ -0,0 +1,26 @@
+import {expectError, expectType} from 'tsd';
+import {getBlock, GetBlockResult} from '../../lnd_methods';
+import {AuthenticatedLnd} from '../../lnd_grpc';
+
+const lnd = {} as AuthenticatedLnd;
+const height = 0;
+const id = 'id';
+
+expectError(getBlock());
+expectError(getBlock({}));
+expectError(getBlock({lnd}));
+expectError(getBlock({height, id}));
+
+expectType<GetBlockResult>(await getBlock({lnd, height}));
+expectType<GetBlockResult>(await getBlock({lnd, id}));
+
+expectType<void>(
+  getBlock({lnd, height}, (error, result) => {
+    expectType<GetBlockResult>(result);
+  })
+);
+expectType<void>(
+  getBlock({lnd, id}, (error, result) => {
+    expectType<GetBlockResult>(result);
+  })
+);

package/test/typescript/probe_for_route.test-d.ts

@@ -6,21 +6,34 @@ const lnd = {} as AuthenticatedLnd;
 
 const destination = 'destination';
 const tokens = 21;
+const mtokens = '21';
 
 expectError(probeForRoute());
 expectError(probeForRoute({}));
+
 expectError(probeForRoute({lnd}));
 expectError(probeForRoute({destination}));
 expectError(probeForRoute({tokens}));
+expectError(probeForRoute({mtokens}));
+
 expectError(probeForRoute({lnd, destination}));
 expectError(probeForRoute({lnd, tokens}));
+expectError(probeForRoute({lnd, mtokens}));
 
 expectType<ProbeForRouteResult>(
   await probeForRoute({lnd, destination, tokens})
 );
+expectType<ProbeForRouteResult>(
+  await probeForRoute({lnd, destination, mtokens})
+);
 
 expectType<void>(
   probeForRoute({lnd, destination, tokens}, (error, result) => {
     expectType<ProbeForRouteResult>(result);
   })
 );
+expectType<void>(
+  probeForRoute({lnd, destination, mtokens}, (error, result) => {
+    expectType<ProbeForRouteResult>(result);
+  })
+);