paid-services 3.6.0 → 3.7.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Versions
 
+## Version 3.7.0
+
+- `changeChannelCapacity`: Add support for decreasing funds into a new channel
+
 ## Version 3.6.0
 
 - `manageTrades`: Add support for persistent open trades

package/capacity/accept_capacity_change.js

@@ -212,6 +212,8 @@ module.exports = ({channel, from, id, increase, lnd, logger}, cbk) => {
             return failure([503, 'FailedToParseSignChangeRequest']);
           }
 
+          logger.info({closing_and_reopening_channel: true});
+
           // Trigger the replacement flow and sign the unsigned tx
           return getReplacementSignature({
             channel,

package/capacity/ask_for_change_details.js

@@ -48,8 +48,9 @@ const weightBuffer = 150;
     cltv_delta: <Locktime Delta Number>
     coop_close_address: <Cooperative Close Address String>
     decrease: [{
-      address: <Decrease Address String>
-      output: <Output Script Hex String>
+      [address]: <Decrease Address String>
+      [node]: <Create Channel with Node With Public Key Hex String>
+      [output]: <Output Script Hex String>
       tokens: <Decrease Tokens Number>
     }]
     estimated_capacity: <Estimated Tokens For New Channel Capacity Number>
@@ -172,6 +173,7 @@ module.exports = ({ask, id, lnd}, cbk) => {
           const disabled = [
             !!channel.cooperative_close_address,
             !channel.is_active,
+            !!channel.pending_payments.length,
           ];
 
           return {
@@ -344,7 +346,7 @@ module.exports = ({ask, id, lnd}, cbk) => {
                 return cbk(err);
               }
 
-              if (decreases.find(n => n.address === res.address)) {
+              if (!!res.address && decreases.find(n => n.address === res.address)) {
                 return cbk([400, 'ExpectedUniqueAddressForSpend']);
               }
 
@@ -356,11 +358,8 @@ module.exports = ({ask, id, lnd}, cbk) => {
               return cbk(err);
             }
 
-            const final = decreases
-              .filter(n => !!n.tokens)
-              .map(({address, output, tokens}) => ({address, output, tokens}));
-
-            return cbk(null, final);
+            // Only include decreases that spend funds
+            return cbk(null, decreases.filter(n => !!n.tokens));
           }
         );
       }],
@@ -413,10 +412,10 @@ module.exports = ({ask, id, lnd}, cbk) => {
               return type;
             }
 
-            return `${type} (Keep Current Status)`;
+            return `${type} (keep current status)`;
           }),
           default: channel.is_private ? 'Private' : 'Public',
-          message: 'Channel type?',
+          message: 'Replacement channel type?',
           name: 'type',
           type: 'list',
         },

package/capacity/ask_for_decrease.js

@@ -1,14 +1,28 @@
 const {address} = require('bitcoinjs-lib');
 const asyncAuto = require('async/auto');
 const {createChainAddress} = require('ln-service');
+const {getIdentity} = require('ln-service');
+const {acceptsChannelOpen} = require('ln-sync');
 const {getNetwork} = require('ln-sync');
 const {networks} = require('bitcoinjs-lib');
 const {returnResult} = require('asyncjs-util');
 
+const proposeChannelOpen = require('./propose_channel_open');
+
+const askForChanSize = max => `Capacity of the new channel? (max: ${max})`;
+const askForSendSize = max => `Amount you want to send out? (max: ${max})`;
 const bufferAsHex = buffer => buffer.toString('hex');
 const dust = 550;
+const {isInteger} = Number;
 const isNumber = n => !isNaN(n);
+const isPublicKey = n => !!n && /^0[2-3][0-9A-F]{64}$/i.test(n);
+const minChannelCapacity = 20000;
+const minSpendTokens = 0;
+const openChannelAction = 'open_channel';
+const spendToExternalAddressAction = 'external_spend_funds';
+const spendToInternalAddressAction = 'internal_spend_funds';
 const {toOutputScript} = address;
+const tokensAsBigUnit = tokens => (tokens / 1e8).toFixed(8);
 
 /** Ask for details about a decrease
 
@@ -22,6 +36,7 @@ const {toOutputScript} = address;
   {
     [address]: <Send Funds to Address String>
     is_final: <Decrease is Final Decrease Bool>
+    [node]: <Create Channel with Node With Public Key Hex String>
     [output]: <Output Script Hex String>
     tokens: <Withdraw Tokens Number>
   }
@@ -46,66 +61,149 @@ module.exports = ({ask, lnd, max}, cbk) => {
         return cbk();
       },
 
-      // Ask for the amount to decrease
-      askForAmount: ['validate', ({}, cbk) => {
+      // Select the type of decrease
+      askForDecreaseType: ['validate', ({}, cbk) => {
         return ask({
-          default: '0',
-          name: 'amount',
-          message: `How much do you want to spend out (max: ${max})?`,
+          choices: [
+            {
+              name: `Send decreased funds to the internal chain wallet`,
+              value: spendToInternalAddressAction,
+            },
+            {
+              name: `Send decreased funds to an external chain address`,
+              value: spendToExternalAddressAction,
+            },
+            {
+              disabled: max < minChannelCapacity,
+              name: `Spend decreased funds into new channel with another peer`,
+              value: openChannelAction,
+            },
+          ],
+          message: 'How do you want to change the channel capacity?',
+          name: 'decrease',
+          type: 'list',
+        },
+        ({decrease}) => cbk(null, decrease));
+      }],
+
+      // Get the node identity key to make sure a channel open isn't with self
+      getIdentity: ['validate', ({}, cbk) => getIdentity({lnd}, cbk)],
+
+      // Get network name to validate addresses against
+      getNetwork: ['validate', ({}, cbk) => getNetwork({lnd}, cbk)],
+
+      // Ask for the public key of the node to trade with
+      askForNodeId: [
+        'askForDecreaseType',
+        'getIdentity',
+        ({askForDecreaseType, getIdentity}, cbk) =>
+      {
+        // Exit early when not opening a new channel
+        if (askForDecreaseType !== openChannelAction) {
+          return cbk();
+        }
+
+        return ask({
+          name: 'key',
+          message: 'Public key of node to open channel with?',
           type: 'input',
           validate: input => {
-            if (!isNumber(input) || !Number.isInteger(Number(input))) {
+            if (!input) {
               return false;
             }
 
-            if (!!Number(input) && Number(input) < dust) {
-              return false;
+            if (!isPublicKey(input)) {
+              return 'Expected public key of node to open channel with';
             }
 
-            if (!!Number(input) && Number(input) > max) {
-              return `The maximum possible to decrease is ${max}`;
+            if (input === getIdentity.public_key) {
+              return 'Expected public key of other node';
             }
 
             return true;
           },
         },
-        ({amount}) => cbk(null, amount));
+        ({key}) => cbk(null, key));
       }],
 
-      // Get network name
-      getNetwork: ['validate', ({}, cbk) => getNetwork({lnd}, cbk)],
-
-      // Ask if withdrawing to an external address
-      askForExternal: ['askForAmount', ({askForAmount}, cbk) => {
-        if (!Number(askForAmount)) {
+      // Create a decrease address to withdraw funds out to
+      createAddress: ['askForDecreaseType', ({askForDecreaseType}, cbk) => {
+        // Exit early when there is no need to create an internal address
+        if (askForDecreaseType !== spendToInternalAddressAction) {
           return cbk();
         }
 
+        return createChainAddress({lnd}, cbk);
+      }],
+
+      // Ask for the amount to decrease
+      askForAmount: ['askForNodeId', ({askForNodeId}, cbk) => {
         return ask({
-          default: false,
-          name: 'spend',
-          message: `Spend ${askForAmount} to an external address?`,
-          type: 'confirm',
+          default: !askForNodeId ? minSpendTokens : minChannelCapacity,
+          message: !askForNodeId ? askForSendSize(max) : askForChanSize(max),
+          name: 'amount',
+          validate: input => {
+            // A numeric input is required
+            if (!isNumber(input) || !isInteger(Number(input))) {
+              return false;
+            }
+
+            // Zero value is acceptable for a decrease when not opening channel
+            if (!askForNodeId && !Number(input)) {
+              return true;
+            }
+
+            // On-chain values must always be above dust
+            if (!!Number(input) && Number(input) < dust) {
+              return false;
+            }
+
+            // Channel opens must always be above the minimum channel size
+            if (!!askForNodeId && Number(input) < minChannelCapacity) {
+              return `The minimum channel capacity is ${minChannelCapacity}`;
+            }
+
+            // A decrease cannot spend more funds than are available
+            if (!!Number(input) && Number(input) > max) {
+              return `The maximum possible to decrease is ${max}`;
+            }
+
+            return true;
+          },
         },
-        ({spend}) => cbk(null, spend));
+        ({amount}) => cbk(null, Number(amount)));
       }],
 
       // Ask for an external address
       askForAddress: [
         'askForAmount',
-        'askForExternal',
-        ({askForAmount, askForExternal}, cbk) =>
+        'askForDecreaseType',
+        'getNetwork',
+        ({askForAmount, askForDecreaseType, getNetwork}, cbk) =>
       {
-        // Exit early when the withdraw address is internal
-        if (askForExternal !== true) {
+        // Exit early when the withdraw address is not external
+        if (askForDecreaseType !== spendToExternalAddressAction) {
           return cbk();
         }
 
         return ask({
           name: 'address',
-          message: `Address to spend ${askForAmount} to?`,
+          message: `Address to spend ${tokensAsBigUnit(askForAmount)} to?`,
           type: 'input',
-          validate: input => !!input,
+          validate: input => {
+            if (!input) {
+              return false;
+            }
+
+            // Make sure that the entered address can be derived to an output
+            try {
+              toOutputScript(input, networks[getNetwork.bitcoinjs]);
+            } catch (err) {
+              return 'Failed to parse address. Try a standard one?';
+            }
+
+            return true;
+          },
         },
         ({address}) => cbk(null, {address}));
       }],
@@ -113,31 +211,46 @@ module.exports = ({ask, lnd, max}, cbk) => {
       // Ask if this is the last output
       askForAddition: [
         'askForAddress',
-        'askForExternal',
-        ({askForExternal}, cbk) =>
+        'askForAmount',
+        'askForDecreaseType',
+        ({askForAmount, askForDecreaseType}, cbk) =>
       {
-        // Exit early when the spend was to an internal addess
-        if (!askForExternal) {
+        // Exit early and only ask for addition when decrease is a "spend" type
+        if (askForDecreaseType === spendToInternalAddressAction) {
+          return cbk();
+        }
+
+        // Exit early when there are no more funds to spend
+        if (max - askForAmount < dust) {
           return cbk();
         }
 
         return ask({
           default: false,
           name: 'add',
-          message: 'Add another spend to a different address?',
+          message: 'Spend additional funds from the channel capacity?',
           type: 'confirm',
         },
         ({add}) => cbk(null, add));
       }],
 
-      // Create a decrease address to withdraw funds out to
-      createAddress: ['askForExternal', ({askForExternal}, cbk) => {
-        // Exit early when the withdraw address is external
-        if (askForExternal !== false) {
+      // Propose a channel open to confirm the peer will accept the channel
+      checkChannelAcceptance: [
+        'askForAmount',
+        'askForNodeId',
+        ({askForAmount, askForNodeId}, cbk) =>
+      {
+        // Exit early if pubkey was not entered
+        if (!askForNodeId) {
           return cbk();
         }
 
-        return createChainAddress({lnd}, cbk);
+        return proposeChannelOpen({
+          lnd,
+          capacity: askForAmount,
+          id: askForNodeId,
+        },
+        cbk);
       }],
 
       // Final decrease output details
@@ -145,38 +258,43 @@ module.exports = ({ask, lnd, max}, cbk) => {
         'askForAddition',
         'askForAddress',
         'askForAmount',
+        'checkChannelAcceptance',
         'createAddress',
         'getNetwork',
         ({
           askForAddition,
           askForAddress,
           askForAmount,
+          askForNodeId,
+          checkChannelAcceptance,
           createAddress,
           getNetwork,
         },
         cbk) =>
       {
-        const {address} = (createAddress || askForAddress || {});
-
-        // Exit early when not decreasing to an address
-        if (!address) {
-          return cbk(null, {is_final: true, tokens: Number(askForAmount)});
+        // Make sure that a channel proposal didn't fail
+        if (!!checkChannelAcceptance && !checkChannelAcceptance.is_accepted) {
+          return cbk([503, 'RemoteNodeRejectedNewChannelProposal']);
         }
 
-        // Make sure the address is valid
-        try {
-          toOutputScript(address, networks[getNetwork.bitcoinjs]);
-        } catch (err) {
-          return cbk([400, 'FailedToParseAddress', {err}]);
+        // Exit early when decreasing to a new channel
+        if (!!askForNodeId) {
+          return cbk(null, {
+            is_final: !askForAddition,
+            node: askForNodeId,
+            tokens: askForAmount,
+          });
         }
 
+        const {address} = (createAddress || askForAddress);
+
         const output = toOutputScript(address, networks[getNetwork.bitcoinjs]);
 
         return cbk(null, {
           address,
           is_final: !askForAddition,
           output: bufferAsHex(output),
-          tokens: Number(askForAmount),
+          tokens: askForAmount,
         });
       }],
     },

package/capacity/fee_for_replacement.js

@@ -13,7 +13,7 @@ const dummySignature = Buffer.alloc(74);
 const dummyTokens = 0;
 const dummyVout = 0;
 const hexAsBuffer = hex => Buffer.from(hex, 'hex');
-const increaseBuffer = 300;
+const increaseBuffer = 250;
 const {max} = Math;
 const weightAsVBytes = weight => weight / 4;
 
@@ -24,7 +24,7 @@ const weightAsVBytes = weight => weight / 4;
     commit_transaction_fee: <Commit Transaction Fee Tokens Number>
     commit_transaction_weight: <Commit Transaction Weight Units Number>
     decrease: [{
-      output: <Output Script Hex String>
+      [output]: <Output Script Hex String>
       tokens: <Spend Value to Chain Address Tokens Number>
     }]
     [increase]: <Add Funds Tokens Number>
@@ -51,16 +51,12 @@ module.exports = args => {
 
   // Add the decreases as outputs
   args.decrease.forEach(({output, tokens}) => {
-    return tx.addOutput(hexAsBuffer(output), tokens);
+    return tx.addOutput(hexAsBuffer(output || dummyP2wsh), tokens);
   });
 
   // Add an output to represent the new channel output
   tx.addOutput(dummyP2wsh, args.capacity);
 
-  args.decrease.forEach(({output}) => {
-    return tx.addOutput(hexAsBuffer(output), dummyTokens);
-  });
-
   // Add an input to represent the old channel input
   tx.addInput(dummyHash, dummyVout);
 

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,