paid-services 3.15.2 → 3.16.0

package/CHANGELOG.md

@@ -1,6 +1,10 @@
 # Versions
 
-## Version 3.15.2
+## Version 3.16.0
+
+- `manageSwap`: Add external funding, conf target setting, keysend pushes
+
+## Version 3.15.4
 
 - `manageSwap`: Add method to execute submarine swaps on testnet
 

package/package.json

@@ -16,7 +16,7 @@
     "ecpair": "2.0.1",
     "goldengate": "11.2.1",
     "invoices": "2.0.6",
-    "ln-service": "53.14.1",
+    "ln-service": "53.15.0",
     "ln-sync": "3.12.0",
     "psbt": "2.0.1",
     "p2tr": "1.3.1",
@@ -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.15.2"
+  "version": "3.16.0"
 }

package/service_types.json

@@ -6,6 +6,7 @@
   "serviceTypeReceiveChannelSale": "8050008",
   "serviceTypeRequestChannelSale": "8050007",
   "serviceTypeSignCapacityChange": "8050004",
+  "serviceTypeSwapResponse": "8050009",
   "serviceTypeWaitOnConfirmation": "8050003",
   "types": {
     "8050001": "serviceTypeChangeCapacity",
@@ -15,6 +16,7 @@
     "8050005": "serviceTypeRequestTrades",
     "8050006": "serviceTypeReceiveTrades",
     "8050007": "serviceTypeRequestChannelSale",
-    "8050008": "serviceTypeReceiveChannelSale"
+    "8050008": "serviceTypeReceiveChannelSale",
+    "8050009": "serviceTypeSwapResponse"
   }
 }

package/swaps/complete_off_to_on_swap.js

@@ -81,6 +81,7 @@ const v1AddressWords = key => [].concat(1).concat(bech32m.toWords(key));
   {
     emitter: <Event Emitter Object>
     [is_avoiding_broadcast]: <Avoid Sweep Broadcast Bool>
+    [is_external_funding]: <Externally Fund Swap Bool>
     [is_uncooperative]: <Avoid Cooperative Signing Bool>
     lnd: <Autenticated LND API Object>
     max_fee_deposit: <Max Routing Fee Tokens For Deposit Number>
@@ -236,6 +237,12 @@ module.exports = (args, cbk) => {
       payToFund: ['responseDetails', asyncReflect(({responseDetails}, cbk) => {
         const request = responseDetails.request;
 
+        if (!!args.is_external_funding) {
+          args.emitter.emit('update', {pay_to_fund_swap_offchain: request});
+
+          return cbk();
+        }
+
         args.emitter.emit('update', {funding_swap_offchain: request});
 
         return pay({
@@ -906,9 +913,9 @@ module.exports = (args, cbk) => {
 
         return cbk(null, {
           paid_execution_fee: deposit.tokens,
-          paid_execution_routing: deposit.fee,
+          paid_execution_routing: deposit.fee || undefined,
           swap_payment_sent: funding.tokens,
-          swap_payment_routing_fee: funding.fee,
+          swap_payment_routing_fee: funding.fee || undefined,
         });
       }],
     },

package/swaps/complete_on_to_off_swap.js

@@ -68,9 +68,9 @@ const witnessLengthTimeoutSweep = 3;
 /** Complete the on-chain side of the swap by taking the off-chain funds
 
   {
+    [confirmation_target]: <Funding Confirmation Target Number>
     emitter: <Event Emitter Object>
     [is_ignoring_deposit]: <Ignore Held Deposit Funds Bool>
-    [fund_fee_rate]: <Fund Chain Fee Rate Number>
     lnd: <Authenticated LND API Object>
     recovery: <Swap Recovery Hex String>
     [request]: <Request Function>
@@ -418,8 +418,7 @@ module.exports = (args, cbk) => {
             });
 
             return cbk(null, tx.toHex());
-          },
-          cbk);
+          });
         },
         cbk);
       }],
@@ -487,8 +486,8 @@ module.exports = (args, cbk) => {
 
         return fundPsbt({
           psbt,
-          fee_tokens_per_vbyte: args.fund_fee_rate,
           lnd: args.lnd,
+          target_confirmations: args.confirmation_target,
         },
         cbk);
       }],
@@ -681,7 +680,7 @@ module.exports = (args, cbk) => {
             transaction,
             lnd: args.lnd,
           },
-          err => {});
+          () => {});
         });
 
         subTimeout.on('error', err => done(err));

package/swaps/manage_swap.js

@@ -1,15 +1,32 @@
 const asyncAuto = require('async/auto');
-const {getNetwork} = require('ln-sync')
+const asyncMap = require('async/map');
+const {findKey} = require('ln-sync');
+const {getMasterPublicKeys} = require('ln-service');
+const {getAllInvoices} = require('ln-sync');
+const {getInvoice} = require('ln-service');
+const {getNetwork} = require('ln-sync');
+const {getNodeAlias} = require('ln-sync');
 const {returnResult} = require('asyncjs-util');
 
+const decodeOffToOnRequest = require('./decode_off_to_on_request');
+const {decodeTrade} = require('./../trades');
 const recoverResponseToSwapOut = require('./recover_response_to_swap_out');
 const requestSwapOut = require('./request_swap_out');
 const respondToSwapOutRequest = require('./respond_to_swap_out_request');
 
+const actionPushRequest = 'push-request';
 const allowedNetwork = 'btctestnet';
+const bip86Path = `m/86'/0'/0'`;
+const flatten = arr => [].concat(...arr);
+const minConfirmations = {btc: 2, btcregtest: 3, btctestnet: 1};
+const niceId = id => id.substring(0, 8);
+const niceName = node => `${node.alias} ${node.id.substring(0, 8)}`.trim();
+const pushesReceivedAfter = () => new Date(Date.now() - 1000 * 60 * 60 * 24);
 const recoverRespondAction = 'recover-response';
 const requestAction = 'request';
 const respondAction = 'respond';
+const tokensAsBigUnit = tokens => (tokens / 1e8).toFixed(8);
+const typeKeySendTrade = '805805';
 
 /** Manage a swap
 
@@ -22,55 +39,174 @@ const respondAction = 'respond';
 
   @returns via cbk or Promise
 */
-module.exports = ({ask, lnd, logger, request}, cbk) => {
+module.exports = (args, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Check arguments
       validate: cbk => {
-        if (!ask) {
+        if (!args.ask) {
           return cbk([400, 'ExpectedAskFunctionToManageSwap']);
         }
 
-        if (!lnd) {
+        if (!args.lnd) {
           return cbk([400, 'ExpectedAuthenticatedLndToManageSwap']);
         }
 
-        if (!logger) {
+        if (!args.logger) {
           return cbk([400, 'ExpectedWinstonLoggerToManageSwap']);
         }
 
-        if (!request) {
+        if (!args.request) {
           return cbk([400, 'ExpectedRequestFunctionToManageSwap']);
         }
 
         return cbk();
       },
 
+      // Get invoices to find past swap requests
+      getInvoices: ['validate', ({}, cbk) => {
+        return getAllInvoices({
+          created_after: pushesReceivedAfter().toISOString(),
+          lnd: args.lnd,
+        },
+        cbk);
+      }],
+
+      // Look for a p2tr master public key to detect p2tr support
+      getMasterPublicKeys: ['validate', ({}, cbk) => {
+        return getMasterPublicKeys({lnd: args.lnd}, cbk);
+      }],
+
       // Get the network to make sure this is on testnet
-      getNetwork: ['validate', ({}, cbk) => getNetwork({lnd}, cbk)],
+      getNetwork: ['validate', ({}, cbk) => getNetwork({lnd: args.lnd}, cbk)],
+
+      // Received swap pushes
+      swapPushes: ['getInvoices', ({getInvoices}, cbk) => {
+        const pushes = getInvoices.invoices.map(invoice => {
+          // A swap push is a KeySend payment
+          if (!invoice.is_confirmed || !invoice.is_push) {
+            return;
+          }
+
+          const messages = flatten(invoice.payments.map(n => n.messages));
+
+          // Convert messages to swaps
+          const swaps = messages.map(message => {
+            // Swaps have the trade type wrapper
+            if (message.type !== typeKeySendTrade) {
+              return;
+            }
+
+            // The trade type should be a swap
+            try {
+              const {swap} = decodeTrade({trade: message.value});
+
+              if (!swap) {
+                return;
+              }
+
+              const details = decodeOffToOnRequest({request: swap.request});
+
+              // Return relevant swap details for acceptance
+              return {
+                confirmed_at: invoice.confirmed_at,
+                id: details.hash,
+                tokens: details.tokens,
+                node: swap.node,
+                trade: message.value,
+              };
+            } catch (err) {
+              return;
+            }
+          });
+
+          const [swap] = swaps.filter(n => !!n);
+
+          return swap;
+        });
+
+        return cbk(null, pushes.filter(n => !!n));
+      }],
+
+      // Get node aliases for pushes
+      getAliases: ['swapPushes', ({swapPushes}, cbk) => {
+        return asyncMap(swapPushes, ({node}, cbk) => {
+          return getNodeAlias({id: node, lnd: args.lnd}, cbk);
+        },
+        cbk);
+      }],
+
+      // Get existing swaps
+      getExisting: ['swapPushes', ({swapPushes}, cbk) => {
+        return asyncMap(swapPushes, ({id}, cbk) => {
+          return getInvoice({id, lnd: args.lnd}, (err, res) => {
+            // Error indicates that the invoice could not be looked up
+            if (!!err) {
+              return cbk();
+            }
+
+            // Result indicates the invoice is known so the swap is in progress
+            return cbk(null, id);
+          });
+        },
+        cbk);
+      }],
+
+      // Determine if taproot is supported or not
+      hasTr: ['getMasterPublicKeys', ({getMasterPublicKeys}, cbk) => {
+        const {keys} = getMasterPublicKeys;
+
+        return cbk(null, !!keys.find(n => n.derivation_path === bip86Path));
+      }],
 
       // Select a swap action
-      selectAction: ['getNetwork', ({getNetwork}, cbk) => {
+      selectAction: [
+        'getAliases',
+        'getExisting',
+        'getNetwork',
+        'hasTr',
+        'swapPushes',
+        ({getAliases, getExisting, getNetwork, hasTr, swapPushes}, cbk) =>
+      {
         // Check to make sure the network is supported
-        if (getNetwork.network !== allowedNetwork) {
+        if (!hasTr && getNetwork.network !== allowedNetwork) {
           return cbk([501, 'CurrentlyUnsupportedChainForSwap']);
         }
 
-        return ask({
-          choices: [
-            {
-              name: 'Make a new swap request',
-              value: requestAction,
-            },
-            {
-              name: 'Respond to a swap request',
-              value: respondAction,
-            },
-            {
-              name: 'Recovery for swap response',
-              value: recoverRespondAction,
-            },
-          ],
+        const pushes = swapPushes
+          .filter(push => !getExisting.includes(push.id))
+          .map(push => {
+            const amount = tokensAsBigUnit(push.tokens);
+            const id = niceId(push.id);
+            const node = niceName(getAliases.find(n => n.id === push.node));
+
+            return {
+              name: `Accept request ${id} to swap ${amount} with ${node}`,
+              value: push.trade,
+            };
+          });
+
+        const choices = [
+          {
+            name: 'Make a new swap request',
+            value: requestAction,
+          },
+          {
+            name: 'Send a new swap request via KeySend',
+            value: actionPushRequest,
+          },
+          {
+            name: 'Respond to a swap request',
+            value: respondAction,
+          },
+          {
+            name: 'Recovery for swap response',
+            value: recoverRespondAction,
+          },
+        ];
+
+        return args.ask({
+          choices: choices.concat(pushes),
           message: 'Off-chain to on-chain swap:',
           name: 'action',
           type: 'list',
@@ -78,31 +214,146 @@ module.exports = ({ask, lnd, logger, request}, cbk) => {
         ({action}) => cbk(null, action));
       }],
 
+      // Ask for the remote to send to
+      askForRemote: ['selectAction', ({selectAction}, cbk) => {
+        // Exit early when the request is not KeySend
+        if (selectAction !== actionPushRequest) {
+          return cbk();
+        }
+
+        return args.ask({
+          message: 'Node key or channel peer alias to send request to?',
+          name: 'remote',
+          validate: input => !!input,
+        },
+        ({remote}) => cbk(null, remote));
+      }],
+
+      // Find the remote identity key when specified
+      findKey: ['askForRemote', ({askForRemote}, cbk) => {
+        if (!askForRemote) {
+          return cbk(null, {});
+        }
+
+        return findKey({lnd: args.lnd, query: askForRemote}, cbk);
+      }],
+
+      // Ask if the offchain funding should be external
+      askForExternal: [
+        'askForRemote',
+        'selectAction',
+        ({selectAction}, cbk) =>
+      {
+        switch (selectAction) {
+        case actionPushRequest:
+        case requestAction:
+          return args.ask({
+            message: 'Use internal funds to pay offchain payment request?',
+            name: 'internal',
+            type: 'confirm',
+          },
+          ({internal}) => cbk(null, !internal));
+
+        default:
+          // External funding not supported
+          return cbk();
+        }
+      }],
+
       // Make swap request
-      makeRequest: ['selectAction', ({selectAction}, cbk) => {
-        if (selectAction !== requestAction) {
+      makeRequest: [
+        'askForExternal',
+        'askForRemote',
+        'findKey',
+        'hasTr',
+        'selectAction',
+        ({askForExternal, askForRemote, findKey, hasTr, selectAction}, cbk) =>
+      {
+        switch (selectAction) {
+        case actionPushRequest:
+          if (!findKey.public_key) {
+            return cbk([400, 'UnknownNodeToPushSwapRequestTo']);
+          }
+          break;
+
+        case requestAction:
+          break;
+
+        default:
           return cbk();
         }
 
-        return requestSwapOut({ask, lnd, logger, request}, cbk);
+        return requestSwapOut({
+          ask: args.ask,
+          is_external_funding: askForExternal,
+          lnd: args.lnd,
+          logger: args.logger,
+          push_to: findKey.public_key,
+          min_confirmations: minConfirmations[getNetwork.network],
+          request: !hasTr ? args.request : undefined,
+        },
+        cbk);
       }],
 
-      // Respond to swap request
-      makeResponse: ['selectAction', ({selectAction}, cbk) => {
+      // Make a response for a swap request
+      makeResponse: ['hasTr', 'selectAction', ({hasTr, selectAction}, cbk) => {
         if (selectAction !== respondAction) {
           return cbk();
         }
 
-        return respondToSwapOutRequest({ask, lnd, logger, request}, cbk);
+        return respondToSwapOutRequest({
+          ask: args.ask,
+          is_external_funding: true,
+          lnd: args.lnd,
+          logger: args.logger,
+          request: !hasTr ? args.request : undefined,
+        },
+        cbk);
+      }],
+
+      // Respond to a pushed swap request
+      respondToPush: [
+        'hasTr',
+        'selectAction',
+        ({hasTr, selectAction}, cbk) =>
+      {
+        // Exit early when not responding to a push
+        try {
+          decodeTrade({trade: selectAction});
+        } catch (err) {
+          return cbk();
+        }
+
+        const {swap} = decodeTrade({trade: selectAction});
+
+        return respondToSwapOutRequest({
+          ask: args.ask,
+          lnd: args.lnd,
+          logger: args.logger,
+          request: !hasTr ? args.request : undefined,
+          swap: swap.request,
+          to: swap.node,
+        },
+        cbk);
       }],
 
       // Recover responding to swap request
-      recoverResponse: ['selectAction', ({selectAction}, cbk) => {
+      recoverResponse: [
+        'hasTr',
+        'selectAction',
+        ({hasTr, selectAction}, cbk) =>
+      {
         if (selectAction !== recoverRespondAction) {
           return cbk();
         }
 
-        return recoverResponseToSwapOut({ask, lnd, logger, request}, cbk);
+        return recoverResponseToSwapOut({
+          ask: args.ask,
+          lnd: args.lnd,
+          logger: args.logger,
+          request: !hasTr ? args.request : undefined,
+        },
+        cbk);
       }],
 
       // Final result
@@ -110,9 +361,26 @@ module.exports = ({ask, lnd, logger, request}, cbk) => {
         'makeRequest',
         'makeResponse',
         'recoverResponse',
-        ({makeRequest, makeResponse, recoverResponse}, cbk) =>
+        'respondToPush',
+        ({makeRequest, makeResponse, recoverResponse, respondToPush}, cbk) =>
       {
-        return cbk(null, makeRequest || makeResponse || recoverResponse);
+        if (!!makeRequest) {
+          return cbk(null, makeRequest);
+        }
+
+        if (!!makeResponse) {
+          return cbk(null, makeResponse);
+        }
+
+        if (!!recoverResponse) {
+          return cbk(null, recoverResponse);
+        }
+
+        if (!!respondToPush) {
+          return cbk(null, respondToPush);
+        }
+
+        return cbk();
       }],
     },
     returnResult({reject, resolve, of: 'result'}, cbk));

package/swaps/recover_response_to_swap_out.js

@@ -11,7 +11,7 @@ const completeOnToOffSwap = require('./complete_on_to_off_swap');
     ask: <Ask Function>
     lnd: <Authenticated LND API Object>
     logger: <Winston Logger Object>
-    request: <Request Function>
+    [request]: <Request Function>
   }
 
   @returns via cbk or Promise
@@ -33,10 +33,6 @@ module.exports = ({ask, lnd, logger, request}, cbk) => {
           return cbk([400, 'ExpectedWinstonLoggerToRecoverResponseToSwapOut']);
         }
 
-        if (!request) {
-          return cbk([400, 'ExpectedRequestFunctionToRecoverResponseToSwap']);
-        }
-
         return cbk();
       },