ln-service 53.7.0 → 53.8.0

package/test/routerrpc-integration/test_subscribe_to_past_payments.js

@@ -2,11 +2,8 @@ const asyncRetry = require('async/retry');
 const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 
-const {addPeer} = require('./../../');
 const {createInvoice} = require('./../../');
 const {delay} = require('./../macros');
-const {getChannels} = require('./../../');
-const {getHeight} = require('./../../');
 const {getPayment} = require('./../../');
 const {payViaPaymentRequest} = require('./../../');
 const {setupChannel} = require('./../macros');

package/test/tower_clientrpc-integration/test_get_connected_watchtowers.js

@@ -1,12 +1,9 @@
 const {test} = require('@alexbosworth/tap');
 
-const {closeChannel} = require('./../../');
 const {connectWatchtower} = require('./../../');
-const {createInvoice} = require('./../../');
 const {createCluster} = require('./../macros');
 const {delay} = require('./../macros');
 const {disconnectWatchtower} = require('./../../');
-const {getChannels} = require('./../../');
 const {getConnectedWatchtowers} = require('./../../');
 const {getTowerServerInfo} = require('./../../');
 const {openChannel} = require('./../../');

package/test/walletrpc-integration/test_fund_psbt.js

@@ -1,29 +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;
@@ -86,7 +112,7 @@ test(`Fund PSBT`, async ({end, equal}) => {
 
   equal(output.output_script, expectedOutput, 'Got expected output script');
 
-  const decoded = decodePsbt({psbt: funded.psbt});
+  const decoded = decodePsbt({ecp, psbt: funded.psbt});
 
   const [decodedInput] = decoded.inputs;
 
@@ -94,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();

package/test/walletrpc-integration/test_get_master_public_keys.js

@@ -0,0 +1,79 @@
+const bip32 = require('bip32');
+const bs58check = require('bs58check');
+const ecc = require('tiny-secp256k1')
+const {spawnLightningCluster} = require('ln-docker-daemons');
+const {test} = require('@alexbosworth/tap');
+
+const {createChainAddress} = require('./../../');
+const {getMasterPublicKeys} = require('./../../');
+
+const asHex = n => n.toString('hex');
+const BIP32Factory = bip32.default;
+const chainCodeFromMasterPublicKey = n => n.slice(13, 45);
+const firstKeyPath = 'm/0/0';
+const identityKeyName = 'act:6';
+const p2wpkhPath = `m/84'/0'/0'`;
+const publicKeyFromMasterPublicKey = n => n.slice(45, 78);
+
+// Getting master public keys should return a list of master public keys
+test(`Get master public keys`, async ({end, equal, strictSame}) => {
+  const [{id, kill, lnd}] = (await spawnLightningCluster({})).nodes;
+
+  const {fromPublicKey} = await BIP32Factory(ecc);
+
+  // This method is not supported on LND 0.13.3 and below
+  try {
+    const {keys} = await getMasterPublicKeys({lnd});
+
+    const [,, key] = keys;
+
+    // Check if extended keys are available
+    if (!key) {
+      await kill({});
+
+      return end();
+    }
+  } catch (err) {
+    strictSame(err, [501, 'GetMasterPublicKeysMethodNotSupported'], 'Got err');
+
+    await kill({});
+
+    return end();
+  }
+
+  try {
+    // Make a new address
+    const {address} = await createChainAddress({lnd});
+
+    // Get the list of accounts
+    const {keys} = await getMasterPublicKeys({lnd});
+
+    const masterP2wpkhKey = keys.find(n => n.derivation_path === p2wpkhPath);
+
+    // The address creation is reflected in the accounts metadata
+    equal(masterP2wpkhKey.external_key_count, [address].length, 'Key is used');
+
+    // Find the identity key master public key
+    const masterIdentityKey = keys.find(n => n.named === identityKeyName);
+
+    // Convert the key from base58 into its raw form
+    const rawKey = bs58check.decode(masterIdentityKey.extended_public_key);
+
+    const chainCode = chainCodeFromMasterPublicKey(rawKey);
+    const publicKey = publicKeyFromMasterPublicKey(rawKey);
+
+    // Make a bip32 object to derive from
+    const masterKey = fromPublicKey(publicKey, chainCode);
+
+    // Pull out the first key from the identity master public key
+    const identityKey = masterKey.derivePath(firstKeyPath);
+
+    equal(asHex(identityKey.publicKey), id, 'Got identity master public key');
+  } catch (err) {
+    equal(err, null, 'Expected no error');
+  }
+
+  await kill({});
+
+  return end();
+});

package/test/walletrpc-integration/test_partially_sign_psbt.js

@@ -8,6 +8,7 @@ const {extractTransaction} = require('psbt');
 const {finalizePsbt} = require('psbt');
 const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
+const tinysecp = require('tiny-secp256k1');
 const {Transaction} = require('bitcoinjs-lib');
 const {updatePsbt} = require('psbt');
 
@@ -30,6 +31,8 @@ const tokens = 1e6;
 
 // Partially signing a PSBT should result in a partially signed PSBT
 test(`Partially sign PSBT`, async ({end, equal, strictSame}) => {
+  const ecp = (await import('ecpair')).ECPairFactory(tinysecp);
+
   const {kill, nodes} = await spawnLightningCluster({size});
 
   const [control, target, remote] = nodes;
@@ -125,9 +128,9 @@ test(`Partially sign PSBT`, async ({end, equal, strictSame}) => {
     });
 
     // Decode the PSBTs to get signing key details
-    const controlDecoded = decodePsbt({psbt: controlFund.psbt});
-    const targetDecoded = decodePsbt({psbt: targetFund.psbt});
-    const remoteDecoded = decodePsbt({psbt: remoteFund.psbt});
+    const controlDecoded = decodePsbt({ecp, psbt: controlFund.psbt});
+    const targetDecoded = decodePsbt({ecp, psbt: targetFund.psbt});
+    const remoteDecoded = decodePsbt({ecp, psbt: remoteFund.psbt});
 
     // Collect all the BIP32 derivations
     const controlBip32Derivations = controlDecoded.inputs
@@ -155,8 +158,14 @@ test(`Partially sign PSBT`, async ({end, equal, strictSame}) => {
 
     const bip32Derivations = flatten(allDerivations);
 
+    // Exit early when derivations are not supported
+    if (!!bip32Derivations.filter(n => !n).length) {
+      await partiallySignPsbt({lnd: control.lnd, psbt: base.psbt});
+    }
+
     // Update the PSBT so that it has the consolidated details
     const updated = updatePsbt({
+      ecp,
       bip32_derivations: bip32Derivations,
       psbt: base.psbt,
       sighashes: inputs.map(input => ({
@@ -175,10 +184,13 @@ test(`Partially sign PSBT`, async ({end, equal, strictSame}) => {
     });
 
     // Finalize the signatures
-    const finalize = finalizePsbt({psbt: combinePsbts({psbts}).psbt});
+    const finalize = finalizePsbt({
+      ecp,
+      psbt: combinePsbts({ecp, psbts}).psbt,
+    });
 
     // Pull out the transaction
-    const {transaction} = extractTransaction({psbt: finalize.psbt});
+    const {transaction} = extractTransaction({ecp, psbt: finalize.psbt});
 
     // Publish the transaction
     await broadcastChainTransaction({lnd: control.lnd, transaction});

package/test/walletrpc-integration/test_sign_psbt.js

@@ -3,6 +3,7 @@ const {address} = require('bitcoinjs-lib');
 const {decodePsbt} = require('psbt');
 const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
+const tinysecp = require('tiny-secp256k1');
 const {Transaction} = require('bitcoinjs-lib');
 
 const {broadcastChainTransaction} = require('./../../');
@@ -29,6 +30,8 @@ const txIdHexByteLength = 64;
 
 // Signing a PSBT should result in a finalized PSBT
 test(`Sign PSBT`, async ({end, equal}) => {
+  const ecp = (await import('ecpair')).ECPairFactory(tinysecp);
+
   const {kill, nodes} = await spawnLightningCluster({size});
 
   const [control, target] = nodes;
@@ -72,7 +75,7 @@ test(`Sign PSBT`, async ({end, equal}) => {
 
   const tx = Transaction.fromHex(finalized.transaction);
 
-  const decoded = decodePsbt({psbt: finalized.psbt});
+  const decoded = decodePsbt({ecp, psbt: finalized.psbt});
 
   equal(!!decoded, true, 'Got a finalized PSBT');
   equal(!!tx, true, 'Got a raw signed transaction');