lightning 4.3.0 → 4.6.0

package/lnd_responses/rpc_attempt_htlc_as_attempt.js

@@ -2,6 +2,8 @@ const {attemptStates} = require('./constants');
 
 const rpcRouteAsRoute = require('./rpc_route_as_route');
 
+const nsAsMs = ns => Number(BigInt(ns) / BigInt(1e6));
+
 /** Payment attempt details from RPC HTLCAttempt message
 
   {
@@ -59,36 +61,10 @@ const rpcRouteAsRoute = require('./rpc_route_as_route');
 
   @returns
   {
+    confirmed_at: <Payment Succeeded At ISO 8601 Date String>
     is_confirmed: <Payment Attempt Succeeded Bool>
     is_failed: <Payment Attempt Failed Bool>
     is_pending: <Payment Attempt is Waiting For Resolution Bool>
-    [failure]: {
-      code: <Error Type Code Number>
-      [details]: {
-        [channel]: <Standard Format Channel Id String>
-        [height]: <Error Associated Block Height Number>
-        [index]: <Failed Hop Index Number>
-        [mtokens]: <Error Millitokens String>
-        [policy]: {
-          base_fee_mtokens: <Base Fee Millitokens String>
-          cltv_delta: <Locktime Delta Number>
-          fee_rate: <Fees Charged in Millitokens Per Million Number>
-          [is_disabled]: <Channel is Disabled Bool>
-          max_htlc_mtokens: <Maximum HLTC Millitokens Value String>
-          min_htlc_mtokens: <Minimum HTLC Millitokens Value String>
-          updated_at: <Updated At ISO 8601 Date String>
-        }
-        [timeout_height]: <Error CLTV Timeout Height Number>
-        [update]: {
-          chain: <Chain Id Hex String>
-          channel_flags: <Channel Flags Number>
-          extra_opaque_data: <Extra Opaque Data Hex String>
-          message_flags: <Message Flags Number>
-          signature: <Channel Update Signature Hex String>
-        }
-      }
-      message: <Error Message String>
-    }
     route: {
       fee: <Route Fee Tokens Number>
       fee_mtokens: <Route Fee Millitokens String>
@@ -115,6 +91,10 @@ module.exports = attempt => {
     throw new Error('ExpectedRpcAttemptDetailsToDeriveAttempt');
   }
 
+  if (!attempt.resolve_time_ns) {
+    throw new Error('ExpectedRpcAttemptResolveTimeNs');
+  }
+
   if (!attempt.route) {
     throw new Error('ExpectedRouteAttemptedInRpcAttemptDetails');
   }
@@ -124,6 +104,7 @@ module.exports = attempt => {
   }
 
   return {
+    confirmed_at: new Date(nsAsMs(attempt.resolve_time_ns)).toISOString(),
     is_confirmed: attempt.status === attemptStates.confirmed,
     is_failed: attempt.status === attemptStates.failed,
     is_pending: attempt.status === attemptStates.pending,

package/lnd_responses/rpc_payment_as_payment.js

@@ -194,8 +194,10 @@ module.exports = payment => {
 
   const hasPath = !!payment.path.length;
   const [attempt] = attempts;
+  const successes = attempts.filter(n => n.is_confirmed);
 
   const path = !hasPath ? routePublicKeys(attempt.route) : payment.path;
+  const [confirmedAt] = successes.map(n => n.confirmed_at).sort().reverse();
 
   const [destination, ...hops] = path.reverse();
 
@@ -211,6 +213,7 @@ module.exports = payment => {
   return {
     destination,
     attempts: payment.htlcs.map(htlc => rpcAttemptHtlcAsAttempt(htlc)),
+    confirmed_at: confirmedAt || undefined,
     created_at: new Date(creationDateEpochMs).toISOString(),
     fee: safeTokens({mtokens: payment.fee_msat}).tokens,
     fee_mtokens: payment.fee_msat,

package/lnd_responses/rpc_wallet_state_as_state.js

@@ -1,6 +1,7 @@
 const stateAbsent = 'NON_EXISTING';
 const stateActive = 'RPC_ACTIVE';
 const stateLocked = 'LOCKED';
+const stateReady = 'SERVER_ACTIVE';
 const stateStarting = 'UNLOCKED';
 const stateWaiting = 'WAITING_TO_START';
 
@@ -15,6 +16,7 @@ const stateWaiting = 'WAITING_TO_START';
     [is_absent]: <Wallet Not Created Bool>
     [is_active]: <Wallet Is Active Bool>
     [is_locked]: <Wallet File Encrypted And Wallet Not Active Bool>
+    [is_ready]: <Wallet Is Ready For All RPC Calls Bool>
     [is_starting]: <Wallet Is Starting Up Bool>
     [is_waiting]: <Wallet Is Waiting To Start Bool>
   }
@@ -38,6 +40,9 @@ module.exports = args => {
   case stateLocked:
     return {is_locked: true};
 
+  case stateReady:
+    return {is_active: true, is_ready: true};
+
   case stateStarting:
     return {is_starting: true};
 

package/package.json

@@ -8,7 +8,7 @@
   },
   "dependencies": {
     "@grpc/grpc-js": "1.3.7",
-    "@grpc/proto-loader": "0.6.4",
+    "@grpc/proto-loader": "0.6.5",
     "@types/express": "4.17.13",
     "@types/node": "16.9.1",
     "@types/request": "2.48.7",
@@ -56,5 +56,5 @@
     "directory": "test/typescript"
   },
   "types": "index.d.ts",
-  "version": "4.3.0"
+  "version": "4.6.0"
 }

package/test/lnd_methods/offchain/test_delete_failed_pay_attempts.js

@@ -8,6 +8,24 @@ const tests = [
     description: 'LND object is required',
     error: [400, 'ExpectedAuthenticatedLndToDeleteFailedAttempts'],
   },
+  {
+    args: {id: 1},
+    description: 'A payment id is expected to be a hash',
+    error: [400, 'ExpectedPaymentHashToDeleteFailedPayAttempts'],
+  },
+  {
+    args: {
+      id: Buffer.alloc(32).toString('hex'),
+      lnd: {
+        default: {
+          deleteAllPayments: ({}, cbk) => cbk(),
+          deletePayment: ({}, cbk) => cbk({details: 'unknown'}),
+        },
+      },
+    },
+    description: 'An unsupported error is returned',
+    error: [501, 'DeleteFailedPaymentAttemptsMethodNotSupported'],
+  },
   {
     args: {lnd: {default: {deleteAllPayments: ({}, cbk) => cbk('err')}}},
     description: 'An unexpected error is returned',

package/test/lnd_methods/offchain/test_delete_payment.js

@@ -0,0 +1,51 @@
+const {test} = require('@alexbosworth/tap');
+
+const {deletePayment} = require('./../../../lnd_methods');
+
+const tests = [
+  {
+    args: {},
+    description: 'An id is required',
+    error: [400, 'ExpectedPaymentHashToDeletePaymentRecord'],
+  },
+  {
+    args: {id: Buffer.alloc(32).toString('hex')},
+    description: 'LND object is required',
+    error: [400, 'ExpectedAuthenticatedLndToDeletePayment'],
+  },
+  {
+    args: {
+      id: Buffer.alloc(32).toString('hex'),
+      lnd: {default: {deletePayment: ({}, cbk) => cbk({details: 'unknown'})}},
+    },
+    description: 'An unexpected error is returned',
+    error: [501, 'DeletePaymentMethodNotSupported'],
+  },
+  {
+    args: {
+      id: Buffer.alloc(32).toString('hex'),
+      lnd: {default: {deletePayment: ({}, cbk) => cbk('err')}},
+    },
+    description: 'An unexpected error is returned',
+    error: [503, 'UnexpectedErrorDeletingPayment', {err: 'err'}],
+  },
+  {
+    args: {
+      id: Buffer.alloc(32).toString('hex'),
+      lnd: {default: {deletePayment: ({}, cbk) => cbk()}},
+    },
+    description: 'Payments are deleted',
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async ({deepEqual, end, equal, rejects}) => {
+    if (!!error) {
+      await rejects(deletePayment(args), error, 'Got expected error');
+    } else {
+      await deletePayment(args);
+    }
+
+    return end();
+  });
+});

package/test/lnd_methods/offchain/test_delete_payments.js

@@ -15,7 +15,7 @@ const tests = [
   },
   {
     args: {lnd: {default: {deleteAllPayments: ({}, cbk) => cbk()}}},
-    description: 'Payments are deleted',
+    description: 'Payment is deleted',
   },
 ];
 

package/test/lnd_methods/offchain/test_finished_payment.js

@@ -5,6 +5,7 @@ const method = require('./../../../lnd_methods/offchain/finished_payment');
 const makeArgs = overrides => {
   const args = {
     confirmed: {
+      confirmed_at: new Date(1).toISOString(),
       fee: 1,
       fee_mtokens: '1000',
       hops: [{
@@ -91,6 +92,7 @@ const tests = [
     args: makeArgs({}),
     description: 'Successful payment details are returned',
     expected: {
+      confirmed_at: '1970-01-01T00:00:00.001Z',
       fee: 1,
       fee_mtokens: '1000',
       hops: [{

package/test/lnd_methods/offchain/test_get_payments.js

@@ -34,7 +34,7 @@ const makeLnd = args => {
               total_fees_msat: '1000',
               total_time_lock: 1,
             },
-            status: 'SETTLED',
+            status: 'SUCCEEDED',
           }],
           path: [Buffer.alloc(33, 2).toString('hex')],
           payment_hash: Buffer.alloc(32).toString('hex'),
@@ -64,7 +64,8 @@ const makeExpectedPayment = ({}) => {
   return {
     destination: '020202020202020202020202020202020202020202020202020202020202020202',
     attempts: [{
-      is_confirmed: false,
+      confirmed_at: '1970-01-01T00:00:00.000Z',
+      is_confirmed: true,
       is_failed: false,
       is_pending: false,
       route: {
@@ -87,6 +88,7 @@ const makeExpectedPayment = ({}) => {
         total_mtokens: undefined
       },
     }],
+    confirmed_at: '1970-01-01T00:00:00.000Z',
     created_at: '1970-01-01T00:00:00.000Z',
     fee: 1,
     fee_mtokens: '1000',

package/test/lnd_methods/offchain/test_subscribe_to_past_payments.js

@@ -203,6 +203,8 @@ const tests = [
     },
     description: 'A past payment is emitted',
     expected: {
+      confirmed_at: '1970-01-01T00:00:00.000Z',
+      destination: '000000000000000000000000000000000000000000000000000000000000000000',
       fee: 1,
       fee_mtokens: '1000',
       hops: [

package/test/lnd_methods/offchain/test_subscribe_to_pay_via_routes.js

@@ -126,6 +126,7 @@ const tests = [
       failures: [],
       success: {
         route,
+        confirmed_at: undefined,
         fee: route.fee,
         fee_mtokens: route.fee_mtokens,
         hops: route.hops,

package/test/lnd_responses/test_confirmed_from_payment.js

@@ -53,6 +53,8 @@ const makeArgs = overrides => {
 
 const makeExpected = overrides => {
   const expected = {
+    confirmed_at: '1970-01-01T00:00:00.000Z',
+    destination: Buffer.alloc(33).toString('hex'),
     fee: 1,
     fee_mtokens: '1000',
     hops: [{

package/test/lnd_responses/test_rpc_attempt_htlc_as_attempt.js

@@ -2,8 +2,33 @@ const {test} = require('@alexbosworth/tap');
 
 const {rpcAttemptHtlcAsAttempt} = require('./../../lnd_responses');
 
+const route = {
+  hops: [{
+    amt_to_forward_msat: '1000',
+    chan_id: '1',
+    chan_capacity: 1,
+    expiry: 1,
+    fee_msat: '1000',
+    mpp_record: {payment_addr: Buffer.alloc(1), total_amt_msat: '1'},
+    pub_key: 'a',
+    tlv_payload: true,
+  }],
+  total_amt_msat: '1000',
+  total_fees_msat: '1000',
+  total_time_lock: 1,
+};
+
+const makeArgs = overrides => {
+  const args = {route, resolve_time_ns: '1', status: 'IN_FLIGHT'};
+
+  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
+
+  return args;
+};
+
 const makeExpected = overrides => {
   const attempt = {
+    confirmed_at: '1970-01-01T00:00:00.000Z',
     is_confirmed: false,
     is_failed: false,
     is_pending: false,
@@ -33,22 +58,6 @@ const makeExpected = overrides => {
   return {attempt};
 };
 
-const route = {
-  hops: [{
-    amt_to_forward_msat: '1000',
-    chan_id: '1',
-    chan_capacity: 1,
-    expiry: 1,
-    fee_msat: '1000',
-    mpp_record: {payment_addr: Buffer.alloc(1), total_amt_msat: '1'},
-    pub_key: 'a',
-    tlv_payload: true,
-  }],
-  total_amt_msat: '1000',
-  total_fees_msat: '1000',
-  total_time_lock: 1,
-};
-
 const tests = [
   {
     args: null,
@@ -56,27 +65,32 @@ const tests = [
     error: 'ExpectedRpcAttemptDetailsToDeriveAttempt',
   },
   {
-    args: {},
+    args: makeArgs({resolve_time_ns: undefined}),
+    description: 'Expected resolve time in rpc attempt details',
+    error: 'ExpectedRpcAttemptResolveTimeNs',
+  },
+  {
+    args: makeArgs({route: undefined}),
     description: 'Expected route in rpc attempt details',
     error: 'ExpectedRouteAttemptedInRpcAttemptDetails',
   },
   {
-    args: {route: {}},
+    args: makeArgs({status: undefined}),
     description: 'A status code is expected',
     error: 'ExpectedAttemptStatusInRpcAttemptDetails',
   },
   {
-    args: {route, status: 'IN_FLIGHT'},
+    args: makeArgs({}),
     description: 'An in flight rpc attempt is mapped to an attempt',
     expected: makeExpected({is_pending: true}),
   },
   {
-    args: {route, status: 'SUCCEEDED'},
+    args: makeArgs({status: 'SUCCEEDED'}),
     description: 'An rpc attempt is mapped to an attempt',
     expected: makeExpected({is_confirmed: true}),
   },
   {
-    args: {route, status: 'FAILED'},
+    args: makeArgs({status: 'FAILED'}),
     description: 'An rpc attempt is mapped to an attempt',
     expected: makeExpected({is_failed: true}),
   },

package/test/lnd_responses/test_rpc_payment_as_payment.js

@@ -73,6 +73,7 @@ const makeArgs = overrides => {
 const makeExpected = overrides => {
   const expected = {
     attempts: [{
+      confirmed_at: '1970-01-01T00:00:00.001Z',
       is_confirmed: false,
       is_failed: true,
       is_pending: false,
@@ -96,6 +97,7 @@ const makeExpected = overrides => {
         total_mtokens: '1000',
       },
     }],
+    confirmed_at: undefined,
     created_at: '1970-01-01T00:00:01.000Z',
     destination: Buffer.alloc(33).toString('hex'),
     fee: 1,
@@ -234,6 +236,7 @@ const tests = [
     description: 'A realistic successful payment is mapped to a payment',
     expected: makeExpected({
       attempts: [{
+        confirmed_at: '2020-04-20T19:17:16.160Z',
         is_confirmed: true,
         is_failed: false,
         is_pending: false,
@@ -257,6 +260,7 @@ const tests = [
           total_mtokens: '100000',
         },
       }],
+      confirmed_at: '2020-04-20T19:17:16.160Z',
       created_at: '2020-04-20T19:17:15.356Z',
       destination: '029860f8550e29316ee97460c79228d939b18d2a51dbef407f410e265c79b19073',
       fee: 0,

package/test/lnd_responses/test_rpc_wallet_state_as_state.js

@@ -30,6 +30,11 @@ const tests = [
     description: 'Wallet is ready',
     expected: makeExpected({is_active: true}),
   },
+  {
+    args: {state: 'SERVER_ACTIVE'},
+    description: 'Server is ready',
+    expected: makeExpected({is_active: true, is_ready: true}),
+  },
   {
     args: {state: 'LOCKED'},
     description: 'Wallet file is encrypted',

package/test/protos/protos.json

@@ -1,6 +1,6 @@
 {
   "overrides": [
-    ["lightning", 3229],
+    ["lightning", 3330],
     ["router", 100, 171],
     ["walletkit", 3],
     ["walletunlocker", 2]

package/test/typescript/subscribe_to_past_payments.test-d.ts

@@ -0,0 +1,11 @@
+import * as events from 'events';
+import {expectError, expectType} from 'tsd';
+import {AuthenticatedLnd} from '../../lnd_grpc';
+import {subscribeToPastPayments} from '../../lnd_methods';
+
+const lnd = {} as AuthenticatedLnd;
+
+expectError(subscribeToPastPayments());
+expectError(subscribeToPastPayments({}));
+
+expectType<events.EventEmitter>(subscribeToPastPayments({lnd}));