ln-service 57.11.0 → 57.12.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Versions
 
+## 57.12.0
+
+- `createFundedPsbt`: Add method to create a funded PSBT given inputs/outputs
+
 ## 57.11.0
 
 - `getChannel`, `getNetworkGraph`, `getNode`: Add

package/README.md

@@ -147,6 +147,8 @@ for `unlocker` methods.
 - [closeChannel](#closechannel) - Terminate an open channel
 - [connectWatchtower](#connectwatchtower) - Connect a watchtower
 - [createChainAddress](#createchainaddress) - Get a chain address to receive at
+- [createFundedPsbt](#createfundedpsbt): Create a funded PSBT given inputs and
+    outputs
 - [createHodlInvoice](#createhodlinvoice) - Make a HODL HTLC invoice
 - [createInvoice](#createinvoice) - Make a regular invoice
 - [createSeed](#createseed) - Generate a wallet seed for a new wallet
@@ -688,6 +690,55 @@ const format = 'p2wpkh';
 const {address} = await createChainAddress({format, lnd});
 ```
 
+### createFundedPsbt
+
+Create an unsigned funded PSBT given inputs or outputs
+
+When specifying local inputs, they must be locked before using
+
+`utxo_selection` methods: 'largest', 'random'
+
+Requires `onchain:write` permission
+
+Requires LND built with `walletrpc` tag
+
+This method is not supported on LND 0.17.5 or below
+
+    {
+      [fee_tokens_per_vbyte]: <Chain Fee Tokens Per Virtual Byte Number>
+      [inputs]: [{
+        [sequence]: <Sequence Number>
+        transaction_id: <Unspent Transaction Id Hex String>
+        transaction_vout: <Unspent Transaction Output Index Number>
+      }]
+      lnd: <Authenticated LND API Object>
+      [min_confirmations]: <Select Inputs With Minimum Confirmations Number>
+      [outputs]: [{
+        [is_change]: <Use This Output For Change Bool>
+        script: <Output Script Hex String>
+        tokens: <Send Tokens Tokens Number>
+      }]
+      [target_confirmations]: <Blocks To Wait for Confirmation Number>
+      [timelock]: <Spendable Lock Time on Transaction Number>
+      [utxo_selection]: <Select Inputs Using Selection Methodology Type String>
+      [version]: <Transaction Version Number>
+    }
+
+    @returns via cbk or Promise
+    {
+      psbt: <Unsigned PSBT Hex String>
+    }
+
+```node
+const {createFundedPsbt} = require('ln-service');
+
+const script = '00';
+const tokens = 1e6;
+
+// Create an unsigned PSBT that sends 1mm to an output script
+const {psbt} = await createFundedPsbt({lnd, outputs: [{script, tokens}]});
+```
+
 ### createHodlInvoice
 
 Create HODL invoice. This invoice will not settle automatically when an

package/index.js

@@ -10,6 +10,7 @@ const {changePassword} = require('lightning');
 const {closeChannel} = require('lightning');
 const {connectWatchtower} = require('lightning');
 const {createChainAddress} = require('lightning');
+const {createFundedPsbt} = require('lightning');
 const {createHodlInvoice} = require('lightning');
 const {createInvoice} = require('lightning');
 const {createSeed} = require('lightning');
@@ -174,6 +175,7 @@ module.exports = {
   closeChannel,
   connectWatchtower,
   createChainAddress,
+  createFundedPsbt,
   createHodlInvoice,
   createInvoice,
   createSeed,

package/package.json

@@ -9,7 +9,7 @@
   "dependencies": {
     "bolt07": "1.8.4",
     "invoices": "3.0.0",
-    "lightning": "10.11.0",
+    "lightning": "10.12.0",
     "macaroon": "3.0.4"
   },
   "description": "Interaction helper for your Lightning Network daemon",
@@ -24,11 +24,11 @@
     "bn.js": "5.2.1",
     "bs58check": "3.0.1",
     "ecpair": "2.1.0",
-    "ln-docker-daemons": "6.0.15",
+    "ln-docker-daemons": "6.0.16",
     "p2tr": "2.0.0",
     "portfinder": "1.0.32",
     "psbt": "3.0.0",
-    "rimraf": "5.0.5",
+    "rimraf": "5.0.7",
     "secp256k1": "5.0.0",
     "tiny-secp256k1": "2.2.3",
     "uuid": "9.0.1",
@@ -71,5 +71,5 @@
     "integration-test-0.14.4": "DOCKER_LND_VERSION=v0.14.4-beta npm run test",
     "test": "echo $DOCKER_LND_VERSION && node test/runner"
   },
-  "version": "57.11.0"
+  "version": "57.12.0"
 }

package/test/integration/test_get_chain_transactions.js

@@ -65,13 +65,6 @@ test(`Get chain transactions`, async () => {
   equal(tx.tokens, 5000000000, 'Got coinbase reward tokens');
   equal(!!tx.transaction, true, 'Got transaction hex');
 
-  const onlyAfter = await getChainTransactions({
-    lnd,
-    after: tx.confirmation_height,
-  });
-
-  equal(onlyAfter.transactions.length, [].length, 'No txs after');
-
   const onlyBefore = await getChainTransactions({lnd, before: 2});
 
   equal(onlyBefore.transactions.length < 100, true, 'Got before txs');

package/test/integration/test_open_channels.js

@@ -47,6 +47,8 @@ test(`Open channels`, async () => {
     await asyncRetry({interval, times}, async () => {
       const lnds = [lnd, target.lnd, remote.lnd];
 
+      await generate({});
+
       const heights = await asyncMap(lnds, async lnd => {
         return (await getHeight({lnd})).current_block_height;
       });

package/test/routerrpc-integration/test_get_route_through_hops.js

@@ -33,14 +33,24 @@ test(`Get route through hops`, async () => {
 
   const [{generate, lnd}, target, remote] = nodes;
 
-  await target.generate({count: maturity});
-
   const controlToTargetChan = await setupChannel({generate, lnd, to: target});
 
-  const targetToRemoteChan = await setupChannel({
-    generate: target.generate,
-    lnd: target.lnd,
-    to: remote,
+  await generate({});
+
+  await asyncRetry({interval, times}, async () => {
+    await generate({});
+
+    await addPeer({
+      lnd: target.lnd,
+      public_key: remote.id,
+      socket: remote.socket,
+    });
+
+    const targetToRemoteChan = await setupChannel({
+      generate: target.generate,
+      lnd: target.lnd,
+      to: remote,
+    });
   });
 
   await target.generate({count: confirmationCount});

package/test/walletrpc-integration/test_create_funded_psbt.js

@@ -0,0 +1,141 @@
+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 {spawnLightningCluster} = require('ln-docker-daemons');
+
+const {broadcastChainTransaction} = require('./../../');
+const {createChainAddress} = require('./../../');
+const {createFundedPsbt} = require('./../../');
+const {getChainTransactions} = require('./../../');
+const {getUtxos} = require('./../../');
+const {lockUtxo} = require('./../../');
+const {signPsbt} = require('./../../');
+
+const bufferAsHex = buffer => buffer.toString('hex');
+const {concat} = Buffer;
+const count = 100;
+const format = 'p2tr';
+const {fromBech32} = address;
+const interval = retryCount => 10 * Math.pow(2, retryCount);
+const OP_1 = Buffer.from([81]);
+const push32 = Buffer.from([32]);
+const sequence = 0;
+const timelock = 1;
+const times = 20;
+const version = 1;
+
+// Creating a funded PSBT should result in a funded PSBT
+test(`Create funded PSBT`, async () => {
+  const {kill, nodes} = await spawnLightningCluster({});
+
+  const [{generate, lnd}] = nodes;
+
+  await generate({count});
+
+  try {
+    await createFundedPsbt({lnd});
+  } catch (err) {
+    if (!Array.isArray(err)) {
+      await kill({});
+
+      equal(err, null, 'Expected array error');
+
+      return;
+    }
+
+    const [code, message] = err;
+
+  // LND 0.17.5 and before do not support the create funded PSBT method
+    if (code === 501) {
+      await kill({});
+
+      equal(message, 'CreateFundedPsbtMethodNotSupported', 'Unsupported');
+
+      return;
+    }
+  }
+
+  try {
+    const {address} = await createChainAddress({format, lnd});
+    const {utxos} = await getUtxos({lnd});
+
+    const outputScriptElements = [OP_1, push32, fromBech32(address).data];
+    const [utxo] = utxos;
+
+    const output = bufferAsHex(concat(outputScriptElements));
+
+    // Creating a funded PSBT requires pre-locking the inputs
+    const lock = await lockUtxo({
+      lnd,
+      transaction_id: utxo.transaction_id,
+      transaction_vout: utxo.transaction_vout,
+    });
+
+    const {psbt} = await createFundedPsbt({
+      fee_tokens_per_vbyte: 50,
+      lnd,
+      inputs: [{
+        sequence,
+        transaction_id: utxo.transaction_id,
+        transaction_vout: utxo.transaction_vout,
+      }],
+      outputs: [{is_change: true, script: output, tokens: 1}],
+      timelock,
+      version,
+    });
+
+    const signed = await signPsbt({lnd, psbt});
+
+    // Make sure this tx can be published
+    await broadcastChainTransaction({lnd, transaction: signed.transaction});
+
+    // Make sure the publishing succeeded by looking for it in chain txns
+    const {transactions} = await getChainTransactions({lnd});
+
+    const [{transaction}] = transactions;
+
+    equal(signed.transaction, transaction, 'Transaction is broadcast');
+
+    const tx = componentsOfTransaction({transaction});
+
+    // Check all the elements of the 1 in 1 out transaction
+    equal(tx.inputs.length, [utxo].length, 'Used a single input');
+    equal(tx.inputs[0].sequence, sequence, 'Used specified input sequence');
+    equal(tx.inputs[0].id, utxo.transaction_id, 'Used specified tx id');
+    equal(tx.inputs[0].vout, utxo.transaction_vout, 'Used specified tx vout');
+    equal(tx.locktime, timelock, 'Used specified timelock value');
+    equal(tx.outputs.length, [output].length, 'Used a single output');
+    equal(tx.outputs[0].script, output, 'Output used output script');
+    equal(tx.outputs[0].tokens, 4999993913, 'Output spent all tokens');
+    equal(tx.version, version, 'Used specified version value');
+
+    // Create a 1 in 2 out transaction, so one with change
+    const withChange = await asyncRetry({interval, times}, async () => {
+      await generate({});
+
+      return await createFundedPsbt({
+        lnd,
+        outputs: [{script: output, tokens: 500}],
+      });
+    });
+
+    const signedChange = await signPsbt({lnd, psbt: withChange.psbt});
+
+    const signedTx = componentsOfTransaction({
+      transaction: signedChange.transaction,
+    });
+
+    equal(signedTx.outputs.length, 2, 'Change output created');
+  } catch (err) {
+    await kill({});
+
+    equal(err, null, 'No error expected');
+  }
+
+  await kill({});
+
+  return;
+});