tigerbeetle 0.0.40 → 0.17.8

data/src/ext/tigerbeetle/tigerbeetle.c

@@ -0,0 +1,310 @@
+// Ruby doesn't guarantee ABI stability, so we must use ruby.h present on the user's machine.
+// We don't want to run a Zig compiler there though, so we have to implement this thin wrapper in C.
+#include "rb_tb_gen.h"
+#include "ruby.h"
+#include "ruby/thread.h"
+#include "tb_client.h"
+#include <stdatomic.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+typedef enum {
+    REQ_PENDING = 0,
+    REQ_DONE = 1,
+    REQ_ABANDONED = 2,
+} rb_tb_request_state_t;
+
+typedef struct rb_tb_request {
+    // Set at init, read by callback.
+    TB_OPERATION operation;
+    uint8_t *send_buf;
+    tb_packet_t packet;
+    // Shared between Ruby thread and callback.
+    _Atomic rb_tb_request_state_t state;
+    // Written by callback, read by Ruby thread.
+    uint8_t status;
+    uint8_t *result;
+    uint32_t result_size;
+} rb_tb_request_t;
+
+static VALUE rb_mTigerBeetle;
+static VALUE rb_cRequest;
+static VALUE rb_eInitError;
+static VALUE rb_eClientClosedError;
+
+static void rb_tb_init_native_client(VALUE mTigerBeetle);
+
+void Init_tigerbeetle(void) {
+    rb_mTigerBeetle = rb_define_module("TigerBeetle");
+
+    rb_eInitError = rb_define_class_under(rb_mTigerBeetle, "InitError", rb_eStandardError);
+    rb_eClientClosedError =
+        rb_define_class_under(rb_mTigerBeetle, "ClientClosedError", rb_eStandardError);
+    rb_define_class_under(rb_mTigerBeetle, "PacketError", rb_eStandardError);
+
+    rb_tb_init_native_client(rb_mTigerBeetle);
+}
+
+static void rb_tb_request_free(void *ptr) {
+    rb_tb_request_t *req = (rb_tb_request_t *)ptr;
+    rb_tb_request_state_t expected = REQ_PENDING;
+    if (atomic_compare_exchange_strong(&req->state, &expected, REQ_ABANDONED)) {
+        // Callback hasn't fired yet. It will free req once it does.
+        return;
+    }
+    // Callback already fired (state == REQ_DONE), we own cleanup.
+    tb_assert(expected == REQ_DONE);
+    free(req->result);
+    free(req);
+}
+
+static size_t rb_tb_request_size(const void *ptr) {
+    (void)ptr;
+    return sizeof(rb_tb_request_t);
+}
+
+static const rb_data_type_t rb_tb_request_type = {
+    .wrap_struct_name = "TigerBeetle::Request",
+    .function =
+        {
+            .dmark = NULL,
+            .dfree = rb_tb_request_free,
+            .dsize = rb_tb_request_size,
+        },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+// Request is only ever created from C via TypedData_Wrap_Struct.
+static VALUE rb_tb_request_alloc(VALUE klass) {
+    (void)klass;
+    rb_raise(rb_eTypeError, "TigerBeetle::Request cannot be instantiated directly");
+    return Qnil; // unreachable
+}
+
+static VALUE rb_tb_request_result(VALUE self) {
+    rb_tb_request_t *req;
+    TypedData_Get_Struct(self, rb_tb_request_t, &rb_tb_request_type, req);
+
+    VALUE result = Qnil;
+    if (req->status == TB_PACKET_OK) {
+        if (req->result_size == 0) {
+            result = rb_ary_new();
+        } else {
+            if (!req->result) {
+                rb_raise(rb_eNoMemError, "failed to allocate result buffer");
+            }
+            result = rb_tb_deserialize(req->operation, req->result, req->result_size);
+        }
+    }
+
+    return rb_ary_new_from_args(2, UINT2NUM(req->status), result);
+}
+
+static void rb_tb_write_completion(int fd, rb_tb_request_t *req) {
+    uint64_t request_id = (uint64_t)(uintptr_t)req;
+    ssize_t written = write(fd, &request_id, sizeof(request_id));
+    tb_assert(written == sizeof(request_id));
+}
+
+static void rb_tb_on_completion(
+    uintptr_t completion_ctx,
+    tb_packet_t *packet,
+    uint64_t timestamp,
+    const uint8_t *result,
+    uint32_t result_size
+) {
+    (void)timestamp;
+    rb_tb_request_t *req = (rb_tb_request_t *)packet->user_data;
+
+    free(req->send_buf);
+    req->send_buf = NULL;
+    req->status = packet->status;
+
+    if (packet->status == TB_PACKET_OK) {
+        req->result_size = result_size;
+        tb_assert(result != NULL);
+
+        if (result_size > 0) {
+            req->result = malloc(result_size);
+            if (req->result) {
+                memcpy(req->result, result, result_size);
+            }
+        }
+    }
+
+    rb_tb_request_state_t expected = REQ_PENDING;
+    if (!atomic_compare_exchange_strong(&req->state, &expected, REQ_DONE)) {
+        // dfree already ran (state == REQ_ABANDONED). We own cleanup.
+        tb_assert(expected == REQ_ABANDONED);
+        free(req->result);
+        free(req);
+        return;
+    }
+
+    rb_tb_write_completion((int)completion_ctx, req);
+}
+
+static void rb_tb_client_free(void *ptr) {
+    tb_client_deinit((tb_client_t *)ptr);
+    ruby_xfree(ptr);
+}
+
+static size_t rb_tb_client_size(const void *ptr) {
+    (void)ptr;
+    return sizeof(tb_client_t);
+}
+
+static const rb_data_type_t rb_tb_client_type = {
+    .wrap_struct_name = "TigerBeetle::NativeClient",
+    .function =
+        {
+            .dmark = NULL,
+            .dfree = rb_tb_client_free,
+            .dsize = rb_tb_client_size,
+        },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static VALUE rb_tb_client_alloc(VALUE klass) {
+    tb_client_t *data = ruby_xmalloc(sizeof(tb_client_t));
+    memset(data, 0, sizeof(tb_client_t));
+    return TypedData_Wrap_Struct(klass, &rb_tb_client_type, data);
+}
+
+static VALUE rb_tb_client_initialize(
+    VALUE self, VALUE cluster_id_rb, VALUE addresses_rb, VALUE completion_fd_rb
+) {
+    tb_client_t *client;
+    TypedData_Get_Struct(self, tb_client_t, &rb_tb_client_type, client);
+
+    uint8_t cluster_id_bytes[16] = {0};
+    rb_integer_pack(cluster_id_rb, cluster_id_bytes, 16, 1, 0, INTEGER_PACK_LITTLE_ENDIAN);
+
+    const char *addr = StringValueCStr(addresses_rb);
+    uint32_t addr_len = (uint32_t)RSTRING_LEN(addresses_rb);
+
+    int completion_fd = NUM2INT(completion_fd_rb);
+
+    TB_INIT_STATUS status = tb_client_init(
+        client, cluster_id_bytes, addr, addr_len, (uintptr_t)completion_fd, rb_tb_on_completion
+    );
+
+    if (status != TB_INIT_SUCCESS) {
+        rb_raise(rb_eInitError, "Init error: %s", rb_tb_init_error_message(status));
+    }
+
+    return self;
+}
+
+static void *rb_tb_deinit_without_gvl(void *arg) {
+    tb_client_deinit((tb_client_t *)arg);
+    return NULL;
+}
+
+static VALUE rb_tb_client_close(VALUE self) {
+    tb_client_t *client;
+    TypedData_Get_Struct(self, tb_client_t, &rb_tb_client_type, client);
+
+    // deinit blocks until all in-flight callbacks complete. The GVL is released
+    // while waiting so other Ruby threads can run.
+    rb_thread_call_without_gvl(rb_tb_deinit_without_gvl, client, NULL, NULL);
+    return Qnil;
+}
+
+typedef struct rb_tb_serialize_context {
+    TB_OPERATION operation;
+    VALUE items_rb;
+    uint8_t *buf;
+    long count;
+} rb_tb_serialize_context_t;
+
+static VALUE rb_tb_serialize_protected(VALUE context_value) {
+    rb_tb_serialize_context_t *context = (rb_tb_serialize_context_t *)context_value;
+    rb_tb_serialize(context->operation, context->items_rb, context->buf, context->count);
+    return Qnil;
+}
+
+static VALUE rb_tb_client_submit(VALUE self, VALUE operation_rb, VALUE items_rb) {
+    tb_client_t *client;
+    TypedData_Get_Struct(self, tb_client_t, &rb_tb_client_type, client);
+
+    TB_OPERATION operation = (TB_OPERATION)NUM2INT(operation_rb);
+    long count = RARRAY_LEN(items_rb);
+
+    rb_tb_request_t *req = malloc(sizeof(rb_tb_request_t));
+    if (!req) {
+        rb_raise(rb_eNoMemError, "failed to allocate request");
+    }
+    memset(req, 0, sizeof(rb_tb_request_t));
+    req->operation = operation;
+
+    if (count > 0) {
+        size_t event_size = rb_tb_event_size(operation);
+        long max_count = (long)(UINT32_MAX / event_size);
+        if (count > max_count) {
+            free(req);
+            rb_raise(rb_eArgError, "batch size exceeds maximum request size");
+        }
+        size_t send_size = event_size * (size_t)count;
+        req->send_buf = malloc(send_size);
+        if (!req->send_buf) {
+            free(req);
+            rb_raise(rb_eNoMemError, "failed to allocate send buffer");
+        }
+
+        rb_tb_serialize_context_t serialize_context = {
+            .operation = operation,
+            .items_rb = items_rb,
+            .buf = req->send_buf,
+            .count = count,
+        };
+        int serialize_state = 0;
+        rb_protect(rb_tb_serialize_protected, (VALUE)&serialize_context, &serialize_state);
+        if (serialize_state) {
+            free(req->send_buf);
+            free(req);
+            rb_jump_tag(serialize_state);
+        }
+
+        req->packet.data_size = (uint32_t)send_size;
+    }
+
+    req->packet.data = req->send_buf;
+    req->packet.operation = (uint8_t)operation;
+    req->packet.user_data = req;
+
+    TB_CLIENT_STATUS cs = tb_client_submit(client, &req->packet);
+    if (cs == TB_CLIENT_INVALID) {
+        free(req->send_buf);
+        free(req);
+        rb_raise(rb_eClientClosedError, "client is closed");
+    }
+
+    return TypedData_Wrap_Struct(rb_cRequest, &rb_tb_request_type, req);
+}
+
+static VALUE rb_tb_request_id(VALUE self) {
+    rb_tb_request_t *req;
+    TypedData_Get_Struct(self, rb_tb_request_t, &rb_tb_request_type, req);
+    return ULL2NUM((unsigned long long)(uintptr_t)req);
+}
+
+static void rb_tb_init_native_client(VALUE mTigerBeetle) {
+    rb_define_const(mTigerBeetle, "PACKET_OK", INT2NUM(TB_PACKET_OK));
+    rb_define_const(mTigerBeetle, "PACKET_CLIENT_SHUTDOWN", INT2NUM(TB_PACKET_CLIENT_SHUTDOWN));
+
+    VALUE cNativeClient = rb_define_class_under(mTigerBeetle, "NativeClient", rb_cObject);
+    rb_define_alloc_func(cNativeClient, rb_tb_client_alloc);
+    rb_define_method(cNativeClient, "initialize", rb_tb_client_initialize, 3);
+    rb_define_method(cNativeClient, "submit", rb_tb_client_submit, 2);
+    rb_define_method(cNativeClient, "close", rb_tb_client_close, 0);
+
+    rb_cRequest = rb_define_class_under(mTigerBeetle, "Request", rb_cObject);
+    rb_define_alloc_func(rb_cRequest, rb_tb_request_alloc);
+    rb_define_method(rb_cRequest, "id", rb_tb_request_id, 0);
+    rb_define_method(rb_cRequest, "result", rb_tb_request_result, 0);
+}

data/src/tigerbeetle/bindings.rb

@@ -0,0 +1,347 @@
+########################################################
+## This file was auto-generated by ruby_bindings.zig ##
+##              Do not manually modify.              ##
+########################################################
+
+module TigerBeetle
+  module AccountFlags
+    NONE = 0
+    LINKED = 1 << 0
+    DEBITS_MUST_NOT_EXCEED_CREDITS = 1 << 1
+    CREDITS_MUST_NOT_EXCEED_DEBITS = 1 << 2
+    HISTORY = 1 << 3
+    IMPORTED = 1 << 4
+    CLOSED = 1 << 5
+  end
+
+  module TransferFlags
+    NONE = 0
+    LINKED = 1 << 0
+    PENDING = 1 << 1
+    POST_PENDING_TRANSFER = 1 << 2
+    VOID_PENDING_TRANSFER = 1 << 3
+    BALANCING_DEBIT = 1 << 4
+    BALANCING_CREDIT = 1 << 5
+    CLOSING_DEBIT = 1 << 6
+    CLOSING_CREDIT = 1 << 7
+    IMPORTED = 1 << 8
+  end
+
+  module AccountFilterFlags
+    NONE = 0
+    DEBITS = 1 << 0
+    CREDITS = 1 << 1
+    REVERSED = 1 << 2
+  end
+
+  module QueryFilterFlags
+    NONE = 0
+    REVERSED = 1 << 0
+  end
+
+  module Operation
+    LOOKUP_ACCOUNTS = 140
+    LOOKUP_TRANSFERS = 141
+    GET_ACCOUNT_TRANSFERS = 142
+    GET_ACCOUNT_BALANCES = 143
+    QUERY_ACCOUNTS = 144
+    QUERY_TRANSFERS = 145
+    CREATE_ACCOUNTS = 146
+    CREATE_TRANSFERS = 147
+  end
+
+  module CreateAccountStatus
+    CREATED = 4294967295
+    LINKED_EVENT_FAILED = 1
+    LINKED_EVENT_CHAIN_OPEN = 2
+    IMPORTED_EVENT_EXPECTED = 22
+    IMPORTED_EVENT_NOT_EXPECTED = 23
+    TIMESTAMP_MUST_BE_ZERO = 3
+    IMPORTED_EVENT_TIMESTAMP_OUT_OF_RANGE = 24
+    IMPORTED_EVENT_TIMESTAMP_MUST_NOT_ADVANCE = 25
+    RESERVED_FIELD = 4
+    RESERVED_FLAG = 5
+    ID_MUST_NOT_BE_ZERO = 6
+    ID_MUST_NOT_BE_INT_MAX = 7
+    EXISTS_WITH_DIFFERENT_FLAGS = 15
+    EXISTS_WITH_DIFFERENT_USER_DATA_128 = 16
+    EXISTS_WITH_DIFFERENT_USER_DATA_64 = 17
+    EXISTS_WITH_DIFFERENT_USER_DATA_32 = 18
+    EXISTS_WITH_DIFFERENT_LEDGER = 19
+    EXISTS_WITH_DIFFERENT_CODE = 20
+    EXISTS = 21
+    FLAGS_ARE_MUTUALLY_EXCLUSIVE = 8
+    DEBITS_PENDING_MUST_BE_ZERO = 9
+    DEBITS_POSTED_MUST_BE_ZERO = 10
+    CREDITS_PENDING_MUST_BE_ZERO = 11
+    CREDITS_POSTED_MUST_BE_ZERO = 12
+    LEDGER_MUST_NOT_BE_ZERO = 13
+    CODE_MUST_NOT_BE_ZERO = 14
+    IMPORTED_EVENT_TIMESTAMP_MUST_NOT_REGRESS = 26
+  end
+
+  module CreateTransferStatus
+    CREATED = 4294967295
+    LINKED_EVENT_FAILED = 1
+    LINKED_EVENT_CHAIN_OPEN = 2
+    IMPORTED_EVENT_EXPECTED = 56
+    IMPORTED_EVENT_NOT_EXPECTED = 57
+    TIMESTAMP_MUST_BE_ZERO = 3
+    IMPORTED_EVENT_TIMESTAMP_OUT_OF_RANGE = 58
+    IMPORTED_EVENT_TIMESTAMP_MUST_NOT_ADVANCE = 59
+    RESERVED_FLAG = 4
+    ID_MUST_NOT_BE_ZERO = 5
+    ID_MUST_NOT_BE_INT_MAX = 6
+    EXISTS_WITH_DIFFERENT_FLAGS = 36
+    EXISTS_WITH_DIFFERENT_PENDING_ID = 40
+    EXISTS_WITH_DIFFERENT_TIMEOUT = 44
+    EXISTS_WITH_DIFFERENT_DEBIT_ACCOUNT_ID = 37
+    EXISTS_WITH_DIFFERENT_CREDIT_ACCOUNT_ID = 38
+    EXISTS_WITH_DIFFERENT_AMOUNT = 39
+    EXISTS_WITH_DIFFERENT_USER_DATA_128 = 41
+    EXISTS_WITH_DIFFERENT_USER_DATA_64 = 42
+    EXISTS_WITH_DIFFERENT_USER_DATA_32 = 43
+    EXISTS_WITH_DIFFERENT_LEDGER = 67
+    EXISTS_WITH_DIFFERENT_CODE = 45
+    EXISTS = 46
+    ID_ALREADY_FAILED = 68
+    FLAGS_ARE_MUTUALLY_EXCLUSIVE = 7
+    DEBIT_ACCOUNT_ID_MUST_NOT_BE_ZERO = 8
+    DEBIT_ACCOUNT_ID_MUST_NOT_BE_INT_MAX = 9
+    CREDIT_ACCOUNT_ID_MUST_NOT_BE_ZERO = 10
+    CREDIT_ACCOUNT_ID_MUST_NOT_BE_INT_MAX = 11
+    ACCOUNTS_MUST_BE_DIFFERENT = 12
+    PENDING_ID_MUST_BE_ZERO = 13
+    PENDING_ID_MUST_NOT_BE_ZERO = 14
+    PENDING_ID_MUST_NOT_BE_INT_MAX = 15
+    PENDING_ID_MUST_BE_DIFFERENT = 16
+    TIMEOUT_RESERVED_FOR_PENDING_TRANSFER = 17
+    CLOSING_TRANSFER_MUST_BE_PENDING = 64
+    LEDGER_MUST_NOT_BE_ZERO = 19
+    CODE_MUST_NOT_BE_ZERO = 20
+    DEBIT_ACCOUNT_NOT_FOUND = 21
+    CREDIT_ACCOUNT_NOT_FOUND = 22
+    ACCOUNTS_MUST_HAVE_THE_SAME_LEDGER = 23
+    TRANSFER_MUST_HAVE_THE_SAME_LEDGER_AS_ACCOUNTS = 24
+    PENDING_TRANSFER_NOT_FOUND = 25
+    PENDING_TRANSFER_NOT_PENDING = 26
+    PENDING_TRANSFER_HAS_DIFFERENT_DEBIT_ACCOUNT_ID = 27
+    PENDING_TRANSFER_HAS_DIFFERENT_CREDIT_ACCOUNT_ID = 28
+    PENDING_TRANSFER_HAS_DIFFERENT_LEDGER = 29
+    PENDING_TRANSFER_HAS_DIFFERENT_CODE = 30
+    EXCEEDS_PENDING_TRANSFER_AMOUNT = 31
+    PENDING_TRANSFER_HAS_DIFFERENT_AMOUNT = 32
+    PENDING_TRANSFER_ALREADY_POSTED = 33
+    PENDING_TRANSFER_ALREADY_VOIDED = 34
+    PENDING_TRANSFER_EXPIRED = 35
+    IMPORTED_EVENT_TIMESTAMP_MUST_NOT_REGRESS = 60
+    IMPORTED_EVENT_TIMESTAMP_MUST_POSTDATE_DEBIT_ACCOUNT = 61
+    IMPORTED_EVENT_TIMESTAMP_MUST_POSTDATE_CREDIT_ACCOUNT = 62
+    IMPORTED_EVENT_TIMEOUT_MUST_BE_ZERO = 63
+    DEBIT_ACCOUNT_ALREADY_CLOSED = 65
+    CREDIT_ACCOUNT_ALREADY_CLOSED = 66
+    OVERFLOWS_DEBITS_PENDING = 47
+    OVERFLOWS_CREDITS_PENDING = 48
+    OVERFLOWS_DEBITS_POSTED = 49
+    OVERFLOWS_CREDITS_POSTED = 50
+    OVERFLOWS_DEBITS = 51
+    OVERFLOWS_CREDITS = 52
+    OVERFLOWS_TIMEOUT = 53
+    EXCEEDS_CREDITS = 54
+    EXCEEDS_DEBITS = 55
+  end
+
+  class Account
+    attr_accessor :id
+    attr_accessor :debits_pending
+    attr_accessor :debits_posted
+    attr_accessor :credits_pending
+    attr_accessor :credits_posted
+    attr_accessor :user_data_128
+    attr_accessor :user_data_64
+    attr_accessor :user_data_32
+    attr_accessor :ledger
+    attr_accessor :code
+    attr_accessor :flags
+    attr_accessor :timestamp
+
+    def initialize(
+      id: 0,
+      debits_pending: 0,
+      debits_posted: 0,
+      credits_pending: 0,
+      credits_posted: 0,
+      user_data_128: 0,
+      user_data_64: 0,
+      user_data_32: 0,
+      ledger: 0,
+      code: 0,
+      flags: AccountFlags::NONE,
+      timestamp: 0
+    )
+      @id = id
+      @debits_pending = debits_pending
+      @debits_posted = debits_posted
+      @credits_pending = credits_pending
+      @credits_posted = credits_posted
+      @user_data_128 = user_data_128
+      @user_data_64 = user_data_64
+      @user_data_32 = user_data_32
+      @ledger = ledger
+      @code = code
+      @flags = flags
+      @timestamp = timestamp
+    end
+  end
+
+  class Transfer
+    attr_accessor :id
+    attr_accessor :debit_account_id
+    attr_accessor :credit_account_id
+    attr_accessor :amount
+    attr_accessor :pending_id
+    attr_accessor :user_data_128
+    attr_accessor :user_data_64
+    attr_accessor :user_data_32
+    attr_accessor :timeout
+    attr_accessor :ledger
+    attr_accessor :code
+    attr_accessor :flags
+    attr_accessor :timestamp
+
+    def initialize(
+      id: 0,
+      debit_account_id: 0,
+      credit_account_id: 0,
+      amount: 0,
+      pending_id: 0,
+      user_data_128: 0,
+      user_data_64: 0,
+      user_data_32: 0,
+      timeout: 0,
+      ledger: 0,
+      code: 0,
+      flags: TransferFlags::NONE,
+      timestamp: 0
+    )
+      @id = id
+      @debit_account_id = debit_account_id
+      @credit_account_id = credit_account_id
+      @amount = amount
+      @pending_id = pending_id
+      @user_data_128 = user_data_128
+      @user_data_64 = user_data_64
+      @user_data_32 = user_data_32
+      @timeout = timeout
+      @ledger = ledger
+      @code = code
+      @flags = flags
+      @timestamp = timestamp
+    end
+  end
+
+  class AccountFilter
+    attr_accessor :account_id
+    attr_accessor :user_data_128
+    attr_accessor :user_data_64
+    attr_accessor :user_data_32
+    attr_accessor :code
+    attr_accessor :timestamp_min
+    attr_accessor :timestamp_max
+    attr_accessor :limit
+    attr_accessor :flags
+
+    def initialize(
+      account_id: 0,
+      user_data_128: 0,
+      user_data_64: 0,
+      user_data_32: 0,
+      code: 0,
+      timestamp_min: 0,
+      timestamp_max: 0,
+      limit: 0,
+      flags: AccountFilterFlags::NONE
+    )
+      @account_id = account_id
+      @user_data_128 = user_data_128
+      @user_data_64 = user_data_64
+      @user_data_32 = user_data_32
+      @code = code
+      @timestamp_min = timestamp_min
+      @timestamp_max = timestamp_max
+      @limit = limit
+      @flags = flags
+    end
+  end
+
+  class QueryFilter
+    attr_accessor :user_data_128
+    attr_accessor :user_data_64
+    attr_accessor :user_data_32
+    attr_accessor :ledger
+    attr_accessor :code
+    attr_accessor :timestamp_min
+    attr_accessor :timestamp_max
+    attr_accessor :limit
+    attr_accessor :flags
+
+    def initialize(
+      user_data_128: 0,
+      user_data_64: 0,
+      user_data_32: 0,
+      ledger: 0,
+      code: 0,
+      timestamp_min: 0,
+      timestamp_max: 0,
+      limit: 0,
+      flags: QueryFilterFlags::NONE
+    )
+      @user_data_128 = user_data_128
+      @user_data_64 = user_data_64
+      @user_data_32 = user_data_32
+      @ledger = ledger
+      @code = code
+      @timestamp_min = timestamp_min
+      @timestamp_max = timestamp_max
+      @limit = limit
+      @flags = flags
+    end
+  end
+
+  class AccountBalance
+    attr_reader :debits_pending
+    attr_reader :debits_posted
+    attr_reader :credits_pending
+    attr_reader :credits_posted
+    attr_reader :timestamp
+
+    def initialize
+      @debits_pending = 0
+      @debits_posted = 0
+      @credits_pending = 0
+      @credits_posted = 0
+      @timestamp = 0
+    end
+  end
+
+  class CreateAccountResult
+    attr_reader :timestamp
+    attr_reader :status
+
+    def initialize
+      @timestamp = 0
+      @status = 0
+    end
+  end
+
+  class CreateTransferResult
+    attr_reader :timestamp
+    attr_reader :status
+
+    def initialize
+      @timestamp = 0
+      @status = 0
+    end
+  end
+
+end