paid-services 3.4.0 → 3.7.0

package/.prettierignore

@@ -0,0 +1,2 @@
+bos
+*.js

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # 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
+- `manageTrades`: Add expiration dates to open trades
+- `manageTrades`: Support longer-lived open trade scenarios
+- `manageTrades`: Show final encoded trade when requesting open trade
+- `manageTrades`: Check for RPC signer support before trading
+
+## Version 3.5.1
+
+- `changeChannelCapacity`: Allow changing private/public status of channel
+
 ## Version 3.4.0
 
 - `changeChannelCapacity`: Fix broken preservation of channel announce status

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

@@ -24,6 +24,8 @@ const minNewLocalBalance = 0;
 const nonNegative = n => Math.max(0, n);
 const outputSize = 44;
 const positive = n => Math.max(1, n);
+const privateType = 1;
+const publicType = 0;
 const slowTarget = 1000;
 const sumOf = arr => arr.reduce((sum, n) => sum + n, 0);
 const sumOfTokens = arr => arr.reduce((sum, n) => sum + n.tokens, 0);
@@ -46,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>
@@ -170,6 +173,7 @@ module.exports = ({ask, id, lnd}, cbk) => {
           const disabled = [
             !!channel.cooperative_close_address,
             !channel.is_active,
+            !!channel.pending_payments.length,
           ];
 
           return {
@@ -342,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']);
               }
 
@@ -354,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));
           }
         );
       }],
@@ -395,10 +396,37 @@ module.exports = ({ask, id, lnd}, cbk) => {
         ({amount}) => cbk(null, Number(amount)));
       }],
 
+      // Confirm or change the announce status of the replacement channel
+      askForPublicPrivate: [
+        'askForDecrease',
+        'askForIncrease',
+        'channel',
+        ({channel}, cbk) =>
+      {
+        return ask({
+          choices: ['Public', 'Private'].map(type => {
+            const isPrivate = type === 'Private';
+
+            // Exit early when the type would be different
+            if (isPrivate !== channel.is_private) {
+              return type;
+            }
+
+            return `${type} (keep current status)`;
+          }),
+          default: channel.is_private ? 'Private' : 'Public',
+          message: 'Replacement channel type?',
+          name: 'type',
+          type: 'list',
+        },
+        ({type}) => cbk(null, {is_private: type === 'Private'}));
+      }],
+
       // Estimate the chain fee
       estimateChainFee: [
         'askForDecrease',
         'askForIncrease',
+        'askForPublicPrivate',
         'channel',
         'getFeeRate',
         ({askForDecrease, askForIncrease, channel, getFeeRate}, cbk) =>
@@ -417,6 +445,7 @@ module.exports = ({ask, id, lnd}, cbk) => {
 
       // Confirm chain fee payment estimate
       confirmFeeEstimate: [
+        'askForPublicPrivate',
         'channel',
         'estimateChainFee',
         ({channel, estimateChainFee}, cbk) =>
@@ -437,6 +466,7 @@ module.exports = ({ask, id, lnd}, cbk) => {
       details: [
         'askForDecrease',
         'askForIncrease',
+        'askForPublicPrivate',
         'channel',
         'confirmFeeEstimate',
         'estimateChainFee',
@@ -444,6 +474,7 @@ module.exports = ({ask, id, lnd}, cbk) => {
         ({
           askForDecrease,
           askForIncrease,
+          askForPublicPrivate,
           channel,
           confirmFeeEstimate,
           estimateChainFee,
@@ -478,6 +509,7 @@ module.exports = ({ask, id, lnd}, cbk) => {
           channel: channel.id,
           decrease: !!askForDecrease ? sumOfTokens(askForDecrease) : undefined,
           increase: askForIncrease,
+          type: askForPublicPrivate.is_private ? privateType : publicType,
         });
 
         return cbk(null, {
@@ -491,7 +523,7 @@ module.exports = ({ask, id, lnd}, cbk) => {
           fee_rate: channel.fee_rate,
           id: channel.id,
           increase: askForIncrease,
-          is_private: channel.is_private,
+          is_private: askForPublicPrivate.is_private,
           open_transaction: channel.open_transaction,
           partner_csv_delay: channel.partner_csv_delay,
           partner_public_key: channel.partner_public_key,

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/capacity_change_requests.js

@@ -1,3 +1,5 @@
+const privateAsType = isPrivate => isPrivate ? 1 : 0;
+
 /** Map change requests to requests considering local channels
 
   {
@@ -13,6 +15,7 @@
       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>
     }]
   }
 
@@ -26,6 +29,7 @@
       from: <From Node Public Key Id Hex String>
       id: <Change Request Id Hex String>
       [increase]: <Add Capacity Tokens Number>
+      [type]: <Change Channel Channel Type Flags Number>
     }]
   }
 */
@@ -61,6 +65,10 @@ module.exports = ({channels, requests}) => {
     .map(request => {
       const channel = channels.find(chan => chan.id === request.channel);
 
+      const currentType = privateAsType(channel.is_private);
+
+      const type = request.type !== undefined && request.type !== currentType;
+
       return {
         address: channel.cooperative_close_address,
         capacity: channel.capacity,
@@ -69,6 +77,7 @@ module.exports = ({channels, requests}) => {
         from: channel.partner_public_key,
         id: request.id,
         increase: request.increase,
+        type: type ? request.type : undefined,
       };
     });
 

package/capacity/change_channel_capacity.js

@@ -10,6 +10,7 @@ const acceptCapacityChange = require('./accept_capacity_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 times = 6 * 60 * 6;
@@ -89,17 +90,22 @@ module.exports = ({ask, delay, lnd, logger}, cbk) => {
 
             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}?`,
+              message: `${action} with ${peer}${by}${changeType}?`,
             },
             ({accept}) => {
               if (!accept) {

package/capacity/encode_change_request.js

@@ -1,10 +1,12 @@
 const {encodeBigSize} = require('bolt01');
 const {rawChanId} = require('bolt07');
 
+const channelFlagsType = '5';
 const channelIdRecordType = '2';
 const decreaseRecordType = '3';
 const increaseRecordType = '4';
 const requestIdRecordType = '1';
+const typeAsHex = type => Buffer.from([type]).toString('hex');
 
 /** Encode a request to change a channel capacity
 
@@ -13,6 +15,7 @@ const requestIdRecordType = '1';
     [decrease]: <Remove Channel Funds By Tokens Number>
     id: <Request Id Hex String>
     increase: <Add Channel Funds By Tokens Number>
+    type: <New Channel Type Number>
   }
 
   @returns
@@ -23,7 +26,7 @@ const requestIdRecordType = '1';
     }]
   }
 */
-module.exports = ({channel, decrease, id, increase}) => {
+module.exports = ({channel, decrease, id, increase, type}) => {
   const records = [
     {
       type: requestIdRecordType,
@@ -33,6 +36,10 @@ module.exports = ({channel, decrease, id, increase}) => {
       type: channelIdRecordType,
       value: rawChanId({channel}).id,
     },
+    {
+      type: channelFlagsType,
+      value: typeAsHex(type),
+    },
   ];
 
   if (!!decrease) {

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 = 150;
+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_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>
+      [type]: <Intended Replacement Channel Channel Type Flags Number>
     }]
   }
 */