paid-services 3.10.0 → 3.11.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Versions
 
+## Version 3.11.0
+
+- `changeChannelCapacity`: Add `nodes` to allow moving channel to another node
+
 ## Version 3.10.0
 
 - `createAnchoredTrade`: Add method to create an anchored open trade

package/capacity/accept_capacity_change.js

@@ -32,6 +32,7 @@ const openTxType = '1';
     [increase]: <Increase Tokens Number>
     lnd: <Authenticated LND API Object>
     logger: <Winston Logger Object>
+    to: <Expect Channel from Public Key Hex String>
   }
 
   @returns via cbk or Promise
@@ -43,7 +44,7 @@ const openTxType = '1';
     transaction_vout: <Replacement Channel Transaction Output Index Number>
   }
 */
-module.exports = ({channel, from, id, increase, lnd, logger}, cbk) => {
+module.exports = ({channel, from, id, increase, lnd, logger, to}, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
@@ -68,6 +69,10 @@ module.exports = ({channel, from, id, increase, lnd, logger}, cbk) => {
           return cbk([400, 'ExpectedLoggerObjectToAcceptCapacityChange']);
         }
 
+        if (!to) {
+          return cbk([400, 'ExpectedToPublicKeyToAcceptCapacityChange']);
+        }
+
         return cbk();
       },
 
@@ -219,6 +224,7 @@ module.exports = ({channel, from, id, increase, lnd, logger}, cbk) => {
             channel,
             lnd,
             output,
+            to,
             id: parameters.id,
             unsigned: parseSignCapacityRequest(parameters).unsigned,
             vout: parameters.vout,

package/capacity/ask_for_change_details.js

@@ -1,10 +1,12 @@
 const asyncAuto = require('async/auto');
 const asyncUntil = require('async/until');
+const {connectPeer} = require('ln-sync');
 const {findKey} = require('ln-sync');
 const {getChainFeeRate} = require('ln-service');
 const {getChainTransactions} = require('ln-service');
 const {getChannel} = require('ln-service');
 const {getChannels} = require('ln-service');
+const {getNodeAlias} = require('ln-sync');
 const {getPeers} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 const {sendMessageToPeer} = require('ln-service');
@@ -16,6 +18,7 @@ const feeForReplacement = require('./fee_for_replacement');
 const {ceil} = Math;
 const dust = 550;
 const dustBuffer = 750;
+const {isArray} = Array;
 const isNumber = n => !isNaN(n);
 const largeChannelsBit = 19;
 const maxSats = 21e6 * 1e8;
@@ -40,6 +43,11 @@ const weightBuffer = 150;
     ask: <Ask Function>
     id: <Request Identifier Hex String>
     lnd: <Authenticated LND API Object>
+    nodes: [{
+      lnd: <Potential Move Node LND API Object>
+      node_name: <Potential Move Node Name String>
+      public_key: <Potential Move Node Public Key Hex String>
+    }]
   }
 
   @returns via cbk or Promise
@@ -59,6 +67,8 @@ const weightBuffer = 150;
     id: <Standard Format Channel Id String>
     increase: <Channel Capacity Increase Tokens Number>
     is_private: <Channel is Private Bool>
+    [open_from]: <Open Replacement Channel From Node with Public Key String>
+    open_lnd: <Open Replacement Channel with LND API Object>
     [open_transaction]: <Channel Open Transaction Hex String>
     partner_csv_delay: <Peer CSV Delay Number>
     partner_public_key: <Node to Ask For Capacity Change Public Key Hex String>
@@ -70,7 +80,7 @@ const weightBuffer = 150;
     transaction_id: <Channel Funding Transaction Id Hex String>
   }
 */
-module.exports = ({ask, id, lnd}, cbk) => {
+module.exports = ({ask, id, lnd, nodes}, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
@@ -87,6 +97,10 @@ module.exports = ({ask, id, lnd}, cbk) => {
           return cbk([400, 'ExpectedLndToAskForChangeDetails']);
         }
 
+        if (!isArray(nodes)) {
+          return cbk([400, 'ExpectedArrayOfPotentialMoveNodesToAskForChange']);
+        }
+
         return cbk();
       },
 
@@ -112,7 +126,7 @@ module.exports = ({ask, id, lnd}, cbk) => {
         return getChainFeeRate({lnd, confirmation_target: slowTarget}, cbk);
       }],
 
-      // Find the public key or alias entered
+      // Find the node with the public key or alias entered
       findKey: [
         'askForPeer',
         'getChannels',
@@ -126,6 +140,11 @@ module.exports = ({ask, id, lnd}, cbk) => {
         cbk);
       }],
 
+      // Get the alias of the peer
+      getAlias: ['findKey', ({findKey}, cbk) => {
+        return getNodeAlias({lnd, id: findKey.public_key}, cbk);
+      }],
+
       // Send a test message to the selected peer to confirm they are connected
       testPeer: ['findKey', 'getChannels', ({findKey, getChannels}, cbk) => {
         const hasPeer = !!getChannels.channels.find(channel => {
@@ -190,7 +209,7 @@ module.exports = ({ask, id, lnd}, cbk) => {
         return ask({
           choices,
           loop: false,
-          message: 'Channel to change capacity?',
+          message: 'Channel to change?',
           name: 'id',
           type: 'list',
         },
@@ -294,20 +313,32 @@ module.exports = ({ask, id, lnd}, cbk) => {
       }],
 
       // Choose whether to add or remove coins
-      askForDirection: ['channel', ({channel}, cbk) => {
+      askForDirection: ['channel', 'getAlias', ({channel, getAlias}, cbk) => {
+        const {alias} = getAlias;
+
+        const choices = [
+          {
+            disabled: !channel.max_increase_tokens,
+            name: `Increase capacity (currently ${channel.capacity})`,
+            value: 'increase',
+          },
+          {
+            disabled: !channel.max_decrease_tokens,
+            name: `Decrease capacity (limit ${channel.max_decrease_tokens})`,
+            value: 'decrease',
+          },
+        ];
+
+        if (!!nodes.filter(n => n.public_key !== getAlias.id).length) {
+          choices.push({
+            disabled: !channel.max_decrease_tokens,
+            name: `Move the channel with ${alias} to another of your nodes?`,
+            value: 'migrate',
+          });
+        }
+
         return ask({
-          choices: [
-            {
-              disabled: !channel.max_increase_tokens,
-              name: `Increase capacity (currently ${channel.capacity})`,
-              value: 'increase',
-            },
-            {
-              disabled: !channel.max_decrease_tokens,
-              name: `Decrease capacity (limit ${channel.max_decrease_tokens})`,
-              value: 'decrease',
-            },
-          ],
+          choices,
           message: 'How do you want to change the channel capacity?',
           name: 'direction',
           type: 'list',
@@ -315,6 +346,51 @@ module.exports = ({ask, id, lnd}, cbk) => {
         ({direction}) => cbk(null, direction));
       }],
 
+      // Ask for migration
+      askForMigration: [
+        'askForDirection',
+        'channel',
+        ({askForDirection, channel}, cbk) =>
+      {
+        // Exit early if not decrease or no saved nodes
+        if (askForDirection !== 'migrate') {
+          return cbk();
+        }
+
+        const peer = channel.partner_public_key;
+
+        const potentialNodes = nodes.filter(n => n.public_key !== peer);
+
+        return ask({
+          choices: potentialNodes.map((node, i) => ({
+            name: `${node.node_name} ${node.public_key}`,
+            value: i,
+          })),
+          message: 'Move channel to?',
+          name: 'migration',
+          type: 'list',
+        },
+        ({migration}) => cbk(null, potentialNodes[migration]));
+      }],
+
+      // Add peer from migrating node
+      connect: [
+        'askForMigration',
+        'findKey',
+        ({askForMigration, findKey}, cbk) =>
+      {
+        // Exit early if its there is no migration
+        if (!askForMigration) {
+          return cbk();
+        }
+
+        return connectPeer({
+          id: findKey.public_key,
+          lnd: askForMigration.lnd,
+        },
+        cbk);
+      }],
+
       // Ask for how much to decrease
       askForDecrease: [
         'askForDirection',
@@ -400,6 +476,7 @@ module.exports = ({ask, id, lnd}, cbk) => {
       askForPublicPrivate: [
         'askForDecrease',
         'askForIncrease',
+        'askForMigration',
         'channel',
         ({channel}, cbk) =>
       {
@@ -452,12 +529,10 @@ module.exports = ({ask, id, lnd}, cbk) => {
       {
         const {fee} = estimateChainFee;
 
-        const pay = `Pay estimated on-chain channel replacement fee: ${fee}`;
-
         return ask({
           type: 'confirm',
           name: 'proceed',
-          message: `${pay} for capacity change?`,
+          message: `Pay estimated channel replacement chain-fee: ${fee}?`,
         },
         ({proceed}) => cbk(null, proceed));
       }],
@@ -466,16 +541,20 @@ module.exports = ({ask, id, lnd}, cbk) => {
       details: [
         'askForDecrease',
         'askForIncrease',
+        'askForMigration',
         'askForPublicPrivate',
         'channel',
+        'connect',
         'confirmFeeEstimate',
         'estimateChainFee',
         'getTx',
         ({
           askForDecrease,
           askForIncrease,
+          askForMigration,
           askForPublicPrivate,
           channel,
+          connect,
           confirmFeeEstimate,
           estimateChainFee,
           getTx,
@@ -509,6 +588,7 @@ module.exports = ({ask, id, lnd}, cbk) => {
           channel: channel.id,
           decrease: !!askForDecrease ? sumOfTokens(askForDecrease) : undefined,
           increase: askForIncrease,
+          to: !!askForMigration ? askForMigration.public_key : undefined,
           type: askForPublicPrivate.is_private ? privateType : publicType,
         });
 
@@ -524,6 +604,8 @@ module.exports = ({ask, id, lnd}, cbk) => {
           id: channel.id,
           increase: askForIncrease,
           is_private: askForPublicPrivate.is_private,
+          open_from: !!askForMigration ? askForMigration.public_key : null,
+          open_lnd: !!askForMigration ? askForMigration.lnd : lnd,
           open_transaction: channel.open_transaction,
           partner_csv_delay: channel.partner_csv_delay,
           partner_public_key: channel.partner_public_key,

package/capacity/ask_to_select_change.js

@@ -0,0 +1,109 @@
+const asyncAuto = require('async/auto');
+const {getNodeAlias} = require('ln-sync');
+const {returnResult} = require('asyncjs-util');
+
+const describeCapacityChange = require('./describe_capacity_change');
+
+/** Ask to select a change
+
+  {
+    ask: <Inquirer Ask Function>
+    [address]: <Cooperative Close Address String>
+    capacity: <Channel Capacity Tokens Number>
+    channel: <Change Channel Id String>
+    [decrease]: <Capacity Change Decrease Tokens Number>
+    from_id: <Peer Public Key Hex String>
+    [increase]: <Capacity Change Increase Tokens Number>
+    lnd: <Authenticated LND API Object>
+    [to_id]: <Node Public Key Hex String>
+    [type]: <Channel Type String>
+  }
+
+  @returns via cbk or Promise
+  {
+    is_selected: <Request to Change Channel is Selected Bool>
+  }
+*/
+module.exports = (args, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!args.ask) {
+          return cbk([400, 'ExpectedAskFunctionToAskToSelectChange']);
+        }
+
+        if (!args.capacity) {
+          return cbk([400, 'ExpectedChannelCapacityToAskToSelectChange']);
+        }
+
+        if (!args.channel) {
+          return cbk([400, 'ExpectedChannelIdToAskToSelectAChangeFor']);
+        }
+
+        if (!args.from_id) {
+          return cbk([400, 'ExpectedChannelPartnerPublicKeyToSelectChange']);
+        }
+
+        if (!args.lnd) {
+          return cbk([400, 'ExpectedLndApiToAskToSelectChange']);
+        }
+
+        return cbk();
+      },
+
+      // Get the peer alias
+      getPeerAlias: ['validate', ({}, cbk) => {
+        return getNodeAlias({id: args.from_id, lnd: args.lnd}, cbk);
+      }],
+
+      // Get the alias of the node to move to
+      getNodeAlias: ['validate', ({}, cbk) => {
+        // Exit early when there is no new node to move to
+        if (!args.to_id) {
+          return cbk(null, {});
+        }
+
+        return getNodeAlias({id: args.to_id, lnd: args.lnd}, cbk);
+      }],
+
+      // Confirm acceptance of the change
+      confirm: [
+        'getNodeAlias',
+        'getPeerAlias',
+        ({getNodeAlias, getPeerAlias}, cbk) =>
+      {
+        const message = describeCapacityChange({
+          capacity: args.capacity,
+          channel: args.channel,
+          decrease: args.decrease,
+          from_alias: getPeerAlias.alias,
+          from_id: args.from_id,
+          increase: args.increase,
+          to_alias: getNodeAlias.alias,
+          to_id: args.to_id,
+          type: args.type,
+        });
+
+        return args.ask({
+          message,
+          name: 'accept',
+          type: 'confirm',
+        },
+        ({accept}) => {
+          if (!accept) {
+            return cbk(null, {is_selected: false});
+          }
+
+          // Fail changing when cooperative_close_address is set
+          if (!!args.address && !args.increase) {
+            return cbk([400, 'ChannelHasLockedCoopCloseAddressSet']);
+          }
+
+          return cbk(null, {is_selected: true});
+        });
+      }],
+    },
+    returnResult({reject, resolve, of: 'confirm'}, cbk));
+  });
+};

package/capacity/capacity_change_requests.js

@@ -29,6 +29,7 @@ const privateAsType = isPrivate => isPrivate ? 1 : 0;
       from: <From Node Public Key Id Hex String>
       id: <Change Request Id Hex String>
       [increase]: <Add Capacity Tokens Number>
+      [to]: <Switch Channel to Node with Identity Public Key Hex String>
       [type]: <Change Channel Channel Type Flags Number>
     }]
   }
@@ -77,6 +78,7 @@ module.exports = ({channels, requests}) => {
         from: channel.partner_public_key,
         id: request.id,
         increase: request.increase,
+        to: request.to,
         type: type ? request.type : undefined,
       };
     });

package/capacity/change_channel_capacity.js

@@ -2,20 +2,17 @@ const asyncAuto = require('async/auto');
 const asyncDetectSeries = require('async/detectSeries');
 const asyncRetry = require('async/retry');
 const {getIdentity} = require('ln-service');
-const {getNodeAlias} = require('ln-sync');
 const {returnResult} = require('asyncjs-util');
 const {updateChannelFee} = require('ln-sync');
 
 const acceptCapacityChange = require('./accept_capacity_change');
+const askToSelectChange = require('./ask_to_select_change');
 const getCapacityChangeRequests = require('./get_capacity_change_requests');
 const initiateCapacityChange = require('./initiate_capacity_change');
 
-const describeType = type => !(type & 0) ? 'private' : 'public';
-const interval = 10 * 1000;
-const peerName = ({alias, id}) => `${alias} ${id.substring(0, 8)}`.trim();
+const interval = 1000 * 10;
+const {isArray} = Array;
 const times = 6 * 60 * 6;
-const tokensAsBigUnit = tokens => (tokens / 1e8).toFixed(8);
-const waitForCloseInterval = 1000 * 3;
 
 /** Change a channel's capacity
 
@@ -24,9 +21,14 @@ const waitForCloseInterval = 1000 * 3;
     [delay]: <Wait Time For Incoming Capacity Requests Milliseconds Number>
     lnd: <Authenticated LND API Object>
     logger: <Winston Logger Object>
+    [nodes]: [{
+      lnd: <Authenticated LND API Object>
+      named: <Node Named String.
+      public_key: <Node Identity Public Key Hex String>
+    }]
   }
 */
-module.exports = ({ask, delay, lnd, logger}, cbk) => {
+module.exports = ({ask, delay, lnd, logger, nodes}, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
@@ -43,6 +45,10 @@ module.exports = ({ask, delay, lnd, logger}, cbk) => {
           return cbk([400, 'ExpectedLoggerObjectToChangeCapacity']);
         }
 
+        if (!!nodes && !isArray(nodes)) {
+          return cbk([400, 'ExpectedArrayOfControlledNodesToChangeCapacity']);
+        }
+
         return cbk();
       },
 
@@ -83,42 +89,24 @@ module.exports = ({ask, delay, lnd, logger}, cbk) => {
         ({waitForProposal}, cbk) =>
       {
         return asyncDetectSeries(waitForProposal.requests, (request, cbk) => {
-          return getNodeAlias({lnd, id: request.from}, (err, res) => {
+          return askToSelectChange({
+            ask,
+            lnd,
+            address: request.address,
+            capacity: request.capacity,
+            channel: request.channel,
+            decrease: request.decrease,
+            from_id: request.from,
+            increase: request.increase,
+            to_id: request.to,
+            type: request.type,
+          },
+          (err, res) => {
             if (!!err) {
               return cbk(err);
             }
 
-            const change = !!request.increase ? 'Increase' : 'Decrease';
-            const delta = request.decrease || request.increase;
-            const hasType = request.type !== undefined;
-            const id = request.channel;
-            const peer = peerName(res);
-            const size = tokensAsBigUnit(request.capacity);
-
-
-            const action = `${change} capacity ${size} channel ${id}`;
-            const by = !!delta ? ` by ${tokensAsBigUnit(delta)}` : '';
-            const type = hasType ? describeType(request.type) : '';
-
-            const changeType = hasType ? ` and make channel ${type}` : '';
-
-            return ask({
-              type: 'confirm',
-              name: 'accept',
-              message: `${action} with ${peer}${by}${changeType}?`,
-            },
-            ({accept}) => {
-              if (!accept) {
-                return cbk(null, false);
-              }
-
-              // Fail changing when cooperative_close_address is set
-              if (!!request.address && !!request.increase) {
-                return cbk([400, 'ChannelHasLockedCoopCloseAddressSet']);
-              }
-
-              return cbk(null, true);
-            });
+            return cbk(null, res.is_selected);
           });
         },
         cbk);
@@ -138,17 +126,30 @@ module.exports = ({ask, delay, lnd, logger}, cbk) => {
           from: askToSelectChange.from,
           id: askToSelectChange.id,
           increase: askToSelectChange.increase,
+          to: askToSelectChange.to || askToSelectChange.from,
         },
         cbk);
       }],
 
       // Initiate a capacity change
-      initiateChange: ['askToSelectChange', ({askToSelectChange}, cbk) => {
+      initiateChange: [
+        'askToSelectChange',
+        'getIdentity',
+        ({askToSelectChange, getIdentity}, cbk) =>
+      {
         if (!!askToSelectChange) {
           return cbk();
         }
 
-        return initiateCapacityChange({ask, lnd, logger}, cbk);
+        return initiateCapacityChange({
+          ask,
+          lnd,
+          logger,
+          nodes: (nodes || []).filter(node => {
+            return node.public_key !== getIdentity.public_key;
+          }),
+        },
+        cbk);
       }],
 
       // Reset the channel routing policies
@@ -164,11 +165,11 @@ module.exports = ({ask, delay, lnd, logger}, cbk) => {
 
         return asyncRetry({interval, times}, cbk => {
           return updateChannelFee({
-            lnd,
             base_fee_mtokens: policy.base_fee_mtokens,
             cltv_delta: policy.cltv_delta,
             fee_rate: policy.fee_rate,
-            from: getIdentity.public_key,
+            from: policy.open_from || getIdentity.public_key,
+            lnd: policy.open_lnd || lnd,
             transaction_id: policy.transaction_id,
             transaction_vout: policy.transaction_vout,
           },

package/capacity/describe_capacity_change.js

@@ -0,0 +1,38 @@
+const describeType = type => !(type & 1) ? 'private' : 'public';
+const peerName = ({alias, id}) => `${alias} ${id.substring(0, 8)}`.trim();
+const tokensAsBigUnit = tokens => (tokens / 1e8).toFixed(8);
+
+/** Describe a capacity change
+
+  {
+    capacity: <Channel Capacity Tokens Number>
+    channel: <Change Channel Id String>
+    [decrease]: <Capacity Change Decrease Tokens Number>
+    from_alias: <Peer Alias String>
+    from_id: <Peer Public Key Hex String>
+    [increase]: <Capacity Change Increase Tokens Number>
+    [to_alias]: <Node Alias String>
+    [to_id]: <Node Public Key Hex String>
+    [type]: <Channel Type String>
+  }
+
+  @returns
+  <Capacity Change Description String>
+*/
+module.exports = args => {
+  const change = !!args.increase ? 'Increase' : 'Decrease';
+  const delta = args.decrease || args.increase;
+  const hasType = args.type !== undefined;
+  const newPeer = peerName({alias: args.to_alias, id: args.to_id || ''});
+  const peer = peerName({alias: args.from_alias, id: args.from_id});
+  const size = tokensAsBigUnit(args.capacity);
+
+  const action = `${change} capacity ${size} channel ${args.channel}`;
+  const by = !!delta ? ` by ${tokensAsBigUnit(delta)}` : '';
+  const move = !!args.to_id ? ` and move channel to ${newPeer}` : '';
+  const type = hasType ? describeType(args.type) : '';
+
+  const changeType = hasType ? ` and make channel ${type}` : '';
+
+  return `${action} with ${peer}${by}${move}${changeType}?`;
+};

package/capacity/encode_change_request.js

@@ -1,12 +1,16 @@
 const {encodeBigSize} = require('bolt01');
+const {encodeTlvRecord} = require('bolt01');
 const {rawChanId} = require('bolt07');
 
 const channelFlagsType = '5';
 const channelIdRecordType = '2';
+const currentVersion = '1';
 const decreaseRecordType = '3';
 const increaseRecordType = '4';
+const migrateRecordType = '6';
 const requestIdRecordType = '1';
 const typeAsHex = type => Buffer.from([type]).toString('hex');
+const versionRecordType = '0';
 
 /** Encode a request to change a channel capacity
 
@@ -15,6 +19,7 @@ const typeAsHex = type => Buffer.from([type]).toString('hex');
     [decrease]: <Remove Channel Funds By Tokens Number>
     id: <Request Id Hex String>
     increase: <Add Channel Funds By Tokens Number>
+    [to]: <Move Channel to Different Node with Public Key Hex String>
     type: <New Channel Type Number>
   }
 
@@ -26,8 +31,12 @@ const typeAsHex = type => Buffer.from([type]).toString('hex');
     }]
   }
 */
-module.exports = ({channel, decrease, id, increase, type}) => {
+module.exports = ({channel, decrease, id, increase, to, type}) => {
   const records = [
+    {
+      type: versionRecordType,
+      value: encodeBigSize({number: currentVersion}).encoded,
+    },
     {
       type: requestIdRecordType,
       value: id,
@@ -42,21 +51,26 @@ module.exports = ({channel, decrease, id, increase, type}) => {
     },
   ];
 
+  // Add a record reflecting the decrease in the capacity
   if (!!decrease) {
-    // Add a record reflecting the decrease in the capacity
     records.push({
       type: decreaseRecordType,
       value: encodeBigSize({number: decrease.toString()}).encoded,
     });
   }
 
+  // Add a record reflecting the increase in the capacity
   if (!!increase) {
-    // Add a record reflecting the increase in the capacity
     records.push({
       type: increaseRecordType,
       value: encodeBigSize({number: increase.toString()}).encoded,
     });
   }
 
+  // Add a record reflecting the migration of channel to a different peer
+  if (!!to) {
+    records.push({type: migrateRecordType, value: to});
+  }
+
   return {records};
 };

package/capacity/get_capacity_change_requests.js

@@ -28,6 +28,7 @@ const waitForRequestsTimeoutMs = 5000;
       from: <From Node Public Key Id Hex String>
       id: <Change Request Id Hex String>
       [increase]: <Add Capacity Tokens Number>
+      [to]: <Switch Channel to Node with Identity Public Key Hex String>
       [type]: <Intended Replacement Channel Channel Type Flags Number>
     }]
   }

package/capacity/get_capacity_replacement.js

@@ -49,6 +49,7 @@ const txIdAsHash = id => Buffer.from(id, 'hex').reverse();
     [increase]: <Increase Channel Size Tokens Number>
     [is_private]: <Original Channel Is Private Bool>
     lnd: <Authenticated LND API Object>
+    open_lnd: <Open Channel with LND API Object>
     transaction_id: <Original Funding Transaction Id Hex String>
     transaction_vout: <Original Funding Output Index Number>
   }
@@ -87,6 +88,10 @@ module.exports = (args, cbk) => {
           return cbk([400, 'ExpectedLndApiToGetCapacityReplacement']);
         }
 
+        if (!args.open_lnd) {
+          return cbk([400, 'ExpectedLndToUseToOpenReplacementChannel']);
+        }
+
         if (!args.transaction_id) {
           return cbk([400, 'ExpectedFundingTxIdToGetCapacityReplacement']);
         }
@@ -302,7 +307,7 @@ module.exports = (args, cbk) => {
             partner_public_key: pendingChannel.partner_public_key,
           }],
           is_avoiding_broadcast: true,
-          lnd: args.lnd,
+          lnd: args.open_lnd,
         },
         cbk);
       }],

package/capacity/get_replacement_signature.js

@@ -24,6 +24,7 @@ const txIdAsHash = id => Buffer.from(id, 'hex').reverse();
     id: <Channel Funding Transaction Id Hex String>
     lnd: <Authenticated LND API Object>
     output: <Original Funding Output Script Hex String>
+    to: <Replacement Channel with Peer Public Key Hex String>
     unsigned: <Unsigned Replacement Transaction Hex String>
     vout: <Channel Funding Output Index Number>
   }
@@ -35,7 +36,7 @@ const txIdAsHash = id => Buffer.from(id, 'hex').reverse();
     transaction_vout: <Replacement Transaction Output Index Number>
   }
 */
-module.exports = ({channel, id, lnd, output, unsigned, vout}, cbk) => {
+module.exports = ({channel, id, lnd, output, to, unsigned, vout}, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
@@ -56,6 +57,10 @@ module.exports = ({channel, id, lnd, output, unsigned, vout}, cbk) => {
           return cbk([400, 'ExpectedOutputScriptToGetReplacementSignature']);
         }
 
+        if (!to) {
+          return cbk([400, 'ExpectedChannelToPublicKeyHexString']);
+        }
+
         if (!unsigned) {
           return cbk([400, 'ExpectedUnsignedTxToGetReplacementSignature']);
         }
@@ -164,8 +169,8 @@ module.exports = ({channel, id, lnd, output, unsigned, vout}, cbk) => {
                 return false;
               }
 
-              // The new channel must be from the same peer
-              if (channel.partner_public_key !== pending.partner_public_key) {
+              // The new channel must be from the expected node
+              if (channel.partner_public_key !== to) {
                 return false;
               }
 

package/capacity/initiate_capacity_change.js

@@ -36,6 +36,7 @@ const familyTemporary = 805;
 const {fromHex} = Transaction;
 const hexAsBuffer = hex => Buffer.from(hex, 'hex');
 const idRecordType = '0';
+const {isArray} = Array;
 const makeId = () => randomBytes(32).toString('hex');
 const messageFrequencyMs = 3000;
 const minimumAddTokens = 20000;
@@ -59,6 +60,11 @@ const waitingTimeoutMs = 1000 * 30;
     ask: <Ask Function>
     lnd: <Authenticated LND API Object>
     logger: <Winston Logger Object>
+    nodes: [{
+      lnd: <Potential Move Node LND API Object>
+      node_name: <Potential Move Node Name String>
+      public_key: <Potential Move Node Public Key Hex String>
+    }]
   }
 
   @returns via cbk or Promise
@@ -66,11 +72,12 @@ const waitingTimeoutMs = 1000 * 30;
     base_fee_mtokens: <Forwarding Base Fee Millitokens String>
     cltv_delta: <Forwarding CLTV Delta Number>
     fee_rate: <Forwarding Parts Per Million Fee Rate Number>
+    open_lnd: <Channel Open LND API Object>
     transaction_id: <Replacement Channel Transaction Id Hex String> 
     transaction_vout: <Replacement Channel Transaction Output Index Number>
   }
 */
-module.exports = ({ask, lnd, logger}, cbk) => {
+module.exports = ({ask, lnd, logger, nodes}, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Generate a unique identifier for the change
@@ -90,6 +97,10 @@ module.exports = ({ask, lnd, logger}, cbk) => {
           return cbk([400, 'ExpectedLoggerObjectToInitiateCapacityChange']);
         }
 
+        if (!isArray(nodes)) {
+          return cbk([400, 'ExpectedArrayOfCandidateMoveNodesToInitiate']);
+        }
+
         return cbk();
       },
 
@@ -98,18 +109,18 @@ module.exports = ({ask, lnd, logger}, cbk) => {
 
       // Ask for all the capacity change details
       askForChangeDetails: ['id', 'validate', ({id}, cbk) => {
-        return askForChangeDetails({ask, id, lnd}, cbk);
+        return askForChangeDetails({ask, id, lnd, nodes}, cbk);
       }],
 
       // Propose the theoretical new channel to the peer to confirm a change
       checkAccept: ['askForChangeDetails', ({askForChangeDetails}, cbk) => {
         // Check that a channel open would be accepted
         return acceptsChannelOpen({
-          lnd,
           capacity: askForChangeDetails.estimated_capacity,
           cooperative_close_address: askForChangeDetails.coop_close_address,
           give_tokens: askForChangeDetails.remote_balance,
           is_private: askForChangeDetails.is_private,
+          lnd: askForChangeDetails.open_lnd,
           min_htlc_mtokens: askForChangeDetails.min_htlc_mtokens,
           partner_csv_delay: askForChangeDetails.partner_csv_delay,
           partner_public_key: askForChangeDetails.partner_public_key,
@@ -403,6 +414,7 @@ module.exports = ({ask, lnd, logger}, cbk) => {
         asyncReflect(({
           askForChangeDetails,
           getFunding,
+          getMigrationLnd,
           getNetwork,
           getPeerChannels,
           id,
@@ -438,6 +450,7 @@ module.exports = ({ask, lnd, logger}, cbk) => {
           increase_transaction_vout: getFunding.vout,
           increase_witness_script: getFunding.script,
           is_private: askForChangeDetails.is_private,
+          open_lnd: askForChangeDetails.open_lnd,
           open_transaction: sendBasicRequest,
           partner_public_key: askForChangeDetails.partner_public_key,
           transaction_id: channel.transaction_id,
@@ -463,6 +476,8 @@ module.exports = ({ask, lnd, logger}, cbk) => {
           base_fee_mtokens: askForChangeDetails.base_fee_mtokens,
           cltv_delta: askForChangeDetails.cltv_delta,
           fee_rate: askForChangeDetails.fee_rate,
+          open_from: askForChangeDetails.open_from || undefined,
+          open_lnd: askForChangeDetails.open_lnd,
           transaction_id: proposeChange.value.transaction_id,
           transaction_vout: proposeChange.value.transaction_vout,
         });

package/capacity/parse_capacity_change_request.js

@@ -4,16 +4,18 @@ 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);
-
 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 findMigrationRecord = records => records.find(n => n.type === '6');
 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');
+const hexAsNumber = n => Buffer.from(n, 'hex').readUInt8();
+const idHexLength = 64;
+const isPublicKey = n => !!n && /^0[2-3][0-9A-F]{64}$/i.test(n);
+const knownVersions = ['01'];
+const tooLarge = BigInt(Number.MAX_SAFE_INTEGER);
 
 /** Parse a capacity change request
 
@@ -34,6 +36,7 @@ const findVersionRecord = records => records.find(n => n.type === '0');
       id: <Change Request Id Hex String>
       [increase]: <Add Capacity Tokens Number>
       [type]: <Intended Replacement Channel Channel Type Flags Number>
+      [to]: <Replace Channel with New Peer with Identity Public Key Hex String>
     }
   }
 */
@@ -43,8 +46,10 @@ module.exports = ({from, records}) => {
     return {};
   }
 
-  // Exit early when there is a version record, indicating a future version
-  if (!!findVersionRecord(records)) {
+  const versionRecord = findVersionRecord(records);
+
+  // Exit early when the request is an unknown version
+  if (!!versionRecord && !knownVersions.includes(versionRecord.value)) {
     return {};
   }
 
@@ -71,6 +76,7 @@ module.exports = ({from, records}) => {
 
   const decreaseRecord = findDecreaseRecord(records);
   const increaseRecord = findIncreaseRecord(records);
+  const migrationRecord = findMigrationRecord(records);
   const typeRecord = findTypeRecord(records);
 
   // Exit early when there is a change in both directions
@@ -82,8 +88,8 @@ module.exports = ({from, records}) => {
   const id = idRecord.value;
   const type = typeRecord ? hexAsNumber(typeRecord.value) : undefined;
 
-  // Exit early when there is no decrease or increase
-  if (!decreaseRecord && !increaseRecord) {
+  // Exit early when there is no decrease, increase or migration record
+  if (!decreaseRecord && !increaseRecord && !migrationRecord) {
     return {request: {channel, from, id, type}};
   }
 
@@ -95,6 +101,21 @@ module.exports = ({from, records}) => {
     return {};
   }
 
+  // Exit early when a migration record is present on a too-old version
+  if (!!migrationRecord && !versionRecord) {
+    return {};
+  }
+
+  // Exit early when a migration record is not a public key
+  if (!!migrationRecord && !isPublicKey(migrationRecord.value)) {
+    return {};
+  }
+
+  // Exit early when a migration record has the same key as the peer
+  if (!!migrationRecord && migrationRecord.value === from) {
+    return {};
+  }
+
   return {
     request: {
       channel,
@@ -103,6 +124,7 @@ module.exports = ({from, records}) => {
       type,
       decrease: Number(decrease) || undefined,
       increase: Number(increase) || undefined,
+      to: !!migrationRecord ? migrationRecord.value : undefined,
     },
   };
 };

package/capacity/propose_capacity_change.js

@@ -53,6 +53,7 @@ const unsignedTransactionType = '1';
     [increase_witness_script]: <Increase Funds Witness Script Hex String>
     lnd: <Authenticated LND API Object>
     logger: <Winston Logger Object>
+    open_lnd: <Open Replacement Channel Using LND API Object>
     open_transaction: <Original Channel Funding Transaction Hex String>
     partner_public_key: <Peer Public Key Hex Encoded String>
     transaction_id: <Original Channel Transaction Id Hex String>
@@ -94,6 +95,10 @@ module.exports = (args, cbk) => {
           return cbk([400, 'ExpectedWinstonLoggerToProposeCapacityChange']);
         }
 
+        if (!args.open_lnd) {
+          return cbk([400, 'ExpectedOpenLndApiToProposeCapacityChange']);
+        }
+
         if (!args.open_transaction) {
           return cbk([400, 'ExpectedChannelOpenTxToProposeCapacityChange']);
         }
@@ -125,6 +130,7 @@ module.exports = (args, cbk) => {
           increase: args.increase,
           is_private: args.is_private,
           lnd: args.lnd,
+          open_lnd: args.open_lnd,
           open_transaction: args.open_transaction,
           transaction_id: args.transaction_id,
           transaction_vout: args.transaction_vout,
@@ -200,7 +206,7 @@ module.exports = (args, cbk) => {
         return fundPendingChannels({
           funding,
           channels: [getReplacement.pending_channel_id],
-          lnd: args.lnd,
+          lnd: args.open_lnd,
         },
         cbk);
       }],
@@ -361,7 +367,7 @@ module.exports = (args, cbk) => {
 
           // Look for the new channel to see if the change succeeded
           try {
-            const {channels} = await getChannels({lnd: args.lnd});
+            const {channels} = await getChannels({lnd: args.open_lnd});
 
             const channel = channels.find(n => n.transaction_id === txId);
 

package/package.json

@@ -12,7 +12,7 @@
     "bolt01": "1.2.3",
     "bolt07": "1.8.0",
     "invoices": "2.0.3",
-    "ln-service": "53.5.0",
+    "ln-service": "53.5.1",
     "ln-sync": "3.7.0"
   },
   "description": "Lightning Paid Services library",
@@ -40,5 +40,5 @@
     "integration-tests": "tap -j 2 --branches=1 --functions=1 --lines=1 --statements=1 -t 180 test/integration/*.js",
     "test": "tap --branches=1 --functions=1 --lines=1 --statements=1 -t 60 test/actions/*.js test/capacity/*.js test/client/*.js test/config/*.js test/p2p/*.js test/records/*.js test/respond/*.js test/server/*.js test/server/*.js test/services/*.js test/trades/*.js"
   },
-  "version": "3.10.0"
+  "version": "3.11.0"
 }

package/test/capacity/test_capacity_change_requests.js

@@ -34,6 +34,7 @@ const tests = [
         from: Buffer.alloc(33, 3).toString('hex'),
         id: Buffer.alloc(32).toString('hex'),
         increase: undefined,
+        to: undefined,
         type: undefined,
       }],
     },

package/test/capacity/test_encode_change_request.js

@@ -22,6 +22,10 @@ const tests = [
     description: 'Encode change request parameters',
     expected: {
       records: [
+        {
+          type: '0',
+          value: '01',
+        },
         {
           type: '1',
           value: '0000000000000000000000000000000000000000000000000000000000000000',

package/test/integration/test_accept_capacity_change.js

@@ -105,6 +105,7 @@ test(`Accept capacity replacement`, async ({end, equal, strictSame}) => {
           bitcoinjs_network: (await getNetwork({lnd})).bitcoinjs,
           channel: channel.id,
           decrease: [],
+          open_lnd: lnd,
           open_transaction: tx.transaction,
           partner_public_key: target.id,
           transaction_id: channel.transaction_id,
@@ -123,6 +124,7 @@ test(`Accept capacity replacement`, async ({end, equal, strictSame}) => {
           channel: channel.id,
           from: control.id,
           lnd: target.lnd,
+          to: control.id,
         });
       },
 

package/test/integration/test_change_channel_capacity.js

@@ -114,6 +114,7 @@ test(`Accept capacity replacement`, async ({end, equal, strictSame}) => {
             throw new Error('UnknownQueryNameForInitiator');
           },
           logger: {error: log, info: log},
+          nodes: [],
         });
       },
 
@@ -146,6 +147,7 @@ test(`Accept capacity replacement`, async ({end, equal, strictSame}) => {
           },
           lnd: target.lnd,
           logger: {error: log, info: log},
+          nodes: [],
         });
       }],
 

package/test/integration/test_decrease_channel_capacity.js

@@ -127,6 +127,7 @@ test(`Decrease capacity replacement`, async ({end, equal, strictSame}) => {
 
             throw new Error('UnexpectedQueryNameForProposingSide');
           },
+          nodes: [],
         });
       },
 
@@ -159,6 +160,7 @@ test(`Decrease capacity replacement`, async ({end, equal, strictSame}) => {
             throw new Error('UnexpectedQueryNameForAcceptingSide');
           },
           lnd: target.lnd,
+          nodes: [],
         });
       }],
 

package/test/integration/test_increase_channel_capacity.js

@@ -116,6 +116,7 @@ test(`Accept capacity replacement`, async ({end, equal, strictSame}) => {
 
             throw new Error('UnexpectedQueryNameForProposingSide');
           },
+          nodes: [],
         });
       },
 
@@ -146,6 +147,7 @@ test(`Accept capacity replacement`, async ({end, equal, strictSame}) => {
             throw new Error('UnexpectedQueryNameForAcceptingSide');
           },
           lnd: target.lnd,
+          nodes: [],
         });
       }],
 

package/test/integration/test_move_channel_capacity.js

@@ -0,0 +1,230 @@
+const {addPeer} = require('ln-service');
+const {address} = require('bitcoinjs-lib');
+const asyncAuto = require('async/auto');
+const asyncMap = require('async/map');
+const asyncRetry = require('async/retry');
+const {broadcastChainTransaction} = require('ln-service');
+const {closeChannel} = require('ln-service');
+const {createChainAddress} = require('ln-service');
+const {getChainTransactions} = require('ln-service');
+const {getChannel} = require('ln-service');
+const {getChannels} = require('ln-service');
+const {getNetwork} = require('ln-sync');
+const {networks} = require('bitcoinjs-lib');
+const {openChannel} = require('ln-service');
+const {spawnLightningCluster} = require('ln-docker-daemons');
+const {test} = require('@alexbosworth/tap');
+const {Transaction} = require('bitcoinjs-lib');
+
+const {changeChannelCapacity} = require('./../../capacity');
+const {getCapacityChangeRequests} = require('./../../capacity');
+
+const bufferAsHex = buffer => buffer.toString('hex');
+const capacity = 1e6;
+const {fromHex} = Transaction;
+const id = Buffer.alloc(32).toString('hex');
+const interval = 10;
+const log = () => {};
+const maturity = 100;
+const size = 3;
+const slow = 5000;
+const times = 2000;
+const {toOutputScript} = address;
+const weightAsVBytes = n => Math.ceil(n / 4);
+
+// A capacity movement proposal should be counter signed and accepted
+test(`Move channel capacity`, async ({end, equal, strictSame}) => {
+  const {kill, nodes} = await spawnLightningCluster({size});
+
+  const [control, target, remote] = nodes;
+
+  const {generate, lnd} = control;
+
+  const network = networks[(await getNetwork({lnd})).bitcoinjs];
+
+  // Make some funds
+  await generate({count: maturity});
+
+  try {
+    // Connect remote and target
+    await addPeer({
+      lnd: target.lnd,
+      public_key: remote.id,
+      socket: remote.socket,
+    });
+
+    // Open up a new channel
+    const channelOpen = await openChannel({
+      lnd,
+      is_private: true,
+      local_tokens: capacity,
+      partner_public_key: target.id,
+      partner_socket: target.socket,
+    });
+
+    // Wait for the channel to be active
+    const channel = await asyncRetry({interval, times}, async () => {
+      const [channel] = (await getChannels({lnd, is_active: true})).channels;
+
+      if (!channel) {
+        await generate({});
+
+        throw new Error('ExpectedChannelActivation');
+      }
+
+      const {policies} = await getChannel({lnd, id: channel.id});
+
+      const noPolicy = policies.find(n => !n.cltv_delta);
+
+      if (!!channel && !noPolicy) {
+        return channel;
+      }
+
+      await generate({});
+
+      throw new Error('ExpectedChannelActivation');
+    });
+
+    await asyncAuto({
+      // Propose the channel
+      propose: async () => {
+        await changeChannelCapacity({
+          lnd,
+          ask: (args, cbk) => {
+            if (args.name === 'amount') {
+              return cbk({amount: '0'});
+            }
+
+            if (args.name === 'decrease') {
+              return cbk({decrease: 'internal_spend_funds'});
+            }
+
+            if (args.name === 'direction') {
+              return cbk({direction: 'migrate'});
+            }
+
+            if (args.name === 'ok') {
+              return cbk({ok: true});
+            }
+
+            if (args.name === 'migration') {
+              return cbk({migration: 0});
+            }
+
+            if (args.name === 'proceed') {
+              return cbk({proceed: true});
+            }
+
+            if (args.name === 'query') {
+              return cbk({query: target.id});
+            }
+
+            if (args.name === 'type') {
+              return cbk({type: args.default});
+            }
+
+            throw new Error('UnknownQueryNameForInitiator');
+          },
+          logger: {error: log, info: log},
+          nodes: [{
+            from: 'from',
+            lnd: remote.lnd,
+            public_key: remote.id,
+          }],
+        });
+      },
+
+      // Wait to see the inbound proposal
+      waitForProposal: async () => {
+        await asyncRetry({interval, times}, async () => {
+          const {requests} = await getCapacityChangeRequests({
+            lnd: target.lnd,
+          });
+
+          if (!requests.length) {
+            throw new Error('FailedToFindChangeRequest');
+          }
+        });
+      },
+
+      // Accept the channel
+      accept: ['waitForProposal', async ({}) => {
+        await changeChannelCapacity({
+          ask: (args, cbk) => {
+            if (args.name === 'accept') {
+              return cbk({accept: true});
+            }
+
+            if (args.name === 'ok') {
+              return cbk({ok: true});
+            }
+
+            throw new Error('UnexpectedQueryForAcceptingPeer');
+          },
+          lnd: target.lnd,
+          logger: {error: log, info: log},
+          nodes: [],
+        });
+      }],
+
+      // Generate to confirm the change
+      generate: ['waitForProposal', async ({}) => {
+        // Wait for the new channel to be active
+        const recreated = await asyncRetry({
+          times,
+          interval: slow,
+        },
+        async () => {
+          const {channels} = await getChannels({
+            lnd: target.lnd,
+            is_active: true,
+          });
+
+          const [channel] = channels.filter(n => n.capacity < capacity);
+
+          await generate({});
+
+          if (!channel) {
+            throw new Error('ExpectedChannelActivation');
+          }
+
+          equal(channel.partner_public_key, remote.id, 'Channel is moved');
+
+          {
+            const {policies} = await getChannel({
+              lnd: remote.lnd,
+              id: channel.id,
+            });
+
+            const noPolicy = policies.find(n => !n.cltv_delta);
+
+            if (!!noPolicy) {
+              throw new Error('ExpectedChannelPolicy');
+            }
+          }
+
+          {
+            const {policies} = await getChannel({
+              id: channel.id,
+              lnd: target.lnd,
+            });
+
+            const noPolicy = policies.find(n => !n.cltv_delta);
+
+            if (!!noPolicy) {
+              throw new Error('ExpectedChannelPolicy');
+            }
+          }
+
+          return;
+        });
+      }],
+    });
+  } catch (err) {
+    strictSame(err, null, 'Expected no failure');
+  } finally {
+    await kill({});
+  }
+
+  return end();
+});

package/test/integration/test_split_channel_capacity.js

@@ -141,6 +141,7 @@ test(`Decrease capacity replacement`, async ({end, equal, strictSame}) => {
 
             throw new Error('UnexpectedQueryNameForProposingSide');
           },
+          nodes: [],
         });
       },
 
@@ -173,6 +174,7 @@ test(`Decrease capacity replacement`, async ({end, equal, strictSame}) => {
             throw new Error('UnexpectedQueryNameForAcceptingSide');
           },
           lnd: target.lnd,
+          nodes: [],
         });
       }],