tigerbeetle-node 0.16.78 → 0.17.0

package/src/index.ts

@@ -2,8 +2,8 @@ export * from './bindings'
 import {
   Account,
   Transfer,
-  CreateAccountsError,
-  CreateTransfersError,
+  CreateAccountResult,
+  CreateTransferResult,
   Operation,
   AccountFilter,
   AccountBalance,
@@ -57,14 +57,54 @@ export type Context = object // tb_client
 export type AccountID = bigint // u128
 export type TransferID = bigint // u128
 export type Event = Account | Transfer | AccountID | TransferID | AccountFilter | QueryFilter
-export type Result = CreateAccountsError | CreateTransfersError | Account | Transfer | AccountBalance
+export type Result = CreateAccountResult | CreateTransferResult | Account | Transfer | AccountBalance
 export type ResultCallback = (error: Error | null, results: Result[] | null) => void
 
 export const amount_max: bigint = (2n ** 128n) - 1n
 
+// Error codes returned by the client.
+export const ErrorCodes = {
+  ERR_CLIENT_CLOSED: 'ERR_CLIENT_CLOSED',
+  ERR_CLIENT_EVICTED: 'ERR_CLIENT_EVICTED',
+  ERR_CLIENT_RELEASE_TOO_LOW: 'ERR_CLIENT_RELEASE_TOO_LOW',
+  ERR_CLIENT_RELEASE_TOO_HIGH: 'ERR_CLIENT_RELEASE_TOO_HIGH',
+  ERR_TOO_MUCH_DATA: 'ERR_TOO_MUCH_DATA',
+} as const;
+
+export type ErrorCodes = typeof ErrorCodes[keyof typeof ErrorCodes];
+
+export class RequestError extends Error {
+  code: ErrorCodes;
+
+  constructor(code: ErrorCodes) {
+    super(RequestError.errorMessage(code));
+    this.name = 'RequestError';
+    this.code = code;
+  }
+
+  static errorMessage(code: ErrorCodes): string {
+    switch (code) {
+      case ErrorCodes.ERR_CLIENT_CLOSED:
+        return 'Client was closed.'
+      case ErrorCodes.ERR_CLIENT_EVICTED:
+        return 'Client was evicted.'
+      case ErrorCodes.ERR_CLIENT_RELEASE_TOO_LOW:
+        return 'Client was evicted: release too old.'
+      case ErrorCodes.ERR_CLIENT_RELEASE_TOO_HIGH:
+        return 'Client was evicted: release too new.'
+      case ErrorCodes.ERR_TOO_MUCH_DATA:
+        return 'Too much data was sent or requested in this batch.'
+      default:
+        throw new Error("Unknown error code.")
+    }
+  }
+
+}
+
 interface BindingInitArgs {
   cluster_id: bigint, // u128
   replica_addresses: Buffer,
+  request_error_class: typeof RequestError,
 }
 
 interface Binding {
@@ -79,8 +119,8 @@ export interface ClientInitArgs {
 }
 
 export interface Client {
-  createAccounts: (batch: Account[]) => Promise<CreateAccountsError[]>
-  createTransfers: (batch: Transfer[]) => Promise<CreateTransfersError[]>
+  createAccounts: (batch: Account[]) => Promise<CreateAccountResult[]>
+  createTransfers: (batch: Transfer[]) => Promise<CreateTransferResult[]>
   lookupAccounts: (batch: AccountID[]) => Promise<Account[]>
   lookupTransfers: (batch: TransferID[]) => Promise<Transfer[]>
   getAccountTransfers: (filter: AccountFilter) => Promise<Transfer[]>
@@ -96,6 +136,7 @@ export function createClient (args: ClientInitArgs): Client {
   let context: Context | null = binding.init({
     cluster_id: args.cluster_id,
     replica_addresses: Buffer.from(args.replica_addresses.join(',')),
+    request_error_class: RequestError,
   })
 
   const destroy = () => {
@@ -106,7 +147,8 @@ export function createClient (args: ClientInitArgs): Client {
   const request = <T extends Result>(operation: Operation, batch: Event[]): Promise<T[]> => {
     return new Promise((resolve, reject) => {
       try {
-        if (!context) throw new Error('Client was shutdown.');
+        if (!context) throw new RequestError(ErrorCodes.ERR_CLIENT_CLOSED);
+
         binding.submit(context, operation, batch, (error, result) => {
           if (error) {
             reject(error)
@@ -165,15 +207,20 @@ export function id(): bigint {
   // Increment the u80 in idLastBuffer using carry arithmetic on u32s (as JS doesn't have fast u64).
   const littleEndian = true
   const randomLo32 = idLastBuffer.getUint32(0, littleEndian) + 1
-  const randomHi32 = idLastBuffer.getUint32(4, littleEndian) + (randomLo32 > 0xFFFFFFFF ? 1 : 0)
-  const randomHi16 = idLastBuffer.getUint16(8, littleEndian) + (randomHi32 > 0xFFFFFFFF ? 1 : 0)
+  const randomHi32 = idLastBuffer.getUint32(4, littleEndian) + (randomLo32 > 0xFFFF_FFFF ? 1 : 0)
+  const randomHi16 = idLastBuffer.getUint16(8, littleEndian) + (randomHi32 > 0xFFFF_FFFF ? 1 : 0)
   if (randomHi16 > 0xFFFF) {
-    throw new Error('random bits overflow on monotonic increment')
+    timestamp += 1
+    idLastTimestamp = timestamp
+
+    if (timestamp === 0x1_0000_0000_0000) {
+        throw new Error('timestamp overflow on monotonic increment')
+    }
   }
 
   // Store the incremented random monotonic and the timestamp into the buffer.
-  idLastBuffer.setUint32(0, randomLo32 & 0xFFFFFFFF, littleEndian)
-  idLastBuffer.setUint32(4, randomHi32 & 0xFFFFFFFF, littleEndian)
+  idLastBuffer.setUint32(0, randomLo32 & 0xFFFF_FFFF, littleEndian)
+  idLastBuffer.setUint32(4, randomHi32 & 0xFFFF_FFFF, littleEndian)
   idLastBuffer.setUint16(8, randomHi16, littleEndian) // No need to mask since checked above.
   idLastBuffer.setUint16(10, timestamp & 0xFFFF, littleEndian) // timestamp lo.
   idLastBuffer.setUint32(12, (timestamp / 0x10000) | 0, littleEndian) // timestamp hi.

package/src/test.ts

@@ -4,8 +4,8 @@ import {
   Account,
   Transfer,
   TransferFlags,
-  CreateAccountError,
-  CreateTransferError,
+  CreateAccountStatus,
+  CreateTransferStatus,
   AccountFilter,
   AccountFilterFlags,
   AccountFlags,
@@ -13,6 +13,8 @@ import {
   id,
   QueryFilter,
   QueryFilterFlags,
+  ErrorCodes,
+  RequestError,
 } from '.'
 
 const client = createClient({
@@ -88,23 +90,27 @@ test('range check `code` on Account to be u16', async (): Promise<void> => {
 })
 
 test('can create accounts', async (): Promise<void> => {
-  const errors = await client.createAccounts([accountA])
-  assert.deepStrictEqual(errors, [])
+  const account_results = await client.createAccounts([accountA])
+  assert.deepStrictEqual(account_results.length, 1)
+  assert.ok(account_results[0].timestamp > 0)
+  assert.deepStrictEqual(account_results[0].status, CreateAccountStatus.created)
 })
 
 test('can return error on account', async (): Promise<void> => {
-  const errors = await client.createAccounts([accountA, accountB])
-
-  assert.strictEqual(errors.length, 1)
-  assert.deepStrictEqual(errors[0], { index: 0, result: CreateAccountError.exists })
+  const account_results = await client.createAccounts([accountA, accountB])
+  assert.deepStrictEqual(account_results.length, 2)
+  assert.ok(account_results[0].timestamp > 0)
+  assert.deepStrictEqual(account_results[0].status, CreateAccountStatus.exists)
+  assert.ok(account_results[1].timestamp > 0)
+  assert.deepStrictEqual(account_results[1].status, CreateAccountStatus.created)
 })
 
 test('error if timestamp is not set to 0n on account', async (): Promise<void> => {
   const account = { ...accountA, timestamp: 2n, id: 3n }
-  const errors = await client.createAccounts([account])
-
-  assert.strictEqual(errors.length, 1)
-  assert.deepStrictEqual(errors[0], { index: 0, result: CreateAccountError.timestamp_must_be_zero })
+  const account_results = await client.createAccounts([account])
+  assert.deepStrictEqual(account_results.length, 1)
+  assert.ok(account_results[0].timestamp > 0)
+  assert.deepStrictEqual(account_results[0].status, CreateAccountStatus.timestamp_must_be_zero)
 })
 
 test('batch max size', async (): Promise<void> => {
@@ -127,13 +133,11 @@ test('batch max size', async (): Promise<void> => {
       timestamp: 0n,
     });
   }
-
-  try {
-    const results = await client.createTransfers(transfers);
-    assert.fail();
-  } catch (error) {
-    assert.strictEqual(error.message, "Too much data provided on this batch.");
-  }
+  assert.rejects(async() => await client.createTransfers(transfers), (err) => {
+    assert.ok(err instanceof RequestError)
+    assert.strictEqual(err.code,  ErrorCodes.ERR_TOO_MUCH_DATA)
+    return true
+  })
 })
 
 test('can lookup accounts', async (): Promise<void> => {
@@ -186,8 +190,10 @@ test('can create a transfer', async (): Promise<void> => {
     timestamp: 0n, // this will be set correctly by the TigerBeetle server
   }
 
-  const errors = await client.createTransfers([transfer])
-  assert.deepStrictEqual(errors, [])
+  const transfers_results = await client.createTransfers([transfer])
+  assert.deepStrictEqual(transfers_results.length, 1)
+  assert.ok(transfers_results[0].timestamp > 0)
+  assert.deepStrictEqual(transfers_results[0].status, CreateTransferStatus.created)
 
   const accounts = await client.lookupAccounts([accountA.id, accountB.id])
   assert.strictEqual(accounts.length, 2)
@@ -221,8 +227,10 @@ test('can create a two-phase transfer', async (): Promise<void> => {
     timestamp: 0n, // this will be set correctly by the TigerBeetle server
   }
 
-  const errors = await client.createTransfers([transfer])
-  assert.deepStrictEqual(errors, [])
+  const transfers_results = await client.createTransfers([transfer])
+  assert.deepStrictEqual(transfers_results.length, 1)
+  assert.ok(transfers_results[0].timestamp > 0)
+  assert.deepStrictEqual(transfers_results[0].status, CreateTransferStatus.created)
 
   const accounts = await client.lookupAccounts([accountA.id, accountB.id])
   assert.strictEqual(accounts.length, 2)
@@ -272,8 +280,10 @@ test('can post a two-phase transfer', async (): Promise<void> => {
     timestamp: 0n, // this will be set correctly by the TigerBeetle server
   }
 
-  const errors = await client.createTransfers([commit])
-  assert.deepStrictEqual(errors, [])
+  const transfers_results = await client.createTransfers([commit])
+  assert.deepStrictEqual(transfers_results.length, 1)
+  assert.ok(transfers_results[0].timestamp > 0)
+  assert.deepStrictEqual(transfers_results[0].status, CreateTransferStatus.created)
 
   const accounts = await client.lookupAccounts([accountA.id, accountB.id])
   assert.strictEqual(accounts.length, 2)
@@ -305,8 +315,10 @@ test('can reject a two-phase transfer', async (): Promise<void> => {
     flags: TransferFlags.pending,
     timestamp: 0n, // this will be set correctly by the TigerBeetle server
   }
-  const transferErrors = await client.createTransfers([transfer])
-  assert.deepStrictEqual(transferErrors, [])
+  let transfers_results = await client.createTransfers([transfer])
+  assert.deepStrictEqual(transfers_results.length, 1)
+  assert.ok(transfers_results[0].timestamp > 0)
+  assert.deepStrictEqual(transfers_results[0].status, CreateTransferStatus.created)
 
   // send in the reject
   const reject: Transfer = {
@@ -325,8 +337,10 @@ test('can reject a two-phase transfer', async (): Promise<void> => {
     timestamp: 0n, // this will be set correctly by the TigerBeetle server
   }
 
-  const errors = await client.createTransfers([reject])
-  assert.deepStrictEqual(errors, [])
+  transfers_results = await client.createTransfers([reject])
+  assert.deepStrictEqual(transfers_results.length, 1)
+  assert.ok(transfers_results[0].timestamp > 0)
+  assert.deepStrictEqual(transfers_results[0].status, CreateTransferStatus.created)
 
   const accounts = await client.lookupAccounts([accountA.id, accountB.id])
   assert.strictEqual(accounts.length, 2)
@@ -375,10 +389,12 @@ test('can link transfers', async (): Promise<void> => {
     timestamp: 0n, // will be set correctly by the TigerBeetle server
   }
 
-  const errors = await client.createTransfers([transfer1, transfer2])
-  assert.strictEqual(errors.length, 2)
-  assert.deepStrictEqual(errors[0], { index: 0, result: CreateTransferError.linked_event_failed })
-  assert.deepStrictEqual(errors[1], { index: 1, result: CreateTransferError.exists_with_different_flags })
+  const transfers_results = await client.createTransfers([transfer1, transfer2])
+  assert.deepStrictEqual(transfers_results.length, 2)
+  assert.ok(transfers_results[0].timestamp > 0)
+  assert.deepStrictEqual(transfers_results[0].status, CreateTransferStatus.linked_event_failed)
+  assert.ok(transfers_results[1].timestamp > 0)
+  assert.deepStrictEqual(transfers_results[1].status, CreateTransferStatus.exists_with_different_flags)
 
   const accounts = await client.lookupAccounts([accountA.id, accountB.id])
   assert.strictEqual(accounts.length, 2)
@@ -410,8 +426,10 @@ test('cannot void an expired transfer', async (): Promise<void> => {
     flags: TransferFlags.pending,
     timestamp: 0n, // this will be set correctly by the TigerBeetle server
   }
-  const transferErrors = await client.createTransfers([transfer])
-  assert.deepStrictEqual(transferErrors, [])
+  let transfers_results = await client.createTransfers([transfer])
+  assert.deepStrictEqual(transfers_results.length, 1)
+  assert.ok(transfers_results[0].timestamp > 0)
+  assert.deepStrictEqual(transfers_results[0].status, CreateTransferStatus.created)
 
   var accounts = await client.lookupAccounts([accountA.id, accountB.id])
   assert.strictEqual(accounts.length, 2)
@@ -462,9 +480,10 @@ test('cannot void an expired transfer', async (): Promise<void> => {
     timestamp: 0n, // this will be set correctly by the TigerBeetle server
   }
 
-  const errors = await client.createTransfers([reject])
-  assert.strictEqual(errors.length, 1)
-  assert.deepStrictEqual(errors[0], { index: 0, result: CreateTransferError.pending_transfer_expired })
+  transfers_results = await client.createTransfers([reject])
+  assert.deepStrictEqual(transfers_results.length, 1)
+  assert.ok(transfers_results[0].timestamp > 0)
+  assert.deepStrictEqual(transfers_results[0].status, CreateTransferStatus.pending_transfer_expired)
 })
 
 test('can close accounts', async (): Promise<void> => {
@@ -483,8 +502,10 @@ test('can close accounts', async (): Promise<void> => {
     flags: TransferFlags.closing_debit | TransferFlags.closing_credit | TransferFlags.pending,
     timestamp: 0n, // will be set correctly by the TigerBeetle server
   }
-  let errors = await client.createTransfers([closing_transfer])
-  assert.strictEqual(errors.length, 0)
+  let transfers_results = await client.createTransfers([closing_transfer])
+  assert.deepStrictEqual(transfers_results.length, 1)
+  assert.ok(transfers_results[0].timestamp > 0)
+  assert.deepStrictEqual(transfers_results[0].status, CreateTransferStatus.created)
 
   let accounts = await client.lookupAccounts([accountA.id, accountB.id])
   assert.strictEqual(accounts.length, 2)
@@ -510,8 +531,10 @@ test('can close accounts', async (): Promise<void> => {
     timestamp: 0n, // will be set correctly by the TigerBeetle server
   }
 
-  errors = await client.createTransfers([voiding_transfer])
-  assert.strictEqual(errors.length, 0)
+  transfers_results = await client.createTransfers([voiding_transfer])
+  assert.deepStrictEqual(transfers_results.length, 1)
+  assert.ok(transfers_results[0].timestamp > 0)
+  assert.deepStrictEqual(transfers_results[0].status, CreateTransferStatus.created)
 
   accounts = await client.lookupAccounts([accountA.id, accountB.id])
   assert.strictEqual(accounts.length, 2)
@@ -538,8 +561,10 @@ test('can get account transfers', async (): Promise<void> => {
     flags: AccountFlags.history,
     timestamp: 0n
   }
-  const account_errors = await client.createAccounts([accountC])
-  assert.deepStrictEqual(account_errors, [])
+  const account_results = await client.createAccounts([accountC])
+  assert.deepStrictEqual(account_results.length, 1)
+  assert.ok(account_results[0].timestamp > 0)
+  assert.deepStrictEqual(account_results[0].status, CreateAccountStatus.created)
 
   var transfers_created : Transfer[] = [];
   // Create transfers where the new account is either the debit or credit account:
@@ -561,8 +586,12 @@ test('can get account transfers', async (): Promise<void> => {
     });
   }
 
-  const transfers_created_result = await client.createTransfers(transfers_created)
-  assert.deepStrictEqual(transfers_created_result, [])
+  const transfers_results = await client.createTransfers(transfers_created)
+  assert.deepStrictEqual(transfers_results.length, transfers_created.length)
+  for (const result of transfers_results) {
+    assert.ok(result.timestamp > 0)
+    assert.deepStrictEqual(result.status, CreateTransferStatus.created)
+  }
 
   // Query all transfers for accountC:
   var filter: AccountFilter = {
@@ -868,6 +897,29 @@ test('can get account transfers', async (): Promise<void> => {
   assert.deepStrictEqual((await client.getAccountTransfers(filter)), [])
   assert.deepStrictEqual((await client.getAccountBalances(filter)), [])
 
+  // TooMuchData
+  filter = {
+    account_id: accountC.id,
+    user_data_128: 0n,
+    user_data_64: 0n,
+    user_data_32: 0,
+    code: 0,
+    timestamp_min: 0n,
+    timestamp_max: 0n,
+    limit: 10_000,
+    flags: AccountFilterFlags.credits | AccountFilterFlags.debits,
+  }
+  assert.rejects(async() => await client.getAccountTransfers(filter), (err) => {
+    assert.ok(err instanceof RequestError)
+    assert.strictEqual(err.code,  ErrorCodes.ERR_TOO_MUCH_DATA)
+    return true
+  })
+  assert.rejects(async() => await client.getAccountBalances(filter), (err) => {
+    assert.ok(err instanceof RequestError)
+    assert.strictEqual(err.code,  ErrorCodes.ERR_TOO_MUCH_DATA)
+    return true
+  })
+
   // Empty flags:
   filter = {
     account_id: accountC.id,
@@ -922,8 +974,12 @@ test('can query accounts', async (): Promise<void> => {
       })
     }
 
-    const create_accounts_result = await client.createAccounts(accounts)
-    assert.deepStrictEqual(create_accounts_result, [])
+    const account_results = await client.createAccounts(accounts)
+    assert.deepStrictEqual(account_results.length, accounts.length)
+    for (const result of account_results) {
+      assert.ok(result.timestamp > 0)
+      assert.deepStrictEqual(result.status, CreateAccountStatus.created)
+    }
   }
 
   {
@@ -1094,8 +1150,10 @@ test('can query transfers', async (): Promise<void> => {
       flags: AccountFlags.none,
       timestamp: 0n
     }
-    const create_accounts_result = await client.createAccounts([account])
-    assert.deepStrictEqual(create_accounts_result, [])
+    const account_results = await client.createAccounts([account])
+    assert.deepStrictEqual(account_results.length, 1)
+    assert.ok(account_results[0].timestamp > 0)
+    assert.deepStrictEqual(account_results[0].status, CreateAccountStatus.created)
 
     var transfers_created : Transfer[] = [];
     // Create transfers:
@@ -1117,8 +1175,12 @@ test('can query transfers', async (): Promise<void> => {
       })
     }
 
-    const create_transfers_result = await client.createTransfers(transfers_created)
-    assert.deepStrictEqual(create_transfers_result, [])
+    const transfers_results = await client.createTransfers(transfers_created)
+    assert.deepStrictEqual(transfers_results.length, transfers_created.length)
+    for (const result of transfers_results) {
+      assert.ok(result.timestamp > 0)
+      assert.deepStrictEqual(result.status, CreateTransferStatus.created)
+    }
   }
 
   {
@@ -1333,6 +1395,29 @@ test('query with invalid filter', async (): Promise<void> => {
   assert.deepStrictEqual((await client.queryAccounts(filter)), [])
   assert.deepStrictEqual((await client.queryTransfers(filter)), [])
 
+  // TooMuchData
+  filter = {
+    user_data_128: 0n,
+    user_data_64: 0n,
+    user_data_32: 0,
+    ledger: 0,
+    code: 0,
+    timestamp_min: 0n,
+    timestamp_max: 0n,
+    limit: 10_000,
+    flags: QueryFilterFlags.none,
+  }
+  assert.rejects(async() => await client.queryAccounts(filter), (err) => {
+    assert.ok(err instanceof RequestError)
+    assert.strictEqual(err.code,  ErrorCodes.ERR_TOO_MUCH_DATA)
+    return true
+  })
+  assert.rejects(async() => await client.queryTransfers(filter), (err) => {
+    assert.ok(err instanceof RequestError)
+    assert.strictEqual(err.code,  ErrorCodes.ERR_TOO_MUCH_DATA)
+    return true
+  })
+
   // Invalid flags:
   filter = {
     user_data_128: 0n,
@@ -1365,8 +1450,10 @@ test('can import accounts and transfers', async (): Promise<void> => {
     flags: 0,
     timestamp: 0n // this will be set correctly by the TigerBeetle server
   }
-  let accountsErrors = await client.createAccounts([accountTmp])
-  assert.deepStrictEqual(accountsErrors, [])
+  let account_results = await client.createAccounts([accountTmp])
+  assert.deepStrictEqual(account_results.length, 1)
+  assert.ok(account_results[0].timestamp > 0)
+  assert.deepStrictEqual(account_results[0].status, CreateAccountStatus.created)
 
   let accountLookup = await client.lookupAccounts([accountTmp.id])
   assert.strictEqual(accountLookup.length, 1)
@@ -1406,8 +1493,12 @@ test('can import accounts and transfers', async (): Promise<void> => {
     flags: AccountFlags.imported,
     timestamp: timestampMax + 2n // user-defined timestamp
   }
-  accountsErrors = await client.createAccounts([accountA, accountB])
-  assert.deepStrictEqual(accountsErrors, [])
+  account_results = await client.createAccounts([accountA, accountB])
+  assert.deepStrictEqual(account_results.length, 2)
+  assert.ok(account_results[0].timestamp > 0)
+  assert.deepStrictEqual(account_results[0].status, CreateAccountStatus.created)
+  assert.ok(account_results[1].timestamp > 0)
+  assert.deepStrictEqual(account_results[1].status, CreateAccountStatus.created)
 
   accountLookup = await client.lookupAccounts([accountA.id, accountB.id])
   assert.strictEqual(accountLookup.length, 2)
@@ -1430,8 +1521,10 @@ test('can import accounts and transfers', async (): Promise<void> => {
     timestamp: timestampMax + 3n, // user-defined timestamp.
   }
 
-  const errors = await client.createTransfers([transfer])
-  assert.deepStrictEqual(errors, [])
+  const transfers_results = await client.createTransfers([transfer])
+  assert.deepStrictEqual(transfers_results.length, 1)
+  assert.ok(transfers_results[0].timestamp > 0)
+  assert.deepStrictEqual(transfers_results[0].status, CreateTransferStatus.created)
 
   const transfers = await client.lookupTransfers([transfer.id])
   assert.strictEqual(transfers.length, 1)
@@ -1439,13 +1532,13 @@ test('can import accounts and transfers', async (): Promise<void> => {
 })
 
 test('accept zero-length create_accounts', async (): Promise<void> => {
-  const errors = await client.createAccounts([])
-  assert.deepStrictEqual(errors, [])
+  const account_results = await client.createAccounts([])
+  assert.deepStrictEqual(account_results.length, 0)
 })
 
 test('accept zero-length create_transfers', async (): Promise<void> => {
-  const errors = await client.createTransfers([])
-  assert.deepStrictEqual(errors, [])
+  const transfers_results = await client.createTransfers([])
+  assert.deepStrictEqual(transfers_results.length, 0)
 })
 
 test('accept zero-length lookup_accounts', async (): Promise<void> => {
@@ -1462,13 +1555,11 @@ test("destroy client in-flight", async (): Promise<void> => {
   // Non-existing cluster.
   const client = createClient({ cluster_id: 92n, replica_addresses: ["99"] });
   setTimeout(() => client.destroy(), 30);
-  try {
-    await client.lookupAccounts([0n]);
-  } catch (error) {
-    assert.strictEqual(error.message, "Client was shutdown.");
-    return;
-  }
-  throw "expected an error";
+  assert.rejects(async () => await client.lookupAccounts([0n]), (err) => {
+    assert.ok(err instanceof RequestError)
+    assert.strictEqual(err.code,  ErrorCodes.ERR_CLIENT_CLOSED)
+    return true
+  })
 });
 
 async function main () {