balanceofsatoshis 24.2.2 → 25.0.0

package/network/pending_payments.js

@@ -0,0 +1,105 @@
+const flatten = arr => [].concat(...arr);
+
+/** Derive pending forwarding and sending HTLCs from channels
+
+  {
+    channels: [{
+      id: <Channel Id String>
+      partner_public_key: <Peer Public Key Hex String>
+      pending_payments: [{
+        id: <Payment Preimage Hash Hex String>
+        [in_channel]: <Forward Inbound From Channel Id String>
+        [in_payment]: <Payment Index on Inbound Channel Number>
+        [is_forward]: <Payment is a Forward Bool>
+        is_outgoing: <Payment Is Outgoing Bool>
+        [out_channel]: <Forward Outbound To Channel Id String>
+        [out_payment]: <Payment Index on Outbound Channel Number>
+        [payment]: <Payment Attempt Id Number>
+        timeout: <Chain Height Expiration Number>
+        tokens: <Payment Tokens Number>
+      }]
+    }]
+  }
+
+  @returns
+  {
+    forwarding: [{
+      fee: <Routing Fee Tokens Number>
+      in_peer: <Forwarding From Peer Public Key Hex String>
+      out_peer: <Forwarding To Peer Public Key Hex String>
+      payment: <Forwarding Payment Hash Hex String>
+      timeout: <Chain Height Expiration Number>
+      tokens: <Forwarding Tokens Amount Number>
+    }]
+    sending: [{
+      id: <Sending Payment Hash Hex String>
+      out_channel: <Sending Out Channel Id String>
+      out_peer: <Sending Out Peer Public Key Hex String>
+      timeout: <Sending Timeout Block Height Number>
+      tokens: <Sending Tokens Amount Number>
+    }]
+  }
+*/
+module.exports = ({channels}) => {
+  // Outgoing HTLCs that are not forwards are payments or probes being sent
+  const sending = flatten(channels.map(channel => {
+    return channel.pending_payments
+      .filter(n => !n.is_forward && !!n.is_outgoing)
+      .map(payment => ({
+        id: payment.id,
+        out_channel: channel.id,
+        out_peer: channel.partner_public_key,
+        timeout: payment.timeout,
+        tokens: payment.tokens,
+      }));
+  }));
+
+  // Outgoing forward HTLCs reference the inbound HTLC that they are relaying
+  const outbound = flatten(channels.map(channel => {
+    return channel.pending_payments
+      .filter(n => !!n.is_forward && !!n.is_outgoing && !!n.in_channel)
+      .map(payment => ({
+        id: payment.id,
+        in_channel: payment.in_channel,
+        in_payment: payment.in_payment,
+        out_channel: channel.id,
+        out_peer: channel.partner_public_key,
+        tokens: payment.tokens,
+      }));
+  }));
+
+  // Pair up outgoing forward HTLCs with the inbound HTLCs they are relaying
+  const forwarding = outbound.map(htlc => {
+    const inboundChannel = channels.find(n => n.id === htlc.in_channel);
+
+    // Exit early when the inbound channel is not a known channel
+    if (!inboundChannel) {
+      return;
+    }
+
+    // The inbound HTLC is the one forwarding to the outbound channel
+    const inbound = inboundChannel.pending_payments.find(payment => {
+      const isForwardIn = !payment.is_outgoing && !!payment.is_forward;
+      const isSameIndex = payment.payment === htlc.in_payment;
+      const isToOutChannel = payment.out_channel === htlc.out_channel;
+
+      return isForwardIn && isToOutChannel && isSameIndex;
+    });
+
+    // Exit early when the inbound HTLC is not present on the inbound channel
+    if (!inbound) {
+      return;
+    }
+
+    return {
+      fee: inbound.tokens - htlc.tokens,
+      in_peer: inboundChannel.partner_public_key,
+      out_peer: htlc.out_peer,
+      payment: htlc.id,
+      timeout: inbound.timeout,
+      tokens: htlc.tokens,
+    };
+  });
+
+  return {sending, forwarding: forwarding.filter(n => !!n)};
+};

package/network/pending_summary.js

@@ -0,0 +1,204 @@
+const {bold} = require('colorette');
+const {formatTokens} = require('ln-sync');
+
+const {formatDuration} = require('./../display');
+
+const blocksAsMs = blocks => blocks * 1000 * 60 * 10;
+const flatten = arr => [].concat(...arr);
+const isEmoji = /[^\p{L}\p{N}\p{P}\p{Z}{\^\$}]/gu;
+const joinLines = lines => lines.join('\n');
+const joinPath = hops => hops.join(' → ');
+const joinSections = sections => sections.join('\n\n');
+const moreHops = count => `...${count} more...`;
+const nothingPending = 'No pending payments or channels';
+const shortKey = key => key.substring(0, 8);
+
+/** Summarize the pending channels and in-flight HTLCs of nodes
+
+  {
+    [is_monochrome]: <Mute Colors Bool>
+    [max_relays]: <Maximum Relaying Peers of a Path to Show Number>
+    nodes: [{
+      closing: [{
+        [blocks_until_recovery]: <Blocks Until Pending Balance Recovers Number>
+        [close_transaction_id]: <Closing Transaction Id Hex String>
+        [peer_alias]: <Peer Alias String>
+        peer_public_key: <Peer Public Key Hex String>
+        [pending_balance]: <Pending Recovery Tokens Number>
+      }]
+      forwarding: [{
+        fee: <Routing Fee Tokens Number>
+        [in_peer_alias]: <Inbound Peer Alias String>
+        in_peer_public_key: <Inbound Peer Public Key Hex String>
+        [out_peer_alias]: <Outbound Peer Alias String>
+        out_peer_public_key: <Outbound Peer Public Key Hex String>
+        tokens: <Forwarding Tokens Number>
+      }]
+      opening: [{
+        capacity: <Channel Capacity Tokens Number>
+        is_partner_initiated: <Peer Is Opening The Channel Bool>
+        [peer_alias]: <Peer Alias String>
+        peer_public_key: <Peer Public Key Hex String>
+        transaction_id: <Funding Transaction Id Hex String>
+      }]
+      sending: [{
+        [fee]: <Routing Fee Tokens Number>
+        hops: [{
+          [alias]: <Hop Node Alias String>
+          public_key: <Hop Node Public Key Hex String>
+        }]
+        is_rebalance: <Payment Is Going Back To The Node Itself Bool>
+        tokens: <Sending Tokens Number>
+      }]
+      [alias]: <Node Alias String>
+      public_key: <Node Identity Public Key Hex String>
+    }]
+    [tagged]: [{
+      icons: [<Icon String>]
+      public_key: <Public Key Hex String>
+    }]
+  }
+
+  @returns
+  {
+    summary: <Pending Items Summary String>
+  }
+*/
+module.exports = ({is_monochrome, max_relays, nodes, tagged}) => {
+  // Zero or absent tokens have no amount to display
+  const amount = tokens => {
+    return formatTokens({is_monochrome, tokens}).display.trim();
+  };
+
+  // Paths may collapse their relaying peers to keep the path short
+  const path = hops => {
+    const [first, ...others] = hops;
+
+    const [last, ...reversedRelays] = others.slice().reverse();
+
+    const relays = reversedRelays.reverse();
+
+    // Exit early when there is no limit or the relays are within the limit
+    if (max_relays === undefined || !others.length) {
+      return joinPath(hops);
+    }
+
+    if (relays.length <= max_relays) {
+      return joinPath(hops);
+    }
+
+    const shown = relays.slice(Number(), max_relays);
+
+    const hidden = [moreHops(relays.length - shown.length)];
+
+    return joinPath([first].concat(shown).concat(hidden).concat(last));
+  };
+
+  // Nodes are named with their alias and a short key
+  const named = (alias, key) => {
+    return [alias, shortKey(key)].filter(n => !!n).join(' ');
+  };
+
+  // Other nodes are named with their tag icons and no emojis of their own
+  const peer = (alias, key) => {
+    const regularAlias = (alias || String()).replace(isEmoji, String()).trim();
+    const tags = (tagged || []).find(n => n.public_key === key);
+
+    const icons = !tags ? [] : tags.icons;
+
+    return [].concat(icons).concat(named(regularAlias, key)).join(' ');
+  };
+
+  const sections = nodes.map(node => {
+    // Channels that are waiting for their funding transaction to confirm
+    const opening = node.opening.map(channel => {
+      const direction = !channel.is_partner_initiated ? 'outbound' : 'inbound';
+      const size = amount(channel.capacity);
+      const tx = channel.transaction_id;
+      const withPeer = peer(channel.peer_alias, channel.peer_public_key);
+
+      const action = `${direction} ${size} channel with ${withPeer}`;
+
+      return `Waiting for ${action} to confirm: ${tx}`;
+    });
+
+    // Channels that are closing, waiting on a timelock or on confirmation
+    const closing = node.closing.map(channel => {
+      const blocks = channel.blocks_until_recovery;
+      const funds = amount(channel.pending_balance);
+      const tx = channel.close_transaction_id;
+      const withPeer = peer(channel.peer_alias, channel.peer_public_key);
+
+      // Exit early when the funds are timelocked for some blocks
+      if (!!blocks && !!funds) {
+        const wait = formatDuration({ms: blocksAsMs(blocks)}).display;
+
+        const action = `recover ${funds} in ${wait} from closing channel`;
+
+        return `Waiting to ${action} with ${withPeer}`;
+      }
+
+      const confirm = !tx ? String() : `: ${tx}`;
+      const recover = `recover ${funds} from closing channel`;
+
+      const action = !funds ? 'close channel' : recover;
+
+      return `Waiting to ${action} with ${withPeer}${confirm}`;
+    });
+
+    // HTLCs that are being relayed from one peer to another
+    const forwarding = node.forwarding.map(forward => {
+      const fee = !forward.fee ? String() : ` for ${amount(forward.fee)} fee`;
+      const from = peer(forward.in_peer_alias, forward.in_peer_public_key);
+      const to = peer(forward.out_peer_alias, forward.out_peer_public_key);
+      const tokens = amount(forward.tokens);
+
+      return `Forwarding ${tokens}${fee} from ${from} to ${to}`;
+    });
+
+    // Payments or probes that are going out along a path of peers
+    const sending = node.sending.map(payment => {
+      const fee = !payment.fee ? String() : ` for ${amount(payment.fee)} fee`;
+      const hops = payment.hops.map(hop => peer(hop.alias, hop.public_key));
+      const tokens = amount(payment.tokens);
+
+      // Exit early when the payment is a rebalance that comes back to self
+      if (!!payment.is_rebalance) {
+        // The final hop of a rebalance is the node itself and not a peer
+        const [ownNode, ...route] = hops.slice().reverse();
+
+        return `Rebalancing ${tokens}${fee} out ${path(route.reverse())}`;
+      }
+
+      return `Probing ${tokens}${fee} out ${path(hops)}`;
+    });
+
+    // Sections go from the slowest to change to the fastest to change
+    return {
+      lines: flatten([closing, opening, forwarding, sending]),
+      title: named(node.alias, node.public_key),
+    };
+  });
+
+  const pending = sections.filter(n => !!n.lines.length);
+
+  // Exit early when there is nothing pending on any node
+  if (!pending.length) {
+    return {summary: nothingPending};
+  }
+
+  // Exit early when there is a single node, there is no need for a title
+  if (nodes.length === [nodes].length) {
+    const [node] = pending;
+
+    return {summary: joinLines(node.lines)};
+  }
+
+  const titled = pending.map(node => {
+    const title = !!is_monochrome ? node.title : bold(node.title);
+
+    return joinLines([title].concat(node.lines));
+  });
+
+  return {summary: joinSections(titled)};
+};

package/network/probe_destination.js

@@ -419,12 +419,17 @@ module.exports = (args, cbk) => {
           return cbk([404, 'NoActiveChannelWithOutgoingPeer']);
         }
 
-        const withBalance = withPeer.filter(n => {
-          const fees = n.commit_transaction_fee + (htlcOutputSize * rate(n));
-          const reserve = channelReserve(n);
+        // The balance that can be sent after the reserve and a buffer for fees
+        const spendable = channel => {
+          const htlcFee = htlcOutputSize * rate(channel);
+          const reserve = channelReserve(channel);
 
-          return n.local_balance - tokens > reserve + feeBuffer(fees);
-        });
+          const fees = channel.commit_transaction_fee + htlcFee;
+
+          return floor(channel.local_balance - reserve - feeBuffer(fees));
+        };
+
+        const withBalance = withPeer.filter(n => spendable(n) > tokens);
 
         if (!withBalance.length) {
           return cbk([404, 'NoOutboundPeerWithSufficientBalance']);
@@ -435,20 +440,20 @@ module.exports = (args, cbk) => {
           return cbk(null, {ids: withBalance.map(n => n.id)});
         }
 
-        // A single peer goes out through one channel with enough balance
         const attribute = 'local_balance';
+        const required = args.find_max || tokens;
 
-        const [channel] = sortBy({attribute, array: withBalance}).sorted;
+        const {sorted} = sortBy({attribute, array: withBalance});
 
-        const bufferFees = htlcOutputSize * rate(channel);
-        const reserve = channelReserve(channel);
+        const [largest] = sorted.slice().reverse();
 
-        const fees = channel.commit_transaction_fee + bufferFees;
-        const spendable = channel.local_balance - reserve;
+        // Use the smallest channel that can send the amount, or the largest
+        const channel = sorted.find(n => spendable(n) >= required) || largest;
 
-        const maxPayable = floor(spendable - feeBuffer(fees)) || args.find_max;
-
-        return cbk(null, {ids: [channel.id], max: maxPayable});
+        return cbk(null, {
+          ids: [channel.id],
+          max: spendable(channel) || args.find_max,
+        });
       }],
 
       // Log sending towards destination

package/package.json

@@ -25,7 +25,6 @@
     "asyncjs-util": "1.2.12",
     "bech32": "2.0.0",
     "bip66": "2.0.0",
-    "bitcoinjs-lib": "6.1.7",
     "bolt03": "2.0.0",
     "bolt04": "1.3.0",
     "bolt07": "2.0.0",
@@ -38,7 +37,7 @@
     "ini": "7.0.0",
     "inquirer": "14.2.3",
     "ln-accounting": "10.0.8",
-    "ln-service": "60.1.2",
+    "ln-service": "60.1.3",
     "ln-sync": "8.0.7",
     "ln-telegram": "8.0.7",
     "moment": "2.31.0",
@@ -53,7 +52,7 @@
   },
   "description": "Lightning balance CLI",
   "devDependencies": {
-    "invoices": "6.2.0",
+    "invoices": "6.3.0",
     "ln-docker-daemons": "8.1.0"
   },
   "engines": {
@@ -105,5 +104,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.2"
+  "version": "25.0.0"
 }

package/services/accept_balanced_channel.js

@@ -1,20 +1,21 @@
-const {address} = require('bitcoinjs-lib');
 const asyncAuto = require('async/auto');
+const {componentsOfTransaction} = require('@alexbosworth/blockchain');
 const {connectPeer} = require('ln-sync');
 const {formatTokens} = require('ln-sync');
 const {getPeers} = require('ln-service');
 const {getPublicKey} = require('ln-service');
+const {idForTransaction} = require('@alexbosworth/blockchain');
 const {maintainUtxoLocks} = require('ln-sync');
 const {makePeerRequest} = require('paid-services');
-const {networks} = require('bitcoinjs-lib');
+const {p2msScript} = require('@alexbosworth/blockchain');
+const {p2wshOutputScript} = require('@alexbosworth/blockchain');
 const {parsePaymentRequest} = require('ln-service');
 const {pay} = require('ln-service');
-const {payments} = require('bitcoinjs-lib');
 const {prepareForChannelProposal} = require('ln-service');
 const {reserveTransitFunds} = require('ln-sync');
 const {returnResult} = require('asyncjs-util');
 const {signTransaction} = require('ln-service');
-const {Transaction} = require('bitcoinjs-lib');
+const {transactionFromComponents} = require('@alexbosworth/blockchain');
 const {waitForPendingOpen} = require('ln-sync');
 
 const {balancedChannelKeyTypes} = require('./service_key_types');
@@ -22,29 +23,28 @@ const {balancedChannelKeyTypes} = require('./service_key_types');
 const acceptRequestIdType = '0';
 const bufferAsHex = buffer => buffer.toString('hex');
 const defaultMaxFeeMtokens = '9000';
-const {fromBech32} = address;
-const {fromHex} = Transaction;
 const fundingAmount = (capacity, rate) => (capacity + (190 * rate)) / 2;
 const fundingFee = rate => Math.ceil(190 / 2 * rate);
 const giveTokens = capacity => Math.ceil(capacity / 2);
 const hexAsBuffer = hex => Buffer.from(hex, 'hex');
 const idAsHash = id => Buffer.from(id, 'hex').reverse();
+const inputsOf = tx => componentsOfTransaction({transaction: tx}).inputs;
 const interval = 1000 * 15;
 const {isArray} = Array;
+const isSameId = (a, b) => a.toLowerCase() === b.toLowerCase();
 const multiSigKeyFamily = 0;
 const networkBitcoin = 'btc';
 const networkRegtest = 'btcregtest';
 const networkTestnet = 'btctestnet';
 const numAsHex = num => num.toString(16);
 const paddedHexNumber = n => n.length % 2 ? `0${n}` : n;
-const {p2ms} = payments;
-const {p2pkh} = payments;
 const p2pTimeoutMs = 1000 * 90;
-const {p2wsh} = payments;
 const relockIntervalMs = 1000 * 20;
+const sighashAll = 1;
 const times = 60 * 6;
-const {toOutputScript} = address;
 const transitKeyFamily = 805;
+const txLocktime = 0;
+const txVersion = 1;
 
 /** Accept a balanced channel
 
@@ -133,17 +133,13 @@ module.exports = (args, cbk) => {
         cbk);
       }],
 
-      // BitcoinJS Network
+      // Make sure the network is supported
       network: ['validate', ({}, cbk) => {
         switch (args.network) {
         case networkBitcoin:
-          return cbk(null, networks.bitcoin);
-
         case networkRegtest:
-          return cbk(null, networks.regtest);
-
         case networkTestnet:
-          return cbk(null, networks.testnet);
+          return cbk(null, args.network);
 
         default:
           return cbk([400, 'UnsupportedNetworkForAcceptingBalancedChannel']);
@@ -200,11 +196,10 @@ module.exports = (args, cbk) => {
         args.logger.info({refund_transaction: askForTransit.refund});
 
         const keys = [getMultiSigKey.public_key, args.remote_multisig_key];
-        const tx = new Transaction();
 
-        const redeem = p2ms({
-          m: keys.length,
-          pubkeys: keys.sort().map(hexAsBuffer),
+        const redeem = p2msScript({
+          keys: keys.sort().map(hexAsBuffer),
+          required: keys.length,
         });
 
         const remoteFunding = {
@@ -212,41 +207,48 @@ module.exports = (args, cbk) => {
           vout: args.remote_tx_vout,
         };
 
-        const multiSig = p2wsh({redeem});
-
-        const script = multiSig.output;
+        const {script} = p2wshOutputScript({hash: redeem.hash});
 
         // The inputs to the funding tx are the transit transactions
         const inputs = [askForTransit, remoteFunding].map(({id, vout}) => ({
-          hash: idAsHash(id),
-          index: vout,
+          id,
+          vout,
+          script: String(),
           sequence: Number(),
         }));
 
         // Sort the inputs for BIP 69 deterministic encoding
         inputs.sort((a, b) => {
-          const aHash = bufferAsHex(a.hash);
-          const bHash = bufferAsHex(b.hash);
+          const aHash = bufferAsHex(idAsHash(a.id));
+          const bHash = bufferAsHex(idAsHash(b.id));
 
-          return aHash.localeCompare(bHash) || a.index - b.index;
+          return aHash.localeCompare(bHash) || a.vout - b.vout;
         });
 
-        // Add the inputs to the channel funding transaction
-        inputs.forEach(n => tx.addInput(n.hash, n.index, n.sequence));
-
         // The output to the channel funding is capacity paid to the 2:2 addr
-        tx.addOutput(script, args.capacity);
+        const outputs = [{script: bufferAsHex(script), tokens: args.capacity}];
+
+        const {transaction} = transactionFromComponents({
+          inputs,
+          outputs,
+          locktime: txLocktime,
+          version: txVersion,
+        });
+
+        const {id} = idForTransaction({transaction});
 
         args.logger.info({
-          funding_tx_id: tx.getId(),
+          funding_tx_id: id,
           waiting_for_full_channel_proposal: true,
         });
 
         return cbk(null, {
-          pending_channel_id: bufferAsHex(multiSig.hash),
-          transaction: tx.toHex(),
-          transaction_id: tx.getId(),
-          transaction_vout: tx.outs.findIndex(n => n.script.equals(script)),
+          transaction,
+          pending_channel_id: bufferAsHex(redeem.hash),
+          transaction_id: id,
+          transaction_vout: outputs.findIndex(n => {
+            return n.script === bufferAsHex(script);
+          }),
         });
       }],
 
@@ -255,19 +257,18 @@ module.exports = (args, cbk) => {
         'askForTransit',
         'fundingTx',
         'network',
-        ({askForTransit, fundingTx, network}, cbk) =>
+        ({askForTransit, fundingTx}, cbk) =>
       {
-        const feeRate = args.fee_rate;
+        const inputs = inputsOf(fundingTx.transaction);
         const tokens = giveTokens(args.capacity) + fundingFee(args.fee_rate);
-        const tx = fromHex(fundingTx.transaction);
 
         // Find the input index where the funding outpoint is being spent
-        const fundingVin = tx.ins.findIndex(input => {
-          if (input.index !== askForTransit.vout) {
+        const fundingVin = inputs.findIndex(input => {
+          if (input.vout !== askForTransit.vout) {
             return false;
           }
 
-          return input.hash.equals(idAsHash(askForTransit.id));
+          return isSameId(input.id, askForTransit.id);
         });
 
         // Sign the channel funding transaction
@@ -278,7 +279,7 @@ module.exports = (args, cbk) => {
             key_index: askForTransit.index,
             output_script: askForTransit.output,
             output_tokens: tokens,
-            sighash: Transaction.SIGHASH_ALL,
+            sighash: sighashAll,
             vin: fundingVin,
             witness_script: askForTransit.script,
           }],