ln-service 53.9.2 → 53.10.0

package/CHANGELOG.md

@@ -1,6 +1,11 @@
 # Versions
 
-## 53.9.2
+## 53.10.0
+
+- `createChainAddress`: Add support for creating P2TR addresses
+- `getUtxos`: Add support for showing P2TR address types
+
+## 53.9.4
 
 - `getPendingPayments`: Add method to get payments in flight
 

package/README.md

@@ -514,12 +514,19 @@ Create a new receive address.
 
 Requires `address:write` permission
 
+LND 0.14.3 and below do not support p2tr addresses
+
     {
-      [format]: <Receive Address Type String> // "np2wpkh" || "p2wpkh"
+      [format]: <Receive Address Type String> // "np2wpkh" || "p2tr" || "p2wpkh"
       [is_unused]: <Get As-Yet Unused Address Bool>
       lnd: <Authenticated LND API Object>
     }
 
+    @returns via cbk or Promise
+    {
+      address: <Chain Address String>
+    }
+
 Example:
 
 ```node
@@ -3530,7 +3537,7 @@ Requires `onchain:write` permission
 
 Requires LND built with `walletrpc` tag
 
-This method is not supported in LND 0.14.2 and below
+This method is not supported in LND 0.14.3 and below
 
     {
       lnd: <Authenticated LND API Object>
@@ -3685,7 +3692,7 @@ Requires `offchain:write` permission
       [outgoing_channels]: [<Pay Out of Outgoing Channel Ids String>]
       [pathfinding_timeout]: <Time to Spend Finding a Route Milliseconds Number>
       [payment]: <Payment Identifier Hex String>
-      routes: [[{
+      [routes]: [[{
         [base_fee_mtokens]: <Base Routing Fee In Millitokens String>
         [channel]: <Standard Format Channel Id String>
         [cltv_delta]: <CLTV Blocks Delta Number>
@@ -5433,6 +5440,8 @@ const {secret} = await once(sub, 'confirmed');
 
 Subscribe to successful outgoing payments
 
+Payments may be omitted if LND does not finalize the payment record
+
 Requires `offchain:read` permission
 
 Note: Method not supported on LND 0.13.4 and below

package/package.json

@@ -11,14 +11,14 @@
     "cors": "2.8.5",
     "express": "4.17.3",
     "invoices": "2.0.4",
-    "lightning": "5.8.1",
+    "lightning": "5.9.0",
     "macaroon": "3.0.4",
     "morgan": "1.10.0",
     "ws": "8.5.0"
   },
   "description": "Interaction helper for your Lightning Network daemon",
   "devDependencies": {
-    "@alexbosworth/tap": "15.0.10",
+    "@alexbosworth/tap": "15.0.11",
     "@alexbosworth/node-fetch": "2.6.2",
     "async": "3.2.3",
     "asyncjs-util": "1.2.8",
@@ -28,8 +28,8 @@
     "bn.js": "5.2.0",
     "bs58check": "2.1.2",
     "ecpair": "2.0.1",
-    "ln-docker-daemons": "2.2.4",
-    "p2tr": "1.2.0",
+    "ln-docker-daemons": "2.2.6",
+    "p2tr": "1.3.0",
     "portfinder": "1.0.28",
     "psbt": "2.0.0",
     "rimraf": "3.0.2",
@@ -69,5 +69,5 @@
     "integration-test-0.12.0": "DOCKER_LND_VERSION=v0.12.0-beta npm run test",
     "test": "echo $DOCKER_LND_VERSION && tap -j 2 --branches=1 --functions=1 --lines=1 --statements=1 -t 200 test/autopilotrpc-integration/*.js test/chainrpc-integration/*.js test/integration/*.js test/invoicesrpc-integration/*.js test/routerrpc-integration/*.js test/signerrpc-integration/*.js test/tower_clientrpc-integration/*.js test/tower_serverrpc-integration/*.js test/walletrpc-integration/*.js"
   },
-  "version": "53.9.2"
+  "version": "53.10.0"
 }

package/test/chainrpc-integration/test_subscribe_to_blocks.js

@@ -10,7 +10,6 @@ const {delay} = require('./../macros');
 const {generateBlocks} = require('./../macros');
 const {getHeight} = require('./../../');
 const {getChainBalance} = require('./../../');
-const {spawnLnd} = require('./../macros');
 const {subscribeToBlocks} = require('./../../');
 const {waitForTermination} = require('./../macros');
 

package/test/chainrpc-integration/test_subscribe_to_chain_address.js

@@ -11,7 +11,6 @@ const {getChainTransactions} = require('./../../');
 const {getHeight} = require('./../../');
 const {mineTransaction} = require('./../macros');
 const {sendToChainAddress} = require('./../../');
-const {spawnLnd} = require('./../macros');
 const {subscribeToChainAddress} = require('./../../');
 const {waitForTermination} = require('./../macros');
 

package/test/integration/test_create_chain_address.js

@@ -7,6 +7,7 @@ const {createChainAddress} = require('./../../');
 const formats = ['np2wpkh', 'p2wpkh'];
 const p2shAddressVersion = 196;
 const pkHashByteLength = 20;
+const prefixForV1 = 'bcrt1p';
 const regtestBech32AddressHrp = 'bcrt';
 
 // Creating addresses should result in addresses
@@ -34,6 +35,14 @@ test(`Create address results in address creation`, async ({end, equal}) => {
   equal(np2wpkh.address, unusedNp2wpkh.address, 'Nested is reused');
   equal(p2wpkh.address, unusedP2wpkh.address, 'Native is reused');
 
+  try {
+    const {address} = await createChainAddress({lnd, format: 'p2tr'});
+
+    equal(address.startsWith(prefixForV1), true, 'A taproot address is made');
+  } catch (err) {
+    // LND 0.14.3 and below do not support TR addresses
+  }
+
   await kill({});
 
   return end();

package/test/integration/test_get_pending_force.js

@@ -178,7 +178,7 @@ test(`Get pending channels`, async ({end, equal}) => {
   equal(forceClose.received, 0, 'No receive amount');
   equal(forceClose.recovered_tokens, undefined, 'No recovered amount');
 
-  // LND 0.14.2 and below do not support remote balance info
+  // LND 0.14.3 and below do not support remote balance info
   if (!!forceClose.remote_balance) {
     equal(forceClose.remote_balance, giftTokens, 'Got gift remote balance');
   } else {

package/test/walletrpc-integration/test_fund_psbt.js

@@ -1,9 +1,16 @@
 const asyncRetry = require('async/retry');
 const {address} = require('bitcoinjs-lib');
+const {controlBlock} = require('p2tr');
 const {createPsbt} = require('psbt');
 const {decodePsbt} = require('psbt');
+const {hashForTree} = require('p2tr');
+const {leafHash} = require('p2tr');
 const {networks} = require('bitcoinjs-lib');
+const {pointAdd} = require('tiny-secp256k1');
+const {privateAdd} = require('tiny-secp256k1');
+const {script} = require('bitcoinjs-lib');
 const {signHash} = require('p2tr');
+const {signSchnorr} = require('tiny-secp256k1');
 const {spawnLightningCluster} = require('ln-docker-daemons');
 const {test} = require('@alexbosworth/tap');
 const tinysecp = require('tiny-secp256k1');
@@ -20,14 +27,18 @@ const {sendToChainAddress} = require('./../../');
 const {signPsbt} = require('./../../');
 
 const chainAddressRowType = 'chain_address';
+const {compile} = script;
 const confirmationCount = 6;
 const count = 100;
+const defaultInternalKey = '0350929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0';
 const description = 'description';
+const {from} = Buffer;
 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 OP_CHECKSIG = 172;
 const regtestBech32AddressHrp = 'bcrt';
 const smallTokens = 2e5;
 const times = 20;
@@ -108,7 +119,198 @@ 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
+  // A Taproot script can be funded and spent with internal key + script hash
+  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 witnessScript = compile([unusedKey.publicKey.slice(1), OP_CHECKSIG]);
+
+    const branches = [{script: witnessScript.toString('hex')}];
+
+    const {hash} = hashForTree({branches});
+
+    // Create a combined key using public key material
+    const combinedPoint = pointAdd(keyPair1.publicKey, keyPair2.publicKey);
+
+    const output = v1OutputScript({
+      hash,
+      internal_key: Buffer.from(combinedPoint).toString('hex'),
+    });
+
+    const [utxo] = (await getUtxos({lnd})).utxos.reverse();
+
+    // Make a PSBT paying to the Taproot output
+    const {psbt} = createPsbt({
+      outputs: [{tokens, script: output.script}],
+      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,
+        [hexAsBuffer(output.script)],
+        [tokens],
+        Transaction.SIGHASH_DEFAULT,
+      );
+    });
+
+    // Ready for private key combining
+    const combinedKey = privateAdd(keyPair1.privateKey, keyPair2.privateKey);
+
+    const signedInput = signHash({
+      hash,
+      private_key: Buffer.from(combinedKey).toString('hex'),
+      public_key: Buffer.from(combinedPoint).toString('hex'),
+      sign_hash: hashToSign.toString('hex'),
+    });
+
+    const signature = hexAsBuffer(signedInput.signature);
+
+    // Add the signature to the input
+    tx.ins.forEach((input, i) => tx.setWitness(i, [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');
+  }
+
+  // A Taproot script output should be funded and spent with script
+  try {
+    await generate({count});
+
+    const keyPair = ecp.makeRandom({network: networks.regtest});
+
+    const witnessScript = compile([keyPair.publicKey.slice(1), OP_CHECKSIG]);
+
+    const branches = [{script: witnessScript.toString('hex')}];
+
+    const {hash} = hashForTree({branches});
+
+    const output = v1OutputScript({hash, internal_key: defaultInternalKey});
+
+    const [utxo] = (await getUtxos({lnd})).utxos.reverse();
+
+    // Make a PSBT paying to the Taproot output
+    const {psbt} = createPsbt({
+      outputs: [{tokens, script: output.script}],
+      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,
+        [hexAsBuffer(output.script)],
+        [tokens],
+        Transaction.SIGHASH_DEFAULT,
+        hexAsBuffer(leafHash({script: witnessScript.toString('hex')}).hash),
+      );
+    });
+
+    const signature = from(signSchnorr(hashToSign, keyPair.privateKey));
+
+    const {block} = controlBlock({
+      external_key: output.external_key,
+      leaf_script: witnessScript.toString('hex'),
+      script_branches: branches,
+    });
+
+    // Add the signature to the input
+    tx.ins.forEach((input, i) => {
+      return tx.setWitness(i, [
+        signature,
+        witnessScript,
+        hexAsBuffer(block),
+      ]);
+    });
+
+    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');
+  }
+
+  // A Taproot output should be funded for a regular key spend
   try {
     await generate({count});