astra-lightning 1.0.0

package/test/lnd_methods/offchain/test_verify_backup.js

@@ -0,0 +1,48 @@
+const {deepStrictEqual} = require('node:assert').strict;
+const {rejects} = require('node:assert').strict;
+const test = require('node:test');
+
+const {verifyBackup} = require('./../../../');
+
+const tests = [
+  {
+    args: {},
+    description: 'A backup to verify is required',
+    error: [400, 'ExpectedChannelBackupToVerify'],
+  },
+  {
+    args: {backup: '00'},
+    description: 'An authenticated LND object is required',
+    error: [400, 'ExpectedLndToVerifyChannelBackup'],
+  },
+  {
+    args: {
+      backup: '00',
+      lnd: {default: {verifyChanBackup: ({}, cbk) => cbk('err')}},
+    },
+    description: 'Channel backup is invalid',
+    expected: {err: 'err', is_valid: false},
+  },
+  {
+    args: {
+      backup: '00',
+      lnd: {default: {verifyChanBackup: ({}, cbk) => cbk()}},
+    },
+    description: 'Channel backup is valid',
+    expected: {is_valid: true},
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async () => {
+    if (!!error) {
+      await rejects(verifyBackup(args), error, 'Got expected error');
+    } else {
+      const res = await verifyBackup(args);
+
+      deepStrictEqual(res, expected, 'Got expected result');
+    }
+
+    return;
+  });
+});

package/test/lnd_methods/offchain/test_verify_backups.js

@@ -0,0 +1,85 @@
+const {deepStrictEqual} = require('node:assert').strict;
+const {rejects} = require('node:assert').strict;
+const test = require('node:test');
+
+const {verifyBackups} = require('./../../../');
+
+const tests = [
+  {
+    args: {},
+    description: 'A backup to verify is required',
+    error: [400, 'ExpectedMultiChannelBackupToVerify'],
+  },
+  {
+    args: {backup: '00'},
+    description: 'Channels to verify are required',
+    error: [400, 'ExpectedChannelsToVerifyInMultiBackup'],
+  },
+  {
+    args: {
+      backup: '00',
+      channels: [{
+        transaction_id: Buffer.alloc(32).toString('hex'),
+        transaction_vout: 0,
+      }],
+    },
+    description: 'An authenticated LND object is required',
+    error: [400, 'ExpectedAuthenticatedLndToVerifyChanBackup'],
+  },
+  {
+    args: {
+      backup: '00',
+      channels: [{transaction_vout: 0}],
+      lnd: {default: {verifyChanBackup: ({}, cbk) => cbk('err')}},
+    },
+    description: 'Channel id is required',
+    error: [400, 'ExpectedChannelOutpointsToVerifyBackups'],
+  },
+  {
+    args: {
+      backup: '00',
+      channels: [{transaction_id: Buffer.alloc(32).toString('hex')}],
+      lnd: {default: {verifyChanBackup: ({}, cbk) => cbk('err')}},
+    },
+    description: 'Channel vout is required',
+    error: [400, 'ExpectedChannelOutpointsToVerifyBackups'],
+  },
+  {
+    args: {
+      backup: '00',
+      channels: [{
+        transaction_id: Buffer.alloc(32).toString('hex'),
+        transaction_vout: 0,
+      }],
+      lnd: {default: {verifyChanBackup: ({}, cbk) => cbk('err')}},
+    },
+    description: 'Channel backup is invalid',
+    expected: {is_valid: false},
+  },
+  {
+    args: {
+      backup: '00',
+      channels: [{
+        transaction_id: Buffer.alloc(32).toString('hex'),
+        transaction_vout: 0,
+      }],
+      lnd: {default: {verifyChanBackup: ({}, cbk) => cbk()}},
+    },
+    description: 'Channel backup is valid',
+    expected: {is_valid: true},
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async () => {
+    if (!!error) {
+      await rejects(verifyBackups(args), error, 'Got expected error');
+    } else {
+      const res = await verifyBackups(args);
+
+      deepStrictEqual(res, expected, 'Got expected result');
+    }
+
+    return;
+  });
+});

package/test/lnd_methods/onchain/test_broadcast_chain_transaction.js

@@ -0,0 +1,97 @@
+const {rejects} = require('node:assert').strict;
+const {strictEqual} = require('node:assert').strict;
+const test = require('node:test');
+
+const {Transaction} = require('bitcoinjs-lib');
+
+const {broadcastChainTransaction} = require('./../../../lnd_methods');
+
+const tests = [
+  {
+    args: {},
+    description: 'LND is required',
+    error: [400, 'ExpectedWalletRpcLndToSendRawTransaction'],
+  },
+  {
+    args: {lnd: {wallet: {publishTransaction: ({}, cbk) => cbk()}}},
+    description: 'Raw transaction is required',
+    error: [400, 'ExpectedTransactionHexStringToBroadcastToPeers'],
+  },
+  {
+    args: {
+      lnd: {wallet: {publishTransaction: ({}, cbk) => cbk('err')}},
+      transaction: new Transaction().toHex(),
+    },
+    description: 'Expected error is returned',
+    error: [503, 'UnexpectedErrBroadcastingRawTx', {err: 'err'}],
+  },
+  {
+    args: {
+      lnd: {wallet: {publishTransaction: ({}, cbk) => cbk()}},
+      transaction: new Transaction().toHex(),
+    },
+    description: 'A result is required',
+    error: [503, 'ExpectedResultOfBroadcastRawTransaction'],
+  },
+  {
+    args: {
+      lnd: {
+        wallet: {
+          publishTransaction: ({}, cbk) => cbk(null, {publish_error: 'err'}),
+        },
+      },
+      transaction: new Transaction().toHex(),
+    },
+    description: 'Failure to broadcast error is returned',
+    error: [
+      503,
+      'FailedToBroadcastRawTransaction',
+      {res: {publish_error: 'err'}},
+    ],
+  },
+  {
+    args: {
+      lnd: {
+        wallet: {
+          publishTransaction: ({}, cbk) => cbk({
+            details: 'unmatched backend error: -26: mempool min fee not met, 123 < 1234',
+          }),
+        },
+      },
+      transaction: new Transaction().toHex(),
+    },
+    description: 'Minimum relay fee not met',
+    error: [
+      503,
+      'ChainBackendMinimumRelayFeeNotMet',
+      {
+        fee: 123,
+        minimum: 1234,
+      },
+    ],
+  },
+  {
+    args: {
+      lnd: {wallet: {publishTransaction: ({}, cbk) => cbk(null, {})}},
+      transaction: new Transaction().toHex(),
+    },
+    description: 'A transaction is published',
+    expected: {
+      id: 'd21633ba23f70118185227be58a63527675641ad37967e2aa461559f577aec43',
+    },
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async () => {
+    if (!!error) {
+      await rejects(() => broadcastChainTransaction(args), error, 'Got error');
+    } else {
+      const {id} = await broadcastChainTransaction(args);
+
+      strictEqual(id, expected.id, 'Got fee rate');
+    }
+
+    return;
+  });
+});

package/test/lnd_methods/onchain/test_cancel_pending_channel.js

@@ -0,0 +1,40 @@
+const {rejects} = require('node:assert').strict;
+const test = require('node:test');
+
+const {cancelPendingChannel} = require('./../../../lnd_methods');
+
+const id = Buffer.alloc(32).toString('hex');
+
+const tests = [
+  {
+    args: {},
+    description: 'A pending channel id is required to cancel pending channel',
+    error: [400, 'ExpectedPendingChannelIdToCancelPendingChannel'],
+  },
+  {
+    args: {id},
+    description: 'LND Object is required to cancel pending channel',
+    error: [400, 'ExpectedAuthenticatedLndToCancelPendingChannel'],
+  },
+  {
+    args: {id, lnd: {default: {fundingStateStep: ({}, cbk) => cbk('err')}}},
+    description: 'Funding state step error is returned',
+    error: [503, 'UnexpectedErrorCancelingPendingChannel', {err: 'err'}],
+  },
+  {
+    args: {id, lnd: {default: {fundingStateStep: ({}, cbk) => cbk()}}},
+    description: 'Funding state step is executed',
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async () => {
+    if (!!error) {
+      await rejects(() => cancelPendingChannel(args), error, 'Got error');
+    } else {
+      await cancelPendingChannel(args);
+    }
+
+    return;
+  });
+});

package/test/lnd_methods/onchain/test_close_channel.js

@@ -0,0 +1,214 @@
+const {deepStrictEqual} = require('node:assert').strict;
+const EventEmitter = require('node:events');
+const {rejects} = require('node:assert').strict;
+const test = require('node:test');
+
+const {closeChannel} = require('./../../../lnd_methods');
+
+const makeLnd = ({err, data}) => {
+  const lnd = {
+    default: {
+      closeChannel: ({}) => {
+        const emitter = new EventEmitter();
+
+        emitter.cancel = () => {};
+
+        process.nextTick(() => {
+
+          if (!!err) {
+            return emitter.emit('error', err);
+          }
+
+          emitter.emit('data', {update: 'chan_close'});
+          emitter.emit('data', {update: 'confirmation'});
+          emitter.emit('data', {update: 'unknown'});
+          emitter.emit('status', {});
+          emitter.emit('end', {});
+
+          if (!!data) {
+            emitter.emit('data', data);
+          } else {
+            emitter.emit('data', {
+              close_pending: {
+                output_index: 0,
+                txid: Buffer.from('01020304', 'hex'),
+              },
+              update: 'close_pending',
+            });
+            emitter.emit('data', {
+              close_pending: {
+                output_index: 0,
+                txid: Buffer.from('01020304', 'hex'),
+              },
+              update: 'close_pending',
+            });
+          }
+        });
+
+        return emitter;
+      },
+      connectPeer: ({}, cbk) => cbk(null, {}),
+      getChanInfo: ({}, cbk) => {
+        return cbk(null, {
+          capacity: '1',
+          chan_point: `${Buffer.alloc(32).toString('hex')}:0`,
+          channel_id: '000000000',
+          node1_policy: {
+            disabled: true,
+            fee_base_msat: '1',
+            fee_rate_milli_msat: '1',
+            last_update: 1,
+            max_htlc_msat: '1',
+            min_htlc: '1',
+            time_lock_delta: 1,
+          },
+          node1_pub: Buffer.alloc(33).toString('hex'),
+          node2_policy: {
+            disabled: false,
+            fee_base_msat: '2',
+            fee_rate_milli_msat: '2',
+            last_update: 1,
+            max_htlc_msat: '2',
+            min_htlc: '2',
+            time_lock_delta: 2,
+          },
+          node2_pub: Buffer.alloc(33, 1).toString('hex'),
+        });
+      },
+      listPeers: ({}, cbk) => cbk(null, {
+        peers: [{
+          address: 'address',
+          bytes_recv: '0',
+          bytes_sent: '0',
+          features: {},
+          flap_count: 0,
+          last_flap_ns: '0',
+          inbound: false,
+          ping_time: '0',
+          pub_key: Buffer.alloc(33).toString('hex'),
+          sat_recv: '0',
+          sat_sent: '0',
+          sync_type: 'ACTIVE_SYNC',
+        }],
+      }),
+    },
+  };
+
+  return lnd;
+};
+
+const makeArgs = overrides => {
+  const args = {
+    lnd: makeLnd({}),
+    transaction_id: Buffer.alloc(32).toString('hex'),
+    transaction_vout: 0,
+  };
+
+  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
+
+  return args;
+};
+
+const tests = [
+  {
+    args: makeArgs({address: 'address', is_force_close: true}),
+    description: 'Address cannot be specified on force close',
+    error: [400, 'ExpectedCoopCloseWhenCloseAddressSpecified'],
+  },
+  {
+    args: makeArgs({transaction_id: undefined, transaction_vout: undefined}),
+    description: 'Either id or transaction outpoint must be specified',
+    error: [400, 'ExpectedIdOfChannelToClose'],
+  },
+  {
+    args: makeArgs({lnd: undefined}),
+    description: 'LND is required',
+    error: [400, 'ExpectedLndToExecuteChannelClose'],
+  },
+  {
+    args: makeArgs({public_key: 'public_key'}),
+    description: 'A socket is required when public key is specified',
+    error: [400, 'ExpectedBothPublicKeyAndSocketForChannelClose'],
+  },
+  {
+    args: makeArgs({socket: 'socket'}),
+    description: 'A public key is required when public key is specified',
+    error: [400, 'ExpectedBothPublicKeyAndSocketForChannelClose'],
+  },
+  {
+    args: makeArgs({target_confirmations: 1, tokens_per_vbyte: 1}),
+    description: 'Either confs or fee rate is allowed, not both',
+    error: [400, 'UnexpectedTokensPerVbyteForChannelClose'],
+  },
+  {
+    args: makeArgs({is_force_close: true, tokens_per_vbyte: 1}),
+    description: 'Setting fee rate is not allowed on force closes',
+    error: [400, 'UnexpectedFeeSettingForForceCloseChannel'],
+  },
+  {
+    args: makeArgs({lnd: makeLnd({data: {update: 'close_pending'}})}),
+    description: 'Close pending data is expected',
+    error: [503, 'ExpectedClosePendingData'],
+  },
+  {
+    args: makeArgs({lnd: makeLnd({err: 'err'})}),
+    description: 'Opening error event is returned',
+    error: [503, 'UnexpectedCloseChannelError', {err: 'err'}],
+  },
+  {
+    args: makeArgs({
+      lnd: makeLnd({data: {close_pending: {}, update: 'close_pending'}}),
+    }),
+    description: 'Close tx vout is expected',
+    error: [503, 'ExpectedOutputIndexForPendingChanClose'],
+  },
+  {
+    args: makeArgs({
+      lnd: makeLnd({
+        data: {
+          close_pending: {output_index: 0},
+          update: 'close_pending',
+        },
+      }),
+    }),
+    description: 'Close tx id is expected',
+    error: [503, 'ExpectedClosePendingTransactionId'],
+  },
+  {
+    args: makeArgs({
+      public_key: Buffer.alloc(33).toString('hex'),
+      socket: 'socket',
+    }),
+    description: 'A peer is connected before closing',
+    expected: {transaction_id: '04030201', transaction_vout: 0},
+  },
+  {
+    args: makeArgs({id: 'id'}),
+    description: 'An id can be specified instead of the outpoint',
+    expected: {transaction_id: '04030201', transaction_vout: 0},
+  },
+  {
+    args: makeArgs({}),
+    description: 'A channel is closed',
+    expected: {transaction_id: '04030201', transaction_vout: 0},
+  },
+  {
+    args: makeArgs({tokens_per_vbyte: 1}),
+    description: 'A channel is closed with a tx fee',
+    expected: {transaction_id: '04030201', transaction_vout: 0},
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async () => {
+    if (!!error) {
+      await rejects(closeChannel(args), error, 'Got expected error');
+    } else {
+      const res = await closeChannel(args);
+
+      deepStrictEqual(res, expected, 'Got expected result');
+    }
+
+    return;
+  });
+});

package/test/lnd_methods/onchain/test_create_funded_psbt.js

@@ -0,0 +1,135 @@
+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({change_format: 'change_format'}),
+    description: 'A valid change format is required',
+    error: [400, 'ExpectedKnownChangeFormatToFundPsbt'],
+  },
+  {
+    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/test/lnd_methods/onchain/test_delete_chain_transaction.js

@@ -0,0 +1,85 @@
+const {deepEqual} = require('node:assert').strict;
+const {rejects} = require('node:assert').strict;
+const test = require('node:test');
+
+const {deleteChainTransaction} = require('./../../../lnd_methods');
+
+const makeLnd = () => {
+  return {
+    wallet: {
+      removeTransaction: ({}, cbk) => {
+        return cbk(null, {status: 'Successfully removed transaction'});
+      },
+    },
+  };
+};
+
+const tests = [
+  {
+    args: {},
+    description: 'An id is required to delete a chain transaction',
+    error: [400, 'ExpectedIdentifyingTxHashOfChainTxToDelete'],
+  },
+  {
+    args: {id: Buffer.alloc(32).toString('hex')},
+    description: 'LND Object is required to delete a chain transaction',
+    error: [400, 'ExpectedLndToDeleteChainTransaction'],
+  },
+  {
+    args: {
+      id: Buffer.alloc(32).toString('hex'),
+      lnd: {wallet: {removeTransaction: ({}, cbk) => cbk('err')}},
+    },
+    description: 'Errors are passed back from remove transaction method',
+    error: [503, 'UnexpectedDeleteChainTransactionError', {err: 'err'}],
+  },
+  {
+    args: {
+      id: Buffer.alloc(32).toString('hex'),
+      lnd: {
+        wallet: {
+          removeTransaction: ({}, cbk) => cbk({
+            details: 'unknown walletrpc.WalletKit',
+          }),
+        },
+      },
+    },
+    description: 'Unsupported errors are returned',
+    error: [501, 'RemoveChainTransactionMethodNotSupported'],
+  },
+  {
+    args: {
+      id: Buffer.alloc(32).toString('hex'),
+      lnd: {wallet: {removeTransaction: ({}, cbk) => cbk()}},
+    },
+    description: 'A response is expected from remove transaction',
+    error: [503, 'ExpectedResponseDeletingChainTransaction'],
+  },
+  {
+    args: {
+      id: Buffer.alloc(32).toString('hex'),
+      lnd: {wallet: {removeTransaction: ({}, cbk) => cbk(null, {})}},
+    },
+    description: 'A success response is expected from remove transaction',
+    error: [503, 'UnexpectedResponseDeletingChainTransaction'],
+  },
+  {
+    args: {
+      id: Buffer.alloc(32).toString('hex'),
+      lnd: makeLnd({}),
+    },
+    description: 'Remove transaction returns successfully',
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async () => {
+    if (!!error) {
+      await rejects(() => deleteChainTransaction(args), error, 'Got err');
+    } else {
+      await deleteChainTransaction(args);
+    }
+
+    return;
+  });
+});