lightning 5.13.1 → 5.15.1

package/lnd_responses/rpc_payment_as_payment.js

@@ -81,6 +81,9 @@ const routePublicKeys = route => route.hops.map(n => n.public_key);
   @returns
   {
     attempts: [{
+      [confirmed_at]: <Payment Attempt Succeeded At ISO 8601 Date String>
+      created_at: <Attempt Was Started At ISO 8601 Date String>
+      [failed_at]: <Payment Attempt Failed At ISO 8601 Date String>
       [failure]: {
         code: <Error Type Code Number>
         [details]: {
@@ -108,6 +111,9 @@ const routePublicKeys = route => route.hops.map(n => n.public_key);
         }
         message: <Error Message String>
       }
+      [confirmed_at]: <Payment Attempt Succeeded At ISO 8601 Date String>
+      created_at: <Attempt Was Started At ISO 8601 Date String>
+      [failed_at]: <Payment Attempt Failed 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>

package/package.json

@@ -8,9 +8,9 @@
   },
   "dependencies": {
     "@grpc/grpc-js": "1.6.7",
-    "@grpc/proto-loader": "0.6.9",
+    "@grpc/proto-loader": "0.6.12",
     "@types/express": "4.17.13",
-    "@types/node": "17.0.25",
+    "@types/node": "17.0.31",
     "@types/request": "2.48.8",
     "@types/ws": "8.5.3",
     "async": "3.2.3",
@@ -22,7 +22,7 @@
     "bolt09": "0.2.3",
     "cbor": "8.1.0",
     "ecpair": "2.0.1",
-    "express": "4.17.3",
+    "express": "4.18.1",
     "invoices": "2.0.6",
     "psbt": "2.0.1",
     "tiny-secp256k1": "2.2.1",
@@ -33,8 +33,8 @@
     "@alexbosworth/node-fetch": "2.6.2",
     "@alexbosworth/tap": "15.0.11",
     "tsd": "0.20.0",
-    "typescript": "4.6.3",
-    "ws": "8.5.0"
+    "typescript": "4.6.4",
+    "ws": "8.6.0"
   },
   "engines": {
     "node": ">=12.20"
@@ -59,5 +59,5 @@
     "directory": "test/typescript"
   },
   "types": "index.d.ts",
-  "version": "5.13.1"
+  "version": "5.15.1"
 }

package/test/lnd_methods/offchain/test_get_payments.js

@@ -65,6 +65,8 @@ const makeExpectedPayment = ({}) => {
     destination: '020202020202020202020202020202020202020202020202020202020202020202',
     attempts: [{
       confirmed_at: '1970-01-01T00:00:00.000Z',
+      created_at: '1970-01-01T00:00:00.000Z',
+      failed_at: undefined,
       is_confirmed: true,
       is_failed: false,
       is_pending: false,

package/test/lnd_methods/signer/test_begin_group_signing_session.js

@@ -0,0 +1,134 @@
+const {test} = require('@alexbosworth/tap');
+
+const {beginGroupSigningSession} = require('./../../../');
+
+const makeLnd = (err, res) => {
+  return {
+    signer: {
+      muSig2CreateSession: ({}, cbk) => cbk(err, res)
+    },
+    wallet: {
+      deriveKey: ({}, cbk) => cbk(null, {
+        key_loc: {key_index: 0},
+        raw_key_bytes: Buffer.alloc(1),
+      }),
+    },
+  };
+};
+
+const makeArgs = override => {
+  const args = {
+    lnd: makeLnd(null, {
+      combined_key: Buffer.alloc(32),
+      local_public_nonces: Buffer.alloc(66),
+      session_id: Buffer.alloc(32),
+      taproot_internal_key: Buffer.alloc(0),
+    }),
+    key_family: 0,
+    key_index: 0,
+    public_keys: [Buffer.alloc(33, 2).toString('hex')],
+  };
+
+  Object.keys(override || {}).forEach(key => args[key] = override[key]);
+
+  return args;
+};
+
+const tests = [
+  {
+    args: makeArgs({lnd: undefined}),
+    description: 'LND object is required',
+    error: [400, 'ExpectedAuthenticatedLndToStartMuSig2Session'],
+  },
+  {
+    args: makeArgs({key_family: undefined}),
+    description: 'A key family is required',
+    error: [400, 'ExpectedKeyFamilyToStartMuSig2Session'],
+  },
+  {
+    args: makeArgs({key_index: undefined}),
+    description: 'The key index is required',
+    error: [400, 'ExpectedKeyIndexToStartMuSig2Session'],
+  },
+  {
+    args: makeArgs({public_keys: undefined}),
+    description: 'Public keys are required',
+    error: [400, 'ExpectedArrayOfPublicKeysForMuSig2SessionStart'],
+  },
+  {
+    args: makeArgs({public_keys: []}),
+    description: 'Remote public keys are required',
+    error: [400, 'ExpectedOtherPublicKeysForMuSig2SessionStart'],
+  },
+  {
+    args: makeArgs({root_hash: 'root_hash'}),
+    description: 'Root hash must be valid',
+    error: [400, 'ExpectedHashWhenSpecifyingMuSig2ScriptRootHash'],
+  },
+  {
+    args: makeArgs({
+      lnd: makeLnd({
+        details: 'unknown method MuSig2CreateSession for service signrpc.Signer',
+      }),
+    }),
+    description: 'MuSig2 must be supported',
+    error: [501, 'MuSig2BeginSigningSessionNotSupported'],
+  },
+  {
+    args: makeArgs({lnd: makeLnd('err')}),
+    description: 'Unexpected errors are passed back',
+    error: [503, 'UnexpectedErrorCreatingMuSig2Session', {err: 'err'}],
+  },
+  {
+    args: makeArgs({lnd: makeLnd(null, {})}),
+    description: 'A valid response is expected',
+    error: [503, 'ExpectedCombinedPublicKeyInMuSig2SessionResponse'],
+  },
+  {
+    args: makeArgs({}),
+    description: 'A group signing session is started',
+    expected: {
+      external_key: '0000000000000000000000000000000000000000000000000000000000000000',
+      id: '0000000000000000000000000000000000000000000000000000000000000000',
+      internal_key: undefined,
+      nonce: '000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+    },
+  },
+  {
+    args: makeArgs({
+      public_keys: [Buffer.alloc(32, 1).toString('hex')],
+      root_hash: Buffer.alloc(32).toString('hex'),
+    }),
+    description: 'A group signing session is started with a root hash',
+    expected: {
+      external_key: '0000000000000000000000000000000000000000000000000000000000000000',
+      id: '0000000000000000000000000000000000000000000000000000000000000000',
+      internal_key: undefined,
+      nonce: '000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+    },
+  },
+  {
+    args: makeArgs({is_key_spend: true}),
+    description: 'A group signing session is started with a key spend',
+    expected: {
+      external_key: '0000000000000000000000000000000000000000000000000000000000000000',
+      id: '0000000000000000000000000000000000000000000000000000000000000000',
+      internal_key: undefined,
+      nonce: '000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+    },
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async ({end, rejects, strictSame}) => {
+    if (!!error) {
+      await rejects(beginGroupSigningSession(args), error, 'Got expected err');
+    } else {
+      const res = await beginGroupSigningSession(args);
+
+      strictSame(res, expected, 'Got expected result');
+    }
+
+    return end();
+  });
+});

package/test/lnd_methods/signer/test_diffie_hellman_compute_secret.js

@@ -33,7 +33,9 @@ const tests = [
       override: {
         lnd: {
           signer: {
-            deriveSharedKey: ({}, cbk) => cbk({details: 'unknown service signrpc.Signer'}),
+            deriveSharedKey: ({}, cbk) => cbk({
+              details: 'unknown service signrpc.Signer',
+            }),
           },
         },
       },

package/test/lnd_methods/signer/test_end_group_signing_session.js

@@ -0,0 +1,93 @@
+const {test} = require('@alexbosworth/tap');
+
+const {endGroupSigningSession} = require('./../../../');
+
+const makeLnd = ({cleanErr, combineErr, combineRes}) => {
+  return {
+    signer: {
+      muSig2Cleanup: ({}, cbk) => cbk(cleanErr),
+      muSig2CombineSig: ({}, cbk) => cbk(combineErr, combineRes),
+    },
+  };
+};
+
+const makeArgs = override => {
+  const args = {
+    id: Buffer.alloc(32).toString('hex'),
+    lnd: makeLnd({combineRes: {final_signature: Buffer.alloc(64)}}),
+    signatures: [Buffer.alloc(64).toString('hex')],
+  };
+
+  Object.keys(override || {}).forEach(key => args[key] = override[key]);
+
+  return args;
+};
+
+const tests = [
+  {
+    args: makeArgs({id: undefined}),
+    description: 'A session id is required',
+    error: [400, 'ExpectedSessionIdToFinishMuSig2Session'],
+  },
+  {
+    args: makeArgs({lnd: undefined}),
+    description: 'An authenticated lnd is required',
+    error: [400, 'ExpectedAuthenticatedLndToFinishMuSig2Session'],
+  },
+  {
+    args: makeArgs({signatures: []}),
+    description: 'Signatures are required',
+    error: [400, 'ExpectedPartialSignaturesToCombineToEndSession'],
+  },
+  {
+    args: makeArgs({lnd: makeLnd({cleanErr: 'err'}), signatures: undefined}),
+    description: 'A cleanup error is passed back',
+    error: [503, 'UnexpectedErrorCleaningUpMuSig2Session', {err: 'err'}],
+  },
+  {
+    args: makeArgs({lnd: makeLnd({combineErr: 'err'})}),
+    description: 'A combine error is passed back',
+    error: [503, 'UnexpectedErrorFinishingMuSig2Session', {err: 'err'}],
+  },
+  {
+    args: makeArgs({lnd: makeLnd({combineRes: null})}),
+    description: 'A combine response is expected',
+    error: [503, 'ExpectedResponseForMuSig2CombineRequest'],
+  },
+  {
+    args: makeArgs({lnd: makeLnd({combineRes: {have_all_signatures: false}})}),
+    description: 'A combine success response is expected',
+    error: [400, 'ExpectedAllSignaturesProvidedForSession'],
+  },
+  {
+    args: makeArgs({lnd: makeLnd({combineRes: {}})}),
+    description: 'A combined signature is expected',
+    error: [503, 'ExpectedFinalSignatureInCombineResponse'],
+  },
+  {
+    args: makeArgs({}),
+    description: 'A group signing session is ended',
+    expected: {
+      signature: '00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+    },
+  },
+  {
+    args: makeArgs({signatures: undefined}),
+    description: 'A group signing session is canceled',
+    expected: {},
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async ({end, rejects, strictSame}) => {
+    if (!!error) {
+      await rejects(endGroupSigningSession(args), error, 'Got expected err');
+    } else {
+      const res = await endGroupSigningSession(args);
+
+      strictSame(res, expected, 'Got expected result');
+    }
+
+    return end();
+  });
+});

package/test/lnd_methods/signer/test_update_group_signing_session.js

@@ -0,0 +1,108 @@
+const {test} = require('@alexbosworth/tap');
+
+const {updateGroupSigningSession} = require('./../../../');
+
+const makeLnd = ({noncesErr, noncesRes, signErr, signRes}) => {
+  return {
+    signer: {
+      muSig2RegisterNonces: ({}, cbk) => cbk(noncesErr, noncesRes),
+      muSig2Sign: ({}, cbk) => cbk(signErr, signRes),
+    },
+  };
+};
+
+const makeArgs = override => {
+  const args = {
+    hash: Buffer.alloc(32).toString('hex'),
+    id: Buffer.alloc(32).toString('hex'),
+    lnd: makeLnd({
+      noncesRes: {have_all_nonces: true},
+      signRes: {local_partial_signature: Buffer.alloc(64)},
+    }),
+    nonces: [Buffer.alloc(66).toString('hex')],
+  };
+
+  Object.keys(override || {}).forEach(key => args[key] = override[key]);
+
+  return args;
+};
+
+const tests = [
+  {
+    args: makeArgs({hash: undefined}),
+    description: 'A hash to sign is required',
+    error: [400, 'ExpectedHashToSignToUpdateMuSig2Session'],
+  },
+  {
+    args: makeArgs({id: undefined}),
+    description: 'A signing group id is required',
+    error: [400, 'ExpectedSessionIdToUpdateMuSig2Session'],
+  },
+  {
+    args: makeArgs({lnd: undefined}),
+    description: 'LND object is required',
+    error: [400, 'ExpectedAuthenticatedLndToUpdateMuSig2Session'],
+  },
+  {
+    args: makeArgs({nonces: undefined}),
+    description: 'Nonces are required',
+    error: [400, 'ExpectedArrayOfNoncesToUpdateMuSig2Session'],
+  },
+  {
+    args: makeArgs({lnd: makeLnd({noncesErr: 'err'})}),
+    description: 'Update nonces errors are passed back',
+    error: [503, 'UnexpectedErrorUpdatingMuSig2Session', {err: 'err'}],
+  },
+  {
+    args: makeArgs({lnd: makeLnd({noncesRes: null})}),
+    description: 'An update response is expected',
+    error: [503, 'ExpectedResultOfRegisterNoncesRequest'],
+  },
+  {
+    args: makeArgs({lnd: makeLnd({noncesRes: {}})}),
+    description: 'A successful update response is expected',
+    error: [400, 'ExpectedAllNoncesForRegisterNoncesRequest'],
+  },
+  {
+    args: makeArgs({
+      lnd: makeLnd({noncesRes: {have_all_nonces: true}, signErr: 'err'}),
+    }),
+    description: 'Sign errors are passed back',
+    error: [503, 'UnexpectedErrorSigningMuSig2Session', {err: 'err'}],
+  },
+  {
+    args: makeArgs({
+      lnd: makeLnd({noncesRes: {have_all_nonces: true}, signRes: null}),
+    }),
+    description: 'Sign response is expected',
+    error: [503, 'ExpectedResultForMuSig2SignRequest'],
+  },
+  {
+    args: makeArgs({
+      lnd: makeLnd({noncesRes: {have_all_nonces: true}, signRes: {}}),
+    }),
+    description: 'A partial signature is expected',
+    error: [503, 'ExpectedPartialSignatureForMuSig2SignRequest'],
+  },
+  {
+    args: makeArgs({}),
+    description: 'A group signing session is updated',
+    expected: {
+      signature: '00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+    },
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async ({end, rejects, strictSame}) => {
+    if (!!error) {
+      await rejects(updateGroupSigningSession(args), error, 'Got expected err');
+    } else {
+      const res = await updateGroupSigningSession(args);
+
+      strictSame(res, expected, 'Got expected result');
+    }
+
+    return end();
+  });
+});

package/test/lnd_responses/test_rpc_attempt_htlc_as_attempt.js

@@ -19,7 +19,12 @@ const route = {
 };
 
 const makeArgs = overrides => {
-  const args = {route, resolve_time_ns: '1', status: 'IN_FLIGHT'};
+  const args = {
+    route,
+    attempt_time_ns: '1',
+    resolve_time_ns: '1',
+    status: 'IN_FLIGHT',
+  };
 
   Object.keys(overrides).forEach(k => args[k] = overrides[k]);
 
@@ -29,6 +34,8 @@ const makeArgs = overrides => {
 const makeExpected = overrides => {
   const attempt = {
     confirmed_at: '1970-01-01T00:00:00.000Z',
+    created_at: '1970-01-01T00:00:00.000Z',
+    failed_at: undefined,
     is_confirmed: false,
     is_failed: false,
     is_pending: false,
@@ -64,6 +71,11 @@ const tests = [
     description: 'An rpc attempt is required to map to an attempt',
     error: 'ExpectedRpcAttemptDetailsToDeriveAttempt',
   },
+  {
+    args: makeArgs({attempt_time_ns: undefined}),
+    description: 'Expected attempt time in rpc attempt details',
+    error: 'ExpectedRpcAttemptStartTimeNs',
+  },
   {
     args: makeArgs({resolve_time_ns: undefined}),
     description: 'Expected resolve time in rpc attempt details',
@@ -82,7 +94,7 @@ const tests = [
   {
     args: makeArgs({}),
     description: 'An in flight rpc attempt is mapped to an attempt',
-    expected: makeExpected({is_pending: true}),
+    expected: makeExpected({confirmed_at: undefined, is_pending: true}),
   },
   {
     args: makeArgs({status: 'SUCCEEDED'}),
@@ -92,7 +104,11 @@ const tests = [
   {
     args: makeArgs({status: 'FAILED'}),
     description: 'An rpc attempt is mapped to an attempt',
-    expected: makeExpected({is_failed: true}),
+    expected: makeExpected({
+      confirmed_at: undefined,
+      failed_at: '1970-01-01T00:00:00.000Z',
+      is_failed: true,
+    }),
   },
 ];
 

package/test/lnd_responses/test_rpc_group_session_as_session.js

@@ -0,0 +1,79 @@
+const {test} = require('@alexbosworth/tap');
+
+const {rpcGroupSessionAsSession} = require('./../../lnd_responses');
+
+const makeArgs = overrides => {
+  const args = {
+    combined_key: Buffer.alloc(32),
+    local_public_nonces: Buffer.alloc(66),
+    session_id: Buffer.alloc(32),
+    taproot_internal_key: Buffer.alloc(32),
+  };
+
+  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
+
+  return args;
+};
+
+
+const tests = [
+  {
+    args: null,
+    description: 'A response is expected',
+    error: 'ExpectedResponseForMuSig2SessionRequest',
+  },
+  {
+    args: makeArgs({combined_key: undefined}),
+    description: 'A combined key is expected',
+    error: 'ExpectedCombinedPublicKeyInMuSig2SessionResponse',
+  },
+  {
+    args: makeArgs({local_public_nonces: undefined}),
+    description: 'Local public nonces are expected',
+    error: 'ExpectedLocalPublicNoncesInMuSig2SessionResponse',
+  },
+  {
+    args: makeArgs({session_id: undefined}),
+    description: 'A session id is expected',
+    error: 'ExpectedMuSig2SigningSessionIdInSessionResponse',
+  },
+  {
+    args: makeArgs({taproot_internal_key: undefined}),
+    description: 'A taproot internal key is expected',
+    error: 'ExpectedTaprootInternalKeyInMuSig2SessionResponse',
+  },
+  {
+    args: makeArgs({}),
+    description: 'Session data is returned',
+    expected: {
+      external_key: '0000000000000000000000000000000000000000000000000000000000000000',
+      id: '0000000000000000000000000000000000000000000000000000000000000000',
+      internal_key: '0000000000000000000000000000000000000000000000000000000000000000',
+      nonce: '000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+    },
+  },
+  {
+    args: makeArgs({taproot_internal_key: Buffer.alloc(0)}),
+    description: 'Session data is returned for a script key',
+    expected: {
+      external_key: '0000000000000000000000000000000000000000000000000000000000000000',
+      id: '0000000000000000000000000000000000000000000000000000000000000000',
+      internal_key: undefined,
+      nonce: '000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+    },
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, ({end, strictSame, throws}) => {
+    if (!!error) {
+      throws(() => rpcGroupSessionAsSession(args), new Error(error), 'Error');
+    } else {
+      const res = rpcGroupSessionAsSession(args);
+
+      strictSame(res, expected, 'Got expected result');
+    }
+
+    return end();
+  });
+});

package/test/lnd_responses/test_rpc_payment_as_payment.js

@@ -73,7 +73,9 @@ const makeArgs = overrides => {
 const makeExpected = overrides => {
   const expected = {
     attempts: [{
-      confirmed_at: '1970-01-01T00:00:00.001Z',
+      confirmed_at: undefined,
+      created_at: '1970-01-01T00:00:00.001Z',
+      failed_at: '1970-01-01T00:00:00.001Z',
       is_confirmed: false,
       is_failed: true,
       is_pending: false,
@@ -272,6 +274,8 @@ const tests = [
     expected: makeExpected({
       attempts: [{
         confirmed_at: '2020-04-20T19:17:16.160Z',
+        created_at: '2020-04-20T19:17:15.428Z',
+        failed_at: undefined,
         is_confirmed: true,
         is_failed: false,
         is_pending: false,