tigerbeetle 0.0.37-aarch64-linux

data/lib/tb_client.rb

@@ -0,0 +1,282 @@
+require 'ffi'
+require 'tb_client/shared_lib'
+
+module TBClient
+  extend FFI::Library
+
+  ffi_lib SharedLib.path
+
+  InitStatus = enum(FFI::Type::UINT8, [
+                    :SUCCESS, 0,
+                    :UNEXPECTED,
+                    :OUT_OF_MEMORY,
+                    :ADDRESS_INVALID,
+                    :ADDRESS_LIMIT_EXCEEDED,
+                    :SYSTEM_RESOURCES,
+                    :NETWORK_SUBSYSTEM])
+
+  ClientStatus = enum(FFI::Type::UINT8, [
+                      :OK, 0,
+                      :INVALID])
+
+  PacketStatus = enum(FFI::Type::UINT8, [
+                      :OK, 0,
+                      :TOO_MUCH_DATA,
+                      :CLIENT_EVICTED,
+                      :CLIENT_RELEASE_TOO_LOW,
+                      :CLIENT_RELEASE_TOO_HIGH,
+                      :CLIENT_SHUTDOWN,
+                      :INVALID_OPERATION,
+                      :INVALID_DATA_SIZE])
+
+  RegisterLogCallbackStatus = enum(FFI::Type::UINT8, [
+                                   :SUCCESS, 0,
+                                   :ALREADY_REGISTERED,
+                                   :NOT_REGISTERED])
+
+  Operation = enum(FFI::Type::UINT8, [
+                   :PULSE, 128,
+                   :GET_EVENTS, 137,
+                   :CREATE_ACCOUNTS, 138,
+                   :CREATE_TRANSFERS, 139,
+                   :LOOKUP_ACCOUNTS, 140,
+                   :LOOKUP_TRANSFERS, 141,
+                   :GET_ACCOUNT_TRANSFERS, 142,
+                   :GET_ACCOUNT_BALANCES, 143,
+                   :QUERY_ACCOUNTS, 144,
+                   :QUERY_TRANSFERS, 145])
+
+  CreateAccountResult = enum(FFI::Type::UINT32, [
+                             :OK, 0,
+                             :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])
+
+  CreateTransferResult = enum(FFI::Type::UINT32, [
+                              :OK, 0,
+                              :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])
+
+  LogLevel = enum(FFI::Type::UINT8, [
+                  :ERR, 0,
+                  :WARN,
+                  :INFO,
+                  :DEBUG])
+
+  AccountFlags = bitmask(FFI::Type::UINT16, [
+    :LINKED,
+    :DEBITS_MUST_NOT_EXCEED_CREDITS,
+    :CREDITS_MUST_NOT_EXCEED_DEBITS,
+    :HISTORY,
+    :IMPORTED,
+    :CLOSED]
+  )
+
+  TransferFlags = bitmask(FFI::Type::UINT16, [
+    :LINKED,
+    :PENDING,
+    :POST_PENDING_TRANSFER,
+    :VOID_PENDING_TRANSFER,
+    :BALANCING_DEBIT,
+    :BALANCING_CREDIT,
+    :CLOSING_DEBIT,
+    :CLOSING_CREDIT,
+    :IMPORTED]
+  )
+
+  AccountFilterFlags = bitmask(FFI::Type::UINT32, [:DEBITS, :CREDITS, :REVERSED])
+
+  QueryFilterFlags = bitmask(FFI::Type::UINT32, [:REVERSED])
+
+  class Client < FFI::Struct
+    layout opaque: [:uint64, 4]
+  end
+
+  class UInt128 < FFI::Struct
+    layout low: :uint64,
+           high: :uint64
+  end
+
+  class Packet < FFI::Struct
+    layout user_data: :pointer,
+           data: :pointer,
+           data_size: :uint32,
+           user_tag: :uint16,
+           operation: Operation,
+           status: PacketStatus,
+           opaque: [:uint8, 64]
+  end
+
+  class Account < FFI::Struct
+    layout id: UInt128,
+           debits_pending: UInt128,
+           debits_posted: UInt128,
+           credits_pending: UInt128,
+           credits_posted: UInt128,
+           user_data_128: UInt128,
+           user_data_64: :uint64,
+           user_data_32: :uint32,
+           reserved: :uint32,
+           ledger: :uint32,
+           code: :uint16,
+           flags: AccountFlags,
+           timestamp: :uint64
+  end
+
+  class Transfer < FFI::Struct
+    layout id: UInt128,
+           debit_account_id: UInt128,
+           credit_account_id: UInt128,
+           amount: UInt128,
+           pending_id: UInt128,
+           user_data_128: UInt128,
+           user_data_64: :uint64,
+           user_data_32: :uint32,
+           timeout: :uint32,
+           ledger: :uint32,
+           code: :uint16,
+           flags: TransferFlags,
+           timestamp: :uint64
+  end
+
+  class CreateAccountsResult < FFI::Struct
+    layout index: :uint32,
+           result: CreateAccountResult
+  end
+
+  class CreateTransfersResult < FFI::Struct
+    layout index: :uint32,
+           result: CreateTransferResult
+  end
+
+  class AccountFilter < FFI::Struct
+    layout account_id: UInt128,
+           user_data_128: UInt128,
+           user_data_64: :uint64,
+           user_data_32: :uint32,
+           code: :uint16,
+           reserved: [:uint8, 58],
+           timestamp_min: :uint64,
+           timestamp_max: :uint64,
+           limit: :uint32,
+           flags: AccountFilterFlags
+  end
+
+  class QueryFilter < FFI::Struct
+    layout user_data_128: UInt128,
+           user_data_64: :uint64,
+           user_data_32: :uint32,
+           ledger: :uint32,
+           code: :uint16,
+           reserved: [:uint8, 6],
+           timestamp_min: :uint64,
+           timestamp_max: :uint64,
+           limit: :uint32,
+           flags: QueryFilterFlags
+  end
+
+  class AccountBalance < FFI::Struct
+    layout debits_pending: UInt128,
+           debits_posted: UInt128,
+           credits_pending: UInt128,
+           credits_posted: UInt128,
+           timestamp: :uint64,
+           reserved: [:uint8, 56]
+  end
+
+  callback :on_completion, [:uint, Packet.by_ref, :uint64, :pointer, :uint32], :void
+  callback :log_handler, [LogLevel, :pointer, :uint32], :void
+
+  attach_function :tb_client_init, [Client.by_ref, :pointer, :string, :uint32, :uint, :on_completion], InitStatus
+  attach_function :tb_client_submit, [Client.by_ref, Packet.by_ref], ClientStatus
+  attach_function :tb_client_deinit, [Client.by_ref], ClientStatus
+  attach_function :tb_client_register_log_callback, [:log_handler, :bool], RegisterLogCallbackStatus
+end

data/lib/tigerbeetle/account.rb

@@ -0,0 +1,38 @@
+module TigerBeetle
+  ACCOUNT_PARAMS = %i[
+    id debits_pending debits_posted credits_pending credits_posted user_data_128
+    user_data_64 user_data_32 ledger code flags timestamp
+  ]
+
+  Account = Struct.new(*ACCOUNT_PARAMS) do
+    def initialize(
+      id:,
+      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:,
+      code:,
+      flags: [],
+      timestamp: nil
+    )
+      super(
+        id,
+        debits_pending,
+        debits_posted,
+        credits_pending,
+        credits_posted,
+        user_data_128,
+        user_data_64,
+        user_data_32,
+        ledger,
+        code,
+        flags,
+        timestamp
+      )
+    end
+  end
+end

data/lib/tigerbeetle/account_balance.rb

@@ -0,0 +1,23 @@
+module TigerBeetle
+  ACCOUNT_BALANCE_PARAMS = %i[
+    debits_pending debits_posted credits_pending credits_posted timestamp
+  ]
+
+  AccountBalance = Struct.new(*ACCOUNT_BALANCE_PARAMS) do
+    def initialize(
+      debits_pending: 0,
+      debits_posted: 0,
+      credits_pending: 0,
+      credits_posted: 0,
+      timestamp: 0
+    )
+      super(
+        debits_pending,
+        debits_posted,
+        credits_pending,
+        credits_posted,
+        timestamp
+      )
+    end
+  end
+end

data/lib/tigerbeetle/account_filter.rb

@@ -0,0 +1,31 @@
+module TigerBeetle
+  ACCOUNT_FILTER_PARAMS = %i[
+    account_id user_data_128 user_data_64 user_data_32 code timestamp_min timestamp_max limit flags
+  ]
+
+  AccountFilter = Struct.new(*ACCOUNT_FILTER_PARAMS) do
+    def initialize(
+      account_id:,
+      user_data_128: 0,
+      user_data_64: 0,
+      user_data_32: 0,
+      code: 0,
+      timestamp_min: 0,
+      timestamp_max: 0,
+      limit:,
+      flags: []
+    )
+      super(
+        account_id,
+        user_data_128,
+        user_data_64,
+        user_data_32,
+        code,
+        timestamp_min,
+        timestamp_max,
+        limit,
+        flags
+      )
+    end
+  end
+end

data/lib/tigerbeetle/atomic_counter.rb

@@ -0,0 +1,14 @@
+module TigerBeetle
+  class AtomicCounter
+    attr_reader :value
+
+    def initialize(value = 0)
+      @value = value
+      @mutex = Mutex.new
+    end
+
+    def increment
+      @mutex.synchronize { @value += 1 }
+    end
+  end
+end

data/lib/tigerbeetle/client.rb

@@ -0,0 +1,214 @@
+require 'ffi'
+require 'tb_client'
+require 'tigerbeetle/converters'
+require 'tigerbeetle/account'
+require 'tigerbeetle/account_balance'
+require 'tigerbeetle/account_filter'
+require 'tigerbeetle/atomic_counter'
+require 'tigerbeetle/error'
+require 'tigerbeetle/query_filter'
+require 'tigerbeetle/request'
+require 'tigerbeetle/transfer'
+
+module TigerBeetle
+  class Client
+    def self.next_id
+      @counter ||= AtomicCounter.new
+      @counter.increment
+    end
+
+    def initialize(cluster_id = 0, address = '3000')
+      @inflight_requests = {}
+      # Keep a pointer to prevent proc from getting GCed
+      @callback = Proc.new { |*args| callback(*args) }
+      @client_id = self.class.next_id
+      @client = TBClient::Client.new
+
+      # FFI::MemoryPointer.new(:pointer, 1) # **void
+      cluster_id_ptr = serialize([cluster_id], Converters::UInt128)
+
+      status = TBClient.tb_client_init(
+        @client,
+        cluster_id_ptr,
+        address,
+        address.length,
+        @client_id,
+        &@callback
+      )
+      raise ClientError, "Unable to initialize native client: #{status}" unless status == :SUCCESS
+
+      # Make sure to deinitialize all clients when the process terminates
+      at_exit { deinit }
+    end
+
+    def logger=(logger)
+      @logger = logger
+      @log_callback = @logger ? Proc.new { |*args| log_callback(*args) } : nil
+
+      status = TBClient.tb_client_register_log_callback(@log_callback, true)
+      raise ClientError, "Unable to register logger: #{status}" unless status == :SUCCESS
+    end
+
+    def create_accounts(*accounts, &block)
+      submit_request(
+        :CREATE_ACCOUNTS,
+        accounts,
+        Converters::Account,
+        Converters::CreateAccountsResult,
+        &block
+      )
+    end
+
+    def create_transfers(*transfers, &block)
+      submit_request(
+        :CREATE_TRANSFERS,
+        transfers,
+        Converters::Transfer,
+        Converters::CreateTransfersResult,
+        &block
+      )
+    end
+
+    def lookup_accounts(*account_ids, &block)
+      submit_request(
+        :LOOKUP_ACCOUNTS,
+        account_ids,
+        Converters::UInt128,
+        Converters::Account,
+        &block
+      )
+    end
+
+    def lookup_transfers(*transfer_ids, &block)
+      submit_request(
+        :LOOKUP_TRANSFERS,
+        transfer_ids,
+        Converters::UInt128,
+        Converters::Transfer,
+        &block
+      )
+    end
+
+    def get_account_transfers(filter, &block)
+      submit_request(
+        :GET_ACCOUNT_TRANSFERS,
+        [filter],
+        Converters::AccountFilter,
+        Converters::Transfer,
+        &block
+      )
+    end
+
+    def get_account_balances(filter, &block)
+      submit_request(
+        :GET_ACCOUNT_BALANCES,
+        [filter],
+        Converters::AccountFilter,
+        Converters::AccountBalance,
+        &block
+      )
+    end
+
+    def query_accounts(filter, &block)
+      submit_request(
+        :QUERY_ACCOUNTS,
+        [filter],
+        Converters::QueryFilter,
+        Converters::Account,
+        &block
+      )
+    end
+
+    def query_transfers(filter, &block)
+      submit_request(
+        :QUERY_TRANSFERS,
+        [filter],
+        Converters::QueryFilter,
+        Converters::Transfer,
+        &block
+      )
+    end
+
+    def deinit
+      return unless client
+      return unless inflight_requests.empty?
+
+      TBClient.tb_client_deinit(client)
+      @client = nil
+    end
+
+    private
+
+    attr_reader :context, :client, :inflight_requests, :logger
+
+    def log_callback(level, ptr, length)
+      message = ptr.read_string(length).force_encoding('UTF-8')
+      case level
+      when :ERR then logger.error(message)
+      when :WARN then logger.warn(message)
+      when :INFO then logger.info(message)
+      when :DEBUG then logger.debug(message)
+      end
+    end
+
+    def callback(client_id, packet, timestamp, result_ptr, result_len)
+      request_id = packet[:user_data].read_uint64
+      request = inflight_requests.delete(request_id)
+      result = deserialize(result_ptr, request.converter, result_len)
+      request.block.call(result)
+    end
+
+    def submit_request(operation, request, request_converter, response_converter, &block)
+      raise ClientError, 'Client is not connected' unless client
+
+      request_id = self.class.next_id
+      user_data_ptr = FFI::MemoryPointer.new(:uint64, 1)
+      user_data_ptr.write_uint64(request_id)
+
+      data_ptr = serialize(request, request_converter)
+
+      packet = TBClient::Packet.new
+      packet[:user_data] = user_data_ptr
+      packet[:operation] = operation
+      packet[:status] = :OK
+      packet[:data_size] = data_ptr.size
+      packet[:data] = data_ptr
+
+      queue = Queue.new
+      inflight_requests[request_id] = Request.new(packet, response_converter) do |response|
+        if block
+          block.call(response)
+        else
+          queue << response
+        end
+      end
+
+      status = TBClient.tb_client_submit(client, packet)
+      raise ClientError, "Unable to submit request: #{status}" unless status == :OK
+
+      # block until the client return a response
+      queue.pop unless block
+    end
+
+    def serialize(data, converter)
+      data_ptr = FFI::MemoryPointer.new(converter.native_type, data.length, true)
+      data.each_with_index do |value, i|
+        # initialize type at the memory address and write value over it
+        converter.to_native(data_ptr[i], value)
+      end
+
+      data_ptr
+    end
+
+    def deserialize(ptr, converter, length)
+      type = converter.native_type
+      # copy data to own memory to retain it after tb_client has freed its memory
+      own_ptr = FFI::MemoryPointer.new(:char, type.size * length)
+      own_ptr.put_bytes(0, ptr.read_bytes(type.size * length))
+
+      Array.new(length / type.size) do |i|
+        converter.from_native(own_ptr + i * type.size)
+      end
+    end
+  end
+end

data/lib/tigerbeetle/converters/account.rb

@@ -0,0 +1,63 @@
+require 'tb_client'
+require 'tigerbeetle/account'
+require 'tigerbeetle/converters/base'
+require 'tigerbeetle/converters/time'
+require 'tigerbeetle/converters/uint_128'
+
+module TigerBeetle
+  module Converters
+    class Account < Base
+      def self.native_type
+        TBClient::Account
+      end
+
+      def from_native(ptr)
+        c_value = TBClient::Account.new(ptr)
+
+        TigerBeetle::Account.new(
+          id: Converters::UInt128.from_native(c_value[:id].to_ptr),
+          debits_pending: Converters::UInt128.from_native(c_value[:debits_pending].to_ptr),
+          debits_posted: Converters::UInt128.from_native(c_value[:debits_posted].to_ptr),
+          credits_pending: Converters::UInt128.from_native(c_value[:credits_pending].to_ptr),
+          credits_posted: Converters::UInt128.from_native(c_value[:credits_posted].to_ptr),
+          user_data_128: Converters::UInt128.from_native(c_value[:user_data_128].to_ptr),
+          user_data_64: c_value[:user_data_64],
+          user_data_32: c_value[:user_data_32],
+          ledger: c_value[:ledger],
+          code: c_value[:code],
+          flags: c_value[:flags],
+          timestamp: Converters::Time.from_native(ptr + c_value.offset_of(:timestamp))
+        )
+      end
+
+      def to_native(ptr, value)
+        validate_uint!(:id, 128, value.id)
+        validate_uint!(:debits_pending, 128, value.debits_pending)
+        validate_uint!(:debits_posted, 128, value.debits_posted)
+        validate_uint!(:credits_pending, 128, value.credits_pending)
+        validate_uint!(:credits_posted, 128, value.credits_posted)
+        validate_uint!(:user_data_128, 128, value.user_data_128)
+        validate_uint!(:user_data_64, 64, value.user_data_64)
+        validate_uint!(:user_data_32, 32, value.user_data_32)
+        validate_uint!(:ledger, 32, value.ledger)
+        validate_uint!(:code, 16, value.code)
+
+        TBClient::Account.new(ptr).tap do |result|
+          Converters::UInt128.to_native(result[:id].to_ptr, value.id)
+          Converters::UInt128.to_native(result[:debits_pending].to_ptr, value.debits_pending)
+          Converters::UInt128.to_native(result[:debits_posted].to_ptr, value.debits_posted)
+          Converters::UInt128.to_native(result[:credits_pending].to_ptr, value.credits_pending)
+          Converters::UInt128.to_native(result[:credits_posted].to_ptr, value.credits_posted)
+          Converters::UInt128.to_native(result[:user_data_128].to_ptr, value.user_data_128)
+          result[:user_data_64] = value.user_data_64
+          result[:user_data_32] = value.user_data_32
+          result[:reserved] = 0
+          result[:ledger] = value.ledger
+          result[:code] = value.code
+          result[:flags] = value.flags
+          Converters::Time.to_native(ptr + result.offset_of(:timestamp), value.timestamp || 0)
+        end
+      end
+    end
+  end
+end

data/lib/tigerbeetle/converters/account_balance.rb

@@ -0,0 +1,31 @@
+require 'tb_client'
+require 'tigerbeetle/account_balance'
+require 'tigerbeetle/converters/base'
+require 'tigerbeetle/converters/time'
+require 'tigerbeetle/converters/uint_128'
+
+module TigerBeetle
+  module Converters
+    class AccountBalance < Base
+      def self.native_type
+        TBClient::AccountBalance
+      end
+
+      def from_native(ptr)
+        c_value = TBClient::AccountBalance.new(ptr)
+
+        TigerBeetle::AccountBalance.new(
+          debits_pending: Converters::UInt128.from_native(c_value[:debits_pending].to_ptr),
+          debits_posted: Converters::UInt128.from_native(c_value[:debits_posted].to_ptr),
+          credits_pending: Converters::UInt128.from_native(c_value[:credits_pending].to_ptr),
+          credits_posted: Converters::UInt128.from_native(c_value[:credits_posted].to_ptr),
+          timestamp: Converters::Time.from_native(ptr + c_value.offset_of(:timestamp))
+        )
+      end
+
+      def to_native(ptr, value)
+        raise 'Unexpected conversion of AccountBalance to native type'
+      end
+    end
+  end
+end