astra-lightning 1.1.2 → 1.1.4

package/lnd_responses/pending_as_pending_channels.js

@@ -41,6 +41,8 @@ const outpointSeparator = ':';
         capacity: <Channel Capacity Tokens Count String>
         channel_point: <Channel Outpoint String>
         commitment_type: <Type of Channel String>
+        confirmation_height: <Best Chain Block Height Funding Seen Number>
+        confirmations_until_active: <Blocks Remaining to Channel Active Number>
         initiator: <Channel Creator Status String>
         local_balance: <Local Balance Tokens String>
         local_chan_reserve_sat: <Local Side Channel Reserve Tokens String>
@@ -97,6 +99,8 @@ const outpointSeparator = ':';
       is_timelocked: <Channel Local Funds Constrained by Timelock Script Bool>
       local_balance: <Channel Local Tokens Balance Number>
       local_reserve: <Channel Local Reserved Tokens Number>
+      [opening_funding_height]: <Funding Seen At Best Block Height Number>
+      [opening_waiting_blocks]: <Open Activation Waiting Blocks Count Number>
       partner_public_key: <Channel Peer Public Key String>
       [pending_balance]: <Tokens Pending Recovery Number>
       [pending_payments]: [{
@@ -247,6 +251,8 @@ module.exports = args => {
 
     sum[pending.channel.channel_point] = {
       funding_expiry: Number(pending.funding_expiry_blocks) || undefined,
+      open_blocks: Number(pending.confirmations_until_active) || undefined,
+      open_height: Number(pending.confirmation_height) || undefined,
       transaction_fee: Number(pending.commit_fee),
       transaction_weight: Number(pending.commit_weight),
     };
@@ -311,6 +317,8 @@ module.exports = args => {
       is_timelocked: forced.timelock_blocks !== undefined,
       local_balance: Number(channel.local_balance),
       local_reserve: Number(channel.local_chan_reserve_sat),
+      opening_funding_height: !chanOpen ? undefined : chanOpen.open_height,
+      opening_waiting_blocks: !chanOpen ? undefined : chanOpen.open_blocks,
       partner_public_key: channel.remote_node_pub,
       pending_balance: pendingTokens || undefined,
       pending_payments: forced.pending_payments || undefined,

package/lnd_responses/pending_from_payment.js

@@ -1,12 +1,12 @@
-const { attemptStates } = require("./constants");
-const rpcAttemptHtlcAsAttempt = require("./rpc_attempt_htlc_as_attempt");
-const { safeTokens } = require("../bolt00");
+const {attemptStates} = require('./constants');
+const rpcAttemptHtlcAsAttempt = require('./rpc_attempt_htlc_as_attempt');
+const {safeTokens} = require('./../bolt00');
 
-const { isArray } = Array;
-const is256Hex = (n) => !!n && /^[0-9A-F]{64}$/i.test(n);
-const { max } = Math;
-const mtokensAsTokens = (mtokens) => safeTokens({ mtokens }).tokens;
-const nsAsDate = (ns) => new Date(Number(BigInt(ns) / BigInt(1e6)));
+const {isArray} = Array;
+const is256Hex = n => !!n && /^[0-9A-F]{64}$/i.test(n);
+const {max} = Math;
+const mtokensAsTokens = mtokens => safeTokens({mtokens}).tokens;
+const nsAsDate = ns => new Date(Number(BigInt(ns) / BigInt(1e6)));
 
 /** Calculate total payment details from RPC payment HTLC elements
 
@@ -93,43 +93,43 @@ const nsAsDate = (ns) => new Date(Number(BigInt(ns) / BigInt(1e6)));
     tokens: <Total Tokens Pending Rounded Down Number>
   }
 */
-module.exports = (payment) => {
+module.exports = payment => {
   if (!payment) {
-    throw new Error("ExpectedPendingPaymentToDerivePendingDetails");
+    throw new Error('ExpectedPendingPaymentToDerivePendingDetails');
   }
 
   if (!payment.creation_time_ns) {
-    throw new Error("ExpectedPaymentCreationDateToDerivePendingDetails");
+    throw new Error('ExpectedPaymentCreationDateToDerivePendingDetails');
   }
 
   if (!payment.fee_msat) {
-    throw new Error("ExpectedPaymentFeeMillitokensAmountForPendingPayment");
+    throw new Error('ExpectedPaymentFeeMillitokensAmountForPendingPayment');
   }
 
   if (!isArray(payment.htlcs)) {
-    throw new Error("ExpectedArrayOfPaymentHtlcsInPendingPayment");
+    throw new Error('ExpectedArrayOfPaymentHtlcsInPendingPayment');
   }
 
-  if (!payment.htlcs.find((n) => n.status === attemptStates.pending)) {
-    throw new Error("ExpectedPendingHtlcInPendingPayment");
+  if (!payment.htlcs.find(n => n.status === attemptStates.pending)) {
+    throw new Error('ExpectedPendingHtlcInPendingPayment');
   }
 
   if (!is256Hex(payment.payment_hash)) {
-    throw new Error("ExpectedPaymentHashForPaymentAsPendingPayment");
+    throw new Error('ExpectedPaymentHashForPaymentAsPendingPayment');
   }
 
   if (mtokensAsTokens(payment.value_msat) !== Number(payment.value_sat)) {
-    throw new Error("ExpectedValueOfTokensAndMillitokensToBeConsistent");
+    throw new Error('ExpectedValueOfTokensAndMillitokensToBeConsistent');
   }
 
-  const attempts = payment.htlcs.map((htlc) => rpcAttemptHtlcAsAttempt(htlc));
+  const attempts = payment.htlcs.map(htlc => rpcAttemptHtlcAsAttempt(htlc));
   const mtokens = BigInt(payment.value_msat) + BigInt(payment.fee_msat);
 
-  const pending = attempts.filter((n) => n.is_pending);
+  const pending = attempts.filter(n => n.is_pending);
 
   const [first] = pending;
 
-  const [destination] = first.route.hops.map((n) => n.public_key).reverse();
+  const [destination] = first.route.hops.map(n => n.public_key).reverse();
 
   return {
     destination,
@@ -137,10 +137,10 @@ module.exports = (payment) => {
     id: payment.payment_hash,
     index: payment.payment_index,
     mtokens: mtokens.toString(),
-    paths: pending.map((n) => n.route),
+    paths: pending.map(n => n.route),
     request: payment.payment_request || undefined,
-    safe_tokens: safeTokens({ mtokens: mtokens.toString() }).safe,
-    timeout: max(...pending.map((n) => n.route.timeout).filter((n) => !!n)),
-    tokens: safeTokens({ mtokens: mtokens.toString() }).tokens,
+    safe_tokens: safeTokens({mtokens: mtokens.toString()}).safe,
+    timeout: max(...pending.map(n => n.route.timeout).filter(n => !!n)),
+    tokens: safeTokens({mtokens: mtokens.toString()}).tokens,
   };
 };

package/lnd_responses/routes_from_query_routes.js

@@ -1,12 +1,12 @@
-const BN = require("bn.js");
-const { chanFormat } = require("bolt07");
+const BN = require('bn.js');
+const {chanFormat} = require('bolt07');
 
-const { safeTokens } = require("../bolt00");
+const {safeTokens} = require('./../bolt00');
 
-const { isArray } = Array;
-const { keys } = Object;
+const {isArray} = Array;
+const {keys} = Object;
 const mtokensPerToken = BigInt(1e3);
-const { round } = Math;
+const {round} = Math;
 const successDenominator = 1e6;
 
 /** Routes from raw lnd query routes gRPC response
@@ -66,29 +66,29 @@ const successDenominator = 1e6;
     }]
   }
 */
-module.exports = ({ response }) => {
+module.exports = ({response}) => {
   if (!response) {
-    throw new Error("ExpectedResponse");
+    throw new Error('ExpectedResponse');
   }
 
-  const { routes } = response;
+  const {routes} = response;
 
   const confidence = round(response.success_prob * successDenominator);
 
   if (!isArray(routes)) {
-    throw new Error("ExpectedRoutes");
+    throw new Error('ExpectedRoutes');
   }
 
   if (!routes.length) {
-    throw new Error("ExpectedMultipleRoutes");
+    throw new Error('ExpectedMultipleRoutes');
   }
 
-  const invalidRoute = routes.find((route) => {
-    if (typeof route.total_fees_msat !== "string") {
+  const invalidRoute = routes.find(route => {
+    if (typeof route.total_fees_msat !== 'string') {
       return true;
     }
 
-    if (typeof route.total_time_lock !== "number") {
+    if (typeof route.total_time_lock !== 'number') {
       return true;
     }
 
@@ -100,54 +100,54 @@ module.exports = ({ response }) => {
   });
 
   if (!!invalidRoute) {
-    throw new Error("ExpectedValidRoutes");
+    throw new Error('ExpectedValidRoutes');
   }
 
   try {
-    routes.forEach((route) => {
-      return route.hops.forEach((h) => chanFormat({ number: h.chan_id }));
+    routes.forEach(route => {
+      return route.hops.forEach(h => chanFormat({number: h.chan_id}));
     });
   } catch (err) {
-    throw new Error("ExpectedValidHopChannelIdsInRoutes");
+    throw new Error('ExpectedValidHopChannelIdsInRoutes');
   }
 
   return {
-    routes: routes.map((route) => {
+    routes: routes.map(route => {
       const [lastHop] = route.hops.slice().reverse();
       const totalFeesMtok = BigInt(route.total_fees_msat);
       const totalAmtMtok = BigInt(route.total_amt_msat);
 
       return {
         confidence: confidence || undefined,
-        fee: safeTokens({ mtokens: route.total_fees_msat }).tokens,
+        fee: safeTokens({mtokens: route.total_fees_msat}).tokens,
         fee_mtokens: route.total_fees_msat,
-        hops: route.hops.map((h) => {
+        hops: route.hops.map(h => {
           return {
-            channel: chanFormat({ number: h.chan_id }).channel,
+            channel: chanFormat({number: h.chan_id}).channel,
             channel_capacity: Number(h.chan_capacity),
-            fee: safeTokens({ mtokens: h.fee_msat }).tokens,
+            fee: safeTokens({mtokens: h.fee_msat}).tokens,
             fee_mtokens: h.fee_msat,
-            forward: safeTokens({ mtokens: h.amt_to_forward_msat }).tokens,
+            forward: safeTokens({mtokens: h.amt_to_forward_msat}).tokens,
             forward_mtokens: h.amt_to_forward_msat,
             public_key: h.pub_key,
             timeout: h.expiry,
           };
         }),
-        messages: keys((lastHop || {}).custom_records || {}).map((type) => {
-          const rawType = Buffer.from(type, "ascii").reverse();
+        messages: keys((lastHop || {}).custom_records || {}).map(type => {
+          const rawType = Buffer.from(type, 'ascii').reverse();
 
           const typeNumber = new BN(rawType).toString();
 
           return {
             type: typeNumber,
-            value: lastHop.custom_records[type].toString("hex"),
+            value: lastHop.custom_records[type].toString('hex'),
           };
         }),
         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,
       };
     }),
   };

package/lnd_responses/rpc_channel_as_channel.js

@@ -1,10 +1,10 @@
-const { chanFormat } = require('bolt07');
+const {chanFormat} = require('bolt07');
 
-const { channelTypes } = require('./constants');
+const {channelTypes} = require('./constants');
 const parseThawHeight = require('./parse_thaw_height');
 const rpcHtlcAsPayment = require('./rpc_htlc_as_payment');
 
-const { isArray } = Array;
+const {isArray} = Array;
 const msPerSec = 1e3;
 const outpointDelimiter = ':';
 
@@ -218,7 +218,7 @@ module.exports = args => {
   }
 
   const commitWeight = Number(args.commit_weight);
-  const { height } = parseThawHeight({ id: args.chan_id, thaw: args.thaw_height });
+  const {height} = parseThawHeight({id: args.chan_id, thaw: args.thaw_height});
   const own = args.local_constraints;
   const peer = args.remote_constraints;
   const pushAmount = Number(args.push_amount_sat) || Number();
@@ -231,21 +231,22 @@ module.exports = args => {
 
   const otherIds = args.alias_scids
     .filter(n => n !== channelId)
-    .map(number => chanFormat({ number }));
+    .map(number => chanFormat({number}));
 
   const customChannelData = args.custom_channel_data ?
-    Buffer.from(args.custom_channel_data, "hex").toString("utf-8")
-    : ""
+  Buffer.from(args.custom_channel_data, "hex").toString("utf-8")
+  : ""
 
   return {
     capacity: Number(args.capacity),
+
     commit_transaction_fee: Number(args.commit_fee),
     commit_transaction_weight: commitWeight,
     cooperative_close_address: args.close_address || undefined,
     cooperative_close_delay_height: height,
     description: args.memo || undefined,
-    id: chanFormat({ number: channelId }).channel,
-    channel_id: channelId,
+    id: chanFormat({number: channelId}).channel,
+    channel_id:channelId,
     is_active: args.active,
     is_closing: false,
     is_opening: false,

package/lnd_responses/rpc_fees_as_channel_fees.js

@@ -1,12 +1,12 @@
-const { chanFormat } = require("bolt07");
+const {chanFormat} = require('bolt07');
 
-const { safeTokens } = require("../bolt00");
+const {safeTokens} = require('./../bolt00');
 
-const discount = (fee) => (!fee ? 0 : -fee).toString();
-const inverse = (rate) => (!rate ? 0 : -rate);
-const isHash = (n) => /^[0-9A-F]{64}$/i.test(n);
+const discount = fee => (!fee ? 0 : -fee).toString();
+const inverse = rate => !rate ? 0 : -rate;
+const isHash = n => /^[0-9A-F]{64}$/i.test(n);
 const notFound = -1;
-const outpointDivider = ":";
+const outpointDivider = ':';
 
 /** Derive channel fees from RPC fees
 
@@ -31,42 +31,42 @@ const outpointDivider = ":";
     transaction_vout: <Funding Outpoint Output Index Number>
   }
 */
-module.exports = (channel) => {
+module.exports = channel => {
   if (!channel) {
-    throw new Error("ExpectedRpcChannelPolicyToDeriveChannelFees");
+    throw new Error('ExpectedRpcChannelPolicyToDeriveChannelFees');
   }
 
   if (!channel.channel_point) {
-    throw new Error("ExpectedChannelPoint");
+    throw new Error('ExpectedChannelPoint');
   }
 
   if (channel.channel_point.indexOf(outpointDivider) === notFound) {
-    throw new Error("UnexpectedChannelPointFormat");
+    throw new Error('UnexpectedChannelPointFormat');
   }
 
   const [txId, index] = channel.channel_point.split(outpointDivider);
 
   if (!isHash(txId)) {
-    throw new Error("ExpectedChannelPointTransactionId");
+    throw new Error('ExpectedChannelPointTransactionId');
   }
 
   if (!index) {
-    throw new Error("ExpectedChannelPointIndex");
+    throw new Error('ExpectedChannelPointIndex');
   }
 
   if (!channel.base_fee_msat) {
-    throw new Error("ExpectedBaseFeeForChannel");
+    throw new Error('ExpectedBaseFeeForChannel');
   }
 
   if (!channel.fee_per_mil) {
-    throw new Error("ExpectedFeeRatePerMillion");
+    throw new Error('ExpectedFeeRatePerMillion');
   }
 
   return {
-    base_fee: safeTokens({ mtokens: channel.base_fee_msat }).tokens,
+    base_fee: safeTokens({mtokens: channel.base_fee_msat}).tokens,
     base_fee_mtokens: channel.base_fee_msat,
     fee_rate: Number(channel.fee_per_mil),
-    id: chanFormat({ number: channel.chan_id }).channel,
+    id: chanFormat({number: channel.chan_id}).channel,
     inbound_base_discount_mtokens: discount(channel.inbound_base_fee_msat),
     inbound_rate_discount: inverse(channel.inbound_fee_per_mil),
     transaction_id: txId,

package/lnd_responses/rpc_forward_as_forward_request.js

@@ -1,13 +1,13 @@
-const BN = require("bn.js");
-const { chanFormat } = require("bolt07");
+const BN = require('bn.js');
+const {chanFormat} = require('bolt07');
 
-const { safeTokens } = require("../bolt00");
+const {safeTokens} = require('./../bolt00');
 
-const bufferAsHex = (buffer) => buffer.toString("hex");
-const { isBuffer } = Buffer;
-const { keys } = Object;
+const bufferAsHex = buffer => buffer.toString('hex');
+const {isBuffer} = Buffer;
+const {keys} = Object;
 
-const numberAsChannelId = (number) => chanFormat({ number }).channel;
+const numberAsChannelId = number => chanFormat({number}).channel;
 
 /** Map an RPC forward request to a forward request
 
@@ -50,60 +50,60 @@ const numberAsChannelId = (number) => chanFormat({ number }).channel;
     tokens: <Tokens to Forward to Next Peer Rounded Down Number>
   }
 */
-module.exports = (forward) => {
+module.exports = forward => {
   if (!forward) {
-    throw new Error("ExpectedRpcForwardRequestToMapToForwardRequest");
+    throw new Error('ExpectedRpcForwardRequestToMapToForwardRequest');
   }
 
   if (!forward.custom_records) {
-    throw new Error("ExpectedCustomRecordsInRpcForwardRequest");
+    throw new Error('ExpectedCustomRecordsInRpcForwardRequest');
   }
 
   if (!forward.incoming_amount_msat) {
-    throw new Error("ExpectedIncomingAmountMillitokensInRpcForwardRequest");
+    throw new Error('ExpectedIncomingAmountMillitokensInRpcForwardRequest');
   }
 
   if (!forward.incoming_circuit_key) {
-    throw new Error("ExpectedInboundChannelDetailsInRpcForwardRequest");
+    throw new Error('ExpectedInboundChannelDetailsInRpcForwardRequest')
   }
 
   if (!forward.incoming_circuit_key.chan_id) {
-    throw new Error("ExpectedInboundChannelIdInRpcForwardRequest");
+    throw new Error('ExpectedInboundChannelIdInRpcForwardRequest');
   }
 
   if (forward.incoming_circuit_key.htlc_id === undefined) {
-    throw new Error("ExpectedInboundChannelHtlcIndexInRpcForwardRequest");
+    throw new Error('ExpectedInboundChannelHtlcIndexInRpcForwardRequest');
   }
 
   if (!forward.incoming_expiry) {
-    throw new Error("ExpectedCltvTimeoutHeightInRpcForwardRequest");
+    throw new Error('ExpectedCltvTimeoutHeightInRpcForwardRequest');
   }
 
   if (!forward.outgoing_amount_msat) {
-    throw new Error("ExpectedOutgoingAmountMillitokensInRpcForwardRequest");
+    throw new Error('ExpectedOutgoingAmountMillitokensInRpcForwardRequest');
   }
 
   if (!forward.outgoing_expiry) {
-    throw new Error("ExpectedOutgoingExpiryHeightInRpcForwardRequest");
+    throw new Error('ExpectedOutgoingExpiryHeightInRpcForwardRequest');
   }
 
   if (forward.outgoing_expiry > forward.incoming_expiry) {
-    throw new Error("ExpectedIncomingForwardExpiryHigherThanOutgoingExpiry");
+    throw new Error('ExpectedIncomingForwardExpiryHigherThanOutgoingExpiry');
   }
 
   if (!forward.outgoing_requested_chan_id) {
-    throw new Error("ExpectedOutgoingRequestedChannelIdInRpcForwardRequest");
+    throw new Error('ExpectedOutgoingRequestedChannelIdInRpcForwardRequest');
   }
 
   if (!isBuffer(forward.payment_hash)) {
-    throw new Error("ExpectedPaymentHashBufferInRpcForwardRequest");
+    throw new Error('ExpectedPaymentHashBufferInRpcForwardRequest');
   }
 
   const incomingAmount = BigInt(forward.incoming_amount_msat);
   const outgoingAmount = BigInt(forward.outgoing_amount_msat);
 
   if (incomingAmount < outgoingAmount) {
-    throw new Error("UnexpectedNegativeFeeInRpcForwardRequest");
+    throw new Error('UnexpectedNegativeFeeInRpcForwardRequest');
   }
 
   const hasOnion = !!forward.onion_blob && !!forward.onion_blob.length;
@@ -111,23 +111,23 @@ module.exports = (forward) => {
 
   return {
     cltv_delta: forward.incoming_expiry - forward.outgoing_expiry,
-    fee: safeTokens({ mtokens: totalFeeAmount.toString() }).tokens,
+    fee: safeTokens({mtokens: totalFeeAmount.toString()}).tokens,
     fee_mtokens: totalFeeAmount.toString(),
     hash: bufferAsHex(forward.payment_hash),
     in_channel: numberAsChannelId(forward.incoming_circuit_key.chan_id),
     in_payment: Number(forward.incoming_circuit_key.htlc_id),
-    messages: keys(forward.custom_records).map((type) => {
-      const rawType = Buffer.from(type, "ascii").reverse();
+    messages: keys(forward.custom_records).map(type => {
+      const rawType = Buffer.from(type, 'ascii').reverse();
 
       return {
         type: new BN(rawType).toString(),
-        value: forward.custom_records[type].toString("hex"),
+        value: forward.custom_records[type].toString('hex'),
       };
     }),
     mtokens: forward.outgoing_amount_msat,
-    onion: hasOnion ? forward.onion_blob.toString("hex") : undefined,
+    onion: hasOnion ? forward.onion_blob.toString('hex') : undefined,
     out_channel: numberAsChannelId(forward.outgoing_requested_chan_id),
     timeout: forward.incoming_expiry,
-    tokens: safeTokens({ mtokens: forward.outgoing_amount_msat }).tokens,
+    tokens: safeTokens({mtokens: forward.outgoing_amount_msat}).tokens,
   };
 };

package/lnd_responses/rpc_payment_as_payment.js

@@ -1,13 +1,13 @@
-const { parsePaymentRequest } = require("invoices");
+const {parsePaymentRequest} = require('invoices');
 
-const rpcAttemptHtlcAsAttempt = require("./rpc_attempt_htlc_as_attempt");
-const { safeTokens } = require("../bolt00");
+const rpcAttemptHtlcAsAttempt = require('./rpc_attempt_htlc_as_attempt');
+const {safeTokens} = require('./../bolt00');
 
-const emptyHash = Buffer.alloc(32).toString("hex");
-const { isArray } = Array;
+const emptyHash = Buffer.alloc(32).toString('hex');
+const {isArray} = Array;
 const msPerSecond = 1e3;
 const nanoSecsPerMillisecond = BigInt(1e6);
-const routePublicKeys = (route) => route.hops.map((n) => n.public_key);
+const routePublicKeys = route => route.hops.map(n => n.public_key);
 
 /** Payment details from RPC payment details
 
@@ -153,33 +153,33 @@ const routePublicKeys = (route) => route.hops.map((n) => n.public_key);
     tokens: <Rounded Down Tokens Sent to Destination Number>
   }
 */
-module.exports = (payment) => {
+module.exports = payment => {
   if (!payment) {
-    throw new Error("ExpectedPaymentInRpcResponse");
+    throw new Error('ExpectedPaymentInRpcResponse');
   }
 
   if (!payment.creation_date) {
-    throw new Error("ExpectedCreationDateInRpcPaymentDetails");
+    throw new Error('ExpectedCreationDateInRpcPaymentDetails');
   }
 
-  if (typeof payment.fee_sat !== "string") {
-    throw new Error("ExpectedPaymentFeeInRpcPaymentDetails");
+  if (typeof payment.fee_sat !== 'string') {
+    throw new Error('ExpectedPaymentFeeInRpcPaymentDetails');
   }
 
   if (!isArray(payment.htlcs)) {
-    throw new Error("ExpectedHtlcsArrayInRpcPaymentDetails");
+    throw new Error('ExpectedHtlcsArrayInRpcPaymentDetails');
   }
 
   if (!payment.payment_hash) {
-    throw new Error("ExpectedPaymentHashInRpcPaymentDetails");
+    throw new Error('ExpectedPaymentHashInRpcPaymentDetails');
   }
 
   if (!payment.payment_preimage) {
-    throw new Error("ExpectedPaymentPreimageInRpcPaymentDetails");
+    throw new Error('ExpectedPaymentPreimageInRpcPaymentDetails');
   }
 
-  if (typeof payment.value_sat !== "string") {
-    throw new Error("ExpectedPaymentValueInRpcPaymentDetails");
+  if (typeof payment.value_sat !== 'string') {
+    throw new Error('ExpectedPaymentValueInRpcPaymentDetails');
   }
 
   const creationDateEpochMs = (() => {
@@ -191,13 +191,13 @@ module.exports = (payment) => {
     return Number(BigInt(payment.creation_time_ns) / nanoSecsPerMillisecond);
   })();
 
-  const attempts = payment.htlcs.map((htlc) => rpcAttemptHtlcAsAttempt(htlc));
+  const attempts = payment.htlcs.map(htlc => rpcAttemptHtlcAsAttempt(htlc));
   const index = Number(payment.payment_index) || undefined;
   const request = payment.payment_request || undefined;
 
   // Exit early when there were no attempts
   if (!attempts.length) {
-    const { destination } = !!request ? parsePaymentRequest({ request }) : {};
+    const {destination} = !!request ? parsePaymentRequest({request}) : {};
 
     return {
       attempts,
@@ -214,20 +214,17 @@ module.exports = (payment) => {
       is_outgoing: true,
       mtokens: payment.value_msat,
       safe_fee: undefined,
-      safe_tokens: safeTokens({ mtokens: payment.value_msat }).safe,
+      safe_tokens: safeTokens({mtokens: payment.value_msat}).safe,
       secret: undefined,
-      tokens: safeTokens({ mtokens: payment.value_msat }).tokens,
+      tokens: safeTokens({mtokens: payment.value_msat}).tokens,
     };
   }
 
   const hasPreimage = payment.payment_preimage !== emptyHash;
   const [attempt] = attempts;
-  const successes = attempts.filter((n) => n.is_confirmed);
+  const successes = attempts.filter(n => n.is_confirmed);
 
-  const [confirmedAt] = successes
-    .map((n) => n.confirmed_at)
-    .sort()
-    .reverse();
+  const [confirmedAt] = successes.map(n => n.confirmed_at).sort().reverse();
   const path = routePublicKeys(attempt.route);
 
   const [destination, ...hops] = path.reverse();
@@ -249,9 +246,9 @@ module.exports = (payment) => {
       is_outgoing: true,
       mtokens: payment.value_msat,
       safe_fee: undefined,
-      safe_tokens: safeTokens({ mtokens: payment.value_msat }).safe,
+      safe_tokens: safeTokens({mtokens: payment.value_msat}).safe,
       secret: undefined,
-      tokens: safeTokens({ mtokens: payment.value_msat }).tokens,
+      tokens: safeTokens({mtokens: payment.value_msat}).tokens,
     };
   }
 
@@ -262,16 +259,16 @@ module.exports = (payment) => {
     request,
     confirmed_at: confirmedAt || undefined,
     created_at: new Date(creationDateEpochMs).toISOString(),
-    fee: safeTokens({ mtokens: payment.fee_msat }).tokens,
+    fee: safeTokens({mtokens: payment.fee_msat}).tokens,
     fee_mtokens: payment.fee_msat,
     hops: hops.reverse(),
     id: payment.payment_hash,
     is_confirmed: true,
     is_outgoing: true,
     mtokens: payment.value_msat,
-    safe_fee: safeTokens({ mtokens: payment.fee_msat }).safe,
-    safe_tokens: safeTokens({ mtokens: payment.value_msat }).safe,
+    safe_fee: safeTokens({mtokens: payment.fee_msat}).safe,
+    safe_tokens: safeTokens({mtokens: payment.value_msat}).safe,
     secret: payment.payment_preimage,
-    tokens: safeTokens({ mtokens: payment.value_msat }).tokens,
+    tokens: safeTokens({mtokens: payment.value_msat}).tokens,
   };
 };