paid-services 3.1.2 → 3.5.0

package/capacity/encode_sign_capacity_response.js

@@ -0,0 +1,32 @@
+const idType = '0';
+const capacityChangeSignatureType = '1';
+
+/** Encode the response to a sign capacity request
+
+  {
+    id: <Capacity Change Id Hex String>
+    signature: <Replacement Transaction Signature Hex String>
+  }
+
+  @returns
+  {
+    records: [{
+      type: <Record Type Number String>
+      value: <Record Value Hex Encoded String>
+    }]
+  }
+*/
+module.exports = ({id, signature}) => {
+  return {
+    records: [
+      {
+        type: idType,
+        value: id,
+      },
+      {
+        type: capacityChangeSignatureType,
+        value: signature,
+      },
+    ],
+  };
+};

package/capacity/fee_for_replacement.js

@@ -0,0 +1,108 @@
+const {Transaction} = require('bitcoinjs-lib');
+
+const {ceil} = Math;
+const decreaseBuffer = 44;
+const dummyHash = Buffer.alloc(32);
+const dummyIncreaseIndex = 1;
+const dummyIndex = 0;
+const dummyMultiSigScript = Buffer.alloc(71);
+const dummyNullDummy = Buffer.alloc(1);
+const dummyP2wsh = Buffer.alloc(68);
+const dummyPublicKey = Buffer.alloc(33);
+const dummySignature = Buffer.alloc(74);
+const dummyTokens = 0;
+const dummyVout = 0;
+const hexAsBuffer = hex => Buffer.from(hex, 'hex');
+const increaseBuffer = 150;
+const {max} = Math;
+const weightAsVBytes = weight => weight / 4;
+
+/** Calculate the chain fee required for the capacity replacement tx
+
+  {
+    capacity: <Original Channel Capacity Tokens Number>
+    commit_transaction_fee: <Commit Transaction Fee Tokens Number>
+    commit_transaction_weight: <Commit Transaction Weight Units Number>
+    decrease: [{
+      output: <Output Script Hex String>
+      tokens: <Spend Value to Chain Address Tokens Number>
+    }]
+    [increase]: <Add Funds Tokens Number>
+    tokens_per_vbyte: <Minimal Fee Rate Tokens Per VByte Number>
+  }
+
+  @returns
+  {
+    fee: <Estimated Replacement Chain Fee Tokens Number>
+  }
+*/
+module.exports = args => {
+  // The cost to close is also known as the commit fee
+  const closeTransactionFee = args.commit_transaction_fee;
+
+  // The commitment transaction size will have to be paid for
+  const replaceSize = weightAsVBytes(args.commit_transaction_weight);
+
+  // Calculate the rate that the commitment tx is paying
+  const commitRate = closeTransactionFee / replaceSize;
+
+  // Create a dummy transaction which models the replacement
+  const tx = new Transaction();
+
+  // Add the decreases as outputs
+  args.decrease.forEach(({output, tokens}) => {
+    return tx.addOutput(hexAsBuffer(output), 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);
+
+  // Spending a channel close requires both signatures
+  const dummyWitnessStack = [
+    dummyNullDummy,
+    dummySignature,
+    dummySignature,
+    dummyMultiSigScript,
+  ];
+
+  // Add a witness to the input
+  tx.setWitness(dummyIndex, dummyWitnessStack);
+
+  // An increase means that there is an additional input
+  if (!!args.increase) {
+    tx.addInput(dummyHash, dummyVout);
+
+    // Add funds input spends from transit, which means signature + public key
+    tx.setWitness(dummyIncreaseIndex, [dummySignature, dummyPublicKey]);
+  }
+
+  // Add additional size for an additional input
+  const inputBuffer = !!args.increase ? increaseBuffer : dummyTokens;
+
+  // Add additional size for additional outputs
+  const outputBuffer = args.decrease.length * decreaseBuffer;
+
+  // Now that we have all inputs and outputs we can measure the virtual bytes
+  const size = tx.virtualSize() + inputBuffer + outputBuffer;
+
+  // The fee for the replacement tx must be above a minimum
+  const minFee = ceil(size * commitRate);
+
+  // The base fee for replacement is the fee of the replacement
+  const baseFee = args.commit_transaction_fee;
+
+  // There is an additional fee which is a relay fee to pay for the replaced tx
+  const deltaFee = ceil(replaceSize * args.tokens_per_vbyte);
+
+  // The new tx pays either min replacement fee or the min overall relay fee
+  const fee = max(minFee, closeTransactionFee + deltaFee);
+
+  return {fee};
+};

package/capacity/finalize_capacity_replacement.js

@@ -0,0 +1,67 @@
+const {script} = require('bitcoinjs-lib');
+const {Transaction} = require('bitcoinjs-lib');
+
+const bufferAsHex = buffer => buffer.toString('hex');
+const {decompile} = script;
+const encodeSig = (n, flag) => Buffer.concat([Buffer.from(n, 'hex'), flag]);
+const {fromHex} = Transaction;
+const hexAsBuffer = hex => Buffer.from(hex, 'hex');
+const {isBuffer} = Buffer;
+const nullDummyStackItem = Buffer.alloc(0);
+const signatureFlag = Buffer.from([Transaction.SIGHASH_ALL]);
+
+/** Add signaturess to a capacity replacement transaction
+
+  {
+    [add_funds_vin]: <Add Funds Input Index>
+    [add_funds_public_key]: <Add Funds Transit Public Key Hex String>
+    [add_funds_signature]: <Add Funds Signature Hex String>
+    local_public_key: <Local MultiSig Public Key Hex String>
+    local_signature: <Local Replacement Signature Hex String>
+    funding_spend_vin: <Funding Transaction Output Spend Input Index Number>
+    remote_signature: <Peer Signature Hex String>
+    transaction: <Unsigned Replacement Transaction Hex String>
+    witness_script: <Funding Witness Script Hex Encoded String>
+  }
+
+  @returns
+  {
+    transaction: <Fully Signed Transaction Hex String>
+  }
+*/
+module.exports = args => {
+  const funding = hexAsBuffer(args.witness_script);
+  const tx = fromHex(args.transaction);
+
+  const keys = decompile(funding).filter(isBuffer).map(bufferAsHex);
+
+  const signatures = [,];
+
+  // Find the indices to place the signatures
+  const localKeyIndex = keys.findIndex(n => n === args.local_public_key);
+  const remoteKeyIndex = keys.findIndex(n => n !== args.local_public_key);
+
+  // Add the local signature to the funding witness stack
+  signatures[localKeyIndex] = encodeSig(args.local_signature, signatureFlag);
+
+  // Add the remote signature to the funding witness stack
+  signatures[remoteKeyIndex] = encodeSig(args.remote_signature, signatureFlag);
+
+  const witness = []
+    .concat([nullDummyStackItem])
+    .concat(signatures)
+    .concat([funding]);
+
+  // Fill in the witness stack including the close spend
+  tx.setWitness(args.funding_spend_vin, witness);
+
+  // The increase in funds also needs a signature added
+  if (!!args.add_funds_signature) {
+    tx.setWitness(args.add_funds_vin, [
+      encodeSig(args.add_funds_signature, signatureFlag),
+      hexAsBuffer(args.add_funds_public_key),
+    ]);
+  }
+
+  return {transaction: tx.toHex()};
+};

package/capacity/get_capacity_change_requests.js

@@ -0,0 +1,99 @@
+const asyncAuto = require('async/auto');
+const {getChannels} = require('ln-service');
+const {returnResult} = require('asyncjs-util');
+const {subscribeToPeerMessages} = require('ln-service');
+
+const capacityChangeRequests = require('./capacity_change_requests');
+const {serviceTypeChangeCapacity} = require('./../service_types');
+const parseCapacityChangeRequest = require('./parse_capacity_change_request');
+const {servicePeerRequests} = require('./../p2p');
+
+const defaultDelayMs = 1000 * 10;
+const waitForRequestsTimeoutMs = 5000;
+
+/** Get capacity change requests
+
+  {
+    [delay]: <Milliseconds To Wait For Change Requests Number>
+    lnd: <Authenticated LND API Object>
+  }
+
+  @returns via cbk or Promise
+  {
+    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]: <Intended Replacement Channel Channel Type Flags Number>
+    }]
+  }
+*/
+module.exports = ({delay, lnd}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!lnd) {
+          return cbk([400, 'ExpectedLndToGetCapacityChangeRequests']);
+        }
+
+        return cbk();
+      },
+
+      // Wait for incoming capacity change requests
+      getRequests: ['validate', ({}, cbk) => {
+        const requests = [];
+        const service = servicePeerRequests({lnd});
+
+        // Listen for capacity change requests
+        service.request({type: serviceTypeChangeCapacity}, (req, res) => {
+          const {from, records} = req;
+
+          const {request} = parseCapacityChangeRequest({from, records});
+
+          // Exit early when the change request message was not understood
+          if (!request) {
+            return res.failure([400, 'FailedToParseChangeRequest']);
+          }
+
+          // Only add new requests
+          if (!requests.find(n => n.id === request.id)) {
+            requests.push(request);
+          }
+
+          return res.success({});
+        });
+
+        return setTimeout(() => {
+          // Stop listening for requests after a little while
+          service.stop({});
+
+          return cbk(null, requests);
+        },
+        delay || waitForRequestsTimeoutMs);
+      }],
+
+      // Get the set of channels
+      getChannels: ['getRequests', ({}, cbk) => getChannels({lnd}, cbk)],
+
+      // Final set of capacity change requests
+      requests: [
+        'getChannels',
+        'getRequests',
+        ({getChannels, getRequests}, cbk) =>
+      {
+        const {requests} = capacityChangeRequests({
+          channels: getChannels.channels,
+          requests: getRequests,
+        });
+
+        return cbk(null, {requests});
+      }],
+    },
+    returnResult({reject, resolve, of: 'requests'}, cbk));
+  });
+};

package/capacity/get_capacity_replacement.js

@@ -0,0 +1,372 @@
+const asyncAuto = require('async/auto');
+const {closeChannel} = require('ln-service');
+const {decodeChanId} = require('bolt07');
+const {getChainFeeRate} = require('ln-service');
+const {getChainTransactions} = require('ln-service');
+const {getHeight} = require('ln-service');
+const {getPendingChannels} = require('ln-service');
+const {openChannels} = require('ln-service');
+const {returnResult} = require('asyncjs-util');
+const {Transaction} = require('bitcoinjs-lib');
+
+const assembleReplacementTx = require('./assemble_replacement_tx');
+const feeForReplacement = require('./fee_for_replacement');
+const signCapacityReplacement = require('./sign_capacity_replacement');
+
+const blocksBuffer = 2e3;
+const bufferAsHex = buffer => buffer.toString('hex');
+const defaultIncrease = 0;
+const {fromHex} = Transaction;
+const fuzzBlocks = 10;
+const highValue = 3000;
+const {isArray} = Array;
+const maxCommitmentOutputs = 4;
+const maxHighValueOutputs = 2;
+const notFoundIndex = -1;
+const positive = n => Math.max(1, n);
+const slowTarget = 1000;
+const sumOf = arr => arr.reduce((sum, n) => sum + n, 0);
+const txIdAsHash = id => Buffer.from(id, 'hex').reverse();
+
+/** Close a channel and get a capacity replacement transaction
+
+  {
+    [add_funds_transaction_id]: <Adding Funds Input Tx Id Hex Encoded String>
+    [add_funds_transaction_vout]: <Adding Funds Output Index Number>
+    bitcoinjs_network: <BitcoinJs Network Name String>
+    decrease: [{
+      address: <Spend to Chain Address String>
+      output: <Spend to Output Script Hex String>
+      tokens: <Spend Value Number>
+    }]
+    id: <Original Channel Standard Format Channel Id String>
+    [increase]: <Increase Channel Size Tokens Number>
+    [is_private]: <Original Channel Is Private Bool>
+    lnd: <Authenticated LND API Object>
+    transaction_id: <Original Funding Transaction Id Hex String>
+    transaction_vout: <Original Funding Output Index Number>
+  }
+
+  @returns via cbk or Promise
+  {
+    [add_funds_vin]: <Funding Spend Input Index Number>
+    capacity: <Replacement Channel Capacity Tokens Number>
+    remote_balance: <Initial Balance for Peer Tokens Number>
+    signature: <Signature for Replacement Transaction Hex Encoded String>
+    signing_key: <Signing Public Key Hex String>
+    pending_channel_id: <Proposed Channel Pending Id Hex String>
+    transaction_id: <Replacement Channel Transaction Id Hex String>
+    transaction_vin: <Original Channel Input Index Number>
+    transaction_vout: <Replacement Channel Transaction Output Index Number>
+    unsigned_transaction: <Unsigned Transaction Hex Encoded String>
+    witness_script: <Original Channel Witness Script Hex String>
+  }
+*/
+module.exports = (args, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!args.bitcoinjs_network) {
+          return cbk([400, 'ExpectedNetworkNameToGetCapacityReplacement']);
+        }
+
+        if (!isArray(args.decrease)) {
+          return cbk([400, 'ExpectedDecreaseArrayToGetCapacityReplacement']);
+        }
+
+        if (!args.lnd) {
+          return cbk([400, 'ExpectedLndApiToGetCapacityReplacement']);
+        }
+
+        if (!args.transaction_id) {
+          return cbk([400, 'ExpectedFundingTxIdToGetCapacityReplacement']);
+        }
+
+        if (args.transaction_vout === undefined) {
+          return cbk([400, 'ExpectedFundingOutIndexToGetCapacityReplacement']);
+        }
+
+        return cbk();
+      },
+
+      // Get the chain fee rate for a slow confirmation to calculate fee delta
+      getFeeRate: ['validate', ({}, cbk) => {
+        return getChainFeeRate({
+          confirmation_target: slowTarget,
+          lnd: args.lnd,
+        },
+        cbk);
+      }],
+
+      // Get the current chain height
+      getHeight: ['validate', ({}, cbk) => getHeight({lnd: args.lnd}, cbk)],
+
+      // Force close the channel in order to get a non-final sequence number
+      channelClose: ['getFeeRate', ({}, cbk) => {
+        return closeChannel({
+          lnd: args.lnd,
+          is_force_close: true,
+          transaction_id: args.transaction_id,
+          transaction_vout: args.transaction_vout,
+        },
+        cbk);
+      }],
+
+      // Get the pending channels
+      getPending: ['channelClose', ({}, cbk) => {
+        return getPendingChannels({lnd: args.lnd}, cbk);
+      }],
+
+      // Find the pending closing channel
+      pendingChannel: ['getPending', ({getPending}, cbk) => {
+        const channel = getPending.pending_channels.find(chan => {
+          if (chan.transaction_id !== args.transaction_id) {
+            return false;
+          }
+
+          return chan.transaction_vout === args.transaction_vout;
+        });
+
+        if (!channel) {
+          return cbk([503, 'FailedToFindPendingCloseChannelForReplacement']);
+        }
+
+        if (!!channel.pending_payments && !!channel.pending_payments.length) {
+          return cbk([503, 'ExpectedNoActiveHtlcsOnCapacityChangeChannel']);
+        }
+
+        return cbk(null, {
+          capacity: channel.capacity,
+          partner_public_key: channel.partner_public_key,
+          remote_balance: channel.remote_balance,
+        });
+      }],
+
+      // Get the chain transactions to pull out the raw close tx
+      getUpdatedTx: ['channelClose', 'getHeight', ({getHeight}, cbk) => {
+        return getChainTransactions({
+          after: getHeight.current_block_height - fuzzBlocks,
+          lnd: args.lnd,
+        },
+        cbk);
+      }],
+
+      // Find the force close transaction
+      closeTx: [
+        'channelClose',
+        'getUpdatedTx',
+        'pendingChannel',
+        ({channelClose, getUpdatedTx, pendingChannel}, cbk) =>
+      {
+        const closeId = channelClose.transaction_id;
+        const id = args.transaction_id;
+        const {capacity} = pendingChannel;
+
+        const tx = getUpdatedTx.transactions.find(n => n.id === closeId);
+
+        if (!tx || !tx.transaction) {
+          return cbk([503, 'ExpectedCloseTransactionInTransactionsList']);
+        }
+
+        const commitment = fromHex(tx.transaction);
+
+        // Make sure there aren't unexpectedly too-many outputs
+        if (commitment.outs.length > maxCommitmentOutputs) {
+          return cbk([503, 'ExpectedFewerOutputsOnCommitmentTransaction']);
+        }
+
+        const highValueOuts = commitment.outs.filter(n => n.value > highValue);
+
+        // There shouldn't be many high value outputs
+        if (highValueOuts.length > maxHighValueOutputs) {
+          return cbk([500, 'ExpectedFewerHighValueOutputsOnCommitTx']);
+        }
+
+        // Input details for the commitment transaction
+        const [{hash, index, witness}, other] = commitment.ins;
+
+        // The commitment transaction should be spending the funding outpoint
+        if (!hash.equals(txIdAsHash(id)) || index !== args.transaction_vout) {
+          return cbk([503, 'ExpectedSpendingOpenTransactionOutputIndex']);
+        }
+
+        // There should be no other inputs on the closing tx
+        if (!!other) {
+          return cbk([503, 'ExpectedSingleInputForCloseTransaction']);
+        }
+
+        // The spending script is the final element in the witness
+        const [fundingScript] = witness.slice().reverse();
+
+        // The difference between commitment outputs and its input is the fee
+        const fee = capacity - sumOf(commitment.outs.map(n => n.value));
+
+        return cbk(null, {
+          fee,
+          id: commitment.getId(),
+          script: bufferAsHex(fundingScript),
+          transaction: tx.transaction,
+          weight: commitment.weight(),
+        });
+      }],
+
+      // Find the open transaction
+      openTx: ['getUpdatedTx', ({getUpdatedTx}, cbk) => {
+        const funding = fromHex(args.open_transaction);
+        const id = args.transaction_id;
+
+        if (!funding.outs[args.transaction_vout]) {
+          return cbk([503, 'ExpectedTransactionOutputOnFundingTransaction']);
+        }
+
+        const capacity = funding.outs[args.transaction_vout].value;
+        const output = bufferAsHex(funding.outs[args.transaction_vout].script);
+
+        return cbk(null, {capacity, output});
+      }],
+
+      // Calculate the new channel's capacity
+      newCapacity: [
+        'closeTx',
+        'getFeeRate',
+        'pendingChannel',
+        ({closeTx, getFeeRate, pendingChannel}, cbk) =>
+      {
+        // The fee for the replacement tx must meet the relay rate minimum
+        const {fee} = feeForReplacement({
+          capacity: pendingChannel.capacity,
+          commit_transaction_fee: closeTx.fee,
+          commit_transaction_weight: closeTx.weight,
+          decrease: args.decrease,
+          increase: args.increase,
+          tokens_per_vbyte: getFeeRate.tokens_per_vbyte,
+        });
+
+        // The new capacity is capacity + increase - decreases - tx fee
+        const newCapacity = sumOf([
+          pendingChannel.capacity,
+          args.increase || defaultIncrease,
+          -sumOf(args.decrease.map(n => n.tokens)),
+          -fee,
+        ]);
+
+        return cbk(null, newCapacity);
+      }],
+
+      // Propose the new channel to replace the existing one
+      proposeChannel: [
+        'newCapacity',
+        'pendingChannel',
+        ({newCapacity, pendingChannel}, cbk) =>
+      {
+        return openChannels({
+          channels: [{
+            capacity: newCapacity,
+            give_tokens: pendingChannel.remote_balance,
+            is_private: args.is_private,
+            partner_public_key: pendingChannel.partner_public_key,
+            is_private: args.is_private,
+          }],
+          is_avoiding_broadcast: true,
+          lnd: args.lnd,
+        },
+        cbk);
+      }],
+
+      // Put together the unsigned replacement transaction
+      replacementTx: [
+        'closeTx',
+        'newCapacity',
+        'proposeChannel',
+        ({closeTx, newCapacity, proposeChannel}, cbk) =>
+      {
+        // The replacement tx pays to the proposed channel multisig address
+        const [{address}] = proposeChannel.pending;
+
+        try {
+          const replacement = assembleReplacementTx({
+            add_funds_transaction_id: args.add_funds_transaction_id,
+            add_funds_transaction_vout: args.add_funds_transaction_vout,
+            bitcoinjs_network: args.bitcoinjs_network,
+            close_transaction: closeTx.transaction,
+            decrease: args.decrease.map(decrease => ({
+              output: decrease.output,
+              tokens: decrease.tokens,
+            })),
+            funding_address: address,
+            funding_tokens: newCapacity,
+            transaction_id: args.transaction_id,
+            transaction_vout: args.transaction_vout,
+          });
+
+          return cbk(null, {
+            add_funds_vin: replacement.add_funds_vin,
+            transaction: replacement.transaction,
+            transaction_vin: replacement.transaction_vin,
+            transaction_id: replacement.transaction_id,
+            transaction_vout: replacement.transaction_vout,
+          });
+        } catch (err) {
+          return cbk([503, err.message]);
+        }
+      }],
+
+      // Partially sign the replacement transaction using the 2:2 key
+      signReplacement: [
+        'closeTx',
+        'openTx',
+        'pendingChannel',
+        'replacementTx',
+        ({closeTx, openTx, pendingChannel, replacementTx}, cbk) =>
+      {
+        return signCapacityReplacement({
+          capacity: openTx.capacity,
+          lnd: args.lnd,
+          output: openTx.output,
+          script: closeTx.script,
+          transaction: replacementTx.transaction,
+          vin: replacementTx.transaction_vin,
+        },
+        cbk);
+      }],
+
+      // Details of proposed replacement
+      proposedReplacement: [
+        'closeTx',
+        'newCapacity',
+        'pendingChannel',
+        'proposeChannel',
+        'replacementTx',
+        'signReplacement',
+        ({
+          closeTx,
+          newCapacity,
+          pendingChannel,
+          proposeChannel,
+          replacementTx,
+          signReplacement,
+        },
+        cbk) =>
+      {
+        const [pending] = proposeChannel.pending;
+
+        return cbk(null, {
+          add_funds_vin: replacementTx.add_funds_vin,
+          capacity: newCapacity,
+          force_close_tx_id: closeTx.id,
+          remote_balance: pendingChannel.remote_balance,
+          signature: signReplacement.signature,
+          signing_key: signReplacement.key,
+          pending_channel_id: pending.id,
+          transaction_id: replacementTx.transaction_id,
+          transaction_vin: replacementTx.transaction_vin,
+          transaction_vout: replacementTx.transaction_vout,
+          unsigned_transaction: replacementTx.transaction,
+          witness_script: closeTx.script,
+        });
+      }],
+    },
+    returnResult({reject, resolve, of: 'proposedReplacement'}, cbk));
+  });
+};