ln-service 59.3.2 → 59.3.3

package/test/walletrpc-integration/test_fund_psbt.js

@@ -2,13 +2,14 @@ const {equal} = require('node:assert').strict;
 const test = require('node:test');
 
 const asyncRetry = require('async/retry');
-const {address} = require('bitcoinjs-lib');
+const {componentsOfTransaction} = require('@alexbosworth/blockchain');
 const {controlBlock} = require('p2tr');
 const {createPsbt} = require('psbt');
+const {decodeBech32Address} = require('@alexbosworth/blockchain');
 const {decodePsbt} = require('psbt');
 const {hashForTree} = require('p2tr');
-const {leafHash} = require('p2tr');
-const {networks} = require('bitcoinjs-lib');
+const {idForTransaction} = require('@alexbosworth/blockchain');
+const {p2wpkhOutputScript} = require('@alexbosworth/blockchain');
 const {pointAdd} = require('tiny-secp256k1');
 const {privateAdd} = require('tiny-secp256k1');
 const {scriptElementsAsScript} = require('@alexbosworth/blockchain');
@@ -16,7 +17,8 @@ const {signHash} = require('p2tr');
 const {signSchnorr} = require('tiny-secp256k1');
 const {spawnLightningCluster} = require('ln-docker-daemons');
 const tinysecp = require('tiny-secp256k1');
-const {Transaction} = require('bitcoinjs-lib');
+const {transactionFromComponents} = require('@alexbosworth/blockchain');
+const {v1HashToSign} = require('p2tr');
 const {v1OutputScript} = require('p2tr');
 
 const {broadcastChainTransaction} = require('./../../');
@@ -28,24 +30,29 @@ const {getUtxos} = require('./../../');
 const {sendToChainAddress} = require('./../../');
 const {signPsbt} = require('./../../');
 
+const bufferAsHex = buffer => buffer.toString('hex');
 const chainAddressRowType = 'chain_address';
 const compile = elements => scriptElementsAsScript({elements}).script;
+const componentsOfTx = tx => componentsOfTransaction({transaction: tx});
 const confirmationCount = 6;
 const count = 100;
 const defaultInternalKey = '0350929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0';
+const defaultLocktime = 0;
+const defaultSequence = 0xffffffff;
+const defaultTxVersion = 1;
 const description = 'description';
+const emptyScriptSig = '';
 const {from} = Buffer;
-const {fromBech32} = address;
-const {fromHex} = Transaction;
-const {fromOutputScript} = address;
 const hexAsBuffer = hex => Buffer.from(hex, 'hex');
+const idForTx = transaction => idForTransaction({transaction}).id;
 const interval = retryCount => 10 * Math.pow(2, retryCount);
 const OP_CHECKSIG = 172;
+const p2wpkh = hash => p2wpkhOutputScript({hash}).script;
 const regtestBech32AddressHrp = 'bcrt';
 const smallTokens = 2e5;
 const times = 20;
-const {toOutputScript} = address;
 const tokens = 1e6;
+const transactionSighashDefault = 0;
 const txIdHexByteLength = 64;
 
 // Funding a transaction should result in a funded PSBT
@@ -107,11 +114,11 @@ test(`Fund PSBT`, async () => {
 
   equal(output.tokens, tokens, 'Got expected tokens output');
 
-  const {data, version} = fromBech32(address);
+  const {program, version} = decodeBech32Address({address});
 
   const prefix = `${Buffer.from([version]).toString('hex')}14`;
 
-  const expectedOutput = `${prefix}${data.toString('hex')}`;
+  const expectedOutput = `${prefix}${bufferAsHex(program)}`;
 
   equal(output.output_script, expectedOutput, 'Got expected output script');
 
@@ -127,9 +134,9 @@ test(`Fund PSBT`, async () => {
   try {
     await generate({count});
 
-    const keyPair1 = ecp.makeRandom({network: networks.regtest});
-    const keyPair2 = ecp.makeRandom({network: networks.regtest});
-    const unusedKey = ecp.makeRandom({network: networks.regtest});
+    const keyPair1 = ecp.makeRandom({});
+    const keyPair2 = ecp.makeRandom({});
+    const unusedKey = ecp.makeRandom({});
 
     const witnessScript = compile([
       from(unusedKey.publicKey).slice(1),
@@ -168,31 +175,42 @@ test(`Fund PSBT`, async () => {
     // Send the tx to the chain
     await broadcastChainTransaction({lnd, transaction: signed.transaction});
 
-    // Make a new tx that will spend the output back into the wallet
-    const tx = new Transaction();
+    const spends = componentsOfTx(signed.transaction).outputs;
 
     // The new tx spends the Taproot output
-    tx.addInput(
-      fromHex(signed.transaction).getHash(),
-      fromHex(signed.transaction).outs.findIndex(n => n.value === tokens)
-    );
+    const inputs = [{
+      id: idForTx(signed.transaction),
+      script: emptyScriptSig,
+      sequence: defaultSequence,
+      vout: spends.findIndex(n => n.tokens === tokens),
+    }];
 
     // Make an output to pay back into the wallet
-    const chainOutput = toOutputScript(
-      (await createChainAddress({lnd})).address,
-      networks.regtest
-    );
+    const chainAddress = await createChainAddress({lnd});
+
+    const {program} = decodeBech32Address({address: chainAddress.address});
 
     // Add output to the pay back transaction
-    tx.addOutput(chainOutput, smallTokens);
-
-    const [hashToSign] = tx.ins.map((input, i) => {
-      return tx.hashForWitnessV1(
-        i,
-        [hexAsBuffer(output.script)],
-        [tokens],
-        Transaction.SIGHASH_DEFAULT,
-      );
+    const outputs = [{
+      script: bufferAsHex(p2wpkh(program)),
+      tokens: smallTokens,
+    }];
+
+    // Make a new tx that will spend the output back into the wallet
+    const unsigned = transactionFromComponents({
+      inputs,
+      outputs,
+      locktime: defaultLocktime,
+      version: defaultTxVersion,
+    });
+
+    const [hashToSign] = inputs.map((input, i) => {
+      return v1HashToSign({
+        sighash: transactionSighashDefault,
+        spends: [{tokens, script: output.script}],
+        transaction: unsigned.transaction,
+        vin: i,
+      }).hash;
     });
 
     // Ready for private key combining
@@ -205,22 +223,33 @@ test(`Fund PSBT`, async () => {
       hash,
       private_key: Buffer.from(combinedKey).toString('hex'),
       public_key: Buffer.from(combinedPoint).toString('hex'),
-      sign_hash: hashToSign.toString('hex'),
+      sign_hash: hashToSign,
     });
 
-    const signature = hexAsBuffer(signedInput.signature);
-
-    // Add the signature to the input
-    tx.ins.forEach((input, i) => tx.setWitness(i, [signature]));
+    const {signature} = signedInput;
+
+    // Add the signature to the input and serialize the signed transaction
+    const {transaction} = transactionFromComponents({
+      outputs,
+      inputs: inputs.map(input => ({
+        id: input.id,
+        script: input.script,
+        sequence: input.sequence,
+        vout: input.vout,
+        witness: [signature],
+      })),
+      locktime: defaultLocktime,
+      version: defaultTxVersion,
+    });
 
-    await broadcastChainTransaction({lnd, transaction: tx.toHex()});
+    await broadcastChainTransaction({lnd, transaction});
 
     await asyncRetry({interval, times}, async () => {
       await generate({});
 
       const {utxos} = await getUtxos({lnd});
 
-      const utxo = utxos.find(n => n.transaction_id === tx.getId());
+      const utxo = utxos.find(n => n.transaction_id === idForTx(transaction));
 
       if (!utxo || !utxo.confirmation_count) {
         throw new Error('ExpectedReceivedTaprootSpend');
@@ -234,7 +263,7 @@ test(`Fund PSBT`, async () => {
   try {
     await generate({count});
 
-    const keyPair = ecp.makeRandom({network: networks.regtest});
+    const keyPair = ecp.makeRandom({});
 
     const witnessScript = compile([
       from(keyPair.publicKey.slice(1)),
@@ -264,35 +293,50 @@ test(`Fund PSBT`, async () => {
     // Send the tx to the chain
     await broadcastChainTransaction({lnd, transaction: signed.transaction});
 
-    // Make a new tx that will spend the output back into the wallet
-    const tx = new Transaction();
+    const spends = componentsOfTx(signed.transaction).outputs;
 
     // The new tx spends the Taproot output
-    tx.addInput(
-      fromHex(signed.transaction).getHash(),
-      fromHex(signed.transaction).outs.findIndex(n => n.value === tokens)
-    );
+    const inputs = [{
+      id: idForTx(signed.transaction),
+      script: emptyScriptSig,
+      sequence: defaultSequence,
+      vout: spends.findIndex(n => n.tokens === tokens),
+    }];
 
     // Make an output to pay back into the wallet
-    const chainOutput = toOutputScript(
-      (await createChainAddress({lnd})).address,
-      networks.regtest
-    );
+    const chainAddress = await createChainAddress({lnd});
+
+    const {program} = decodeBech32Address({address: chainAddress.address});
 
     // Add output to the pay back transaction
-    tx.addOutput(chainOutput, smallTokens);
-
-    const [hashToSign] = tx.ins.map((input, i) => {
-      return tx.hashForWitnessV1(
-        i,
-        [hexAsBuffer(output.script)],
-        [tokens],
-        Transaction.SIGHASH_DEFAULT,
-        hexAsBuffer(leafHash({script: witnessScript}).hash),
-      );
+    const outputs = [{
+      script: bufferAsHex(p2wpkh(program)),
+      tokens: smallTokens,
+    }];
+
+    // Make a new tx that will spend the output back into the wallet
+    const unsigned = transactionFromComponents({
+      inputs,
+      outputs,
+      locktime: defaultLocktime,
+      version: defaultTxVersion,
     });
 
-    const signature = from(signSchnorr(hashToSign, from(keyPair.privateKey)));
+    const [hashToSign] = inputs.map((input, i) => {
+      return v1HashToSign({
+        leaf: {script: witnessScript},
+        sighash: transactionSighashDefault,
+        spends: [{tokens, script: output.script}],
+        transaction: unsigned.transaction,
+        vin: i,
+      }).hash;
+    });
+
+    const hashBuffer = hexAsBuffer(hashToSign);
+
+    const schnorrSig = signSchnorr(hashBuffer, from(keyPair.privateKey));
+
+    const signature = bufferAsHex(from(schnorrSig));
 
     const {block} = controlBlock({
       external_key: output.external_key,
@@ -300,23 +344,28 @@ test(`Fund PSBT`, async () => {
       script_branches: branches,
     });
 
-    // Add the signature to the input
-    tx.ins.forEach((input, i) => {
-      return tx.setWitness(i, [
-        signature,
-        hexAsBuffer(witnessScript),
-        hexAsBuffer(block),
-      ]);
+    // Add the signature to the input and serialize the signed transaction
+    const {transaction} = transactionFromComponents({
+      outputs,
+      inputs: inputs.map(input => ({
+        id: input.id,
+        script: input.script,
+        sequence: input.sequence,
+        vout: input.vout,
+        witness: [signature, witnessScript, block],
+      })),
+      locktime: defaultLocktime,
+      version: defaultTxVersion,
     });
 
-    await broadcastChainTransaction({lnd, transaction: tx.toHex()});
+    await broadcastChainTransaction({lnd, transaction});
 
     await asyncRetry({interval, times}, async () => {
       await generate({});
 
       const {utxos} = await getUtxos({lnd});
 
-      const utxo = utxos.find(n => n.transaction_id === tx.getId());
+      const utxo = utxos.find(n => n.transaction_id === idForTx(transaction));
 
       if (!utxo || !utxo.confirmation_count) {
         throw new Error('ExpectedReceivedTaprootSpend');
@@ -334,19 +383,17 @@ test(`Fund PSBT`, async () => {
   try {
     await generate({count});
 
-    const keyPair = ecp.makeRandom({network: networks.regtest});
+    const keyPair = ecp.makeRandom({});
 
     const output = v1OutputScript({
       internal_key: from(keyPair.publicKey).toString('hex'),
     });
 
-    const outputScript = hexAsBuffer(output.script);
-
     const [utxo] = (await getUtxos({lnd})).utxos.reverse();
 
     // Make a PSBT paying to the Taproot output
     const {psbt} = createPsbt({
-      outputs: [{tokens, script: outputScript.toString('hex')}],
+      outputs: [{tokens, script: output.script}],
       utxos: [{id: utxo.transaction_id, vout: utxo.transaction_vout}],
     });
 
@@ -359,52 +406,74 @@ test(`Fund PSBT`, async () => {
     // Send the tx to the chain
     await broadcastChainTransaction({lnd, transaction: signed.transaction});
 
-    // Make a new tx that will spend the output back into the wallet
-    const tx = new Transaction();
+    const spends = componentsOfTx(signed.transaction).outputs;
 
     // The new tx spends the Taproot output
-    tx.addInput(
-      fromHex(signed.transaction).getHash(),
-      fromHex(signed.transaction).outs.findIndex(n => n.value === tokens)
-    );
+    const inputs = [{
+      id: idForTx(signed.transaction),
+      script: emptyScriptSig,
+      sequence: defaultSequence,
+      vout: spends.findIndex(n => n.tokens === tokens),
+    }];
 
     // Make an output to pay back into the wallet
-    const chainOutput = toOutputScript(
-      (await createChainAddress({lnd})).address,
-      networks.regtest
-    );
+    const chainAddress = await createChainAddress({lnd});
+
+    const {program} = decodeBech32Address({address: chainAddress.address});
 
     // Add output to the pay back transaction
-    tx.addOutput(chainOutput, smallTokens);
-
-    const [hashToSign] = tx.ins.map((input, i) => {
-      return tx.hashForWitnessV1(
-        i,
-        [outputScript],
-        [tokens],
-        Transaction.SIGHASH_DEFAULT,
-      );
+    const outputs = [{
+      script: bufferAsHex(p2wpkh(program)),
+      tokens: smallTokens,
+    }];
+
+    // Make a new tx that will spend the output back into the wallet
+    const unsigned = transactionFromComponents({
+      inputs,
+      outputs,
+      locktime: defaultLocktime,
+      version: defaultTxVersion,
+    });
+
+    const [hashToSign] = inputs.map((input, i) => {
+      return v1HashToSign({
+        sighash: transactionSighashDefault,
+        spends: [{tokens, script: output.script}],
+        transaction: unsigned.transaction,
+        vin: i,
+      }).hash;
     });
 
     const signedInput = signHash({
       private_key: from(keyPair.privateKey).toString('hex'),
       public_key: from(keyPair.publicKey).toString('hex'),
-      sign_hash: hashToSign.toString('hex'),
+      sign_hash: hashToSign,
     });
 
-    const signature = hexAsBuffer(signedInput.signature);
-
-    // Add the signature to the input
-    tx.ins.forEach((input, i) => tx.setWitness(i, [Buffer.from(signature)]));
+    const {signature} = signedInput;
+
+    // Add the signature to the input and serialize the signed transaction
+    const {transaction} = transactionFromComponents({
+      outputs,
+      inputs: inputs.map(input => ({
+        id: input.id,
+        script: input.script,
+        sequence: input.sequence,
+        vout: input.vout,
+        witness: [signature],
+      })),
+      locktime: defaultLocktime,
+      version: defaultTxVersion,
+    });
 
-    await broadcastChainTransaction({lnd, transaction: tx.toHex()});
+    await broadcastChainTransaction({lnd, transaction});
 
     await asyncRetry({interval, times}, async () => {
       await generate({});
 
       const {utxos} = await getUtxos({lnd});
 
-      const utxo = utxos.find(n => n.transaction_id === tx.getId());
+      const utxo = utxos.find(n => n.transaction_id === idForTx(transaction));
 
       if (!utxo || !utxo.confirmation_count) {
         throw new Error('ExpectedReceivedTaprootSpend');

package/test/macros/btcsuite_type_daemon.js

@@ -1,143 +0,0 @@
-const {join} = require('path');
-const {spawn} = require('child_process');
-
-const asyncAuto = require('async/auto');
-const openPortFinder = require('portfinder');
-const {networks} = require('bitcoinjs-lib');
-const {payments} = require('bitcoinjs-lib');
-const tinysecp = require('tiny-secp256k1');
-
-const knownDaemons = ['btcd'];
-const localhost = '127.0.0.1';
-const notFoundIndex = -1;
-const {p2pkh} = payments;
-const rpcServerReady = /RPC.server.listening/;
-const unableToStartServer = /Unable.to.start.server/;
-
-/** Start a BTCSuite Type Daemon
-
-  {
-    daemon: <Daemon Name String>
-    dir: <Data Directory String>
-    [is_tls]: <Uses TLS Bool>
-    mining_public_key: <Mining Public Key Hex String>
-  }
-
-  @returns
-  <Daemon Object>
-
-  @returns via cbk
-  {
-    daemon: <Daemon Child Process Object>
-    listen_port: <Listen Port Number>
-    rpc_cert: <RPC Cert Path String>
-    rpc_port: <RPC Port Number>
-  }
-*/
-module.exports = (args, cbk) => {
-  return asyncAuto({
-    // Import ECPair library
-    ecp: async () => (await import('ecpair')).ECPairFactory(tinysecp),
-
-    // Check arguments
-    validate: cbk => {
-      if (knownDaemons.indexOf(args.daemon) === notFoundIndex) {
-        return cbk([400, 'ExpectedBtcsuiteDaemonName', args.daemon]);
-      }
-
-      if (!args.dir) {
-        return cbk([400, 'ExpectedDirectoryForDaemon']);
-      }
-
-      if (!args.mining_public_key) {
-        return cbk([400, 'ExpectedMiningPublicKeyForDaemon']);
-      }
-
-      return cbk();
-    },
-
-    // Get an open P2P listen port
-    listenPort: ['validate', ({}, cbk) => {
-      const port = 14567 + Math.round(Math.random() * 1000);
-
-      const stopPort = port + 1000;
-
-      return openPortFinder.getPort({port, stopPort}, (err, port) => {
-        if (!!err) {
-          return cbk([500, 'FailedToFindOpenPortForListenPort', err]);
-        }
-
-        return cbk(null, port);
-      });
-    }],
-
-    // Get an open RPC listen port
-    rpcPort: ['listenPort', ({}, cbk) => {
-      const port = 14567 + Math.round(Math.random() * 1000);
-
-      const stopPort = port + 1000;
-
-      return openPortFinder.getPort({port, stopPort}, (err, port) => {
-        if (!!err) {
-          return cbk([500, 'FailedToFindOpenPortForRpc', err]);
-        }
-
-        return cbk(null, port);
-      });
-    }],
-
-    // Spin up the chain daemon
-    spawnDaemon: [
-      'ecp',
-      'listenPort',
-      'rpcPort',
-      ({ecp, listenPort, rpcPort}, cbk) =>
-    {
-      const miningKey = Buffer.from(args.mining_public_key, 'hex');
-      const network = networks.testnet;
-
-      const pubkey = ecp.fromPublicKey(miningKey, network).publicKey;
-
-      const daemon = spawn(args.daemon, [
-        '--datadir', args.dir,
-        '--debuglevel', 'trace',
-        '--listen', `${localhost}:${listenPort}`,
-        '--logdir', args.dir,
-        '--miningaddr', p2pkh({network, pubkey}).address,
-        (!args.is_tls ? '--notls' : null),
-        '--regtest',
-        '--relaynonstd',
-        '--rpccert', join(args.dir, 'rpc.cert'),
-        '--rpckey', join(args.dir, 'rpc.key'),
-        '--rpclisten', `${localhost}:${rpcPort}`,
-        '--rpcpass', '0k39BVOdg4uuS7qNCG2jbIXNpwU7d3Ft87PpHPPoCfk=',
-        '--rpcuser', 'bitcoinrpc',
-        '--txindex',
-      ]);
-
-      daemon.stdout.on('data', data => {
-        if (unableToStartServer.test(`${data}`)) {
-          return cbk([503, 'SpawnDaemonFailure', `${data}`, args]);
-        }
-
-        if (rpcServerReady.test(`${data}`)) {
-          return cbk(null, daemon);
-        }
-
-        return;
-      });
-    }],
-  },
-  (err, res) => {
-    if (!!err) {
-      return cbk(err);
-    }
-
-    return cbk(null, {
-      daemon: res.spawnDaemon,
-      listen_port: res.listenPort,
-      rpc_cert: join(args.dir, 'rpc.cert'),
-      rpc_port: res.rpcPort,
-    });
-  });
-};

package/test/macros/chain_send_transaction.js

@@ -1,102 +0,0 @@
-const {encode} = require('varuint-bitcoin');
-
-const {address} = require('bitcoinjs-lib');
-const {crypto} = require('bitcoinjs-lib');
-const {networks} = require('bitcoinjs-lib');
-const {payments} = require('bitcoinjs-lib');
-const {script} = require('bitcoinjs-lib');
-const {Transaction} = require('bitcoinjs-lib');
-
-const scriptBufAsScript = require('./script_buffers_as_script');
-
-const defaultNetwork = 'testnet';
-const encodeSignature = script.signature.encode;
-const hexBase = 16;
-const {p2pkh} = payments;
-const {SIGHASH_ALL} = Transaction;
-const {toOutputScript} = address;
-
-/** Create a transaction that sends coins to a destination chain address
-
-  {
-    destination: <Destination Address String>
-    ecp: <ECPair Object>
-    fee: <Fee Tokens To Remove From Spend Number>
-    private_key: <WIF Serialized Private Key String>
-    spend_transaction_id: <Transaction Id to Spend Hex String>
-    spend_vout: <Vout to Spend Number>
-    tokens: <Tokens to Spend Number>
-  }
-
-  @returns
-  {
-    transaction: <Transaction Hex Serialized String>
-  }
-*/
-module.exports = args => {
-  if (!args.destination) {
-    throw new Error('ExpectedDestinationAddressToSendTokensTo');
-  }
-
-  if (!args.ecp) {
-    throw new Error('ExpectedEcpairObjectToChainSendTransaction');
-  }
-
-  if (!args.private_key) {
-    throw new Error('ExpectedPrivateKeyToAuthorizeSend');
-  }
-
-  if (!args.spend_transaction_id) {
-    throw new Error('ExpectedOutpointTxIdToSpend');
-  }
-
-  if (args.spend_vout === undefined) {
-    throw new Error('ExpectedOutpointVoutToSpend');
-  }
-
-  if (!args.tokens) {
-    throw new Error('ExpectedTokenCountToSend');
-  }
-
-  const network = networks[defaultNetwork];
-
-  const keyPair = args.ecp.fromWIF(args.private_key, network);
-  const outputScript = toOutputScript(args.destination, network);
-  const tx = new Transaction();
-
-  const outpointHash = Buffer.from(args.spend_transaction_id, 'hex').reverse();
-
-  tx.addInput(outpointHash, args.spend_vout);
-
-  try {
-    tx.addOutput(outputScript, (args.tokens - (args.fee || 0)));
-  } catch (err) {
-    throw new Error('ErrorAddingOutputToSendOnChainTransaction');
-  }
-
-  const sigHashAll = parseInt(SIGHASH_ALL, hexBase);
-
-  [keyPair].forEach((signingKey, vin) => {
-    const flag = sigHashAll;
-    const {publicKey} = signingKey;
-
-    const scriptPub = p2pkh({network, pubkey: publicKey}).output;
-
-    const sigHash = tx.hashForSignature(vin, scriptPub, flag);
-
-    const signature = signingKey.sign(sigHash);
-
-    const sig = encodeSignature(signature, flag);
-
-    const sigPush = Buffer.concat([encode(sig.length), sig]);
-    const pubKeyPush = Buffer.concat([encode(publicKey.length), publicKey]);
-
-    const scriptSig = Buffer.concat([sigPush, pubKeyPush]);
-
-    tx.setInputScript(vin, scriptSig);
-
-    return;
-  });
-
-  return {transaction: tx.toHex()};
-};