balanceofsatoshis 25.3.1 → 25.4.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Versions
 
+## 25.4.0
+
+- `accounting`: After 2021-10-19 derive USD prices from chain payments data
+- `accounting`: Add `--rate-provider coinbase`
+- `telegram`: Reduce telegram linkification in messages
+
 ## 25.3.1
 
 - `closed`: Avoid using external chain data lookups to derive resolution info

package/README.md

@@ -7,8 +7,8 @@ Commands for working with LND balances.
 
 Supported LND versions:
 
-- v0.21.0-beta to v0.21.4-beta
-- v0.20.0-beta to v0.20.5-beta
+- v0.21.0-beta to v0.21.5-beta
+- v0.20.0-beta to v0.20.6-beta
 
 ## Install
 
@@ -298,6 +298,20 @@ If that is set, it will use that node if no node is specified.
 You can also add a JSON file to your .bos directory: config.json, add
 `{"default_saved_node": "nodename"}` to set the default via a file instead
 
+## Files in `~/.bos`
+
+`bos` keeps its files in `~/.bos`, or in `BOS_DATA_PATH` when that is set:
+
+- `chain_prices.json`: USD prices of BTC that `bos accounting` derived from
+    chain data, kept so that a day is only derived once. Prices are derived
+    this way when no `--rate-provider` is given, and the prices of the days
+    up to the release of `bos` come with it rather than being written here.
+    The file can be deleted, prices are then derived again when needed
+- `config.json`: settings you add, like a default saved node
+- `tags.json`: the tags made with `bos tags`
+- `telegram_bot_api_key`: the bot API key that `bos telegram` asked for
+- `YOUR_NODE_NAME/credentials.json`: the credentials of a saved node
+
 ## Linux Fu
 
 Some commands are designed to return outputs that can be piped or used in other CLI programs.

package/balances/constants.json

@@ -1,6 +1,11 @@
 {
+  "chainPricesFile": "chain_prices.json",
+  "coinbaseProvider": "coinbase",
   "defaultCurrency": "BTC",
   "defaultFiat": "USD",
+  "failedRequestErrors": ["UnexpectedErrorGettingCoinbaseCandles"],
+  "fsMethods": ["getFile", "makeDirectory", "renameFile", "writeFile"],
+  "mainnet": "btc",
   "notFoundIndex": -1,
   "monthNumbers": [
     "01",
@@ -25,5 +30,13 @@
     "11",
     "12"
   ],
-  "monthOffset": 1
+  "monthOffset": 1,
+  "pricesFileErrors": [
+    "ExpectedPricesObjectInPricesFile",
+    "FailedToParsePricesFile",
+    "FailedToReadPricesFile",
+    "FailedToReplacePricesFile",
+    "FailedToWritePricesFile",
+    "UnsupportedPricesFileVersion"
+  ]
 }

package/balances/get_accounting_report.js

@@ -1,11 +1,19 @@
 const asyncAuto = require('async/auto');
+const {chainRates} = require('@alexbosworth/fiat');
 const {getAccountingReport} = require('ln-accounting');
 const {getNetwork} = require('ln-sync');
 const {returnResult} = require('asyncjs-util');
 
 const categories = require('./accounting_categories');
+const {chainPricesFile} = require('./constants');
+const {coinbaseProvider} = require('./constants');
 const {defaultCurrency} = require('./constants');
 const {defaultFiat} = require('./constants');
+const {fsMethods} = require('./constants');
+const getRecordRate = require('./get_record_rate');
+const guardChainRate = require('./guard_chain_rate');
+const {homePath} = require('./../storage');
+const {mainnet} = require('./constants');
 const {monthNumbers} = require('./constants');
 const {monthOffset} = require('./constants');
 const {notFoundIndex} = require('./constants');
@@ -26,9 +34,16 @@ const summaryHeadings = ['Total', 'Asset', 'Report Date', 'Total Fiat'];
     [currency]: <Currency Label String>
     [date]: <Day of Month String>
     [fiat]: <Fiat Type String>
+    [fs]: {
+      getFile: <Read File Contents Function> (path, cbk) => {}
+      makeDirectory: <Make Directory Function> (path, cbk) => {}
+      renameFile: <Rename File Function> (from, to, cbk) => {}
+      writeFile: <Write File Contents Function> (path, contents, cbk) => {}
+    }
     [is_csv]: <Return CSV Output Bool>
     [is_fiat_disabled]: <Omit Fiat Conversion Bool>
     lnd: <Authenticated LND API Object>
+    [logger]: <Winston Logger Object>
     [month]: <Month for Report String>
     [node]: <Node Name String>
     [rate_provider]: <Rate Provider String>
@@ -47,6 +62,8 @@ module.exports = (args, cbk) => {
     return asyncAuto({
       // Validate
       validate: cbk => {
+        const {fs} = args;
+
         if (!args.category || !categories[args.category]) {
           return cbk([400, 'ExpectedKnownAccountingRecordsCategory']);
         }
@@ -55,6 +72,10 @@ module.exports = (args, cbk) => {
           return cbk([400, 'ExpectedMonthForDateToGetAccountingReport']);
         }
 
+        if (!!fs && !fsMethods.every(n => typeof fs[n] === 'function')) {
+          return cbk([400, 'ExpectedFileSystemMethodsToGetAccountingReport']);
+        }
+
         if (!args.lnd) {
           return cbk([400, 'ExpectedAuthenticatedLndToGetAccountingReport']);
         }
@@ -68,25 +89,88 @@ module.exports = (args, cbk) => {
 
       // Get date range
       dateRange: ['validate', ({}, cbk) => {
-        try {
-          return cbk(null, rangeForDate({
-            date: args.date,
-            month: args.month,
-            year: args.year,
-          }));
-        } catch (err) {
-          return cbk([400, err.message]);
+        const range = (() => {
+          try {
+            return {
+              value: rangeForDate({
+                date: args.date,
+                month: args.month,
+                year: args.year,
+              }),
+            };
+          } catch (err) {
+            return {err};
+          }
+        })();
+
+        // Exit early when the date range cannot be determined
+        if (!!range.err) {
+          return cbk([400, range.err.message]);
         }
+
+        return cbk(null, range.value);
       }],
 
       // Get the network name
       getNetwork: ['validate', ({}, cbk) => getNetwork({lnd: args.lnd}, cbk)],
 
+      // Make the method that gets chain prices, used without a rate provider
+      chain: ['getNetwork', ({getNetwork}, cbk) => {
+        // Exit early when fiat is disabled or a rate provider is specified
+        if (!!args.is_fiat_disabled || !!args.rate_provider) {
+          return cbk();
+        }
+
+        // Exit early when there are no chain prices for the network or no
+        // file system to keep them in
+        if (!args.fs || getNetwork.network !== mainnet) {
+          return cbk();
+        }
+
+        // Progress is only logged when it cannot end up in CSV output
+        const logger = !args.is_csv ? args.logger : undefined;
+
+        const {getChainRate} = chainRates({
+          logger,
+          fs: args.fs,
+          lnd: args.lnd,
+          path: homePath({file: chainPricesFile}).path,
+        });
+
+        return cbk(null, guardChainRate({getChainRate}));
+      }],
+
+      // Without a rate provider, records are valued with chain prices, and
+      // at their hour on Coinbase Exchange when chain prices cannot value them
+      rate: ['chain', ({chain}, cbk) => {
+        // Exit early when fiat is disabled
+        if (!!args.is_fiat_disabled) {
+          return cbk();
+        }
+
+        // Exit early when a rate provider other than Coinbase is specified
+        if (!!args.rate_provider && args.rate_provider !== coinbaseProvider) {
+          return cbk();
+        }
+
+        return cbk(null, {
+          rate: (record, cbk) => getRecordRate({
+            currency: record.currency,
+            date: record.date,
+            fiat: record.fiat,
+            get_chain_rate: !!chain ? chain.getChainRate : undefined,
+            request: args.request,
+          },
+          cbk),
+        });
+      }],
+
       // Get accounting info
       getAccounting: [
         'dateRange',
         'getNetwork',
-        ({dateRange, getNetwork}, cbk) =>
+        'rate',
+        ({dateRange, getNetwork, rate}, cbk) =>
       {
         return getAccountingReport({
           after: dateRange.after,
@@ -96,7 +180,8 @@ module.exports = (args, cbk) => {
           fiat: !args.is_fiat_disabled ? (args.fiat || defaultFiat) : null,
           lnd: args.lnd,
           network: getNetwork.network,
-          rate_provider: args.rate_provider || undefined,
+          rate: !!rate ? rate.rate : undefined,
+          rate_provider: !rate ? args.rate_provider : undefined,
           request: args.request,
         },
         cbk);

package/balances/get_historic_rate.js

@@ -0,0 +1,75 @@
+const asyncAuto = require('async/auto');
+const asyncRetry = require('async/retry');
+const {getPrices} = require('@alexbosworth/fiat');
+const {returnResult} = require('asyncjs-util');
+
+const {failedRequestErrors} = require('./constants');
+
+const isFailedRequest = err => !!err && failedRequestErrors.includes(err[1]);
+const retryDelaysMs = [1000, 2000];
+const supportedCurrency = 'BTC';
+
+/** Get the fiat rate of BTC at the hour of a date from a rate provider
+
+  {
+    currency: <Currency Type String>
+    date: <ISO 8601 Date String>
+    fiat: <Fiat Type String>
+    from: <Rate Provider String>
+    request: <Request Function>
+  }
+
+  @returns via cbk or Promise
+  {
+    cents: <Cents Per BTC Number>
+  }
+*/
+module.exports = ({currency, date, fiat, from, request}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (currency !== supportedCurrency) {
+          return cbk([400, 'UnsupportedCurrencyToGetHistoricRate']);
+        }
+
+        if (!date) {
+          return cbk([400, 'ExpectedDateToGetHistoricRate']);
+        }
+
+        if (!fiat) {
+          return cbk([400, 'ExpectedFiatToGetHistoricRate']);
+        }
+
+        if (!from) {
+          return cbk([400, 'ExpectedRateProviderToGetHistoricRate']);
+        }
+
+        if (!request) {
+          return cbk([400, 'ExpectedRequestFunctionToGetHistoricRate']);
+        }
+
+        return cbk();
+      },
+
+      // Get the price at the hour of the date, trying a failed request again
+      getPrice: ['validate', ({}, cbk) => {
+        return asyncRetry({
+          errorFilter: isFailedRequest,
+          interval: count => retryDelaysMs[count - 1],
+          times: retryDelaysMs.length + 1,
+        },
+        cbk => getPrices({date, from, request, symbols: [fiat]}, cbk),
+        cbk);
+      }],
+
+      // The rate of the fiat
+      rate: ['getPrice', ({getPrice}, cbk) => {
+        const [ticker] = getPrice.tickers;
+
+        return cbk(null, {cents: ticker.rate});
+      }],
+    },
+    returnResult({reject, resolve, of: 'rate'}, cbk));
+  });
+};

package/balances/get_record_rate.js

@@ -0,0 +1,77 @@
+const asyncAuto = require('async/auto');
+const {returnResult} = require('asyncjs-util');
+
+const {coinbaseProvider} = require('./constants');
+const getHistoricRate = require('./get_historic_rate');
+
+/** Get the fiat rate of BTC for an accounting record
+
+  {
+    currency: <Currency Type String>
+    date: <Record ISO 8601 Date String>
+    fiat: <Fiat Type String>
+    [get_chain_rate]: <Get Chain Rate Function>
+    request: <Request Function>
+  }
+
+  @returns via cbk or Promise
+  {
+    cents: <Cents Per BTC Number>
+  }
+*/
+module.exports = (args, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!args.request) {
+          return cbk([400, 'ExpectedRequestFunctionToGetRecordRate']);
+        }
+
+        return cbk();
+      },
+
+      // Get the price derived from chain data
+      getChainRate: ['validate', ({}, cbk) => {
+        // Exit early when there are no chain prices
+        if (!args.get_chain_rate) {
+          return cbk();
+        }
+
+        return args.get_chain_rate({
+          currency: args.currency,
+          date: args.date,
+          fiat: args.fiat,
+        },
+        cbk);
+      }],
+
+      // Get the price at the hour of the record on Coinbase Exchange
+      getCoinbaseRate: ['getChainRate', ({getChainRate}, cbk) => {
+        // Exit early when the record has a chain price
+        if (!!getChainRate) {
+          return cbk();
+        }
+
+        return getHistoricRate({
+          currency: args.currency,
+          date: args.date,
+          fiat: args.fiat,
+          from: coinbaseProvider,
+          request: args.request,
+        },
+        cbk);
+      }],
+
+      // The rate of the record
+      rate: [
+        'getChainRate',
+        'getCoinbaseRate',
+        ({getChainRate, getCoinbaseRate}, cbk) =>
+      {
+        return cbk(null, {cents: (getChainRate || getCoinbaseRate).cents});
+      }],
+    },
+    returnResult({reject, resolve, of: 'rate'}, cbk));
+  });
+};

package/balances/guard_chain_rate.js

@@ -0,0 +1,50 @@
+const {pricesFileErrors} = require('./constants');
+
+const isFileError = err => !!err && pricesFileErrors.includes(err[1]);
+
+/** Make a chain rate lookup that only fails on prices file errors
+
+  {
+    getChainRate: <Get Chain Rate Function>
+  }
+
+  @returns
+  {
+    getChainRate: <Get Chain Rate Method> ({
+      currency: <Currency To Price String>
+      date: <Date To Price ISO 8601 Date String>
+      fiat: <Fiat Currency To Price In String>
+    }, cbk) => (err, [{
+      cents: <US Cents Per BTC Number>
+    }])
+  }
+*/
+module.exports = ({getChainRate}) => {
+  const failure = {};
+
+  return {
+    getChainRate: (args, cbk) => {
+      // Exit early when the prices file failed, since it would fail again
+      if (!!failure.err) {
+        return cbk(failure.err);
+      }
+
+      return getChainRate(args, (err, res) => {
+        // Exit early when there is a chain price
+        if (!err) {
+          return cbk(null, res);
+        }
+
+        // Exit early without a price when chain prices cannot value the date
+        if (!isFileError(err)) {
+          return cbk();
+        }
+
+        // A prices file error is kept, as trying again cannot fix the file
+        failure.err = err;
+
+        return cbk(err);
+      });
+    },
+  };
+};

package/bos

@@ -70,6 +70,7 @@ prog
   .argument('<category>', 'Report category', keys(accountingCategories))
   .help(`Categories: ${keys(accountingCategories).join(', ')}`)
   .help(`Rate providers: ${rateProviders.join(', ')}`)
+  .help('By default fiat rates after 2021-10-19 use chain data derived rates')
   .help('Privacy note: this requests tx related data from third parties')
   .option('--csv', 'Output a CSV')
   .option('--date <day>', 'Show only records for specific date')
@@ -84,8 +85,15 @@ prog
     return new Promise(async (resolve, reject) => {
       try {
         return balances.getAccountingReport({
+          logger,
           category: args.category,
           date: options.date,
+          fs: {
+            writeFile,
+            getFile: readFile,
+            makeDirectory: mkdir,
+            renameFile: rename,
+          },
           is_csv: !!options.csv,
           is_fiat_disabled: options.disableFiat,
           lnd: (await lnd.authenticatedLnd({logger, node: options.node})).lnd,

package/commands/constants.json

@@ -25,6 +25,6 @@
   ],
   "priceProviders": ["coinbase", "coindesk", "coingecko"],
   "process": "bos",
-  "rateProviders": ["coindesk", "coingecko"],
+  "rateProviders": ["coinbase", "coindesk", "coingecko"],
   "swapTypes": ["inbound", "outbound"]
 }

package/commands/simple_request.js

@@ -8,8 +8,10 @@ const {parse} = JSON;
 /** Simplified version of request method
 
   {
+    [headers]: <Request Headers Object>
     [json]: <Interpret Result as JSON Bool>
     [method]: <HTTPS Method String>
+    [qs]: <Query String Arguments Object>
     [timeout]: <Timeout MS Number>
     url: <HTTPS URL String>
   }
@@ -29,15 +31,28 @@ module.exports = (args, cbk) => {
     return cbk([400, 'ExpectedHttpsProtocolToExecuteSimpleRequest']);
   }
 
-  let error;
+  let isFinished = false;
   const qs = url.searchParams;
 
+  // Call back once, since a request that times out also errors
+  const finish = (err, res, body) => {
+    // Exit early when the request has already called back
+    if (isFinished) {
+      return;
+    }
+
+    isFinished = true;
+
+    return cbk(err, res, body);
+  };
+
   // Include passed query string arguments
   if (!!args.qs) {
     keys(args.qs).forEach(key => qs.set(key, args.qs[key]));
   }
 
   const req = https.request({
+    headers: args.headers,
     hostname: url.hostname,
     method: args.method,
     path: url.pathname + asQueryString(qs.toString()),
@@ -50,31 +65,51 @@ module.exports = (args, cbk) => {
     // Collect response chunks
     res.on('data', data => body.push(data));
 
+    // A response that is cut off is an error
+    res.on('error', err => {
+      return finish([503, 'UnexpectedErrorReceivingSimpleRequest', {err}]);
+    });
+
     // Response is finished
     res.on('end', () => {
-      if (!!error) {
-        return cbk(err);
-      }
-
       const combined = Buffer.concat(body).toString();
 
+      // Exit early when the response is not meant to be JSON
       if (!args.json) {
-        return cbk(null, res, combined);
+        return finish(null, res, combined);
       }
 
-      try {
-        return cbk(null, res, parse(combined));
-      } catch (err) {
-        return cbk(err);
+      // Only the parsing is guarded, so the callback is called once
+      const parsed = (() => {
+        try {
+          return {json: parse(combined)};
+        } catch (err) {
+          return {err};
+        }
+      })();
+
+      // Exit early when the response is not JSON
+      if (!!parsed.err) {
+        return finish([503, 'ExpectedJsonResponseToSimpleRequest', {
+          err: parsed.err,
+        }]);
       }
+
+      return finish(null, res, parsed.json);
     });
   });
 
-  req.on('error', err => error = err);
+  // A request that fails before it is answered is an error
+  req.on('error', err => {
+    return finish([503, 'UnexpectedErrorExecutingSimpleRequest', {err}]);
+  });
+
+  // A request that is not answered in time is an error
   req.on('timeout', () => {
-    req.abort();
+    finish([503, 'RequestTimedOut']);
 
-    return cbk([503, 'RequestTimedOut']);
+    // The request is stopped, and the error that comes of it is not passed on
+    return req.destroy();
   });
 
   req.end();

package/encryption/encode_as_cbor.js

@@ -0,0 +1,28 @@
+const {Encoder} = require('cbor');
+
+const bufferAsHex = buffer => buffer.toString('hex');
+
+/** Encode a value as CBOR
+
+  {
+    value: <Value to Encode Object>
+  }
+
+  @returns
+  {
+    cbor: <CBOR Encoded Hex String>
+  }
+*/
+module.exports = ({value}) => {
+  const chunks = [];
+  const encoder = new Encoder();
+
+  // Gather the encoding as it is emitted, reading it later can cut it short
+  encoder.on('data', chunk => chunks.push(chunk));
+
+  encoder.pushAny(value);
+
+  encoder.end();
+
+  return {cbor: bufferAsHex(Buffer.concat(chunks))};
+};

package/encryption/encrypt_to_secret.js

@@ -3,11 +3,11 @@ const {randomBytes} = require('crypto');
 const {scrypt} = require('crypto');
 
 const asyncAuto = require('async/auto');
-const {encode} = require('cbor');
 const {returnResult} = require('asyncjs-util');
 
+const encodeAsCbor = require('./encode_as_cbor');
+
 const algorithm = 'aes-256-gcm';
-const cbor = n => encode(n).toString('hex');
 const derivation = 'scrypt';
 const digest = 'sha512';
 const fromHex = n => Buffer.from(n, 'hex');
@@ -37,7 +37,7 @@ module.exports = ({encoding, from, plain, secret, to}, cbk) => {
       // Check arguments
       validate: cbk => {
         if (!plain) {
-          return cbk([400, 'ExectedDataToEncryptToSecret']);
+          return cbk([400, 'ExpectedDataToEncryptToSecret']);
         }
 
         if (!secret) {
@@ -90,7 +90,9 @@ module.exports = ({encoding, from, plain, secret, to}, cbk) => {
         const encrypted = Buffer.concat(updated);
         const tag = cipher.getAuthTag();
 
-        return cbk(null, {cipher: cbor({encrypted, iv, salt, settings, tag})});
+        const value = {encrypted, iv, salt, settings, tag};
+
+        return cbk(null, {cipher: encodeAsCbor({value}).cbor});
       }],
     },
     returnResult({reject, resolve, of: 'encrypt'}, cbk));

package/encryption/index.js

@@ -2,6 +2,7 @@ const certExpiration = require('./cert_expiration');
 const decryptCiphertext = require('./decrypt_ciphertext');
 const decryptWithNode = require('./decrypt_with_node');
 const derAsPem = require('./der_as_pem');
+const encodeAsCbor = require('./encode_as_cbor');
 const encryptToNode = require('./encrypt_to_node');
 const encryptToPublicKeys = require('./encrypt_to_public_keys');
 const pemAsDer = require('./pem_as_der');
@@ -11,6 +12,7 @@ module.exports = {
   decryptCiphertext,
   decryptWithNode,
   derAsPem,
+  encodeAsCbor,
   encryptToNode,
   encryptToPublicKeys,
   pemAsDer,

package/lnd/get_credentials.js

@@ -1,9 +1,9 @@
 const asyncAuto = require('async/auto');
-const {encode} = require('cbor');
 const {grantAccess} = require('ln-service');
 const moment = require('moment');
 const {returnResult} = require('asyncjs-util');
 
+const {encodeAsCbor} = require('./../encryption');
 const lndCredentials = require('./lnd_credentials');
 const {pemAsDer} = require('./../encryption');
 
@@ -112,7 +112,7 @@ module.exports = (args, cbk) => {
         };
 
         return cbk(null, {
-          exported_credentials: encode(credentials).toString('hex'),
+          exported_credentials: encodeAsCbor({value: credentials}).cbor,
         });
       }],
     },

package/package.json

@@ -17,7 +17,7 @@
   "dependencies": {
     "@alexbosworth/blockchain": "4.12.0",
     "@alexbosworth/caporal": "2.0.0",
-    "@alexbosworth/fiat": "2.0.0",
+    "@alexbosworth/fiat": "3.0.0",
     "@alexbosworth/formulas": "1.5.0",
     "@alexbosworth/html2unicode": "1.1.5",
     "asciichart": "1.5.25",
@@ -34,24 +34,24 @@
     "grammy": "1.46.0",
     "import-lazy": "4.0.0",
     "ini": "7.0.0",
-    "inquirer": "14.2.3",
+    "inquirer": "14.2.5",
     "ln-accounting": "10.0.9",
-    "ln-service": "60.1.6",
+    "ln-service": "60.1.8",
     "ln-sync": "8.0.9",
-    "ln-telegram": "8.1.2",
+    "ln-telegram": "8.2.0",
     "moment": "2.31.0",
     "paid-services": "10.3.3",
-    "probing": "7.0.1",
+    "probing": "7.0.2",
     "qrcode-terminal": "0.12.0",
     "sanitize-filename": "1.6.4",
     "socks-proxy-agent": "10.1.0",
     "table": "6.9.0",
-    "tiny-secp256k1": "2.2.4",
+    "tiny-secp256k1": "2.2.5",
     "window-size": "1.1.1"
   },
   "description": "Lightning balance CLI",
   "devDependencies": {
-    "invoices": "6.3.0",
+    "invoices": "6.3.3",
     "ln-docker-daemons": "8.1.3"
   },
   "engines": {
@@ -101,7 +101,7 @@
     "integration-tests": "node test/integration",
     "postpack": "PACKAGE_VERSION=$(cat package.json | grep \\\"version\\\" | head -1 | awk -F: '{ print $2 }' | sed 's/[\",]//g' | tr -d '[[:space:]]') && git tag -s v$PACKAGE_VERSION -m v$PACKAGE_VERSION && git push github --tags",
     "postpublish": "docker buildx build --platform linux/amd64,linux/arm64 -t alexbosworth/balanceofsatoshis -t alexbosworth/balanceofsatoshis:$npm_package_version --push .",
-    "test": "node --experimental-test-coverage --test 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/offchain/*.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"
+    "test": "node --experimental-test-coverage --test test/arrays/*.js test/balances/*.js test/chain/*.js test/commands/*.js test/display/*.js test/encryption/*.js test/lnd/*.js test/network/*.js test/nodes/*.js test/offchain/*.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": "25.3.1"
+  "version": "25.4.0"
 }

package/swaps/get_paid_service.js

@@ -1,5 +1,4 @@
 const asyncAuto = require('async/auto');
-const {encode} = require('cbor');
 const {genericSwapAuth} = require('goldengate');
 const {genericSwapService} = require('goldengate');
 const {getNetwork} = require('ln-sync');
@@ -14,13 +13,13 @@ const {returnResult} = require('asyncjs-util');
 const {swapUserId} = require('goldengate');
 
 const decodeSwapApiKey = require('./decode_swap_api_key');
+const {encodeAsCbor} = require('./../encryption');
 
 const bitcoinNetwork = 'btc';
 const bitcoinTestnetNetwork = 'btctestnet';
 const bufferFromBase64 = base64 => Buffer.from(base64, 'base64');
 const bufferFromHex = hex => Buffer.from(hex, 'hex');
 const connectError = 'FailedToConnectToService';
-const encodeCbor = json => encode(json).toString('hex');
 const httpMatch = /^https?:\/\//;
 const {isArray} = Array;
 const mainnetSocket = 'https://balanceofsatoshis.com:11011';
@@ -222,10 +221,13 @@ module.exports = ({fetch, lnd, socket, token}, cbk) => {
         const paid = payForMacaroon.tokens;
         const {service} = remote;
 
-        const token = encodeCbor({
-          macaroon: bufferFromBase64(getUnpaidMacaroon.macaroon),
-          preimage: bufferFromHex(payForMacaroon.secret),
-        });
+        const token = encodeAsCbor({
+          value: {
+            macaroon: bufferFromBase64(getUnpaidMacaroon.macaroon),
+            preimage: bufferFromHex(payForMacaroon.secret),
+          },
+        })
+        .cbor;
 
         return cbk(null, {id, metadata, paid, service, token});
       }],

package/swaps/swap_api_key.js

@@ -1,9 +1,9 @@
 const asyncAuto = require('async/auto');
-const {encode} = require('cbor');
 const {returnResult} = require('asyncjs-util');
 const {swapUserId} = require('goldengate');
 
 const decodeSwapApiKey = require('./decode_swap_api_key');
+const {encodeAsCbor} = require('./../encryption');
 const getPaidService = require('./get_paid_service');
 
 /** Purchase or inspect a swap API key
@@ -75,7 +75,7 @@ module.exports = (args, cbk) => {
         const preimage = Buffer.from(args.preimage, 'hex');
 
         return cbk(null, {
-          api_key: encode({macaroon, preimage}).toString('hex'),
+          api_key: encodeAsCbor({value: {macaroon, preimage}}).cbor,
           id: swapUserId({macaroon: macaroon.toString('base64')}),
         });
       }],