lightning 6.8.1 → 7.0.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Versions
 
+## 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/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/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.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_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,7 +7,7 @@
     "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.18",
@@ -26,7 +26,7 @@
     "invoices": "2.2.2",
     "psbt": "2.7.1",
     "tiny-secp256k1": "2.2.1",
-    "type-fest": "3.5.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.1"
+  "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_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();
+  });
+});