balanceofsatoshis 24.0.0 → 24.1.0

package/CHANGELOG.md

@@ -1,6 +1,14 @@
 # Versions
 
-## 24.0.0
+## 24.1.0
+
+- `fees`: Add `--repeat-interval-ms` to show or set the fees again each time an
+    interval elapses, such as `5*min` to keep formula fee rates up to date
+- `rebalance`: Add `--repeat-interval-ms` to run the rebalance again each time
+    an interval elapses, such as `30*min`, `1*h * (0.5 + RAND())` for a random
+    interval, or `1*min * 2^FAILURES_COUNT` to back off on failures in a row
+
+## 24.0.1
 
 ### Breaking Changes
 

package/README.md

@@ -327,18 +327,17 @@ expr $(bos balance --node=savedNode1) + $(bos balance --node=savedNode2)
 
 ### Auto Adjust Fees
 
-```
-# Cron every 5 minutes adjust fees
-*/5 * * * * /bin/timeout -s 2 30 /home/ubuntu/update-fees.sh
-```
-
-update-fees.sh:
+Repeat the `fees` command on an interval to keep a fee rate formula up to date
 
+```shell
+# Every 5 minutes, raise the outbound fees to a public key when inbound increases
+bos fees --to PUBLIC_KEY --set-fee-rate="IF(INBOUND>10000000,1000,500)" --repeat-interval-ms="5*min"
 ```
-#!/bin/bash
-# Raise the outbound fees to a public key when inbound increases
-/home/ubuntu/.npm-global/bin/bos fees --to PUBLIC_KEY --set-fee-rate="IF(INBOUND>10000000,1000,500)"
-```
+
+The interval is a formula in milliseconds that can use `s`, `min`, `h`, `d` and
+`w` units, so `"5*min * (0.5 + RAND())"` repeats at a random interval between
+2.5 and 7.5 minutes. See "Persist Long-Running Commands" below to keep the
+command running.
 
 ### Auto Balance Liquidity Between Two Nodes
 
@@ -431,13 +430,11 @@ Docker example:
 docker run -d --restart always -v $HOME/.bos:/home/node/.bos alexbosworth/balanceofsatoshis telegram --connect CONNECT_CODE
 ```
 
-You can also create a shell-script.sh to run a command repeatedly, with a delay
+Commands like `fees` and `rebalance` can also repeat themselves, with a delay
 
-```bash
-while true;
-do bos rebalance;
-sleep 2000;
-done
+```shell
+# Rebalance again 30 minutes after each attempt, or 1 hour when it failed
+bos rebalance --repeat-interval-ms="IF(FAILURES_COUNT > 0, 1*h, 30*min)"
 ```
 
 ## Docker

package/bos

@@ -731,7 +731,9 @@ prog
   .help('You can use INBOUND_FEE_RATE to mirror an inbound fee')
   .help('You can use FEE_RATE_OF_<PUBKEY> to reference other node rates')
   .help('--set-inbound-discount-rate is total discount on traffic from peer')
+  .help('--repeat-interval-ms vars: s, min, h, d, w: 1*h repeats hourly')
   .option('--node <node_name>', 'Saved node (not peer to set fees on)')
+  .option('--repeat-interval-ms <interval>', 'Repeat fees after interval')
   .option('--set-cltv-delta <count>', 'Set the number of blocks for CLTV', INT)
   .option('--set-fee-rate <rate>', 'Fee in parts per million or use a formula')
   .option('--set-inbound-rate-discount <rate>', 'Source discount rate in PPM')
@@ -739,13 +741,14 @@ prog
   .action((args, options, logger) => {
     return new Promise(async (resolve, reject) => {
       try {
-        return routing.adjustFees({
+        return routing.manageFees({
           logger,
           cltv_delta: options.setCltvDelta,
           fee_rate: options.setFeeRate,
           fs: {getFile: readFile},
           inbound_rate_discount: options.setInboundRateDiscount,
           lnd: (await lnd.authenticatedLnd({logger, node: options.node})).lnd,
+          repeat_interval_ms: options.repeatIntervalMs || undefined,
           to: flatten([options.to].filter(n => !!n)),
         },
         responses.returnObject({logger, reject, resolve, table: 'rows'}));
@@ -1693,6 +1696,8 @@ prog
   .help('--in-filter/--out-filter vars: OUTBOUND_LIQUIDITY/PENDING_PAYMENTS')
   .help('--in-filter/--out-filter vars: INBOUND_BASE_FEE/INBOUND_FEE_RATE')
   .help('--out increases the inbound liquidity with a specific peer/tag')
+  .help('--repeat-interval-ms vars: s, min, h, d, w: 1*h repeats hourly')
+  .help('--repeat-interval-ms var FAILURES_COUNT: count of failures in a row')
   .option('--amount <amount>', 'Maximum amount to rebalance')
   .option('--avoid <pubkey_or_chanid>', 'Avoid forwarding through', REPEATABLE)
   .option('--avoid-append', 'Formula for appending failing edges to list')
@@ -1709,6 +1714,7 @@ prog
   .option('--out <pubkey_or_alias>', 'Route out through a specific peer')
   .option('--out-filter <out_filter>', 'Filter outbound peer/tag', REPEATABLE)
   .option('--out-target-inbound <amount>', 'Balance up to inbound amount')
+  .option('--repeat-interval-ms <interval>', 'Repeat rebalance after interval')
   .action((args, options, logger) => {
     return new Promise(async (resolve, reject) => {
       try {
@@ -1729,6 +1735,7 @@ prog
           out_filters: flatten([options.outFilter].filter(n => !!n)),
           out_inbound: options.outTargetInbound,
           out_through: options.out || undefined,
+          repeat_interval_ms: options.repeatIntervalMs || undefined,
           timeout_minutes: options.minutes || undefined,
         },
         responses.returnObject({exit, logger, reject, resolve}));

package/chain/index.js

@@ -6,7 +6,6 @@ const getDepositAddress = require('./get_deposit_address');
 const getMempoolSize = require('./get_mempool_size');
 const getRawTransaction = require('./get_raw_transaction');
 const getUtxos = require('./get_utxos');
-const outputScriptForAddress = require('./output_script_for_address');
 const recoverP2pk = require('./recover_p2pk');
 const splitUtxos = require('./split_utxos');
 
@@ -19,7 +18,6 @@ module.exports = {
   getMempoolSize,
   getRawTransaction,
   getUtxos,
-  outputScriptForAddress,
   recoverP2pk,
   splitUtxos,
 };

package/chain/recover_p2pk.js

@@ -1,40 +1,39 @@
 const {createHash} = require('crypto');
 
 const asyncAuto = require('async/auto');
-const bitcoinjsLib = require('bitcoinjs-lib');
 const {broadcastChainTransaction} = require('ln-service');
+const {componentsOfTransaction} = require('@alexbosworth/blockchain');
 const {createChainAddress} = require('ln-service');
-const {decode} = require('bip66');
 const {getChainFeeRate} = require('ln-service');
 const {getIdentity} = require('ln-service');
 const {getNetwork} = require('ln-sync');
+const {idForTransaction} = require('@alexbosworth/blockchain');
+const {outputScriptForAddress} = require('@alexbosworth/blockchain');
 const {returnResult} = require('asyncjs-util');
+const {scriptElementsAsScript} = require('@alexbosworth/blockchain');
 const {signBytes} = require('ln-service');
+const {sizeOfTransaction} = require('@alexbosworth/blockchain');
+const {transactionFromComponents} = require('@alexbosworth/blockchain');
 
 const getRawTransaction = require('./get_raw_transaction');
 
 const {ceil} = Math;
-const {compile} = bitcoinjsLib.script;
 const {concat} = Buffer;
 const description = 'bos recover p2pk node identity key funds';
-const {encode} = bitcoinjsLib.script.signature;
 const estimatedSignatureSize = 73;
 const format = 'p2wpkh';
-const {fromHex} = bitcoinjsLib.Transaction;
 const hashFlag = Buffer.from('01000000', 'hex');
 const hexAsBuffer = hex => Buffer.from(hex, 'hex');
-const inputIndex = 0;
 const inputSequence = 0;
 const isHash = n => !!n && /^[0-9A-F]{64}$/i.test(n);
-const networkNames = {btc: 'bitcoin', btctestnet: 'testnet'};
-const {networks} = bitcoinjsLib;
+const locktime = 0;
 const nodeIdentityKeyFamily = 6;
 const nodeIdentityKeyIndex = 0;
 const OP_CHECKSIG = 172;
 const sha256 = n => createHash('sha256').update(n).digest().toString('hex');
-const slicePoint = r => r.length === 33 ? r.slice(1) : r;
-const {toOutputScript} = bitcoinjsLib.address;
-const {Transaction} = bitcoinjsLib;
+const sigHashType = Buffer.from('01', 'hex');
+const unsignedScript = '';
+const version = 1;
 
 /** Recover funds sent to a P2PK using the node identity key
 
@@ -97,14 +96,16 @@ module.exports = ({id, lnd, request, vout}, cbk) => {
 
       // Derive the transaction details
       output: ['getIdentity', 'getTx', ({getIdentity, getTx}, cbk) => {
-        const tx = fromHex(getTx.transaction);
+        const {transaction} = getTx;
 
         // Make sure the tx data matches the input id
-        if (tx.getId() !== id) {
+        if (idForTransaction({transaction}).id !== id) {
           return cbk([503, 'ExpectedTransactionIdToMatchTxDataHashToRecover']);
         }
 
-        const output = tx.outs[vout];
+        const {outputs} = componentsOfTransaction({transaction});
+
+        const output = outputs[vout];
 
         // Make sure the output exists
         if (!output) {
@@ -113,14 +114,16 @@ module.exports = ({id, lnd, request, vout}, cbk) => {
 
         const identityKey = hexAsBuffer(getIdentity.public_key);
 
-        const expectedScript = compile([identityKey, OP_CHECKSIG]);
+        const expected = scriptElementsAsScript({
+          elements: [identityKey, OP_CHECKSIG],
+        });
 
         // Make sure that the output pays to the node identity key
-        if (!output.script.equals(expectedScript)) {
+        if (output.script !== expected.script) {
           return cbk([503, 'ExpectedOutputPayingToNodeIdentityPublicKey']);
         }
 
-        return cbk(null, {script: output.script, tokens: output.value});
+        return cbk(null, {script: output.script, tokens: output.tokens});
       }],
 
       // Create a recovery address
@@ -128,45 +131,73 @@ module.exports = ({id, lnd, request, vout}, cbk) => {
         return createChainAddress({format, lnd}, cbk);
       }],
 
-      // Make the transaction to sign
-      txToSign: [
+      // Derive the output script of the recovery address
+      recoveryScript: [
         'createAddress',
-        'getFee',
         'getNetwork',
-        'output',
-        ({createAddress, getFee, getNetwork, output}, cbk) =>
+        ({createAddress, getNetwork}, cbk) =>
       {
-        const network = networks[networkNames[getNetwork.network]];
-        const tx = new Transaction();
-
-        const scriptPubKey = toOutputScript(createAddress.address, network);
+        try {
+          const {script} = outputScriptForAddress({
+            address: createAddress.address,
+            network: getNetwork.network,
+          });
+
+          return cbk(null, {script});
+        } catch (err) {
+          return cbk([503, 'FailedToParseRecoveryAddress', {err}]);
+        }
+      }],
 
-        tx.addInput(hexAsBuffer(id).reverse(), vout, inputSequence);
-        tx.addOutput(scriptPubKey, output.tokens);
+      // Derive the sweep output, less the amount needed to pay for chain fees
+      sweep: [
+        'getFee',
+        'output',
+        'recoveryScript',
+        ({getFee, output, recoveryScript}, cbk) =>
+      {
+        const {script} = recoveryScript;
+
+        const unsigned = transactionFromComponents({
+          locktime,
+          version,
+          inputs: [{
+            id,
+            vout,
+            script: unsignedScript,
+            sequence: inputSequence,
+          }],
+          outputs: [{script, tokens: output.tokens}],
+        });
 
-        // There is only one output on the sweep transaction
-        const [out] = tx.outs;
+        const {vsize} = sizeOfTransaction(unsigned);
 
         // Include the prospective signature in the tx total weight
-        const vbytes = tx.virtualSize() + estimatedSignatureSize;
+        const vbytes = vsize + estimatedSignatureSize;
 
         // Reduce the sweep value by the amount needed to pay for chain fees
-        out.value -= ceil(vbytes * getFee.tokens_per_vbyte);
+        const tokens = output.tokens - ceil(vbytes * getFee.tokens_per_vbyte);
 
-        return cbk(null, tx);
+        return cbk(null, {script, tokens});
       }],
 
       // Derive the preimage to use for signing
-      preimage: ['output', 'txToSign', ({output, txToSign}, cbk) => {
-        const cloneTx = txToSign.clone();
-
-        const [input] = cloneTx.ins;
-
+      preimage: ['output', 'sweep', ({output, sweep}, cbk) => {
         // When signing, the input to sign is set to the previous output script
-        input.script = output.script;
+        const {transaction} = transactionFromComponents({
+          locktime,
+          version,
+          inputs: [{
+            id,
+            vout,
+            script: output.script,
+            sequence: inputSequence,
+          }],
+          outputs: [sweep],
+        });
 
         // The bytes to sign are the tx itself plus the signature hash flag
-        return cbk(null, concat([cloneTx.toBuffer(), hashFlag]));
+        return cbk(null, concat([hexAsBuffer(transaction), hashFlag]));
       }],
 
       // Give the preimage to signer, hashed once - signBytes does 2nd SHA hash
@@ -181,17 +212,18 @@ module.exports = ({id, lnd, request, vout}, cbk) => {
       }],
 
       // Put together the signature with the transaction
-      signedTx: ['getSig', 'txToSign', ({getSig, txToSign}, cbk) => {
-        const {r, s} = decode(hexAsBuffer(getSig.signature));
-
-        const rValue = slicePoint(r);
-
-        // Convert the signature from sign bytes to a chain signature
-        const scriptSig = encode(concat([rValue, s]), Transaction.SIGHASH_ALL);
-
-        txToSign.setInputScript(inputIndex, compile([scriptSig]));
-
-        return cbk(null, txToSign);
+      signedTx: ['getSig', 'sweep', ({getSig, sweep}, cbk) => {
+        // A chain signature is the DER signature followed by the sighash type
+        const signature = concat([hexAsBuffer(getSig.signature), sigHashType]);
+
+        const {script} = scriptElementsAsScript({elements: [signature]});
+
+        return cbk(null, transactionFromComponents({
+          locktime,
+          version,
+          inputs: [{id, script, vout, sequence: inputSequence}],
+          outputs: [sweep],
+        }));
       }],
 
       // Broadcast the signed transaction
@@ -199,7 +231,7 @@ module.exports = ({id, lnd, request, vout}, cbk) => {
         return broadcastChainTransaction({
           description,
           lnd,
-          transaction: signedTx.toHex(),
+          transaction: signedTx.transaction,
         },
         cbk);
       }],
@@ -214,7 +246,7 @@ module.exports = ({id, lnd, request, vout}, cbk) => {
         return cbk(null, {
           recovering: output.tokens,
           recovering_to: createAddress.address,
-          transaction_id: signedTx.getId(),
+          transaction_id: idForTransaction(signedTx).id,
         });
       }],
     },

package/display/constants.json

@@ -1,4 +1,10 @@
 {
+  "durationUnits": [
+    {"ms": 86400000, "unit": "day"},
+    {"ms": 3600000, "unit": "hour"},
+    {"ms": 60000, "unit": "minute"},
+    {"ms": 1000, "unit": "second"}
+  ],
   "parseErrors": {
     "#DIV/0!": "CannotDivideByZeroInFormula",
     "#ERROR!":  "FailedToParseFormula",

package/display/format_duration.js

@@ -0,0 +1,34 @@
+const {durationUnits} = require('./constants');
+
+const {floor} = Math;
+const maxUnits = 2;
+const plural = (count, unit) => `${count} ${unit}${count === 1 ? '' : 's'}`;
+
+/** Format a duration for display, using the two largest units of time
+
+  {
+    ms: <Duration Milliseconds Number>
+  }
+
+  @returns
+  {
+    display: <Display Formatted Duration String>
+  }
+*/
+module.exports = ({ms}) => {
+  // Take whole counts of each unit out of the duration, largest unit first
+  const {parts, remaining} = durationUnits.reduce((sum, unit) => {
+    const count = floor(sum.remaining / unit.ms);
+
+    return {
+      parts: !count ? sum.parts : sum.parts.concat(plural(count, unit.unit)),
+      remaining: sum.remaining - count * unit.ms,
+    };
+  },
+  {parts: [], remaining: ms});
+
+  // Leftover milliseconds are shown when present or when there is nothing else
+  const leftover = !remaining && !!parts.length ? [] : [`${remaining} ms`];
+
+  return {display: parts.concat(leftover).slice(0, maxUnits).join(' ')};
+};

package/display/index.js

@@ -2,6 +2,7 @@ const chartAliasForPeer = require('./chart_alias_for_peer');
 const describeConfidence = require('./describe_confidence');
 const describeRoute = require('./describe_route');
 const describeRoutingFailure = require('./describe_routing_failure');
+const formatDuration = require('./format_duration');
 const formatFeeRate = require('./format_fee_rate');
 const getIcons = require('./get_icons');
 const isMatchingFilters = require('./is_matching_filters');
@@ -13,6 +14,7 @@ module.exports = {
   describeConfidence,
   describeRoute,
   describeRoutingFailure,
+  formatDuration,
   formatFeeRate,
   getIcons,
   isMatchingFilters,

package/package.json

@@ -15,10 +15,10 @@
     "url": "https://github.com/alexbosworth/balanceofsatoshis/issues"
   },
   "dependencies": {
-    "@alexbosworth/blockchain": "4.8.0",
+    "@alexbosworth/blockchain": "4.9.0",
     "@alexbosworth/caporal": "2.0.0",
     "@alexbosworth/fiat": "2.0.0",
-    "@alexbosworth/formulas": "1.4.0",
+    "@alexbosworth/formulas": "1.5.0",
     "@alexbosworth/html2unicode": "1.1.5",
     "@alexbosworth/node-fetch": "2.6.2",
     "abort-controller": "3.0.0",
@@ -33,18 +33,18 @@
     "bolt07": "2.0.0",
     "cbor": "10.0.12",
     "colorette": "2.0.20",
-    "csv-parse": "7.0.2",
+    "csv-parse": "7.0.3",
     "goldengate": "16.0.7",
     "grammy": "1.46.0",
     "import-lazy": "4.0.0",
     "ini": "7.0.0",
     "inquirer": "14.2.2",
     "ln-accounting": "10.0.7",
-    "ln-service": "59.7.0",
+    "ln-service": "60.0.0",
     "ln-sync": "8.0.6",
     "ln-telegram": "8.0.6",
     "moment": "2.31.0",
-    "paid-services": "8.0.7",
+    "paid-services": "9.0.0",
     "probing": "7.0.0",
     "qrcode-terminal": "0.12.0",
     "sanitize-filename": "1.6.4",
@@ -107,5 +107,5 @@
     "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"
   },
-  "version": "24.0.0"
+  "version": "24.1.0"
 }

package/peers/intercept_inbound_channels.js

@@ -1,12 +1,12 @@
 const asyncAuto = require('async/auto');
 const {getIdentity} = require('ln-service');
 const {getNetwork} = require('ln-sync');
+const {outputScriptForAddress} = require('@alexbosworth/blockchain');
 const {returnResult} = require('asyncjs-util');
 const {subscribeToOpenRequests} = require('ln-service');
 
 const detectOpenRuleViolation = require('./detect_open_rule_violation');
 const openRequestViolation = require('./open_request_violation');
-const {outputScriptForAddress} = require('./../chain');
 
 const {isArray} = Array;
 const isPublicKey = n => !!n && /^0[2-3][0-9A-F]{64}$/i.test(n);

package/routing/index.js

@@ -8,6 +8,7 @@ const getIgnores = require('./get_ignores');
 const getPastForwards = require('./get_past_forwards');
 const giftRoute = require('./gift_route');
 const ignoreFromAvoid = require('./ignore_from_avoid');
+const manageFees = require('./manage_fees');
 
 module.exports = {
   adjustFees,
@@ -20,4 +21,5 @@ module.exports = {
   getPastForwards,
   giftRoute,
   ignoreFromAvoid,
+  manageFees,
 };

package/routing/manage_fees.js

@@ -0,0 +1,129 @@
+const asyncAuto = require('async/auto');
+const asyncForever = require('async/forever');
+const {getBorderCharacters} = require('table');
+const moment = require('moment');
+const renderTable = require('table').table;
+const {returnResult} = require('asyncjs-util');
+
+const adjustFees = require('./adjust_fees');
+const {formatDuration} = require('./../display');
+const parseIntervalFormula = require('./../swaps/parse_interval_formula');
+
+const border = getBorderCharacters('norc');
+const calendarFormats = {sameElse: 'L [at] LT'};
+const {isArray} = Array;
+
+/** Manage routing fee adjustments
+
+  {
+    [cltv_delta]: <Set CLTV Delta Number>
+    [fee_rate]: <Fee Rate String>
+    fs: {
+      getFile: <Read File Contents Function> (path, cbk) => {}
+    }
+    [inbound_rate_discount]: <Discount Fee Rate Number>
+    lnd: <Authenticated LND API Object>
+    logger: <Winston Logger Object>
+    [repeat_interval_ms]: <Repeat After Interval Milliseconds Formula String>
+    to: [<Adjust Routing Fee To Peer Alias or Public Key or Tag String>]
+  }
+
+  @returns via cbk or Promise
+  {
+    rows: [[<Table Cell String>]]
+  }
+*/
+module.exports = (args, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!args.fs) {
+          return cbk([400, 'ExpectedFsMethodsToManageFees']);
+        }
+
+        if (!args.lnd) {
+          return cbk([400, 'ExpectedLndToManageFees']);
+        }
+
+        if (!args.logger) {
+          return cbk([400, 'ExpectedLoggerToManageFees']);
+        }
+
+        if (isArray(args.repeat_interval_ms)) {
+          return cbk([400, 'ExpectedSingleRepeatIntervalValue']);
+        }
+
+        return cbk();
+      },
+
+      // Check that the repeat interval formula is valid before starting
+      interval: ['validate', ({}, cbk) => {
+        // Exit early when the fee adjustment is not repeated
+        if (args.repeat_interval_ms === undefined) {
+          return cbk();
+        }
+
+        const {failure} = parseIntervalFormula({
+          formula: args.repeat_interval_ms,
+        });
+
+        if (!!failure) {
+          return cbk([400, 'FailedToParseRepeatIntervalFormula', {failure}]);
+        }
+
+        return cbk();
+      }],
+
+      // Adjust the fees
+      adjust: ['interval', ({}, cbk) => {
+        const execute = cbk => adjustFees({
+          cltv_delta: args.cltv_delta,
+          fee_rate: args.fee_rate,
+          fs: args.fs,
+          inbound_rate_discount: args.inbound_rate_discount,
+          lnd: args.lnd,
+          logger: args.logger,
+          to: args.to,
+        },
+        cbk);
+
+        // Exit early when the fees are only adjusted once
+        if (args.repeat_interval_ms === undefined) {
+          return execute(cbk);
+        }
+
+        // Adjust the fees again every time the interval elapses
+        return asyncForever(cbk => {
+          return execute((err, res) => {
+            if (!!err) {
+              args.logger.error({err});
+            } else {
+              args.logger.info(renderTable(res.rows, {border}));
+            }
+
+            // The interval formula is evaluated again after every attempt
+            const {failure, ms} = parseIntervalFormula({
+              formula: args.repeat_interval_ms,
+            });
+
+            if (!!failure) {
+              return cbk([400, 'FailedToEvaluateRepeatInterval', {failure}]);
+            }
+
+            const next = moment().add(ms, 'ms');
+
+            args.logger.info({
+              repeat_interval: formatDuration({ms}).display,
+              repeating_fees_at: next.calendar(null, calendarFormats),
+            });
+
+            return setTimeout(cbk, ms);
+          });
+        },
+        cbk);
+      }],
+    },
+    returnResult({reject, resolve, of: 'adjust'}, cbk));
+  });
+};

package/services/open_balanced_channel.js

@@ -9,12 +9,12 @@ const {getNodeAlias} = require('ln-sync');
 const {getPublicKey} = require('ln-service');
 const moment = require('moment');
 const {networks} = require('bitcoinjs-lib');
+const {outputScriptForAddress} = require('@alexbosworth/blockchain');
 const {returnResult} = require('asyncjs-util');
 
 const acceptBalancedChannel = require('./accept_balanced_channel');
 const getBalancedOpens = require('./get_balanced_opens');
 const initiateBalancedChannel = require('./initiate_balanced_channel');
-const {outputScriptForAddress} = require('./../chain');
 const recoverTransitFunds = require('./recover_transit_funds');
 
 const bufferAsHex = buffer => buffer.toString('hex');