paid-services 3.4.0 → 3.7.0

package/capacity/get_capacity_replacement.js

@@ -1,10 +1,14 @@
+const {address} = require('bitcoinjs-lib');
 const asyncAuto = require('async/auto');
+const asyncEach = require('async/each');
 const {closeChannel} = require('ln-service');
+const {connectPeer} = require('ln-sync');
 const {decodeChanId} = require('bolt07');
 const {getChainFeeRate} = require('ln-service');
 const {getChainTransactions} = require('ln-service');
 const {getHeight} = require('ln-service');
 const {getPendingChannels} = require('ln-service');
+const {networks} = require('bitcoinjs-lib');
 const {openChannels} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 const {Transaction} = require('bitcoinjs-lib');
@@ -26,6 +30,7 @@ const notFoundIndex = -1;
 const positive = n => Math.max(1, n);
 const slowTarget = 1000;
 const sumOf = arr => arr.reduce((sum, n) => sum + n, 0);
+const {toOutputScript} = address;
 const txIdAsHash = id => Buffer.from(id, 'hex').reverse();
 
 /** Close a channel and get a capacity replacement transaction
@@ -36,7 +41,8 @@ const txIdAsHash = id => Buffer.from(id, 'hex').reverse();
     bitcoinjs_network: <BitcoinJs Network Name String>
     decrease: [{
       address: <Spend to Chain Address String>
-      output: <Spend to Output Script Hex String>
+      [node]: <Node to Open Channel to Public Key Hex String>
+      [output]: <Spend to Output Script Hex String>
       tokens: <Spend Value Number>
     }]
     id: <Original Channel Standard Format Channel Id String>
@@ -51,10 +57,12 @@ const txIdAsHash = id => Buffer.from(id, 'hex').reverse();
   {
     [add_funds_vin]: <Funding Spend Input Index Number>
     capacity: <Replacement Channel Capacity Tokens Number>
+    force_close_tx: <Raw Force Close Transaction Hex String>
+    open_pending_ids: [<Proposed Additional Channel Id String>]
+    pending_channel_id: <Proposed Replacement Channel Pending Id Hex String>
     remote_balance: <Initial Balance for Peer Tokens Number>
     signature: <Signature for Replacement Transaction Hex Encoded String>
     signing_key: <Signing Public Key Hex String>
-    pending_channel_id: <Proposed Channel Pending Id Hex String>
     transaction_id: <Replacement Channel Transaction Id Hex String>
     transaction_vin: <Original Channel Input Index Number>
     transaction_vout: <Replacement Channel Transaction Output Index Number>
@@ -102,8 +110,34 @@ module.exports = (args, cbk) => {
       // Get the current chain height
       getHeight: ['validate', ({}, cbk) => getHeight({lnd: args.lnd}, cbk)],
 
+      // Connect to nodes to open channels to
+      connect: ['validate', ({}, cbk) => {
+        return asyncEach(args.decrease.filter(n => !!n.node), (spend, cbk) => {
+          return connectPeer({id: spend.node, lnd: args.lnd}, cbk);
+        },
+        cbk);
+      }],
+
+      // Propose any additional channels to nodes
+      openChannels: ['connect', ({}, cbk) => {
+        // Exit early when there are no nodes to propose channels to
+        if (!args.decrease.filter(n => !!n.node).length) {
+          return cbk(null, {pending: []});
+        }
+
+        return openChannels({
+          channels: args.decrease.filter(n => !!n.node).map(decrease => ({
+            capacity: decrease.tokens,
+            partner_public_key: decrease.node,
+          })),
+          is_avoiding_broadcast: true,
+          lnd: args.lnd,
+        },
+        cbk);
+      }],
+
       // Force close the channel in order to get a non-final sequence number
-      channelClose: ['getFeeRate', ({}, cbk) => {
+      channelClose: ['getFeeRate','openChannels', ({}, cbk) => {
         return closeChannel({
           lnd: args.lnd,
           is_force_close: true,
@@ -277,19 +311,31 @@ module.exports = (args, cbk) => {
       replacementTx: [
         'closeTx',
         'newCapacity',
+        'openChannels',
         'proposeChannel',
-        ({closeTx, newCapacity, proposeChannel}, cbk) =>
+        ({closeTx, newCapacity, openChannels, proposeChannel}, cbk) =>
       {
         // The replacement tx pays to the proposed channel multisig address
         const [{address}] = proposeChannel.pending;
 
+        const network = networks[args.bitcoinjs_network];
+
+        // Map pending channel opens to match the spends
+        const openAsSpends = openChannels.pending.map(({address, tokens}) => ({
+          tokens,
+          output: bufferAsHex(toOutputScript(address, network)),
+        }));
+
+        // Decreases are spends to regular addresses plus channel outputs
+        const decreases = [].concat(args.decrease).concat(openAsSpends);
+
         try {
           const replacement = assembleReplacementTx({
             add_funds_transaction_id: args.add_funds_transaction_id,
             add_funds_transaction_vout: args.add_funds_transaction_vout,
             bitcoinjs_network: args.bitcoinjs_network,
             close_transaction: closeTx.transaction,
-            decrease: args.decrease.map(decrease => ({
+            decrease: decreases.filter(n => !!n.output).map(decrease => ({
               output: decrease.output,
               tokens: decrease.tokens,
             })),
@@ -334,6 +380,7 @@ module.exports = (args, cbk) => {
       proposedReplacement: [
         'closeTx',
         'newCapacity',
+        'openChannels',
         'pendingChannel',
         'proposeChannel',
         'replacementTx',
@@ -341,6 +388,7 @@ module.exports = (args, cbk) => {
         ({
           closeTx,
           newCapacity,
+          openChannels,
           pendingChannel,
           proposeChannel,
           replacementTx,
@@ -353,11 +401,12 @@ module.exports = (args, cbk) => {
         return cbk(null, {
           add_funds_vin: replacementTx.add_funds_vin,
           capacity: newCapacity,
-          force_close_tx_id: closeTx.id,
+          force_close_tx: closeTx.transaction,
+          open_pending_ids: openChannels.pending.map(n => n.id),
+          pending_channel_id: pending.id,
           remote_balance: pendingChannel.remote_balance,
           signature: signReplacement.signature,
           signing_key: signReplacement.key,
-          pending_channel_id: pending.id,
           transaction_id: replacementTx.transaction_id,
           transaction_vin: replacementTx.transaction_vin,
           transaction_vout: replacementTx.transaction_vout,

package/capacity/initiate_capacity_change.js

@@ -47,7 +47,6 @@ const rebroadcastTimeMs = 1000 * 5;
 const recordsAsObject = a => a.reduce((sum, n) => sum[n.type] = n.value, {});
 const requestCapacityChangeIntervalMs = 2000;
 const requestCapacityChangeTimeoutMs = 1000 * 60 * 60 * 6;
-const sumOf = arr => arr.reduce((sum, n) => sum + n, Number());
 const testMessage = '00';
 const tokensAsBigUnit = tokens => (tokens / 1e8).toFixed(8);
 const uniq = arr => Array.from(new Set(arr));
@@ -438,7 +437,7 @@ module.exports = ({ask, lnd, logger}, cbk) => {
           increase_transaction_id: getFunding.id,
           increase_transaction_vout: getFunding.vout,
           increase_witness_script: getFunding.script,
-          is_private: channel.is_private,
+          is_private: askForChangeDetails.is_private,
           open_transaction: sendBasicRequest,
           partner_public_key: askForChangeDetails.partner_public_key,
           transaction_id: channel.transaction_id,

package/capacity/parse_capacity_change_request.js

@@ -4,6 +4,7 @@ const {decodeBigSize} = require('bolt01');
 const channelIdHexLength = 16;
 const decodeNumber = encoded => BigInt(decodeBigSize({encoded}).decoded);
 const defaultRecord = {value: '00'};
+const hexAsNumber = n => Buffer.from(n, 'hex').readUInt8();
 const idHexLength = 64;
 const tooLarge = BigInt(Number.MAX_SAFE_INTEGER);
 
@@ -11,6 +12,7 @@ const findChannelRecord = records => records.find(n => n.type === '2');
 const findDecreaseRecord = records => records.find(n => n.type === '3');
 const findIncreaseRecord = records => records.find(n => n.type === '4');
 const findRequestIdRecord = records => records.find(n => n.type === '1');
+const findTypeRecord = records => records.find(n => n.type === '5');
 const findVersionRecord = records => records.find(n => n.type === '0');
 
 /** Parse a capacity change request
@@ -31,6 +33,7 @@ const findVersionRecord = records => records.find(n => n.type === '0');
       from: <From Node Public Key Id Hex String>
       id: <Change Request Id Hex String>
       [increase]: <Add Capacity Tokens Number>
+      [type]: <Intended Replacement Channel Channel Type Flags Number>
     }
   }
 */
@@ -52,6 +55,7 @@ module.exports = ({from, records}) => {
     return {};
   }
 
+  // Make sure the channel id is a regular one
   try {
     chanFormat({id: channelRecord.value});
   } catch (err) {
@@ -67,6 +71,7 @@ module.exports = ({from, records}) => {
 
   const decreaseRecord = findDecreaseRecord(records);
   const increaseRecord = findIncreaseRecord(records);
+  const typeRecord = findTypeRecord(records);
 
   // Exit early when there is a change in both directions
   if (!!decreaseRecord && !!increaseRecord) {
@@ -75,10 +80,11 @@ module.exports = ({from, records}) => {
 
   const {channel} = chanFormat({id: channelRecord.value});
   const id = idRecord.value;
+  const type = typeRecord ? hexAsNumber(typeRecord.value) : undefined;
 
   // Exit early when there is no decrease or increase
   if (!decreaseRecord && !increaseRecord) {
-    return {request: {channel, from, id}};
+    return {request: {channel, from, id, type}};
   }
 
   const decrease = decodeNumber((decreaseRecord || defaultRecord).value);
@@ -94,6 +100,7 @@ module.exports = ({from, records}) => {
       channel,
       from,
       id,
+      type,
       decrease: Number(decrease) || undefined,
       increase: Number(increase) || undefined,
     },

package/capacity/propose_capacity_change.js

@@ -1,15 +1,17 @@
 const asyncAuto = require('async/auto');
-const asyncDoUntil = require('async/doUntil');
+const asyncEach = require('async/each');
 const asyncReflect = require('async/reflect');
 const {broadcastChainTransaction} = require('ln-service');
 const {cancelPendingChannel} = require('ln-service');
+const {deletePendingChannel} = require('ln-service');
 const {fundPendingChannels} = require('ln-service');
-const {getChainTransactions} = require('ln-service');
 const {getChannels} = require('ln-service');
 const {getClosedChannels} = require('ln-service');
 const {getHeight} = require('ln-service');
+const {getPendingChannels} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 const {signTransaction} = require('ln-service');
+const {subscribeToBlocks} = require('ln-service');
 const {Transaction} = require('bitcoinjs-lib');
 const {transactionAsPsbt} = require('psbt');
 
@@ -21,6 +23,7 @@ const {serviceTypeSignCapacityChange} = require('./../service_types');
 
 const capacityChangeIdType = '0';
 const findSignatureRecord = records => records.find(n => n.type === '1');
+const {fromHex} = Transaction;
 const fuzzHeight = 3;
 const maxSigHexLength = 146;
 const peerRequestTimeoutMs = 1000 * 60 * 10;
@@ -35,9 +38,10 @@ const unsignedTransactionType = '1';
     bitcoinjs_network: <BitcoinJS Network Name String>
     channel: <Channel to Change Standard Format Channel Id String>
     decrease: [{
-      address: <Spend to Chain Address String>
-      output: <Spend to Output Script Hex String>
-      tokens: <Spend Value Number>
+      [address]: <Decrease Address String>
+      [node]: <Create Channel with Node With Public Key Hex String>
+      [output]: <Output Script Hex String>
+      tokens: <Decrease Tokens Number>
     }]
     id: <Capacity Change Request Id Hex String>
     is_private: <Channel is Private Bool>
@@ -109,10 +113,7 @@ module.exports = (args, cbk) => {
         return cbk();
       },
 
-      // Get the starting height
-      getHeight: ['validate', ({}, cbk) => getHeight({lnd: args.lnd}, cbk)],
-
-      // Close the current channal and get the unsigned replacement
+      // Close the current channel and get the unsigned replacement
       getReplacement: ['validate', ({}, cbk) => {
         return getCapacityReplacement({
           add_funds_transaction_id: args.increase_transaction_id,
@@ -122,6 +123,7 @@ module.exports = (args, cbk) => {
           id: args.channel,
           is_private: args.is_private,
           increase: args.increase,
+          is_private: args.is_private,
           lnd: args.lnd,
           open_transaction: args.open_transaction,
           transaction_id: args.transaction_id,
@@ -130,9 +132,9 @@ module.exports = (args, cbk) => {
         cbk);
       }],
 
-      // Replacement channel outpoint
+      // The replacement channel outpoint will be returned as a result
       replacement: ['getReplacement', ({getReplacement}, cbk) => {
-        args.logger.info({pending_chan_id: getReplacement.pending_channel_id});
+        args.logger.info({proposal_id: getReplacement.pending_channel_id});
 
         return cbk(null, {
           transaction_id: getReplacement.transaction_id,
@@ -163,8 +165,8 @@ module.exports = (args, cbk) => {
         cbk);
       }],
 
-      // Use the unsigned replacement transaction to "fund" the pending channel
-      fundWithReplacement: [
+      // Derive the funding PSBT to use for funding
+      funding: [
         'getReplacement',
         'signAddFunds',
         ({getReplacement, signAddFunds}, cbk) =>
@@ -182,10 +184,22 @@ module.exports = (args, cbk) => {
           witness_script: getReplacement.witness_script,
         });
 
-        // Create the commitment transaction with the peer on the replacement
+        return cbk(null, psbt);
+      }],
+
+      // Use the unsigned replacement transaction to "fund" the pending channel
+      fundWithReplacement: [
+        'funding',
+        'getReplacement',
+        ({funding, getReplacement}, cbk) =>
+      {
+        const replacement = getReplacement.unsigned_transaction;
+
+        args.logger.info({funding_with_replacement_tx: replacement});
+
         return fundPendingChannels({
+          funding,
           channels: [getReplacement.pending_channel_id],
-          funding: psbt,
           lnd: args.lnd,
         },
         cbk);
@@ -193,8 +207,8 @@ module.exports = (args, cbk) => {
 
       // Send the final go ahead signal now that a proposal is made
       getPeerSignature: [
-        'getReplacement',
         'fundWithReplacement',
+        'getReplacement',
         asyncReflect(({getReplacement}, cbk) =>
       {
         return makePeerRequest({
@@ -228,49 +242,86 @@ module.exports = (args, cbk) => {
             return cbk([503, 'ExpectedSignatureRecordFromPeerForChange']);
           }
 
+          args.logger.info({peer_cosigned_capacity_change: true});
+
           return cbk(null, record.value);
         });
       })],
 
-      // Cancel the funding proposal when there is an error
+      // Fund the additional other channel opens if present
+      fundAdditionalOpens: [
+        'funding',
+        'getPeerSignature',
+        'getReplacement',
+        asyncReflect(({funding, getPeerSignature, getReplacement}, cbk) =>
+      {
+        // Exit early when there was an error getting the peer signature
+        if (!!getPeerSignature.error) {
+          return cbk();
+        }
+
+        // Exit early when there is nothing else to fund
+        if (!getReplacement.open_pending_ids.length) {
+          return cbk();
+        }
+
+        // Funding for the additional opens is separated for smoother canceling
+        return fundPendingChannels({
+          funding,
+          channels: getReplacement.open_pending_ids,
+          lnd: args.lnd,
+        },
+        cbk);
+      })],
+
+      // Cancel the unfunded channel opens when there is an error
       cancelFunding: [
         'getPeerSignature',
         'getReplacement',
         ({getPeerSignature, getReplacement}, cbk) =>
       {
-        // Exit early when there is no need to cancel
+        // Exit early when there was an error getting the peer signature
         if (!getPeerSignature.error) {
           return cbk();
         }
 
-        return cancelPendingChannel({
-          id: getReplacement.pending_channel_id,
-          lnd: args.lnd,
-        },
-        err => {
-          if (!!err) {
-            return cbk([503, 'FailedToCancelPendingChannel', {err}]);
-          }
+        const ids = getReplacement.open_pending_ids;
 
-          // Return the original error
-          return cbk(getPeerSignature.error);
-        });
+        return asyncEach(ids, asyncReflect((id, cbk) => {
+          return cancelPendingChannel({id, lnd: args.lnd}, cbk);
+        }),
+        cbk);
       }],
 
       // Broadcast the new funding transaction using the peer's signature
       confirmFunding: [
-        'getHeight',
+        'fundAdditionalOpens',
         'getPeerSignature',
         'getReplacement',
         'signAddFunds',
-        ({getHeight, getPeerSignature, getReplacement, signAddFunds}, cbk) =>
+        ({
+          fundAdditionalOpens,
+          getPeerSignature,
+          getReplacement,
+          signAddFunds,
+        },
+        cbk) =>
       {
-        // Exit early when there was an error getting the peer signature
+        // When there is no peer signature, the force close must confirm
         if (!!getPeerSignature.error) {
-          return cbk();
+          return cbk(null, {is_success: false});
+        }
+
+        // Do not broadcast a replacement when additional opens fail
+        if (!!fundAdditionalOpens.error) {
+          return cbk(null, {is_success: false});
         }
 
         const [addFundsSignature] = signAddFunds.signatures || [];
+        const openOutputs = fromHex(args.open_transaction).outs;
+        const txId = fromHex(getReplacement.unsigned_transaction).getId();
+
+        const outScript = openOutputs[args.transaction_vout].script;
 
         // Insert the peer signature to get the final signed funding tx
         const {transaction} = finalizeCapacityReplacement({
@@ -287,75 +338,140 @@ module.exports = (args, cbk) => {
 
         args.logger.info({publishing_new_channel_transaction: transaction});
 
-        return asyncDoUntil(
-          cbk => {
-            // Try and override the force close tx using the replacement
-            return broadcastChainTransaction({
-              transaction,
-              after: getHeight.current_block_height - fuzzHeight,
-              lnd: args.lnd,
-            },
-            cbk);
-          },
-          (broadcast, cbk) => {
-            args.logger.info({waiting_for_confirmation: broadcast.id});
+        // Listen to new blocks to wait for the channel change confirmation
+        const sub = subscribeToBlocks({lnd: args.lnd});
 
-            // Rebroadcast until the transaction is confirmed
-            return getChainTransactions({lnd: args.lnd}, (err, res) => {
-              if (!!err) {
-                return cbk(err);
-              }
+        // Fail with error when the blocks subscription is lost
+        sub.on('error', err => {
+          sub.removeAllListeners();
+
+          return cbk([503, 'LostBlockchainSubscription', {err}]);
+        });
+
+        // Publish the new channel transaction when a block is received
+        sub.on('block', async () => {
+          // Broadcast the channel replacement tx
+          try {
+            await broadcastChainTransaction({transaction, lnd: args.lnd});
+
+            args.logger.info({published_new_channel_tx: txId});
+          } catch (err) {
+            args.logger.error({err});
+          }
+
+          // Look for the new channel to see if the change succeeded
+          try {
+            const {channels} = await getChannels({lnd: args.lnd});
 
-              const confirmed = res.transactions.filter(n => !!n.is_confirmed);
+            const channel = channels.find(n => n.transaction_id === txId);
 
-              // Find the confirmed tx
-              const tx = confirmed.find(tx => tx.id === broadcast.id);
+            // Replacement is present but not yet active
+            if (!!channel && !channel.is_active) {
+              args.logger.info({waiting_for_channel_to_activate: true});
+            }
 
-              if (!!tx) {
-                return cbk(null, true);
+            // The new channel confirmed successfully and so the change worked
+            if (!!channel && !!channel.is_active) {
+              sub.removeAllListeners();
+
+              return cbk(null, {is_success: true});
+            }
+          } catch (err) {
+            args.logger.error({err});
+          }
+
+          // Also look for a force closed channel to see if the change failed
+          try {
+            const {channels} = await getClosedChannels({lnd: args.lnd});
+            const chainTip = await getHeight({lnd: args.lnd});
+
+            const currentHeight = chainTip.current_block_height;
+
+            const channel = channels.find(channel => {
+              // The closed channel must have a closed tx id
+              if (!channel.close_transaction_id) {
+                return false;
               }
 
-              // Find the replacing tx
-              const replacing = confirmed.find(tx => {
-                return tx.id === getReplacement.force_close_tx_id;
-              });
-
-              // Cancel the pending channel if the force close confirms
-              if (!!replacing) {
-                return cancelPendingChannel({
-                  id: getReplacement.pending_channel_id,
-                  lnd: args.lnd,
-                },
-                () => {
-                  return cbk([503, 'FailedToReplaceForceCloseTransaction']);
-                });
+              // Only consider channels that are conclusively closed
+              if (currentHeight - channel.close_confirm_height < fuzzHeight) {
+                return false;
               }
 
-              return getChannels({
-                lnd: args.lnd,
-                partner_public_key: args.partner_public_key,
-              },
-              (err, res) => {
-                if (!!err) {
-                  return cbk(err);
-                }
-
-                const channel = res.channels.find(channel => {
-                  return channel.transaction_id === broadcast.id
-                });
-
-                // Stop broadcasting when a channel shows up
-                if (!!channel) {
-                  return cbk(null, true);
-                }
-
-                // Rebroadcast after a delay
-                return setTimeout(() => cbk(null, false), rebroadcastDelayMs);
-              });
+              // Find close channel matching the channel outpoint
+              if (channel.transaction_id !== args.transaction_id) {
+                return false;
+              }
+
+              return channel.transaction_vout === args.transaction_vout;
             });
+
+            // The old channel force closed and so the change fully failed
+            if (!!channel && channel.close_transaction_id !== txId) {
+              sub.removeAllListeners();
+
+              return cbk(null, {is_success: false});
+            }
+          } catch (err) {
+            args.logger.error({err});
+          }
+
+          return;
+        });
+
+        return;
+      }],
+
+      // Get pending channels to clean up if there was a failure
+      getPending: ['confirmFunding', ({confirmFunding}, cbk) => {
+        // Exit early when there was no failure
+        if (!!confirmFunding.is_success) {
+          return cbk();
+        }
+
+        return getPendingChannels({lnd: args.lnd}, cbk);
+      }],
+
+      // Clean up pending channels that will never confirm
+      cleanPendingChannels: [
+        'confirmFunding',
+        'getPending',
+        'getReplacement',
+        ({confirmFunding, getPending, getReplacement}, cbk) =>
+      {
+        // Exit early when the channel activated
+        if (!!confirmFunding.is_success) {
+          args.logger.info({channel_capacity_changed: true});
+
+          return cbk();
+        }
+
+        const replaceId = fromHex(getReplacement.unsigned_transaction).getId();
+
+        // Collect all the pending channels that depend on the replacement
+        const pending = getPending.pending_channels
+          .filter(n => !!n.is_opening)
+          .filter(n => n.transaction_id === replaceId);
+
+        // Delete the pending channels that can never confirm
+        return asyncEach(pending, (channel, cbk) => {
+          return deletePendingChannel({
+            confirmed_transaction: getReplacement.force_close_tx,
+            lnd: args.lnd,
+            pending_transaction: getReplacement.unsigned_transaction,
+            pending_transaction_vout: channel.transaction_vout,
           },
-          cbk
-        );
+          err => {
+            if (!!err) {
+              args.logger.error({err});
+            }
+
+            return cbk();
+          });
+        },
+        () => {
+          return cbk([503, 'FailedToChangeChannelCapacity']);
+        });
       }],
     },
     returnResult({reject, resolve, of: 'replacement'}, cbk));