paid-services 3.11.3 → 3.12.1

package/CHANGELOG.md

@@ -1,6 +1,10 @@
 # Versions
 
-## Version 3.11.3
+## Version 3.12.1
+
+- `balancedOpenRequest`: Add method to derive balanced open proposal details
+
+## Version 3.11.4
 
 - `changeChannelCapacity`: Add `nodes` to allow moving channel to another node
 

package/balanced/balanced_open_request.js

@@ -0,0 +1,157 @@
+const {parsePaymentRequest} = require('invoices');
+
+const {balancedChannelKeyTypes} = require('./service_key_types');
+
+const expectedRequestMtokens = '10000';
+const expectedResponseMtokens = '1000';
+const hexAsUtf8 = hex => Buffer.from(hex, 'hex').toString();
+const isHexHashSized = hex => hex.length === 64;
+const isHexNumberSized = hex => hex.length < 14;
+const isOdd = n => n % 2;
+const isPublicKey = n => !!n && /^0[2-3][0-9A-F]{64}$/i.test(n);
+const parseHexNumber = hex => parseInt(hex, 16);
+
+/** Derive a balanced open request from a received payment
+
+  {
+    confirmed_at: <Received Request At ISO 8601 Date String>
+    is_push: <Received Funds as Push Payment Bool>
+    payments: [{
+      messages: [{
+        type: <Message Record TLV Type String>
+        value: <Message Record Value Hex String>
+      }]
+    }]
+    received_mtokens: <Received Millitokens String>
+  }
+
+  @returns
+  {
+    [proposal]: {
+      accept_request: request,
+      capacity: parseHexNumber(channelCapacity.value),
+      fee_rate: parseHexNumber(fundingFeeRate.value),
+      partner_public_key: destination,
+      proposed_at: invoice.confirmed_at,
+      remote_multisig_key: remoteMultiSigKey.value,
+      remote_tx_id: remoteTxId.value,
+      remote_tx_vout: parseHexNumber(remoteTxVout.value),
+    }
+  }
+*/
+module.exports = args => {
+  // Exit early when not receiving a push of the proposal amount
+  if (!args.is_push || args.received_mtokens !== expectedRequestMtokens) {
+    return {}
+  }
+
+  const payment = args.payments.find(payment => {
+    return !!payment.messages.find(({type}) => {
+      return type === balancedChannelKeyTypes.accept_request;
+    });
+  });
+
+  // Exit early when there is no payment with an accept request
+  if (!payment) {
+    return {};
+  }
+
+  // The accept request is the reply request for the proposal
+  const acceptRequest = payment.messages.find(({type}) => {
+    return type === balancedChannelKeyTypes.accept_request;
+  });
+
+  const request = hexAsUtf8(acceptRequest.value);
+
+  // Make sure the accept payment request is a regular one
+  try {
+    parsePaymentRequest({request});
+  } catch (err) {
+    return {};
+  }
+
+  const {destination, mtokens} = parsePaymentRequest({request});
+
+  // The accept payment request should request the expected amount
+  if (mtokens !== expectedResponseMtokens) {
+    return {};
+  }
+
+  // Find the requested channel capacity
+  const channelCapacity = payment.messages.find(({type}) => {
+    return type === balancedChannelKeyTypes.channel_capacity;
+  });
+
+  // Exit early when there is no channel capacity
+  if (!channelCapacity || !isHexNumberSized(channelCapacity.value)) {
+    return {};
+  }
+
+  // Exit early when the capacity doesn't make sense for splitting equally
+  if (isOdd(parseHexNumber(channelCapacity.value))) {
+    return {};
+  }
+
+  // Find the requested chain fee rate
+  const fundingFeeRate = payment.messages.find(({type}) => {
+    return type === balancedChannelKeyTypes.funding_tx_fee_rate;
+  });
+
+  // Exit early when there is no fee rate
+  if (!fundingFeeRate || !isHexNumberSized(fundingFeeRate.value)) {
+    return {};
+  }
+
+  // There must be a non-zero fee rate
+  if (!parseHexNumber(fundingFeeRate.value)) {
+    return {};
+  }
+
+  // Find the remote multisig key for the open
+  const remoteMultiSigKey = payment.messages.find(({type}) => {
+    return type === balancedChannelKeyTypes.multisig_public_key;
+  });
+
+  // Exit early when there is no remote multisig key
+  if (!remoteMultiSigKey) {
+    return {};
+  }
+
+  // The remote multisig key must be a public key
+  if (!isPublicKey(remoteMultiSigKey.value)) {
+    return {};
+  }
+
+  // Find the remote transaction UTXO transaction id
+  const remoteTxId = payment.messages.find(({type}) => {
+    return type === balancedChannelKeyTypes.transit_tx_id;
+  });
+
+  // Exit early when there is no tx id
+  if (!remoteTxId || !isHexHashSized(remoteTxId.value)) {
+    return {};
+  }
+
+  // Find the remote transaction UTXO transaction output index
+  const remoteTxVout = payment.messages.find(({type}) => {
+    return type === balancedChannelKeyTypes.transit_tx_vout;
+  });
+
+  // Exit early when there is no tx vout
+  if (!remoteTxVout || !isHexNumberSized(remoteTxVout.value)) {
+    return {};
+  }
+
+  return {
+    proposal: {
+      accept_request: request,
+      capacity: parseHexNumber(channelCapacity.value),
+      fee_rate: parseHexNumber(fundingFeeRate.value),
+      partner_public_key: destination,
+      proposed_at: args.confirmed_at,
+      remote_multisig_key: remoteMultiSigKey.value,
+      remote_tx_id: remoteTxId.value,
+      remote_tx_vout: parseHexNumber(remoteTxVout.value),
+    },
+  };
+};

package/balanced/index.js

@@ -0,0 +1,3 @@
+const balancedOpenRequest = require('./balanced_open_request');
+
+module.exports = {balancedOpenRequest};

package/balanced/service_key_types.json

@@ -0,0 +1,12 @@
+{
+  "balancedChannelKeyTypes": {
+    "accept_request": "80501",
+    "channel_capacity": "80502",
+    "funding_signature": "80503",
+    "funding_tx_fee_rate": "80504",
+    "multisig_public_key": "80505",
+    "transit_public_key": "80506",
+    "transit_tx_id": "80507",
+    "transit_tx_vout": "80508"
+  }
+}

package/capacity/get_capacity_replacement.js

@@ -293,8 +293,22 @@ module.exports = (args, cbk) => {
         return cbk(null, newCapacity);
       }],
 
+      // Make sure that we are still connected to the original peer
+      confirmConnection: [
+        'newCapacity',
+        'pendingChannel',
+        ({pendingChannel}, cbk) =>
+      {
+        return connectPeer({
+          id: pendingChannel.partner_public_key,
+          lnd: args.open_lnd,
+        },
+        cbk);
+      }],
+
       // Propose the new channel to replace the existing one
       proposeChannel: [
+        'confirmConnection',
         'newCapacity',
         'pendingChannel',
         ({newCapacity, pendingChannel}, cbk) =>

package/capacity/propose_capacity_change.js

@@ -351,12 +351,24 @@ module.exports = (args, cbk) => {
 
         // Listen to new blocks to wait for the channel change confirmation
         const sub = subscribeToBlocks({lnd: args.lnd});
+        let isFinished = false;
 
-        // Fail with error when the blocks subscription is lost
-        sub.on('error', err => {
+        // Avoid multiple callbacks
+        const done = (err, res) => {
           sub.removeAllListeners();
 
-          return cbk([503, 'LostBlockchainSubscription', {err}]);
+          if (isFinished) {
+            return;
+          }
+
+          isFinished = true;
+
+          return cbk(err, res);
+        };
+
+        // Fail with error when the blocks subscription is lost
+        sub.on('error', err => {
+          return done([503, 'LostBlockchainSubscription', {err}]);
         });
 
         // Publish the new channel transaction when a block is received
@@ -383,9 +395,7 @@ module.exports = (args, cbk) => {
 
             // The new channel confirmed successfully and so the change worked
             if (!!channel && !!channel.is_active) {
-              sub.removeAllListeners();
-
-              return cbk(null, {is_success: true});
+              return done(null, {is_success: true});
             }
           } catch (err) {
             args.logger.error({err});
@@ -419,9 +429,7 @@ module.exports = (args, cbk) => {
 
             // The old channel force closed and so the change fully failed
             if (!!channel && channel.close_transaction_id !== txId) {
-              sub.removeAllListeners();
-
-              return cbk(null, {is_success: false});
+              return done(null, {is_success: false});
             }
           } catch (err) {
             args.logger.error({err});

package/index.js

@@ -1,3 +1,4 @@
+const {balancedOpenRequest} = require('./balanced');
 const {changeChannelCapacity} = require('./capacity');
 const {confirmServiceUse} = require('./client');
 const {createAnchoredTrade} = require('./trades');
@@ -17,6 +18,7 @@ const {servicePeerRequests} = require('./p2p');
 const serviceIds = schema.types;
 
 module.exports = {
+  balancedOpenRequest,
   changeChannelCapacity,
   confirmServiceUse,
   createAnchoredTrade,

package/package.json

@@ -13,9 +13,9 @@
     "bolt07": "1.8.0",
     "ecpair": "2.0.1",
     "invoices": "2.0.4",
-    "ln-service": "53.9.0",
+    "ln-service": "53.9.2",
     "ln-sync": "3.10.1",
-    "tiny-secp256k1": "2.2.0"
+    "tiny-secp256k1": "2.2.1"
   },
   "description": "Lightning Paid Services library",
   "devDependencies": {
@@ -40,7 +40,7 @@
   },
   "scripts": {
     "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/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"
+    "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.11.3"
+  "version": "3.12.1"
 }

package/test/balanced/test_balanced_open_request.js

@@ -0,0 +1,178 @@
+const {test} = require('@alexbosworth/tap');
+
+const method = require('./../../balanced/balanced_open_request');
+
+const makeMessages = overrides => {
+  const args = {
+    '80501': Buffer.from('lntb10n1p3p6msgpp5s3xkaa2gg8q2zgmva8k9ruh3r7falxqdmkadac06wxc8fkqu4x0qdqqcqzpgxqr23ssp5ukm2dcl8wzfztx63758gmdjkna8jycypey880lenh082060fem4s9qyyssqul9nlwtpxqs2qegvpl9amltr4d9d8k9e008gr5ymv4aqkerel7dknusv60gtedgfvl3pq5lzg6c4sk4xf7lmlqtwr97cx047hpj9zqcp3mqur9').toString('hex'),
+    '80502': (2e6).toString(16),
+    '80504': (255).toString(16),
+    '80505': Buffer.alloc(33, 2).toString('hex'),
+    '80507': Buffer.alloc(32).toString('hex'),
+    '80508': (255).toString(16),
+  };
+
+  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
+
+  const messages = Object.keys(args)
+    .filter(type => args[type] !== undefined)
+    .map(type => ({type, value: args[type]}));
+
+  return messages;
+};
+
+const makeArgs = overrides => {
+  const args = {
+    confirmed_at: new Date(0).toISOString(),
+    is_push: true,
+    payments: [{messages: makeMessages({})}],
+    received_mtokens: '10000',
+  };
+
+  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
+
+  return args;
+};
+
+const tests = [
+  {
+    args: makeArgs({is_push: false}),
+    description: 'A balanced open is a push',
+    expected: {},
+  },
+  {
+    args: makeArgs({received_mtokens: '10'}),
+    description: 'A balanced open receives 10 sats',
+    expected: {},
+  },
+  {
+    args: makeArgs({
+      payments: [{messages: makeMessages({'80501': undefined})}],
+    }),
+    description: 'A balanced open has a reply request',
+    expected: {},
+  },
+  {
+    args: makeArgs({
+      payments: [{messages: makeMessages({'80501': 'invalid request'})}],
+    }),
+    description: 'A balanced open has a valid reply request',
+    expected: {},
+  },
+  {
+    args: makeArgs({
+      payments: [{
+        messages: makeMessages({
+          '80501': Buffer.from('lnbc1pvjluezsp5zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zygspp5qqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqypqdpl2pkx2ctnv5sxxmmwwd5kgetjypeh2ursdae8g6twvus8g6rfwvs8qun0dfjkxaq9qrsgq357wnc5r2ueh7ck6q93dj32dlqnls087fxdwk8qakdyafkq3yap9us6v52vjjsrvywa6rt52cm9r9zqt8r2t7mlcwspyetp5h2tztugp9lfyql').toString('hex'),
+        }),
+      }],
+    }),
+    description: 'A balanced open has a reply request with the correct amount',
+    expected: {},
+  },
+  {
+    args: makeArgs({
+      payments: [{messages: makeMessages({'80502': undefined})}],
+    }),
+    description: 'A balanced open has capacity',
+    expected: {},
+  },
+  {
+    args: makeArgs({
+      payments: [{
+        messages: makeMessages({'80502': Buffer.alloc(32).toString('hex')}),
+      }],
+    }),
+    description: 'A balanced open has numeric capacity',
+    expected: {},
+  },
+  {
+    args: makeArgs({payments: [{messages: makeMessages({'80502': '01'})}]}),
+    description: 'A balanced open has even capacity',
+    expected: {},
+  },
+  {
+    args: makeArgs({
+      payments: [{messages: makeMessages({'80504': undefined})}],
+    }),
+    description: 'A balanced open has a fee rate',
+    expected: {},
+  },
+  {
+    args: makeArgs({
+      payments: [{
+        messages: makeMessages({'80504': Buffer.alloc(32).toString('hex')}),
+      }],
+    }),
+    description: 'A balanced open has a numeric fee rate',
+    expected: {},
+  },
+  {
+    args: makeArgs({payments: [{messages: makeMessages({'80504': '00'})}]}),
+    description: 'A balanced open has non zero fee rate',
+    expected: {},
+  },
+  {
+    args: makeArgs({
+      payments: [{messages: makeMessages({'80505': undefined})}],
+    }),
+    description: 'A balanced open has a remote multisig key',
+    expected: {},
+  },
+  {
+    args: makeArgs({
+      payments: [{messages: makeMessages({'80505': Buffer.alloc(32)})}],
+    }),
+    description: 'A balanced open has a remote multisig public key',
+    expected: {},
+  },
+  {
+    args: makeArgs({
+      payments: [{messages: makeMessages({'80507': undefined})}],
+    }),
+    description: 'A balanced open has a tx id',
+    expected: {},
+  },
+  {
+    args: makeArgs({payments: [{messages: makeMessages({'80507': '00'})}]}),
+    description: 'A balanced open has a regular sized tx id',
+    expected: {},
+  },
+  {
+    args: makeArgs({
+      payments: [{messages: makeMessages({'80508': undefined})}],
+    }),
+    description: 'A balanced open has a tx vout',
+    expected: {},
+  },
+  {
+    args: makeArgs({}),
+    description: 'Derive a balanced open request',
+    expected: {
+      proposal: {
+        accept_request: 'lntb10n1p3p6msgpp5s3xkaa2gg8q2zgmva8k9ruh3r7falxqdmkadac06wxc8fkqu4x0qdqqcqzpgxqr23ssp5ukm2dcl8wzfztx63758gmdjkna8jycypey880lenh082060fem4s9qyyssqul9nlwtpxqs2qegvpl9amltr4d9d8k9e008gr5ymv4aqkerel7dknusv60gtedgfvl3pq5lzg6c4sk4xf7lmlqtwr97cx047hpj9zqcp3mqur9',
+        capacity: 2000000,
+        fee_rate: 255,
+        partner_public_key: '020ec0c6a0c4fe5d8a79928ead294c36234a76f6e0dca896c35413612a3fd8dbf8',
+        proposed_at: '1970-01-01T00:00:00.000Z',
+        remote_multisig_key: '020202020202020202020202020202020202020202020202020202020202020202',
+        remote_tx_id: '0000000000000000000000000000000000000000000000000000000000000000',
+        remote_tx_vout: 255,
+      },
+    },
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async ({end, strictSame, throws}) => {
+    if (!!error) {
+      throws(() => method(args), new Error(error), 'Got error');
+    } else {
+      const res = method(args);
+
+      strictSame(res, expected, 'Got expected result');
+    }
+
+    return end();
+  });
+});

package/test/integration/test_accept_capacity_change.js

@@ -6,6 +6,7 @@ const {broadcastChainTransaction} = require('ln-service');
 const {closeChannel} = require('ln-service');
 const {createChainAddress} = require('ln-service');
 const {getChainTransactions} = require('ln-service');
+const {getChannel} = require('ln-service');
 const {getChannels} = require('ln-service');
 const {getNetwork} = require('ln-sync');
 const {networks} = require('bitcoinjs-lib');
@@ -51,18 +52,30 @@ test(`Accept capacity replacement`, async ({end, equal, strictSame}) => {
 
   try {
     // Open up a new channel
-    const channelOpen = await openChannel({
-      lnd,
-      local_tokens: capacity,
-      partner_public_key: target.id,
-      partner_socket: target.socket,
+    const channelOpen = await asyncRetry({interval, times}, async () => {
+      return await openChannel({
+        lnd,
+        local_tokens: capacity,
+        partner_public_key: target.id,
+        partner_socket: target.socket,
+      });
     });
 
     // Wait for the channel to be active
     const channel = await asyncRetry({interval, times}, async () => {
       const [channel] = (await getChannels({lnd})).channels;
 
-      if (!!channel && !!channel.is_active) {
+      if (!channel) {
+        await generate({});
+
+        throw new Error('ExpectedInitialChannelActivation');
+      }
+
+      const {policies} = await getChannel({lnd, id: channel.id});
+
+      const [missingCltv] = policies.filter(n => !n.cltv_delta);
+
+      if (!!channel && !!channel.is_active && !missingCltv) {
         return channel;
       }
 

package/test/integration/test_change_channel_capacity.js

@@ -46,12 +46,14 @@ test(`Accept capacity replacement`, async ({end, equal, strictSame}) => {
 
   try {
     // Open up a new channel
-    const channelOpen = await openChannel({
-      lnd,
-      is_private: true,
-      local_tokens: capacity,
-      partner_public_key: target.id,
-      partner_socket: target.socket,
+    const channelOpen = await asyncRetry({interval, times}, async () => {
+      return await openChannel({
+        lnd,
+        is_private: true,
+        local_tokens: capacity,
+        partner_public_key: target.id,
+        partner_socket: target.socket,
+      });
     });
 
     // Wait for the channel to be active