tigerbeetle-node 0.11.5 → 0.11.7

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

@@ -1,286 +0,0 @@
-const std = @import("std");
-const builtin = @import("builtin");
-const IO = @import("../../io.zig").IO;
-
-const os = std.os;
-const assert = std.debug.assert;
-const Atomic = std.atomic.Atomic;
-
-const log = std.log.scoped(.tb_client_signal);
-
-/// A Signal is a way to trigger a registered callback on a tigerbeetle IO instance 
-/// when notification occurs from another thread.
-/// It does this by using OS sockets (which are thread safe) 
-/// to resolve IO.Completions on the tigerbeetle thread.
-pub const Signal = struct {
-    io: *IO,
-    server_socket: os.socket_t,
-    accept_socket: os.socket_t,
-    connect_socket: os.socket_t,
-
-    completion: IO.Completion,
-    recv_buffer: [1]u8,
-    send_buffer: [1]u8,
-
-    on_signal_fn: fn (*Signal) void,
-    state: Atomic(enum(u8) {
-        running,
-        waiting,
-        notified,
-        shutdown,
-    }),
-
-    pub fn init(self: *Signal, io: *IO, on_signal_fn: fn (*Signal) void) !void {
-        self.io = io;
-        self.server_socket = os.socket(
-            os.AF.INET,
-            os.SOCK.STREAM | os.SOCK.NONBLOCK,
-            os.IPPROTO.TCP,
-        ) catch |err| {
-            log.err("failed to create signal server socket: {}", .{err});
-            return switch (err) {
-                error.PermissionDenied, error.ProtocolNotSupported, error.SocketTypeNotSupported, error.AddressFamilyNotSupported, error.ProtocolFamilyNotAvailable => error.NetworkSubsystemFailed,
-                error.ProcessFdQuotaExceeded, error.SystemFdQuotaExceeded, error.SystemResources => error.SystemResources,
-                error.Unexpected => error.Unexpected,
-            };
-        };
-        errdefer os.closeSocket(self.server_socket);
-
-        // Windows requires that the socket is bound before listening
-        if (builtin.target.os.tag == .windows) {
-            const addr = std.net.Address.initIp4(.{ 127, 0, 0, 1 }, 0); // zero port lets the OS choose
-            os.bind(self.server_socket, &addr.any, addr.getOsSockLen()) catch |err| {
-                log.err("failed to bind the server socket to a local random port: {}", .{err});
-                return switch (err) {
-                    error.AccessDenied => unreachable,
-                    error.AlreadyBound => unreachable,
-                    error.AddressInUse, error.AddressNotAvailable => unreachable,
-                    error.SymLinkLoop => unreachable,
-                    error.NameTooLong => unreachable,
-                    error.FileNotFound, error.FileDescriptorNotASocket => unreachable,
-                    error.NotDir => unreachable,
-                    error.ReadOnlyFileSystem => unreachable,
-                    error.SystemResources, error.NetworkSubsystemFailed, error.Unexpected => |e| e,
-                };
-            };
-        }
-
-        os.listen(self.server_socket, 1) catch |err| {
-            log.err("failed to listen on signal server socket: {}", .{err});
-            return switch (err) {
-                error.AddressInUse => unreachable,
-                error.FileDescriptorNotASocket => unreachable,
-                error.AlreadyConnected => unreachable,
-                error.SocketNotBound => unreachable,
-                error.OperationNotSupported, error.NetworkSubsystemFailed => error.NetworkSubsystemFailed,
-                error.SystemResources => error.SystemResources,
-                error.Unexpected => error.Unexpected,
-            };
-        };
-
-        var addr = std.net.Address.initIp4(undefined, undefined);
-        var addr_len = addr.getOsSockLen();
-        os.getsockname(self.server_socket, &addr.any, &addr_len) catch |err| {
-            log.err("failed to get address of signal server socket: {}", .{err});
-            return switch (err) {
-                error.SocketNotBound => unreachable,
-                error.FileDescriptorNotASocket => unreachable,
-                error.SystemResources => error.SystemResources,
-                error.NetworkSubsystemFailed => error.NetworkSubsystemFailed,
-                error.Unexpected => error.Unexpected,
-            };
-        };
-
-        self.connect_socket = self.io.open_socket(
-            os.AF.INET,
-            os.SOCK.STREAM,
-            os.IPPROTO.TCP,
-        ) catch |err| {
-            log.err("failed to create signal connect socket: {}", .{err});
-            return error.Unexpected;
-        };
-        errdefer os.closeSocket(self.connect_socket);
-
-        // Tracks when the connect_socket connects to the server_socket
-        const DoConnect = struct {
-            result: IO.ConnectError!void = undefined,
-            completion: IO.Completion = undefined,
-            is_connected: bool = false,
-
-            fn on_connect(
-                do_connect: *@This(),
-                _completion: *IO.Completion,
-                result: IO.ConnectError!void,
-            ) void {
-                assert(&do_connect.completion == _completion);
-                assert(!do_connect.is_connected);
-                do_connect.is_connected = true;
-                do_connect.result = result;
-            }
-        };
-
-        var do_connect = DoConnect{};
-        self.io.connect(
-            *DoConnect,
-            &do_connect,
-            DoConnect.on_connect,
-            &do_connect.completion,
-            self.connect_socket,
-            addr,
-        );
-
-        // Wait for the connect_socket to connect to the server_socket.
-        self.accept_socket = IO.INVALID_SOCKET;
-        while (!do_connect.is_connected or self.accept_socket == IO.INVALID_SOCKET) {
-            self.io.tick() catch |err| {
-                log.err("failed to tick IO when setting up signal: {}", .{err});
-                return error.Unexpected;
-            };
-
-            // Try to accept the connection from the connect_socket as the accept_socket
-            if (self.accept_socket == IO.INVALID_SOCKET) {
-                self.accept_socket = os.accept(self.server_socket, null, null, 0) catch |e| switch (e) {
-                    error.WouldBlock => continue,
-                    error.ConnectionAborted => unreachable,
-                    error.ConnectionResetByPeer => unreachable,
-                    error.FileDescriptorNotASocket => unreachable,
-                    error.ProcessFdQuotaExceeded, error.SystemFdQuotaExceeded, error.SystemResources => return error.SystemResources,
-                    error.SocketNotListening => unreachable,
-                    error.BlockedByFirewall => unreachable,
-                    error.ProtocolFailure, error.OperationNotSupported, error.NetworkSubsystemFailed => return error.NetworkSubsystemFailed,
-                    error.Unexpected => return error.Unexpected,
-                };
-            }
-        }
-
-        _ = do_connect.result catch |err| {
-            log.err("failed to connect on signal client socket: {}", .{err});
-            return error.Unexpected;
-        };
-
-        assert(do_connect.is_connected);
-        assert(self.accept_socket != IO.INVALID_SOCKET);
-        assert(self.connect_socket != IO.INVALID_SOCKET);
-
-        self.completion = undefined;
-        self.recv_buffer = undefined;
-        self.send_buffer = undefined;
-
-        self.state = @TypeOf(self.state).init(.running);
-        self.on_signal_fn = on_signal_fn;
-        self.wait();
-    }
-
-    pub fn deinit(self: *Signal) void {
-        os.closeSocket(self.server_socket);
-        os.closeSocket(self.accept_socket);
-        os.closeSocket(self.connect_socket);
-    }
-
-    /// Schedules the on_signal callback to be invoked on the IO thread.
-    /// Safe to call from multiple threads.
-    pub fn notify(self: *Signal) void {
-        if (self.state.swap(.notified, .Release) == .waiting) {
-            self.wake();
-        }
-    }
-
-    /// Stops the signal from firing on_signal callbacks on the IO thread.
-    /// Safe to call from multiple threads.
-    pub fn shutdown(self: *Signal) void {
-        if (self.state.swap(.shutdown, .Release) == .waiting) {
-            self.wake();
-        }
-    }
-
-    /// Return true if the Signal was marked disabled and should no longer fire on_signal callbacks.
-    /// Safe to call from multiple threads.
-    pub fn is_shutdown(self: *const Signal) bool {
-        return self.state.load(.Acquire) == .shutdown;
-    }
-
-    fn wake(self: *Signal) void {
-        assert(self.accept_socket != IO.INVALID_SOCKET);
-        self.send_buffer[0] = 0;
-
-        // TODO: use os.send() instead when it gets fixed for windows
-        if (builtin.target.os.tag != .windows) {
-            _ = os.send(self.accept_socket, &self.send_buffer, 0) catch unreachable;
-            return;
-        }
-
-        const buf: []const u8 = &self.send_buffer;
-        const rc = os.windows.sendto(self.accept_socket, buf.ptr, buf.len, 0, null, 0);
-        assert(rc != os.windows.ws2_32.SOCKET_ERROR);
-    }
-
-    fn wait(self: *Signal) void {
-        const state = self.state.compareAndSwap(
-            .running,
-            .waiting,
-            .Acquire,
-            .Acquire,
-        ) orelse return self.io.recv(
-            *Signal,
-            self,
-            on_recv,
-            &self.completion,
-            self.connect_socket,
-            &self.recv_buffer,
-        );
-
-        switch (state) {
-            .running => unreachable, // Not possible due to CAS semantics.
-            .waiting => unreachable, // We should be the only ones who could've started waiting.
-            .notified => {}, // A thread woke us up before we started waiting so reschedule below.
-            .shutdown => return, // A thread shut down the signal before we started waiting.
-        }
-
-        self.io.timeout(
-            *Signal,
-            self,
-            on_timeout,
-            &self.completion,
-            0, // zero-timeout functions as a yield
-        );
-    }
-
-    fn on_recv(
-        self: *Signal,
-        completion: *IO.Completion,
-        result: IO.RecvError!usize,
-    ) void {
-        assert(completion == &self.completion);
-        _ = result catch |err| std.debug.panic("Signal recv error: {}", .{err});
-        self.on_signal();
-    }
-
-    fn on_timeout(
-        self: *Signal,
-        completion: *IO.Completion,
-        result: IO.TimeoutError!void,
-    ) void {
-        assert(completion == &self.completion);
-        _ = result catch |err| std.debug.panic("Signal timeout error: {}", .{err});
-        self.on_signal();
-    }
-
-    fn on_signal(self: *Signal) void {
-        const state = self.state.compareAndSwap(
-            .notified,
-            .running,
-            .Acquire,
-            .Acquire,
-        ) orelse {
-            (self.on_signal_fn)(self);
-            return self.wait();
-        };
-
-        switch (state) {
-            .running => unreachable, // Multiple racing calls to on_signal().
-            .waiting => unreachable, // on_signal() called without transitioning to a waking state.
-            .notified => unreachable, // Not possible due to CAS semantics.
-            .shutdown => return, // A thread shut down the signal before we started running.
-        }
-    }
-};

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

@@ -1,88 +0,0 @@
-const std = @import("std");
-const assert = std.debug.assert;
-
-const log = std.log.scoped(.tb_client_thread);
-
-const Packet = @import("packet.zig").Packet;
-const Signal = @import("signal.zig").Signal;
-
-pub fn ThreadType(
-    comptime Context: type,
-) type {
-    return struct {
-        const Self = @This();
-
-        context: *Context,
-
-        retry: Packet.List,
-        submitted: Packet.Stack,
-
-        signal: Signal,
-        thread: std.Thread,
-
-        pub fn init(
-            self: *Self,
-            context: *Context,
-        ) !void {
-            self.context = context;
-            self.retry = .{};
-            self.submitted = .{};
-
-            log.debug("{}: init: initializing signal", .{context.client_id});
-            try self.signal.init(&context.io, Self.on_signal);
-            errdefer self.signal.deinit();
-
-            log.debug("{}: init: spawning thread", .{context.client_id});
-            self.thread = std.Thread.spawn(.{}, Context.run, .{context}) catch |err| {
-                log.err("{}: failed to spawn thread: {s}", .{
-                    context.client_id,
-                    @errorName(err),
-                });
-                return switch (err) {
-                    error.Unexpected => error.Unexpected,
-                    error.OutOfMemory => error.OutOfMemory,
-                    error.SystemResources, error.ThreadQuotaExceeded, error.LockedMemoryLimitExceeded => error.SystemResources,
-                };
-            };
-        }
-
-        pub fn deinit(self: *Self) void {
-            self.signal.shutdown();
-            self.thread.join();
-            self.signal.deinit();
-
-            self.* = undefined;
-        }
-
-        pub fn submit(self: *Self, list: Packet.List) void {
-            if (list.peek() == null) return;
-            self.submitted.push(list);
-            self.signal.notify();
-        }
-
-        fn on_signal(signal: *Signal) void {
-            const self = @fieldParentPtr(Self, "signal", signal);
-            self.context.tick();
-
-            // Consume all of retry here to avoid infinite loop
-            // if the code below pushes to self.retry while we're dequeueing.
-            var pending = self.retry;
-            self.retry = .{};
-
-            // The loop below can exit early without processing all of pending
-            // if available_messages becomes zero.
-            // In such a case we need to restore self.retry we consumed above
-            // with those that weren't processed.
-            defer {
-                pending.push(self.retry);
-                self.retry = pending;
-            }
-
-            // Process packets from either pending or submitted as long as we have messages.
-            while (self.context.messages_available > 0) {
-                const packet = pending.pop() orelse self.submitted.pop() orelse break;
-                self.context.request(packet);
-            }
-        }
-    };
-}

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

@@ -1,221 +0,0 @@
- //////////////////////////////////////////////////////////
- // 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;
-
-typedef enum TB_ACCOUNT_FLAGS {
-    TB_ACCOUNT_LINKED = 1 << 0,
-    TB_ACCOUNT_DEBITS_MUST_NOT_EXCEED_CREDITS = 1 << 1,
-    TB_ACCOUNT_CREDITS_MUST_NOT_EXCEED_DEBITS = 1 << 2,
-} TB_ACCOUNT_FLAGS;
-
-typedef struct tb_account_t {
-    tb_uint128_t id;
-    tb_uint128_t user_data;
-    uint8_t reserved[48];
-    uint32_t ledger;
-    uint16_t code;
-    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_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 {
-    tb_uint128_t id;
-    tb_uint128_t debit_account_id;
-    tb_uint128_t credit_account_id;
-    tb_uint128_t user_data;
-    tb_uint128_t reserved;
-    tb_uint128_t pending_id;
-    uint64_t timeout;
-    uint32_t ledger;
-    uint16_t code;
-    uint16_t flags;
-    uint64_t amount;
-    uint64_t timestamp;
-} tb_transfer_t;
-
-typedef enum TB_CREATE_ACCOUNT_RESULT {
-    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 = 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 {
-    uint32_t index;
-    uint32_t result;
-} tb_create_accounts_result_t;
-
-typedef struct tb_create_transfers_result_t {
-    uint32_t index;
-    uint32_t result;
-} tb_create_transfers_result_t;
-
-typedef enum TB_OPERATION {
-    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 = 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 {
-    struct tb_packet_t* next;
-    void* user_data;
-    uint8_t operation;
-    uint8_t status;
-    uint32_t data_size;
-    void* data;
-} tb_packet_t;
-
-typedef struct tb_packet_list_t {
-    struct tb_packet_t* head;
-    struct tb_packet_t* tail;
-} tb_packet_list_t;
-
-typedef void* tb_client_t; 
-
-typedef enum TB_STATUS {
-    TB_STATUS_SUCCESS = 0,
-    TB_STATUS_UNEXPECTED = 1,
-    TB_STATUS_OUT_OF_MEMORY = 2,
-    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(
-    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
-);
-
-#endif // TB_CLIENT_H
-