paid-services 4.0.4 → 4.1.0

package/CHANGELOG.md

@@ -1,6 +1,10 @@
 # Versions
 
-## Version 4.0.4
+## Version 4.1.0
+
+- `createGroupChannel`: Add `members` to restrict and order group membership
+
+## Version 4.0.5
 
 - `manageTrades`: Fix connection to seller failing
 

package/groups/assemble/assemble_unsigned_psbt.js

@@ -142,6 +142,7 @@ module.exports = ({capacity, proposed, rate}, cbk) => {
           .map(utxo => ({
             id: utxo.transaction_id,
             non_witness_utxo: utxo.non_witness_utxo,
+            sequence: Number(),
             vout: utxo.transaction_vout,
             witness_utxo: utxo.witness_utxo,
           }))

package/groups/assemble/coordinate_group.js

@@ -25,6 +25,7 @@ const minGroupCount = 2;
 const now = () => new Date().toISOString();
 const staleDate = () => new Date(Date.now() - (1000 * 60 * 10)).toISOString();
 const typeGroupId = '1';
+const uniq = arr => Array.from(new Set(arr));
 
 /** Coordinate channel group
 
@@ -33,6 +34,7 @@ const typeGroupId = '1';
     count: <Group Members Count Number>
     identity: <Coordinator Identity Public Key Hex String>
     lnd: <Authenticated LND API Object>
+    [members]: [<Member Node Id Public Key Hex String>]
     rate: <Chain Fee Rate Number>
   }
 
@@ -87,7 +89,7 @@ const typeGroupId = '1';
   // All members have submitted their partial signatures
   @event 'signed'
 */
-module.exports = ({capacity, count, identity, lnd, rate}) => {
+module.exports = ({capacity, count, identity, lnd, members, rate}) => {
   if (count < minGroupCount) {
     throw new Error('ExpectedHigherGroupMembersCountToCoordinateGroup');
   }
@@ -100,8 +102,13 @@ module.exports = ({capacity, count, identity, lnd, rate}) => {
     throw new Error('ExpectedAuthenticatedLndToCoordinateGroup');
   }
 
+  if (!!members && uniq(members).length !== count) {
+    throw new Error('ExpectedCompleteSetOfAllowedMembers');
+  }
+
   // Instantiate the group with self as a member
   const group = {
+    allowed: members,
     connected: [],
     emitter: new EventEmitter(),
     members: [{id: identity}],
@@ -152,6 +159,11 @@ module.exports = ({capacity, count, identity, lnd, rate}) => {
       return;
     }
 
+    // Exit early when group member is not allowed
+    if (!!group.allowed && !group.allowed.includes(req.from)) {
+      return res.failure([403, 'AccessDeniedToGroup']);
+    }
+
     // Emit event that someone is joining
     if (!group.members.find(n => n.id === req.from)) {
       group.emitter.emit('joining', {id: req.from});

package/groups/assemble_channel_group.js

@@ -27,6 +27,7 @@ const times = 2 * 60 * 10;
     ecp: <ECPair Library Object>
     identity: <Coordinator Identity Public Key Hex String>
     lnd: <Authenticated LND API Object>
+    [members]: [<Member Identity Public Key Hex String>]
     rate: <Chain Fee Tokens Per VByte Number>
   }
 
@@ -68,12 +69,20 @@ const times = 2 * 60 * 10;
   @event 'signed'
   {}
 */
-module.exports = ({capacity, count, ecp, identity, lnd, rate}) => {
+module.exports = ({capacity, count, ecp, identity, lnd, members, rate}) => {
   if (count < minGroupCount) {
     throw new Error('ExpectedHigherGroupCountToAssembleChannelGroup');
   }
 
-  const coordinator = coordinateGroup({capacity, count, identity, lnd, rate});
+  const coordinator = coordinateGroup({
+    capacity,
+    count,
+    identity,
+    lnd,
+    members,
+    rate,
+  });
+
   const emitter = new EventEmitter();
   const pending = {};
 

package/groups/create_group_channel.js

@@ -10,7 +10,10 @@ const tinysecp = require('tiny-secp256k1');
 const assembleChannelGroup = require('./assemble_channel_group');
 
 const halfOf = n => n / 2;
+const {isArray} = Array;
+const isPublicKey = n => !!n && /^0[2-3][0-9A-F]{64}$/i.test(n);
 const isOdd = n => !!(n % 2);
+const isValidMembersCount = (n, count) => !n.length || n.length === count - 1;
 const join = arr => arr.join(', ');
 const maxGroupSize = 420;
 const minChannelSize = 2e4;
@@ -18,13 +21,14 @@ const minGroupSize = 2;
 const niceName = ({alias, id}) => `${alias} ${id}`.trim();
 const signPsbtEndpoint = '/walletrpc.WalletKit/SignPsbt';
 
-/** Join a channel group
+/** Create a channel group
 
   {
     capacity: <Channel Capacity Tokens Number>
     count: <Group Member Count Number>
     lnd: <Authenticated LND API Object>
     logger: <Winston Logger Object>
+    [members]: [<Member Identity Public Key Hex String>]
     rate: <Opening Chain Fee Tokens Per VByte Rate Number>
   }
 
@@ -69,6 +73,18 @@ module.exports = (args, cbk) => {
           return cbk([400, 'ExpectedWinstonLoggerToCreateChannelGroup']);
         }
 
+        if (!isArray(args.members)) {
+          return cbk([400, 'ExpectedArrayOfGroupMembersToCreateChannelGroup']);
+        }
+
+        if (!isValidMembersCount(args.members, args.count)) {
+          return cbk([400, 'ExpectedCompleteSetOfAllowedGroupMembers']);
+        }
+
+        if (!!args.members.filter(n => !isPublicKey(n)).length) {
+          return cbk([400, 'ExpectedNodeIdentityPublicKeysForChannelGroup']);
+        }
+
         if (!args.rate) {
           return cbk([400, 'ExpectedOpeningFeeRateToCreateChannelGroup']);
         }
@@ -121,12 +137,15 @@ module.exports = (args, cbk) => {
         'getIdentity',
         ({ecp, getIdentity}, cbk) =>
       {
+        const members = [getIdentity.public_key].concat(args.members);
+
         const coordinate = assembleChannelGroup({
           ecp,
           capacity: args.capacity,
           count: args.count,
           identity: getIdentity.public_key,
           lnd: args.lnd,
+          members: !!args.members.length ? members : undefined,
           rate: args.rate,
         });
 

package/groups/members/partners_from_members.js

@@ -4,6 +4,7 @@ const minGroupCount = 2;
 
   {
     group: {
+      allowed: [<Allowed Public Key Id Hex String>]
       ids: [<Public Key Id Hex String>]
     }
     id: <Identity Public Key Hex String>
@@ -21,11 +22,13 @@ module.exports = ({group, id}) => {
     return {inbound: group.ids.find(n => n !== id)};
   }
 
-  const [first] = group.ids;
-  const reversed = group.ids.slice().reverse();
+  const ids = group.allowed || group.ids;
+
+  const [first] = ids;
+  const reversed = ids.slice().reverse();
 
   const [last] = reversed;
-  const [, next] = group.ids.slice(group.ids.indexOf(id));
+  const [, next] = ids.slice(ids.indexOf(id));
 
   const [, previous] = reversed.slice(reversed.indexOf(id));
 

package/package.json

@@ -15,9 +15,9 @@
     "bolt07": "1.8.2",
     "ecpair": "2.1.0",
     "goldengate": "11.4.0",
-    "invoices": "2.2.0",
-    "ln-service": "54.2.5",
-    "ln-sync": "4.0.4",
+    "invoices": "2.2.2",
+    "ln-service": "54.3.1",
+    "ln-sync": "4.0.5",
     "psbt": "2.7.1",
     "p2tr": "1.3.2",
     "tiny-secp256k1": "2.2.1"
@@ -25,7 +25,7 @@
   "description": "Lightning Paid Services library",
   "devDependencies": {
     "@alexbosworth/tap": "15.0.11",
-    "ln-docker-daemons": "3.1.4",
+    "ln-docker-daemons": "3.1.5",
     "mock-lnd": "1.4.4",
     "secp256k1": "4.0.3"
   },
@@ -47,5 +47,5 @@
     "integration-tests": "tap -j 2 --branches=1 --functions=1 --lines=1 --statements=1 -t 180 test/integration/*.js",
     "test": "tap --branches=1 --functions=1 --lines=1 --statements=1 -t 60 test/actions/*.js test/balanced/*.js test/capacity/*.js test/client/*.js test/config/*.js test/p2p/*.js test/records/*.js test/respond/*.js test/server/*.js test/swaps/*.js test/services/*.js test/trades/*.js"
   },
-  "version": "4.0.4"
+  "version": "4.1.0"
 }

package/test/integration/test_group_noninteractive.js

@@ -82,6 +82,7 @@ test(`Setup joint channel group`, async ({end, equal, strictSame}) => {
           count: nodes.length,
           lnd: control.lnd,
           logger: {info: line => createLog.push(line)},
+          members: [],
           rate: feeRate,
         });
       },

package/test/integration/test_group_sort.js

@@ -0,0 +1,202 @@
+const {once} = require('events');
+
+const {addPeer} = require('ln-service');
+const asyncMap = require('async/map');
+const asyncRetry = require('async/retry');
+const {createChainAddress} = require('ln-service');
+const {getChainTransactions} = require('ln-service');
+const {getChannels} = require('ln-service');
+const {getNetwork} = require('ln-sync');
+const {getUtxos} = require('ln-service');
+const {networks} = require('bitcoinjs-lib');
+const {sendToChainAddress} = require('ln-service');
+const {spawnLightningCluster} = require('ln-docker-daemons');
+const {test} = require('@alexbosworth/tap');
+const tinysecp = require('tiny-secp256k1');
+
+const assembleChannelGroup = require('./../../groups/assemble_channel_group');
+const {confirmIncomingChannel} = require('./../../groups/funding');
+const {getGroupDetails} = require('./../../groups/p2p');
+const joinChannelGroup = require('./../../groups/join_channel_group');
+
+const capacity = 1e5;
+const count = 102;
+const feeRate = 1;
+const interval = 10;
+const size = 4;
+const tokens = 1e6;
+const times = 2000;
+
+// Make a joint transaction channel group with a sort defined
+test(`Setup sorted channel group`, async ({end, equal, strictSame}) => {
+  const ecp = (await import('ecpair')).ECPairFactory(tinysecp);
+  const {kill, nodes} = await spawnLightningCluster({size});
+
+  const [control, target, remote, extra] = nodes;
+
+  const {generate, lnd} = control;
+
+  try {
+    // Setup the cluster of nodes to have funds and be connected
+
+    // Make some funds for control
+    await generate({count});
+
+    // Get the bitcoinjs network
+    const network = networks[(await getNetwork({lnd})).bitcoinjs];
+
+    // Create a target chain address
+    const targetAddress = await createChainAddress({lnd: target.lnd});
+
+    // Send coins to target
+    await sendToChainAddress({lnd, tokens, address: targetAddress.address});
+
+    // Create a remote chain address
+    const remoteAddress = await createChainAddress({lnd: remote.lnd});
+
+    // Create an address on the extra node
+    const extraAddress = await createChainAddress({lnd: extra.lnd});
+
+    // Send coins to remote
+    await sendToChainAddress({lnd, tokens, address: remoteAddress.address});
+
+    // Send coins to extra
+    await sendToChainAddress({lnd, tokens, address: extraAddress.address});
+
+    // Wait for funds to arrive
+    await asyncRetry({interval, times}, async () => {
+      await generate({});
+
+      const {transactions} = await getChainTransactions({lnd});
+
+      if (!!transactions.filter(n => !n.is_confirmed).length) {
+        throw new Error('TransactionsAreUnconfirmed');
+      }
+    });
+
+    // Wait for UTXOs to be confirmed
+    await asyncRetry({interval, times}, async () => {
+      const remoteUtxos = await getUtxos({lnd: remote.lnd});
+      const targetUtxos = await getUtxos({lnd: target.lnd});
+
+      if (!targetUtxos.utxos.filter(n => !!n.confirmation_count).length) {
+        throw new Error('ExpectedConfirmedUtxoOnTarget');
+      }
+
+      if (!remoteUtxos.utxos.filter(n => !!n.confirmation_count).length) {
+        throw new Error('ExpectedConfirmUtxoOnRemote');
+      }
+    });
+
+    // Connect control to target
+    await addPeer({lnd, public_key: target.id, socket: target.socket});
+
+    // Connect target to remote
+    await addPeer({
+      lnd: target.lnd,
+      public_key: remote.id,
+      socket: remote.socket,
+    });
+
+    // Connect remote to control
+    await addPeer({
+      lnd: remote.lnd,
+      public_key: control.id,
+      socket: control.socket,
+    });
+
+    // Connect extra to the other nodes
+    await asyncMap([control, target, remote], async ({id, socket}) => {
+      await addPeer({socket, lnd: extra.lnd, public_key: id});
+    });
+
+    // Start Group Coordination
+
+    // Start the coordination
+    const assemble = assembleChannelGroup({
+      capacity,
+      ecp,
+      count: nodes.length,
+      identity: control.id,
+      lnd: control.lnd,
+      members: [control.id, extra.id, remote.id, target.id],
+      rate: feeRate,
+    });
+
+    const events = {};
+
+    assemble.events.once('broadcast', n => events.broadcast = n);
+    assemble.events.once('filled', n => events.filled = n);
+
+    // Target, remote, and extra join the group
+    const joins = await asyncMap([target, remote, extra], async node => {
+      const group = await getGroupDetails({
+        coordinator: control.id,
+        id: assemble.id,
+        lnd: node.lnd,
+      });
+
+      const join = joinChannelGroup({
+        capacity: group.capacity,
+        coordinator: control.id,
+        count: group.count,
+        id: assemble.id,
+        lnd: node.lnd,
+        rate: group.rate,
+      });
+
+      const [{inbound, outbound}] = await once(join, 'peering');
+
+      switch (node.id) {
+      case (extra.id):
+        strictSame(inbound, control.id, 'Extra inbound is control');
+        strictSame(outbound, remote.id, 'Extra outbound is remote');
+        break;
+
+      case (remote.id):
+        strictSame(inbound, extra.id, 'Remote inbound is extra');
+        strictSame(outbound, target.id, 'Remote outbound is target');
+        break;
+
+      case (target.id):
+        strictSame(inbound, remote.id, 'Target inbound is remote');
+        strictSame(outbound, control.id, 'Target outbound is control');
+        break;
+
+      default:
+        break;
+      }
+
+      strictSame(!!inbound, true, 'Received inbound peer');
+      strictSame(!!outbound, true, 'Received outbound peer');
+
+      const [tx] = await once(join, 'end');
+
+      return tx;
+    });
+
+    // Transaction ids of the open should be returned
+    const ids = joins.map(n => n.id);
+
+    // Finished, wait for the channels to activate
+    await generate({count});
+
+    await asyncRetry({interval, times}, async () => {
+      const {channels} = await getChannels({lnd, is_active: true});
+
+      if (!channels.length) {
+        throw new Error('ExpectedChannelActivation');
+      }
+    });
+
+    strictSame(events.broadcast.id.length, 64, 'Got broadcast tx id');
+    strictSame(!!events.broadcast.transaction, true, 'Got broadcast tx');
+    strictSame(events.filled.ids.length, nodes.length, 'Got filled event');
+  } catch (err) {
+    strictSame(err, null, 'Expected no failure');
+  } finally {
+    await kill({});
+  }
+
+  return end();
+});