tigerbeetle-node 0.10.0 → 0.11.1

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

@@ -7,7 +7,6 @@
 
 typedef __uint128_t tb_uint128_t;
 
-
 typedef enum TB_ACCOUNT_FLAGS {
     TB_ACCOUNT_LINKED = 1 << 0,
     TB_ACCOUNT_DEBITS_MUST_NOT_EXCEED_CREDITS = 1 << 1,
@@ -18,20 +17,21 @@ typedef struct tb_account_t {
     tb_uint128_t id;
     tb_uint128_t user_data;
     uint8_t reserved[48];
-    uint16_t unit;
+    uint32_t ledger;
     uint16_t code;
-    uint32_t flags;
-    uint64_t debits_reserved;
-    uint64_t debits_accepted;
-    uint64_t credits_reserved;
-    uint64_t credits_accepted;
+    uint16_t flags;
+    uint64_t debits_pending;
+    uint64_t debits_posted;
+    uint64_t credits_pending;
+    uint64_t credits_posted;
     uint64_t timestamp;
 } tb_account_t;
 
 typedef enum TB_TRANSFER_FLAGS {
     TB_TRANSFER_LINKED = 1 << 0,
-    TB_TRANSFER_TWO_PHASE_COMMIT = 1 << 1,
-    TB_TRANSFER_CONDITION = 1 << 2,
+    TB_TRANSFER_PENDING = 1 << 1,
+    TB_TRANSFER_POST_PENDING_TRANSFER = 1 << 2,
+    TB_TRANSFER_VOID_PENDING_TRANSFER = 1 << 3,
 } TB_TRANSFER_FLAGS;
 
 typedef struct tb_transfer_t {
@@ -39,111 +39,132 @@ typedef struct tb_transfer_t {
     tb_uint128_t debit_account_id;
     tb_uint128_t credit_account_id;
     tb_uint128_t user_data;
-    uint8_t reserved[32];
+    tb_uint128_t reserved;
+    tb_uint128_t pending_id;
     uint64_t timeout;
-    uint32_t code;
-    uint32_t flags;
+    uint32_t ledger;
+    uint16_t code;
+    uint16_t flags;
     uint64_t amount;
     uint64_t timestamp;
 } tb_transfer_t;
 
-typedef enum TB_COMMIT_FLAGS {
-    TB_COMMIT_LINKED = 1 << 0,
-    TB_COMMIT_REJECT = 1 << 1,
-    TB_COMMIT_PREIMAGE = 1 << 2,
-} TB_COMMIT_FLAGS;
-
-typedef struct tb_commit_t {
-    tb_uint128_t id;
-    uint8_t reserved[32];
-    uint32_t code;
-    uint32_t flags;
-    uint64_t timestamp;
-} tb_commit_t;
-
 typedef enum TB_CREATE_ACCOUNT_RESULT {
     TB_CREATE_ACCOUNT_OK,
     TB_CREATE_ACCOUNT_LINKED_EVENT_FAILED,
-    TB_CREATE_ACCOUNT_EXISTS,
+    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_RESERVED_FIELD,
-    TB_CREATE_ACCOUNT_EXISTS_WITH_DIFFERENT_UNIT,
+    TB_CREATE_ACCOUNT_EXISTS_WITH_DIFFERENT_LEDGER,
     TB_CREATE_ACCOUNT_EXISTS_WITH_DIFFERENT_CODE,
-    TB_CREATE_ACCOUNT_EXISTS_WITH_DIFFERENT_FLAGS,
-    TB_CREATE_ACCOUNT_EXCEEDS_CREDITS,
-    TB_CREATE_ACCOUNT_EXCEEDS_DEBITS,
-    TB_CREATE_ACCOUNT_RESERVE_FAILED,
-    TB_CREATE_ACCOUNT_RESERVE_FLAG_PADDING
+    TB_CREATE_ACCOUNT_EXISTS
 } TB_CREATE_ACCOUNT_RESULT;
 
 typedef enum TB_CREATE_TRANSFER_RESULT {
     TB_CREATE_TRANSFER_OK,
     TB_CREATE_TRANSFER_LINKED_EVENT_FAILED,
-    TB_CREATE_TRANSFER_EXISTS,
+    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_RESERVED_FIELD,
+    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_WITH_DIFFERENT_TIMEOUT,
-    TB_CREATE_TRANSFER_EXISTS_WITH_DIFFERENT_FLAGS,
-    TB_CREATE_TRANSFER_EXISTS_AND_ALREADY_COMMITTED_AND_ACCEPTED,
-    TB_CREATE_TRANSFER_EXISTS_AND_ALREADY_COMMITTED_AND_REJECTED,
-    TB_CREATE_TRANSFER_RESERVED_FIELD,
-    TB_CREATE_TRANSFER_RESERVED_FLAG_PADDING,
-    TB_CREATE_TRANSFER_DEBIT_ACCOUNT_NOT_FOUND,
-    TB_CREATE_TRANSFER_CREDIT_ACCOUNT_NOT_FOUND,
-    TB_CREATE_TRANSFER_ACCOUNTS_ARE_THE_SAME,
-    TB_CREATE_TRANSFER_ACCOUNTS_HAVE_DIFFERENT_UNITS,
-    TB_CREATE_TRANSFER_AMOUNT_IS_ZERO,
+    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_TWO_PHASE_COMMIT_MUST_TIMEOUT,
-    TB_CREATE_TRANSFER_TIMEOUT_RESERVED_FOR_TWO_PHASE_COMMIT
-} TB_CREATE_TRANSFER_RESULT;
 
-typedef enum TB_COMMIT_TRANSFER_RESULT {
-    TB_COMMIT_TRANSFER_OK,
-    TB_COMMIT_TRANSFER_LINKED_EVENT_FAILED,
-    TB_COMMIT_TRANSFER_RESERVE_FAILED,
-    TB_COMMIT_TRANSFER_RESERVE_FLAG_PADDING,
-    TB_COMMIT_TRANSFER_NOT_FOUND,
-    TB_COMMIT_TRANSFER_NOT_TWO_PHASE_COMMIT,
-    TB_COMMIT_TRANSFER_EXPIRED,
-    TB_COMMIT_TRANSFER_ALREADY_COMMITTED,
-    TB_COMMIT_TRANSFER_ALREADY_COMMITTED_BUT_ACCEPTED,
-    TB_COMMIT_TRANSFER_ALREADY_COMMITTED_BUT_REJECTED,
-    TB_COMMIT_TRANSFER_DEBIT_ACCOUNT_NOT_FOUND,
-    TB_COMMIT_TRANSFER_CREDIT_ACCOUNT_NOT_FOUND,
-    TB_COMMIT_TRANSFER_EXCEEDS_CREDITS,
-    TB_COMMIT_TRANSFER_EXCEEDS_DEBITS,
-    TB_COMMIT_TRANSFER_CONDITION_REQUIRES_PREIMAGE,
-    TB_COMMIT_TRANSFER_PREIMAGE_REQUIRES_CONDITION,
-    TB_COMMIT_TRANSFER_PREIMAGE_INVALID
-} TB_COMMIT_TRANSFER_RESULT;
+    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_RESULT;
 
 typedef struct tb_create_accounts_result_t {
     uint32_t index;
-    TB_CREATE_ACCOUNT_RESULT result;
+    uint32_t result;
 } tb_create_accounts_result_t;
 
 typedef struct tb_create_transfers_result_t {
     uint32_t index;
-    TB_CREATE_TRANSFER_RESULT result;
+    uint32_t result;
 } tb_create_transfers_result_t;
 
-typedef struct tb_commit_transfers_result_t {
-    uint32_t index;
-    TB_COMMIT_TRANSFER_RESULT result;
-} tb_commit_transfers_result_t;
-
 typedef enum TB_OPERATION {
     TB_OP_CREATE_ACCOUNTS = 3,
     TB_OP_CREATE_TRANSFERS = 4,
-    TB_OP_COMMIT_TRANSFERS = 5,
-    TB_OP_LOOKUP_ACCOUNTS = 6,
-    TB_OP_LOOKUP_TRANSFERS = 7
+    TB_OP_LOOKUP_ACCOUNTS = 5,
+    TB_OP_LOOKUP_TRANSFERS = 6
 } TB_OPERATION;
 
 typedef enum TB_PACKET_STATUS {
@@ -173,9 +194,11 @@ typedef enum TB_STATUS {
     TB_STATUS_SUCCESS = 0,
     TB_STATUS_UNEXPECTED = 1,
     TB_STATUS_OUT_OF_MEMORY = 2,
-    TB_STATUS_INVALID_ADDRESS = 3,
-    TB_STATUS_SYSTEM_RESOURCES = 4,
-    TB_STATUS_NETWORK_SUBSYSTEM = 5,
+    TB_STATUS_ADDRESS_INVALID = 3,
+    TB_STATUS_ADDRESS_LIMIT_EXCEEDED = 4,
+    TB_STATUS_PACKETS_COUNT_INVALID = 5,
+    TB_STATUS_SYSTEM_RESOURCES = 6,
+    TB_STATUS_NETWORK_SUBSYSTEM = 7,
 } TB_STATUS;
 
 TB_STATUS tb_client_init(
@@ -184,7 +207,18 @@ TB_STATUS tb_client_init(
     uint32_t cluster_id,
     const char* address_ptr,
     uint32_t address_len,
-    uint32_t num_packets,
+    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,
+    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)
 );
@@ -198,4 +232,4 @@ void tb_client_deinit(
     tb_client_t client
 );
 
-#endif // TB_CLIENT_C
+#endif // TB_CLIENT_C

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

@@ -10,7 +10,9 @@ pub const tb_status_t = enum(c_int) {
     success = 0,
     unexpected,
     out_of_memory,
-    invalid_address,
+    address_invalid,
+    address_limit_exceeded,
+    packets_count_invalid,
     system_resources,
     network_subsystem,
 };
@@ -23,9 +25,26 @@ pub const tb_completion_t = fn (
     result_len: u32,
 ) callconv(.C) void;
 
+const config = @import("../config.zig");
+const Storage = @import("../storage.zig").Storage;
+const MessageBus = @import("../message_bus.zig").MessageBusClient;
+const StateMachine = @import("../state_machine.zig").StateMachineType(Storage, .{
+    .message_body_size_max = config.message_body_size_max,
+});
+
 const ContextType = @import("tb_client/context.zig").ContextType;
 const ContextImplementation = @import("tb_client/context.zig").ContextImplementation;
 
+const DefaultContext = blk: {
+    const Client = @import("../vsr/client.zig").Client(StateMachine, MessageBus);
+    break :blk ContextType(Client);
+};
+
+const TestingContext = blk: {
+    const EchoClient = @import("tb_client/echo_client.zig").EchoClient(StateMachine, MessageBus);
+    break :blk ContextType(EchoClient);
+};
+
 pub fn context_to_client(implementation: *ContextImplementation) tb_client_t {
     return @ptrCast(tb_client_t, implementation);
 }
@@ -34,21 +53,10 @@ fn client_to_context(tb_client: tb_client_t) *ContextImplementation {
     return @ptrCast(*ContextImplementation, @alignCast(@alignOf(ContextImplementation), tb_client));
 }
 
-const DefaultContext = blk: {
-    const Storage = @import("../storage.zig").Storage;
-    const MessageBus = @import("../message_bus.zig").MessageBusClient;
-    const StateMachine = @import("../state_machine.zig").StateMachineType(Storage);
-    break :blk ContextType(StateMachine, MessageBus);
-};
-
-// const TestingContext = blk: {
-//     const MessageBus = @import("test_message_bus.zig").MessageBusClient;
-//     const StateMachine = @import("../state_machine.zig").StateMachine;
-//     break :blk ContextType(StateMachine, MessageBus);
-// };
-
 // Pick the most suitable allocator
-const global_allocator = if (builtin.link_libc)
+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 {
@@ -63,28 +71,85 @@ pub export fn tb_client_init(
     cluster_id: u32,
     addresses_ptr: [*:0]const u8,
     addresses_len: u32,
-    num_packets: u32,
+    packets_count: u32,
     on_completion_ctx: usize,
     on_completion_fn: tb_completion_t,
 ) tb_status_t {
-    var init_fn = DefaultContext.init;
-    // if (addresses_len == 0) {
-    //     init_fn = TestingContext.init;
-    // }
+    return init(
+        DefaultContext,
+        out_client,
+        out_packets,
+        cluster_id,
+        addresses_ptr,
+        addresses_len,
+        packets_count,
+        on_completion_ctx,
+        on_completion_fn,
+    );
+}
 
-    return (init_fn)(
-        global_allocator,
+pub export fn tb_client_init_echo(
+    out_client: *tb_client_t,
+    out_packets: *tb_packet_list_t,
+    cluster_id: u32,
+    addresses_ptr: [*:0]const u8,
+    addresses_len: u32,
+    packets_count: u32,
+    on_completion_ctx: usize,
+    on_completion_fn: tb_completion_t,
+) tb_status_t {
+    return init(
+        TestingContext,
         out_client,
         out_packets,
         cluster_id,
         addresses_ptr,
         addresses_len,
-        num_packets,
+        packets_count,
         on_completion_ctx,
         on_completion_fn,
     );
 }
 
+fn init(
+    comptime Context: type,
+    out_client: *tb_client_t,
+    out_packets: *tb_packet_list_t,
+    cluster_id: u32,
+    addresses_ptr: [*:0]const u8,
+    addresses_len: u32,
+    packets_count: u32,
+    on_completion_ctx: usize,
+    on_completion_fn: tb_completion_t,
+) tb_status_t {
+    const addresses = @ptrCast([*]const u8, addresses_ptr)[0..addresses_len];
+    const context = Context.init(
+        global_allocator,
+        cluster_id,
+        addresses,
+        packets_count,
+        on_completion_ctx,
+        on_completion_fn,
+    ) catch |err| switch (err) {
+        error.Unexpected => return .unexpected,
+        error.OutOfMemory => return .out_of_memory,
+        error.AddressInvalid => return .address_invalid,
+        error.AddressLimitExceeded => return .address_limit_exceeded,
+        error.PacketsCountInvalid => return .packets_count_invalid,
+        error.SystemResources => return .system_resources,
+        error.NetworkSubsystemFailed => return .network_subsystem,
+    };
+
+    out_client.* = context_to_client(&context.implementation);
+    var list = tb_packet_list_t{};
+    for (context.packets) |*packet| {
+        list.push(tb_packet_list_t.from(packet));
+    }
+
+    out_packets.* = list;
+    return .success;
+}
+
 pub export fn tb_client_submit(
     client: tb_client_t,
     packets: *tb_packet_list_t,

package/src/tigerbeetle/src/c/tb_client_header_test.zig

@@ -0,0 +1,135 @@
+const std = @import("std");
+const assert = std.debug.assert;
+
+const tb = @import("../tigerbeetle.zig");
+const tb_client = @import("./tb_client.zig");
+const c = @cImport(@cInclude("tb_client.h"));
+
+fn to_lowercase(comptime input: []const u8) []const u8 {
+    comptime var lowercase: [input.len]u8 = undefined;
+    inline for (input) |char, i| {
+        const is_uppercase = (char >= 'A') and (char <= 'Z');
+        lowercase[i] = char + (@as(u8, @boolToInt(is_uppercase)) * 32);
+    }
+    return &lowercase;
+}
+
+fn to_uppercase(comptime input: []const u8) []const u8 {
+    comptime var uppercase: [input.len]u8 = undefined;
+    inline for (input) |char, i| {
+        const is_lowercase = (char >= 'a') and (char <= 'z');
+        uppercase[i] = char - (@as(u8, @boolToInt(is_lowercase)) * 32);
+    }
+    return &uppercase;
+}
+
+fn to_snakecase(comptime input: []const u8) []const u8 {
+    comptime var output: []const u8 = &.{};
+    inline for (input) |char, i| {
+        const is_uppercase = (char >= 'A') and (char <= 'Z');
+        if (is_uppercase and i > 0) output = "_" ++ output;
+        output = output ++ &[_]u8{char};
+    }
+    return output;
+}
+
+test "valid tb_client.h" {
+    @setEvalBranchQuota(10_000);
+
+    inline for (.{
+        .{ tb.Account, "tb_account_t" },
+        .{ tb.Transfer, "tb_transfer_t" },
+        .{ tb.AccountFlags, "TB_ACCOUNT_FLAGS" },
+        .{ tb.TransferFlags, "TB_TRANSFER_FLAGS" },
+        .{ 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" },
+
+        .{ u128, "tb_uint128_t" },
+        .{ tb_client.tb_status_t, "TB_STATUS" },
+        .{ tb_client.tb_client_t, "tb_client_t" },
+        .{ tb_client.tb_packet_t, "tb_packet_t" },
+        .{ tb_client.tb_packet_list_t, "tb_packet_list_t" },
+        .{ tb_client.tb_packet_status_t, "TB_PACKET_STATUS" },
+    }) |c_export| {
+        const ty: type = c_export[0];
+        const c_type_name = @as([]const u8, c_export[1]);
+        const c_type: type = @field(c, c_type_name);
+
+        switch (@typeInfo(ty)) {
+            .Int => comptime assert(ty == c_type),
+            .Pointer => comptime assert(@sizeOf(ty) == @sizeOf(c_type)),
+            .Enum => {
+                const prefix_offset = comptime std.mem.lastIndexOf(u8, c_type_name, "_").?;
+                comptime var c_enum_prefix: []const u8 = c_type_name[0 .. prefix_offset + 1];
+                comptime assert(c_type == c_uint);
+
+                // TB_STATUS is a special case in naming
+                if (comptime std.mem.eql(u8, c_type_name, "TB_STATUS")) {
+                    c_enum_prefix = c_type_name ++ "_";
+                }
+
+                // Compare the enum int values in C to the enum int values in Zig.
+                inline for (std.meta.fields(ty)) |field| {
+                    const c_enum_field = comptime to_uppercase(to_snakecase(field.name));
+                    const c_value = @field(c, c_enum_prefix ++ c_enum_field);
+
+                    const zig_value = @enumToInt(@field(ty, field.name));
+                    comptime assert(zig_value == c_value);
+                }
+            },
+            .Struct => |type_info| switch (type_info.layout) {
+                .Auto => @compileError("struct must be extern or packed to be used in C"),
+                .Packed => {
+                    const prefix_offset = comptime std.mem.lastIndexOf(u8, c_type_name, "_").?;
+                    const c_enum_prefix = c_type_name[0 .. prefix_offset + 1];
+                    comptime assert(c_type == c_uint);
+
+                    inline for (std.meta.fields(ty)) |field| {
+                        if (comptime !std.mem.eql(u8, field.name, "padding")) {
+                            // Get the bit value in the C enum.
+                            const c_enum_field = comptime to_uppercase(to_snakecase(field.name));
+                            const c_value = @field(c, c_enum_prefix ++ c_enum_field);
+
+                            // Compare the bit value to the packed struct's field.
+                            comptime var instance = std.mem.zeroes(ty);
+                            @field(instance, field.name) = true;
+                            comptime assert(@bitCast(u16, instance) == c_value);
+                        }
+                    }
+                },
+                .Extern => {
+                    // Ensure structs are effectively the same.
+                    comptime assert(@sizeOf(ty) == @sizeOf(c_type));
+                    comptime assert(@alignOf(ty) == @alignOf(c_type));
+
+                    inline for (std.meta.fields(ty)) |field| {
+                        // In C, packed structs and enums are replaced with integers.
+                        comptime var field_type = field.field_type;
+                        switch (@typeInfo(field_type)) {
+                            .Struct => |info| {
+                                comptime assert(info.layout == .Packed);
+                                comptime assert(@sizeOf(field_type) <= @sizeOf(u128));
+                                field_type = std.meta.Int(.unsigned, @bitSizeOf(field_type));
+                            },
+                            .Enum => |info| field_type = info.tag_type,
+                            else => {},
+                        }
+
+                        // In C, pointers are opaque so we compare only the field sizes,
+                        comptime var c_field_type = @TypeOf(@field(@as(c_type, undefined), field.name));
+                        switch (@typeInfo(c_field_type)) {
+                            .Pointer => |info| {
+                                comptime assert(info.size == .C);
+                                comptime assert(@sizeOf(c_field_type) == @sizeOf(field_type));
+                            },
+                            else => comptime assert(c_field_type == field_type),
+                        }
+                    }
+                },
+            },
+            else => |i| @compileLog("TODO", i),
+        }
+    }
+}