tigerbeetle-node 0.14.178 → 0.14.180

package/src/bindings.ts

@@ -24,6 +24,11 @@ export enum AccountFlags {
   * See [credits_must_not_exceed_debits](https://docs.tigerbeetle.com/reference/accounts#flagscredits_must_not_exceed_debits)
   */
   credits_must_not_exceed_debits = (1 << 2),
+
+  /**
+  * See [history](https://docs.tigerbeetle.com/reference/accounts#flagshistory)
+  */
+  history = (1 << 3),
 }
 
 
@@ -66,23 +71,23 @@ export enum TransferFlags {
 
 
 /**
-* See [GetAccountTransfersFlags](https://docs.tigerbeetle.com/reference/operations/get_account_transfers#flags)
+* See [AccountFilterFlags](https://docs.tigerbeetle.com/reference/account_filter#flags)
 */
-export enum GetAccountTransfersFlags {
+export enum AccountFilterFlags {
   none = 0,
 
   /**
-  * See [debits](https://docs.tigerbeetle.com/reference/operations/get_account_transfers#flagsdebits)
+  * See [debits](https://docs.tigerbeetle.com/reference/account_filter#flagsdebits)
   */
   debits = (1 << 0),
 
   /**
-  * See [credits](https://docs.tigerbeetle.com/reference/operations/get_account_transfers#flagscredits)
+  * See [credits](https://docs.tigerbeetle.com/reference/account_filter#flagscredits)
   */
   credits = (1 << 1),
 
   /**
-  * See [reversed](https://docs.tigerbeetle.com/reference/operations/get_account_transfers#flagsreversed)
+  * See [reversed](https://docs.tigerbeetle.com/reference/account_filter#flagsreversed)
   */
   reversed = (1 << 2),
 }
@@ -647,41 +652,74 @@ export type CreateTransfersError = {
 
 
 /**
-* See [GetAccountTransfers](https://docs.tigerbeetle.com/reference/operations/get_account_transfers#)
+* See [AccountFilter](https://docs.tigerbeetle.com/reference/account_filter#)
 */
-export type GetAccountTransfers = {
+export type AccountFilter = {
 
   /**
-  * See [account_id](https://docs.tigerbeetle.com/reference/operations/get_account_transfers#account_id)
+  * See [account_id](https://docs.tigerbeetle.com/reference/account_filter#account_id)
   */
   account_id: bigint
 
   /**
-  * See [timestamp_min](https://docs.tigerbeetle.com/reference/operations/get_account_transfers#timestamp_min)
+  * See [timestamp_min](https://docs.tigerbeetle.com/reference/account_filter#timestamp_min)
   */
   timestamp_min: bigint
 
   /**
-  * See [timestamp_max](https://docs.tigerbeetle.com/reference/operations/get_account_transfers#timestamp_max)
+  * See [timestamp_max](https://docs.tigerbeetle.com/reference/account_filter#timestamp_max)
   */
   timestamp_max: bigint
 
   /**
-  * See [limit](https://docs.tigerbeetle.com/reference/operations/get_account_transfers#limit)
+  * See [limit](https://docs.tigerbeetle.com/reference/account_filter#limit)
   */
   limit: number
 
   /**
-  * See [flags](https://docs.tigerbeetle.com/reference/operations/get_account_transfers#flags)
+  * See [flags](https://docs.tigerbeetle.com/reference/account_filter#flags)
   */
   flags: number
 }
 
+
+/**
+* See [AccountBalance](https://docs.tigerbeetle.com/reference/account_balances#)
+*/
+export type AccountBalance = {
+
+  /**
+  * See [debits_pending](https://docs.tigerbeetle.com/reference/account_balances#debits_pending)
+  */
+  debits_pending: bigint
+
+  /**
+  * See [debits_posted](https://docs.tigerbeetle.com/reference/account_balances#debits_posted)
+  */
+  debits_posted: bigint
+
+  /**
+  * See [credits_pending](https://docs.tigerbeetle.com/reference/account_balances#credits_pending)
+  */
+  credits_pending: bigint
+
+  /**
+  * See [credits_posted](https://docs.tigerbeetle.com/reference/account_balances#credits_posted)
+  */
+  credits_posted: bigint
+
+  /**
+  * See [timestamp](https://docs.tigerbeetle.com/reference/account_balances#timestamp)
+  */
+  timestamp: bigint
+}
+
 export enum Operation {
   create_accounts = 128,
   create_transfers = 129,
   lookup_accounts = 130,
   lookup_transfers = 131,
   get_account_transfers = 132,
+  get_account_history = 133,
 }
 

package/src/index.ts

@@ -5,8 +5,10 @@ import {
   CreateAccountsError,
   CreateTransfersError,
   Operation,
-  GetAccountTransfers,
+  AccountFilter,
+  AccountBalance,
 } from './bindings'
+import { randomFillSync } from 'node:crypto'
 
 const binding: Binding = (() => {
   const { arch, platform } = process
@@ -66,8 +68,8 @@ const binding: Binding = (() => {
 export type Context = object // tb_client
 export type AccountID = bigint // u128
 export type TransferID = bigint // u128
-export type Event = Account | Transfer | AccountID | TransferID | GetAccountTransfers
-export type Result = CreateAccountsError | CreateTransfersError | Account | Transfer
+export type Event = Account | Transfer | AccountID | TransferID | AccountFilter
+export type Result = CreateAccountsError | CreateTransfersError | Account | Transfer | AccountBalance
 export type ResultCallback = (error: Error | null, results: Result[] | null) => void
 
 interface BindingInitArgs {
@@ -93,7 +95,8 @@ export interface Client {
   createTransfers: (batch: Transfer[]) => Promise<CreateTransfersError[]>
   lookupAccounts: (batch: AccountID[]) => Promise<Account[]>
   lookupTransfers: (batch: TransferID[]) => Promise<Transfer[]>
-  getAccountTransfers: (filter: GetAccountTransfers) => Promise<Transfer[]>
+  getAccountTransfers: (filter: AccountFilter) => Promise<Transfer[]>
+  getAccountHistory: (filter: AccountFilter) => Promise<AccountBalance[]>
   destroy: () => void
 }
 
@@ -129,6 +132,49 @@ export function createClient (args: ClientInitArgs): Client {
     lookupAccounts(batch) { return request(Operation.lookup_accounts, batch) },
     lookupTransfers(batch) { return request(Operation.lookup_transfers, batch) },
     getAccountTransfers(filter) { return request(Operation.get_account_transfers, [filter]) },
+    getAccountHistory(filter) { return request(Operation.get_account_history, [filter]) },
     destroy() { binding.deinit(context) },
   }
 }
+
+let idLastTimestamp = 0;
+let idLastBuffer = new DataView(new ArrayBuffer(16));
+
+/**
+ * Generates a Universally Unique and Sortable Identifier as a u128 bigint.
+ *
+ * @remarks
+ * Based on {@link https://github.com/ulid/spec}, IDs returned are guaranteed to be monotonically
+ * increasing.
+ */
+export function id(): bigint {
+  // Ensure timestamp monotonically increases and generate a new random on each new timestamp.
+  let timestamp = Date.now()
+  if (timestamp <= idLastTimestamp) {
+    timestamp = idLastTimestamp
+  } else {
+    idLastTimestamp = timestamp
+    randomFillSync(idLastBuffer)
+  }
+
+  // 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)
+  if (randomHi16 > 0xFFFF) {
+    throw new Error('random bits 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.setUint16(8, randomHi16, littleEndian) // No need to mask since checked above.
+  idLastBuffer.setUint16(10, timestamp & 0xFFFF, littleEndian) // timestamp lo.
+  idLastBuffer.setUint32(12, (timestamp >>> 16) & 0xFFFFFFFF, littleEndian) // timestamp hi.
+
+  // Then return the buffer's contents as a little-endian u128 bigint.
+  const lo = idLastBuffer.getBigUint64(0, littleEndian)
+  const hi = idLastBuffer.getBigUint64(8, littleEndian)
+  return (hi << 64n) | lo
+}

package/src/node.zig

@@ -15,8 +15,9 @@ const Transfer = tb.Transfer;
 const TransferFlags = tb.TransferFlags;
 const CreateAccountsResult = tb.CreateAccountsResult;
 const CreateTransfersResult = tb.CreateTransfersResult;
-const GetAccountTransfers = tb.GetAccountTransfers;
-const GetAccountTransfersFlags = tb.GetAccountTransfersFlags;
+const AccountFilter = tb.AccountFilter;
+const AccountFilterFlags = tb.AccountFilterFlags;
+const AccountBalance = tb.AccountBalance;
 
 const Storage = @import("../../../storage.zig").Storage;
 const StateMachine = @import("../../../state_machine.zig").StateMachineType(Storage, constants.state_machine_config);
@@ -367,7 +368,7 @@ fn decode_array(comptime Event: type, env: c.napi_env, array: c.napi_value, even
     for (events, 0..) |*event, i| {
         const object = try translate.array_element(env, array, @intCast(i));
         switch (Event) {
-            Account, Transfer, GetAccountTransfers => {
+            Account, Transfer, AccountFilter, AccountBalance => {
                 inline for (std.meta.fields(Event)) |field| {
                     const value: field.type = switch (@typeInfo(field.type)) {
                         .Struct => |info| @bitCast(try @field(
@@ -419,6 +420,8 @@ fn encode_array(comptime Result: type, env: c.napi_env, results: []const Result)
             const FieldInt = switch (@typeInfo(field.type)) {
                 .Struct => |info| info.backing_integer.?,
                 .Enum => |info| info.tag_type,
+                // Arrays are only used for padding/reserved fields.
+                .Array => continue,
                 else => field.type,
             };
 
@@ -474,9 +477,7 @@ fn BufferType(comptime op: Operation) type {
             // Allocate enough bytes to hold memory for the Events and the Results.
             const max_bytes = @max(
                 @sizeOf(Event) * count,
-                @sizeOf(Result) *
-                    // Ad-hoc hack, event and result sizes are not the same size.
-                    if (op == .get_account_transfers) 8190 else count,
+                @sizeOf(Result) * event_count(op, count),
             );
             if (@sizeOf(vsr.Header) + max_bytes > constants.message_size_max) {
                 return translate.throw(env, "Batch is larger than the maximum message size.");
@@ -496,9 +497,7 @@ fn BufferType(comptime op: Operation) type {
         fn free(buffer: Buffer) void {
             const max_bytes = @max(
                 @sizeOf(Event) * buffer.count,
-                @sizeOf(Result) *
-                    //TODO(batiati): Refine the way we handle events with asymmetric results.
-                    if (op == .get_account_transfers) 8190 else buffer.count,
+                @sizeOf(Result) * event_count(op, buffer.count),
             );
             const bytes: []align(max_align) u8 = @alignCast(buffer.ptr[0..max_bytes]);
             allocator.free(bytes);
@@ -510,10 +509,16 @@ fn BufferType(comptime op: Operation) type {
         }
 
         fn results(buffer: Buffer) []Result {
-            const result_bytes = buffer.ptr[0 .. @sizeOf(Result) *
-                // Ad-hoc hack, event and result sizes are not the same size.
-                if (op == .get_account_transfers) 8190 else buffer.count];
+            const result_bytes = buffer.ptr[0 .. @sizeOf(Result) * event_count(op, buffer.count)];
             return @alignCast(std.mem.bytesAsSlice(Result, result_bytes));
         }
+
+        fn event_count(operation: Operation, count: usize) usize {
+            // TODO(batiati): Refine the way we handle events with asymmetric results.
+            return switch (operation) {
+                .get_account_transfers, .get_account_history => 8190,
+                else => count,
+            };
+        }
     };
 }