paid-services 3.1.2 → 3.5.0

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));
+  });
+};

package/capacity/assemble_replacement_tx.js

@@ -0,0 +1,171 @@
+const {address} = require('bitcoinjs-lib');
+const {networks} = require('bitcoinjs-lib');
+const {Transaction} = require('bitcoinjs-lib');
+
+const isOpenWitnessScript = require('./is_open_witness_script');
+
+const bufferAsHex = buffer => buffer.toString('hex');
+const {fromHex} = Transaction;
+const hashFromTxId = id => Buffer.from(id, 'hex').reverse();
+const hexAsBuffer = hex => Buffer.from(hex, 'hex');
+const {isArray} = Array;
+const sequence = 0;
+const {toOutputScript} = address;
+
+/** Put together the replacement transaction
+
+  {
+    [add_funds_transaction_id]: <Add Funds Transaction Id Hex String>
+    [add_funds_transaction_vout]: <Add Funds Transaction Output Index Number>
+    bitcoinjs_network: <BitcoinJs Network Name String>
+    close_transaction: <Force Closed Transaction Hex String>
+    decrease: [{
+      output: <Output Script Hex Encoded String>
+      tokens: <Decrease By Tokens Number>
+    }]
+    funding_address: <Replacement Channel Funding Address String>
+    funding_tokens: <Replacement Channel Funding Tokens Number>
+    transaction_id: <Original Channel Funding Transaction Id Hex String>
+    transaction_vout: <Original Channel Funding Output Index Number>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    [add_funds_vin]: <Add Funds Input Index>
+    transaction: <Unsigned Transaction Hex String>
+    transaction_id: <Transaction Id Hex String>
+    transaction_vin: <Input Index of Original Channel Spend Number>
+    transaction_vout: <Replacement Channel Transaction Output Index Number>
+  }
+*/
+module.exports = args => {
+  if (!args.bitcoinjs_network) {
+    throw new Error('ExpectedBitcoinJsNetworkNameToAssembleReplacementTx');
+  }
+
+  if (!args.close_transaction) {
+    throw new Error('ExpectedCloseTransactionToAssembleReplacementTx');
+  }
+
+  if (!isArray(args.decrease)) {
+    throw new Error('ExpectedArrayOfDecreasesToAssembleReplacementTx');
+  }
+
+  if (!args.funding_address) {
+    throw new Error('ExpectedFundingAddressToAssembleReplacementTx');
+  }
+
+  if (!args.funding_tokens) {
+    throw new Error('ExpectedFundingTokensToAssembleReplacementTx');
+  }
+
+  if (!args.transaction_id) {
+    throw new Error('ExpectedFundingTransactionIdToAssembleReplacementTx');
+  }
+
+  if (args.transaction_vout === undefined) {
+    throw new Error('ExpectedFundingTransactionVoutToAssembleReplacementTx');
+  }
+
+  const replacement = new Transaction();
+
+  // The replacement will spend the same input as the close transaction
+  const [{witness}, secondInput] = fromHex(args.close_transaction).ins;
+
+  // Confirm that the witness stack is a 2:2
+  if (!isOpenWitnessScript({script: bufferAsHex(witness.slice().pop())})) {
+    throw new Error('ExpectedMultiSigWitnessInCloseTransaction');
+  }
+
+  if (!!secondInput) {
+    throw new Error('ExpectedOnlySingleInputForCloseTransaction');
+  }
+
+  // The replacement will spend the funding outpoint
+  const hash = hashFromTxId(args.transaction_id);
+  const index = args.transaction_vout;
+
+  // The new channel multi-sig will be the replacement output
+  const network = networks[args.bitcoinjs_network];
+
+  // The replacement spends to the channel funding output
+  const fundingOutput = {
+    script: toOutputScript(args.funding_address, network),
+    tokens: args.funding_tokens,
+  };
+
+  // There can also be other outputs attached
+  const decreaseOutputs = args.decrease.map(({output, tokens}) => ({
+    tokens,
+    script: hexAsBuffer(output),
+  }));
+
+  const outputs = [].concat(decreaseOutputs).concat(fundingOutput);
+
+  // Sort outputs by BIP 69
+  outputs.sort((a, b) => {
+    // Sort by tokens ascending when no tie breaker needed
+    if (a.tokens !== b.tokens) {
+      return a.tokens - b.tokens;
+    }
+
+    // Otherwise compare output scripts lexicographically ascending
+    return a.script.compare(b.script);
+  });
+
+  const respendOutputIndex = outputs.findIndex(out => {
+    return out.script.equals(fundingOutput.script);
+  });
+
+  // Add the outputs to the replacement transaction
+  outputs.forEach(({script, tokens}) => replacement.addOutput(script, tokens));
+
+  // Exit early when not adding more inputs to the transaction
+  if (!args.add_funds_transaction_id) {
+    replacement.addInput(hash, index, sequence);
+
+    return {
+      transaction: replacement.toHex(),
+      transaction_id: replacement.getId(),
+      transaction_vin: replacement.ins.findIndex(input => {
+        return input.hash.equals(hash) && input.index === index;
+      }),
+      transaction_vout: respendOutputIndex,
+    };
+  }
+
+  // An additional input needs to be added when adding funds
+  const add = {
+    hash: hashFromTxId(args.add_funds_transaction_id),
+    index: args.add_funds_transaction_vout,
+  };
+
+  // Adding funds means spending the channel output plus the transit one
+  const spends = [{hash, index}, add];
+
+  // Sort the spending inputs for BIP 69
+  spends.sort((a, b) => {
+    const aHash = bufferAsHex(a.hash);
+    const bHash = bufferAsHex(b.hash);
+
+    return aHash.localeCompare(bHash) || a.index - b.index;
+  });
+
+  // Add the spends as inputs to the replacement tx
+  spends.forEach(({hash, index}) => replacement.addInput(hash, index));
+
+  return {
+    add_funds_vin: replacement.ins.findIndex(input => {
+      return input.hash.equals(add.hash) && input.index === add.index;
+    }),
+    transaction: replacement.toHex(),
+    transaction_id: replacement.getId(),
+    transaction_vin: replacement.ins.findIndex(input => {
+      return input.hash.equals(hash) && input.index === index;
+    }),
+    transaction_vout: respendOutputIndex,
+  };
+};

package/capacity/capacity_change_requests.js

@@ -0,0 +1,85 @@
+const privateAsType = isPrivate => isPrivate ? 1 : 0;
+
+/** Map change requests to requests considering local channels
+
+  {
+    channels: [{
+      capacity: <Channel Capacity Number>
+      [cooperative_close_address]: <Cooperative Close Locked Address String>
+      id: <Standard Format Channel Id String>
+      partner_public_key: <Peer Public Key Hex String>
+    }]
+    requests: [{
+      channel: <Standard Format Channel Id String>
+      [decrease]: <Reduce Capacity Tokens Number>
+      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>
+    }]
+  }
+
+  @returns
+  {
+    requests: [{
+      [address]: <Cooperative Close Address String>
+      capacity: <Channel Capacity Tokens Number>
+      channel: <Standard Format Channel Id String>
+      [decrease]: <Reduce Capacity Tokens Number>
+      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>
+    }]
+  }
+*/
+module.exports = ({channels, requests}) => {
+  // Change requests can only come from channels with the messaging peer
+  const capacityChangeRequests = requests.filter(request => {
+    const channel = channels.find(chan => chan.id === request.channel);
+
+    // Ignore requests from channels that aren't present
+    if (!channel) {
+      return false;
+    }
+
+    // The change request must come from the peer in the channel
+    return channel.partner_public_key === request.from;
+  });
+
+  const existing = {};
+
+  // Only consider one change request per channel
+  const changeRequests = capacityChangeRequests
+    .filter(({channel}) => {
+      // Exit early when the channel already has a change request
+      if (!!existing[channel]) {
+        return false;
+      }
+
+      // Do not allow more requests for this channel
+      existing[channel] = true;
+
+      return true;
+    })
+    .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,
+        channel: channel.id,
+        decrease: request.decrease,
+        from: channel.partner_public_key,
+        id: request.id,
+        increase: request.increase,
+        type: type ? request.type : undefined,
+      };
+    });
+
+  return {requests: changeRequests};
+};

package/capacity/change_channel_capacity.js

@@ -0,0 +1,189 @@
+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 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;
+const tokensAsBigUnit = tokens => (tokens / 1e8).toFixed(8);
+const waitForCloseInterval = 1000 * 3;
+
+/** Change a channel's capacity
+
+  {
+    ask: <Ask Function>
+    [delay]: <Wait Time For Incoming Capacity Requests Milliseconds Number>
+    lnd: <Authenticated LND API Object>
+    logger: <Winston Logger Object>
+  }
+*/
+module.exports = ({ask, delay, lnd, logger}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!ask) {
+          return cbk([400, 'ExpectedAskFunctionToChangeCapacity']);
+        }
+
+        if (!lnd) {
+          return cbk([400, 'ExpectedLndToChangeCapacity']);
+        }
+
+        if (!logger) {
+          return cbk([400, 'ExpectedLoggerObjectToChangeCapacity']);
+        }
+
+        return cbk();
+      },
+
+      // Ask to confirm what will happen in a change capacity
+      askToConfirm: ['validate', ({}, cbk) => {
+        const details = [
+          'This is experimental. Channels may force-close instead of change.',
+          'Adding funds currently requires an extra confirmation wait.',
+          'Chain fees will be deducted from the changed capacity total.',
+          'Chain fees will be paid from the initiator local balance.',
+          'Forwards with the peer will be halted during capacity change.',
+        ];
+
+        // Show the warnings
+        logger.info({details});
+
+        return ask({type: 'confirm', name: 'ok', message: 'OK?'}, ({ok}) => {
+          if (!ok) {
+            return cbk([400, 'CanceledChannelCapacityChange']);
+          }
+
+          return cbk();
+        });
+      }],
+
+      // Get the public key of this node
+      getIdentity: ['validate', ({}, cbk) => getIdentity({lnd}, cbk)],
+
+      // Wait for an incoming capacity change request
+      waitForProposal: ['validate', ({}, cbk) => {
+        return getCapacityChangeRequests({delay, lnd}, cbk);
+      }],
+
+      // Ask for acceptance of a channel
+      askToSelectChange: [
+        'askToConfirm',
+        'waitForProposal',
+        ({waitForProposal}, cbk) =>
+      {
+        return asyncDetectSeries(waitForProposal.requests, (request, cbk) => {
+          return getNodeAlias({lnd, id: request.from}, (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);
+            });
+          });
+        },
+        cbk);
+      }],
+
+      // Accept a capacity change proposal
+      acceptChange: ['askToSelectChange', ({askToSelectChange}, cbk) => {
+        // Exit early when there is no change proposal to accept
+        if (!askToSelectChange) {
+          return cbk();
+        }
+
+        return acceptCapacityChange({
+          lnd,
+          logger,
+          channel: askToSelectChange.channel,
+          from: askToSelectChange.from,
+          id: askToSelectChange.id,
+          increase: askToSelectChange.increase,
+        },
+        cbk);
+      }],
+
+      // Initiate a capacity change
+      initiateChange: ['askToSelectChange', ({askToSelectChange}, cbk) => {
+        if (!!askToSelectChange) {
+          return cbk();
+        }
+
+        return initiateCapacityChange({ask, lnd, logger}, cbk);
+      }],
+
+      // Reset the channel routing policies
+      adjustPolicy: [
+        'acceptChange',
+        'getIdentity',
+        'initiateChange',
+        ({acceptChange, getIdentity, initiateChange}, cbk) =>
+      {
+        const policy = acceptChange || initiateChange;
+
+        logger.info({restoring_routing_policy: true});
+
+        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,
+            transaction_id: policy.transaction_id,
+            transaction_vout: policy.transaction_vout,
+          },
+          cbk);
+        },
+        cbk);
+      }],
+
+      // Capacity change complete
+      complete: ['adjustPolicy', ({}, cbk) => {
+        logger.info({channel_capacity_successfully_changed: true});
+
+        return cbk();
+      }],
+    },
+    returnResult({reject, resolve}, cbk));
+  });
+};

package/capacity/encode_change_request.js

@@ -0,0 +1,62 @@
+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
+
+  {
+    channel: <Channel to Change Standard Format Id String>
+    [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
+  {
+    records: [{
+      type: <Record Type Number String>
+      value: <Record Value Hex Encoded String>
+    }]
+  }
+*/
+module.exports = ({channel, decrease, id, increase, type}) => {
+  const records = [
+    {
+      type: requestIdRecordType,
+      value: id,
+    },
+    {
+      type: channelIdRecordType,
+      value: rawChanId({channel}).id,
+    },
+    {
+      type: channelFlagsType,
+      value: typeAsHex(type),
+    },
+  ];
+
+  if (!!decrease) {
+    // Add a record reflecting the decrease in the capacity
+    records.push({
+      type: decreaseRecordType,
+      value: encodeBigSize({number: decrease.toString()}).encoded,
+    });
+  }
+
+  if (!!increase) {
+    // Add a record reflecting the increase in the capacity
+    records.push({
+      type: increaseRecordType,
+      value: encodeBigSize({number: increase.toString()}).encoded,
+    });
+  }
+
+  return {records};
+};