paid-services 4.0.5 → 4.2.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Versions
 
+## Version 4.2.0
+
+- `manageSwap`: Add support for P2TR output addresses
+
+## 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

@@ -14,10 +14,10 @@
     "bolt01": "1.2.5",
     "bolt07": "1.8.2",
     "ecpair": "2.1.0",
-    "goldengate": "11.4.0",
-    "invoices": "2.2.0",
-    "ln-service": "54.2.6",
-    "ln-sync": "4.0.5",
+    "goldengate": "12.0.0",
+    "invoices": "2.2.2",
+    "ln-service": "54.8.0",
+    "ln-sync": "4.1.0",
     "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": "4.0.2",
     "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.5"
+  "version": "4.2.0"
 }

package/swaps/complete_off_to_on_swap.js

@@ -65,6 +65,7 @@ const encodeAddress = (prefix, data) => bech32m.encode(prefix, data);
 const externalKeyAsOutputScript = key => `5120${key}`;
 const family = 805;
 const {floor} = Math;
+const format = 'p2tr';
 const {from} = Buffer;
 const {fromHex} = Transaction;
 const fuzzBlocks = 100;
@@ -79,7 +80,7 @@ const {min} = Math;
 const minTokens = 10000;
 const minBlockMs = 1000 * 60;
 const pollInterval = {btcregtest: 100};
-const ppmRate = (fee, total) => fee * 1e6 / total.tokens;
+const ppmRate = (fee, total) => fee * 1e6 / total;
 const preimageByteLength = 32;
 const pubKeyAsInternalKey = key => Buffer.from(key).slice(1).toString('hex');
 const pushSecret = asyncTimeout(releaseSwapOutSecret, 1000 * 30);
@@ -155,7 +156,7 @@ module.exports = (args, cbk) => {
           return cbk(null, {address: args.sweep_address});
         }
 
-        return createChainAddress({lnd: args.lnd}, cbk);
+        return createChainAddress({format, lnd: args.lnd}, cbk);
       }],
 
       // Get the current chain fee rate for the sweep fee rate calculation

package/swaps/complete_on_to_off_swap.js

@@ -42,9 +42,11 @@ const {typePayMetadata} = require('./swap_field_types');
 const bufferAsHex = buffer => buffer.toString('hex');
 const defaultMaxFundingConfirmationDelay = 12;
 const defaultMinDelta = 60;
+const estimatedSize = 150;
 const family = 805;
 const flatten = arr => [].concat(...arr);
 const {floor} = Math;
+const format = 'p2tr';
 const {from} = Buffer;
 const {fromHex} = Transaction;
 const fuzzBlocks = 100;
@@ -126,7 +128,7 @@ module.exports = (args, cbk) => {
 
       // Get an address to sweep out to
       getSweepAddress: ['validate', ({}, cbk) => {
-        return createChainAddress({lnd: args.lnd}, cbk);
+        return createChainAddress({format, lnd: args.lnd}, cbk);
       }],
 
       // Get the encryption key to decode the recovery secrets
@@ -370,6 +372,11 @@ module.exports = (args, cbk) => {
         });
 
         const refunds = uniqBy(feeRates, 'rate').map(({rate, height}) => {
+          // Exit early when there is nothing to recover
+          if (rate * estimatedSize > recoveryDetails.tokens) {
+            return;
+          }
+
           return taprootRefundTransaction({
             ecp,
             block_height: height,
@@ -388,7 +395,7 @@ module.exports = (args, cbk) => {
           });
         });
 
-        return cbk(null, refunds.map(n => n.transaction));
+        return cbk(null, refunds.filter(n => !!n).map(n => n.transaction));
       }],
 
       // Sign the refund transactions

package/swaps/manage_swap.js

@@ -13,6 +13,7 @@ const {returnResult} = require('asyncjs-util');
 const decodeOffToOnRequest = require('./decode_off_to_on_request');
 const decodeOffToOnRestart = require('./decode_off_to_on_restart');
 const {decodeTrade} = require('./../trades');
+const outputScriptForAddress = require('./output_script_for_address');
 const recoverResponseToSwapOut = require('./recover_response_to_swap_out');
 const requestSwapOut = require('./request_swap_out');
 const respondToSwapOutRequest = require('./respond_to_swap_out_request');
@@ -310,7 +311,10 @@ module.exports = (args, cbk) => {
               }
 
               try {
-                return !!toOutputScript(input, networks[getNetwork.bitcoinjs]);
+                return !!outputScriptForAddress({
+                  address: input,
+                  network: getNetwork.bitcoinjs,
+                });
               } catch (err) {
                 return 'Unsupported on-chain address format';
               }

package/swaps/output_script_for_address.js

@@ -0,0 +1,55 @@
+const {address} = require('bitcoinjs-lib');
+const {networks} = require('bitcoinjs-lib');
+
+const bufferAsHex = buffer => buffer.toString('hex');
+const byteLengthForP2tr = 32;
+const {fromBech32} = address;
+const prefixForP2tr = '5120';
+const toOutputScript = (a, n) => address.toOutputScript(a, n).toString('hex');
+const versionTaproot = 1;
+
+/** Get the output script for an address
+
+  {
+    address: <Address String>
+    network: <BitcoinJs Network Name String>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    script: <Output Script Hex String>
+  }
+*/
+module.exports = ({address, network}) => {
+  try {
+    return {
+      script: bufferAsHex(toOutputScript(address, networks[network])),
+    };
+  } catch (err) {
+    // Exit early when this is not a bech32 address
+    try {
+      fromBech32(address);
+    } catch (_) {
+      throw err;
+    }
+
+    const {data, prefix, version} = fromBech32(address);
+
+    if (prefix !== networks[network].bech32) {
+      throw new Error('InvalidNetworkToConvertAddressToOutputScript');
+    }
+
+    if (version !== versionTaproot) {
+      throw new Error('UnexpectedVersionOfAddressToConverToOutputScript');
+    }
+
+    if (data.length !== byteLengthForP2tr) {
+      throw new Error('UnexpectedByteLengthForPayToTaprootAddress');
+    }
+
+    return {script: `${prefixForP2tr}${bufferAsHex(data)}`};
+  }
+};

package/swaps/request_swap_out.js

@@ -31,6 +31,7 @@ const defaultFeeRate = 5000;
 const defaultMaxAmount = 21e14;
 const defaultMaxFeeForDeposit = 1337;
 const defaultSwapAmount = 2500000;
+const feeAsPpm = (fee, total) => Math.ceil(fee * 1e6 / total);
 const findRecord = (r, type) => (r.find(n => n.type === type) || {}).value;
 const {floor} = Math;
 const hexAsBuffer = hex => Buffer.from(hex, 'hex');
@@ -421,14 +422,19 @@ module.exports = (args, cbk) => {
 
         const deposit = mtokensAsTokens(response.deposit_mtokens);
 
+        const combinedFee = tokens - askForTokens + deposit;
         const serviceFee = tokensAsBigUnit(deposit);
         const totalFee = tokensAsBigUnit(tokens - askForTokens + deposit);
 
+        const ppmTotal = feeAsPpm(combinedFee, askForTokens);
+
+        const feeInfo = `total fee is ${totalFee}, est PPM ${ppmTotal}`
+
         return cbk(null, {
           deposit,
           fee: tokens - askForTokens,
           incoming_peer: response.incoming_peer,
-          pricing: `Execution cost ${serviceFee}, total fee is ${totalFee}`,
+          pricing: `Execution cost ${serviceFee}, ${feeInfo}`,
           rate: rateForFee(askForTokens, deposit + (tokens - askForTokens)),
           timeout: response.timeout,
         });

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

package/test/integration/test_request_swap_out.js

@@ -53,7 +53,7 @@ test(`Start offchain swap`, async ({end, equal, strictSame}) => {
       });
 
       await asyncRetry({interval, times}, async () => {
-        const {channels} = await getChannels({lnd, is_actve: true});
+        const {channels} = await getChannels({lnd, is_active: true});
 
         if (!!channels.length) {
           return channels;

package/test/integration/test_swap_with_claim_path.js

@@ -53,7 +53,7 @@ test(`Swap with claim path`, async ({end, equal, strictSame}) => {
       });
 
       await asyncRetry({interval, times}, async () => {
-        const {channels} = await getChannels({lnd, is_actve: true});
+        const {channels} = await getChannels({lnd, is_active: true});
 
         if (!!channels.length) {
           return channels;

package/test/integration/test_swap_with_refund_path.js

@@ -58,7 +58,7 @@ test(`Timeout a swap`, async ({end, equal, strictSame}) => {
       });
 
       await asyncRetry({interval, times}, async () => {
-        const {channels} = await getChannels({lnd, is_actve: true});
+        const {channels} = await getChannels({lnd, is_active: true});
 
         if (!!channels.length) {
           return channels;