lightning 10.11.0 → 10.12.0

package/CHANGELOG.md

@@ -1,6 +1,10 @@
 # Versions
 
-## 10.11.0
+## 10.12.0
+
+- `createFundedPsbt`: Add method to create a funded PSBT given inputs/outputs
+
+## 10.11.1
 
 - `getChannel`, `getNetworkGraph`, `getNode`: Add
     `inbound_base_discount_mtokens` and `inbound_rate_discount`

package/README.md

@@ -103,6 +103,8 @@ variables set:
     new watchtower.
 - [createChainAddress](https://github.com/alexbosworth/ln-service#createchainaddress): Generate
     a chain address to receive on-chain funds.
+- [createFundedPsbt](https://github.com/alexbosworth/ln-service#createfundedpsbt):
+    Create a funded PSBT given inputs and outputs
 - [createHodlInvoice](https://github.com/alexbosworth/ln-service#createhodlinvoice): Make a new
     off-chain invoice that will not automatically accept payment.
 - [createInvoice](https://github.com/alexbosworth/ln-service#createinvoice): Make a new off-chain

package/grpc/protos/lightning.proto

@@ -4369,6 +4369,16 @@ message FeeReportResponse {
     uint64 month_fee_sum = 4;
 }
 
+message InboundFee {
+    // The inbound base fee charged regardless of the number of milli-satoshis
+    // received in the channel. By default, only negative values are accepted.
+    int32 base_fee_msat = 1;
+
+    // The effective inbound fee rate in micro-satoshis (parts per million).
+    // By default, only negative values are accepted.
+    int32 fee_rate_ppm = 2;
+}
+
 message PolicyUpdateRequest {
     oneof scope {
         // If set, then this update applies to all currently active channels.
@@ -4402,8 +4412,9 @@ message PolicyUpdateRequest {
     // If true, min_htlc_msat is applied.
     bool min_htlc_msat_specified = 8;
 
-    int32 inbound_base_fee_msat = 10;
-    int32 inbound_fee_rate_ppm = 11;
+    // Optional inbound fee. If unset, the previously set value will be
+    // retained [EXPERIMENTAL].
+    InboundFee inbound_fee = 10;
 }
 
 enum UpdateFailure {

package/index.js

@@ -10,6 +10,7 @@ const {changePassword} = require('./lnd_methods');
 const {closeChannel} = require('./lnd_methods');
 const {connectWatchtower} = require('./lnd_methods');
 const {createChainAddress} = require('./lnd_methods');
+const {createFundedPsbt} = require('./lnd_methods');
 const {createHodlInvoice} = require('./lnd_methods');
 const {createInvoice} = require('./lnd_methods');
 const {createSeed} = require('./lnd_methods');
@@ -169,6 +170,7 @@ module.exports = {
   closeChannel,
   connectWatchtower,
   createChainAddress,
+  createFundedPsbt,
   createHodlInvoice,
   createInvoice,
   createSeed,

package/lnd_methods/index.js

@@ -9,6 +9,7 @@ const {changePassword} = require('./unauthenticated');
 const {closeChannel} = require('./onchain');
 const {connectWatchtower} = require('./offchain');
 const {createChainAddress} = require('./address');
+const {createFundedPsbt} = require('./onchain');
 const {createHodlInvoice} = require('./invoices');
 const {createInvoice} = require('./invoices');
 const {createSeed} = require('./unauthenticated');
@@ -167,6 +168,7 @@ module.exports = {
   closeChannel,
   connectWatchtower,
   createChainAddress,
+  createFundedPsbt,
   createHodlInvoice,
   createInvoice,
   createSeed,

package/lnd_methods/info/get_channel.d.ts

@@ -1,6 +1,7 @@
 import {
   AuthenticatedLightningArgs,
   AuthenticatedLightningMethod,
+  ChannelPolicy,
 } from '../../typescript';
 
 export type GetChannelArgs = AuthenticatedLightningArgs<{
@@ -13,24 +14,7 @@ export type GetChannelResult = {
   capacity: number;
   /** Standard Format Channel Id */
   id: string;
-  policies: {
-    /** Base Fee Millitokens */
-    base_fee_mtokens?: string;
-    /** Locktime Delta */
-    cltv_delta?: number;
-    /** Fees Charged Per Million Millitokens */
-    fee_rate?: number;
-    /** Channel Is Disabled */
-    is_disabled?: boolean;
-    /** Maximum HTLC Millitokens Value */
-    max_htlc_mtokens?: string;
-    /** Minimum HTLC Millitokens Value */
-    min_htlc_mtokens?: string;
-    /** Node Public Key */
-    public_key: string;
-    /** Policy Last Updated At ISO 8601 Date */
-    updated_at?: string;
-  }[];
+  policies: ChannelPolicy[];
   /** Transaction Id Hex */
   transaction_id: string;
   /** Transaction Output Index */

package/lnd_methods/info/get_network_graph.d.ts

@@ -1,43 +1,29 @@
-import {AuthenticatedLnd} from '../../lnd_grpc';
-import {AuthenticatedLightningMethod} from '../../typescript';
+import type {AuthenticatedLnd} from '../../lnd_grpc';
+import type {
+  AuthenticatedLightningMethod,
+  ChannelPolicy,
+} from '../../typescript';
 
 export type GetNetworkGraphResult = {
-  channels: {
+  channels: Array<{
     /** Channel Capacity Tokens */
     capacity: number;
     /** Standard Format Channel Id */
     id: string;
-    policies: {
-      /** Base Fee Millitokens */
-      base_fee_mtokens?: string;
-      /** CLTV Height Delta */
-      cltv_delta?: number;
-      /** Fee Rate In Millitokens Per Million */
-      fee_rate?: number;
-      /** Edge is Disabled */
-      is_disabled?: boolean;
-      /** Maximum HTLC Millitokens */
-      max_htlc_mtokens?: string;
-      /** Minimum HTLC Millitokens */
-      min_htlc_mtokens?: string;
-      /** Public Key */
-      public_key: string;
-      /** Last Update Epoch ISO 8601 Date */
-      updated_at?: string;
-    }[];
+    policies: ChannelPolicy[];
     /** Funding Transaction Id */
     transaction_id: string;
     /** Funding Transaction Output Index */
     transaction_vout: number;
     /** Last Update Epoch ISO 8601 Date */
     updated_at?: string;
-  }[];
-  nodes: {
+  }>;
+  nodes: Array<{
     /** Name */
     alias: string;
     /** Hex Encoded Color */
     color: string;
-    features: {
+    features: Array<{
       /** BOLT 09 Feature Bit */
       bit: number;
       /** Feature is Known */
@@ -46,14 +32,14 @@ export type GetNetworkGraphResult = {
       is_required: boolean;
       /** Feature Type */
       type: string;
-    }[];
+    }>;
     /** Node Public Key */
     public_key: string;
     /** Network Addresses and Ports */
     sockets: string[];
     /** Last Updated ISO 8601 Date */
     updated_at: string;
-  }[];
+  }>;
 };
 
 /**

package/lnd_methods/info/get_node.d.ts

@@ -1,6 +1,7 @@
-import {
+import type {
   AuthenticatedLightningArgs,
   AuthenticatedLightningMethod,
+  ChannelPolicy,
 } from '../../typescript';
 
 export type GetNodeArgs = AuthenticatedLightningArgs<{
@@ -17,39 +18,22 @@ export type GetNodeResult = {
   capacity: number;
   /** Known Node Channels */
   channel_count: number;
-  channels?: {
+  channels?: Array<{
     /** Maximum Tokens */
     capacity: number;
     /** Standard Format Channel Id */
     id: string;
-    policies: {
-      /** Base Fee Millitokens */
-      base_fee_mtokens?: string;
-      /** Locktime Delta */
-      cltv_delta?: number;
-      /** Fees Charged Per Million Millitokens */
-      fee_rate?: number;
-      /** Channel Is Disabled */
-      is_disabled?: boolean;
-      /** Maximum HTLC Millitokens Value */
-      max_htlc_mtokens?: string;
-      /** Minimum HTLC Millitokens Value */
-      min_htlc_mtokens?: string;
-      /** Node Public Key */
-      public_key: string;
-      /** Policy Last Updated At ISO 8601 Date */
-      updated_at?: string;
-    }[];
+    policies: ChannelPolicy[];
     /** Transaction Id Hex */
     transaction_id: string;
     /** Transaction Output Index */
     transaction_vout: number;
     /** Channel Last Updated At ISO 8601 Date */
     updated_at?: string;
-  }[];
+  }>;
   /** RGB Hex Color */
   color: string;
-  features: {
+  features: Array<{
     /** BOLT 09 Feature Bit */
     bit: number;
     /** Feature is Known */
@@ -58,13 +42,13 @@ export type GetNodeResult = {
     is_required: boolean;
     /** Feature Type */
     type: string;
-  }[];
-  sockets: {
+  }>;
+  sockets: Array<{
     /** Host and Port */
     socket: string;
     /** Socket Type */
     type: string;
-  }[];
+  }>;
   /** Last Known Update ISO 8601 Date */
   updated_at?: string;
 };

package/lnd_methods/macaroon/methods.json

@@ -42,6 +42,10 @@
     "method": "NewAddress",
     "type": "default"
   },
+  "createFundedPsbt": {
+    "method": "FundPsbt",
+    "type": "wallet"
+  },
   "createHodlInvoice": {
     "depends_on": ["createChainAddress"],
     "method": "AddHoldInvoice",

package/lnd_methods/offchain/update_routing_fees.js

@@ -90,8 +90,29 @@ module.exports = (args, cbk) => {
         return cbk(null, tokensAsMtokens(args.base_fee_tokens));
       }],
 
+      // Determine the inbound fee discount policy
+      inboundFee: ['validate', ({}, cbk) => {
+        const inboundBase = args.inbound_base_discount_mtokens;
+        const inboundRate = args.inbound_rate_discount;
+
+        // Exit early when there is no inbound policy defined
+        if (inboundBase === undefined && inboundRate === undefined) {
+          return cbk();
+        }
+
+        // Convert discounts into the surcharges format
+        return cbk(null, {
+          base_fee_msat: surcharge(inboundBase),
+          fee_rate_ppm: surcharge(inboundRate)
+        });
+      }],
+
       // Set the routing fee policy
-      updateFees: ['baseFeeMillitokens', ({baseFeeMillitokens}, cbk) => {
+      updateFees: [
+        'baseFeeMillitokens',
+        'inboundFee',
+        ({baseFeeMillitokens, inboundFee}, cbk) =>
+      {
         const id = args.transaction_id || undefined;
         const rate = args.fee_rate === undefined ? defaultRate : args.fee_rate;
         const vout = args.transaction_vout;
@@ -108,8 +129,7 @@ module.exports = (args, cbk) => {
           chan_point: !isGlobal ? chan : undefined,
           fee_rate: rate / feeRatio,
           global: isGlobal || undefined,
-          inbound_base_fee_msat: surcharge(args.inbound_base_discount_mtokens),
-          inbound_fee_rate_ppm: surcharge(args.inbound_rate_discount),
+          inbound_fee: inboundFee,
           max_htlc_msat: args.max_htlc_mtokens || undefined,
           min_htlc_msat: args.min_htlc_mtokens || undefined,
           min_htlc_msat_specified: !!args.min_htlc_mtokens,

package/lnd_methods/onchain/create_funded_psbt.js

@@ -0,0 +1,167 @@
+const asyncAuto = require('async/auto');
+const {createPsbt} = require('psbt');
+const {returnResult} = require('asyncjs-util');
+
+const {isLnd} = require('./../../lnd_requests');
+
+const bufferAsHex = buffer => buffer.toString('hex');
+const defaultChangeType = 'CHANGE_ADDRESS_TYPE_P2TR';
+const defaultConfirmationTarget = 6;
+const errorUnsupported = 'transaction template missing, need to specify either PSBT or raw TX template';
+const hexAsBuffer = hex => Buffer.from(hex, 'hex');
+const indexNotFound = -1;
+const {isBuffer} = Buffer;
+const method = 'fundPsbt';
+const strategy = type => !type ? undefined : `STRATEGY_${type.toUpperCase()}`;
+const type = 'wallet';
+const unconfirmedConfirmationsCount = 0;
+
+/** 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>
+  }
+*/
+module.exports = (args, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!isLnd({method, type, lnd: args.lnd})) {
+          return cbk([400, 'ExpectedAuthenticatedLndToCreateFundedPsbt']);
+        }
+
+        return cbk();
+      },
+
+      // Determine the change type
+      change: ['validate', ({}, cbk) => {
+        const changeIndex = (args.outputs || []).findIndex(n => !!n.is_change);
+
+        // Exit early when there is no change defined
+        if (changeIndex !== indexNotFound) {
+          return cbk(null, {existing_output_index: changeIndex});
+        }
+
+        // When there is no change output specified, add a change output
+        return cbk(null, {add: true});
+      }],
+
+      // Determine the fee setting for the funded PSBT
+      fee: ['validate', ({}, cbk) => {
+        // Exit early when the fee is directly specified
+        if (!!args.fee_tokens_per_vbyte) {
+          return cbk(null, {fee_tokens_per_vbyte: args.fee_tokens_per_vbyte});
+        }
+
+        // Exit early when the confirmation target is directly specified
+        if (!!args.target_confirmations) {
+          return cbk(null, {target_confirmations: args.target_confirmations});
+        }
+
+        // Use the default confirmations target when there's no preference
+        return cbk(null, {target_confirmations: defaultConfirmationTarget});
+      }],
+
+      // Construct the PSBT that is needed for coin select type funding
+      funding: ['validate', ({}, cbk) => {
+        const {psbt} = createPsbt({
+          outputs: args.outputs || [],
+          timelock: args.timelock,
+          utxos: (args.inputs || []).map(input => ({
+            id: input.transaction_id,
+            sequence: input.sequence,
+            vout: input.transaction_vout,
+          })),
+          version: args.version,
+        });
+
+        return cbk(null, hexAsBuffer(psbt));
+      }],
+
+      // Determine the minimum confirmations for UTXOs to select
+      minConfs: ['validate', ({}, cbk) => {
+        // Exit early when using unconfirmed UTXOs is explicitly specified
+        if (args.min_confirmations === unconfirmedConfirmationsCount) {
+          return cbk(null, unconfirmedConfirmationsCount);
+        }
+
+        return cbk(null, args.min_confirmations || undefined);
+      }],
+
+      // Create the funded PSBT using the coin select strategy
+      fund: [
+        'change',
+        'fee',
+        'funding',
+        'minConfs',
+        ({change, fee, funding, minConfs}, cbk) =>
+      {
+        return args.lnd[type][method]({
+          change_type: defaultChangeType,
+          coin_select: {
+            add: change.add,
+            psbt: funding,
+            existing_output_index: change.existing_output_index,
+          },
+          coin_selection_strategy: strategy(args.utxo_selection),
+          min_confs: minConfs,
+          sat_per_vbyte: fee.fee_tokens_per_vbyte,
+          spend_unconfirmed: minConfs === unconfirmedConfirmationsCount,
+          target_conf: fee.target_confirmations,
+        },
+        (err, res) => {
+          if (!!err && err.details === errorUnsupported) {
+            return cbk([501, 'CreateFundedPsbtMethodNotSupported']);
+          }
+
+          if (!!err) {
+            return cbk([503, 'UnexpectedErrorCreatingFundedPsbt', {err}]);
+          }
+
+          if (!res) {
+            return cbk([503, 'ExpectedResultWhenCreatingFundedPsbt']);
+          }
+
+          if (!isBuffer(res.funded_psbt)) {
+            return cbk([503, 'ExpectedFundedTransactionPsbtToBeCreated']);
+          }
+
+          return cbk(null, {psbt: bufferAsHex(res.funded_psbt)});
+        });
+      }],
+    },
+    returnResult({reject, resolve, of: 'fund'}, cbk));
+  });
+};

package/lnd_methods/onchain/get_pending_sweeps.d.ts

@@ -0,0 +1,47 @@
+import {
+  AuthenticatedLightningArgs,
+  AuthenticatedLightningMethod,
+} from '../../typescript';
+
+export type GetPendingSweepsArgs = AuthenticatedLightningArgs;
+
+export interface Sweep {
+  /** Total Sweep Broadcast Attempts Count Number */
+  broadcasts_count: number;
+  /** Current Chain Fee Rate Tokens Per VByte Number */
+  current_fee_rate?: number;
+  /** Requested Chain Fee Rate Tokens per VByte Number */
+  initial_fee_rate?: number;
+  /** Requested Waiting For Batching Bool */
+  is_batching: boolean;
+  /** Maximum Total Fee Tokens Allowed Number */
+  max_fee?: number;
+  /** Targeted Maximum Confirmation Height Number */
+  max_height?: number;
+  /** Sweep Outpoint Tokens Value Number */
+  tokens: number;
+  /** Sweeping Outpoint Transaction Id Hex String */
+  transaction_id: string;
+  /** Sweeping Outpoint Transaction Output Index Number */
+  transaction_vout: number;
+  /** Outpoint Constraint Script Type String */
+  type: string;
+}
+
+export interface GetPendingSweepsResult {
+  sweeps: Sweep[];
+}
+
+/**
+ * Get pending self-transfer spends
+ *
+ * Requires `onchain:read` permission
+ *
+ * Requires LND built with `walletrpc` build tag
+ *
+ * This method is not supported in LND 0.17.5 or below
+ */
+export const getPendingSweeps: AuthenticatedLightningMethod<
+  GetPendingSweepsArgs,
+  GetPendingSweepsResult
+>;

package/lnd_methods/onchain/index.d.ts

@@ -15,6 +15,7 @@ export * from './get_chain_transactions';
 export * from './get_locked_utxos';
 export * from './get_master_public_keys';
 export * from './get_pending_chain_balance';
+export * from './get_pending_sweeps';
 export * from './get_sweep_transactions';
 export * from './get_utxos';
 export * from './lock_utxo';
@@ -23,6 +24,7 @@ export * from './open_channels';
 export * from './partially_sign_psbt';
 export * from './prepare_for_channel_proposal';
 export * from './propose_channel';
+export * from './request_batched_fee_increase';
 export * from './request_chain_fee_increase';
 export * from './send_to_chain_address';
 export * from './send_to_chain_addresses';

package/lnd_methods/onchain/index.js

@@ -1,6 +1,7 @@
 const broadcastChainTransaction = require('./broadcast_chain_transaction');
 const cancelPendingChannel = require('./cancel_pending_channel');
 const closeChannel = require('./close_channel');
+const createFundedPsbt = require('./create_funded_psbt');
 const deleteChainTransaction = require('./delete_chain_transaction');
 const fundPendingChannels = require('./fund_pending_channels');
 const fundPsbt = require('./fund_psbt');
@@ -44,6 +45,7 @@ module.exports = {
   broadcastChainTransaction,
   cancelPendingChannel,
   closeChannel,
+  createFundedPsbt,
   deleteChainTransaction,
   fundPendingChannels,
   fundPsbt,

package/lnd_methods/onchain/request_batched_fee_increase.d.ts

@@ -0,0 +1,26 @@
+import {
+  AuthenticatedLightningArgs,
+  AuthenticatedLightningMethod,
+} from '../../typescript';
+
+export type RequestBatchedFeeIncreaseArgs = AuthenticatedLightningArgs<{
+  /** Maximum Tokens to Pay Into Chain Fees Number */
+  max_fee?: number;
+  /** Maximum Height To Reach a Confirmation Number */
+  max_height?: number;
+  /** Unconfirmed UTXO Transaction Id Hex String */
+  transaction_id: string;
+  /** Unconfirmed UTXO Transaction Index Number */
+  transaction_vout: number;
+}>;
+
+/**
+ * Request batched CPFP fee bumping of an unconfirmed outpoint on a deadline
+ *
+ * Requires `onchain:write` permission
+ *
+ * Requires LND built with `walletrpc` build tag
+ *
+ * This method is unsupported on LND 0.17.5 and below
+ */
+export const requestBatchedFeeIncrease: AuthenticatedLightningMethod<RequestBatchedFeeIncreaseArgs>;

package/package.json

@@ -7,9 +7,9 @@
     "url": "https://github.com/alexbosworth/lightning/issues"
   },
   "dependencies": {
-    "@grpc/grpc-js": "1.10.7",
+    "@grpc/grpc-js": "1.10.8",
     "@grpc/proto-loader": "0.7.13",
-    "@types/node": "20.12.10",
+    "@types/node": "20.12.12",
     "@types/request": "2.48.12",
     "@types/ws": "8.5.10",
     "async": "3.2.5",
@@ -53,5 +53,5 @@
     "directory": "test/typescript"
   },
   "types": "index.d.ts",
-  "version": "10.11.0"
+  "version": "10.12.0"
 }

package/test/lnd_methods/offchain/test_update_routing_fees.js

@@ -163,6 +163,22 @@ const tests = [
     },
     description: 'A local channel policy is updated',
   },
+  {
+    args: {
+      inbound_base_discount_mtokens: '1',
+      lnd: makeLnd({
+        policy: {
+          base_fee_msat: '1000',
+          chan_point: undefined,
+          fee_rate: 0.000001,
+          global: true,
+          max_htlc_msat: undefined,
+          time_lock_delta: 144,
+        },
+      }),
+      description: 'Set a base discount',
+    },
+  },
 ];
 
 tests.forEach(({args, description, error, expected}) => {

package/test/lnd_methods/onchain/test_create_funded_psbt.js

@@ -0,0 +1,130 @@
+const {deepStrictEqual} = require('node:assert').strict;
+const {rejects} = require('node:assert').strict;
+const test = require('node:test');
+
+const {createFundedPsbt} = require('./../../../lnd_methods');
+
+const psbt = '70736274ff01009a020000000258e87a21b56daf0c23be8e7070456c336f7cbaa5c8757924f545887bb2abdd750000000000ffffffff838d0427d0ec650a68aa46bb0b098aea4422c071b2ca78352a077959d07cea1d0100000000ffffffff0270aaf00800000000160014d85c2b71d0060b09c9886aeb815e50991dda124d00e1f5050000000016001400aea9a2e5f0f876a588df5546e8742d1d87008f000000000000000000';
+const unsupported = {details: 'transaction template missing, need to specify either PSBT or raw TX template'};
+
+const makeLnd = overrides => {
+  const res = {
+    change_output_index: 0,
+    funded_psbt: Buffer.from(psbt, 'hex'),
+    locked_utxos: [{
+      expiration: 1,
+      id: Buffer.alloc(32),
+      outpoint: {
+        output_index: 0,
+        txid_bytes: Buffer.from('75ddabb27b8845f5247975c8a5ba7c6f336c4570708ebe230caf6db5217ae858', 'hex').reverse(),
+      },
+    }],
+  };
+
+  Object.keys(overrides).forEach(k => res[k] = overrides[k]);
+
+  return {wallet: {fundPsbt: (args, cbk) => cbk(null, res)}};
+};
+
+const makeArgs = overrides => {
+  const args = {
+    lnd: makeLnd({}),
+    outputs: [{script: '00', tokens: 1}],
+  };
+
+  Object.keys(overrides).forEach(key => args[key] = overrides[key]);
+
+  return args;
+};
+
+const makeExpected = overrides => {
+  const expected = {
+    psbt: '70736274ff01009a020000000258e87a21b56daf0c23be8e7070456c336f7cbaa5c8757924f545887bb2abdd750000000000ffffffff838d0427d0ec650a68aa46bb0b098aea4422c071b2ca78352a077959d07cea1d0100000000ffffffff0270aaf00800000000160014d85c2b71d0060b09c9886aeb815e50991dda124d00e1f5050000000016001400aea9a2e5f0f876a588df5546e8742d1d87008f000000000000000000',
+  };
+
+  Object.keys(overrides).forEach(k => expected[k] = overrides[k]);
+
+  return expected;
+};
+
+const tests = [
+  {
+    args: makeArgs({lnd: undefined}),
+    description: 'An LND object is required',
+    error: [400, 'ExpectedAuthenticatedLndToCreateFundedPsbt'],
+  },
+  {
+    args: makeArgs({lnd: {wallet: {fundPsbt: ({}, cbk) => cbk(unsupported)}}}),
+    description: 'Unsupported error is passed back',
+    error: [501, 'CreateFundedPsbtMethodNotSupported'],
+  },
+  {
+    args: makeArgs({lnd: {wallet: {fundPsbt: ({}, cbk) => cbk('err')}}}),
+    description: 'Errors funding are passed back',
+    error: [503, 'UnexpectedErrorCreatingFundedPsbt', {err: 'err'}],
+  },
+  {
+    args: makeArgs({lnd: {wallet: {fundPsbt: ({}, cbk) => cbk()}}}),
+    description: 'A response is expected',
+    error: [503, 'ExpectedResultWhenCreatingFundedPsbt'],
+  },
+  {
+    args: makeArgs({lnd: makeLnd({funded_psbt: undefined})}),
+    description: 'A funded PSBT is expected in the response',
+    error: [503, 'ExpectedFundedTransactionPsbtToBeCreated'],
+  },
+  {
+    args: makeArgs({}),
+    description: 'PSBT funding is executed',
+    expected: makeExpected({}),
+  },
+  {
+    args: makeArgs({min_confirmations: 0}),
+    description: 'PSBT funding is executed with min confs specified',
+    expected: makeExpected({}),
+  },
+  {
+    args: makeArgs({fee_tokens_per_vbyte: 1, outputs: undefined}),
+    description: 'PSBT funding can specify fee rate',
+    expected: makeExpected({}),
+  },
+  {
+    args: makeArgs({target_confirmations: 1}),
+    description: 'PSBT funding can specify conf target',
+    expected: makeExpected({}),
+  },
+  {
+    args: makeArgs({
+      inputs: [{
+        transaction_id: Buffer.alloc(32).toString('hex'),
+        transaction_vout: 0,
+      }],
+    }),
+    description: 'Inputs can be specified',
+    expected: makeExpected({}),
+  },
+  {
+    args: makeArgs({outputs: [{is_change: true, script: '00', tokens: 1}]}),
+    description: 'Outputs can be specified',
+    expected: makeExpected({}),
+  },
+  {
+    args: makeArgs({utxo_selection: 'largest'}),
+    description: 'PSBT funding can select largest coins',
+    expected: makeExpected({}),
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async () => {
+    if (!!error) {
+      await rejects(createFundedPsbt(args), error, 'Got error');
+    } else {
+      const got = await createFundedPsbt(args);
+
+      deepStrictEqual(got, expected, 'Got expected result');
+    }
+
+    return;
+  });
+});

package/typescript/shared.d.ts

@@ -19,13 +19,13 @@ export type LightningError<TError = {err: Error}> = TError extends undefined
 
 export type LightningCallback<TResult = void, TErrorDetails = any> = (
   error: LightningError<TErrorDetails> | undefined | null,
-  result: TResult extends void ? undefined : TResult
+  result: TResult extends void ? undefined : TResult,
 ) => void;
 
 export type LightningMethod<
   TArgs = EmptyObject,
   TResult = void,
-  TErrorDetails = any
+  TErrorDetails = any,
 > = {
   (args: TArgs): Promise<TResult>;
   (args: TArgs, callback: LightningCallback<TResult, TErrorDetails>): void;
@@ -34,21 +34,21 @@ export type LightningMethod<
 export type AuthenticatedLightningMethod<
   TArgs extends {lnd: AuthenticatedLnd} = {lnd: AuthenticatedLnd},
   TResult = void,
-  TErrorDetails = any
+  TErrorDetails = any,
 > = LightningMethod<TArgs, TResult, TErrorDetails>;
 
 export type UnauthenticatedLightningMethod<
   TArgs extends {lnd: UnauthenticatedLnd} = {lnd: UnauthenticatedLnd},
   TResult = void,
-  TErrorDetails = any
+  TErrorDetails = any,
 > = LightningMethod<TArgs, TResult, TErrorDetails>;
 
 export type AuthenticatedLightningSubscription<
-  TArgs extends {lnd: AuthenticatedLnd} = {lnd: AuthenticatedLnd}
+  TArgs extends {lnd: AuthenticatedLnd} = {lnd: AuthenticatedLnd},
 > = (args: TArgs) => events.EventEmitter;
 
 export type UnauthenticatedLightningSubscription<
-  TArgs extends {lnd: UnauthenticatedLnd} = {lnd: UnauthenticatedLnd}
+  TArgs extends {lnd: UnauthenticatedLnd} = {lnd: UnauthenticatedLnd},
 > = (args: TArgs) => events.EventEmitter;
 
 type CommonStatus = 'IN_FLIGHT' | 'SUCCEEDED' | 'FAILED';
@@ -113,10 +113,41 @@ export type RouteNode = {
   fee_rate?: number;
   /** Forward Edge Public Key Hex */
   public_key: string;
-}
+};
+
+export type Route = RouteNode[];
 
-export type Route = RouteNode[]
+export type Routes = Route[];
 
-export type Routes = Route[]
+export type UtxoSelection = 'largest' | 'random';
 
-export type UtxoSelection = "largest" | "random";
+export interface ChannelPolicy {
+  /** Base Fee Millitokens */
+  base_fee_mtokens?: string;
+  /** Locktime Delta */
+  cltv_delta?: number;
+  /** Fees Charged Per Million Millitokens */
+  fee_rate?: number;
+  /**
+   * Source Based Base Fee Reduction String
+   *
+   * Not supported on LND 0.17.5 and below
+   */
+  inbound_base_discount_mtokens?: string;
+  /**
+   * Source Based Per Million Rate Reduction Number
+   *
+   * Not supported on LND 0.17.5 and below
+   */
+  inbound_rate_discount?: number;
+  /** Channel Is Disabled */
+  is_disabled?: boolean;
+  /** Maximum HTLC Millitokens Value */
+  max_htlc_mtokens?: string;
+  /** Minimum HTLC Millitokens Value */
+  min_htlc_mtokens?: string;
+  /** Node Public Key */
+  public_key: string;
+  /** Policy Last Updated At ISO 8601 Date */
+  updated_at?: string;
+}