paid-services 3.2.0 → 3.3.0

package/capacity/ask_for_change_details.js

@@ -0,0 +1,505 @@
+const asyncAuto = require('async/auto');
+const asyncUntil = require('async/until');
+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 {getPeers} = require('ln-service');
+const {returnResult} = require('asyncjs-util');
+const {sendMessageToPeer} = require('ln-service');
+
+const askForDecrease = require('./ask_for_decrease');
+const encodeChangeRequest = require('./encode_change_request');
+const feeForReplacement = require('./fee_for_replacement');
+
+const {ceil} = Math;
+const dust = 550;
+const dustBuffer = 750;
+const isNumber = n => !isNaN(n);
+const largeChannelsBit = 19;
+const maxSats = 21e6 * 1e8;
+const maxSize = 16777215;
+const minNewLocalBalance = 0;
+const nonNegative = n => Math.max(0, n);
+const outputSize = 44;
+const positive = n => Math.max(1, n);
+const slowTarget = 1000;
+const sumOf = arr => arr.reduce((sum, n) => sum + n, 0);
+const sumOfTokens = arr => arr.reduce((sum, n) => sum + n.tokens, 0);
+const testMessage = '00';
+const tokensAsBigUnit = tokens => (tokens / 1e8).toFixed(8);
+const weightAsVBytes = n => n / 4;
+const weightBuffer = 150;
+
+/** Ask for change details
+
+  {
+    ask: <Ask Function>
+    id: <Request Identifier Hex String>
+    lnd: <Authenticated LND API Object>
+  }
+
+  @returns via cbk or Promise
+  {
+    base_fee_mtokens: <Base Fee Millitokens String>
+    cltv_delta: <Locktime Delta Number>
+    coop_close_address: <Cooperative Close Address String>
+    decrease: [{
+      address: <Decrease Address String>
+      output: <Output Script Hex String>
+      tokens: <Decrease Tokens Number>
+    }]
+    estimated_capacity: <Estimated Tokens For New Channel Capacity Number>
+    estimated_local_delta: <Estimated Local Balance Delta Tokens Number>
+    fee_rate: <Fees Charged in Millitokens Per Million Number>
+    id: <Standard Format Channel Id String>
+    increase: <Channel Capacity Increase Tokens Number>
+    is_private: <Channel is Private Bool>
+    [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>
+    records: [{
+      type: <Change Record Type Number String>
+      value: <Change Record Value Hex Encoded String>
+    }]
+    remote_balance: <Peer Balance Tokens Number>
+    transaction_id: <Channel Funding Transaction Id Hex String>
+  }
+*/
+module.exports = ({ask, id, lnd}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!ask) {
+          return cbk([400, 'ExpectedAskFunctionToAskForChangeDetails']);
+        }
+
+        if (!id) {
+          return cbk([400, 'ExpectedRequestIdentifierToAskForChangeDetails']);
+        }
+
+        if (!lnd) {
+          return cbk([400, 'ExpectedLndToAskForChangeDetails']);
+        }
+
+        return cbk();
+      },
+
+      // Select peer to adjust
+      askForPeer: ['validate', ({}, cbk) => {
+        return ask({
+          name: 'query',
+          message: 'Public key or alias of peer to change capacity with?',
+          type: 'input',
+          validate: input => !!input,
+        },
+        ({query}) => cbk(null, query));
+      }],
+
+      // Get channels to use to lookup a public key for a peer
+      getChannels: ['validate', ({}, cbk) => getChannels({lnd}, cbk)],
+
+      // Get feature info for peers to figure out maximum channel size
+      getFeatures: ['validate', ({}, cbk) => getPeers({lnd}, cbk)],
+
+      // Get the chain fee rate
+      getFeeRate: ['validate', ({}, cbk) => {
+        return getChainFeeRate({lnd, confirmation_target: slowTarget}, cbk);
+      }],
+
+      // Find the public key or alias entered
+      findKey: [
+        'askForPeer',
+        'getChannels',
+        ({askForPeer, getChannels}, cbk) =>
+      {
+        return findKey({
+          lnd,
+          channels: getChannels.channels,
+          query: askForPeer,
+        },
+        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 => {
+          return channel.partner_public_key === findKey.public_key;
+        });
+
+        if (!hasPeer) {
+          return cbk([400, 'UnknownPeerToChangeChannelCapacityWith']);
+        }
+
+        return sendMessageToPeer({
+          lnd,
+          message: testMessage,
+          public_key: findKey.public_key,
+        },
+        err => {
+          if (!!err) {
+            return cbk([503, 'CannotCommunicateWithSelectedPeer', {err}]);
+          }
+
+          return cbk();
+        });
+      }],
+
+      // Select a channel to adjust when there are multiple choices
+      askForChannel: [
+        'findKey',
+        'getChannels',
+        'testPeer',
+        ({findKey, getChannels}, cbk) =>
+      {
+        const channelsForPeer = getChannels.channels.filter(channel => {
+          return channel.partner_public_key === findKey.public_key;
+        });
+
+        const [channel, more] = channelsForPeer;
+
+        // Exit early when there is only one channel, no need to ask
+        if (!more) {
+          return cbk(null, channel.id);
+        }
+
+        const choices = channelsForPeer.map(channel => {
+          // Do not allow changes on inactive or coop close locked channels
+          const disabled = [
+            !!channel.cooperative_close_address,
+            !channel.is_active,
+          ];
+
+          return {
+            disabled: !!disabled.filter(n => !!n).length,
+            name: `${channel.id}: ${tokensAsBigUnit(channel.capacity)}`,
+            value: channel.id,
+          };
+        });
+
+        if (!choices.filter(n => !n.disabled).length) {
+          return cbk([400, 'NoSuitableChannelsToChangeCapacity']);
+        }
+
+        return ask({
+          choices,
+          loop: false,
+          message: 'Channel to change capacity?',
+          name: 'id',
+          type: 'list',
+        },
+        ({id}) => cbk(null, id));
+      }],
+
+      // Get the channel policy info
+      getPolicy: ['askForChannel', ({askForChannel}, cbk) => {
+        return getChannel({lnd, id: askForChannel}, cbk);
+      }],
+
+      // Get chain transactions
+      getTx: ['askForChannel', ({askForChannel}, cbk) => {
+        return getChainTransactions({lnd}, cbk);
+      }],
+
+      // Details of the channel to change capacity with
+      channel: [
+        'askForChannel',
+        'findKey',
+        'getChannels',
+        'getFeatures',
+        'getFeeRate',
+        'getPolicy',
+        'getTx',
+        ({
+          askForChannel,
+          findKey,
+          getChannels,
+          getFeatures,
+          getFeeRate,
+          getPolicy,
+          getTx,
+        },
+        cbk) =>
+      {
+        const feeRate = getFeeRate.tokens_per_vbyte;
+        const id = askForChannel;
+        const peerKey = findKey.public_key;
+
+        const channel = getChannels.channels.find(n => n.id === id);
+
+        // Do not allow selecting channels that are in use
+        if (channel.pending_payments.length) {
+          return cbk([400, 'ChannelHasPendingPayments']);
+        }
+
+        const peer = getFeatures.peers.find(n => n.public_key === peerKey);
+
+        // The peer must be connected
+        if (!peer) {
+          return cbk([503, 'FailedToFindConnectedPeer']);
+        }
+
+        const policy = getPolicy.policies.find(n => n.public_key === peerKey);
+
+        // A routing policy must be known so that it can be reset later
+        if (!policy || !policy.cltv_delta) {
+          return cbk([503, 'CannotFindChannelRoutingPolicyDetails']);
+        }
+
+        const openTx = getTx.transactions.find(tx => {
+          return tx.id === channel.transaction_id;
+        });
+
+        // A peer that disallows large channels limits the increase allowable
+        const isLarge = peer.features.find(n => n.bit === largeChannelsBit);
+
+        // When decreasing, cannot decrease more than there are fund available
+        const maxDecreaseTokens = nonNegative(sumOf([
+          -channel.commit_transaction_fee,
+          -ceil(weightAsVBytes(weightBuffer) * feeRate),
+          -ceil(weightAsVBytes(channel.commit_transaction_weight) * feeRate),
+          channel.local_balance,
+          -dustBuffer,
+        ]));
+
+        // When increasing, cannot increase more than the peer supports
+        const maxIncrease = !!isLarge ? maxSats : maxSize - channel.capacity;
+
+        return cbk(null, {
+          base_fee_mtokens: policy.base_fee_mtokens,
+          capacity: channel.capacity,
+          cltv_delta: policy.cltv_delta,
+          commit_transaction_fee: channel.commit_transaction_fee,
+          commit_transaction_weight: channel.commit_transaction_weight,
+          coop_close_address: channel.cooperative_close_address,
+          fee_rate: policy.fee_rate,
+          id: channel.id,
+          is_private: channel.is_private,
+          local_balance: channel.local_balance,
+          open_transaction: !!openTx ? openTx.transaction : undefined,
+          max_decrease_tokens: maxDecreaseTokens,
+          max_increase_tokens: nonNegative(maxIncrease),
+          partner_public_key: channel.partner_public_key,
+          remote_balance: channel.remote_balance,
+          remote_csv: channel.remote_csv,
+          transaction_id: channel.transaction_id,
+          transaction_vout: channel.transaction_vout,
+        });
+      }],
+
+      // Choose whether to add or remove coins
+      askForDirection: ['channel', ({channel}, cbk) => {
+        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',
+            },
+          ],
+          message: 'How do you want to change the channel capacity?',
+          name: 'direction',
+          type: 'list',
+        },
+        ({direction}) => cbk(null, direction));
+      }],
+
+      // Ask for how much to decrease
+      askForDecrease: [
+        'askForDirection',
+        'channel',
+        ({askForDirection, channel}, cbk) =>
+      {
+        // Exit early when funds are being added
+        if (askForDirection !== 'decrease') {
+          return cbk();
+        }
+
+        const decreases = [];
+        const maximum = channel.max_decrease_tokens;
+
+        if (!maximum) {
+          return cbk([400, 'ChannelLocalBalanceTooLowToDecrease']);
+        }
+
+        return asyncUntil(
+          cbk => cbk(null, !!decreases.find(n => n.is_final)),
+          cbk => {
+            return askForDecrease({
+              ask,
+              lnd,
+              max: maximum - sumOf(decreases.map(n => n.tokens + outputSize)),
+            },
+            (err, res) => {
+              if (!!err) {
+                return cbk(err);
+              }
+
+              if (decreases.find(n => n.address === res.address)) {
+                return cbk([400, 'ExpectedUniqueAddressForSpend']);
+              }
+
+              return cbk(null, decreases.push(res));
+            });
+          },
+          err => {
+            if (!!err) {
+              return cbk(err);
+            }
+
+            const final = decreases
+              .filter(n => !!n.tokens)
+              .map(({address, output, tokens}) => ({address, output, tokens}));
+
+            return cbk(null, final);
+          }
+        );
+      }],
+
+      // Ask to see how much to add to the channel
+      askForIncrease: [
+        'askForDirection',
+        'channel',
+        ({askForDirection, channel}, cbk) =>
+      {
+        // Exit early when funds are being added
+        if (askForDirection !== 'increase') {
+          return cbk();
+        }
+
+        const balance = channel.local_balance;
+
+        return ask({
+          name: 'amount',
+          message: `Amount to add?`,
+          type: 'input',
+          validate: input => {
+            if (!isNumber(input) || !Number.isInteger(Number(input))) {
+              return false;
+            }
+
+            if (!!Number(input) && Number(input) < dust) {
+              return false;
+            }
+
+            return true;
+          },
+        },
+        ({amount}) => cbk(null, Number(amount)));
+      }],
+
+      // Estimate the chain fee
+      estimateChainFee: [
+        'askForDecrease',
+        'askForIncrease',
+        'channel',
+        'getFeeRate',
+        ({askForDecrease, askForIncrease, channel, getFeeRate}, cbk) =>
+      {
+        const {fee} = feeForReplacement({
+          capacity: channel.capacity,
+          commit_transaction_fee: channel.commit_transaction_fee,
+          commit_transaction_weight: channel.commit_transaction_weight,
+          decrease: askForDecrease || [],
+          increase: askForIncrease || undefined,
+          tokens_per_vbyte: getFeeRate.tokens_per_vbyte,
+        });
+
+        return cbk(null, {fee});
+      }],
+
+      // Confirm chain fee payment estimate
+      confirmFeeEstimate: [
+        'channel',
+        'estimateChainFee',
+        ({channel, estimateChainFee}, 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?`,
+        },
+        ({proceed}) => cbk(null, proceed));
+      }],
+
+      // Final capacity change details
+      details: [
+        'askForDecrease',
+        'askForIncrease',
+        'channel',
+        'confirmFeeEstimate',
+        'estimateChainFee',
+        'getTx',
+        ({
+          askForDecrease,
+          askForIncrease,
+          channel,
+          confirmFeeEstimate,
+          estimateChainFee,
+          getTx,
+        },
+        cbk) =>
+      {
+        if (!confirmFeeEstimate) {
+          return cbk([400, 'RejectedCapacityChangeDueToFeeEstimate']);
+        }
+
+        // Estimate how much local balance will be adjusted down
+        const estimatedLocalDelta = sumOf([
+          -sumOfTokens(askForDecrease || []),
+          askForIncrease || Number(),
+          -estimateChainFee.fee,
+        ]);
+
+        // The new capacity is the old one with decreases/increases, minus fee
+        const estimatedNewCapacity = sumOf([
+          channel.capacity,
+          estimatedLocalDelta,
+        ]);
+
+        if (channel.local_balance + estimatedLocalDelta < minNewLocalBalance) {
+          return cbk([400, 'InsufficientFundsToChangeChannelCapacity']);
+        }
+
+        // The change will be communicated in change records
+        const {records} = encodeChangeRequest({
+          id,
+          channel: channel.id,
+          decrease: !!askForDecrease ? sumOfTokens(askForDecrease) : undefined,
+          increase: askForIncrease,
+        });
+
+        return cbk(null, {
+          records,
+          base_fee_mtokens: channel.base_fee_mtokens,
+          cltv_delta: channel.cltv_delta,
+          coop_close_address: channel.coop_close_address,
+          decrease: askForDecrease || [],
+          estimated_capacity: estimatedNewCapacity,
+          estimated_local_delta: estimatedLocalDelta,
+          fee_rate: channel.fee_rate,
+          id: channel.id,
+          increase: askForIncrease,
+          is_private: channel.is_private,
+          open_transaction: channel.open_transaction,
+          partner_csv_delay: channel.partner_csv_delay,
+          partner_public_key: channel.partner_public_key,
+          remote_balance: channel.remote_balance,
+          transaction_id: channel.transaction_id,
+        });
+      }],
+    },
+    returnResult({reject, resolve, of: 'details'}, cbk));
+  });
+};

package/capacity/ask_for_decrease.js

@@ -0,0 +1,185 @@
+const {address} = require('bitcoinjs-lib');
+const asyncAuto = require('async/auto');
+const {createChainAddress} = require('ln-service');
+const {getNetwork} = require('ln-sync');
+const {networks} = require('bitcoinjs-lib');
+const {returnResult} = require('asyncjs-util');
+
+const bufferAsHex = buffer => buffer.toString('hex');
+const dust = 550;
+const isNumber = n => !isNaN(n);
+const {toOutputScript} = address;
+
+/** Ask for details about a decrease
+
+  {
+    ask: <Ask Function>
+    lnd: <Authenticated LND API Object>
+    max: <Maximum Possible Decrease Number>
+  }
+
+  @returns via cbk or Promise
+  {
+    [address]: <Send Funds to Address String>
+    is_final: <Decrease is Final Decrease Bool>
+    [output]: <Output Script Hex String>
+    tokens: <Withdraw Tokens Number>
+  }
+*/
+module.exports = ({ask, lnd, max}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!ask) {
+          return cbk([400, 'ExpectedAskFunctionToAskForDecrease']);
+        }
+
+        if (!lnd) {
+          return cbk([400, 'ExpectedAuthenticatedLndToAskForDecrease']);
+        }
+
+        if (!max) {
+          return cbk([400, 'ExpectedMaximumAvaialbleTok'])
+        }
+
+        return cbk();
+      },
+
+      // Ask for the amount to decrease
+      askForAmount: ['validate', ({}, cbk) => {
+        return ask({
+          default: '0',
+          name: 'amount',
+          message: `How much do you want to spend out (max: ${max})?`,
+          type: 'input',
+          validate: input => {
+            if (!isNumber(input) || !Number.isInteger(Number(input))) {
+              return false;
+            }
+
+            if (!!Number(input) && Number(input) < dust) {
+              return false;
+            }
+
+            if (!!Number(input) && Number(input) > max) {
+              return `The maximum possible to decrease is ${max}`;
+            }
+
+            return true;
+          },
+        },
+        ({amount}) => cbk(null, amount));
+      }],
+
+      // Get network name
+      getNetwork: ['validate', ({}, cbk) => getNetwork({lnd}, cbk)],
+
+      // Ask if withdrawing to an external address
+      askForExternal: ['askForAmount', ({askForAmount}, cbk) => {
+        if (!Number(askForAmount)) {
+          return cbk();
+        }
+
+        return ask({
+          default: false,
+          name: 'spend',
+          message: `Spend ${askForAmount} to an external address?`,
+          type: 'confirm',
+        },
+        ({spend}) => cbk(null, spend));
+      }],
+
+      // Ask for an external address
+      askForAddress: [
+        'askForAmount',
+        'askForExternal',
+        ({askForAmount, askForExternal}, cbk) =>
+      {
+        // Exit early when the withdraw address is internal
+        if (askForExternal !== true) {
+          return cbk();
+        }
+
+        return ask({
+          name: 'address',
+          message: `Address to spend ${askForAmount} to?`,
+          type: 'input',
+          validate: input => !!input,
+        },
+        ({address}) => cbk(null, {address}));
+      }],
+
+      // Ask if this is the last output
+      askForAddition: [
+        'askForAddress',
+        'askForExternal',
+        ({askForExternal}, cbk) =>
+      {
+        // Exit early when the spend was to an internal addess
+        if (!askForExternal) {
+          return cbk();
+        }
+
+        return ask({
+          default: false,
+          name: 'add',
+          message: 'Add another spend to a different address?',
+          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) {
+          return cbk();
+        }
+
+        return createChainAddress({lnd}, cbk);
+      }],
+
+      // Final decrease output details
+      decrease: [
+        'askForAddition',
+        'askForAddress',
+        'askForAmount',
+        'createAddress',
+        'getNetwork',
+        ({
+          askForAddition,
+          askForAddress,
+          askForAmount,
+          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 the address is valid
+        try {
+          toOutputScript(address, networks[getNetwork.bitcoinjs]);
+        } catch (err) {
+          return cbk([400, 'FailedToParseAddress', {err}]);
+        }
+
+        const output = toOutputScript(address, networks[getNetwork.bitcoinjs]);
+
+        return cbk(null, {
+          address,
+          is_final: !askForAddition,
+          output: bufferAsHex(output),
+          tokens: Number(askForAmount),
+        });
+      }],
+    },
+    returnResult({reject, resolve, of: 'decrease'}, cbk));
+  });
+};