balanceofsatoshis 24.2.0 → 24.2.1

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Versions
 
+## 24.2.1
+
+- `open`: Adhere to BIP 69 when ordering funding outputs with equal amounts
+
 ## 24.2.0
 
 - Add support for LND 0.21.4 and LND 0.20.5

package/package.json

@@ -15,7 +15,7 @@
     "url": "https://github.com/alexbosworth/balanceofsatoshis/issues"
   },
   "dependencies": {
-    "@alexbosworth/blockchain": "4.9.0",
+    "@alexbosworth/blockchain": "4.10.0",
     "@alexbosworth/caporal": "2.0.0",
     "@alexbosworth/fiat": "2.0.0",
     "@alexbosworth/formulas": "1.5.0",
@@ -38,7 +38,7 @@
     "ini": "7.0.0",
     "inquirer": "14.2.2",
     "ln-accounting": "10.0.7",
-    "ln-service": "60.1.1",
+    "ln-service": "60.1.2",
     "ln-sync": "8.0.6",
     "ln-telegram": "8.0.6",
     "moment": "2.31.0",
@@ -54,7 +54,7 @@
   "description": "Lightning balance CLI",
   "devDependencies": {
     "invoices": "6.2.0",
-    "ln-docker-daemons": "8.0.5"
+    "ln-docker-daemons": "8.1.0"
   },
   "engines": {
     "node": ">=22"
@@ -105,5 +105,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.2.0"
+  "version": "24.2.1"
 }

package/peers/open_channels.js

@@ -2,7 +2,6 @@ const {randomBytes} = require('crypto');
 
 const {acceptsChannelOpen} = require('ln-sync');
 const {addPeer} = require('ln-service');
-const {address} = require('bitcoinjs-lib');
 const {askForFeeRate} = require('ln-sync');
 const asyncAuto = require('async/auto');
 const asyncEach = require('async/each');
@@ -14,6 +13,7 @@ const asyncReflect = require('async/reflect');
 const asyncRetry = require('async/retry');
 const {broadcastChainTransaction} = require('ln-service');
 const {cancelPendingChannel} = require('ln-service');
+const {decodeBech32Address} = require('@alexbosworth/blockchain');
 const {fundPendingChannels} = require('ln-service');
 const {getChainBalance} = require('ln-service');
 const {getChannels} = require('ln-service');
@@ -23,12 +23,13 @@ const {getNode} = require('ln-service');
 const {getPeers} = require('ln-service');
 const {getPsbtFromTransaction} = require('goldengate');
 const {getWalletVersion} = require('ln-service');
+const {idForTransaction} = require('@alexbosworth/blockchain');
 const {openChannels} = require('ln-service');
 const {maintainUtxoLocks} = require('ln-sync');
 const moment = require('moment');
 const {parseAmount} = require('ln-accounting');
 const {returnResult} = require('asyncjs-util');
-const {Transaction} = require('bitcoinjs-lib');
+const {scriptElementsAsScript} = require('@alexbosworth/blockchain');
 const {unlockUtxo} = require('ln-service');
 
 const adjustFees = require('./../routing/adjust_fees');
@@ -38,13 +39,14 @@ const {getAddressUtxo} = require('./../chain');
 const getChannelOutpoints = require('./get_channel_outpoints');
 const getPeersForNodes = require('./get_peers_for_nodes');
 
-const bech32AsData = bech32 => address.fromBech32(bech32).data;
 const description = 'bos open';
 const detectNetworks = ['btc', 'btctestnet'];
+const encodeVersion = version => 80 + version;
 const featureAnchors = 'anchor_zero_fee_htlc_tx';
 const flatten = arr => [].concat(...arr);
 const format = 'p2wpkh';
-const {fromHex} = Transaction;
+const hexAsBuffer = hex => Buffer.from(hex, 'hex');
+const idOf = transaction => idForTransaction({transaction}).id;
 const interval = 1000;
 const {isArray} = Array;
 const isPublicKey = n => !!n && /^0[2-3][0-9A-F]{64}$/i.test(n);
@@ -623,15 +625,28 @@ module.exports = (args, cbk) => {
           return pending.map(n => ({address: n.address, tokens: n.tokens}));
         }));
 
+        // Map a bech32 address to its output script: OP_n then a data push
+        const scriptOf = address => {
+          const {program, version} = decodeBech32Address({address});
+
+          // Encode the version as a script number
+          const op = !version ? version : encodeVersion(version);
+
+          const {script} = scriptElementsAsScript({elements: [op, program]});
+
+          return hexAsBuffer(script);
+        };
+
         // Sort all the outputs using BIP 69
         try {
-            pending.sort((a, b) => {
+          pending.sort((a, b) => {
             // Sort by tokens ascending when no tie breaker needed
             if (a.tokens !== b.tokens) {
               return a.tokens - b.tokens;
             }
 
-            return bech32AsData(a.address).compare(bech32AsData(b.address));
+            // Break ties by comparing the output scripts as bytes
+            return scriptOf(a.address).compare(scriptOf(b.address));
           });
         } catch (err) {}
 
@@ -690,9 +705,7 @@ module.exports = (args, cbk) => {
                 return cbk();
               }
 
-              args.logger.info({
-                funding_detected: Transaction.fromHex(foundTx).getId(),
-              });
+              args.logger.info({funding_detected: idOf(foundTx)});
 
               return asyncEach(openChannels, ({lnd, node, pending}, cbk) => {
                 return fundPendingChannels({
@@ -817,7 +830,7 @@ module.exports = (args, cbk) => {
         }
 
         const toOpen = flatten(openChannels.map(n => n.pending));
-        const txId = fromHex(getFunding.value.transaction).getId();
+        const txId = idOf(getFunding.value.transaction);
 
         args.logger.info({confirming_pending_open: true});
 

package/swaps/channel_for_receive.js

@@ -0,0 +1,91 @@
+const {sortBy} = require('./../arrays');
+
+const attribute = 'receivable';
+const feeBuffer = fees => fees * 2;
+const {floor} = Math;
+const htlcOutputSize = 43;
+const {min} = Math;
+const mtokensAsTokens = mtokens => Number(BigInt(mtokens) / BigInt(1e3));
+const rate = n => n.commit_transaction_fee / (n.commit_transaction_weight / 4);
+
+/** Choose a channel with a peer to receive a payment through
+
+  The peer forwards the payment to us over the channel, so the peer needs the
+  balance on their side to send it and their policy towards us must allow it.
+
+  The preferred channel is kept when it can receive the full amount, otherwise
+  the channel that can receive the most is chosen.
+
+  {
+    channels: [{
+      commit_transaction_fee: <Commit Transaction Fee Number>
+      commit_transaction_weight: <Commit Transaction Weight Number>
+      id: <Standard Format Channel Id String>
+      is_active: <Channel Active Bool>
+      is_partner_initiated: <Channel Partner Opened Channel Bool>
+      partner_public_key: <Peer Public Key Hex String>
+      policies: [{
+        [is_disabled]: <Channel Is Disabled Bool>
+        [max_htlc_mtokens]: <Maximum HTLC Millitokens Value String>
+        public_key: <Node Public Key Hex String>
+      }]
+      remote_balance: <Remote Balance Tokens Number>
+      remote_reserve: <Remote Reserved Tokens Number>
+    }]
+    [id]: <Preferred Channel Id String>
+    peer: <Peer Public Key Hex String>
+    tokens: <Tokens To Receive Number>
+  }
+
+  @returns
+  {
+    [id]: <Channel Id String>
+    [receivable]: <Receivable Tokens Number>
+  }
+*/
+module.exports = ({channels, id, peer, tokens}) => {
+  const candidates = channels
+    .filter(n => n.partner_public_key === peer)
+    .filter(n => !!n.is_active)
+    .map(channel => {
+      const policy = channel.policies.find(n => n.public_key === peer);
+
+      // Exit early when the peer does not forward to us over this channel
+      if (!policy || !!policy.is_disabled) {
+        return;
+      }
+
+      // The partner needs to keep a buffer for fees when they pay for commits
+      const fees = !channel.is_partner_initiated ? Number() :
+        channel.commit_transaction_fee + htlcOutputSize * rate(channel);
+
+      const balance = channel.remote_balance - channel.remote_reserve;
+
+      const spendable = balance - feeBuffer(fees);
+
+      // The peer limits the size of HTLCs that they will forward to us
+      const maxHtlc = !policy.max_htlc_mtokens ? spendable :
+        mtokensAsTokens(policy.max_htlc_mtokens);
+
+      return {id: channel.id, receivable: floor(min(spendable, maxHtlc))};
+    })
+    .filter(n => !!n && n.receivable > Number());
+
+  const preferred = candidates.find(n => n.id === id);
+
+  // Exit early when the preferred channel can receive the full amount
+  if (!!preferred && preferred.receivable >= tokens) {
+    return {id, receivable: preferred.receivable};
+  }
+
+  // Exit early when no channel with the peer can receive anything
+  if (!candidates.length) {
+    return {};
+  }
+
+  const {sorted} = sortBy({attribute, array: candidates});
+
+  const [best] = sorted.slice().reverse();
+
+  return {id: best.id, receivable: best.receivable};
+};

package/swaps/rebalance.js

@@ -16,6 +16,7 @@ const {payViaRoutes} = require('ln-service');
 const {returnResult} = require('asyncjs-util');
 const {routeFromChannels} = require('ln-service');
 
+const channelForReceive = require('./channel_for_receive');
 const findRebalancePeer = require('./find_rebalance_peer');
 const {formatFeeRate} = require('./../display');
 const {getIgnores} = require('./../routing');
@@ -599,10 +600,9 @@ module.exports = (args, cbk) => {
         cbk);
       }],
 
-      // Get channels for the rebalance route
-      channels: [
+      // Get channels for the probed rebalance route
+      getRouteChannels: [
         'findRoute',
-        'getInitialLiquidity',
         'getPublicKey',
         'lnd',
         ({findRoute, getPublicKey, lnd}, cbk) =>
@@ -633,13 +633,116 @@ module.exports = (args, cbk) => {
         cbk);
       }],
 
+      // Get the current channels with the inbound peer
+      getInboundChannels: [
+        'getInbound',
+        'getRouteChannels',
+        'lnd',
+        ({getInbound, lnd}, cbk) =>
+      {
+        return getChannels({
+          lnd,
+          is_active: true,
+          partner_public_key: getInbound.public_key,
+        },
+        cbk);
+      }],
+
+      // Get the inbound peer channels together with their routing policies
+      inboundChannels: [
+        'getInboundChannels',
+        'lnd',
+        ({getInboundChannels, lnd}, cbk) =>
+      {
+        return asyncMap(getInboundChannels.channels, (channel, cbk) => {
+          return getChannel({lnd, id: channel.id}, (err, res) => {
+            // Policies are unknown when the channel is not found in the graph
+            const policies = !!err ? [] : res.policies;
+
+            return cbk(null, {
+              policies,
+              capacity: channel.capacity,
+              commit_transaction_fee: channel.commit_transaction_fee,
+              commit_transaction_weight: channel.commit_transaction_weight,
+              id: channel.id,
+              is_active: channel.is_active,
+              is_partner_initiated: channel.is_partner_initiated,
+              partner_public_key: channel.partner_public_key,
+              remote_balance: channel.remote_balance,
+              remote_reserve: channel.remote_reserve,
+            });
+          });
+        },
+        cbk);
+      }],
+
+      // Choose the final hop channel that has the inbound to receive the amount
+      finalHop: [
+        'findRoute',
+        'getInbound',
+        'getPublicKey',
+        'getRouteChannels',
+        'inboundChannels',
+        ({
+          findRoute,
+          getInbound,
+          getPublicKey,
+          getRouteChannels,
+          inboundChannels,
+        },
+        cbk) =>
+      {
+        const [probed] = getRouteChannels.slice().reverse();
+        const inPeer = getInbound.public_key;
+        const maximum = findRoute.route_maximum;
+
+        const fromInPeer = probed.policies.find(n => n.public_key === inPeer);
+
+        // Exit early when the route does not end with the inbound peer to self
+        if (!fromInPeer || probed.destination !== getPublicKey.public_key) {
+          return cbk(null, {maximum, channel: probed});
+        }
+
+        // LND picks the final hop channel without regard to the peer balance
+        const {id, receivable} = channelForReceive({
+          channels: inboundChannels,
+          id: probed.id,
+          peer: inPeer,
+          tokens: maximum,
+        });
+
+        // Exit early when the probed final hop channel is used to receive
+        if (!id || id === probed.id) {
+          return cbk(null, {maximum, channel: probed});
+        }
+
+        const {capacity, policies} = inboundChannels.find(n => n.id === id);
+
+        // The amount is limited to what the switched channel can receive
+        return cbk(null, {
+          channel: {capacity, id, policies, destination: probed.destination},
+          maximum: min(maximum, receivable),
+        });
+      }],
+
+      // Channels for the rebalance route, ending with the chosen final hop
+      channels: [
+        'finalHop',
+        'getRouteChannels',
+        ({finalHop, getRouteChannels}, cbk) =>
+      {
+        const hops = getRouteChannels.slice(Number(), -1);
+
+        return cbk(null, hops.concat(finalHop.channel));
+      }],
+
       // Create local invoice
-      invoice: ['channels', 'findRoute', 'lnd', ({findRoute, lnd}, cbk) => {
+      invoice: ['channels', 'finalHop', 'lnd', ({finalHop, lnd}, cbk) => {
         return createInvoice({
           lnd,
           cltv_delta: defaultCltvDelta,
           description: 'Rebalance',
-          tokens: findRoute.route_maximum,
+          tokens: finalHop.maximum,
         },
         cbk);
       }],