paid-services 3.4.0 → 3.7.0

package/capacity/propose_channel_open.js

@@ -0,0 +1,54 @@
+const {acceptsChannelOpen} = require('ln-sync');
+const asyncAuto = require('async/auto');
+const {connectPeer} = require('ln-sync');
+const {returnResult} = require('asyncjs-util');
+
+/** Check that a channel open would be accepted by a node
+
+  {
+    capacity: <Capacity Tokens Number>
+    id: <Node Identity Public Key Hex String>
+    lnd: <Authenticated LND API Object>
+  }
+
+  @returns via cbk or Promise
+  {
+    is_accepted: <Channel Proposal Is Accepted Bool>
+  }
+*/
+module.exports = ({capacity, id, lnd}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!capacity) {
+          return cbk([400, 'ExpectedCapacityTokensToProposeChannelOpen']);
+        }
+
+        if (!id) {
+          return cbk([400, 'ExpectedNodePublicKeyToProposeChannelOpen']);
+        }
+
+        if (!lnd) {
+          return cbk([400, 'ExpectedAuthenticatedLndToProposeChannelOpen']);
+        }
+
+        return cbk();
+      },
+
+      // Connect to the peer
+      connect: ['validate', ({}, cbk) => connectPeer({id, lnd}, cbk)],
+
+      // Propose a channel open to check acceptance
+      checkAccept: ['connect', ({}, cbk) => {
+        return acceptsChannelOpen({
+          capacity,
+          lnd,
+          partner_public_key: id,
+        },
+        cbk);
+      }],
+    },
+    returnResult({reject, resolve, of: 'checkAccept'}, cbk));
+  });
+};

package/package.json

@@ -7,20 +7,20 @@
     "url": "https://github.com/alexbosworth/paid-services/issues"
   },
   "dependencies": {
-    "async": "3.2.2",
-    "asyncjs-util": "1.2.7",
+    "async": "3.2.3",
+    "asyncjs-util": "1.2.8",
     "bolt01": "1.2.3",
     "bolt07": "1.8.0",
-    "invoices": "2.0.2",
-    "ln-service": "53.2.0",
-    "ln-sync": "3.6.0"
+    "invoices": "2.0.3",
+    "ln-service": "53.4.0",
+    "ln-sync": "3.6.1"
   },
   "description": "Lightning Paid Services library",
   "devDependencies": {
     "@alexbosworth/tap": "15.0.10",
-    "ln-docker-daemons": "2.1.0",
+    "ln-docker-daemons": "2.2.0",
     "mock-lnd": "1.4.1",
-    "secp256k1": "4.0.2"
+    "secp256k1": "4.0.3"
   },
   "engines": {
     "node": ">=12.20"
@@ -37,8 +37,8 @@
     "url": "https://github.com/alexbosworth/paid-services.git"
   },
   "scripts": {
-    "integration-tests": "tap --branches=1 --functions=1 --lines=1 --statements=1 -t 120 test/integration/*.js",
+    "integration-tests": "tap --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"
   },
-  "version": "3.4.0"
+  "version": "3.7.0"
 }

package/services/response_for_relay.js

@@ -18,7 +18,6 @@ const defaultProbeTimeoutMs = 1000 * 60 * 5;
 const expiresAt = () => new Date(Date.now() + 1000 * 60 * 30).toISOString();
 const interval = 1000 * 60 * 10;
 const rateDivisor = BigInt(1e6);
-const sumOf = arr => arr.reduce((sum, n) => BigInt(n) + n, BigInt(0));
 const text = 'Relay payment request created';
 const times = 12;
 

package/test/capacity/test_capacity_change_requests.js

@@ -34,6 +34,7 @@ const tests = [
         from: Buffer.alloc(33, 3).toString('hex'),
         id: Buffer.alloc(32).toString('hex'),
         increase: undefined,
+        type: undefined,
       }],
     },
   },

package/test/capacity/test_encode_change_request.js

@@ -8,6 +8,7 @@ const makeArgs = overrides => {
     decrease: 0,
     id: Buffer.alloc(32).toString('hex'),
     increase: undefined,
+    type: 1,
   };
 
   Object.keys(overrides).forEach(k => args[k] = overrides[k]);
@@ -29,6 +30,10 @@ const tests = [
           type: '2',
           value: '0000000000000000',
         },
+        {
+          type: '5',
+          value: '01',
+        },
       ],
     },
   },

package/test/capacity/test_parse_capacity_change_request.js

@@ -31,6 +31,7 @@ const tests = [
         channel: '102x1x0',
         from: '0218819f4e0dbab6c6bc434913bace0b69f20d832f68934acd72fc610a9b76fe30',
         id: '2bf4a6bf1b97aff5bbb760f1aa7a5705c885194b4e29d42e5576498107f02361',
+        type: undefined,
       },
     },
   },

package/test/integration/test_accept_capacity_change.js

@@ -32,7 +32,6 @@ const maturity = 100;
 const proposeCapacityChange = propose;
 const signCapacityReplacement = method;
 const size = 2;
-const sumOf = arr => arr.reduce((sum, n) => sum + n, 0);
 const times = 2000;
 const {toOutputScript} = address;
 const weightAsVBytes = n => Math.ceil(n / 4);
@@ -61,15 +60,15 @@ test(`Accept capacity replacement`, async ({end, equal, strictSame}) => {
 
     // Wait for the channel to be active
     const channel = await asyncRetry({interval, times}, async () => {
-      const [channel] = (await getChannels({lnd, is_active: true})).channels;
+      const [channel] = (await getChannels({lnd})).channels;
 
-      if (!!channel) {
+      if (!!channel && !!channel.is_active) {
         return channel;
       }
 
       await generate({});
 
-      throw new Error('ExpectedChannelActivation');
+      throw new Error('ExpectedInitialChannelActivation');
     });
 
     // Find the open tx

package/test/integration/test_change_channel_capacity.js

@@ -27,7 +27,6 @@ const log = () => {};
 const maturity = 100;
 const size = 2;
 const slow = 5000;
-const sumOf = arr => arr.reduce((sum, n) => sum + n, 0);
 const times = 2000;
 const {toOutputScript} = address;
 const weightAsVBytes = n => Math.ceil(n / 4);
@@ -88,6 +87,10 @@ test(`Accept capacity replacement`, async ({end, equal, strictSame}) => {
               return cbk({amount: '0'});
             }
 
+            if (args.name === 'decrease') {
+              return cbk({decrease: 'internal_spend_funds'});
+            }
+
             if (args.name === 'direction') {
               return cbk({direction: 'decrease'});
             }
@@ -104,6 +107,10 @@ test(`Accept capacity replacement`, async ({end, equal, strictSame}) => {
               return cbk({query: target.id});
             }
 
+            if (args.name === 'type') {
+              return cbk({type: args.default});
+            }
+
             throw new Error('UnknownQueryNameForInitiator');
           },
           logger: {error: log, info: log},

package/test/integration/test_decrease_channel_capacity.js

@@ -27,7 +27,6 @@ const logger = {error: () => {}, info: () => {}};
 const maturity = 100;
 const size = 2;
 const slow = 3000;
-const sumOf = arr => arr.reduce((sum, n) => sum + n, 0);
 const times = 2000;
 const {toOutputScript} = address;
 const weightAsVBytes = n => Math.ceil(n / 4);
@@ -47,11 +46,13 @@ test(`Decrease 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
@@ -88,6 +89,10 @@ test(`Decrease capacity replacement`, async ({end, equal, strictSame}) => {
               return cbk({amount: '200000'});
             }
 
+            if (args.name === 'decrease') {
+              return cbk({decrease: 'internal_spend_funds'});
+            }
+
             if (args.name === 'direction') {
               return cbk({direction: 'decrease'});
             }
@@ -116,6 +121,10 @@ test(`Decrease capacity replacement`, async ({end, equal, strictSame}) => {
               return cbk({query: target.id});
             }
 
+            if (args.name === 'type') {
+              return cbk({type: 'Private'});
+            }
+
             throw new Error('UnexpectedQueryNameForProposingSide');
           },
         });
@@ -124,7 +133,9 @@ test(`Decrease capacity replacement`, async ({end, equal, strictSame}) => {
       // Wait to see the inbound proposal
       waitForProposal: async () => {
         await asyncRetry({interval, times}, async () => {
-          const {requests} = await getCapacityChangeRequests({lnd: target.lnd});
+          const {requests} = await getCapacityChangeRequests({
+            lnd: target.lnd,
+          });
 
           if (!requests.length) {
             throw new Error('FailedToFindChangeRequest');
@@ -159,7 +170,9 @@ test(`Decrease capacity replacement`, async ({end, equal, strictSame}) => {
           interval: slow,
         },
         async () => {
-          const [channel] = (await getChannels({lnd, is_active: true})).channels.filter(n => n.capacity < capacity);
+          const {channels} = await getChannels({lnd, is_active: true});
+
+          const [channel] = channels.filter(n => n.capacity < capacity);
 
           await generate({});
 
@@ -167,6 +180,8 @@ test(`Decrease capacity replacement`, async ({end, equal, strictSame}) => {
             throw new Error('ExpectedChannelActivation');
           }
 
+          equal(channel.is_private, true, 'Channel is changed to private');
+
           {
             const {policies} = await getChannel({lnd, id: channel.id});
 

package/test/integration/test_increase_channel_capacity.js

@@ -26,7 +26,6 @@ const interval = 10;
 const logger = {error: () => {}, info: () => {}};
 const maturity = 100;
 const size = 2;
-const sumOf = arr => arr.reduce((sum, n) => sum + n, 0);
 const times = 2000;
 const {toOutputScript} = address;
 const weightAsVBytes = n => Math.ceil(n / 4);
@@ -111,6 +110,10 @@ test(`Accept capacity replacement`, async ({end, equal, strictSame}) => {
               return cbk({query: target.id});
             }
 
+            if (args.name === 'type') {
+              return cbk({type: args.default});
+            }
+
             throw new Error('UnexpectedQueryNameForProposingSide');
           },
         });

package/test/integration/test_split_channel_capacity.js

@@ -0,0 +1,241 @@
+const {addPeer} = require('ln-service');
+const {address} = require('bitcoinjs-lib');
+const asyncAuto = require('async/auto');
+const asyncMap = require('async/map');
+const asyncRetry = require('async/retry');
+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');
+const {openChannel} = require('ln-service');
+const {spawnLightningCluster} = require('ln-docker-daemons');
+const {test} = require('@alexbosworth/tap');
+const {Transaction} = require('bitcoinjs-lib');
+
+const {changeChannelCapacity} = require('./../../capacity');
+const {getCapacityChangeRequests} = require('./../../capacity');
+
+const bufferAsHex = buffer => buffer.toString('hex');
+const capacity = 1e6;
+const {fromHex} = Transaction;
+const id = Buffer.alloc(32).toString('hex');
+const interval = 10;
+const logger = {error: () => {}, info: () => {}};
+const maturity = 100;
+const size = 3;
+const slow = 3000;
+const splitCapacity = 200000;
+const sumOf = arr => arr.reduce((sum, n) => sum + n, 0);
+const times = 2000;
+const {toOutputScript} = address;
+const weightAsVBytes = n => Math.ceil(n / 4);
+
+// A capacity replacement proposal should be counter signed and accepted
+test(`Decrease capacity replacement`, async ({end, equal, strictSame}) => {
+  const {kill, nodes} = await spawnLightningCluster({size});
+
+  const [control, target, remote] = nodes;
+
+  const {generate, lnd} = control;
+
+  const network = networks[(await getNetwork({lnd})).bitcoinjs];
+
+  // Make some funds
+  await generate({count: maturity});
+
+  // Add remote as a peer
+  await addPeer({lnd, public_key: remote.id, socket: remote.socket});
+
+  try {
+    // Open up a new channel
+    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, is_active: true})).channels;
+
+      if (!channel) {
+        await generate({});
+
+        throw new Error('ExpectedChannelActivation');
+      }
+
+      const {policies} = await getChannel({lnd, id: channel.id});
+
+      const noPolicy = policies.find(n => !n.cltv_delta);
+
+      if (!!channel && !noPolicy) {
+        return channel;
+      }
+
+      await generate({});
+
+      throw new Error('ExpectedChannelActivation');
+    });
+
+    await asyncAuto({
+      // Propose the channel
+      propose: async () => {
+        await changeChannelCapacity({
+          lnd,
+          logger,
+          ask: (args, cbk) => {
+            if (args.name === 'add') {
+              return cbk({add: false});
+            }
+
+            if (args.name === 'amount') {
+              return cbk({amount: splitCapacity});
+            }
+
+            if (args.name === 'decrease') {
+              return cbk({decrease: 'open_channel'});
+            }
+
+            if (args.name === 'direction') {
+              return cbk({direction: 'decrease'});
+            }
+
+            if (args.name === 'internal') {
+              return cbk({internal: true});
+            }
+
+            if (args.name === 'key') {
+              return cbk({key: remote.id});
+            }
+
+            if (args.name === 'ok') {
+              return cbk({ok: true});
+            }
+
+            if (args.name === 'proceed') {
+              return cbk({proceed: true});
+            }
+
+            if (args.name === 'rate') {
+              return cbk({rate: args.default});
+            }
+
+            if (args.name === 'spend') {
+              return cbk({spend: false});
+            }
+
+            if (args.name === 'query') {
+              return cbk({query: target.id});
+            }
+
+            if (args.name === 'type') {
+              return cbk({type: 'Private'});
+            }
+
+            throw new Error('UnexpectedQueryNameForProposingSide');
+          },
+        });
+      },
+
+      // Wait to see the inbound proposal
+      waitForProposal: async () => {
+        await asyncRetry({interval, times}, async () => {
+          const {requests} = await getCapacityChangeRequests({
+            lnd: target.lnd,
+          });
+
+          if (!requests.length) {
+            throw new Error('FailedToFindChangeRequest');
+          }
+        });
+      },
+
+      // Accept the channel
+      accept: ['waitForProposal', async ({}) => {
+        await changeChannelCapacity({
+          logger,
+          ask: (args, cbk) => {
+            if (args.name === 'accept') {
+              return cbk({accept: true});
+            }
+
+            if (args.name === 'ok') {
+              return cbk({ok: true});
+            }
+
+            throw new Error('UnexpectedQueryNameForAcceptingSide');
+          },
+          lnd: target.lnd,
+        });
+      }],
+
+      // Generate to confirm the change
+      generate: ['waitForProposal', async ({}) => {
+        // Wait for the new channel to be active
+        const recreated = await asyncRetry({
+          times,
+          interval: slow,
+        },
+        async () => {
+          const {channels} = await getChannels({lnd, is_active: true});
+
+          const [channel] = channels
+            .filter(n => n.is_private)
+            .filter(n => n.capacity < capacity);
+
+          await generate({});
+
+          if (!channel) {
+            throw new Error('ExpectedChannelActivation');
+          }
+
+          const channelWithRemote = channels.find(channel => {
+            return channel.partner_public_key === remote.id;
+          });
+
+          equal(channelWithRemote.capacity, splitCapacity, 'Remote created');
+
+          {
+            const {policies} = await getChannel({lnd, id: channel.id});
+
+            const noPolicy = policies.find(n => !n.cltv_delta);
+
+            if (!!noPolicy) {
+              throw new Error('ExpectedChannelPolicy');
+            }
+          };
+
+          {
+            const {policies} = await getChannel({
+              id: channel.id,
+              lnd: target.lnd,
+            });
+
+            const noPolicy = policies.find(n => !n.cltv_delta);
+
+            if (!!noPolicy) {
+              throw new Error('ExpectedChannelPolicy');
+            }
+          };
+
+          return;
+        });
+
+        return;
+      }],
+    });
+  } catch (err) {
+    strictSame(err, null, 'Expected no failure');
+  } finally {
+    await kill({});
+  }
+
+  return end();
+});

package/trades/accept_trade.js

@@ -1,6 +1,7 @@
 const asyncAuto = require('async/auto');
 const asyncEach = require('async/each');
 const {cancelHodlInvoice} = require('ln-service');
+const {getInvoice} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 const {settleHodlInvoice} = require('ln-service');
 
@@ -10,13 +11,14 @@ const {isArray} = Array;
 
   {
     cancel: [<Alternative Invoice Id Hex String>]
+    id: <Trade Id Hex String>
     lnd: <Authenticated LND API Object>
     secret: <Invoice to Settle Preimage Hex String>
   }
 
   @returns via cbk or Promise
 */
-module.exports = ({cancel, lnd, secret}, cbk) => {
+module.exports = ({cancel, id, lnd, secret}, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
@@ -25,6 +27,10 @@ module.exports = ({cancel, lnd, secret}, cbk) => {
           return cbk([400, 'ExpectedArrayOfIdsToCancelToAcceptTrade']);
         }
 
+        if (!id) {
+          return cbk([400, 'ExpectedAnchorTradeIdToAcceptTrade']);
+        }
+
         if (!lnd) {
           return cbk([400, 'ExpectedAuthenticatedLndToAcceptTrade']);
         }
@@ -36,9 +42,12 @@ module.exports = ({cancel, lnd, secret}, cbk) => {
         return cbk();
       },
 
+      // Fetch the anchor invoice to make sure it's still open
+      getAnchor: ['validate', ({}, cbk) => getInvoice({id, lnd}, cbk)],
+
       // Cancel alternative invoices so that only one resolves as settled
-      cancel: ['validate', ({}, cbk) => {
-        return asyncEach(cancel, (id, cbk) => {
+      cancel: ['getAnchor', ({}, cbk) => {
+        return asyncEach([].concat(cancel).concat(id), (id, cbk) => {
           return cancelHodlInvoice({id, lnd}, cbk);
         },
         cbk);