lightning 10.27.5 → 11.0.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Versions
 
+## 11.0.0
+
+### Breaking Changes
+
+- End support for node.js 18, require 20 or higher
+
 ## 10.26.5
 
 - `pay`, `payViaPaymentRequest`, `subscribeToPayViaRequest`: Allow short CLTV

package/lnd_methods/offchain/delete_pending_channel.js

@@ -1,11 +1,12 @@
 const asyncAuto = require('async/auto');
+const {componentsOfTransaction} = require('@alexbosworth/blockchain');
+const {idForTransaction} = require('@alexbosworth/blockchain');
 const {returnResult} = require('asyncjs-util');
-const {Transaction} = require('bitcoinjs-lib');
 
-const {fromHex} = Transaction;
 const method = 'abandonChannel';
 const methodUnsupported = 'AbandonChannel RPC call only available in dev builds';
 const txIdAsHash = id => Buffer.from(id, 'hex').reverse();
+const txComponents = transaction => componentsOfTransaction({transaction});
 const type = 'default';
 
 /** Delete a pending channel
@@ -34,7 +35,7 @@ module.exports = (args, cbk) => {
         }
 
         try {
-          fromHex(args.confirmed_transaction);
+          txComponents(args.confirmed_transaction);
         } catch (err) {
           return cbk([400, 'ExpectedValidConfirmedTxToDeleteChannel']);
         }
@@ -52,7 +53,7 @@ module.exports = (args, cbk) => {
         }
 
         try {
-          fromHex(args.pending_transaction);
+          txComponents(args.pending_transaction);
         } catch (err) {
           return cbk([400, 'ExpectedValidPendingTxToDeleteChannel']);
         }
@@ -66,16 +67,16 @@ module.exports = (args, cbk) => {
 
       // Check for a conflicting input between the confirmed and pending txs
       transactionId: ['validate', ({}, cbk) => {
-        const confirmedInputs = fromHex(args.confirmed_transaction).ins;
-        const pending = fromHex(args.pending_transaction);
+        const confirmed = txComponents(args.confirmed_transaction);
+        const pending = txComponents(args.pending_transaction);
 
-        const conflictingInput = pending.ins.find(pendingInput => {
-          return confirmedInputs.find(confirmedInput => {
-            if (!confirmedInput.hash.equals(pendingInput.hash)) {
+        const conflictingInput = pending.inputs.find(pendingInput => {
+          return confirmed.inputs.find(confirmedInput => {
+            if (confirmedInput.id !== pendingInput.id) {
               return false;
             }
 
-            return confirmedInput.index === pendingInput.index;
+            return confirmedInput.vout === pendingInput.vout;
           });
         });
 
@@ -83,8 +84,11 @@ module.exports = (args, cbk) => {
           return cbk([400, 'FailedToFindConflictingInputInConfirmedTx']);
         }
 
+        // Calculate the transaction ID to be sure we are deleting the conflict
+        const {id} = idForTransaction({transaction: args.pending_transaction});
+
         // The pending transaction conflicts with the confirmed transaction
-        return cbk(null, pending.getId());
+        return cbk(null, id);
       }],
 
       // Delete the channel

package/lnd_methods/onchain/broadcast_chain_transaction.js

@@ -1,11 +1,10 @@
 const asyncAuto = require('async/auto');
+const {idForTransaction} = require('@alexbosworth/blockchain');
 const {returnResult} = require('asyncjs-util');
-const {Transaction} = require('bitcoinjs-lib');
 
 const {isLnd} = require('./../../lnd_requests');
 
 const bufFromHex = hex => Buffer.from(hex, 'hex');
-const {fromHex} = Transaction;
 const method = 'publishTransaction';
 const minRelayFeeError = /^unmatched backend error: -26: mempool min fee not met, (\d*) < (\d*)$/;
 const type = 'wallet';
@@ -37,7 +36,7 @@ module.exports = ({description, lnd, transaction}, cbk) => {
         }
 
         try {
-          fromHex(transaction);
+          idForTransaction({transaction});
         } catch (err) {
           return cbk([400, 'ExpectedTransactionHexStringToBroadcastToPeers']);
         }
@@ -77,7 +76,7 @@ module.exports = ({description, lnd, transaction}, cbk) => {
             return cbk([503, 'FailedToBroadcastRawTransaction', {res}]);
           }
 
-          return cbk(null, {id: fromHex(transaction).getId()});
+          return cbk(null, {id: idForTransaction({transaction}).id});
         });
       }],
     },

package/lnd_methods/onchain/fund_psbt.js

@@ -1,7 +1,7 @@
 const asyncAuto = require('async/auto');
+const {componentsOfTransaction} = require('@alexbosworth/blockchain');
 const {returnResult} = require('asyncjs-util');
-const {Psbt} = require('bitcoinjs-lib');
-const {Transaction} = require('bitcoinjs-lib');
+const {unsignedTxFromPsbt} = require('@alexbosworth/blockchain');
 
 const {isLnd} = require('./../../lnd_requests');
 
@@ -9,18 +9,15 @@ const asOutpoint = n => `${n.transaction_id}:${n.transaction_vout}`;
 const defaultChangeType = () => 'CHANGE_ADDRESS_TYPE_P2TR';
 const defaultConfirmationTarget = 6;
 const expirationAsDate = epoch => new Date(Number(epoch) * 1e3).toISOString();
-const {fromBuffer} = Transaction;
 const hexFromBuffer = buffer => buffer.toString('hex');
 const {isArray} = Array;
 const {isBuffer} = Buffer;
 const isKnownChangeFormat = format => !format || format === 'p2tr';
 const method = 'fundPsbt';
 const notSupported = /unknown.*walletrpc.WalletKit/;
-const psbtFromHex = hex => Psbt.fromBuffer(Buffer.from(hex, 'hex'));
 const strategy = type => !type ? undefined : `STRATEGY_${type.toUpperCase()}`;
 const type = 'wallet';
 const txIdFromBuffer = buffer => buffer.slice().reverse().toString('hex');
-const txIdFromHash = hash => hash.reverse().toString('hex');
 
 /** Lock and optionally select inputs to a partially signed transaction
 
@@ -223,11 +220,12 @@ module.exports = (args, cbk) => {
         const {psbt} = fund;
 
         try {
-          const tx = psbtFromHex(psbt).data.globalMap.unsignedTx.toBuffer();
+          const tx = hexFromBuffer(unsignedTxFromPsbt({psbt}).transaction);
 
-          return cbk(null, fromBuffer(tx));
-        } catch (err) {
+          const {inputs, outputs} = componentsOfTransaction({transaction: tx});
 
+          return cbk(null, {inputs, outputs});
+        } catch (err) {
           return cbk([503, 'FailedToDecodePsbtInFundPsbtResponse', {err}]);
         }
       }],
@@ -243,9 +241,9 @@ module.exports = (args, cbk) => {
         }));
 
         // The funding inputs are encoded in the PSBT's unsigned tx
-        const funding = tx.ins.map(({hash, index}) => ({
-          transaction_id: txIdFromHash(hash),
-          transaction_vout: index,
+        const funding = tx.inputs.map(({id, vout}) => ({
+          transaction_id: id,
+          transaction_vout: vout,
         }));
 
         // Include relevant UTXO locks with inputs
@@ -272,10 +270,10 @@ module.exports = (args, cbk) => {
       {
         return cbk(null, {
           inputs: fundingInputs,
-          outputs: tx.outs.map(({script, value}, index) => ({
+          outputs: tx.outputs.map(({script, tokens}, index) => ({
+            tokens,
             is_change: index === fund.change_output_index,
-            output_script: hexFromBuffer(script),
-            tokens: value,
+            output_script: script,
           })),
           psbt: fund.psbt,
         });

package/lnd_methods/onchain/get_pending_sweeps.js

@@ -1,11 +1,9 @@
 const asyncAuto = require('async/auto');
 const {returnResult} = require('asyncjs-util');
-const {Transaction} = require('bitcoinjs-lib');
 
 const {isLnd} = require('./../../lnd_requests');
 const {rpcSweepAsSweep} = require('./../../lnd_responses');
 
-const {fromHex} = Transaction;
 const {isArray} = Array;
 const method = 'pendingSweeps';
 const notSupportedError = 'unknown service walletrpc.WalletKit';

package/lnd_methods/onchain/get_sweep_transactions.js

@@ -1,14 +1,14 @@
 const asyncAuto = require('async/auto');
+const {componentsOfTransaction} = require('@alexbosworth/blockchain');
 const {returnResult} = require('asyncjs-util');
-const {Transaction} = require('bitcoinjs-lib');
 
 const getChainTransactions = require('./get_chain_transactions');
 const {isLnd} = require('./../../lnd_requests');
 
-const {fromHex} = Transaction;
 const {isArray} = Array;
 const method = 'listSweeps';
 const notSupportedError = 'unknown service walletrpc.WalletKit';
+const txComponents = transaction => componentsOfTransaction({transaction});
 const type = 'wallet';
 
 /** Get self-transfer spend transactions related to channel closes
@@ -100,14 +100,12 @@ module.exports = ({after, lnd}, cbk) => {
           .filter(({id}) => getSweeps.includes(id))
           .filter(({transaction}) => !!transaction)
           .map(tx => {
-            const {ins} = fromHex(tx.transaction);
+            const {inputs} = txComponents(tx.transaction);
 
-            const spends = ins.map(input => {
-              return {
-                transaction_id: input.hash.reverse().toString('hex'),
-                transaction_vout: input.index,
-              };
-            });
+            const spends = inputs.map(input => ({
+              transaction_id: input.id,
+              transaction_vout: input.vout,
+            }));
 
             const relatedUtxos = spends.map(spend => {
               const spending = getTransactions.transactions.find(({id}) => {
@@ -122,12 +120,10 @@ module.exports = ({after, lnd}, cbk) => {
                 };
               }
 
-              const parentTx = spending.transaction;
-
-              const {value} = fromHex(parentTx).outs[spend.transaction_vout];
+              const parentOutputs = txComponents(spending.transaction).outputs;
 
               return {
-                tokens: value,
+                tokens: parentOutputs[spend.transaction_vout].tokens,
                 transaction_id: spend.transaction_id,
                 transaction_vout: spend.transaction_vout,
               };

package/lnd_methods/onchain/script_from_chain_address.js

@@ -1,13 +1,12 @@
-const {address} = require('bitcoinjs-lib');
-const {payments} = require('bitcoinjs-lib');
+const {decodeBase58Address} = require('@alexbosworth/blockchain');
+const {decodeBech32Address} = require('@alexbosworth/blockchain');
+const {p2pkhOutputScript} = require('@alexbosworth/blockchain');
+const {p2shOutputScript} = require('@alexbosworth/blockchain');
+const {p2wpkhOutputScript} = require('@alexbosworth/blockchain');
+const {p2wshOutputScript} = require('@alexbosworth/blockchain');
 
-const {fromBase58Check} = address;
-const {fromBech32} = address;
-const {p2pkh} = payments;
-const {p2sh} = payments;
+const bufferAsHex = buffer => buffer.toString('hex');
 const p2wpkhAddressLength = 20;
-const {p2wpkh} = payments;
-const {p2wsh} = payments;
 const p2wshAddressLength = 32;
 
 /** Derive output script from on-chain address
@@ -30,9 +29,9 @@ module.exports = args => {
 
   if (!!args.p2pkh_address) {
     try {
-      const {hash} = fromBase58Check(args.p2pkh_address);
+      const {hash} = decodeBase58Address({address: args.p2pkh_address});
 
-      return {script: p2pkh({hash}).output.toString('hex')};
+      return {script: bufferAsHex(p2pkhOutputScript({hash}).script)};
     } catch (err) {
       return {};
     }
@@ -40,23 +39,29 @@ module.exports = args => {
 
   if (!!args.p2sh_address) {
     try {
-      const {hash} = fromBase58Check(args.p2sh_address);
+      const {hash} = decodeBase58Address({address: args.p2sh_address});
 
-      return {script: p2sh({hash}).output.toString('hex')};
+      return {script: bufferAsHex(p2shOutputScript({hash}).script)};
     } catch (err) {
       return {};
     }
   }
 
   try {
-    const {data} = fromBech32(args.bech32_address);
+    const {program, version} = decodeBech32Address({
+      address: args.bech32_address,
+    });
 
-    switch (data.length) {
+    if (!!version) {
+      throw new Error('ExpectedV0VersionForScriptFromChainAddress');
+    }
+
+    switch (program.length) {
     case p2wpkhAddressLength:
-      return {script: p2wpkh({hash: data}).output.toString('hex')};
+      return {script: bufferAsHex(p2wpkhOutputScript({hash: program}).script)};
 
     case p2wshAddressLength:
-      return {script: p2wsh({hash: data}).output.toString('hex')};
+      return {script: bufferAsHex(p2wshOutputScript({hash: program}).script)};
 
     default:
       break;

package/lnd_methods/onchain/send_to_chain_output_scripts.js

@@ -1,11 +1,10 @@
 const asyncAuto = require('async/auto');
+const {idForTransaction} = require('@alexbosworth/blockchain');
 const {returnResult} = require('asyncjs-util');
-const {Transaction} = require('bitcoinjs-lib');
 
 const {isLnd} = require('./../../lnd_requests');
 
 const bufferAsHex = buffer => buffer.toString('hex');
-const {fromBuffer} = Transaction;
 const hexAsBuffer = hex => Buffer.from(hex, 'hex');
 const initialConfirmationCount = 0;
 const {isArray} = Array;
@@ -92,18 +91,20 @@ module.exports = (args, cbk) => {
           }
 
           try {
-            fromBuffer(res.raw_tx).getId();
+            idForTransaction({transaction: bufferAsHex(res.raw_tx)});
           } catch (err) {
             return cbk([500, 'ExpectedRawTransactionInSendToOutputsResponse']);
           }
 
+          const transaction = bufferAsHex(res.raw_tx);
+
           const row = {
+            transaction,
             confirmation_count: initialConfirmationCount,
-            id: fromBuffer(res.raw_tx).getId(),
+            id: idForTransaction({transaction}).id,
             is_confirmed: false,
             is_outgoing: true,
             tokens: args.send_to.reduce((sum, n) => sum + n.tokens, Number()),
-            transaction: bufferAsHex(res.raw_tx),
           };
 
           return cbk(null, row);

package/lnd_methods/onchain/subscribe_to_chain_address.js

@@ -24,7 +24,7 @@ const type = 'chain';
   Requires `onchain:read` permission
 
   {
-    [bech32_address]: <Address String>
+    [bech32_address]: <Bech32 P2WPKH or P2WSH Address String>
     lnd: <Authenticated LND API Object>
     [min_confirmations]: <Minimum Confirmations Number>
     min_height: <Minimum Transaction Inclusion Blockchain Height Number>

package/package.json

@@ -7,20 +7,20 @@
     "url": "https://github.com/alexbosworth/lightning/issues"
   },
   "dependencies": {
+    "@alexbosworth/blockchain": "3.2.0",
     "@grpc/grpc-js": "1.14.3",
     "@grpc/proto-loader": "0.8.0",
-    "@types/node": "25.0.1",
+    "@types/node": "25.0.10",
     "@types/request": "2.48.13",
     "@types/ws": "8.18.1",
     "async": "3.2.6",
     "asyncjs-util": "1.2.12",
-    "bitcoinjs-lib": "6.1.7",
     "bn.js": "5.2.2",
     "bolt07": "1.9.4",
     "bolt09": "2.2.0",
     "invoices": "4.0.0",
     "psbt": "4.0.0",
-    "type-fest": "5.3.1"
+    "type-fest": "5.4.1"
   },
   "description": "Lightning Network client library",
   "devDependencies": {
@@ -28,7 +28,7 @@
     "typescript": "5.9.3"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
   "keywords": [
     "grpc",
@@ -51,5 +51,5 @@
     "directory": "test-typescript/typescript"
   },
   "types": "index.d.ts",
-  "version": "10.27.5"
+  "version": "11.0.0"
 }

package/test/lnd_methods/offchain/test_delete_pending_channel.js

@@ -1,25 +1,17 @@
 const {rejects} = require('node:assert').strict;
 const test = require('node:test');
 
-const {Transaction} = require('bitcoinjs-lib');
-
 const {deletePendingChannel} = require('./../../../lnd_methods');
 
-const tx1 = new Transaction();
-const tx2 = new Transaction();
-const tx3 = new Transaction();
-
-tx1.addInput(Buffer.alloc(32, 0), 0);
-tx2.addInput(Buffer.alloc(32, 0), 0);
-tx2.addInput(Buffer.alloc(32, 1), 0);
-tx2.addOutput(Buffer.alloc(10), 1);
-tx3.addInput(Buffer.alloc(32, 2), 0);
+const tx1 = '010000000100000000000000000000000000000000000000000000000000000000000000000000000000ffffffff0000000000';
+const tx2 = '010000000200000000000000000000000000000000000000000000000000000000000000000000000000ffffffff01010101010101010101010101010101010101010101010101010101010101010000000000ffffffff0101000000000000000a0000000000000000000000000000';
+const tx3 = '010000000102020202020202020202020202020202020202020202020202020202020202020000000000ffffffff0000000000';
 
 const makeArgs = overrides => {
   const args = {
-    confirmed_transaction: tx1.toHex(),
+    confirmed_transaction: tx1,
     lnd: {default: {abandonChannel: ({}, cbk) => cbk()}},
-    pending_transaction: tx2.toHex(),
+    pending_transaction: tx2,
     pending_transaction_vout: 0,
   };
 
@@ -40,7 +32,7 @@ const tests = [
     error: [400, 'ExpectedValidConfirmedTxToDeleteChannel'],
   },
   {
-    args: makeArgs({confirmed_transaction: tx2.toHex()}),
+    args: makeArgs({confirmed_transaction: tx2}),
     description: 'Pending transaction must be different from confirmed tx',
     error: [400, 'ExpectedConflictingTransactionToDeleteChannel'],
   },
@@ -65,7 +57,7 @@ const tests = [
     error: [400, 'ExpectedPendingChannelTxVoutToDeleteChannel'],
   },
   {
-    args: makeArgs({confirmed_transaction: tx3.toHex()}),
+    args: makeArgs({confirmed_transaction: tx3}),
     description: 'A conflicting tx is required',
     error: [400, 'FailedToFindConflictingInputInConfirmedTx'],
   },

package/test/lnd_methods/onchain/test_broadcast_chain_transaction.js

@@ -2,10 +2,10 @@ const {rejects} = require('node:assert').strict;
 const {strictEqual} = require('node:assert').strict;
 const test = require('node:test');
 
-const {Transaction} = require('bitcoinjs-lib');
-
 const {broadcastChainTransaction} = require('./../../../lnd_methods');
 
+const emptyTx = '01000000000000000000';
+
 const tests = [
   {
     args: {},
@@ -20,7 +20,7 @@ const tests = [
   {
     args: {
       lnd: {wallet: {publishTransaction: ({}, cbk) => cbk('err')}},
-      transaction: new Transaction().toHex(),
+      transaction: emptyTx,
     },
     description: 'Expected error is returned',
     error: [503, 'UnexpectedErrBroadcastingRawTx', {err: 'err'}],
@@ -28,7 +28,7 @@ const tests = [
   {
     args: {
       lnd: {wallet: {publishTransaction: ({}, cbk) => cbk()}},
-      transaction: new Transaction().toHex(),
+      transaction: emptyTx,
     },
     description: 'A result is required',
     error: [503, 'ExpectedResultOfBroadcastRawTransaction'],
@@ -40,7 +40,7 @@ const tests = [
           publishTransaction: ({}, cbk) => cbk(null, {publish_error: 'err'}),
         },
       },
-      transaction: new Transaction().toHex(),
+      transaction: emptyTx,
     },
     description: 'Failure to broadcast error is returned',
     error: [
@@ -58,7 +58,7 @@ const tests = [
           }),
         },
       },
-      transaction: new Transaction().toHex(),
+      transaction: emptyTx,
     },
     description: 'Minimum relay fee not met',
     error: [
@@ -73,7 +73,7 @@ const tests = [
   {
     args: {
       lnd: {wallet: {publishTransaction: ({}, cbk) => cbk(null, {})}},
-      transaction: new Transaction().toHex(),
+      transaction: emptyTx,
     },
     description: 'A transaction is published',
     expected: {

package/test/lnd_methods/onchain/test_get_sweep_transactions.js

@@ -2,10 +2,10 @@ const {deepStrictEqual} = require('node:assert').strict;
 const {rejects} = require('node:assert').strict;
 const test = require('node:test');
 
-const {Transaction} = require('bitcoinjs-lib');
-
 const {getSweepTransactions} = require('./../../../lnd_methods');
 
+const emptyTx = '01000000000000000000';
+
 const makeDefault = overrides => {
   const methods = {
     getTransactions: ({}, cbk) => {
@@ -17,7 +17,7 @@ const makeDefault = overrides => {
           dest_addresses: ['address'],
           num_confirmations: 1,
           previous_outpoints: [],
-          raw_tx_hex: (new Transaction()).toHex(),
+          raw_tx_hex: emptyTx,
           time_stamp: '1',
           total_fees: '1',
           tx_hash: Buffer.alloc(32).toString('hex'),

package/test/lnd_methods/onchain/test_script_from_chain_address.js

@@ -1,5 +1,6 @@
 const {deepStrictEqual} = require('node:assert').strict;
 const test = require('node:test');
+const {throws} = require('node:assert').strict;
 
 const scriptFromChainAddress = require('./../../../lnd_methods/onchain/script_from_chain_address');
 
@@ -61,13 +62,24 @@ const tests = [
     description: 'Nothing returned for no recognized address',
     expected: {},
   },
+  {
+    args: {
+      bech32_address: 'bc1p5d7rjq7g6rdk2yhzks9smlaqtedr4dekq08ge8ztwac72sfr9rusxg3297',
+    },
+    description: 'Script not derived from p2tr address',
+    expected: {},
+  },
 ];
 
-tests.forEach(({args, description, expected}) => {
+tests.forEach(({args, description, error, expected}) => {
   return test(description, (t, end) => {
-    const {script} = scriptFromChainAddress(args);
+    if (!!error) {
+      throws(() => scriptFromChainAddress(args), new Error(error), 'Got error');
+    } else {
+      const {script} = scriptFromChainAddress(args);
 
-    deepStrictEqual(script, expected.script, 'Script derived from address');
+      deepStrictEqual(script, expected.script, 'Script derived from address');
+    }
 
     return end();
   });

package/test/lnd_methods/onchain/test_send_to_chain_output_scripts.js

@@ -2,16 +2,16 @@ const {deepStrictEqual} = require('node:assert').strict;
 const {rejects} = require('node:assert').strict;
 const test = require('node:test');
 
-const {Transaction} = require('bitcoinjs-lib');
-
 const {sendToChainOutputScripts} = require('./../../../lnd_methods');
 
+const emptyTx = '01000000000000000000';
+
 const makeArgs = overrides => {
   const args = {
     lnd: {
       wallet: {
         sendOutputs: ({}, cbk) => cbk(null, {
-          raw_tx: new Transaction().toBuffer(),
+          raw_tx: Buffer.from(emptyTx, 'hex'),
         }),
       },
     },

package/test/lnd_methods/onchain/test_subscribe_to_chain_address.js

@@ -3,10 +3,10 @@ const {strictEqual} = require('node:assert').strict;
 const test = require('node:test');
 const {throws} = require('node:assert').strict;
 
-const {Transaction} = require('bitcoinjs-lib');
-
 const {subscribeToChainAddress} = require('./../../../lnd_methods');
 
+const emptyTx = '01000000000000000000';
+
 const tests = [
   {
     args: {
@@ -20,7 +20,7 @@ const tests = [
     expected: {
       block: Buffer.alloc(32).toString('hex'),
       height: 200,
-      transaction: (new Transaction()).toHex(),
+      transaction: emptyTx,
     },
   },
   {
@@ -35,7 +35,7 @@ const tests = [
     expected: {
       block: Buffer.alloc(32).toString('hex'),
       height: 200,
-      transaction: (new Transaction()).toHex(),
+      transaction: emptyTx,
     },
   },
   {
@@ -79,7 +79,7 @@ tests.forEach(({args, description, emitter, error, expected}) => {
       conf: {
         block_hash: Buffer.alloc(32),
         block_height: 200,
-        raw_tx: (new Transaction()).toBuffer(),
+        raw_tx: Buffer.from(emptyTx, 'hex'),
       },
     });
 

package/test/lnd_methods/onchain/test_subscribe_to_chain_spend.js

@@ -3,10 +3,10 @@ const {strictEqual} = require('node:assert').strict;
 const test = require('node:test');
 const {throws} = require('node:assert').strict;
 
-const {Transaction} = require('bitcoinjs-lib');
-
 const {subscribeToChainSpend} = require('./../../../lnd_methods');
 
+const emptyTx = '01000000000000000000';
+
 const tests = [
   {
     args: {
@@ -16,11 +16,7 @@ const tests = [
       transaction_vout: 0,
     },
     description: 'Confirmation emitted for chain spend',
-    expected: {
-      height: 200,
-      transaction: (new Transaction()).toHex(),
-      vin: 0,
-    },
+    expected: {height: 200, transaction: emptyTx, vin: 0},
   },
   {
     args: {},
@@ -63,7 +59,7 @@ tests.forEach(({args, description, error, expected}) => {
 
     emitter.emit('data', {
       spend: {
-        raw_spending_tx: (new Transaction()).toBuffer(),
+        raw_spending_tx: Buffer.from(emptyTx, 'hex'),
         spending_height: 200,
         spending_input_index: 0,
       },

package/test-typescript/typescript/broadcast_chain_transaction.test-d.ts

@@ -4,10 +4,9 @@ import {
   broadcastChainTransaction,
   BroadcastChainTransactionResult,
 } from '../../lnd_methods';
-import {Transaction} from 'bitcoinjs-lib';
 
 const lnd = {} as AuthenticatedLnd;
-const transaction = new Transaction().toHex();
+const transaction = '01000000000000000000';
 const description = 'description';
 
 expectError(broadcastChainTransaction());