ln-service 53.7.2 → 53.9.0

package/test/routerrpc-integration/test_pay_via_payment_request.js

@@ -22,99 +22,111 @@ test(`Pay via payment request`, async ({end, equal, rejects, strictSame}) => {
 
   const [{generate, lnd}, target, remote] = nodes;
 
-  const channel = await setupChannel({generate, lnd, to: target});
-
-  // Make sure that an error is returned when there is no route
   try {
-    const {request} = await createInvoice({tokens, lnd: remote.lnd});
+    await generate({count: 100});
 
-    await rejects(
-      payViaPaymentRequest({lnd, request}),
-      [503, 'PaymentPathfindingFailedToFindPossibleRoute'],
-      'A payment with no route returns an error'
-    );
-  } catch (err) {
-    equal(err, null, 'Expected no error creating invoice');
-  }
+    const channel = await setupChannel({generate, lnd, to: target});
 
-  const remoteChan = await setupChannel({
-    lnd: target.lnd,
-    generate: target.generate,
-    to: remote,
-  });
+    // Make sure that an error is returned when there is no route
+    try {
+      const {request} = await createInvoice({tokens, lnd: remote.lnd});
 
-  await addPeer({lnd, public_key: remote.id, socket: remote.socket});
-
-  await waitForRoute({lnd, tokens, destination: remote.id});
+      await rejects(
+        payViaPaymentRequest({lnd, request}),
+        [503, 'PaymentPathfindingFailedToFindPossibleRoute'],
+        'A payment with no route returns an error'
+      );
+    } catch (err) {
+      equal(err, null, 'Expected no error creating invoice');
+    }
 
-  // When a route exists, payment is successful
-  try {
-    const commitTxFee = channel.commit_transaction_fee;
-    const height = (await getWalletInfo({lnd})).current_block_height;
-    const invoice = await createInvoice({tokens, lnd: remote.lnd});
-
-    const paid = await payViaPaymentRequest({
-      lnd,
-      max_timeout_height: height + 40 + 43,
-      messages: [{type: tlvType, value: tlvValue}],
-      request: invoice.request,
+    await addPeer({
+      lnd: target.lnd,
+      public_key: remote.id,
+      socket: remote.socket,
     });
 
-    equal(paid.confirmed_at > start, true, 'Got confirmation date');
-    equal(paid.fee, 1, 'Fee tokens paid');
-    equal(paid.fee_mtokens, '1000', 'Fee mtokens tokens paid');
-    equal(paid.id, invoice.id, 'Payment hash is equal on both sides');
-    equal(paid.mtokens, '101000', 'Paid mtokens');
-    equal(paid.secret, invoice.secret, 'Paid for invoice secret');
-
-    paid.hops.forEach(n => {
-      equal(n.timeout === height + 40 || n.timeout === height + 43, true);
-
-      delete n.timeout;
-
-      return;
+    const remoteChan = await setupChannel({
+      lnd: target.lnd,
+      generate: target.generate,
+      to: remote,
     });
 
-    const expectedHops = [
-      {
-        channel: channel.id,
-        channel_capacity: 1000000,
-        fee: 1,
-        fee_mtokens: '1000',
-        forward: 100,
-        forward_mtokens: invoice.mtokens,
-        public_key: target.id,
-      },
-      {
-        channel: remoteChan.id,
-        channel_capacity: 1000000,
-        fee: 0,
-        fee_mtokens: '0',
-        forward: 100,
-        forward_mtokens: '100000',
-        public_key: remote.id,
-      },
-    ];
-
-    strictSame(paid.hops, expectedHops, 'Hops are returned');
-
-    const {payments} = await getInvoice({id: paid.id, lnd: remote.lnd});
-
-    if (!!payments.length) {
-      const [payment] = payments;
-
-      if (!!payment.messages.length) {
-        const [message] = payment.messages;
-
-        equal(message.type, tlvType, 'Got TLV message type');
-        equal(message.value, tlvValue, 'Got TLV message value');
+    await addPeer({lnd, public_key: remote.id, socket: remote.socket});
+
+    await waitForRoute({lnd, tokens, destination: remote.id});
+
+    // When a route exists, payment is successful
+    try {
+      const commitTxFee = channel.commit_transaction_fee;
+      const height = (await getWalletInfo({lnd})).current_block_height;
+      const invoice = await createInvoice({tokens, lnd: remote.lnd});
+
+      const paid = await payViaPaymentRequest({
+        lnd,
+        max_timeout_height: height + 40 + 43,
+        messages: [{type: tlvType, value: tlvValue}],
+        request: invoice.request,
+      });
+
+      equal(paid.confirmed_at > start, true, 'Got confirmation date');
+      equal(paid.fee, 1, 'Fee tokens paid');
+      equal(paid.fee_mtokens, '1000', 'Fee mtokens tokens paid');
+      equal(paid.id, invoice.id, 'Payment hash is equal on both sides');
+      equal(paid.mtokens, '101000', 'Paid mtokens');
+      equal(paid.secret, invoice.secret, 'Paid for invoice secret');
+
+      paid.hops.forEach(n => {
+        equal(n.timeout === height + 40 || n.timeout === height + 43, true);
+
+        delete n.timeout;
+
+        return;
+      });
+
+      const expectedHops = [
+        {
+          channel: channel.id,
+          channel_capacity: 1000000,
+          fee: 1,
+          fee_mtokens: '1000',
+          forward: 100,
+          forward_mtokens: invoice.mtokens,
+          public_key: target.id,
+        },
+        {
+          channel: remoteChan.id,
+          channel_capacity: 1000000,
+          fee: 0,
+          fee_mtokens: '0',
+          forward: 100,
+          forward_mtokens: '100000',
+          public_key: remote.id,
+        },
+      ];
+
+      strictSame(paid.hops, expectedHops, 'Hops are returned');
+
+      const {payments} = await getInvoice({id: paid.id, lnd: remote.lnd});
+
+      if (!!payments.length) {
+        const [payment] = payments;
+
+        if (!!payment.messages.length) {
+          const [message] = payment.messages;
+
+          equal(message.type, tlvType, 'Got TLV message type');
+          equal(message.value, tlvValue, 'Got TLV message value');
+        }
       }
+    } catch (err) {
+      equal(err, null, 'Expected no error paying payment request');
     }
   } catch (err) {
-    equal(err, null, 'Expected no error paying payment request');
+    equal(err, 'Expected no errors');
+  } finally {
+    await kill({});
   }
 
-  await kill({});
-
   return end();
 });

package/test/routerrpc-integration/test_probe_for_route.js

@@ -31,10 +31,12 @@ test('Probe for route', async ({end, equal, strictSame}) => {
 
   const [{generate, lnd}, target, remote] = nodes;
 
-  // Send coins to remote so that it can accept a channel
-  await remote.generate({count});
-
   try {
+    // Send coins to remote so that it can accept a channel
+    await remote.generate({count});
+
+    await addPeer({lnd, public_key: remote.id, socket: remote.socket});
+
     await setupChannel({
       generate,
       lnd,
@@ -50,8 +52,6 @@ test('Probe for route', async ({end, equal, strictSame}) => {
       to: remote,
     });
 
-    await addPeer({lnd, public_key: remote.id, socket: remote.socket});
-
     const invoice = await createInvoice({tokens, lnd: remote.lnd});
 
     await delay(1000);

package/test/routerrpc-integration/test_subscribe_to_forward_requests.js

@@ -10,7 +10,6 @@ const {deleteForwardingReputations} = require('./../../');
 const {getHeight} = require('./../../');
 const {getInvoice} = require('./../../');
 const {getPayment} = require('./../../');
-const {getWalletVersion} = require('./../../');
 const {payViaPaymentRequest} = require('./../../');
 const {subscribeToForwardRequests} = require('./../../');
 const {subscribeToPayViaRequest} = require('./../../');

package/test/routerrpc-integration/test_subscribe_to_forwards.js

@@ -17,7 +17,7 @@ const {subscribeToForwards} = require('./../../');
 const anchorsFeatureBit = 23;
 const interval = 10;
 const size = 3;
-const times = 100;
+const times = 1000;
 const tokens = 100;
 
 // Subscribing to forwards should show forwarding events
@@ -41,7 +41,16 @@ test('Subscribe to forwards', async ({end, equal, rejects, strictSame}) => {
       to: remote,
     });
 
-    await addPeer({lnd, public_key: remote.id, socket: remote.socket});
+    await asyncRetry({interval, times}, async () => {
+      await addPeer({
+        lnd,
+        public_key: remote.id,
+        retry_count: 1,
+        retry_delay: 1,
+        socket: remote.socket,
+        timeout: 1000,
+      });
+    });
 
     await delay(3000);
 

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,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();

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

@@ -158,6 +158,11 @@ 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,