paid-services 3.11.4 → 3.12.2

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Versions
 
+## Version 3.12.2
+
+- `serviceOpenTrade`: Fix regtest network support
+
+## 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/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.1",
-    "ln-sync": "3.10.1",
-    "tiny-secp256k1": "2.2.0"
+    "ln-service": "53.9.3",
+    "ln-sync": "3.11.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.4"
+  "version": "3.12.2"
 }

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/trades/network_record_from_network.js

@@ -25,7 +25,7 @@ module.exports = ({network}) => {
     return {};
 
   case regtestNetwork:
-    return {value: regestNetworkType};
+    return {value: regtestNetworkType};
 
   case testnetNetwork:
     return {value: testnetNetworkType};

package/trades/service_open_trade.js

@@ -140,7 +140,7 @@ module.exports = (args, cbk) => {
         });
 
         // Show the trade details blob
-        return args.logger.info({
+        args.logger.info({
           waiting_for_trade_request_to: openTrade.trade,
         });