astra-lightning 1.1.2 → 1.1.4

package/lnd_methods/onchain/close_channel.d.ts

@@ -47,6 +47,8 @@ export type ForceCloseChannelArgs = AuthenticatedLightningArgs<
 export type CoopCloseChannelArgs = AuthenticatedLightningArgs<
   ExpectedIdOfChannelToClose & {
     is_force_close?: false;
+    /** Is Waiting For Pending Payments to Coop Close Bool */
+    is_graceful_close?: boolean;
     /** Request Sending Local Channel Funds To Address String */
     address?: string;
     /** Fail Cooperative Close Above Fee Rate */
@@ -79,6 +81,8 @@ export type CloseChannelResult = {
  * Requires `info:read`, `offchain:write`, `onchain:write`, `peers:write` permissions
  *
  * `max_tokens_per_vbyte` is not supported in LND 0.15.0 and below
+ * 
+ * `is_graceful_close` is not supported in LND 0.17.5 and below
  */
 export const closeChannel: AuthenticatedLightningMethod<
   CloseChannelArgs,

package/lnd_methods/onchain/close_channel.js

@@ -23,10 +23,13 @@ const type = 'default';
 
   `max_tokens_per_vbyte` is not supported in LND 0.15.0 and below
 
+  `is_graceful_close` is not supported in LND 0.17.5 and below
+
   {
     [address]: <Request Sending Local Channel Funds To Address String>
     [id]: <Standard Format Channel Id String>
     [is_force_close]: <Is Force Close Bool>
+    [is_graceful_close]: <Is Waiting For Pending Payments to Coop Close Bool>
     lnd: <Authenticated LND API Object>
     [max_tokens_per_vbyte]: <Fail Cooperative Close Above Fee Rate Number>
     [public_key]: <Peer Public Key String>
@@ -143,6 +146,7 @@ module.exports = (args, cbk) => {
           delivery_address: args.address || undefined,
           force: !!args.is_force_close,
           max_fee_per_vbyte: args.max_tokens_per_vbyte || undefined,
+          no_wait: args.is_graceful_close || undefined,
           sat_per_vbyte: !!tokensPerVByte ? tokensPerVByte : undefined,
           target_conf: targetConf,
         });

package/lnd_methods/onchain/open_channels.d.ts

@@ -11,6 +11,7 @@ export type MultipleChannelOpenOptions = Pick<
   | 'description'
   | 'fee_rate'
   | 'give_tokens'
+  | 'is_allowing_minimal_reserve'
   | 'is_private'
   | 'min_htlc_mtokens'
   | 'partner_public_key'

package/lnd_methods/onchain/open_channels.js

@@ -17,7 +17,7 @@ const {isArray} = Array;
 const isPublicKey = n => /^[0-9A-F]{66}$/i.test(n);
 const makeId = () => randomBytes(32);
 const method = 'openChannel';
-const notEnoughOutputs = 'not enough witness outputs to create funding';
+const reserve = isDust => isDust ? 354 : undefined;
 const taproot = 'SIMPLE_TAPROOT';
 const type = 'default';
 
@@ -38,6 +38,8 @@ const type = 'default';
   `--protocol.option-scid-alias` and `--protocol.zero-conf` set on both sides
   as well as a channel open request listener to accept the trusted funding.
 
+  `is_allowing_minimal_reserve` is not supported on LND 0.15.0 and below
+
   `base_fee_mtokens` is not supported on LND 0.15.5 and below
   `fee_rate` is not supported on LND 0.15.5 and below
 
@@ -54,6 +56,7 @@ const type = 'default';
       [description]: <Immutable Channel Description String>
       [fee_rate]: <Routing Fee Rate In Millitokens Per Million Number>
       [give_tokens]: <Tokens to Gift To Partner Number> // Defaults to zero
+      [is_allowing_minimal_reserve]: <Allow Peer to Have Minimal Reserve Bool>
       [is_private]: <Channel is Private Bool> // Defaults to false
       [is_simplified_taproot]: <Channel is Simplified Taproot Type Bool>
       [is_trusted_funding]: <Peer Should Avoid Waiting For Confirmation Bool>
@@ -112,6 +115,7 @@ module.exports = (args, cbk) => {
           id: makeId(),
           cooperative_close_address: channel.cooperative_close_address,
           give_tokens: channel.give_tokens,
+          is_allowing_minimal_reserve: channel.is_allowing_minimal_reserve,
           is_private: channel.is_private,
           is_simplified_taproot: channel.is_simplified_taproot,
           is_trusted_funding: channel.is_trusted_funding,
@@ -129,6 +133,7 @@ module.exports = (args, cbk) => {
           const baseType = !!channel.is_trusted_funding ? anchors : undefined;
           let isDone = false;
           const isSelfPublish = !!args.is_avoiding_broadcast;
+          const remoteReserve = reserve(!!channel.is_allowing_minimal_reserve);
 
           const commit = !!channel.is_simplified_taproot ? taproot : baseType;
 
@@ -149,6 +154,7 @@ module.exports = (args, cbk) => {
             node_pubkey: bufferFromHex(channel.partner_public_key),
             private: !!channel.is_private,
             push_sat: channel.give_tokens || undefined,
+            remote_chan_reserve_sat: remoteReserve,
             remote_csv_delay: channel.partner_csv_delay || undefined,
             scid_alias: channel.is_trusted_funding && channel.is_private,
             use_base_fee: channel.base_fee_mtokens !== undefined,

package/lnd_methods/onchain/request_chain_fee_increase.js

@@ -7,6 +7,7 @@ const defaultConfirmations = 6;
 const isHash = n => /^[0-9A-F]{64}$/i.test(n);
 const isNumber = n => !isNaN(n);
 const messageExternalUtxo = 'the passed output does not belong to the wallet';
+const messageInvalidOutputIndex = /^invalid.output.index/;
 const method = 'bumpFee';
 const type = 'wallet';
 
@@ -81,6 +82,10 @@ module.exports = (args, cbk) => {
             return cbk([404, 'SpecifiedOutpointNotFoundInWalletUtxos']);
           }
 
+          if (!!err && messageInvalidOutputIndex.test(err.details)) {
+            return cbk([404, 'SpecifiedOutpointNotFoundInWalletUtxos']);
+          }
+
           if (!!err) {
             return cbk([500, 'UnexpectedErrorRequestingChainFeeBump', {err}]);
           }

package/lnd_methods/onchain/subscribe_to_blocks.js

@@ -82,7 +82,7 @@ module.exports = ({lnd}) => {
       return emitError([503, 'UnexpectedBlockEventHashLength']);
     }
 
-    if (!data.height) {
+    if (data.height === undefined) {
       return emitError([503, 'ExpectedHeightInBlockEvent']);
     }
 

package/lnd_responses/confirmed_from_payment_status.js

@@ -1,17 +1,17 @@
-const { createHash } = require("crypto");
+const {createHash} = require('crypto');
 
-const { chanFormat } = require("bolt07");
+const {chanFormat} = require('bolt07');
 
-const { attemptStates } = require("./constants");
-const { safeTokens } = require("../bolt00");
+const {attemptStates} = require('./constants');
+const {safeTokens} = require('./../bolt00');
 
-const { confirmed } = attemptStates;
-const hexFromBuffer = (buffer) => buffer.toString("hex");
-const { isArray } = Array;
-const { isBuffer } = Buffer;
-const { max } = Math;
-const sha256 = (preimage) => createHash("sha256").update(preimage).digest();
-const sum = (arr) => arr.reduce((sum, n) => sum + BigInt(n), BigInt(Number()));
+const {confirmed} = attemptStates;
+const hexFromBuffer = buffer => buffer.toString('hex');
+const {isArray} = Array;
+const {isBuffer} = Buffer;
+const {max} = Math;
+const sha256 = preimage => createHash('sha256').update(preimage).digest();
+const sum = arr => arr.reduce((sum, n) => sum + BigInt(n), BigInt(Number()));
 
 /** Calculate total payment details from RPC payment HTLC elements
 
@@ -110,67 +110,65 @@ const sum = (arr) => arr.reduce((sum, n) => sum + BigInt(n), BigInt(Number()));
     tokens: <Total Tokens Paid Rounded Down Number>
   }
 */
-module.exports = ({ htlcs, preimage, route }) => {
+module.exports = ({htlcs, preimage, route}) => {
   if (!isArray(htlcs)) {
-    throw new Error("ExpectedArrayOfHtlcsToDeriveConfirmedFromPaymentStatus");
+    throw new Error('ExpectedArrayOfHtlcsToDeriveConfirmedFromPaymentStatus');
   }
 
   if (!isBuffer(preimage)) {
-    throw new Error("ExpectedPreimageBufferToDeriveConfirmFromPaymentStatus");
+    throw new Error('ExpectedPreimageBufferToDeriveConfirmFromPaymentStatus');
   }
 
   if (!route && !htlcs.length) {
-    throw new Error("ExpectedEitherRouteOrAttemptHtlcs");
+    throw new Error('ExpectedEitherRouteOrAttemptHtlcs');
   }
 
-  if (!!htlcs.length && !htlcs.filter((n) => n.status === confirmed).length) {
-    throw new Error("ExpectedSuccessfulHtlcAttemptForConfirmedStatus");
+  if (!!htlcs.length && !htlcs.filter(n => n.status === confirmed).length) {
+    throw new Error('ExpectedSuccessfulHtlcAttemptForConfirmedStatus');
   }
 
   const hasHtlcs = !!htlcs.length;
-  const id = sha256(preimage).toString("hex");
-  const secret = preimage.toString("hex");
-  const successHtlcs = htlcs.filter(
-    (n) => n.status === attemptStates.confirmed
-  );
+  const id = sha256(preimage).toString('hex');
+  const secret = preimage.toString('hex');
+  const successHtlcs = htlcs.filter(n => n.status === attemptStates.confirmed);
 
-  const payments = hasHtlcs ? successHtlcs.map(({ route }) => route) : [route];
+  const payments = hasHtlcs ? successHtlcs.map(({route}) => route) : [route];
 
-  const paths = payments.map((route) => ({
-    fee: safeTokens({ mtokens: route.total_fees_msat }).tokens,
+  const paths = payments.map(route => ({
+    fee: safeTokens({mtokens: route.total_fees_msat}).tokens,
     fee_mtokens: route.total_fees_msat,
-    hops: route.hops.map((hop) => ({
-      channel: chanFormat({ number: hop.chan_id }).channel,
+    hops: route.hops.map(hop => ({
+      channel: chanFormat({number: hop.chan_id}).channel,
       channel_capacity: Number(hop.chan_capacity),
-      fee: safeTokens({ mtokens: hop.fee_msat }).tokens,
+      fee: safeTokens({mtokens: hop.fee_msat}).tokens,
       fee_mtokens: hop.fee_msat,
-      forward: safeTokens({ mtokens: hop.amt_to_forward_msat }).tokens,
+      forward: safeTokens({mtokens: hop.amt_to_forward_msat}).tokens,
       forward_mtokens: hop.amt_to_forward_msat,
       public_key: hexFromBuffer(hop.pub_key),
       timeout: hop.expiry,
     })),
     mtokens: route.total_amt_msat,
-    safe_fee: safeTokens({ mtokens: route.total_fees_msat }).safe,
-    safe_tokens: safeTokens({ mtokens: route.total_amt_msat }).safe,
+    safe_fee: safeTokens({mtokens: route.total_fees_msat}).safe,
+    safe_tokens: safeTokens({mtokens: route.total_amt_msat}).safe,
     timeout: route.total_time_lock,
-    tokens: safeTokens({ mtokens: route.total_amt_msat }).tokens,
+    tokens: safeTokens({mtokens: route.total_amt_msat}).tokens,
   }));
 
-  const feeMtokens = sum(paths.map((n) => n.fee_mtokens));
-  const [{ hops }] = paths;
-  const mtokens = sum(paths.map(({ mtokens }) => mtokens));
+  const feeMtokens = sum(paths.map(n => n.fee_mtokens));
+  const [{hops}] = paths;
+  const mtokens = sum(paths.map(({mtokens}) => mtokens));
 
   return {
     hops,
     id,
     paths,
     secret,
-    fee: safeTokens({ mtokens: feeMtokens.toString() }).tokens,
+    fee: safeTokens({mtokens: feeMtokens.toString()}).tokens,
     fee_mtokens: feeMtokens.toString(),
     mtokens: mtokens.toString(),
-    safe_fee: safeTokens({ mtokens: feeMtokens.toString() }).safe,
-    safe_tokens: safeTokens({ mtokens: mtokens.toString() }).safe,
-    timeout: max(...paths.map(({ timeout }) => timeout)),
-    tokens: safeTokens({ mtokens: mtokens.toString() }).tokens,
+    safe_fee: safeTokens({mtokens: feeMtokens.toString()}).safe,
+    safe_tokens: safeTokens({mtokens: mtokens.toString()}).safe,
+    timeout: max(...paths.map(({timeout}) => timeout)),
+    tokens: safeTokens({mtokens: mtokens.toString()}).tokens,
   };
 };

package/lnd_responses/constants.json

@@ -25,6 +25,7 @@
   "commitmentTypes": {
     "anchor": "ANCHORS",
     "simplified_taproot": "SIMPLE_TAPROOT",
+    "simple_taproot_overlay": "SIMPLE_TAPROOT_OVERLAY",
     "static_remote_key": "STATIC_REMOTE_KEY",
     "variable_remote_key": "LEGACY"
   },

package/lnd_responses/forward_from_htlc_event.js

@@ -1,9 +1,9 @@
-const { chanFormat } = require("bolt07");
+const {chanFormat} = require('bolt07');
 
-const { htlcTypes } = require("./constants");
-const { safeTokens } = require("../bolt00");
+const {htlcTypes} = require('./constants');
+const {safeTokens} = require('./../bolt00');
 
-const bufferAsHex = (buffer) => buffer.toString("hex");
+const bufferAsHex = buffer => buffer.toString('hex');
 const nsPerMs = BigInt(1e6);
 
 /** Get RPC HTLC Event as a forward event
@@ -65,97 +65,97 @@ const nsPerMs = BigInt(1e6);
     [tokens]: <Sending Tokens Number>
   }
 */
-module.exports = (htlc) => {
+module.exports = htlc => {
   if (!htlc.event_type) {
-    throw new Error("ExpectedHtlcEventTypeToDeriveForwardFromHtlcEvent");
+    throw new Error('ExpectedHtlcEventTypeToDeriveForwardFromHtlcEvent');
   }
 
   if (!!htlc.forward_event) {
     if (!htlc.forward_event.info) {
-      throw new Error("ExpectedHtlcInfoInForwardEvent");
+      throw new Error('ExpectedHtlcInfoInForwardEvent');
     }
 
     if (!htlc.forward_event.info.incoming_amt_msat) {
-      throw new Error("ExpectedForwardEventIncomingAmountMsatToDeriveForward");
+      throw new Error('ExpectedForwardEventIncomingAmountMsatToDeriveForward');
     }
 
     if (htlc.forward_event.info.incoming_timelock === undefined) {
-      throw new Error("ExpectedForwardEventIncomingTimelockToDeriveForward");
+      throw new Error('ExpectedForwardEventIncomingTimelockToDeriveForward');
     }
 
     if (!htlc.forward_event.info.outgoing_amt_msat) {
-      throw new Error("ExpectedForwardEventOutgoingAmountMsatToDeriveForward");
+      throw new Error('ExpectedForwardEventOutgoingAmountMsatToDeriveForward');
     }
 
     if (htlc.forward_event.info.outgoing_timelock === undefined) {
-      throw new Error("ExpectedForwardEventOutgoingTimelockToDeriveForward");
+      throw new Error('ExpectedForwardEventOutgoingTimelockToDeriveForward');
     }
   }
 
   if (!htlc.incoming_channel_id) {
-    throw new Error("ExpectedIncomingChannelIdToDeriveForward");
+    throw new Error('ExpectedIncomingChannelIdToDeriveForward');
   }
 
   if (!htlc.incoming_htlc_id) {
-    throw new Error("ExpectedIncomingHtlcIdToDeriveForward");
+    throw new Error('ExpectedIncomingHtlcIdToDeriveForward');
   }
 
   if (!!htlc.link_fail_event) {
     if (!htlc.link_fail_event.failure_detail) {
-      throw new Error("ExpectedLinkFailureDetailInLinkFailureEvent");
+      throw new Error('ExpectedLinkFailureDetailInLinkFailureEvent');
     }
 
     if (!htlc.link_fail_event.failure_string) {
-      throw new Error("ExpectedLinkFailureStringInLinkFailureEvent");
+      throw new Error('ExpectedLinkFailureStringInLinkFailureEvent');
     }
 
     if (!htlc.link_fail_event.info) {
-      throw new Error("ExpectedHtlcInfoInLinkFailEvent");
+      throw new Error('ExpectedHtlcInfoInLinkFailEvent');
     }
 
     if (!htlc.link_fail_event.info.incoming_amt_msat) {
-      throw new Error("ExpectedLinkFailEventIncomingMsatToDeriveForward");
+      throw new Error('ExpectedLinkFailEventIncomingMsatToDeriveForward');
     }
 
     if (htlc.link_fail_event.info.incoming_timelock === undefined) {
-      throw new Error("ExpectedLinkFailEventIncomingTimelockToDeriveForward");
+      throw new Error('ExpectedLinkFailEventIncomingTimelockToDeriveForward');
     }
 
     if (!htlc.link_fail_event.info.outgoing_amt_msat) {
-      throw new Error("ExpectedLinkFailEventOutgoingMsatToDeriveForward");
+      throw new Error('ExpectedLinkFailEventOutgoingMsatToDeriveForward');
     }
 
     if (htlc.link_fail_event.info.outgoing_timelock === undefined) {
-      throw new Error("ExpectedForwardEventOutgoingTimelockToDeriveForward");
+      throw new Error('ExpectedForwardEventOutgoingTimelockToDeriveForward');
     }
   }
 
   if (!htlc.outgoing_channel_id) {
-    throw new Error("ExpectedOutgoingChannelIdToDeriveForward");
+    throw new Error('ExpectedOutgoingChannelIdToDeriveForward');
   }
 
   if (!htlc.outgoing_htlc_id) {
-    throw new Error("ExpectedOutgoingHtlcIdToDeriveForward");
+    throw new Error('ExpectedOutgoingHtlcIdToDeriveForward');
   }
 
   if (!!htlc.settle_event && !Buffer.isBuffer(htlc.settle_event.preimage)) {
-    throw new Error("ExpectedHtlcPreimageInForwardedSettleEvent");
+    throw new Error('ExpectedHtlcPreimageInForwardedSettleEvent');
   }
 
   if (!htlc.timestamp_ns) {
-    throw new Error("ExpectedHtlcTimestampToDeriveForward");
+    throw new Error('ExpectedHtlcTimestampToDeriveForward');
   }
 
   const createdAt = new Date(Number(BigInt(htlc.timestamp_ns) / nsPerMs));
-  const incoming = chanFormat({ number: htlc.incoming_channel_id });
+  const incoming = chanFormat({number: htlc.incoming_channel_id});
   const incomingId = Number(htlc.incoming_htlc_id);
   const isFailure = !!htlc.forward_fail_event || !!htlc.link_fail_event;
   const isForward = htlc.event_type === htlcTypes.forward;
   const isReceive = htlc.event_type === htlcTypes.receive;
   const isSend = htlc.event_type === htlcTypes.send;
-  const outgoing = chanFormat({ number: htlc.outgoing_channel_id });
+  const outgoing = chanFormat({number: htlc.outgoing_channel_id});
   const outgoingId = Number(htlc.outgoing_htlc_id);
-  const settleEvent = htlc.settle_event || { preimage: Buffer.alloc(Number()) };
+  const settleEvent = htlc.settle_event || {preimage: Buffer.alloc(Number())};
 
   // Exit early when there is no extended info, for failed forwards and settles
   if (!!htlc.forward_fail_event || !!htlc.settle_event) {
@@ -182,10 +182,10 @@ module.exports = (htlc) => {
   }
 
   if (!htlc.forward_event && !htlc.link_fail_event) {
-    throw new Error("ExpectedForwardEventOrLinkFailEventInHtlcEvent");
+    throw new Error('ExpectedForwardEventOrLinkFailEventInHtlcEvent');
   }
 
-  const { info } = htlc.forward_event || htlc.link_fail_event;
+  const {info} = htlc.forward_event || htlc.link_fail_event;
 
   const outgoingAmount = BigInt(info.outgoing_amt_msat);
   const outgoingCltvHeight = Number(info.outgoing_timelock);
@@ -193,13 +193,13 @@ module.exports = (htlc) => {
   const cltvDelta = Number(info.incoming_timelock) - outgoingCltvHeight;
   const feeMtok = (BigInt(info.incoming_amt_msat) - outgoingAmount).toString();
 
-  const { tokens } = safeTokens({ mtokens: info.outgoing_amt_msat });
+  const {tokens} = safeTokens({mtokens: info.outgoing_amt_msat});
 
   return {
     at: createdAt.toISOString(),
     cltv_delta: !isForward ? undefined : cltvDelta,
     external_failure: (htlc.link_fail_event || {}).wire_failure,
-    fee: !isForward ? undefined : safeTokens({ mtokens: feeMtok }).tokens,
+    fee: !isForward ? undefined : safeTokens({mtokens: feeMtok}).tokens,
     fee_mtokens: !isForward ? undefined : feeMtok,
     in_channel: !!isSend ? undefined : incoming.channel,
     in_payment: !!isSend ? undefined : incomingId,

package/lnd_responses/info_as_wallet_info.js

@@ -1,12 +1,12 @@
-const { chainId } = require("../bolt02");
-const { featureFlagDetails } = require("bolt09");
+const {chainId} = require('./../bolt02');
+const {featureFlagDetails} = require('bolt09');
 
-const dateFromEpoch = (epoch) => new Date(epoch * 1e3);
-const { isArray } = Array;
-const isBoolean = (n) => n === false || n === true;
-const isNumber = (n) => !isNaN(n);
-const isString = (n) => typeof n === "string";
-const { keys } = Object;
+const dateFromEpoch = epoch => new Date(epoch * 1e3);
+const {isArray} = Array;
+const isBoolean = n => n === false || n === true;
+const isNumber = n => !isNaN(n);
+const isString = n => typeof n === 'string';
+const {keys} = Object;
 
 /** Interpret info as wallet info
 
@@ -29,81 +29,81 @@ const { keys } = Object;
     version: <Node Version String>
   }
 */
-module.exports = (args) => {
+module.exports = args => {
   if (!args) {
-    throw new Error("ExpectedWalletResponse");
+    throw new Error('ExpectedWalletResponse');
   }
 
   if (!isString(args.alias)) {
-    throw new Error("ExpectedWalletAlias");
+    throw new Error('ExpectedWalletAlias');
   }
 
   if (!args.best_header_timestamp) {
-    throw new Error("ExpectedBestHeaderTimestampInInfoResponse");
+    throw new Error('ExpectedBestHeaderTimestampInInfoResponse');
   }
 
   if (!isString(args.block_hash)) {
-    throw new Error("ExpectedCurrentBlockHash");
+    throw new Error('ExpectedCurrentBlockHash');
   }
 
   if (!isNumber(args.block_height)) {
-    throw new Error("ExpectedBlockHeight");
+    throw new Error('ExpectedBlockHeight');
   }
 
   if (!isArray(args.chains)) {
-    throw new Error("ExpectedChainsAssociatedWithWallet");
+    throw new Error('ExpectedChainsAssociatedWithWallet');
   }
 
   if (!args.color) {
-    throw new Error("ExpectedWalletColorInWalletInfoResponse");
+    throw new Error('ExpectedWalletColorInWalletInfoResponse');
   }
 
   if (!args.features) {
-    throw new Error("ExpectedFeaturesMapInWalletInfoResponse");
+    throw new Error('ExpectedFeaturesMapInWalletInfoResponse');
   }
 
   if (!args.identity_pubkey) {
-    throw new Error("ExpectedIdentityPubkey");
+    throw new Error('ExpectedIdentityPubkey');
   }
 
   if (!isNumber(args.num_active_channels)) {
-    throw new Error("ExpectedNumActiveChannels");
+    throw new Error('ExpectedNumActiveChannels');
   }
 
   if (!isNumber(args.num_peers)) {
-    throw new Error("ExpectedNumPeers");
+    throw new Error('ExpectedNumPeers');
   }
 
   if (!isNumber(args.num_pending_channels)) {
-    throw new Error("ExpectedNumPendingChannels");
+    throw new Error('ExpectedNumPendingChannels');
   }
 
   if (!isBoolean(args.synced_to_chain)) {
-    throw new Error("ExpectedSyncedToChainStatus");
+    throw new Error('ExpectedSyncedToChainStatus');
   }
 
   if (!isArray(args.uris)) {
-    throw new Error("ExpectedArrayOfUrisInWalletInfoResponse");
+    throw new Error('ExpectedArrayOfUrisInWalletInfoResponse');
   }
 
   if (!isString(args.version)) {
-    throw new Error("ExpectedWalletLndVersion");
+    throw new Error('ExpectedWalletLndVersion');
   }
 
   return {
     chains: args.chains
-      .map(({ chain, network }) => chainId({ chain, network }).chain)
-      .filter((n) => !!n),
+      .map(({chain, network}) => chainId({chain, network}).chain)
+      .filter(n => !!n),
     color: args.color,
     active_channels_count: args.num_active_channels,
     alias: args.alias,
     current_block_hash: args.block_hash,
     current_block_height: args.block_height,
-    features: keys(args.features).map((bit) => ({
+    features: keys(args.features).map(bit => ({
       bit: Number(bit),
       is_known: args.features[bit].is_known,
       is_required: args.features[bit].is_required,
-      type: featureFlagDetails({ bit: Number(bit) }).type,
+      type: featureFlagDetails({bit: Number(bit)}).type,
     })),
     is_synced_to_chain: args.synced_to_chain,
     is_synced_to_graph: !args.synced_to_graph ? undefined : true,

package/lnd_responses/payment_request_details.js

@@ -1,16 +1,16 @@
-const { featureFlagDetails } = require("bolt09");
+const {featureFlagDetails} = require('bolt09');
 
-const routeFromRouteHint = require("./route_from_route_hint");
-const { safeTokens } = require("../bolt00");
+const routeFromRouteHint = require('./route_from_route_hint');
+const {safeTokens} = require('./../bolt00');
 
-const bufToHex = (n) => (!n.length ? undefined : n.toString("hex"));
+const bufToHex = n => !n.length ? undefined : n.toString('hex');
 const defaultExpireMs = 1000 * 60 * 60;
-const { isArray } = Array;
-const { isBuffer } = Buffer;
-const isHash = (n) => !!n && /^[0-9A-F]{64}$/i.test(n);
-const { keys } = Object;
+const {isArray} = Array;
+const {isBuffer} = Buffer;
+const isHash = n => !!n && /^[0-9A-F]{64}$/i.test(n);
+const {keys} = Object;
 const msPerSec = 1e3;
-const { now } = Date;
+const {now} = Date;
 
 /** Map payment request details to request details
 
@@ -76,40 +76,38 @@ const { now } = Date;
     tokens: <Requested Tokens Rounded Down Number>
   }
 */
-module.exports = (args) => {
+module.exports = args => {
   if (!args.destination) {
-    throw new Error("ExpectedDestinationInDecodedPaymentRequest");
+    throw new Error('ExpectedDestinationInDecodedPaymentRequest');
   }
 
   if (!args.expiry) {
-    throw new Error("ExpectedPaymentReqExpirationInDecodedPayReq");
+    throw new Error('ExpectedPaymentReqExpirationInDecodedPayReq');
   }
 
   if (!isBuffer(args.payment_addr)) {
-    throw new Error("ExpectedPaymentAddrBufferInDecodePayReqResponse");
+    throw new Error('ExpectedPaymentAddrBufferInDecodePayReqResponse');
   }
 
   if (!isHash(args.payment_hash)) {
-    throw new Error("ExpectedPaymentHashFromDecodePayReqResponse");
+    throw new Error('ExpectedPaymentHashFromDecodePayReqResponse');
   }
 
   if (!args.num_satoshis) {
-    throw new Error("ExpectedNumSatoshis");
+    throw new Error('ExpectedNumSatoshis');
   }
 
   if (!isArray(args.route_hints)) {
-    throw new Error("ExpectedRouteHintsArray");
+    throw new Error('ExpectedRouteHintsArray');
   }
 
-  const routes = args.route_hints.forEach((route) =>
-    routeFromRouteHint({
-      destination: args.destination,
-      hop_hints: route.hop_hints,
-    })
-  );
+  const routes = args.route_hints.forEach(route => routeFromRouteHint({
+    destination: args.destination,
+    hop_hints: route.hop_hints,
+  }));
 
   if (!args.timestamp) {
-    throw new Error("ExpectedPaymentRequestTimestamp");
+    throw new Error('ExpectedPaymentRequestTimestamp');
   }
 
   const createdAtMs = Number(args.timestamp) * msPerSec;
@@ -125,23 +123,21 @@ module.exports = (args) => {
     description_hash: args.description_hash || undefined,
     destination: args.destination,
     expires_at: new Date(expiryDateMs).toISOString(),
-    features: keys(args.features).map((bit) => ({
+    features: keys(args.features).map(bit => ({
       bit: Number(bit),
       is_known: args.features[bit].is_known,
       is_required: args.features[bit].is_required,
-      type: featureFlagDetails({ bit }).type,
+      type: featureFlagDetails({bit}).type,
     })),
     id: args.payment_hash,
     is_expired: now() > expiryDateMs,
     mtokens: args.num_msat,
     payment: bufToHex(args.payment_addr) || undefined,
-    routes: args.route_hints.map((route) =>
-      routeFromRouteHint({
-        destination: args.destination,
-        hop_hints: route.hop_hints,
-      })
-    ),
-    safe_tokens: safeTokens({ mtokens: args.num_msat }).safe,
+    routes: args.route_hints.map(route => routeFromRouteHint({
+      destination: args.destination,
+      hop_hints: route.hop_hints,
+    })),
+    safe_tokens: safeTokens({mtokens: args.num_msat}).safe,
     tokens: Number(args.num_satoshis),
   };
 };