ln-service 53.7.2 → 53.7.3

package/test/walletrpc-integration/test_fund_psbt.js

@@ -1,32 +1,55 @@
 const asyncRetry = require('async/retry');
 const {address} = require('bitcoinjs-lib');
+const {createPsbt} = require('psbt');
+const {crypto} = require('bitcoinjs-lib');
 const {decodePsbt} = require('psbt');
+const {networks} = require('bitcoinjs-lib');
+const {script} = require('bitcoinjs-lib');
 const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 const tinysecp = require('tiny-secp256k1');
+const {Transaction} = require('bitcoinjs-lib');
 
+const {broadcastChainTransaction} = require('./../../');
 const {createChainAddress} = require('./../../');
 const {fundPsbt} = require('./../../');
 const {getChainBalance} = require('./../../');
 const {getChainTransactions} = require('./../../');
 const {getUtxos} = require('./../../');
 const {sendToChainAddress} = require('./../../');
+const {signPsbt} = require('./../../');
 
 const chainAddressRowType = 'chain_address';
+const {compile} = script;
 const confirmationCount = 6;
 const count = 100;
 const description = 'description';
+const extra = Buffer.alloc(32);
 const {fromBech32} = address;
+const {fromHex} = Transaction;
+const {fromOutputScript} = address;
+const hexAsBuffer = hex => Buffer.from(hex, 'hex');
 const interval = retryCount => 10 * Math.pow(2, retryCount);
+const isLowPublicKey = keyPair => keyPair.publicKey[0] === 2;
+const makeTaprootKey = (k, h) => tinysecp.xOnlyPointAddTweak(k, h).xOnlyPubkey;
+const nLess1 = 'fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140';
+const one256BitBigEndian = '0000000000000000000000000000000000000000000000000000000000000001';
+const OP_1 = 81;
+const {privateAdd} = tinysecp;
+const {privateSub} = tinysecp;
 const regtestBech32AddressHrp = 'bcrt';
+const shortKey = keyPair =>  keyPair.publicKey.slice(1, 33);
+const {signSchnorr} = tinysecp;
+const smallTokens = 2e5;
+const tapHash = k => crypto.taggedHash('TapTweak', k.publicKey.slice(1, 33));
 const times = 20;
+const {toOutputScript} = address;
 const tokens = 1e6;
 const txIdHexByteLength = 64;
 
 // Funding a transaction should result in a funded PSBT
 test(`Fund PSBT`, async ({end, equal}) => {
   const ecp = (await import('ecpair')).ECPairFactory(tinysecp);
-
   const {kill, nodes} = await spawnLightningCluster({});
 
   const [{generate, lnd}] = nodes;
@@ -97,6 +120,92 @@ test(`Fund PSBT`, async ({end, equal}) => {
   equal(!!decodedInput.witness_utxo.script_pub, true, 'PSBT input address');
   equal(decodedInput.witness_utxo.tokens, 5000000000, 'PSBT has input tokens');
 
+  // A Taproot output should be funded
+  try {
+    await generate({count});
+
+    const keyPair = ecp.makeRandom({network: networks.regtest});
+
+    const outputKey = makeTaprootKey(shortKey(keyPair), tapHash(keyPair));
+    const tweakHash = tapHash(keyPair);
+
+    const outputScript = compile([OP_1, Buffer.from(outputKey)]);
+
+    const [utxo] = (await getUtxos({lnd})).utxos.reverse();
+
+    // Make a PSBT paying to the Taproot output
+    const {psbt} = createPsbt({
+      outputs: [{tokens, script: outputScript.toString('hex')}],
+      utxos: [{id: utxo.transaction_id, vout: utxo.transaction_vout}],
+    });
+
+    // Sign the PSBT
+    const signed = await signPsbt({
+      lnd,
+      psbt: (await fundPsbt({lnd, psbt})).psbt,
+    });
+
+    // 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();
+
+    // The new tx spends the Taproot output
+    tx.addInput(
+      fromHex(signed.transaction).getHash(),
+      fromHex(signed.transaction).outs.findIndex(n => n.value === tokens)
+    );
+
+    // Make an output to pay back into the wallet
+    const chainOutput = toOutputScript(
+      (await createChainAddress({lnd})).address,
+      networks.regtest
+    );
+
+    // 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 isLow = isLowPublicKey(keyPair);
+    const ONE = hexAsBuffer(one256BitBigEndian);
+    const subtract = privateSub(hexAsBuffer(nLess1), keyPair.privateKey);
+
+    const privateKey = isLow ? keyPair.privateKey : privateAdd(subtract, ONE);
+
+    // Only low keys are allowed to save a leading byte on the public key
+    const lowPrivateKey = privateAdd(privateKey, tweakHash);
+
+    const signature = signSchnorr(hashToSign, lowPrivateKey, extra);
+
+    // Add the signature to the input
+    tx.ins.forEach((input, i) => tx.setWitness(i, [Buffer.from(signature)]));
+
+    await broadcastChainTransaction({lnd, transaction: tx.toHex()});
+
+    await asyncRetry({interval, times}, async () => {
+      await generate({});
+
+      const {utxos} = await getUtxos({lnd});
+
+      const utxo = utxos.find(n => n.transaction_id === tx.getId());
+
+      if (!utxo || !utxo.confirmation_count) {
+        throw new Error('ExpectedReceivedTaprootSpend');
+      }
+    });
+  } catch (err) {
+    equal(err, null, 'Expected no error');
+  }
+
   await kill({});
 
   return end();