paid-services 10.3.1 → 10.3.3

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Versions
 
-## Version 10.3.1
+## Version 10.3.3
 
 - `getOfferInvoice`: Add support for offer paths that start at the payer
 - `serviceSupportOffer`: Add support for reply paths that start at the node

package/config/bech32_prefixes.json

@@ -0,0 +1,7 @@
+{
+  "btc": "bc",
+  "btcregtest": "bcrt",
+  "btcsignet": "tb",
+  "btctestnet": "tb",
+  "btctestnet4": "tb"
+}

package/config/index.js

@@ -1,3 +1,4 @@
+const bech32Prefixes = require('./bech32_prefixes');
 const invoiceNetwork = require('./invoice_network');
 const isActivityEnabled = require('./is_activity_enabled');
 const isConnectEnabled = require('./is_connect_enabled');
@@ -8,6 +9,7 @@ const isSmsConfigured = require('./is_sms_configured');
 const validateServerConfig = require('./validate_server_config');
 
 module.exports = {
+  bech32Prefixes,
   invoiceNetwork,
   isActivityEnabled,
   isConnectEnabled,

package/groups/assemble_channel_group.js

@@ -6,7 +6,7 @@ const {combinePsbts} = require('psbt');
 const {decodePsbt} = require('psbt');
 const {extractTransaction} = require('psbt');
 const {finalizePsbt} = require('psbt');
-const {Transaction} = require('bitcoinjs-lib');
+const {idForTransaction} = require('@alexbosworth/blockchain');
 
 const {confirmIncomingChannel} = require('./funding');
 const {coordinateGroup} = require('./assemble');
@@ -15,7 +15,6 @@ const {proposeGroupChannel} = require('./funding');
 const {signAndFundGroupChannel} = require('./funding');
 const transactionFeeRate = require('./transaction_fee_rate');
 
-const {fromHex} = Transaction;
 const interval = 500;
 const minGroupCount = 2;
 const times = 2 * 60 * 10;
@@ -176,7 +175,7 @@ module.exports = ({capacity, count, identity, lnd, members, rate}) => {
           capacity,
           lnd,
           from: coordinator.partners(identity).inbound,
-          id: fromHex(basePsbt.unsigned_transaction).getId(),
+          id: idForTransaction({transaction: basePsbt.unsigned_transaction}).id,
           to: coordinator.partners(identity).outbound || undefined,
         });
       });

package/groups/estimate_fee_rate.js

@@ -1,10 +1,12 @@
-const {Transaction} = require('bitcoinjs-lib');
+const {componentsOfTransaction} = require('@alexbosworth/blockchain');
+const {sizeOfTransaction} = require('@alexbosworth/blockchain');
+const {transactionFromComponents} = require('@alexbosworth/blockchain');
 
-const {fromHex} = Transaction;
+const bufferAsHex = buffer => buffer.toString('hex');
 const isUtxoP2wpkh = utxo => utxo.witness_utxo.script_pub.startsWith('0014');
 const sumTokens = arr => arr.reduce((sum, n) => sum + n.tokens, 0);
-const dummyP2wpkh = [Buffer.alloc(33), Buffer.alloc(72)];
-const dummyP2tr = [Buffer.alloc(64)];
+const dummyP2wpkh = [Buffer.alloc(33), Buffer.alloc(72)].map(bufferAsHex);
+const dummyP2tr = [Buffer.alloc(64)].map(bufferAsHex);
 
 /** Assuming large ECDSA signatures, determine a chain fee rate for a PSBT
 
@@ -28,11 +30,21 @@ const dummyP2tr = [Buffer.alloc(64)];
 */
 module.exports = ({inputs, outputs, unsigned}) => {
   const fee = sumTokens(inputs.map(n => n.witness_utxo)) - sumTokens(outputs);
-  const tx = fromHex(unsigned);
+  const tx = componentsOfTransaction({transaction: unsigned});
 
-  inputs.forEach((input, index) => {
-    return tx.setWitness(index, isUtxoP2wpkh(input) ? dummyP2wpkh : dummyP2tr);
+  // Add dummy witnesses to the inputs to estimate the final signed size
+  const {transaction} = transactionFromComponents({
+    inputs: tx.inputs.map((input, index) => ({
+      id: input.id,
+      script: input.script,
+      sequence: input.sequence,
+      vout: input.vout,
+      witness: isUtxoP2wpkh(inputs[index]) ? dummyP2wpkh : dummyP2tr,
+    })),
+    locktime: tx.locktime,
+    outputs: tx.outputs,
+    version: tx.version,
   });
 
-  return {rate: fee / tx.virtualSize()};
+  return {rate: fee / sizeOfTransaction({transaction}).vsize};
 };

package/groups/fanout/join_fanout.js

@@ -2,14 +2,13 @@ const EventEmitter = require('events');
 
 const asyncAuto = require('async/auto');
 const {decodePsbt} = require('psbt');
-const {Transaction} = require('bitcoinjs-lib');
+const {idForTransaction} = require('@alexbosworth/blockchain');
 
 const getFanoutFunding = require('./get_fanout_funding');
 const {registerGroupConnected} = require('./../p2p');
 const {registerFanoutProposal} = require('./../p2p');
 const {registerFanoutSigned} = require('./../p2p');
 
-const {fromHex} = Transaction;
 const {isArray} = Array;
 const isNumber = n => !isNaN(n);
 
@@ -128,9 +127,9 @@ module.exports = (args, cbk) => {
     transaction: ['register', ({register}, cbk) => {
       const psbt = decodePsbt({psbt: register.psbt});
 
-      const tx = fromHex(psbt.unsigned_transaction);
+      const {id} = idForTransaction({transaction: psbt.unsigned_transaction});
 
-      return cbk(null, {id: tx.getId(), raw: psbt.unsigned_transaction});
+      return cbk(null, {id, raw: psbt.unsigned_transaction});
     }],
 
     // Publish the partial funding signatures to coordinator

package/groups/funding/propose_group_channel.js

@@ -1,15 +1,17 @@
 const asyncAuto = require('async/auto');
 const asyncEach = require('async/each');
 const {connectPeer} = require('ln-sync');
+const {encodeBech32Address} = require('@alexbosworth/blockchain');
 const {fundPsbtDisallowingInputs} = require('ln-sync');
 const {getNetwork} = require('ln-sync');
 const {getUtxos} = require('ln-service');
 const {openChannels} = require('ln-service');
-const {networks} = require('bitcoinjs-lib');
-const {payments} = require('bitcoinjs-lib');
+const {p2msScript} = require('@alexbosworth/blockchain');
 const {returnResult} = require('asyncjs-util');
 const {unlockUtxo} = require('ln-service');
 
+const {bech32Prefixes} = require('./../../config');
+
 const dummyKeys = () => ([Buffer.alloc(33, 2), Buffer.alloc(33, 3)]);
 const fuzzSize = 1;
 const halfOf = n => n / 2;
@@ -17,6 +19,7 @@ const isEven = n => !(n % 2);
 const minGroupCount = 2;
 const nestedSegWitAddressFormat = 'np2wpkh';
 const nestedSegWitPath = "m/49'/";
+const witnessVersionSegWit = 0;
 
 /** Fund and propose a group channel to a peer
 
@@ -101,13 +104,15 @@ module.exports = ({capacity, count, lnd, rate, to}, cbk) => {
 
         // Exit early when there is a shared proposal due to a pair group
         if (!to) {
-          const {address} = payments.p2wsh({
-            network: networks[getNetwork.bitcoinjs],
-            redeem: payments.p2ms({
-              m: dummyKeys().length,
-              network: networks[getNetwork.bitcoinjs],
-              pubkeys: dummyKeys(),
-            }),
+          const {hash} = p2msScript({
+            keys: dummyKeys(),
+            required: dummyKeys().length,
+          });
+
+          const {address} = encodeBech32Address({
+            prefix: bech32Prefixes[getNetwork.network],
+            program: hash,
+            version: witnessVersionSegWit,
           });
 
           // Pretend we are opening a channel when there is no outbound target

package/groups/funding/sign_and_fund_group_channel.js

@@ -3,11 +3,10 @@ const asyncRetry = require('async/retry');
 const {decodePsbt} = require('psbt');
 const {fundPendingChannels} = require('ln-service');
 const {getPendingChannels} = require('ln-service');
+const {idForTransaction} = require('@alexbosworth/blockchain');
 const {returnResult} = require('asyncjs-util');
 const {signAndFundPsbt} = require('ln-sync');
-const {Transaction} = require('bitcoinjs-lib');
 
-const {fromHex} = Transaction;
 const interval = 10;
 const {isArray} = Array;
 const times = 500;
@@ -88,7 +87,9 @@ module.exports = ({id, lnd, psbt, utxos}, cbk) => {
           return cbk();
         }
 
-        const tx = fromHex(decodePsbt({psbt}).unsigned_transaction);
+        const unsigned = decodePsbt({psbt}).unsigned_transaction;
+
+        const txId = idForTransaction({transaction: unsigned}).id;
 
         // Wait for the outgoing pending channel to be present
         return asyncRetry({interval, times}, cbk => {
@@ -99,7 +100,7 @@ module.exports = ({id, lnd, psbt, utxos}, cbk) => {
 
             const ids = res.pending_channels.map(n => n.transaction_id);
 
-            if (!ids.includes(tx.getId())) {
+            if (!ids.includes(txId)) {
               return cbk([503, 'FailedToFindPendingChannelForGroupOpen']);
             }
 

package/groups/join_channel_group.js

@@ -3,9 +3,10 @@ const EventEmitter = require('events');
 const asyncAuto = require('async/auto');
 const asyncReflect = require('async/reflect');
 const asyncRetry = require('async/retry');
+const {componentsOfTransaction} = require('@alexbosworth/blockchain');
 const {decodePsbt} = require('psbt');
 const {deletePendingChannel} = require('ln-service');
-const {Transaction} = require('bitcoinjs-lib');
+const {idForTransaction} = require('@alexbosworth/blockchain');
 
 const {confirmIncomingChannel} = require('./funding');
 const {findGroupPartners} = require('./p2p');
@@ -15,8 +16,6 @@ const {registerGroupConnected} = require('./p2p');
 const {registerPendingOpen} = require('./p2p');
 const {registerSignedOpen} = require('./p2p');
 
-const {fromHex} = Transaction;
-const hexAsBuffer = hex => Buffer.from(hex, 'hex');
 const interval = 1000;
 const times = 60 * 10;
 
@@ -148,15 +147,16 @@ module.exports = ({capacity, coordinator, count, id, lnd, rate}, cbk) => {
       'register',
       ({propose, register}, cbk) =>
     {
-      const funding = hexAsBuffer(propose.funding);
       const psbt = decodePsbt({psbt: register.psbt});
 
-      const tx = fromHex(psbt.unsigned_transaction);
+      const transaction = psbt.unsigned_transaction;
+
+      const {outputs} = componentsOfTransaction({transaction});
 
       return cbk(null, {
-        id: tx.getId(),
-        raw: psbt.unsigned_transaction,
-        vout: tx.outs.findIndex(n => n.script.equals(funding)),
+        id: idForTransaction({transaction}).id,
+        raw: transaction,
+        vout: outputs.findIndex(n => n.script === propose.funding),
       });
     }],
 

package/groups/messages/decode_utxos_record.js

@@ -1,9 +1,8 @@
+const {componentsOfTransaction} = require('@alexbosworth/blockchain');
 const {decodeBigSize} = require('bolt01');
 const {decodeTlvStream} = require('bolt01');
-const {Transaction} = require('bitcoinjs-lib');
 
 const findRecord = (records, type) => records.find(n => n.type === type);
-const {fromHex} = Transaction;
 
 const expectedTxIdHexLength = 64;
 const isP2tr = n => n.startsWith('5120') && n.length === 68;
@@ -61,7 +60,7 @@ module.exports = ({encoded}) => {
 
     if (!!nonWitnessUtxo) {
       try {
-        fromHex(nonWitnessUtxo.value);
+        componentsOfTransaction({transaction: nonWitnessUtxo.value});
       } catch (err) {
         throw new Error('ExpectedValidTransactionInPendingWitnessUtxo');
       }

package/groups/p2p/register_fanout_proposal.js

@@ -1,11 +1,11 @@
 const asyncAuto = require('async/auto');
 const asyncReflect = require('async/reflect');
 const asyncRetry = require('async/retry');
+const {componentsOfTransaction} = require('@alexbosworth/blockchain');
 const {connectPeer} = require('ln-sync');
 const {decodePsbt} = require('psbt');
 const {returnResult} = require('asyncjs-util');
 const {signAndFundPsbt} = require('ln-sync');
-const {Transaction} = require('bitcoinjs-lib');
 
 const {decodeUnsignedFunding} = require('./../messages');
 const {encodeFanoutProposal} = require('./../messages');
@@ -13,12 +13,9 @@ const estimateFeeRate = require('./../estimate_fee_rate');
 const {makePeerRequest} = require('./../../p2p');
 const {serviceTypeRegisterPendingFanout} = require('./../../service_types')
 
-const bufferAsHex = buffer => buffer.toString('hex');
 const defaultIntervalMs = 500;
 const defaultPollTimes = 2 * 60 * 30;
 const defaultRequestTimeoutMs = 1000 * 60;
-const {fromHex} = Transaction;
-const hexAsBuffer = hex => Buffer.from(hex, 'hex');
 const {isArray} = Array;
 const missingGroupPartners = 'NoGroupPartnersFound';
 
@@ -159,11 +156,13 @@ module.exports = (args, cbk) => {
           return cbk([503, 'ExpectedAllFanoutInputsSpendingWitnessUtxos']);
         }
 
-        const tx = fromHex(psbt.unsigned_transaction);
+        const tx = componentsOfTransaction({
+          transaction: psbt.unsigned_transaction,
+        });
 
         const estimated = estimateFeeRate({
           inputs: psbt.inputs,
-          outputs: tx.outs.map(n => ({tokens: n.value})),
+          outputs: tx.outputs.map(n => ({tokens: n.tokens})),
           unsigned: psbt.unsigned_transaction,
         });
 
@@ -173,20 +172,17 @@ module.exports = (args, cbk) => {
 
         // All the specified utxos should be represented in the PSBT
         const missingInput = args.utxos.find(utxo => {
-          const hash = hexAsBuffer(utxo.transaction_id).reverse();
+          const id = utxo.transaction_id;
           const vout = utxo.transaction_vout;
 
-          return !tx.ins.find(n => n.hash.equals(hash) && n.index === vout);
+          return !tx.inputs.find(n => n.id === id && n.vout === vout);
         });
 
         if (!!missingInput) {
           return cbk([503, 'ExpectedAllInputsRepresentedInFanoutGroupPsbt']);
         }
 
-        const outputs = tx.outs.map(({script, value}) => ({
-          script: bufferAsHex(script),
-          tokens: value,
-        }));
+        const {outputs} = tx;
 
         const change = outputs.find(n => n.script === args.change);
         const funding = outputs.filter(n => args.funding.includes(n.script));

package/groups/p2p/register_pending_open.js

@@ -2,10 +2,10 @@ const asyncAuto = require('async/auto');
 const asyncReflect = require('async/reflect');
 const asyncRetry = require('async/retry');
 const {cancelPendingChannel} = require('ln-service');
+const {componentsOfTransaction} = require('@alexbosworth/blockchain');
 const {connectPeer} = require('ln-sync');
 const {decodePsbt} = require('psbt');
 const {returnResult} = require('asyncjs-util');
-const {Transaction} = require('bitcoinjs-lib');
 
 const {decodeUnsignedFunding} = require('./../messages');
 const {encodePendingProposal} = require('./../messages');
@@ -14,12 +14,9 @@ const {makePeerRequest} = require('./../../p2p');
 const {serviceTypeRegisterPendingOpen} = require('./../../service_types');
 const {signAndFundGroupChannel} = require('./../funding');
 
-const bufferAsHex = buffer => buffer.toString('hex');
 const defaultIntervalMs = 500;
 const defaultPollTimes = 2 * 60 * 30;
 const defaultRequestTimeoutMs = 1000 * 60;
-const {fromHex} = Transaction;
-const hexAsBuffer = hex => Buffer.from(hex, 'hex');
 const {isArray} = Array;
 const missingGroupPartners = 'NoGroupPartnersFound';
 
@@ -183,30 +180,29 @@ module.exports = (args, cbk) => {
           return cbk([503, 'ExpectedAllGroupInputsSpendingWitnessUtxos']);
         }
 
-        const tx = fromHex(psbt.unsigned_transaction);
+        const tx = componentsOfTransaction({
+          transaction: psbt.unsigned_transaction,
+        });
 
         const estimated = estimateFeeRate({
           inputs: psbt.inputs,
-          outputs: tx.outs.map(n => ({tokens: n.value})),
+          outputs: tx.outputs.map(n => ({tokens: n.tokens})),
           unsigned: psbt.unsigned_transaction,
         });
 
         // The utxos should be represented in the PSBT
         const missing = args.utxos.find(utxo => {
-          const hash = hexAsBuffer(utxo.transaction_id).reverse();
+          const id = utxo.transaction_id;
           const vout = utxo.transaction_vout;
 
-          return !tx.ins.find(n => n.hash.equals(hash) && n.index === vout);
+          return !tx.inputs.find(n => n.id === id && n.vout === vout);
         });
 
         if (!!missing) {
           return cbk([503, 'ExpectedAllInputsRepresentedInGroupChannelPsbt']);
         }
 
-        const outputs = tx.outs.map(({script, value}) => ({
-          script: bufferAsHex(script),
-          tokens: value,
-        }));
+        const {outputs} = tx;
 
         const change = outputs.find(n => n.script === args.change);
         const funding = outputs.find(n => n.script === args.funding);

package/groups/transaction_fee_rate.js

@@ -1,6 +1,6 @@
-const {Transaction} = require('bitcoinjs-lib');
+const {componentsOfTransaction} = require('@alexbosworth/blockchain');
+const {sizeOfTransaction} = require('@alexbosworth/blockchain');
 
-const {fromHex} = Transaction;
 const sumOf = arr => arr.reduce((sum, n) => sum + n, 0);
 
 /** Given a transaction and inputs metadata, derive transaction chain fee rate
@@ -21,9 +21,9 @@ const sumOf = arr => arr.reduce((sum, n) => sum + n, 0);
 */
 module.exports = ({inputs, transaction}) => {
   const inputsValue = sumOf(inputs.map(n => n.witness_utxo.tokens));
-  const tx = fromHex(transaction);
+  const {outputs} = componentsOfTransaction({transaction});
 
-  const fee = inputsValue - sumOf(tx.outs.map(n => n.value));
+  const fee = inputsValue - sumOf(outputs.map(n => n.tokens));
 
-  return {rate: fee / tx.virtualSize()};
+  return {rate: fee / sizeOfTransaction({transaction}).vsize};
 };

package/package.json

@@ -22,15 +22,15 @@
     "goldengate": "16.0.9",
     "invoices": "6.3.0",
     "ln-service": "60.1.6",
-    "ln-sync": "8.0.8",
+    "ln-sync": "8.0.9",
     "psbt": "7.0.0",
     "p2tr": "3.0.0",
     "tiny-secp256k1": "2.2.4"
   },
   "description": "Lightning Paid Services library",
   "devDependencies": {
-    "ln-docker-daemons": "8.1.2",
-    "mock-lnd": "4.0.0"
+    "ln-docker-daemons": "8.1.3",
+    "mock-lnd": "4.0.1"
   },
   "engines": {
     "node": ">=22"
@@ -72,5 +72,5 @@
     "integration-tests": "node test/integration",
     "test": "node --experimental-test-coverage --test test/actions/*.js test/balanced/*.js test/client/*.js test/config/*.js test/network/*.js test/offers/*.js test/p2p/*.js test/records/*.js test/respond/*.js test/server/*.js test/service_records/*.js test/swaps/*.js test/services/*.js test/support/*.js test/trades/*.js"
   },
-  "version": "10.3.1"
+  "version": "10.3.3"
 }

package/swaps/complete_off_to_on_swap.js

@@ -10,6 +10,7 @@ const asyncTimeout = require('async/timeout');
 const {beginGroupSigningSession} = require('ln-service');
 const {broadcastChainTransaction} = require('ln-service');
 const {cancelSwapOut} = require('goldengate');
+const {componentsOfTransaction} = require('@alexbosworth/blockchain');
 const {confirmationFee} = require('goldengate');
 const {controlBlock} = require('p2tr');
 const {createChainAddress} = require('ln-service');
@@ -25,9 +26,9 @@ const {getNetwork} = require('ln-sync');
 const {getPayment} = require('ln-service');
 const {getPublicKey} = require('ln-service');
 const {hashForTree} = require('p2tr');
+const {idForTransaction} = require('@alexbosworth/blockchain');
 const {lightningLabsSwapAuth} = require('goldengate');
 const {lightningLabsSwapService} = require('goldengate');
-const {networks} = require('bitcoinjs-lib');
 const {parsePaymentRequest} = require('ln-service');
 const {pay} = require('ln-service');
 const {payViaPaymentDetails} = require('ln-service');
@@ -36,25 +37,28 @@ const {pointFromScalar} = require('tiny-secp256k1');
 const {privateAdd} = require('tiny-secp256k1');
 const {releaseSwapOutSecret} = require('goldengate');
 const {returnResult} = require('asyncjs-util');
-const {script} = require('bitcoinjs-lib');
+const {scriptAsScriptElements} = require('@alexbosworth/blockchain');
 const {signTransaction} = require('ln-service');
+const {sizeOfTransaction} = require('@alexbosworth/blockchain');
 const {subscribeToBlocks} = require('ln-service');
 const {subscribeToPastPayment} = require('ln-service');
 const {subscribeToSpend} = require('goldengate');
 const {swapScriptBranches} = require('goldengate');
 const {taprootClaimTransaction} = require('goldengate');
 const {taprootCoopTransaction} = require('goldengate');
-const {Transaction} = require('bitcoinjs-lib');
+const {transactionFromComponents} = require('@alexbosworth/blockchain');
 const {v1OutputScript} = require('p2tr');
 
+const {bech32Prefixes} = require('./../config');
 const decodeLoopResponse = require('./decode_loop_response');
 const decodeOffToOnRecovery = require('./decode_off_to_on_recovery');
 const decodeOffToOnResponse = require('./decode_off_to_on_response');
+const {invoiceNetworks} = require('./constants');
 const {typePayMetadata} = require('./swap_field_types');
 
 const bufferAsHex = buffer => buffer.toString('hex');
 const {ceil} = Math;
-const decompileOutputScript = hex => script.decompile(Buffer.from(hex, 'hex'));
+const decompileScript = script => scriptAsScriptElements({script}).elements;
 const defaultConfsCount = 1;
 const defaultDepositSettleTimeoutMs = 1000 * 60 * 10;
 const defaultMaxFeeMultiplier = 1000;
@@ -66,7 +70,6 @@ const family = 805;
 const {floor} = Math;
 const format = 'p2tr';
 const {from} = Buffer;
-const {fromHex} = Transaction;
 const fuzzBlocks = 100;
 const fuzzTimelock = 1;
 const getLoopCoopSignedTransaction = asyncTimeout(getCoopSignedTx, 1000 * 30);
@@ -86,7 +89,7 @@ const pubKeyAsInternalKey = key => Buffer.from(key).slice(1).toString('hex');
 const publicKeyFor = key => Buffer.from(pointFromScalar(key, isCompressed));
 const pushSecret = asyncTimeout(releaseSwapOutSecret, 1000 * 30);
 const sha256 = preimage => createHash('sha256').update(preimage).digest('hex');
-const sighash = Transaction.SIGHASH_DEFAULT;
+const sighashDefault = 0;
 const slowConfs = 144 * 7;
 const sumOf = arr => arr.reduce((sum, n) => sum + n, 0);
 const sweepInputIndex = 0;
@@ -220,7 +223,7 @@ module.exports = (args, cbk) => {
         if (!!args.is_loop_service) {
           try {
             const details = decodeLoopResponse({
-              network: getNetwork.bitcoinjs,
+              network: invoiceNetworks[getNetwork.network],
               response: args.response,
             });
 
@@ -243,7 +246,7 @@ module.exports = (args, cbk) => {
         try {
           // Decode the response
           const decoded = decodeOffToOnResponse({
-            network: getNetwork.bitcoinjs,
+            network: invoiceNetworks[getNetwork.network],
             response: args.response,
           });
 
@@ -680,9 +683,9 @@ module.exports = (args, cbk) => {
         'swap',
         ({deadline, getNetwork, requestDetails, startHeight, swap}, cbk) =>
       {
-        const [, key] = decompileOutputScript(swap.output_script);
+        const [, key] = decompileScript(swap.output_script);
         const outputScript = swap.output_script;
-        const prefix = networks[getNetwork.bitcoinjs].bech32;
+        const prefix = bech32Prefixes[getNetwork.network];
 
         const {address} = encodeBech32Address({
           prefix,
@@ -840,11 +843,11 @@ module.exports = (args, cbk) => {
           return signTransaction({
             transaction,
             inputs: [{
-              sighash,
               key_family: family,
               key_index: requestDetails.key_index,
               output_script: swap.output_script,
               output_tokens: requestDetails.tokens,
+              sighash: sighashDefault,
               vin: sweepInputIndex,
               witness_script: swap.claim_script,
             }],
@@ -871,14 +874,23 @@ module.exports = (args, cbk) => {
               block,
             ];
 
-            const tx = fromHex(transaction);
+            const tx = componentsOfTransaction({transaction});
 
             // Add the signature to the sweep
-            tx.ins.forEach((input, vin) => {
-              return tx.setWitness(vin, witness.map(hexAsBuffer));
+            const signed = transactionFromComponents({
+              inputs: tx.inputs.map(input => ({
+                witness,
+                id: input.id,
+                script: input.script,
+                sequence: input.sequence,
+                vout: input.vout,
+              })),
+              locktime: tx.locktime,
+              outputs: tx.outputs,
+              version: tx.version,
             });
 
-            return cbk(null, {height, transaction: tx.toHex()});
+            return cbk(null, {height, transaction: signed.transaction});
           });
         },
         cbk);
@@ -1229,15 +1241,15 @@ module.exports = (args, cbk) => {
 
           const [{transaction}] = broadcast.reverse();
 
-          const tx = fromHex(transaction);
+          const {outputs} = componentsOfTransaction({transaction});
 
-          const fee = requestDetails.tokens - sumOf(tx.outs.map(n => n.value));
+          const fee = requestDetails.tokens - sumOf(outputs.map(n => n.tokens));
 
           args.emitter.emit('update', {
             blocks_until_potential_funds_forfeit: swap.timeout - block.height,
-            broadcasting_fee_rate: fee / tx.virtualSize(),
+            broadcasting_fee_rate: fee / sizeOfTransaction({transaction}).vsize,
             broadcasting_tx_to_resolve_swap: transaction,
-            broadcasting_tx_id: tx.getId(),
+            broadcasting_tx_id: idForTransaction({transaction}).id,
           });
 
           return broadcastChainTransaction({
@@ -1251,11 +1263,13 @@ module.exports = (args, cbk) => {
 
         // Look for the sweep to confirm
         subSpend.on('confirmation', ({transaction}) => {
-          const tx = fromHex(transaction);
+          const {outputs} = componentsOfTransaction({transaction});
 
-          const fee = requestDetails.tokens - sumOf(tx.outs.map(n => n.value));
+          const fee = requestDetails.tokens - sumOf(outputs.map(n => n.tokens));
 
-          return done(null, {fee: fee, rate: fee / tx.virtualSize()});
+          const {vsize} = sizeOfTransaction({transaction});
+
+          return done(null, {fee: fee, rate: fee / vsize});
         });
 
         subSpend.on('error', err => done(err));

package/swaps/complete_on_to_off_swap.js

@@ -5,6 +5,7 @@ const asyncMap = require('async/map');
 const asyncReflect = require('async/reflect');
 const {broadcastChainTransaction} = require('ln-service');
 const {cancelHodlInvoice} = require('ln-service');
+const {componentsOfTransaction} = require('@alexbosworth/blockchain');
 const {confirmationFee} = require('goldengate');
 const {controlBlock} = require('p2tr');
 const {createChainAddress} = require('ln-service');
@@ -21,6 +22,7 @@ const {getInvoice} = require('ln-service');
 const {getNetwork} = require('ln-sync');
 const {getPublicKey} = require('ln-service');
 const {hashForTree} = require('p2tr');
+const {idForTransaction} = require('@alexbosworth/blockchain');
 const {pointAdd} = require('tiny-secp256k1');
 const {pointFromScalar} = require('tiny-secp256k1');
 const {returnResult} = require('asyncjs-util');
@@ -33,7 +35,7 @@ const {subscribeToInvoice} = require('ln-service');
 const {subscribeToSpend} = require('goldengate');
 const {swapScriptBranches} = require('goldengate');
 const {taprootRefundTransaction} = require('goldengate');
-const {Transaction} = require('bitcoinjs-lib');
+const {transactionFromComponents} = require('@alexbosworth/blockchain');
 const {v1OutputScript} = require('p2tr');
 
 const decodeOnToOffRecovery = require('./decode_on_to_off_recovery');
@@ -48,13 +50,13 @@ const flatten = arr => [].concat(...arr);
 const {floor} = Math;
 const format = 'p2tr';
 const {from} = Buffer;
-const {fromHex} = Transaction;
 const fuzzBlocks = 100;
 const hexAsBase64 = hex => Buffer.from(hex, 'hex').toString('base64');
 const hexAsBuffer = hex => Buffer.from(hex, 'hex');
 const historicBlocksRange = 144 * 30;
-const isAnnex = element => element[0] === 0x50;
+const isAnnex = element => element.startsWith('50');
 const isCompressed = true;
+const locktimeOf = tx => componentsOfTransaction({transaction: tx}).locktime;
 const maxRefundMultiple = (r, t) => Math.min(100, ((1000 + t) / 150) / r);
 const {min} = Math;
 const minBlocks = 50;
@@ -64,7 +66,7 @@ const pubKeyAsSecret = hexPublicKey => hexPublicKey.slice(2);
 const publicKeyFor = key => Buffer.from(pointFromScalar(key, isCompressed));
 const removeAnnex = stack => stack.slice(0, -1);
 const sha256 = preimage => createHash('sha256').update(preimage).digest('hex');
-const sighash = Transaction.SIGHASH_DEFAULT;
+const sighashDefault = 0;
 const slowTarget = 144 * 7;
 const sweepInputIndex = 0;
 const times = n => Array(n).fill(null).map((_, i) => i);
@@ -404,11 +406,11 @@ module.exports = (args, cbk) => {
           return signTransaction({
             transaction,
             inputs: [{
-              sighash,
               key_family: family,
               key_index: recoveryDetails.key_index,
               output_script: swap.output_script,
               output_tokens: recoveryDetails.tokens,
+              sighash: sighashDefault,
               vin: sweepInputIndex,
               witness_script: swap.refund_script,
             }],
@@ -430,14 +432,23 @@ module.exports = (args, cbk) => {
 
             const witness = [signature, swap.refund_script, block];
 
-            const tx = fromHex(transaction);
+            const tx = componentsOfTransaction({transaction});
 
             // Add the signature to the sweep
-            tx.ins.forEach((input, vin) => {
-              return tx.setWitness(vin, witness.map(hexAsBuffer));
+            const signed = transactionFromComponents({
+              inputs: tx.inputs.map(input => ({
+                witness,
+                id: input.id,
+                script: input.script,
+                sequence: input.sequence,
+                vout: input.vout,
+              })),
+              locktime: tx.locktime,
+              outputs: tx.outputs,
+              version: tx.version,
             });
 
-            return cbk(null, tx.toHex());
+            return cbk(null, signed.transaction);
           });
         },
         cbk);
@@ -525,12 +536,18 @@ module.exports = (args, cbk) => {
         ({getTransactions, swap}, cbk) =>
       {
         const tx = getTransactions.transactions.find(({transaction}) => {
-          return !!transaction && !!fromHex(transaction).outs.find(output => {
-            if (output.value !== swap.tokens) {
+          if (!transaction) {
+            return false;
+          }
+
+          const {outputs} = componentsOfTransaction({transaction});
+
+          return !!outputs.find(output => {
+            if (output.tokens !== swap.tokens) {
               return false;
             }
 
-            return bufferAsHex(output.script) === swap.output_script;
+            return output.script === swap.output_script;
           });
         });
 
@@ -567,11 +584,12 @@ module.exports = (args, cbk) => {
 
       // Output funding the swap on chain
       outpoint: ['signFunding', 'swap', ({signFunding, swap}, cbk) => {
-        const tx = fromHex(signFunding.transaction);
-        const script = hexAsBuffer(swap.output_script);
+        const {transaction} = signFunding;
+
+        const {outputs} = componentsOfTransaction({transaction});
 
-        const id = tx.getId();
-        const vout = tx.outs.findIndex(n => n.script.equals(script));
+        const {id} = idForTransaction({transaction});
+        const vout = outputs.findIndex(n => n.script === swap.output_script);
 
         args.emitter.emit('update', {
           funding_transaction: signFunding.transaction,
@@ -592,7 +610,7 @@ module.exports = (args, cbk) => {
 
         args.emitter.emit('update', {
           refund_transaction: refund,
-          refund_valid_at: fromHex(refund).locktime,
+          refund_valid_at: locktimeOf(refund),
         });
 
         // Exit early when the transaction was already published
@@ -682,12 +700,10 @@ module.exports = (args, cbk) => {
 
         // Look for the preimage to be used on-chain in a sweep
         subSpend.on('confirmation', ({transaction}) => {
-          const spend = fromHex(transaction).ins.find(input => {
-            if (!input.hash.equals(hexAsBuffer(outpoint.id).reverse())) {
-              return false;
-            }
+          const {inputs} = componentsOfTransaction({transaction});
 
-            return input.index === outpoint.vout;
+          const spend = inputs.find(input => {
+            return input.id === outpoint.id && input.vout === outpoint.vout;
           });
 
           const [lastElement, nextToLast] = spend.witness.slice().reverse();
@@ -722,7 +738,7 @@ module.exports = (args, cbk) => {
 
           const [secret] = stack;
 
-          return done(null, {secret: bufferAsHex(secret)});
+          return done(null, {secret});
         });
 
         subSpend.on('error', err => done(err));
@@ -739,7 +755,7 @@ module.exports = (args, cbk) => {
           // Find the latest valid refund transaction
           const [transaction] = signRefunds
             .filter(transaction => {
-              return fromHex(transaction).locktime <= block.height;
+              return locktimeOf(transaction) <= block.height;
             })
             .reverse();
 

package/swaps/constants.json

@@ -0,0 +1,16 @@
+{
+  "invoiceNetworks": {
+    "btc": "bitcoin",
+    "btcregtest": "regtest",
+    "btcsignet": "signet",
+    "btctestnet": "testnet",
+    "btctestnet4": "testnet"
+  },
+  "minConfirmations": {
+    "btc": 2,
+    "btcregtest": 3,
+    "btcsignet": 1,
+    "btctestnet": 1,
+    "btctestnet4": 1
+  }
+}

package/swaps/manage_swap.js

@@ -1,4 +1,3 @@
-const {address} = require('bitcoinjs-lib');
 const asyncAuto = require('async/auto');
 const asyncMap = require('async/map');
 const {findKey} = require('ln-sync');
@@ -7,13 +6,13 @@ const {getAllInvoices} = require('ln-sync');
 const {getInvoice} = require('ln-service');
 const {getNetwork} = require('ln-sync');
 const {getNodeAlias} = require('ln-sync');
-const {networks} = require('bitcoinjs-lib');
+const {outputScriptForAddress} = require('@alexbosworth/blockchain');
 const {returnResult} = require('asyncjs-util');
 
 const decodeOffToOnRequest = require('./decode_off_to_on_request');
 const decodeOffToOnRestart = require('./decode_off_to_on_restart');
 const {decodeTrade} = require('./../trades');
-const outputScriptForAddress = require('./output_script_for_address');
+const {minConfirmations} = require('./constants');
 const recoverResponseToSwapOut = require('./recover_response_to_swap_out');
 const requestSwapOut = require('./request_swap_out');
 const respondToSwapOutRequest = require('./respond_to_swap_out_request');
@@ -24,14 +23,12 @@ const actionRestartRequest = 'restart-request';
 const allowedNetwork = 'btctestnet';
 const bip86Path = `m/86'/0'/0'`;
 const flatten = arr => [].concat(...arr);
-const minConfirmations = {btc: 2, btcregtest: 3, btctestnet: 1};
 const niceId = id => id.substring(0, 8);
 const niceName = node => `${node.alias} ${node.id.substring(0, 8)}`.trim();
 const pushesReceivedAfter = () => new Date(Date.now() - 1000 * 60 * 60 * 24);
 const recoverRespondAction = 'recover-response';
 const requestAction = 'request';
 const respondAction = 'respond';
-const {toOutputScript} = address;
 const tokensAsBigUnit = tokens => (tokens / 1e8).toFixed(8);
 const typeKeySendTrade = '805805';
 
@@ -314,7 +311,7 @@ module.exports = (args, cbk) => {
               try {
                 return !!outputScriptForAddress({
                   address: input,
-                  network: getNetwork.bitcoinjs,
+                  network: getNetwork.network,
                 });
               } catch (err) {
                 return 'Unsupported on-chain address format';

package/swaps/request_swap_out.js

@@ -20,6 +20,7 @@ const decodeOffToOnRequest = require('./decode_off_to_on_request');
 const decodeOffToOnResponse = require('./decode_off_to_on_response');
 const encodeOffToOnRestart = require('./encode_off_to_on_restart');
 const {encodeTrade} = require('./../trades');
+const {invoiceNetworks} = require('./constants');
 const makeRequest = require('./start_off_to_on_swap');
 const {pushTypes} = require('./swap_field_types');
 const requestLoopOut = require('./request_loop_out');
@@ -251,7 +252,10 @@ module.exports = (args, cbk) => {
 
           // Check the swap response is valid
           try {
-            decodeOffToOnResponse({response, network: getNetwork.bitcoinjs});
+            decodeOffToOnResponse({
+              response,
+              network: invoiceNetworks[getNetwork.network],
+            });
           } catch (err) {
             return res.failure([400, err.message]);
           }
@@ -373,7 +377,10 @@ module.exports = (args, cbk) => {
             }
 
             try {
-              decodeOffToOnResponse({response, network: getNetwork.bitcoinjs});
+              decodeOffToOnResponse({
+                response,
+                network: invoiceNetworks[getNetwork.network],
+              });
             } catch (err) {
               return 'Failed parse this response, check input?';
             }
@@ -395,7 +402,7 @@ module.exports = (args, cbk) => {
         // Exit early when the request is to Lightning Loop
         if (!!args.is_loop_service) {
           const details = decodeLoopResponse({
-            network: getNetwork.bitcoinjs,
+            network: invoiceNetworks[getNetwork.network],
             response: getResponse,
           });
 
@@ -414,7 +421,7 @@ module.exports = (args, cbk) => {
         }
 
         const response = decodeOffToOnResponse({
-          network: getNetwork.bitcoinjs,
+          network: invoiceNetworks[getNetwork.network],
           response: getResponse,
         });
 

package/swaps/start_off_to_on_swap.js

@@ -6,11 +6,11 @@ const {diffieHellmanComputeSecret} = require('ln-service');
 const {getIdentity} = require('ln-service');
 const {getNetwork} = require('ln-sync');
 const {getPublicKey} = require('ln-service');
-const {networks} = require('bitcoinjs-lib');
 const {pointFromScalar} = require('tiny-secp256k1');
 const {returnResult} = require('asyncjs-util');
 
 const encodeOffToOnRequest = require('./encode_off_to_on_request');
+const {invoiceNetworks} = require('./constants');
 const makePrivateKey = require('./make_private_key');
 
 const bufferAsHex = buffer => buffer.toString('hex');
@@ -77,15 +77,13 @@ module.exports = (args, cbk) => {
       // Get the network name for creating the private key
       getNetwork: ['validate', ({}, cbk) => getNetwork({lnd: args.lnd}, cbk)],
 
-      // Bitcoinjs network details
+      // Check that the network is supported
       network: ['getNetwork', ({getNetwork}, cbk) => {
-        const network = networks[getNetwork.bitcoinjs];
-
-        if (!network) {
+        if (!invoiceNetworks[getNetwork.network]) {
           return cbk([400, 'UnsupportedNetworkToStartOffToOnSwapOn']);
         }
 
-        return cbk(null, network);
+        return cbk(null, getNetwork.network);
       }],
 
       // Generate the claim coop key

package/swaps/start_on_to_off_swap.js

@@ -7,13 +7,13 @@ const {getHeight} = require('ln-service');
 const {getIdentity} = require('ln-service');
 const {getNetwork} = require('ln-sync');
 const {getPublicKey} = require('ln-service');
-const {networks} = require('bitcoinjs-lib');
 const {parsePaymentRequest} = require('ln-service');
 const {pointFromScalar} = require('tiny-secp256k1');
 const {returnResult} = require('asyncjs-util');
 
 const decodeOffToOnRequest = require('./decode_off_to_on_request');
 const encodeOffToOnResponse = require('./encode_off_to_on_response');
+const {invoiceNetworks} = require('./constants');
 const makePrivateKey = require('./make_private_key');
 
 const bufferAsHex = buffer => buffer.toString('hex');
@@ -107,15 +107,13 @@ module.exports = (args, cbk) => {
         });
       }],
 
-      // Bitcoinjs network name
+      // Check that the network is supported
       network: ['getNetwork', ({getNetwork}, cbk) => {
-        const network = networks[getNetwork.bitcoinjs];
-
-        if (!network) {
+        if (!invoiceNetworks[getNetwork.network]) {
           return cbk([400, 'UnsupportedNetworkForOnToOffSwap']);
         }
 
-        return cbk(null, network);
+        return cbk(null, getNetwork.network);
       }],
 
       // Generate the refund coop key

package/swaps/output_script_for_address.js

@@ -1,55 +0,0 @@
-const {address} = require('bitcoinjs-lib');
-const {networks} = require('bitcoinjs-lib');
-
-const bufferAsHex = buffer => buffer.toString('hex');
-const byteLengthForP2tr = 32;
-const {fromBech32} = address;
-const prefixForP2tr = '5120';
-const toOutputScript = (a, n) => address.toOutputScript(a, n).toString('hex');
-const versionTaproot = 1;
-
-/** Get the output script for an address
-
-  {
-    address: <Address String>
-    network: <BitcoinJs Network Name String>
-  }
-
-  @throws
-  <Error>
-
-  @returns
-  {
-    script: <Output Script Hex String>
-  }
-*/
-module.exports = ({address, network}) => {
-  try {
-    return {
-      script: bufferAsHex(toOutputScript(address, networks[network])),
-    };
-  } catch (err) {
-    // Exit early when this is not a bech32 address
-    try {
-      fromBech32(address);
-    } catch (_) {
-      throw err;
-    }
-
-    const {data, prefix, version} = fromBech32(address);
-
-    if (prefix !== networks[network].bech32) {
-      throw new Error('InvalidNetworkToConvertAddressToOutputScript');
-    }
-
-    if (version !== versionTaproot) {
-      throw new Error('UnexpectedVersionOfAddressToConverToOutputScript');
-    }
-
-    if (data.length !== byteLengthForP2tr) {
-      throw new Error('UnexpectedByteLengthForPayToTaprootAddress');
-    }
-
-    return {script: `${prefixForP2tr}${bufferAsHex(data)}`};
-  }
-};