paid-services 6.1.5 → 6.1.7

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Versions
 
-## Version 6.1.5
+## Version 6.1.7
 
 - `manageSwap`: Add support for Loop Out to external address
 

package/groups/assemble/coordinate_group.js

@@ -1,7 +1,8 @@
 const EventEmitter = require('events');
 const {randomBytes} = require('crypto');
 
-const assembleUnsignedPsbt = require('./assemble_unsigned_psbt');
+const {assembleUnsignedPsbt} = require('ln-sync');
+
 const {decodeGroupDetails} = require('./../messages');
 const {decodePendingProposal} = require('./../messages');
 const {decodeSignedFunding} = require('./../messages');
@@ -32,6 +33,7 @@ const uniq = arr => Array.from(new Set(arr));
   {
     capacity: <Channel Capacity Tokens Number>
     count: <Group Members Count Number>
+    ecp: <ECPair Library Object>
     identity: <Coordinator Identity Public Key Hex String>
     lnd: <Authenticated LND API Object>
     [members]: [<Member Node Id Public Key Hex String>]
@@ -95,11 +97,15 @@ const uniq = arr => Array.from(new Set(arr));
   // All members have submitted their partial signatures
   @event 'signed'
 */
-module.exports = ({capacity, count, identity, lnd, members, rate}) => {
+module.exports = ({capacity, count, ecp, identity, lnd, members, rate}) => {
   if (count < minGroupCount) {
     throw new Error('ExpectedHigherGroupMembersCountToCoordinateGroup');
   }
 
+  if (!ecp) {
+    throw new Error('ExpectedEcpLibraryToCoordinateChannelGroup');
+  }
+
   if (!identity) {
     throw new Error('ExpectedSelfIdentityPublicKeyToCoordinateGroup');
   }
@@ -307,7 +313,7 @@ module.exports = ({capacity, count, identity, lnd, members, rate}) => {
 
       group.proposed.push({
         change: proposal.change,
-        funding: proposal.funding,
+        funding: [proposal.funding],
         id: req.from,
         utxos: proposal.utxos,
       });
@@ -371,12 +377,12 @@ module.exports = ({capacity, count, identity, lnd, members, rate}) => {
     }
 
     try {
-      decodeSignedFunding({records: req.records});
+      decodeSignedFunding({ecp, records: req.records});
     } catch (err) {
       return res.failure([400, err.message]);
     }
 
-    const signed = decodeSignedFunding({records: req.records});
+    const signed = decodeSignedFunding({ecp, records: req.records});
 
     // Register the signed funding
     if (!group.signed.find(n => n.id === req.from)) {

package/groups/assemble_channel_group.js

@@ -13,6 +13,7 @@ const {coordinateGroup} = require('./assemble');
 const {peerWithPartners} = require('./p2p');
 const {proposeGroupChannel} = require('./funding');
 const {signAndFundGroupChannel} = require('./funding');
+const transactionFeeRate = require('./transaction_fee_rate');
 
 const {fromHex} = Transaction;
 const interval = 500;
@@ -82,6 +83,7 @@ module.exports = ({capacity, count, ecp, identity, lnd, members, rate}) => {
   const coordinator = coordinateGroup({
     capacity,
     count,
+    ecp,
     identity,
     lnd,
     members,
@@ -144,7 +146,12 @@ module.exports = ({capacity, count, ecp, identity, lnd, members, rate}) => {
       pending.utxos = utxos;
 
       // Register as proposed
-      return coordinator.proposed({change, funding, utxos, id: identity});
+      return coordinator.proposed({
+        change,
+        utxos,
+        funding: !!funding ? [funding] : undefined,
+        id: identity,
+      });
     } catch (err) {
       return errored(err);
     }
@@ -203,6 +210,13 @@ module.exports = ({capacity, count, ecp, identity, lnd, members, rate}) => {
       // Pull out the raw transaction from the PSBT
       const {transaction} = extractTransaction({ecp, psbt: finalized.psbt});
 
+      const {inputs} = decodePsbt({ecp, psbt: combined.psbt});
+
+      // Make sure the final transaction fee rate is not too low
+      if (transactionFeeRate({inputs, transaction}).rate < rate) {
+        throw [503, 'UnexpectedLowFeeRateForChannelGroupTransaction'];
+      }
+
       emitter.emit('broadcasting', ({transaction}));
 
       const {id} = await broadcastChainTransaction({lnd, transaction});

package/groups/estimate_fee_rate.js

@@ -0,0 +1,38 @@
+const {Transaction} = require('bitcoinjs-lib');
+
+const {fromHex} = Transaction;
+const isUtxoP2wpkh = utxo => utxo.witness_utxo.script_pub.startsWith('0014');
+const sumTokens = arr => arr.reduce((sum, n) => sum + n.tokens, 0);
+const dummyP2wpkh = [Buffer.alloc(33), Buffer.alloc(72)];
+const dummyP2tr = [Buffer.alloc(64)];
+
+/** Assuming large ECDSA signatures, determine a chain fee rate for a PSBT
+
+  {
+    inputs: [{
+      witness_utxo: {
+        script_pub: <P2TR or P2WPKH Output Script Hex String>
+        tokens: <Input Value Tokens Number>
+      }
+    }]
+    outputs: [{
+      tokens: <Output Value Tokens Number>
+    }]
+    unsigned: <Unsigned Transaction Hex String>
+  }
+
+  @returns
+  {
+    rate: <Estimated Chain Fee Tokens Per VByte Number>
+  }
+*/
+module.exports = ({inputs, outputs, unsigned}) => {
+  const fee = sumTokens(inputs.map(n => n.witness_utxo)) - sumTokens(outputs);
+  const tx = fromHex(unsigned);
+
+  inputs.forEach((input, index) => {
+    return tx.setWitness(index, isUtxoP2wpkh(input) ? dummyP2wpkh : dummyP2tr);
+  });
+
+  return {rate: fee / tx.virtualSize()};
+};

package/groups/fanout/assemble_fanout_group.js

@@ -0,0 +1,185 @@
+const EventEmitter = require('events');
+
+const {broadcastChainTransaction} = require('ln-service');
+const {combinePsbts} = require('psbt');
+const {decodePsbt} = require('psbt');
+const {extractTransaction} = require('psbt');
+const {finalizePsbt} = require('psbt');
+const {signAndFundPsbt} = require('ln-sync');
+
+const coordinateFanout = require('./coordinate_fanout');
+const getFanoutFunding = require('./get_fanout_funding');
+const transactionFeeRate = require('./../transaction_fee_rate');
+
+/** Assemble a fanout group
+
+  This group type must have at least 3 participants
+
+  {
+    capacity: <Output Size Tokens Number>
+    count: <Fanout Members Count Number>
+    ecp: <ECPair Library Object>
+    identity: <Coordinator Identity Public Key Hex String>
+    inputs: [<Utxo Outpoint String>]
+    lnd: <Authenticated LND API Object>
+    [members]: [<Member Identity Public Key Hex String>]
+    outputs: <Output Count Number>
+    rate: <Chain Fee Tokens Per VByte Number>
+  }
+
+  @returns
+  {
+    events: <Fanout Status Notifications EventEmitter Object>
+    id: <Group Identifier Hex Encoded String>
+  }
+
+  // The fanout transaction was successfully published to relays
+  @event 'broadcast'
+  {
+    id: <Transaction Id Hex String>
+    transaction: <Transaction Hex String>
+  }
+
+  // The fanout transaction is being published to relays
+  @event 'broadcasting'
+  {
+    transaction: <Transaction Hex String>
+  }
+
+  // A member is peered with the coordinator
+  @event 'connected'
+  {}
+
+  // All members are peered with the coordinator
+  @event 'filled'
+  {
+    ids: [<Group Member Identity Public Key Hex String>]
+  }
+
+  // A member sent a presence update
+  @event 'present'
+  {
+    id: <Present Member Public Id Hex String>
+  }
+
+  // Members have proposed the entire unsigned fanout to the coordinator
+  @event 'proposed'
+  {}
+
+  // Members have all signed the fanout transaction
+  @event 'signed'
+  {}
+*/
+module.exports = args => {
+  const coordinator = coordinateFanout({
+    capacity: args.capacity,
+    count: args.count,
+    ecp: args.ecp,
+    identity: args.identity,
+    lnd: args.lnd,
+    members: args.members,
+    rate: args.rate,
+  });
+
+  const emitter = new EventEmitter();
+  const pending = {};
+
+  const errored = err => {
+    coordinator.events.removeAllListeners();
+
+    return emitter.emit('error', err);
+  };
+
+  // An error was encountered
+  coordinator.events.once('error', errored);
+
+  // Group members have registered themselves
+  coordinator.events.once('joined', ({ids}) => emitter.emit('filled', {ids}));
+
+  // Group members have connected to the coordinator
+  coordinator.events.once('connected', async () => {
+    emitter.emit('connected', {});
+
+    try {
+      // Get the self funding details for the fanout
+      const {change, funding, utxos} = await getFanoutFunding({
+        capacity: args.capacity,
+        inputs: args.inputs,
+        lnd: args.lnd,
+        outputs: args.outputs,
+        rate: args.rate,
+      });
+
+      pending.utxos = utxos;
+
+      // Register self as proposed
+      return coordinator.proposed({change, funding, utxos, id: args.identity});
+    } catch (err) {
+      return errored(err);
+    }
+  });
+
+  // Group members have proposed fanout to the coordinator
+  coordinator.events.once('funded', async () => {
+    emitter.emit('proposed', {unsigned: coordinator.unsigned()});
+
+    try {
+      // Sign the unsigned funding transaction
+      const signed = await signAndFundPsbt({
+        lnd: args.lnd,
+        psbt: coordinator.unsigned(),
+        utxos: pending.utxos,
+      });
+
+      // Register the signature with the coordinator
+      return coordinator.sign({id: args.identity, signed: signed.psbt});
+    } catch (err) {
+      return errored(err);
+    }
+  });
+
+  // Relay presence notifications
+  coordinator.events.on('present', ({id}) => emitter.emit('present', {id}));
+
+  // Group members have submitted their partial signatures
+  coordinator.events.once('signed', async () => {
+    // Collect all the partially signed PSBTs to be combined into a single PSBT
+    const psbts = coordinator.signed().map(n => n.signed);
+
+    emitter.emit('signed', {psbts});
+
+    try {
+      // Merge all the partial signed PSBTs into a single PSBT with all sigs
+      const combined = combinePsbts({psbts, ecp: args.ecp});
+
+      // Finalize the PSBT to convert partial signatures to final signatures
+      const finalized = finalizePsbt({ecp: args.ecp, psbt: combined.psbt});
+
+      // Pull out the raw transaction from the PSBT
+      const {transaction} = extractTransaction({
+        ecp: args.ecp,
+        psbt: finalized.psbt,
+      });
+
+      const {inputs} = decodePsbt({ecp: args.ecp, psbt: combined.psbt});
+
+      // Make sure the final transaction fee rate is not too low
+      if (transactionFeeRate({inputs, transaction}).rate < args.rate) {
+        throw [503, 'UnexpectedLowFeeRateForFanoutTransaction'];
+      }
+
+      emitter.emit('broadcasting', ({transaction}));
+
+      const {id} = await broadcastChainTransaction({
+        transaction,
+        lnd: args.lnd,
+      });
+
+      return emitter.emit('broadcast', {id, transaction});
+    } catch (err) {
+      return errored(err);
+    }
+  });
+
+  return {events: emitter, id: coordinator.id};
+};

package/groups/fanout/confirm_fanout_join.js

@@ -0,0 +1,156 @@
+const asyncAuto = require('async/auto');
+const asyncRetry = require('async/retry');
+const asyncTimeout = require('async/timeout');
+const {connectPeer} = require('ln-sync');
+const {getChainBalance} = require('ln-service');
+const {getNodeAlias} = require('ln-sync');
+const {returnResult} = require('asyncjs-util');
+
+const getFanoutDetails = require('./get_fanout_details');
+
+const coordinatorFromJoinCode = n => n.slice(0, 66);
+const defaultTimeoutMs = 1000 * 60;
+const groupIdFromJoinCode = n => n.slice(66);
+const interval = 500;
+const isCode = n => !!n && n.length === 98;
+const isNumber = n => !isNaN(n);
+const isPublicKey = n => !!n && /^0[2-3][0-9A-F]{64}$/i.test(n);
+const join = arr => arr.join(' ');
+const niceName = n => `${n.alias} ${n.id}`.trim();
+const times = 2 * 60;
+const tokensAsBigUnit = tokens => (tokens / 1e8).toFixed(8);
+
+/** Ask to confirm joining a group
+
+  {
+    code: <Group Invite Code String>
+    count: <Output Count Number>
+    lnd: <Authenticated LND API Object>
+    logger: <Winston Logger Object>
+  }
+
+  @returns via cbk or Promise
+  {
+    capacity: <Fanout Output Capacity Tokens Number>
+    coordinator: <Group Coordinator Identity Public Key Hex String>
+    count: <Group Members Count>
+    id: <Group Id Hex String>
+    rate: <Chain Fee Tokens Per VByte Number>
+  }
+*/
+module.exports = ({code, count, lnd, logger}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!isCode(code)) {
+          return cbk([400, 'ExpectedFanoutGroupInviteCodeToGetJoinDetails']);
+        }
+
+        if (!count || !isNumber(count)) {
+          return cbk([400, 'ExpectedOutputCountToJoinGroupFanout']);
+        }
+
+        if (!lnd) {
+          return cbk([400, 'ExpectedAuthenticatedLndToGetJoinGroupDetails']);
+        }
+
+        if (!logger) {
+          return cbk([400, 'ExpectedWinstonLoggerObjectToGetJoinDetails']);
+        }
+
+        return cbk();
+      },
+
+      // Get the wallet balance to make sure there are enough funds to join
+      getBalance: ['validate', ({}, cbk) => getChainBalance({lnd}, cbk)],
+
+      // Parse the group join code
+      group: ['validate', ({}, cbk) => {
+        const coordinator = coordinatorFromJoinCode(code);
+
+        if (!isPublicKey(coordinator)) {
+          return cbk([400, 'ExpectedValidGroupJoinCodeToRequestGroupDetails']);
+        }
+
+        const id = groupIdFromJoinCode(code);
+
+        return cbk(null, {coordinator, id});
+      }],
+
+      // Connect to the coordinator
+      connect: ['group', ({group}, cbk) => {
+        return asyncRetry({interval, times}, cbk => {
+          logger.info({connecting_to: group.coordinator});
+
+          return asyncTimeout(connectPeer, defaultTimeoutMs)({
+            lnd,
+            id: group.coordinator,
+          },
+          cbk);
+        },
+        cbk);
+      }],
+
+      // Get the coordinator node alias to log it out
+      getAlias: ['group', ({group}, cbk) => {
+        return getNodeAlias({lnd, id: group.coordinator}, cbk);
+      }],
+
+      // Get the group details from the coordinator once connected
+      getDetails: ['connect', 'group', ({group}, cbk) => {
+        return asyncRetry({interval, times}, cbk => {
+          logger.info({requesting_group_details_from: group.coordinator});
+
+          return getFanoutDetails({
+            lnd,
+            coordinator: group.coordinator,
+            id: group.id,
+          },
+          cbk);
+        },
+        cbk);
+      }],
+
+      // Log the details of the group being joined
+      log: [
+        'getAlias',
+        'getBalance',
+        'getDetails',
+        ({getAlias, getBalance, getDetails}, cbk) =>
+      {
+        const coordinatedBy = `coordinated by ${niceName(getAlias)}`;
+        const members = `${getDetails.count} member fanout group`;
+        const size = `with ${tokensAsBigUnit(getDetails.capacity)} outputs`;
+        const rate = `and paying ${getDetails.rate}/vbyte chain fee`;
+
+        logger.info({joining: join([members, coordinatedBy, size, rate])});
+
+        const requiredFunding = getDetails.funding * count;
+
+        // Check to make sure that there are on chain funds for this group
+        if (getBalance.chain_balance < requiredFunding) {
+          return cbk([
+            400,
+            'InsufficientChainFundsAvailableToJoinGroup',
+            {chain_balance: getBalance.chain_balance},
+          ]);
+        }
+
+        return cbk();
+      }],
+
+      // Go ahead with the group join
+      join: ['getDetails', 'group', ({getDetails, group}, cbk) => {
+        return cbk(null, {
+          capacity: getDetails.capacity,
+          coordinator: group.coordinator,
+          count: getDetails.count,
+          id: group.id,
+          rate: getDetails.rate,
+        });
+      }],
+    },
+    returnResult({reject, resolve, of: 'join'}, cbk));
+  });
+};