tigerbeetle-node 0.11.2 → 0.11.4

package/dist/.client.node.sha256

@@ -1 +1 @@
-5e64232ef290c0ed5f8b48762a2f9d03683e4a2ac5d74fc06ea594c035ec4b8b  dist/client.node
+17ba799be39b3aa1c55b37b39f013d58b0c9d8a5e3356aa750951d4c3cc7e248  dist/client.node

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tigerbeetle-node",
-  "version": "0.11.2",
+  "version": "0.11.4",
   "description": "TigerBeetle Node.js client",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",

package/src/node.zig

@@ -20,12 +20,17 @@ const Operation = StateMachine.Operation;
 const MessageBus = @import("tigerbeetle/src/message_bus.zig").MessageBusClient;
 const MessagePool = @import("tigerbeetle/src/message_pool.zig").MessagePool;
 const IO = @import("tigerbeetle/src/io.zig").IO;
-const config = @import("tigerbeetle/src/config.zig");
+const config = @import("tigerbeetle/src/constants.zig");
 
 const vsr = @import("tigerbeetle/src/vsr.zig");
 const Header = vsr.Header;
 const Client = vsr.Client(StateMachine, MessageBus);
 
+// TODO(jamii)
+// This is a hack used to work around the absence of tigerbeetle_build_options.
+// This should be removed once the node client is built using `zig build`.
+pub const tracer_backend: @import("tigerbeetle/src/config.zig").TracerBackend = .none;
+
 // Since this is running in application space, log only critical messages to reduce noise.
 pub const log_level: std.log.Level = .err;
 

package/src/tigerbeetle/src/benchmark.zig

@@ -1,7 +1,7 @@
 const std = @import("std");
 const builtin = @import("builtin");
 const assert = std.debug.assert;
-const config = @import("config.zig");
+const config = @import("constants.zig");
 
 const log = std.log;
 pub const log_level: std.log.Level = .err;

package/src/tigerbeetle/src/c/tb_client/context.zig

@@ -2,7 +2,7 @@ const std = @import("std");
 const os = std.os;
 const assert = std.debug.assert;
 
-const config = @import("../../config.zig");
+const config = @import("../../constants.zig");
 const log = std.log.scoped(.tb_client_context);
 
 const util = @import("../../util.zig");

package/src/tigerbeetle/src/c/tb_client/echo_client.zig

@@ -2,7 +2,7 @@ const std = @import("std");
 const assert = std.debug.assert;
 const mem = std.mem;
 
-const config = @import("../../config.zig");
+const config = @import("../../constants.zig");
 const vsr = @import("../../vsr.zig");
 const Header = vsr.Header;
 

package/src/tigerbeetle/src/c/tb_client/thread.zig

@@ -1,7 +1,7 @@
 const std = @import("std");
 const assert = std.debug.assert;
 
-const config = @import("../../config.zig");
+const config = @import("../../constants.zig");
 const log = std.log.scoped(.tb_client_thread);
 
 const Packet = @import("packet.zig").Packet;

package/src/tigerbeetle/src/c/tb_client.h

@@ -1,6 +1,11 @@
-#ifndef TB_CLIENT_C
-#define TB_CLIENT_C
-
+ //////////////////////////////////////////////////////////
+ // This file was auto-generated by tb_client_header.zig //
+ //              Do not manually modify.                 //
+ //////////////////////////////////////////////////////////
+
+#ifndef TB_CLIENT_H
+#define TB_CLIENT_H
+ 
 #include <stddef.h>
 #include <stdint.h>
 #include <stdbool.h>
@@ -50,104 +55,84 @@ typedef struct tb_transfer_t {
 } tb_transfer_t;
 
 typedef enum TB_CREATE_ACCOUNT_RESULT {
-    TB_CREATE_ACCOUNT_OK,
-    TB_CREATE_ACCOUNT_LINKED_EVENT_FAILED,
-    TB_CREATE_ACCOUNT_LINKED_EVENT_CHAIN_OPEN,
-    
-    TB_CREATE_ACCOUNT_RESERVED_FLAG,
-    TB_CREATE_ACCOUNT_RESERVED_FIELD,
-    
-    TB_CREATE_ACCOUNT_ID_MUST_NOT_BE_ZERO,
-    TB_CREATE_ACCOUNT_ID_MUST_NOT_BE_INT_MAX,
-    TB_CREATE_ACCOUNT_LEDGER_MUST_NOT_BE_ZERO,
-    TB_CREATE_ACCOUNT_CODE_MUST_NOT_BE_ZERO,
-    TB_CREATE_ACCOUNT_DEBITS_PENDING_MUST_BE_ZERO,
-    TB_CREATE_ACCOUNT_DEBITS_POSTED_MUST_BE_ZERO,
-    TB_CREATE_ACCOUNT_CREDITS_PENDING_MUST_BE_ZERO,
-    TB_CREATE_ACCOUNT_CREDITS_POSTED_MUST_BE_ZERO,
-
-    TB_CREATE_ACCOUNT_MUTUALLY_EXCLUSIVE_FLAGS,
-
-    TB_CREATE_ACCOUNT_EXISTS_WITH_DIFFERENT_FLAGS,
-    TB_CREATE_ACCOUNT_EXISTS_WITH_DIFFERENT_USER_DATA,
-    TB_CREATE_ACCOUNT_EXISTS_WITH_DIFFERENT_LEDGER,
-    TB_CREATE_ACCOUNT_EXISTS_WITH_DIFFERENT_CODE,
-    TB_CREATE_ACCOUNT_EXISTS
+    TB_CREATE_ACCOUNT_OK = 0,
+    TB_CREATE_ACCOUNT_LINKED_EVENT_FAILED = 1,
+    TB_CREATE_ACCOUNT_LINKED_EVENT_CHAIN_OPEN = 2,
+    TB_CREATE_ACCOUNT_RESERVED_FLAG = 3,
+    TB_CREATE_ACCOUNT_RESERVED_FIELD = 4,
+    TB_CREATE_ACCOUNT_ID_MUST_NOT_BE_ZERO = 5,
+    TB_CREATE_ACCOUNT_ID_MUST_NOT_BE_INT_MAX = 6,
+    TB_CREATE_ACCOUNT_LEDGER_MUST_NOT_BE_ZERO = 7,
+    TB_CREATE_ACCOUNT_CODE_MUST_NOT_BE_ZERO = 8,
+    TB_CREATE_ACCOUNT_DEBITS_PENDING_MUST_BE_ZERO = 9,
+    TB_CREATE_ACCOUNT_DEBITS_POSTED_MUST_BE_ZERO = 10,
+    TB_CREATE_ACCOUNT_CREDITS_PENDING_MUST_BE_ZERO = 11,
+    TB_CREATE_ACCOUNT_CREDITS_POSTED_MUST_BE_ZERO = 12,
+    TB_CREATE_ACCOUNT_MUTUALLY_EXCLUSIVE_FLAGS = 13,
+    TB_CREATE_ACCOUNT_EXISTS_WITH_DIFFERENT_FLAGS = 14,
+    TB_CREATE_ACCOUNT_EXISTS_WITH_DIFFERENT_USER_DATA = 15,
+    TB_CREATE_ACCOUNT_EXISTS_WITH_DIFFERENT_LEDGER = 16,
+    TB_CREATE_ACCOUNT_EXISTS_WITH_DIFFERENT_CODE = 17,
+    TB_CREATE_ACCOUNT_EXISTS = 18,
 } TB_CREATE_ACCOUNT_RESULT;
 
 typedef enum TB_CREATE_TRANSFER_RESULT {
-    TB_CREATE_TRANSFER_OK,
-    TB_CREATE_TRANSFER_LINKED_EVENT_FAILED,
-    TB_CREATE_TRANSFER_LINKED_EVENT_CHAIN_OPEN,
-
-    TB_CREATE_TRANSFER_RESERVED_FLAG,
-    TB_CREATE_TRANSFER_RESERVED_FIELD,
-    
-    TB_CREATE_TRANSFER_ID_MUST_NOT_BE_ZERO,
-    TB_CREATE_TRANSFER_ID_MUST_NOT_BE_INT_MAX,
-    TB_CREATE_TRANSFER_DEBIT_ACCOUNT_ID_MUST_NOT_BE_ZERO,
-    TB_CREATE_TRANSFER_DEBIT_ACCOUNT_ID_MUST_NOT_BE_INT_MAX,
-    TB_CREATE_TRANSFER_CREDIT_ACCOUNT_ID_MUST_NOT_BE_ZERO,
-    TB_CREATE_TRANSFER_CREDIT_ACCOUNT_ID_MUST_NOT_BE_INT_MAX,
-    TB_CREATE_TRANSFER_ACCOUNTS_MUST_BE_DIFFERENT,
-
-    TB_CREATE_TRANSFER_PENDING_ID_MUST_BE_ZERO,
-    TB_CREATE_TRANSFER_PENDING_TRANSFER_MUST_TIMEOUT,
-
-    TB_CREATE_TRANSFER_LEDGER_MUST_NOT_BE_ZERO,
-    TB_CREATE_TRANSFER_CODE_MUST_NOT_BE_ZERO,
-    TB_CREATE_TRANSFER_AMOUNT_MUST_NOT_BE_ZERO,
-
-    TB_CREATE_TRANSFER_DEBIT_ACCOUNT_NOT_FOUND,
-    TB_CREATE_TRANSFER_CREDIT_ACCOUNT_NOT_FOUND,
-
-    TB_CREATE_TRANSFER_ACCOUNTS_MUST_HAVE_THE_SAME_LEDGER,
-    TB_CREATE_TRANSFER_TRANSFER_MUST_HAVE_THE_SAME_LEDGER_AS_ACCOUNTS,
-
-    TB_CREATE_TRANSFER_EXISTS_WITH_DIFFERENT_FLAGS,
-    TB_CREATE_TRANSFER_EXISTS_WITH_DIFFERENT_DEBIT_ACCOUNT_ID,
-    TB_CREATE_TRANSFER_EXISTS_WITH_DIFFERENT_CREDIT_ACCOUNT_ID,
-    TB_CREATE_TRANSFER_EXISTS_WITH_DIFFERENT_USER_DATA,
-    TB_CREATE_TRANSFER_EXISTS_WITH_DIFFERENT_PENDING_ID,
-    TB_CREATE_TRANSFER_EXISTS_WITH_DIFFERENT_TIMEOUT,
-    TB_CREATE_TRANSFER_EXISTS_WITH_DIFFERENT_CODE,
-    TB_CREATE_TRANSFER_EXISTS_WITH_DIFFERENT_AMOUNT,
-    TB_CREATE_TRANSFER_EXISTS,
-
-    TB_CREATE_TRANSFER_OVERFLOWS_DEBITS_PENDING,
-    TB_CREATE_TRANSFER_OVERFLOWS_CREDITS_PENDING,
-    TB_CREATE_TRANSFER_OVERFLOWS_DEBITS_POSTED,
-    TB_CREATE_TRANSFER_OVERFLOWS_CREDITS_POSTED,
-    TB_CREATE_TRANSFER_OVERFLOWS_DEBITS,
-    TB_CREATE_TRANSFER_OVERFLOWS_CREDITS,
-    TB_CREATE_TRANSFER_OVERFLOWS_TIMEOUT,
-
-    TB_CREATE_TRANSFER_EXCEEDS_CREDITS,
-    TB_CREATE_TRANSFER_EXCEEDS_DEBITS,
-
-    TB_CREATE_TRANSFER_CANNOT_POST_AND_VOID_PENDING_TRANSFER,
-    TB_CREATE_TRANSFER_PENDING_TRANSFER_CANNOT_POST_OR_VOID_ANOTHER,
-    TB_CREATE_TRANSFER_TIMEOUT_RESERVED_FOR_PENDING_TRANSFER,
-
-    TB_CREATE_TRANSFER_PENDING_ID_MUST_NOT_BE_ZERO,
-    TB_CREATE_TRANSFER_PENDING_ID_MUST_NOT_BE_INT_MAX,
-    TB_CREATE_TRANSFER_PENDING_ID_MUST_BE_DIFFERENT,
-
-    TB_CREATE_TRANSFER_PENDING_TRANSFER_NOT_FOUND,
-    TB_CREATE_TRANSFER_PENDING_TRANSFER_NOT_PENDING,
-
-    TB_CREATE_TRANSFER_PENDING_TRANSFER_HAS_DIFFERENT_DEBIT_ACCOUNT_ID,
-    TB_CREATE_TRANSFER_PENDING_TRANSFER_HAS_DIFFERENT_CREDIT_ACCOUNT_ID,
-    TB_CREATE_TRANSFER_PENDING_TRANSFER_HAS_DIFFERENT_LEDGER,
-    TB_CREATE_TRANSFER_PENDING_TRANSFER_HAS_DIFFERENT_CODE,
-
-    TB_CREATE_TRANSFER_EXCEEDS_PENDING_TRANSFER_AMOUNT,
-    TB_CREATE_TRANSFER_PENDING_TRANSFER_HAS_DIFFERENT_AMOUNT,
-
-    TB_CREATE_TRANSFER_PENDING_TRANSFER_ALREADY_POSTED,
-    TB_CREATE_TRANSFER_PENDING_TRANSFER_ALREADY_VOIDED,
-    
-    TB_CREATE_TRANSFER_PENDING_TRANSFER_EXPIRED,
+    TB_CREATE_TRANSFER_OK = 0,
+    TB_CREATE_TRANSFER_LINKED_EVENT_FAILED = 1,
+    TB_CREATE_TRANSFER_LINKED_EVENT_CHAIN_OPEN = 2,
+    TB_CREATE_TRANSFER_RESERVED_FLAG = 3,
+    TB_CREATE_TRANSFER_RESERVED_FIELD = 4,
+    TB_CREATE_TRANSFER_ID_MUST_NOT_BE_ZERO = 5,
+    TB_CREATE_TRANSFER_ID_MUST_NOT_BE_INT_MAX = 6,
+    TB_CREATE_TRANSFER_DEBIT_ACCOUNT_ID_MUST_NOT_BE_ZERO = 7,
+    TB_CREATE_TRANSFER_DEBIT_ACCOUNT_ID_MUST_NOT_BE_INT_MAX = 8,
+    TB_CREATE_TRANSFER_CREDIT_ACCOUNT_ID_MUST_NOT_BE_ZERO = 9,
+    TB_CREATE_TRANSFER_CREDIT_ACCOUNT_ID_MUST_NOT_BE_INT_MAX = 10,
+    TB_CREATE_TRANSFER_ACCOUNTS_MUST_BE_DIFFERENT = 11,
+    TB_CREATE_TRANSFER_PENDING_ID_MUST_BE_ZERO = 12,
+    TB_CREATE_TRANSFER_PENDING_TRANSFER_MUST_TIMEOUT = 13,
+    TB_CREATE_TRANSFER_LEDGER_MUST_NOT_BE_ZERO = 14,
+    TB_CREATE_TRANSFER_CODE_MUST_NOT_BE_ZERO = 15,
+    TB_CREATE_TRANSFER_AMOUNT_MUST_NOT_BE_ZERO = 16,
+    TB_CREATE_TRANSFER_DEBIT_ACCOUNT_NOT_FOUND = 17,
+    TB_CREATE_TRANSFER_CREDIT_ACCOUNT_NOT_FOUND = 18,
+    TB_CREATE_TRANSFER_ACCOUNTS_MUST_HAVE_THE_SAME_LEDGER = 19,
+    TB_CREATE_TRANSFER_TRANSFER_MUST_HAVE_THE_SAME_LEDGER_AS_ACCOUNTS = 20,
+    TB_CREATE_TRANSFER_EXISTS_WITH_DIFFERENT_FLAGS = 21,
+    TB_CREATE_TRANSFER_EXISTS_WITH_DIFFERENT_DEBIT_ACCOUNT_ID = 22,
+    TB_CREATE_TRANSFER_EXISTS_WITH_DIFFERENT_CREDIT_ACCOUNT_ID = 23,
+    TB_CREATE_TRANSFER_EXISTS_WITH_DIFFERENT_USER_DATA = 24,
+    TB_CREATE_TRANSFER_EXISTS_WITH_DIFFERENT_PENDING_ID = 25,
+    TB_CREATE_TRANSFER_EXISTS_WITH_DIFFERENT_TIMEOUT = 26,
+    TB_CREATE_TRANSFER_EXISTS_WITH_DIFFERENT_CODE = 27,
+    TB_CREATE_TRANSFER_EXISTS_WITH_DIFFERENT_AMOUNT = 28,
+    TB_CREATE_TRANSFER_EXISTS = 29,
+    TB_CREATE_TRANSFER_OVERFLOWS_DEBITS_PENDING = 30,
+    TB_CREATE_TRANSFER_OVERFLOWS_CREDITS_PENDING = 31,
+    TB_CREATE_TRANSFER_OVERFLOWS_DEBITS_POSTED = 32,
+    TB_CREATE_TRANSFER_OVERFLOWS_CREDITS_POSTED = 33,
+    TB_CREATE_TRANSFER_OVERFLOWS_DEBITS = 34,
+    TB_CREATE_TRANSFER_OVERFLOWS_CREDITS = 35,
+    TB_CREATE_TRANSFER_OVERFLOWS_TIMEOUT = 36,
+    TB_CREATE_TRANSFER_EXCEEDS_CREDITS = 37,
+    TB_CREATE_TRANSFER_EXCEEDS_DEBITS = 38,
+    TB_CREATE_TRANSFER_CANNOT_POST_AND_VOID_PENDING_TRANSFER = 39,
+    TB_CREATE_TRANSFER_PENDING_TRANSFER_CANNOT_POST_OR_VOID_ANOTHER = 40,
+    TB_CREATE_TRANSFER_TIMEOUT_RESERVED_FOR_PENDING_TRANSFER = 41,
+    TB_CREATE_TRANSFER_PENDING_ID_MUST_NOT_BE_ZERO = 42,
+    TB_CREATE_TRANSFER_PENDING_ID_MUST_NOT_BE_INT_MAX = 43,
+    TB_CREATE_TRANSFER_PENDING_ID_MUST_BE_DIFFERENT = 44,
+    TB_CREATE_TRANSFER_PENDING_TRANSFER_NOT_FOUND = 45,
+    TB_CREATE_TRANSFER_PENDING_TRANSFER_NOT_PENDING = 46,
+    TB_CREATE_TRANSFER_PENDING_TRANSFER_HAS_DIFFERENT_DEBIT_ACCOUNT_ID = 47,
+    TB_CREATE_TRANSFER_PENDING_TRANSFER_HAS_DIFFERENT_CREDIT_ACCOUNT_ID = 48,
+    TB_CREATE_TRANSFER_PENDING_TRANSFER_HAS_DIFFERENT_LEDGER = 49,
+    TB_CREATE_TRANSFER_PENDING_TRANSFER_HAS_DIFFERENT_CODE = 50,
+    TB_CREATE_TRANSFER_EXCEEDS_PENDING_TRANSFER_AMOUNT = 51,
+    TB_CREATE_TRANSFER_PENDING_TRANSFER_HAS_DIFFERENT_AMOUNT = 52,
+    TB_CREATE_TRANSFER_PENDING_TRANSFER_ALREADY_POSTED = 53,
+    TB_CREATE_TRANSFER_PENDING_TRANSFER_ALREADY_VOIDED = 54,
+    TB_CREATE_TRANSFER_PENDING_TRANSFER_EXPIRED = 55,
 } TB_CREATE_TRANSFER_RESULT;
 
 typedef struct tb_create_accounts_result_t {
@@ -161,17 +146,17 @@ typedef struct tb_create_transfers_result_t {
 } tb_create_transfers_result_t;
 
 typedef enum TB_OPERATION {
-    TB_OP_CREATE_ACCOUNTS = 3,
-    TB_OP_CREATE_TRANSFERS = 4,
-    TB_OP_LOOKUP_ACCOUNTS = 5,
-    TB_OP_LOOKUP_TRANSFERS = 6
+    TB_OPERATION_CREATE_ACCOUNTS = 3,
+    TB_OPERATION_CREATE_TRANSFERS = 4,
+    TB_OPERATION_LOOKUP_ACCOUNTS = 5,
+    TB_OPERATION_LOOKUP_TRANSFERS = 6,
 } TB_OPERATION;
 
 typedef enum TB_PACKET_STATUS {
-    TB_PACKET_OK,
-    TB_PACKET_TOO_MUCH_DATA,
-    TB_PACKET_INVALID_OPERATION,
-    TB_PACKET_INVALID_DATA_SIZE
+    TB_PACKET_OK = 0,
+    TB_PACKET_TOO_MUCH_DATA = 1,
+    TB_PACKET_INVALID_OPERATION = 2,
+    TB_PACKET_INVALID_DATA_SIZE = 3,
 } TB_PACKET_STATUS;
 
 typedef struct tb_packet_t {
@@ -188,7 +173,7 @@ typedef struct tb_packet_list_t {
     struct tb_packet_t* tail;
 } tb_packet_list_t;
 
-typedef void* tb_client_t;
+typedef void* tb_client_t; 
 
 typedef enum TB_STATUS {
     TB_STATUS_SUCCESS = 0,
@@ -203,7 +188,7 @@ typedef enum TB_STATUS {
 
 TB_STATUS tb_client_init(
     tb_client_t* out_client,
-    tb_packet_list_t* out_packets,
+    struct tb_packet_list_t* out_packets,
     uint32_t cluster_id,
     const char* address_ptr,
     uint32_t address_len,
@@ -214,7 +199,7 @@ TB_STATUS tb_client_init(
 
 TB_STATUS tb_client_init_echo(
     tb_client_t* out_client,
-    tb_packet_list_t* out_packets,
+    struct tb_packet_list_t* out_packets,
     uint32_t cluster_id,
     const char* address_ptr,
     uint32_t address_len,
@@ -225,11 +210,12 @@ TB_STATUS tb_client_init_echo(
 
 void tb_client_submit(
     tb_client_t client,
-    tb_packet_list_t* packets
+    struct tb_packet_list_t* packets
 );
 
 void tb_client_deinit(
     tb_client_t client
 );
 
-#endif // TB_CLIENT_C
+#endif // TB_CLIENT_H
+

package/src/tigerbeetle/src/c/tb_client.zig

@@ -17,6 +17,7 @@ pub const tb_status_t = enum(c_int) {
     network_subsystem,
 };
 
+pub const tb_operation_t = StateMachine.Operation;
 pub const tb_completion_t = fn (
     context: usize,
     client: tb_client_t,
@@ -25,7 +26,7 @@ pub const tb_completion_t = fn (
     result_len: u32,
 ) callconv(.C) void;
 
-const config = @import("../config.zig");
+const config = @import("../constants.zig");
 const Storage = @import("../storage.zig").Storage;
 const MessageBus = @import("../message_bus.zig").MessageBusClient;
 const StateMachine = @import("../state_machine.zig").StateMachineType(Storage, .{
@@ -53,19 +54,17 @@ fn client_to_context(tb_client: tb_client_t) *ContextImplementation {
     return @ptrCast(*ContextImplementation, @alignCast(@alignOf(ContextImplementation), tb_client));
 }
 
-// Pick the most suitable allocator
-const global_allocator = if (builtin.is_test)
-    std.testing.allocator
-else if (builtin.link_libc)
-    std.heap.c_allocator
-else if (builtin.target.os.tag == .windows)
-    (struct {
-        var gpa = std.heap.HeapAllocator.init();
-    }).gpa.allocator()
-else
-    @compileError("tb_client must be built with libc");
-
-pub export fn tb_client_init(
+// Only export the functions if we're compiling libtb_client.
+// If it's only being imported by another zig file, then exporting the functions
+// will force them to be evaluated/codegen/linked and trigger unexpected comptime paths.
+comptime {
+    if (builtin.link_libc) {
+        @export(tb_client_init, .{ .name = "tb_client_init", .linkage = .Strong });
+        @export(tb_client_init_echo, .{ .name = "tb_client_init_echo", .linkage = .Strong });
+    }
+}
+
+pub fn tb_client_init(
     out_client: *tb_client_t,
     out_packets: *tb_packet_list_t,
     cluster_id: u32,
@@ -74,7 +73,7 @@ pub export fn tb_client_init(
     packets_count: u32,
     on_completion_ctx: usize,
     on_completion_fn: tb_completion_t,
-) tb_status_t {
+) callconv(.C) tb_status_t {
     return init(
         DefaultContext,
         out_client,
@@ -88,7 +87,7 @@ pub export fn tb_client_init(
     );
 }
 
-pub export fn tb_client_init_echo(
+pub fn tb_client_init_echo(
     out_client: *tb_client_t,
     out_packets: *tb_packet_list_t,
     cluster_id: u32,
@@ -97,7 +96,7 @@ pub export fn tb_client_init_echo(
     packets_count: u32,
     on_completion_ctx: usize,
     on_completion_fn: tb_completion_t,
-) tb_status_t {
+) callconv(.C) tb_status_t {
     return init(
         TestingContext,
         out_client,
@@ -122,9 +121,21 @@ fn init(
     on_completion_ctx: usize,
     on_completion_fn: tb_completion_t,
 ) tb_status_t {
+    // Pick the most suitable allocator for the platform.
+    const allocator = if (builtin.is_test)
+        std.testing.allocator
+    else if (builtin.link_libc)
+        std.heap.c_allocator
+    else if (builtin.target.os.tag == .windows)
+        (struct {
+            var gpa = std.heap.HeapAllocator.init();
+        }).gpa.allocator()
+    else
+        @compileError("tb_client must be built with libc");
+
     const addresses = @ptrCast([*]const u8, addresses_ptr)[0..addresses_len];
     const context = Context.init(
-        global_allocator,
+        allocator,
         cluster_id,
         addresses,
         packets_count,

package/src/tigerbeetle/src/c/tb_client_header.zig

@@ -0,0 +1,218 @@
+const std = @import("std");
+const tb = @import("../tigerbeetle.zig");
+const tb_client = @import("tb_client.zig");
+
+const type_mappings = .{
+    .{ tb.AccountFlags, "TB_ACCOUNT_FLAGS" },
+    .{ tb.Account, "tb_account_t" },
+    .{ tb.TransferFlags, "TB_TRANSFER_FLAGS" },
+    .{ tb.Transfer, "tb_transfer_t" },
+    .{ tb.CreateAccountResult, "TB_CREATE_ACCOUNT_RESULT" },
+    .{ tb.CreateTransferResult, "TB_CREATE_TRANSFER_RESULT" },
+    .{ tb.CreateAccountsResult, "tb_create_accounts_result_t" },
+    .{ tb.CreateTransfersResult, "tb_create_transfers_result_t" },
+    .{ tb_client.tb_operation_t, "TB_OPERATION" },
+    .{ tb_client.tb_packet_status_t, "TB_PACKET_STATUS" },
+    .{ tb_client.tb_packet_t, "tb_packet_t" },
+    .{ tb_client.tb_packet_list_t, "tb_packet_list_t" },
+    .{ tb_client.tb_client_t, "tb_client_t" },
+    .{ tb_client.tb_status_t, "TB_STATUS" },
+};
+
+fn resolve_c_type(comptime Type: type) []const u8 {
+    switch (@typeInfo(Type)) {
+        .Array => |info| return resolve_c_type(info.child),
+        .Enum => |info| return resolve_c_type(info.tag_type),
+        .Struct => return resolve_c_type(std.meta.Int(.unsigned, @bitSizeOf(Type))),
+        .Int => |info| {
+            std.debug.assert(info.signedness == .unsigned);
+            return switch (info.bits) {
+                8 => "uint8_t",
+                16 => "uint16_t",
+                32 => "uint32_t",
+                64 => "uint64_t",
+                128 => "tb_uint128_t",
+                else => @compileError("invalid int type"),
+            };
+        },
+        .Optional => |info| switch (@typeInfo(info.child)) {
+            .Pointer => return resolve_c_type(info.child),
+            else => @compileError("Unsupported optional type: " ++ @typeName(Type)),
+        },
+        .Pointer => |info| {
+            std.debug.assert(info.size != .Slice);
+            std.debug.assert(!info.is_allowzero);
+
+            inline for (type_mappings) |type_mapping| {
+                const ZigType = type_mapping[0];
+                const c_name = type_mapping[1];
+
+                if (info.child == ZigType) {
+                    const prefix = if (@typeInfo(ZigType) == .Struct) "struct " else "";
+                    return prefix ++ c_name ++ "*";
+                }
+            }
+
+            return resolve_c_type(info.child) ++ "*";
+        },
+        .Void, .Opaque => return "void",
+        else => @compileError("Unhandled type: " ++ @typeName(Type)),
+    }
+}
+
+fn to_uppercase(comptime input: []const u8) []const u8 {
+    comptime var output: [input.len]u8 = undefined;
+    inline for (output) |*char, i| {
+        char.* = input[i];
+        char.* -= 32 * @as(u8, @boolToInt(char.* >= 'a' and char.* <= 'z'));
+    }
+    return &output;
+}
+
+fn emit_enum(
+    buffer: *std.ArrayList(u8),
+    comptime type_info: anytype,
+    comptime c_name: []const u8,
+    comptime value_fmt: []const u8,
+    comptime skip_fields: []const []const u8,
+) !void {
+    var suffix_pos = std.mem.lastIndexOf(u8, c_name, "_").?;
+    if (std.mem.count(u8, c_name, "_") == 1) suffix_pos = c_name.len;
+
+    try buffer.writer().print("typedef enum {s} {{\n", .{c_name});
+
+    inline for (type_info.fields) |field, i| {
+        comptime var skip = false;
+        inline for (skip_fields) |sf| {
+            skip = skip or comptime std.mem.eql(u8, sf, field.name);
+        }
+
+        if (!skip) {
+            try buffer.writer().print("    {s}_{s} = " ++ value_fmt ++ ",\n", .{
+                c_name[0..suffix_pos],
+                to_uppercase(field.name),
+                i,
+            });
+        }
+    }
+
+    try buffer.writer().print("}} {s};\n\n", .{c_name});
+}
+
+fn emit_struct(
+    buffer: *std.ArrayList(u8),
+    comptime type_info: anytype,
+    comptime c_name: []const u8,
+) !void {
+    try buffer.writer().print("typedef struct {s} {{\n", .{c_name});
+
+    inline for (type_info.fields) |field| {
+        try buffer.writer().print("    {s} {s}", .{
+            resolve_c_type(field.field_type),
+            field.name,
+        });
+
+        switch (@typeInfo(field.field_type)) {
+            .Array => |array| try buffer.writer().print("[{d}]", .{array.len}),
+            else => {},
+        }
+
+        try buffer.writer().print(";\n", .{});
+    }
+
+    try buffer.writer().print("}} {s};\n\n", .{c_name});
+}
+
+pub fn main() !void {
+    @setEvalBranchQuota(100_000);
+
+    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    var buffer = std.ArrayList(u8).init(allocator);
+    try buffer.writer().print(
+        \\ //////////////////////////////////////////////////////////
+        \\ // This file was auto-generated by tb_client_header.zig //
+        \\ //              Do not manually modify.                 //
+        \\ //////////////////////////////////////////////////////////
+        \\
+        \\#ifndef TB_CLIENT_H
+        \\#define TB_CLIENT_H
+        \\ 
+        \\#include <stddef.h>
+        \\#include <stdint.h>
+        \\#include <stdbool.h>
+        \\
+        \\typedef __uint128_t tb_uint128_t;
+        \\
+        \\
+    , .{});
+
+    // Emit C type declarations.
+    inline for (type_mappings) |type_mapping| {
+        const ZigType = type_mapping[0];
+        const c_name = type_mapping[1];
+
+        switch (@typeInfo(ZigType)) {
+            .Struct => |info| switch (info.layout) {
+                .Auto => @compileError("Invalid C struct type: " ++ @typeName(ZigType)),
+                .Packed => try emit_enum(&buffer, info, c_name, "1 << {d}", &.{"padding"}),
+                .Extern => try emit_struct(&buffer, info, c_name),
+            },
+            .Enum => |info| {
+                comptime var skip: []const []const u8 = &.{};
+                if (ZigType == tb_client.tb_operation_t) {
+                    skip = &.{ "reserved", "root", "register" };
+                }
+
+                try emit_enum(&buffer, info, c_name, "{d}", skip);
+            },
+            else => try buffer.writer().print("typedef {s} {s}; \n\n", .{
+                resolve_c_type(ZigType),
+                c_name,
+            }),
+        }
+    }
+
+    // Emit C function declarations.
+    // TODO: use `std.meta.declaractions` and generate with pub + export functions.
+    // Zig 0.9.1 has `decl.data.Fn.arg_names` but it's currently/incorrectly a zero-sized slice.
+    try buffer.writer().print(
+        \\TB_STATUS tb_client_init(
+        \\    tb_client_t* out_client,
+        \\    struct tb_packet_list_t* out_packets,
+        \\    uint32_t cluster_id,
+        \\    const char* address_ptr,
+        \\    uint32_t address_len,
+        \\    uint32_t packets_count,
+        \\    uintptr_t on_completion_ctx,
+        \\    void (*on_completion_fn)(uintptr_t, tb_client_t, tb_packet_t*, const uint8_t*, uint32_t)
+        \\);
+        \\
+        \\TB_STATUS tb_client_init_echo(
+        \\    tb_client_t* out_client,
+        \\    struct tb_packet_list_t* out_packets,
+        \\    uint32_t cluster_id,
+        \\    const char* address_ptr,
+        \\    uint32_t address_len,
+        \\    uint32_t packets_count,
+        \\    uintptr_t on_completion_ctx,
+        \\    void (*on_completion_fn)(uintptr_t, tb_client_t, tb_packet_t*, const uint8_t*, uint32_t)
+        \\);
+        \\
+        \\void tb_client_submit(
+        \\    tb_client_t client,
+        \\    struct tb_packet_list_t* packets
+        \\);
+        \\
+        \\void tb_client_deinit(
+        \\    tb_client_t client
+        \\);
+        \\
+        \\
+    , .{});
+
+    try buffer.writer().print("#endif // TB_CLIENT_H\n\n", .{});
+    try std.fs.cwd().writeFile("src/c/tb_client.h", buffer.items);
+}