balanceofsatoshis 12.0.2 → 12.3.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Versions
 
+## 12.3.0
+
+- `lnurl`: Add support for the `auth` function to authenticate with a node key
+
+## 12.2.0
+
+- `swap`: Add utility command for testing submarine swaps
+
+## 12.1.0
+
+- `lnurl`: Add support for the `withdraw` function to send a payment request
+
 ## 12.0.2
 
 - `open-balanced-channel`: Fix display issue where `undefined` was printed

package/bos

@@ -1023,6 +1023,9 @@ prog
   .command('lnurl', 'Collection of lnurl features')
   .argument('<function>', 'lnurl function', keys(lnurlFunctions))
   .help(`Functions: ${keys(lnurlFunctions).join(', ')}`)
+  .help('lnurl auth will request authorization')
+  .help('lnurl pay will request a payment request from a service')
+  .help('lnurl withdraw will create an invoice and send it to a service')
   .option('--avoid <avoid>', 'Avoid forwarding via node/chan/tag', REPEATABLE)
   .option('--max-fee <max_fee>', 'Maximum fee to pay', INT, 1337)
   .option('--max-paths <max_paths>', 'Maximum paths to use', INT, 1)
@@ -1032,7 +1035,7 @@ prog
   .action((args, options, logger) => {
     return new Promise(async (resolve, reject) => {
       try {
-        return lnurl.pay({
+        return lnurl.manageLnurl({
           logger,
           ask: (n, cbk) => inquirer.prompt(n).then(n => cbk(n)),
           avoid: flatten([options.avoid].filter(n => !!n)),
@@ -1624,6 +1627,26 @@ prog
     });
   })
 
+  // Submarine swap
+  .command('swap', 'Trade off-chain coins for on-chain via submarine swap')
+  .visible(false)
+  .option('--node <node_name>', 'Node to use for swap')
+  .action((args, options, logger) => {
+    return new Promise(async (resolve, reject) => {
+      try {
+        return paidServices.manageSwap({
+          logger,
+          ask: (n, cbk) => inquirer.prompt([n]).then(res => cbk(res)),
+          lnd: (await lnd.authenticatedLnd({logger, node: options.node})).lnd,
+          request: commands.simpleRequest,
+        },
+        responses.returnObject({exit, logger, reject, resolve}));
+      } catch (err) {
+        return logger.error({err}) && reject();
+      }
+    });
+  })
+
   // Create submarine swap to convert on-chain funds to off-chain
   .command('swap-in', 'Trade on-chain coins for off-chain via submarine swap')
   .argument('[amount]', 'Amount to receive', INT, 1e6)

package/commands/constants.json

@@ -8,7 +8,9 @@
     "payments": "payments"
   },
   "lnurlFunctions": {
-    "pay": "pay"
+    "auth": "auth",
+    "pay": "pay",
+    "withdraw": "withdraw"
   },
   "peerSortOptions": [
     "alias",

package/lnurl/auth.js

@@ -0,0 +1,178 @@
+const asyncAuto = require('async/auto');
+const {bech32} = require('bech32');
+const {returnResult} = require('asyncjs-util');
+const {signMessage} = require('ln-service');
+const tinysecp = require('tiny-secp256k1');
+
+const signAuthChallenge = require('./sign_auth_challenge');
+
+const actionKey = 'action';
+const {decode} = bech32;
+const defaultAction = 'authenticate';
+const asLnurl = n => n.substring(n.startsWith('lightning:') ? 10 : 0);
+const bech32CharLimit = 2000;
+const challengeKey = 'k1';
+const errorStatus = 'ERROR';
+const knownActions = ['auth', 'link', 'login', 'register'];
+const okStatus = 'OK';
+const prefix = 'lnurl';
+const tlsProtocol = 'https:';
+const lud13AuthPhrase = 'DO NOT EVER SIGN THIS TEXT WITH YOUR PRIVATE KEYS! IT IS ONLY USED FOR DERIVATION OF LNURL-AUTH HASHING-KEY, DISCLOSING ITS SIGNATURE WILL COMPROMISE YOUR LNURL-AUTH IDENTITY AND MAY LEAD TO LOSS OF FUNDS!';
+const wordsAsUtf8 = n => Buffer.from(bech32.fromWords(n)).toString('utf8');
+
+/** Authenticate using lnurl
+
+  {
+    ask: <Ask Function>
+    request: <Request Function>
+    lnd: <Authenticated LND API Object>
+    lnurl: <Lnurl String>
+    logger: <Winston Logger Object>
+  }
+
+  @returns via cbk or Promise
+*/
+module.exports = (args, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Import the ECPair library
+      ecp: async () => (await import('ecpair')).ECPairFactory(tinysecp),
+
+      // Check arguments
+      validate: cbk => {
+        if (!args.ask) {
+          return cbk([400, 'ExpectedAskFunctionToAuthenticateUsingLnurl']);
+        }
+
+        if (!args.lnurl) {
+          return cbk([400, 'ExpectedUrlToAuthenticateToLnurl']);
+        }
+
+        try {
+          decode(asLnurl(args.lnurl), bech32CharLimit);
+        } catch (err) {
+          return cbk([400, 'FailedToDecodeLnurlToAuthenticate', {err}]);
+        }
+
+        if (decode(asLnurl(args.lnurl), bech32CharLimit).prefix !== prefix) {
+          return cbk([400, 'ExpectedLnUrlPrefixToAuthenticate']);
+        }
+
+        if (!args.lnd) {
+          return cbk([400, 'ExpectedLndToAuthenticateUsingLnurl']);
+        }
+
+        if (!args.logger) {
+          return cbk([400, 'ExpectedLoggerToAuthenticateUsingLnurl']);
+        }
+
+        if (!args.request) {
+          return cbk([400, 'ExpectedRequestFunctionToGetLnurlAuthentication']);
+        }
+
+        return cbk();
+      },
+
+      // Parse the encoded Lnurl
+      parse: ['validate', ({}, cbk) => {
+        const {words} = decode(asLnurl(args.lnurl), bech32CharLimit);
+
+        const url = wordsAsUtf8(words);
+
+        try {
+          new URL(url);
+        } catch (err) {
+          return cbk([400, 'ExpectedValidCallbackUrlInDecodedLnurlForAuth']);
+        }
+
+        const {hostname, protocol, searchParams} = new URL(url);
+
+        if (protocol !== tlsProtocol) {
+          return cbk([501, 'UnsupportedUrlProtocolForLnurlAuthentication']);
+        }
+
+        const action = searchParams.get(actionKey);
+
+        if (!!action && !knownActions.includes(action)) {
+          return cbk([503, 'UnknownAuthenticationActionForLnurlAuth']);
+        }
+
+        const k1 = searchParams.get(challengeKey);
+
+        if (!k1) {
+          return cbk([503, 'ExpectedChallengeK1ValueInDecodedLnurlForAuth']);
+        }
+
+        return cbk(null, {hostname, k1, url, action: action || defaultAction});
+      }],
+
+      // Sign the canonical phrase for LUD-13 signMessage based seed generation
+      seed: ['parse', ({}, cbk) => {
+        return signMessage({lnd: args.lnd, message: lud13AuthPhrase}, cbk);
+      }],
+
+      // Derive keys and get signatures
+      sign: ['ecp', 'parse', 'seed', ({ecp, parse, seed}, cbk) => {
+        const sign = signAuthChallenge({
+          ecp,
+          hostname: parse.hostname,
+          k1: parse.k1,
+          seed: seed.signature,
+        });
+
+        return cbk(null, {
+          public_key: sign.public_key,
+          signature: sign.signature,
+        });
+      }],
+
+      // Display confirmation dialog with domain name and action
+      ok: ['parse', 'sign', ({parse, sign}, cbk) => {
+        return args.ask({
+          default: true,
+          message: `Do you want to ${parse.action} with ${parse.hostname}?`,
+          name: 'ok',
+          type: 'confirm',
+        },
+        ({ok}) => cbk(null, ok));
+      }],
+
+      // Transmit authenticating signature and key to the host
+      send: ['ok', 'parse', 'sign', ({ok, parse, sign}, cbk) => {
+        if (!ok) {
+          return cbk([400, 'AuthenticationCanceled']);
+        }
+
+        args.logger.info({sending_authentication: sign.public_key});
+
+        return args.request({
+          json: true,
+          qs: {key: sign.public_key, sig: sign.signature},
+          url: parse.url,
+        },
+        (err, r, json) => {
+          if (!!err) {
+            return cbk([503, 'FailedToGetLnurlAuthenticationData', {err}]);
+          }
+
+          if (!json) {
+            return cbk([503, 'ExpectedJsonReturnedInLnurlResponseForAuth']);
+          }
+
+          if (json.status === errorStatus) {
+            return cbk([503, 'LnurlAuthenticationFail', {err: json.reason}]);
+          }
+
+          if (json.status !== okStatus) {
+            return cbk([503, 'ExpectedOkStatusInLnurlResponseJsonForAuth']);
+          }
+
+          args.logger.info({is_authenticated: true});
+
+          return cbk();
+        });
+      }],
+    },
+    returnResult({reject, resolve}, cbk));
+  });
+};

package/lnurl/der_encode_signature.js

@@ -0,0 +1,37 @@
+const asDer = n => (n[0]&128)?Buffer.concat([Buffer.alloc(1),n],1+n.length):n;
+const bufferAsHex = buffer => buffer.toString('hex');
+const {concat} = Buffer;
+const decomposeSignature = sig => [sig.slice(0, 32), sig.slice(32, 64)];
+const {from} = Buffer;
+const header = 0x30;
+const hexAsBuffer = hex => Buffer.from(hex, 'hex');
+const int = 0x02;
+
+/** DER encode a signature given r and s values
+
+  {
+    signature: <Signature Buffer Object>
+  }
+
+  @returns
+  {
+    encoded: <DER Encoded Signature Buffer Object>
+  }
+*/
+module.exports = ({signature}) => {
+  // Split the signature for DER encoding
+  const [r, s] = decomposeSignature(hexAsBuffer(signature)).map(asDer);
+
+  const encoded = bufferAsHex(concat([
+    from([header]), // Header byte indicating compound structure
+    from([r.length + s.length + [int, int, r.length, s.length].length]), // Len
+    from([int]), // Integer indicator
+    from([r.length]), // Length of data
+    r,
+    from([int]), // Integer indicator
+    from([s.length]), // Length of data
+    s,
+  ]));
+
+  return {encoded};
+};

package/lnurl/index.js

@@ -1,3 +1,3 @@
-const pay = require('./pay');
+const manageLnurl = require('./manage_lnurl');
 
-module.exports = {pay};
+module.exports = {manageLnurl};

package/lnurl/manage_lnurl.js

@@ -0,0 +1,127 @@
+const asyncAuto = require('async/auto');
+const {returnResult} = require('asyncjs-util');
+
+const auth = require('./auth');
+const pay = require('./pay');
+const withdraw = require('./withdraw');
+
+const functionAuth = 'auth';
+const functionPay = 'pay';
+const functionWithdraw = 'withdraw';
+const {isArray} = Array;
+
+/** Manage Lnurl functions
+
+  {
+    ask: <Ask Function>
+    avoid: [<Avoid Forwarding Through String>]
+    function: <Lnurl Function String>
+    request: <Request Function>
+    lnd: <Authenticated LND API Object>
+    lnurl: <Lnurl String>
+    logger: <Winston Logger Object>
+    [max_fee]: <Max Fee Tokens Number>
+    [max_paths]: <Maximum Paths Number>
+    out: [<Out Through Peer With Public Key Hex String>]
+  }
+
+  @returns via cbk or Promise
+*/
+module.exports = (args, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!args.ask) {
+          return cbk([400, 'ExpectedAskFunctionToManageLnurl']);
+        }
+
+        if (!isArray(args.avoid)) {
+          return cbk([400, 'ExpectedArrayOfAvoidsToManageLnurl']);
+        }
+
+        if (![functionAuth, functionPay, functionWithdraw].includes(args.function)) {
+          return cbk([400, 'ExpectedLnurlFunctionToManageLnurl']);
+        }
+
+        if (!args.lnd) {
+          return cbk([400, 'ExpectedLndToManageLnurl']);
+        }
+
+        if (!args.lnurl) {
+          return cbk([400, 'ExpectedUrlStringToManageLnurl']);
+        }
+
+        if (!args.logger) {
+          return cbk([400, 'ExpectedLoggerToManageLnurl']);
+        }
+
+        if (!isArray(args.out)) {
+          return cbk([400, 'ExpectedArrayOfOutPeersToManageLnurl']);
+        }
+
+        if (!args.request) {
+          return cbk([400, 'ExpectedRequestFunctionToManageLnurl']);
+        }
+
+        return cbk();
+      },
+
+      // Authenticate using lnurl
+      auth: ['validate', ({}, cbk) => {
+        // Exit early if not lnurl auth
+        if (args.function !== functionAuth) {
+          return cbk();
+        }
+
+        return auth({
+          ask: args.ask,
+          lnd: args.lnd,
+          lnurl: args.lnurl,
+          logger: args.logger,
+          request: args.request,
+        },
+        cbk);
+      }],
+
+      // Pay to lnurl
+      pay: ['validate', ({}, cbk) => {
+        // Exit early if not lnurl pay
+        if (args.function !== functionPay) {
+          return cbk();
+        }
+
+        return pay({
+          ask: args.ask,
+          avoid: args.avoid,
+          lnd: args.lnd,
+          lnurl: args.lnurl,
+          logger: args.logger,
+          max_fee: args.max_fee,
+          max_paths: args.max_paths,
+          out: args.out,
+          request: args.request,
+        },
+        cbk);
+      }],
+
+      // Withdraw from lnurl
+      withdraw: ['validate', ({}, cbk) => {
+        // Exit early if not lnurl withdraw
+        if (args.function !== functionWithdraw) {
+          return cbk();
+        }
+
+        return withdraw({
+          ask: args.ask,
+          lnd: args.lnd,
+          lnurl: args.lnurl,
+          logger: args.logger,
+          request: args.request,
+        },
+        cbk);
+      }],
+    },
+    returnResult({reject, resolve}, cbk));
+  });
+};

package/lnurl/pay.js

@@ -36,13 +36,13 @@ const wordsAsUtf8 = n => Buffer.from(bech32.fromWords(n)).toString('utf8');
  {
   ask: <Ask Function>
   avoid: [<Avoid Forwarding Through String>]
-  fetch: <Fetch Function>
   lnd: <Authenticated LND API Object>
   lnurl: <Lnurl String>
   logger: <Winston Logger Object>
   max_fee: <Max Fee Tokens Number>
   max_paths: <Maximum Paths Number>
   out: [<Out Through Peer With Public Key Hex String>]
+  request: <Request Function>
  }
 */
 module.exports = (args, cbk) => {
@@ -58,10 +58,6 @@ module.exports = (args, cbk) => {
           return cbk([400, 'ExpectedAvoidArrayToGetPaymentRequestFromLnurl']);
         }
 
-        if (!args.request) {
-          return cbk([400, 'ExpectedRequestFunctionToGetLnurlData']);
-        }
-
         if (!args.lnurl) {
           return cbk([400, 'ExpectedUrlToGetPaymentRequestFromLnurl']);
         }
@@ -96,6 +92,10 @@ module.exports = (args, cbk) => {
           return cbk([400, 'ExpectedArrayOfOutPeersToPayViaLnurl']);
         }
 
+        if (!args.request) {
+          return cbk([400, 'ExpectedRequestFunctionToGetLnurlData']);
+        }
+
         return cbk();
       },
 

package/lnurl/sign_auth_challenge.js

@@ -0,0 +1,46 @@
+const {createHash} = require('crypto');
+const {createHmac} = require('crypto');
+
+const derEncodeSignature = require('./der_encode_signature');
+
+const asDer = n => (n[0]&128)?Buffer.concat([Buffer.alloc(1),n],1+n.length):n;
+const bufferAsHex = buffer => buffer.toString('hex');
+const {from} = Buffer;
+const hexAsBuffer = hex => Buffer.from(hex, 'hex');
+const hmacSha256 = (pk, url) => createHmac('sha256', pk).update(url).digest();
+const sha256 = n => createHash('sha256').update(n).digest();
+const utf8AsBuffer = utf8 => Buffer.from(utf8, 'utf8');
+
+/** Sign an authentication challenge for LNURL Auth
+
+  {
+    ecp: <ECPair Object>
+    hostname: <Domain for Authentication Challenge String>
+    k1: <Challenge Nonce String>
+    seed: <Seed Signature String>
+  }
+
+  @returns
+  {
+    public_key: <Signing Identity Public Key Hex String>
+    signature: <Signature For Authentication Challenge Hex String>
+  }
+*/
+module.exports = ({ecp, hostname, k1, seed}) => {
+  // LUD-13: LN wallet defines hashingKey as sha256(signature)
+  const hashingKey = sha256(utf8AsBuffer(seed));
+
+  // LUD-13: linkingPrivKey is defined as hmacSha256(hashingKey, domain)
+  const linkingPrivKey = hmacSha256(hashingKey, utf8AsBuffer(hostname));
+
+  // Instantiate the key pair from this derived private key
+  const linkingKey = ecp.fromPrivateKey(linkingPrivKey);
+
+  // Using the host-specific linking key, sign the challenge k1 value
+  const signature = bufferAsHex(from(linkingKey.sign(hexAsBuffer(k1))));
+
+  return {
+    public_key: bufferAsHex(linkingKey.publicKey),
+    signature: derEncodeSignature({signature}).encoded,
+  };
+};

package/lnurl/withdraw.js

@@ -0,0 +1,226 @@
+const asyncAuto = require('async/auto');
+const {bech32} = require('bech32');
+const {createInvoice} = require('ln-service');
+const {returnResult} = require('asyncjs-util');
+
+const {decode} = bech32;
+const asLnurl = n => n.substring(n.startsWith('lightning:') ? 10 : 0);
+const bech32CharLimit = 2000;
+const errorStatus = 'ERROR';
+const isNumber = n => !isNaN(n);
+const minWithdrawable = 1;
+const mtokensAsTokens = n => Math.floor(n / 1000);
+const prefix = 'lnurl';
+const {round} = Math;
+const sslProtocol = 'https:';
+const tag = 'withdrawRequest';
+const tokensAsMillitokens = n => n * 1000;
+const wordsAsUtf8 = n => Buffer.from(bech32.fromWords(n)).toString('utf8');
+
+/** Withdraw from lnurl
+
+  {
+    ask: <Ask Function>
+    request: <Request Function>
+    lnd: <Authenticated LND API Object>
+    lnurl: <Lnurl String>
+    logger: <Winston Logger Object>
+  }
+
+  @returns via cbk or Promise
+*/
+module.exports = (args, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!args.ask) {
+          return cbk([400, 'ExpectedAskFunctionToWithdrawFromLnurl']);
+        }
+
+        if (!args.lnurl) {
+          return cbk([400, 'ExpectedUrlToWithdrawFromLnurl']);
+        }
+
+        try {
+          decode(asLnurl(args.lnurl), bech32CharLimit);
+        } catch (err) {
+          return cbk([400, 'FailedToDecodeLnurlToWithdraw', {err}]);
+        }
+
+        if (decode(asLnurl(args.lnurl), bech32CharLimit).prefix !== prefix) {
+          return cbk([400, 'ExpectedLnUrlPrefixToWithdraw']);
+        }
+
+        if (!args.lnd) {
+          return cbk([400, 'ExpectedLndToWithdrawFromLnurl']);
+        }
+
+        if (!args.logger) {
+          return cbk([400, 'ExpectedLoggerToWithdrawFromLnurl']);
+        }
+
+        if (!args.request) {
+          return cbk([400, 'ExpectedRequestFunctionToGetLnurlWithdrawData']);
+        }
+
+        return cbk();
+      },
+
+      // Get accepted terms from the encoded url
+      getTerms: ['validate', ({}, cbk) => {
+        const {words} = decode(asLnurl(args.lnurl), bech32CharLimit);
+
+        const url = wordsAsUtf8(words);
+
+        return args.request({url, json: true}, (err, r, json) => {
+          if (!!err) {
+            return cbk([503, 'FailureGettingLnUrlDataFromUrl', {err}]);
+          }
+
+          if (!json) {
+            return cbk([503, 'ExpectedJsonObjectReturnedInLnurlResponse']);
+          }
+
+          if (json.status === errorStatus) {
+            return cbk([503, 'LnurlWithdrawReturnedErr', {err: json.reason}]);
+          }
+
+          if (!json.callback) {
+            return cbk([503, 'ExpectedCallbackInLnurlResponseJson']);
+          }
+
+          try {
+            new URL(json.callback);
+          } catch (err) {
+            return cbk([503, 'ExpectedValidCallbackUrlInLnurlResponseJson']);
+          }
+
+          if ((new URL(json.callback)).protocol !== sslProtocol) {
+            return cbk([400, 'LnurlsThatSpecifyNonSslUrlsAreUnsupported']);
+          }
+
+          if (!json.k1) {
+            return cbk([503, 'ExpectedK1InLnurlResponseJson']);
+          }
+
+          if (!json.tag) {
+            return cbk([503, 'ExpectedTagInLnurlResponseJson']);
+          }
+
+          if (json.tag !== tag) {
+            return cbk([503, 'ExpectedTagToBeWithdrawRequestInLnurlResponse']);
+          }
+
+          if (!isNumber(json.minWithdrawable)) {
+            return cbk([503, 'ExpectedNumericValueForMinWithdrawable']);
+          }
+
+          if (!isNumber(json.maxWithdrawable)) {
+            return cbk([503, 'ExpectedNumericValueForMaxWithdrawable']);
+          }
+
+          if (json.minWithdrawable < minWithdrawable) {
+            return cbk([400, 'MinWithdrawableIsLowerThanSupportedValue']);
+          }
+
+          if (json.minWithdrawable > json.maxWithdrawable) {
+            return cbk([400, 'MinWithdrawableIsHigherThanMaxWithdrawable']);
+          }
+
+          return cbk(null, {
+            description: json.defaultDescription,
+            k1: json.k1,
+            max: mtokensAsTokens(json.maxWithdrawable),
+            min: mtokensAsTokens(json.minWithdrawable),
+            url: json.callback,
+          });
+        });
+      }],
+
+      // Ask amount for invoice
+      askAmount: ['getTerms', ({getTerms}, cbk) => {
+        const {max} = getTerms;
+        const {min} = getTerms;
+
+        return args.ask({
+          default: min,
+          message: `Amount to withdraw? (min: ${min}, max: ${max})`,
+          name: 'amount',
+          type: 'input',
+          validate: input => {
+            if (!input) {
+              return false;
+            }
+
+            // The amount should be numeric
+            if (!isNumber(input)) {
+              return false;
+            }
+
+            if (round(input) !== Number(input)) {
+              return 'Fractional amounts are not supported';
+            }
+
+            if (Number(input) > max) {
+              return `Service max withdrawable is ${max}, try a lower amount?`;
+            }
+
+            if (Number(input) < min) {
+              return `Service min withdrawable is ${min}, try higher amount?`;
+            }
+
+            return true;
+          },
+        },
+        ({amount}) => cbk(null, tokensAsMillitokens(Number(amount))));
+      }],
+
+      // Create a new payment request for withdrawl
+      createInvoice: ['askAmount', ({askAmount}, cbk) => {
+        return createInvoice({lnd: args.lnd, mtokens: askAmount}, cbk);
+      }],
+
+      // Send the withdraw request
+      withdraw: [
+        'createInvoice',
+        'getTerms',
+        ({createInvoice, getTerms}, cbk) =>
+      {
+        args.logger.info({invoice: createInvoice.request});
+
+        const {url} = getTerms;
+        const {k1} = getTerms;
+
+        const qs = {k1, pr: createInvoice.request};
+
+        return args.request({url, qs, json: true}, (err, r, json) => { 
+          if (!!err) {
+            return cbk([503, 'UnexpectedErrorRequestingLnurlWithdraw', {err}]);
+          }
+
+          if (!json) {
+            return cbk([503, 'ExpectedJsonObjectReturnedInWithdrawResponse']);
+          }
+
+          if (!json.status) {
+            return cbk([503, 'ExpectedStatusInLnurlWithdrawResponseJson']);
+          }
+
+          if (json.status === errorStatus) {
+            return cbk([503, 'LnurlWithdrawReqFailed', {err: json.reason}]);
+          }
+
+          if (json.status !== 'OK') {
+            return cbk([503, 'ExpectedStatusToBeOkInLnurlResponseJson']);
+          }
+
+          args.logger.info({withdrawal_request_sent: true});
+
+          return cbk();
+        });
+      }],
+    },
+    returnResult({reject, resolve}, cbk));
+  });
+};

package/network/probe_destination.js

@@ -7,7 +7,7 @@ const {getChannels} = require('ln-service');
 const {getIdentity} = require('ln-service');
 const {getNode} = require('ln-service');
 const moment = require('moment');
-const {parsePaymentRequest} = require('invoices');
+const {parsePaymentRequest} = require('ln-service');
 const {payViaRoutes} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 const {signBytes} = require('ln-service');

package/package.json

@@ -28,31 +28,33 @@
     "colorette": "2.0.16",
     "crypto-js": "4.1.1",
     "csv-parse": "5.0.4",
-    "goldengate": "11.1.1",
-    "grammy": "1.7.3",
+    "ecpair": "2.0.1",
+    "goldengate": "11.2.1",
+    "grammy": "1.8.0",
     "hot-formula-parser": "4.0.0",
     "import-lazy": "4.0.0",
     "ini": "3.0.0",
     "inquirer": "8.2.2",
-    "invoices": "2.0.5",
     "ln-accounting": "5.0.6",
     "ln-service": "53.11.0",
     "ln-sync": "3.12.0",
     "ln-telegram": "3.21.1",
-    "moment": "2.29.2",
-    "paid-services": "3.14.5",
+    "moment": "2.29.3",
+    "paid-services": "3.15.1",
     "probing": "2.0.5",
     "psbt": "2.0.1",
     "qrcode-terminal": "0.12.0",
     "sanitize-filename": "1.6.3",
     "socks-proxy-agent": "6.2.0-beta.0",
     "table": "6.8.0",
+    "tiny-secp256k1": "2.2.1",
     "update-notifier": "5.1.0",
     "window-size": "1.1.1"
   },
   "description": "Lightning balance CLI",
   "devDependencies": {
     "@alexbosworth/tap": "15.0.11",
+    "invoices": "2.0.6",
     "ln-docker-daemons": "2.2.7",
     "mock-lnd": "1.4.1",
     "tiny-secp256k1": "2.2.1"
@@ -82,5 +84,5 @@
     "postpublish": "docker buildx build --platform linux/amd64,linux/arm64,linux/arm/v7 -t alexbosworth/balanceofsatoshis --push .",
     "test": "tap --branches=1 --functions=1 --lines=1 --statements=1 -t 60 test/arrays/*.js test/balances/*.js test/chain/*.js test/display/*.js test/encryption/*.js test/lnd/*.js test/network/*.js test/nodes/*.js test/peers/*.js test/responses/*.js test/routing/*.js test/services/*.js test/swaps/*.js test/tags/*.js test/telegram/*.js test/wallets/*.js"
   },
-  "version": "12.0.2"
+  "version": "12.3.0"
 }

package/services/get_balanced_opens.js

@@ -3,7 +3,7 @@ const asyncFilter = require('async/filter');
 const {balancedOpenRequest} = require('paid-services');
 const {getInvoices} = require('ln-service');
 const {getPayment} = require('ln-service');
-const {parsePaymentRequest} = require('invoices');
+const {parsePaymentRequest} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 
 const {balancedChannelKeyTypes} = require('./service_key_types');

package/services/respond_to_key_send_ping.js

@@ -2,7 +2,7 @@ const asyncAuto = require('async/auto');
 const {formatTokens} = require('ln-sync');
 const {getNodeAlias} = require('ln-sync');
 const {getPayment} = require('ln-service');
-const {parsePaymentRequest} = require('invoices');
+const {parsePaymentRequest} = require('ln-service');
 const {payViaPaymentRequest} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 

package/swaps/get_paid_service.js

@@ -8,7 +8,7 @@ const {getSwapOutTerms} = require('goldengate');
 const {lightningLabsSwapAuth} = require('goldengate');
 const {lightningLabsSwapService} = require('goldengate');
 const {paidMacaroon} = require('goldengate');
-const {parsePaymentRequest} = require('invoices');
+const {parsePaymentRequest} = require('ln-service');
 const {payViaPaymentRequest} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 const {swapUserId} = require('goldengate');