balanceofsatoshis 25.2.2 → 25.3.0

package/chain/funding_keys.js

@@ -0,0 +1,59 @@
+const {scriptAsScriptElements} = require('@alexbosworth/blockchain');
+
+const bufferAsHex = buffer => buffer.toString('hex');
+const fundingScriptElementsCount = 5;
+const {isBuffer} = Buffer;
+const OP_2 = 82;
+const OP_CHECKMULTISIG = 174;
+const publicKeyByteLength = 33;
+
+/** Derive the funding public keys from the witness of the funding output spend
+
+  A close transaction spends the funding output with a 2 of 2 multisig witness
+  script that commits to both funding public keys.
+
+  {
+    [witness]: [<Witness Stack Element Hex String>]
+  }
+
+  @returns
+  {
+    [keys]: [<Funding Public Key Hex String>]
+  }
+*/
+module.exports = ({witness}) => {
+  // Exit early when there is no witness script to look at
+  if (!witness || !witness.length) {
+    return {};
+  }
+
+  const [script] = [].concat(witness).reverse();
+
+  // Witness elements are always hex, a malformed script has no elements
+  const {elements} = scriptAsScriptElements({script});
+
+  // Exit early when the script is not shaped like a 2 of 2 multisig
+  if (!elements || elements.length !== fundingScriptElementsCount) {
+    return {};
+  }
+
+  const [op2, key1, key2, op2Again, opCheckMultisig] = elements;
+
+  // Exit early when the script is not a 2 of 2 multisig
+  if (op2 !== OP_2 || op2Again !== OP_2) {
+    return {};
+  }
+
+  if (opCheckMultisig !== OP_CHECKMULTISIG) {
+    return {};
+  }
+
+  const keys = [key1, key2];
+
+  // Exit early when the keys are not public keys
+  if (!!keys.find(n => !isBuffer(n) || n.length !== publicKeyByteLength)) {
+    return {};
+  }
+
+  return {keys: keys.map(bufferAsHex)};
+};

package/chain/get_block_transactions.js

@@ -0,0 +1,100 @@
+const asyncAuto = require('async/auto');
+const {getBlock} = require('ln-service');
+const {queryTransactions} = require('@alexbosworth/blockchain');
+const {returnResult} = require('asyncjs-util');
+
+const defaultTimeoutMs = 1000 * 10;
+const {isArray} = Array;
+const isHash = n => /^[0-9A-F]{64}$/i.test(n);
+
+/** Get transactions in a block by their ids using the LND chain backend
+
+  When the block is not retrieved before the timeout, no txs are returned
+
+  {
+    height: <Block Height Number>
+    ids: [<Transaction Id Hex String>]
+    lnd: <Authenticated LND API Object>
+    [timeout]: <Stop Waiting For The Block After Milliseconds Number>
+  }
+
+  @returns via cbk or Promise
+  {
+    transactions: [{
+      id: <Transaction Id Hex String>
+      transaction: <Raw Transaction Hex String>
+    }]
+  }
+*/
+module.exports = (args, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!args.height) {
+          return cbk([400, 'ExpectedBlockHeightToGetBlockTransactions']);
+        }
+
+        if (!isArray(args.ids) || !args.ids.length) {
+          return cbk([400, 'ExpectedTransactionIdsToGetBlockTransactions']);
+        }
+
+        if (!!args.ids.find(n => !isHash(n))) {
+          return cbk([400, 'ExpectedTransactionIdHexStringsToGetBlockTxs']);
+        }
+
+        if (!args.lnd) {
+          return cbk([400, 'ExpectedLndToGetBlockTransactions']);
+        }
+
+        return cbk();
+      },
+
+      // Get the block from LND, giving up when it takes too long
+      getBlock: ['validate', ({}, cbk) => {
+        let isFinished = false;
+
+        const finished = (err, res) => {
+          // Exit early when the result was already returned
+          if (isFinished) {
+            return;
+          }
+
+          isFinished = true;
+
+          clearTimeout(timer);
+
+          return cbk(err, res);
+        };
+
+        // Stop waiting when the block is not retrieved in time
+        const timer = setTimeout(() => {
+          return finished(null, {});
+        },
+        args.timeout || defaultTimeoutMs);
+
+        return getBlock({height: args.height, lnd: args.lnd}, finished);
+      }],
+
+      // Find the transactions in the block
+      transactions: ['getBlock', ({getBlock}, cbk) => {
+        // Exit early when there is no block to look through
+        if (!getBlock.block) {
+          return cbk(null, {transactions: []});
+        }
+
+        try {
+          const {transactions} = queryTransactions({
+            block: getBlock.block,
+            ids: args.ids,
+          });
+
+          return cbk(null, {transactions});
+        } catch (err) {
+          return cbk([503, 'UnexpectedErrorParsingBlockTransactions', {err}]);
+        }
+      }],
+    },
+    returnResult({reject, resolve, of: 'transactions'}, cbk));
+  });
+};

package/chain/get_channel_closes.js

@@ -3,47 +3,54 @@ const asyncMapSeries = require('async/mapSeries');
 const {getChainTransactions} = require('ln-service');
 const {getClosedChannels} = require('ln-service');
 const {getHeight} = require('ln-service');
-const {getNetwork} = require('ln-sync');
-const {getNode} = require('ln-service');
 const {getNodeAlias} = require('ln-sync');
+const {getPendingChannels} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 
+const anchorOutput = require('./anchor_output');
+const closeResolutions = require('./close_resolutions');
 const closingFees = require('./closing_fees');
-const getChannelResolution = require('./get_channel_resolution');
+const contractOutputs = require('./contract_outputs');
+const getCloseTransactions = require('./get_close_transactions');
 
 const defaultLimit = 20;
+const flatten = arr => [].concat(...arr);
 
 /** Get the last channel close outcomes
 
   {
     [limit]: <Limit Number>
     lnd: <Authenticated LND API Object>
-    request: <Request Function>
   }
 
   @returns via cbk or Promise
   {
-    peer_public_key: <Peer Public Key Hex String>
-    [peer_alias]: <Peer Alias Strring>
-    [is_local_force_close]: <Channel Was Locally Force Closed Bool>
-    [is_cooperative_close]: <Channel Was Cooperatively Closed Bool>
-    [is_remote_force_close]: <Channel was Remotely Force Closed Bool>
-    [peer_closed_channel]: <Peer Closed the Channel Bool>
-    blocks_since_close: <Count of Blocks Since Close Number>
-    capacity: <Channel Capacity Tokens Number>
-    [channel_id]: <Channel Id String>
-    channel_open: <Channel Funding Outpoint String>
-    channel_close: <Channel Close Transaction Id Hex String>
-    [channel_balance_spend]: <Channel Balance Spent In Tx Id Hex String>
-    [channel_resolutions]: [{
-      type: <Resolution Type String>
-      value: <Value Number>
+    closes: [{
+      peer_public_key: <Peer Public Key Hex String>
+      [peer_alias]: <Peer Alias Strring>
+      [is_local_force_close]: <Channel Was Locally Force Closed Bool>
+      [is_cooperative_close]: <Channel Was Cooperatively Closed Bool>
+      [is_remote_force_close]: <Channel was Remotely Force Closed Bool>
+      [peer_opened_channel]: <Peer Opened the Channel Bool>
+      [peer_closed_channel]: <Peer Closed the Channel Bool>
+      blocks_since_close: <Count of Blocks Since Close Number>
+      capacity: <Channel Capacity Tokens Number>
+      [channel_id]: <Channel Id String>
+      channel_open: <Channel Funding Outpoint String>
+      channel_close: <Channel Close Transaction Id Hex String>
+      [channel_balance_spend]: <Channel Balance Spent In Tx Id Hex String>
+      [channel_resolutions]: [{
+        [transaction_id]: <Latest Resolving Transaction Id Hex String>
+        type: <Resolution Type String>
+        [value]: <Value Number>
+      }]
+      [is_breach_close]: <Channel Was Breach Closed Bool>
+      [closing_fee_paid]: <Closing Fees Paid Related To Channel Tokens Number>
+      [is_closing_fee_unknown]: <Closing Fees Paid Are Not Known Bool>
     }]
-    [is_breach_close]: <Channel Was Breach Closed Bool>
-    [closing_fee_paid]: <Closing Fees Paid Related To Channel Tokens Number>
   }
 */
-module.exports = ({limit, lnd, request}, cbk) => {
+module.exports = ({limit, lnd}, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
@@ -52,10 +59,6 @@ module.exports = ({limit, lnd, request}, cbk) => {
           return cbk([400, 'ExpectedLndToGetChannelCloses']);
         }
 
-        if (!request) {
-          return cbk([400, 'ExpectedRequestFunctionToGetChannelCloses']);
-        }
-
         return cbk();
       },
 
@@ -65,20 +68,14 @@ module.exports = ({limit, lnd, request}, cbk) => {
       // Get the current height
       getHeight: ['validate', ({}, cbk) => getHeight({lnd}, cbk)],
 
-      // Get the network
-      getNetwork: ['validate', ({}, cbk) => getNetwork({lnd}, cbk)],
+      // Get pending channels, their outputs may share resolving transactions
+      getPending: ['validate', ({}, cbk) => getPendingChannels({lnd}, cbk)],
 
       // Get on-chain transactions
       getTx: ['validate', ({}, cbk) => getChainTransactions({lnd}, cbk)],
 
-      // Get spends
-      getSpends: [
-        'getClosed',
-        'getHeight',
-        'getNetwork',
-        'getTx',
-        async ({getClosed, getHeight, getNetwork, getTx}) =>
-      {
+      // Select the most recent closed channels
+      getChannels: ['getClosed', ({getClosed}, cbk) => {
         const closedChannels = getClosed.channels
           .reverse()
           .filter(channel => !!channel.close_transaction_id)
@@ -86,30 +83,133 @@ module.exports = ({limit, lnd, request}, cbk) => {
 
         const channels = closedChannels.slice(Number(), limit || defaultLimit);
 
-        return await asyncMapSeries(channels, async channel => {
-          const {resolutions} = await getChannelResolution({
-            request,
+        return cbk(null, channels);
+      }],
+
+      // Get the aliases of the closed channel peers
+      getAliases: ['getChannels', ({getChannels}, cbk) => {
+        return asyncMapSeries(getChannels, (channel, cbk) => {
+          return getNodeAlias({lnd, id: channel.partner_public_key}, cbk);
+        },
+        cbk);
+      }],
+
+      // Get close transactions that are not in the wallet from LND
+      getCloseTxs: ['getChannels', 'getTx', ({getChannels, getTx}, cbk) => {
+        return getCloseTransactions({
+          lnd,
+          channels: getChannels,
+          transactions: getTx.transactions,
+        },
+        cbk);
+      }],
+
+      // Channel closes
+      closes: [
+        'getAliases',
+        'getChannels',
+        'getClosed',
+        'getCloseTxs',
+        'getHeight',
+        'getPending',
+        'getTx',
+        ({
+          getAliases,
+          getChannels,
+          getClosed,
+          getCloseTxs,
+          getHeight,
+          getPending,
+          getTx,
+        },
+        cbk) =>
+      {
+        // Close transactions found by LND are added to the wallet transactions
+        const transactions = []
+          .concat(getTx.transactions)
+          .concat(getCloseTxs.transactions);
+
+        // Close tx outputs and HTLC tx outputs belong to closed channels
+        const closedContractOutputs = getClosed.channels.map(channel => {
+          return contractOutputs({
             close_transaction_id: channel.close_transaction_id,
-            is_cooperative_close: channel.is_cooperative_close,
-            network: getNetwork.network,
-            transactions: getTx.transactions.filter(n => !!n.transaction),
+            payments: channel.close_payments,
           });
+        });
 
-          const {alias} = await getNodeAlias({
-            lnd,
-            id: channel.partner_public_key,
+        // Pending close tx outputs and HTLC outputs belong to closing channels
+        const pendingContractOutputs = getPending.pending_channels.map(n => {
+          return contractOutputs({
+            close_transaction_id: n.close_transaction_id,
+            payments: n.pending_payments || [],
           });
+        });
+
+        const allContractOutputs = flatten([]
+          .concat(closedContractOutputs)
+          .concat(pendingContractOutputs));
 
+        const closes = getChannels.map((channel, i) => {
+          const {alias} = getAliases[i];
           const currentHeight = getHeight.current_block_height;
-          const isRemoteForceClose = channel.is_remote_force_close;
           const init = `${channel.transaction_id}:${channel.transaction_vout}`;
+          const isRemoteForceClose = channel.is_remote_force_close;
+
+          // Outputs of this channel are not shared with other channels
+          const ownContractOutputs = contractOutputs({
+            close_transaction_id: channel.close_transaction_id,
+            payments: channel.close_payments,
+          });
+
+          const otherContractOutputs = allContractOutputs.filter(output => {
+            return !ownContractOutputs.find(own => {
+              return own.id === output.id && own.vout === output.vout;
+            });
+          });
+
+          const closeTx = transactions
+            .filter(n => !!n.transaction)
+            .find(n => n.id === channel.close_transaction_id);
+
+          // Our anchor output is found in the close tx when it is not reported
+          const anchor = anchorOutput({
+            anchor_vout: channel.anchor_vout,
+            close_balance_spent_by: channel.close_balance_spent_by,
+            close_balance_vout: channel.close_balance_vout,
+            close_payments: channel.close_payments,
+            close_transaction_id: channel.close_transaction_id,
+            is_cooperative_close: channel.is_cooperative_close,
+            transaction: !!closeTx ? closeTx.transaction : undefined,
+          });
 
           const closingFeePaid = closingFees({
+            transactions,
+            anchor_is_confirmed: channel.anchor_is_confirmed,
+            anchor_is_pending: channel.anchor_is_pending,
+            anchor_spent_by: channel.anchor_spent_by,
+            anchor_vout: anchor.vout,
             capacity: channel.capacity,
             close_balance_spent_by: channel.close_balance_spent_by,
+            close_payments: channel.close_payments,
             close_transaction_id: channel.close_transaction_id,
+            is_cooperative_close: channel.is_cooperative_close,
+            is_partner_closed: channel.is_partner_closed,
             is_partner_initiated: channel.is_partner_initiated,
-            transactions: getTx.transactions,
+            other_contract_outputs: otherContractOutputs,
+          });
+
+          const isFeeUnknown = closingFeePaid.fees === undefined;
+
+          const {resolutions} = closeResolutions({
+            transactions,
+            anchor_is_confirmed: channel.anchor_is_confirmed,
+            anchor_is_pending: channel.anchor_is_pending,
+            anchor_spent_by: channel.anchor_spent_by,
+            anchor_vout: anchor.vout,
+            close_balance_spent_by: channel.close_balance_spent_by,
+            close_balance_vout: channel.close_balance_vout,
+            close_payments: channel.close_payments,
+            close_transaction_id: channel.close_transaction_id,
           });
 
           return {
@@ -118,6 +218,7 @@ module.exports = ({limit, lnd, request}, cbk) => {
             is_local_force_close: channel.is_local_force_close || undefined,
             is_cooperative_close: channel.is_cooperative_close || undefined,
             is_remote_force_close: isRemoteForceClose || undefined,
+            peer_opened_channel: channel.is_partner_initiated || undefined,
             peer_closed_channel: channel.is_partner_closed || undefined,
             blocks_since_close: currentHeight - channel.close_confirm_height,
             capacity: channel.capacity,
@@ -125,16 +226,14 @@ module.exports = ({limit, lnd, request}, cbk) => {
             channel_open: init,
             channel_close: channel.close_transaction_id,
             channel_balance_spend: channel.close_balance_spent_by || undefined,
-            channel_resolutions: resolutions || undefined,
+            channel_resolutions: !resolutions.length ? undefined : resolutions,
             is_breach_close: channel.is_breach_close || undefined,
             closing_fee_paid: closingFeePaid.fees || undefined,
+            is_closing_fee_unknown: isFeeUnknown || undefined,
           };
         });
-      }],
 
-      // Channel closes
-      closes: ['getSpends', ({getSpends}, cbk) => {
-        return cbk(null, {closes: getSpends.slice().reverse()});
+        return cbk(null, {closes: closes.reverse()});
       }],
     },
     returnResult({reject, resolve, of :'closes'}, cbk));

package/chain/get_close_from_spend.js

@@ -0,0 +1,125 @@
+const asyncAuto = require('async/auto');
+const {componentsOfTransaction} = require('@alexbosworth/blockchain');
+const {idForTransaction} = require('@alexbosworth/blockchain');
+const {returnResult} = require('asyncjs-util');
+
+const getSpendingTransaction = require('./get_spending_transaction');
+
+const {isArray} = Array;
+
+/** Get a close transaction by looking up the spend of its funding output
+
+  When the spend is not found or is not the close tx, nothing is returned
+
+  {
+    close_confirm_height: <Close Confirmed At Height Number>
+    close_transaction_id: <Close Transaction Id Hex String>
+    lnd: <Authenticated LND API Object>
+    transaction_id: <Funding Transaction Id Hex String>
+    transaction_vout: <Funding Transaction Output Index Number>
+    transactions: [{
+      id: <Transaction Id Hex String>
+      [transaction]: <Raw Transaction Hex String>
+    }]
+  }
+
+  @returns via cbk or Promise
+  {
+    [id]: <Close Transaction Id Hex String>
+    [transaction]: <Raw Close Transaction Hex String>
+  }
+*/
+module.exports = (args, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!args.close_confirm_height) {
+          return cbk([400, 'ExpectedCloseConfirmHeightToGetCloseFromSpend']);
+        }
+
+        if (!args.close_transaction_id) {
+          return cbk([400, 'ExpectedCloseTransactionIdToGetCloseFromSpend']);
+        }
+
+        if (!args.lnd) {
+          return cbk([400, 'ExpectedLndToGetCloseFromSpend']);
+        }
+
+        if (!args.transaction_id) {
+          return cbk([400, 'ExpectedFundingTransactionIdToGetCloseFromSpend']);
+        }
+
+        if (args.transaction_vout === undefined) {
+          return cbk([400, 'ExpectedFundingOutputIndexToGetCloseFromSpend']);
+        }
+
+        if (!isArray(args.transactions)) {
+          return cbk([400, 'ExpectedTransactionsToGetCloseFromSpend']);
+        }
+
+        return cbk();
+      },
+
+      // Find the funding output to look for the spend of
+      fundingOutput: ['validate', ({}, cbk) => {
+        const [fundingTx] = args.transactions
+          .filter(n => !!n.transaction)
+          .filter(n => n.id === args.transaction_id);
+
+        // Exit early when the funding transaction is not known
+        if (!fundingTx) {
+          return cbk();
+        }
+
+        const {outputs} = componentsOfTransaction({
+          transaction: fundingTx.transaction,
+        });
+
+        return cbk(null, outputs[args.transaction_vout]);
+      }],
+
+      // Get the transaction that spent the funding output
+      getSpend: ['fundingOutput', ({fundingOutput}, cbk) => {
+        // Exit early when the funding output script is not known
+        if (!fundingOutput) {
+          return cbk();
+        }
+
+        return getSpendingTransaction({
+          lnd: args.lnd,
+          min_height: args.close_confirm_height,
+          output_script: fundingOutput.script,
+          transaction_id: args.transaction_id,
+          transaction_vout: args.transaction_vout,
+        },
+        (err, res) => {
+          // Exit early when LND can't find the spend, leaving it unknown
+          if (!!err) {
+            return cbk();
+          }
+
+          return cbk(null, res.transaction);
+        });
+      }],
+
+      // The spend is the close transaction when it has the close tx id
+      close: ['getSpend', ({getSpend}, cbk) => {
+        // Exit early when the spend was not found
+        if (!getSpend) {
+          return cbk(null, {});
+        }
+
+        const {id} = idForTransaction({transaction: getSpend});
+
+        // Exit early when the spend is not the expected close tx
+        if (id !== args.close_transaction_id) {
+          return cbk(null, {});
+        }
+
+        return cbk(null, {id, transaction: getSpend});
+      }],
+    },
+    returnResult({reject, resolve, of: 'close'}, cbk));
+  });
+};

package/chain/get_close_transactions.js

@@ -0,0 +1,116 @@
+const asyncAuto = require('async/auto');
+const asyncMapSeries = require('async/mapSeries');
+const {returnResult} = require('asyncjs-util');
+
+const getCloseFromSpend = require('./get_close_from_spend');
+const getClosesInBlocks = require('./get_closes_in_blocks');
+
+const {isArray} = Array;
+
+/** Get close transactions that are missing from the wallet transactions
+
+  A close transaction spends the channel funding output. When the funding
+  transaction is in the wallet, LND can find the close transaction by looking
+  for the spend of the funding output.
+
+  When the spend is not found that way, the close transaction is looked for in
+  the block that it was confirmed in using the LND chain backend.
+
+  {
+    channels: [{
+      [close_confirm_height]: <Close Confirmed At Height Number>
+      close_transaction_id: <Close Transaction Id Hex String>
+      transaction_id: <Funding Transaction Id Hex String>
+      transaction_vout: <Funding Transaction Output Index Number>
+    }]
+    lnd: <Authenticated LND API Object>
+    transactions: [{
+      id: <Transaction Id Hex String>
+      [transaction]: <Raw Transaction Hex String>
+    }]
+  }
+
+  @returns via cbk or Promise
+  {
+    transactions: [{
+      id: <Close Transaction Id Hex String>
+      transaction: <Raw Close Transaction Hex String>
+    }]
+  }
+*/
+module.exports = (args, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!isArray(args.channels)) {
+          return cbk([400, 'ExpectedChannelsToGetCloseTransactions']);
+        }
+
+        if (!args.lnd) {
+          return cbk([400, 'ExpectedLndToGetCloseTransactions']);
+        }
+
+        if (!isArray(args.transactions)) {
+          return cbk([400, 'ExpectedTransactionsToGetCloseTransactions']);
+        }
+
+        return cbk();
+      },
+
+      // Channels with a close tx missing from the wallet and a height to look
+      missing: ['validate', ({}, cbk) => {
+        const knownIds = args.transactions
+          .filter(n => !!n.transaction)
+          .map(n => n.id);
+
+        const channels = args.channels
+          .filter(n => !!n.close_confirm_height)
+          .filter(n => !knownIds.includes(n.close_transaction_id));
+
+        return cbk(null, channels);
+      }],
+
+      // Look for the close transactions as spends of the funding outputs
+      getSpends: ['missing', ({missing}, cbk) => {
+        return asyncMapSeries(missing, (channel, cbk) => {
+          return getCloseFromSpend({
+            close_confirm_height: channel.close_confirm_height,
+            close_transaction_id: channel.close_transaction_id,
+            lnd: args.lnd,
+            transaction_id: channel.transaction_id,
+            transaction_vout: channel.transaction_vout,
+            transactions: args.transactions,
+          },
+          cbk);
+        },
+        cbk);
+      }],
+
+      // Find the remaining close transactions in their confirmation blocks
+      getBlockTxs: ['getSpends', 'missing', ({getSpends, missing}, cbk) => {
+        const found = getSpends.filter(n => !!n.id).map(n => n.id);
+
+        const remaining = missing.filter(channel => {
+          return !found.includes(channel.close_transaction_id);
+        });
+
+        return getClosesInBlocks({channels: remaining, lnd: args.lnd}, cbk);
+      }],
+
+      // Close transactions that were found
+      transactions: [
+        'getBlockTxs',
+        'getSpends',
+        ({getBlockTxs, getSpends}, cbk) =>
+      {
+        const transactions = []
+          .concat(getSpends.filter(n => !!n.transaction))
+          .concat(getBlockTxs.transactions);
+
+        return cbk(null, {transactions});
+      }],
+    },
+    returnResult({reject, resolve, of: 'transactions'}, cbk));
+  });
+};