paid-services 3.19.2 → 3.20.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Versions
 
+## Version 3.20.2
+
+- `manageGroupJoin`: Allow opening a pair channel when funds are below capacity
+
+## Version 3.20.1
+
+- `manageTrades`: Fix seller connection when not peered
+
+## Version 3.20.0
+
+- `manageGroupJoin`: Add support for 2 person groups
+
 ## Version 3.19.2
 
 - `manageSwap`: Add support for inbound peer constraint

package/groups/ask_for_group_details.js

@@ -11,7 +11,7 @@ const isOdd = n => !!(n % 2);
 const maxChannelSize = 21e14;
 const minChannelSize = 2e4;
 const maxGroupSize = 420;
-const minGroupSize = 3;
+const minGroupSize = 2;
 const {round} = Math;
 
 /** Ask for new group details to create a group
@@ -150,7 +150,7 @@ module.exports = ({ask, lnd}, cbk) => {
       {
         return cbk(null, {
           capacity: askForCapacity,
-          count: askForCount,
+          count: Number(askForCount),
           rate: askForFeeRate,
         });
       }],

package/groups/ask_to_confirm_group_join.js

@@ -105,7 +105,7 @@ module.exports = ({ask, lnd}, cbk) => {
         ({getAlias, getBalance, getDetails}, cbk) =>
       {
         // Check to make sure that there are on chain funds for this group
-        if (getBalance.chain_balance < getDetails.capacity) {
+        if (getBalance.chain_balance < getDetails.funding) {
           return cbk([
             400,
             'InsufficientChainFundsAvailableToJoinGroup',

package/groups/assemble/assemble_unsigned_psbt.js

@@ -6,6 +6,7 @@ const tinysecp = require('tiny-secp256k1');
 const {Transaction} = require('bitcoinjs-lib');
 
 const {ceil} = Math;
+const committed = (capacity, m) => m.length === 2 ? capacity / 2 : capacity;
 const dummyEcdsaSignature = Buffer.alloc(74);
 const dummyPublicKey = Buffer.alloc(33);
 const dummySchnorrSignature = Buffer.alloc(64);
@@ -24,7 +25,7 @@ const sumOf = arr => arr.reduce((sum, n) => sum + n, 0);
     capacity: <Channel Capacity Tokens Number>
     proposed: [{
       [change]: <Change Output Hex String>
-      funding: <Funding Output Hex String>
+      [funding]: <Funding Output Hex String>
       utxos: [{
         [non_witness_utxo]: <Spending Transaction Hex String>
         transaction_id: <Transaction Id Hex String>
@@ -120,7 +121,7 @@ module.exports = ({capacity, proposed, rate}, cbk) => {
             },
             {
               script: member.change,
-              tokens: funded - capacity - (vbytes * rate),
+              tokens: funded - committed(capacity, proposed) - (vbytes * rate),
             },
           ];
         });

package/groups/assemble/coordinate_group.js

@@ -21,7 +21,7 @@ const {serviceTypeRegisterSignedOpen} = require('./../../service_types');
 const findRecord = (records, type) => records.find(n => n.type === type);
 const {isArray} = Array;
 const makeGroupId = () => randomBytes(16).toString('hex');
-const minGroupCount = 3;
+const minGroupCount = 2;
 const now = () => new Date().toISOString();
 const staleDate = () => new Date(Date.now() - (1000 * 60 * 10)).toISOString();
 const typeGroupId = '1';
@@ -186,6 +186,11 @@ module.exports = ({capacity, count, identity, lnd, rate}) => {
     // Emit event that everyone has joined
     group.emitter.emit('joined', {ids: group.ids});
 
+    // Exit early when this is a pair group
+    if (count === minGroupCount) {
+      return res.success({});
+    }
+
     // Derive position in members list
     const {inbound, outbound} = partnersFromMembers({group, id: req.from});
 

package/groups/assemble_channel_group.js

@@ -16,6 +16,7 @@ const {signAndFundGroupChannel} = require('./funding');
 
 const {fromHex} = Transaction;
 const interval = 500;
+const minGroupCount = 2;
 const times = 2 * 60 * 10;
 
 /** Assemble a channel group
@@ -68,6 +69,10 @@ const times = 2 * 60 * 10;
   {}
 */
 module.exports = ({capacity, count, ecp, identity, lnd, rate}) => {
+  if (count < minGroupCount) {
+    throw new Error('ExpectedHigherGroupCountToAssembleChannelGroup');
+  }
+
   const coordinator = coordinateGroup({capacity, count, identity, lnd, rate});
   const emitter = new EventEmitter();
   const pending = {};
@@ -85,6 +90,11 @@ module.exports = ({capacity, count, ecp, identity, lnd, rate}) => {
   coordinator.events.once('joined', async ({ids}) => {
     emitter.emit('filled', {ids});
 
+    // Exit early when this is a pair group
+    if (count === minGroupCount) {
+      return coordinator.connected();
+    }
+
     const {inbound, outbound} = coordinator.partners(identity);
 
     // Connect to the inbound and outbound partners
@@ -106,6 +116,7 @@ module.exports = ({capacity, count, ecp, identity, lnd, rate}) => {
       // Fund and propose the pending channel to the outbound partner
       const {change, funding, id, utxos} = await proposeGroupChannel({
         capacity,
+        count,
         lnd,
         rate,
         to: coordinator.partners(identity).outbound,
@@ -142,7 +153,7 @@ module.exports = ({capacity, count, ecp, identity, lnd, rate}) => {
         lnd,
         from: coordinator.partners(identity).inbound,
         id: fromHex(basePsbt.unsigned_transaction).getId(),
-        to: coordinator.partners(identity).outbound,
+        to: coordinator.partners(identity).outbound || undefined,
       });
     });
 

package/groups/funding/confirm_incoming_channel.js

@@ -11,7 +11,7 @@ const half = n => n / 2;
     from: <Look for Incoming Channel From Identity Public Key Hex String>
     id: <Channel Transaction id Hex String>
     lnd: <Authenticated LND API Object>
-    to: <Look for Outgoing Channel To Identity Public Key Hex String>
+    [to]: <Look for Outgoing Channel To Identity Public Key Hex String>
   }
 
   @returns via cbk or Promise
@@ -37,10 +37,6 @@ module.exports = ({capacity, from, id, lnd, to}, cbk) => {
           return cbk([400, 'ExpectedAuthenticatedLndToConfirmChannel']);
         }
 
-        if (!to) {
-          return cbk([400, "ExpectedToPublicKeyToConfirmIncomingChannel"]);
-        }
-
         return cbk();
       },
 
@@ -78,6 +74,11 @@ module.exports = ({capacity, from, id, lnd, to}, cbk) => {
 
       // Double check that there is also a twin outgoing channel
       outgoing: ['getPending', ({getPending}, cbk) => {
+        // Exit early when there is no outgoing channel
+        if (!to) {
+          return cbk();
+        }
+
         const pending = getPending.pending_channels.find(chan => {
           return !chan.is_partner_initiated && chan.transaction_id === id;
         });

package/groups/funding/propose_group_channel.js

@@ -1,14 +1,19 @@
 const asyncAuto = require('async/auto');
 const asyncEach = require('async/each');
 const {fundPsbtDisallowingInputs} = require('ln-sync');
+const {getNetwork} = require('ln-sync');
 const {getUtxos} = require('ln-service');
 const {openChannels} = require('ln-service');
+const {networks} = require('bitcoinjs-lib');
+const {payments} = require('bitcoinjs-lib');
 const {returnResult} = require('asyncjs-util');
 const {unlockUtxo} = require('ln-service');
 
+const dummyKeys = () => ([Buffer.alloc(33, 2), Buffer.alloc(33, 3)]);
 const fuzzSize = 1;
 const halfOf = n => n / 2;
 const isEven = n => !(n % 2);
+const minGroupCount = 2;
 const nestedSegWitAddressFormat = 'np2wpkh';
 const nestedSegWitPath = "m/49'/";
 
@@ -18,7 +23,7 @@ const nestedSegWitPath = "m/49'/";
     capacity: <Channel Capacity Tokens Number>
     lnd: <Authenticated LND API Object>
     rate: <Fee Rate Number>
-    to: <Peer Id Public Key Hex String>
+    [to]: <Peer Id Public Key Hex String>
   }
 
   @returns via cbk or Promise
@@ -45,7 +50,7 @@ const nestedSegWitPath = "m/49'/";
     }]
   }
 */
-module.exports = ({capacity, lnd, rate, to}, cbk) => {
+module.exports = ({capacity, count, lnd, rate, to}, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
@@ -54,6 +59,10 @@ module.exports = ({capacity, lnd, rate, to}, cbk) => {
           return cbk([400, 'ExpectedCapacityToProposeGroupChannel']);
         }
 
+        if (!count) {
+          return cbk([400, 'ExpectedGroupCountToProposeGroupChannel']);
+        }
+
         if (!isEven(capacity)) {
           return cbk([400, 'ExpectedEventCapacityToProposeGroupChannel']);
         }
@@ -66,28 +75,59 @@ module.exports = ({capacity, lnd, rate, to}, cbk) => {
           return cbk([400, 'ExpectedChainFeeRateToProposeGroupChannel']);
         }
 
-        if (!to) {
-          return cbk([400, 'ExpectedChannelPartnerPublicKeyToProposeChannel']);
-        }
-
         return cbk();
       },
 
       // Get inputs to figure out which cannot be used for a group funding
       getInputs: ['validate', ({}, cbk) => getUtxos({lnd}, cbk)],
 
+      // Get the bitcoinjs network name for dummy output derivation
+      getNetwork: ['validate', ({}, cbk) => getNetwork({lnd}, cbk)],
+
       // Propose the channel to get an address to fund
-      propose: ['validate', ({}, cbk) => {
+      propose: ['getNetwork', ({getNetwork}, cbk) => {
+        const tokens = halfOf(capacity);
+
+        // Exit early when there is a shared proposal due to a pair group
+        if (!to) {
+          const {address} = payments.p2wsh({
+            network: networks[getNetwork.bitcoinjs],
+            redeem: payments.p2ms({
+              m: dummyKeys().length,
+              network: networks[getNetwork.bitcoinjs],
+              pubkeys: dummyKeys(),
+            }),
+          });
+
+          // Pretend we are opening a channel when there is no outbound target
+          return cbk(null, {pending: [{address, tokens}]});
+        }
+
+        // Propose a channel
         return openChannels({
           lnd,
           channels: [{
             capacity,
-            give_tokens: halfOf(capacity),
+            give_tokens: tokens,
             partner_public_key: to,
           }],
           is_avoiding_broadcast: true,
         },
-        cbk);
+        (err, res) => {
+          if (!!err) {
+            return cbk(err);
+          }
+
+          // Exit early with the regular pending when it's a normal group size
+          if (count > minGroupCount) {
+            return cbk(null, res);
+          }
+
+          // In a pair group size, remap the funding so that it's only half
+          const [{address, id}] = res.pending;
+
+          return cbk(null, {pending: [{address, id, tokens}]});
+        });
       }],
 
       // Fund the address to populate UTXOs that can be used
@@ -145,10 +185,13 @@ module.exports = ({capacity, lnd, rate, to}, cbk) => {
         // Find the change output
         const change = fund.outputs.find(n => n.is_change);
 
-        // UTXOs have been selected and channel has been proposed to peer
+        // Find the funding output
+        const funding = fund.outputs.find(n => !n.is_change);
+
+        // UTXOs have been selected
         return cbk(null, {
           change: !!change ? change.output_script : undefined,
-          funding: fund.outputs.find(n => !n.is_change).output_script,
+          funding: !!to ? funding.output_script : undefined,
           id: proposal.id,
           overflow: !!change ? change.tokens : undefined,
           utxos: fund.inputs.map(input => ({

package/groups/funding/sign_and_fund_group_channel.js

@@ -40,7 +40,7 @@ const times = 500;
 /** Sign and fund group channel
 
   {
-    id: <Pending Channel Id Hex String>
+    [id]: <Pending Channel Id Hex String>
     lnd: <Authenticated LND API Object>
     psbt: <Base Funding PSBT Hex String>
     utxos: [{
@@ -74,10 +74,6 @@ module.exports = ({id, lnd, psbt, utxos}, cbk) => {
 
       // Check arguments
       validate: cbk => {
-        if (!id) {
-          return cbk([400, 'ExpectedPendingChannelIdToSignAndFundGroupChan']);
-        }
-
         if (!lnd) {
           return cbk([400, 'ExpectedAuthenticatedLndToSignAndFundGroupChan']);
         }
@@ -254,6 +250,11 @@ module.exports = ({id, lnd, psbt, utxos}, cbk) => {
 
       // Fund the pending channel with the finalized PSBT
       fundChannel: ['conflict', 'finalizePsbt', ({finalizePsbt}, cbk) => {
+        // Exit early when this is a pair channel and there is no proposal
+        if (!id) {
+          return cbk();
+        }
+
         return fundPendingChannels({
           lnd,
           channels: [id],
@@ -264,6 +265,11 @@ module.exports = ({id, lnd, psbt, utxos}, cbk) => {
 
       // Confirm that the outgoing pending channel is present
       confirmOutPending: ['ecp', 'fundChannel', ({ecp}, cbk) => {
+        // Exit early when this is a pair channel and there is no proposal
+        if (!id) {
+          return cbk();
+        }
+
         const tx = fromHex(decodePsbt({ecp, psbt}).unsigned_transaction);
 
         // Wait for the outgoing pending channel to be present

package/groups/join_channel_group.js

@@ -90,11 +90,16 @@ module.exports = ({capacity, coordinator, count, id, lnd, rate}, cbk) => {
 
     // Find partners in the group
     partners: ['validate', ({}, cbk) => {
-      return findGroupPartners({coordinator, id, lnd}, cbk);
+      return findGroupPartners({coordinator, count, id, lnd}, cbk);
     }],
 
     // Peer with the group partners
     peer: ['partners', ({partners}, cbk) => {
+      // Exit early when there is no inbound partner to connect with
+      if (!partners.inbound) {
+        return cbk();
+      }
+
       // Let listeners know that peering will be happening
       emitter.emit('peering', {
         inbound: partners.inbound,
@@ -118,6 +123,7 @@ module.exports = ({capacity, coordinator, count, id, lnd, rate}, cbk) => {
     propose: ['connected', 'partners', ({partners}, cbk) => {
       return proposeGroupChannel({
         capacity,
+        count,
         lnd,
         rate,
         to: partners.outbound,
@@ -168,6 +174,11 @@ module.exports = ({capacity, coordinator, count, id, lnd, rate}, cbk) => {
       'transaction',
       asyncReflect(({ecp, partners, register, transaction}, cbk) =>
     {
+      // Exit early when there is no inbound partner
+      if (!partners.inbound) {
+        return cbk();
+      }
+
       // Make sure that there is an inbound channel
       return asyncRetry({interval, times}, cbk => {
         return confirmIncomingChannel({

package/groups/members/partners_from_members.js

@@ -1,3 +1,5 @@
+const minGroupCount = 2;
+
 /** Derive inbound and outbound partners from members list
 
   {
@@ -14,6 +16,11 @@
   }
 */
 module.exports = ({group, id}) => {
+  // Exit early when the group only has a pair and there is only one partner
+  if (group.ids.length === minGroupCount) {
+    return {inbound: group.ids.find(n => n !== id)};
+  }
+
   const [first] = group.ids;
   const reversed = group.ids.slice().reverse();
 

package/groups/messages/decode_group_details.js

@@ -1,15 +1,18 @@
 const {decodeBigSize} = require('bolt01');
 
 const findRecord = (records, type) => records.find(n => n.type === type);
+const funding = (capacity, count) => count === 2 ? capacity / 2 : capacity;
 const {isArray} = Array;
 const isOdd = n => !!(n % 2);
 const maxCapacityTokens = BigInt(7e14);
 const maxMembersCount = BigInt(650);
 const maxFeeRate = BigInt(1e5);
+const minMembersCount = BigInt(2);
 const typeCapacity = '1';
 const typeCount = '2';
 const typeRate = '3';
 const typeVersion = '0';
+const version = '1';
 
 /** Decode group details
 
@@ -27,6 +30,7 @@ const typeVersion = '0';
   {
     capacity: <Channel Capacity Tokens Number>
     count: <Target Members Count Number>
+    funding: <Amount Of Funding Required Tokens Number>
     rate: <Chain Fee Rate Number>
   }
 */
@@ -41,8 +45,18 @@ module.exports = ({records}) => {
 
   const versionRecord = findRecord(records, typeVersion);
 
-  if (!!versionRecord) {
-    throw new Error('UnexpectedVersionOfGroupDetailsRecords');
+  if (!versionRecord) {
+    throw new Error('ExpectedVersionOfGroupDetailsRecords');
+  }
+
+  try {
+    decodeBigSize({encoded: versionRecord.value});
+  } catch (err) {
+    throw new Error('ExpectedValidVersionNumberInGroupRecords');
+  }
+
+  if (decodeBigSize({encoded: versionRecord.value}).decoded !== version) {
+    throw new Error('UnsupportedGroupVersion');
   }
 
   const capacityRecord = findRecord(records, typeCapacity);
@@ -77,6 +91,10 @@ module.exports = ({records}) => {
     throw new Error('UnexpectedValueForCountInGroupRecords');
   }
 
+  if (BigInt(count) < minMembersCount) {
+    throw new Error('ExpectedHigherMembersCountInGroupDetails');
+  }
+
   const rateRecord = findRecord(records, typeRate);
 
   try {
@@ -94,6 +112,7 @@ module.exports = ({records}) => {
   return {
     capacity: Number(capacity),
     count: Number(count),
+    funding: funding(Number(capacity), Number(count)),
     rate: Number(rate),
   };
 };

package/groups/messages/encode_group_details.js

@@ -4,6 +4,8 @@ const encodeNumber = number => encodeBigSize({number}).encoded;
 const typeCapacity = '1';
 const typeCount = '2';
 const typeRate = '3';
+const typeVersion = '0';
+const version = '1';
 
 /** Encode group details records
 
@@ -27,6 +29,7 @@ module.exports = ({capacity, count, rate}) => {
       {type: typeCapacity, value: encodeNumber(capacity)},
       {type: typeCount, value: encodeNumber(count)},
       {type: typeRate, value: encodeNumber(rate)},
+      {type: typeVersion, value: encodeNumber(version)},
     ],
   };
 };

package/groups/messages/encode_partners_records.js

@@ -16,7 +16,5 @@ const typePartnersRecord = '1';
   }
 */
 module.exports = ({inbound, outbound}) => {
-  const records = [{type: typePartnersRecord, value: inbound + outbound}];
-
-  return {records};
+  return {records: [{type: typePartnersRecord, value: inbound + outbound}]};
 };

package/groups/p2p/find_group_partners.js

@@ -13,6 +13,7 @@ const defaultConnectPollTimes = 2 * 60 * 5;
 const defaultGroupPartnersIntervalMs = 500;
 const defaultGroupPartnersPollTimes = 2 * 60 * 60 * 24 * 3;
 const defaultRequestTimeoutMs = 1000 * 60;
+const minGroupCount = 2;
 const missingGroupPartners = 'NoGroupPartnersFound';
 const typeGroupChannelId = '1';
 
@@ -30,7 +31,7 @@ const typeGroupChannelId = '1';
     outbound: <Outbound Peer Public Key Identity Hex String>
   }
 */
-module.exports = ({coordinator, id, lnd}, cbk) => {
+module.exports = ({coordinator, count, id, lnd}, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
@@ -39,6 +40,10 @@ module.exports = ({coordinator, id, lnd}, cbk) => {
           return cbk([400, 'ExpectedCoordinatorToFindGroupPartners']);
         }
 
+        if (!count) {
+          return cbk([400, 'ExpectedGroupMemberCountToFindGroupPartners']);
+        }
+
         if (!id) {
           return cbk([400, 'ExpectedGroupIdToFindGroupPartners']);
         }
@@ -84,6 +89,11 @@ module.exports = ({coordinator, id, lnd}, cbk) => {
               return cbk(err);
             }
 
+            // Exit early when the group is a pair
+            if (count === minGroupCount) {
+              return cbk();
+            }
+
             // Exit with error when there are no group partners
             if (!res.records || !res.records.length) {
               return cbk([503, missingGroupPartners]);
@@ -97,6 +107,11 @@ module.exports = ({coordinator, id, lnd}, cbk) => {
 
       // Parse the group partners response
       partners: ['request', ({request}, cbk) => {
+        // Exit early when there are no records
+        if (!request) {
+          return cbk(null, {outbound: coordinator});
+        }
+
         try {
           return cbk(null, decodePartnersRecords({records: request}));
         } catch (err) {
@@ -106,6 +121,11 @@ module.exports = ({coordinator, id, lnd}, cbk) => {
 
       // Attempt to connect to the partners
       peer: ['partners', ({partners}, cbk) => {
+        // Exit early when there are no partners
+        if (!partners.inbound) {
+          return cbk();
+        }
+
         return asyncEach([partners.inbound, partners.outbound], (id, cbk) => {
           return asyncRetry({
             interval: defaultConnectIntervalMs,

package/groups/p2p/get_group_details.js

@@ -24,6 +24,7 @@ const typeGroupChannelId = '1';
   {
     capacity: <Channel Capacity Tokens Number>
     count: <Target Members Count Number>
+    funding: <Amount Of Funding Required Tokens Number>
     rate: <Chain Fee Rate Number>
   }
 */

package/groups/p2p/register_pending_open.js

@@ -34,7 +34,7 @@ const typeGroupChannelId = '1';
     group: <Group Identifier Hex String>
     lnd: <Authenticated LND API Object>
     overflow: <Expected Minimum Change Amount Tokens Number>
-    pending: <Pending Channel Id Hex String>
+    [pending]: <Pending Channel Id Hex String>
     utxos: [{
       [non_witness_utxo]: <Non Witness Transaction Hex String>
       transaction_id: <Transaction Id Hex String>
@@ -80,10 +80,6 @@ module.exports = (args, cbk) => {
           return cbk([400, 'ExpectedAuthenticatedLndToRegisterPendingOpen']);
         }
 
-        if (!args.pending) {
-          return cbk([400, 'ExpectedPendingChannelIdToRegisterPendingOpen']);
-        }
-
         if (!isArray(args.utxos)) {
           return cbk([400, 'ExpectedArrayOfUtxosToRegisterPendingOpen']);
         }
@@ -157,6 +153,11 @@ module.exports = (args, cbk) => {
           return cbk();
         }
 
+        // Exit early if there is no pending id
+        if (!args.pending) {
+          return cbk();
+        }
+
         return cancelPendingChannel({id: args.pending, lnd: args.lnd}, err => {
           if (!!err) {
             return cbk([503, 'UnexpectedErrorCleaningPendingChannel', {err}]);

package/package.json

@@ -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/server/*.js test/services/*.js test/trades/*.js"
   },
-  "version": "3.19.2"
+  "version": "3.20.2"
 }

package/test/integration/test_group.js

@@ -57,7 +57,7 @@ test(`Setup joint channel group`, async ({end, equal, strictSame}) => {
       lnd: remote.lnd,
     });
 
-    // Send coins to target
+    // Send coins to remote
     await sendToChainAddress({lnd, tokens, address: remoteAddress.address});
 
     // Wait for funds to arrive

package/test/integration/test_group_pair.js

@@ -0,0 +1,145 @@
+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 = 101;
+const feeRate = 1;
+const interval = 10;
+const size = 2;
+const tokens = 1e6;
+const times = 2000;
+
+// Make a joint transaction channel group
+test(`Setup joint channel group`, async ({end, equal, strictSame}) => {
+  const ecp = (await import('ecpair')).ECPairFactory(tinysecp);
+  const {kill, nodes} = await spawnLightningCluster({size});
+
+  const [control, target] = 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});
+
+    // 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 targetUtxos = await getUtxos({lnd: target.lnd});
+
+      if (!targetUtxos.utxos.filter(n => !!n.confirmation_count).length) {
+        throw new Error('ExpectedConfirmedUtxoOnTarget');
+      }
+    });
+
+    // Connect control to target
+    await addPeer({lnd, public_key: target.id, socket: target.socket});
+
+    // Start Group Coordination
+
+    // Start the coordination
+    const assemble = assembleChannelGroup({
+      capacity,
+      ecp,
+      count: nodes.length,
+      identity: control.id,
+      lnd: control.lnd,
+      rate: feeRate,
+    });
+
+    const events = {};
+
+    assemble.events.once('broadcast', n => events.broadcast = n);
+    assemble.events.once('filled', n => events.filled = n);
+
+    // Target join the group
+    const joins = await asyncMap([target.lnd], async lnd => {
+      const group = await getGroupDetails({
+        lnd,
+        coordinator: control.id,
+        id: assemble.id,
+      });
+
+      const join = joinChannelGroup({
+        lnd,
+        capacity: group.capacity,
+        coordinator: control.id,
+        count: group.count,
+        id: assemble.id,
+        rate: group.rate,
+      });
+
+      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});
+
+    const {getPendingChannels} = require('ln-service');
+
+    await asyncRetry({interval, times}, async () => {
+      await generate({});
+
+      const {channels} = await getChannels({lnd, is_active: true});
+
+      if (!channels.length) {
+        throw new Error('ExpectedChannelActivation');
+      }
+    });
+
+    strictSame(ids, [events.broadcast.id], 'Got tx ids');
+    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();
+});

package/trades/connect_to_seller.js

@@ -66,6 +66,9 @@ module.exports = ({lnd, logger, nodes}, cbk) => {
       // Derive the self public key
       getIdentity: ['validate', ({}, cbk) => getIdentity({lnd}, cbk)],
 
+      // Get the actively connected peers
+      getPeered: ['validate', ({}, cbk) => getPeers({lnd}, cbk)],
+
       // Find node connect info to connect to
       getNodes: ['getIdentity', ({getIdentity}, cbk) => {
         return asyncMap(nodes, (connect, cbk) => {
@@ -144,7 +147,8 @@ module.exports = ({lnd, logger, nodes}, cbk) => {
       removePeer: [
         'getChannels',
         'getNodes',
-        ({getChannels, getNodes}, cbk) =>
+        'getPeered',
+        ({getChannels, getNodes, getPeered}, cbk) =>
       {
         const ids = getChannels.channels.map(n => n.partner_public_key);
 
@@ -154,6 +158,11 @@ module.exports = ({lnd, logger, nodes}, cbk) => {
             return cbk();
           }
 
+          // Exit early when already not peered
+          if (!getPeered.peers.map(n => n.public_key).includes(node.id)) {
+            return cbk();
+          }
+
           return removePeer({lnd, public_key: node.id}, (err, res) => {
             if (!!err) {
               return cbk(err);
@@ -181,7 +190,7 @@ module.exports = ({lnd, logger, nodes}, cbk) => {
       }],
 
       // Get the list of connected peers
-      getPeers: ['removePeer', ({}, cbk) => getPeers({lnd}, cbk)],
+      getPeers: ['validate', ({}, cbk) => getPeers({lnd}, cbk)],
 
       // Try and connect to a node in order to do p2p messaging
       connect: [