tigerbeetle-node 0.4.2 → 0.5.2

package/src/tigerbeetle/src/state_machine.zig

@@ -2,7 +2,25 @@ const std = @import("std");
 const assert = std.debug.assert;
 const log = std.log.scoped(.state_machine);
 
-usingnamespace @import("tigerbeetle.zig");
+const tb = @import("tigerbeetle.zig");
+
+const Account = tb.Account;
+const AccountFlags = tb.AccountFlags;
+
+const Transfer = tb.Transfer;
+const TransferFlags = tb.TransferFlags;
+
+const Commit = tb.Commit;
+const CommitFlags = tb.CommitFlags;
+
+const CreateAccountsResult = tb.CreateAccountsResult;
+const CreateTransfersResult = tb.CreateTransfersResult;
+const CommitTransfersResult = tb.CommitTransfersResult;
+
+const CreateAccountResult = tb.CreateAccountResult;
+const CreateTransferResult = tb.CreateTransferResult;
+const CommitTransferResult = tb.CommitTransferResult;
+const LookupAccountResult = tb.LookupAccountResult;
 
 const HashMapAccounts = std.AutoHashMap(u128, Account);
 const HashMapTransfers = std.AutoHashMap(u128, Transfer);
@@ -20,13 +38,10 @@ pub const StateMachine = struct {
         create_transfers,
         commit_transfers,
         lookup_accounts,
-
-        pub fn jsonStringify(self: Command, options: StringifyOptions, writer: anytype) !void {
-            try std.fmt.format(writer, "\"{}\"", .{@tagName(self)});
-        }
+        lookup_transfers,
     };
 
-    allocator: *std.mem.Allocator,
+    allocator: std.mem.Allocator,
     prepare_timestamp: u64,
     commit_timestamp: u64,
     accounts: HashMapAccounts,
@@ -34,22 +49,22 @@ pub const StateMachine = struct {
     commits: HashMapCommits,
 
     pub fn init(
-        allocator: *std.mem.Allocator,
+        allocator: std.mem.Allocator,
         accounts_max: usize,
         transfers_max: usize,
         commits_max: usize,
     ) !StateMachine {
         var accounts = HashMapAccounts.init(allocator);
         errdefer accounts.deinit();
-        try accounts.ensureCapacity(@intCast(u32, accounts_max));
+        try accounts.ensureTotalCapacity(@intCast(u32, accounts_max));
 
         var transfers = HashMapTransfers.init(allocator);
         errdefer transfers.deinit();
-        try transfers.ensureCapacity(@intCast(u32, transfers_max));
+        try transfers.ensureTotalCapacity(@intCast(u32, transfers_max));
 
         var commits = HashMapCommits.init(allocator);
         errdefer commits.deinit();
-        try commits.ensureCapacity(@intCast(u32, commits_max));
+        try commits.ensureTotalCapacity(@intCast(u32, commits_max));
 
         // TODO After recovery, set prepare_timestamp max(wall clock, op timestamp).
         // TODO After recovery, set commit_timestamp max(wall clock, commit timestamp).
@@ -76,6 +91,7 @@ pub const StateMachine = struct {
             .create_transfers => Transfer,
             .commit_transfers => Commit,
             .lookup_accounts => u128,
+            .lookup_transfers => u128,
             else => unreachable,
         };
     }
@@ -86,6 +102,7 @@ pub const StateMachine = struct {
             .create_transfers => CreateTransfersResult,
             .commit_transfers => CommitTransfersResult,
             .lookup_accounts => Account,
+            .lookup_transfers => Transfer,
             else => unreachable,
         };
     }
@@ -98,6 +115,7 @@ pub const StateMachine = struct {
             .create_transfers => self.prepare_timestamps(realtime, .create_transfers, input),
             .commit_transfers => self.prepare_timestamps(realtime, .commit_transfers, input),
             .lookup_accounts => {},
+            .lookup_transfers => {},
             else => unreachable,
         }
     }
@@ -136,6 +154,8 @@ pub const StateMachine = struct {
         input: []const u8,
         output: []u8,
     ) usize {
+        _ = client;
+
         return switch (operation) {
             .init => unreachable,
             .register => 0,
@@ -143,6 +163,7 @@ pub const StateMachine = struct {
             .create_transfers => self.execute(.create_transfers, input, output),
             .commit_transfers => self.execute(.commit_transfers, input, output),
             .lookup_accounts => self.execute_lookup_accounts(input, output),
+            .lookup_transfers => self.execute_lookup_transfers(input, output),
             else => unreachable,
         };
     }
@@ -153,7 +174,7 @@ pub const StateMachine = struct {
         input: []const u8,
         output: []u8,
     ) usize {
-        comptime assert(operation != .lookup_accounts);
+        comptime assert(operation != .lookup_accounts and operation != .lookup_transfers);
 
         const events = std.mem.bytesAsSlice(Event(operation), input);
         var results = std.mem.bytesAsSlice(Result(operation), output);
@@ -255,10 +276,10 @@ pub const StateMachine = struct {
 
     fn execute_lookup_accounts(self: *StateMachine, input: []const u8, output: []u8) usize {
         const batch = std.mem.bytesAsSlice(u128, input);
-        var output_len = @divFloor(output.len, @sizeOf(Account)) * @sizeOf(Account);
-        var results = std.mem.bytesAsSlice(Account, output[0..output_len]);
+        const output_len = @divFloor(output.len, @sizeOf(Account)) * @sizeOf(Account);
+        const results = std.mem.bytesAsSlice(Account, output[0..output_len]);
         var results_count: usize = 0;
-        for (batch) |id, index| {
+        for (batch) |id| {
             if (self.get_account(id)) |result| {
                 results[results_count] = result.*;
                 results_count += 1;
@@ -267,6 +288,20 @@ pub const StateMachine = struct {
         return results_count * @sizeOf(Account);
     }
 
+    fn execute_lookup_transfers(self: *StateMachine, input: []const u8, output: []u8) usize {
+        const batch = std.mem.bytesAsSlice(u128, input);
+        const output_len = @divFloor(output.len, @sizeOf(Transfer)) * @sizeOf(Transfer);
+        const results = std.mem.bytesAsSlice(Transfer, output[0..output_len]);
+        var results_count: usize = 0;
+        for (batch) |id| {
+            if (self.get_transfer(id)) |result| {
+                results[results_count] = result.*;
+                results_count += 1;
+            }
+        }
+        return results_count * @sizeOf(Transfer);
+    }
+
     fn create_account(self: *StateMachine, a: Account) CreateAccountResult {
         assert(a.timestamp > self.commit_timestamp);
 
@@ -339,8 +374,7 @@ pub const StateMachine = struct {
             const exists = insert.value_ptr.*;
             if (exists.debit_account_id != t.debit_account_id) {
                 return .exists_with_different_debit_account_id;
-            }
-            if (exists.credit_account_id != t.credit_account_id) {
+            } else if (exists.credit_account_id != t.credit_account_id) {
                 return .exists_with_different_credit_account_id;
             }
             if (exists.amount != t.amount) return .exists_with_different_amount;
@@ -437,6 +471,7 @@ pub const StateMachine = struct {
     }
 
     fn commit_transfer_rollback(self: *StateMachine, c: Commit) void {
+        assert(self.get_commit(c.id) != null);
         var t = self.get_transfer(c.id).?;
         var dr = self.get_account(t.debit_account_id).?;
         var cr = self.get_account(t.credit_account_id).?;
@@ -516,30 +551,188 @@ fn equal_48_bytes(a: [48]u8, b: [48]u8) bool {
 
 const testing = std.testing;
 
+test "create/lookup accounts" {
+    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena.deinit();
+
+    const allocator = arena.allocator();
+
+    const Vector = struct { result: CreateAccountResult, object: Account };
+
+    const vectors = [_]Vector{
+        Vector{
+            .result = .reserved_flag_padding,
+            .object = std.mem.zeroInit(Account, .{
+                .id = 1,
+                .timestamp = 1,
+                .flags = .{ .padding = 1 },
+            }),
+        },
+        Vector{
+            .result = .reserved_field,
+            .object = std.mem.zeroInit(Account, .{
+                .id = 2,
+                .timestamp = 1,
+                .reserved = [_]u8{1} ** 48,
+            }),
+        },
+        Vector{
+            .result = .exceeds_credits,
+            .object = std.mem.zeroInit(Account, .{
+                .id = 3,
+                .timestamp = 1,
+                .debits_reserved = 10,
+                .flags = .{ .debits_must_not_exceed_credits = true },
+            }),
+        },
+        Vector{
+            .result = .exceeds_credits,
+            .object = std.mem.zeroInit(Account, .{
+                .id = 4,
+                .timestamp = 1,
+                .debits_accepted = 10,
+                .flags = .{ .debits_must_not_exceed_credits = true },
+            }),
+        },
+        Vector{
+            .result = .exceeds_debits,
+            .object = std.mem.zeroInit(Account, .{
+                .id = 5,
+                .timestamp = 1,
+                .credits_reserved = 10,
+                .flags = .{ .credits_must_not_exceed_debits = true },
+            }),
+        },
+        Vector{
+            .result = .exceeds_debits,
+            .object = std.mem.zeroInit(Account, .{
+                .id = 6,
+                .timestamp = 1,
+                .credits_accepted = 10,
+                .flags = .{ .credits_must_not_exceed_debits = true },
+            }),
+        },
+        Vector{
+            .result = .ok,
+            .object = std.mem.zeroInit(Account, .{
+                .id = 7,
+                .timestamp = 1,
+            }),
+        },
+        Vector{
+            .result = .exists,
+            .object = std.mem.zeroInit(Account, .{
+                .id = 7,
+                .timestamp = 2,
+            }),
+        },
+        Vector{
+            .result = .ok,
+            .object = std.mem.zeroInit(Account, .{
+                .id = 8,
+                .timestamp = 2,
+                .user_data = 'U',
+                .unit = 9,
+            }),
+        },
+        Vector{
+            .result = .exists_with_different_unit,
+            .object = std.mem.zeroInit(Account, .{
+                .id = 8,
+                .timestamp = 3,
+                .user_data = 'U',
+                .unit = 10,
+            }),
+        },
+        Vector{
+            .result = .ok,
+            .object = std.mem.zeroInit(Account, .{
+                .id = 9,
+                .timestamp = 3,
+                .code = 9,
+                .user_data = 'U',
+            }),
+        },
+        Vector{
+            .result = .exists_with_different_code,
+            .object = std.mem.zeroInit(Account, .{
+                .id = 9,
+                .timestamp = 4,
+                .code = 10,
+                .user_data = 'D',
+            }),
+        },
+        Vector{
+            .result = .ok,
+            .object = std.mem.zeroInit(Account, .{
+                .id = 10,
+                .timestamp = 4,
+                .flags = .{ .credits_must_not_exceed_debits = true },
+            }),
+        },
+        Vector{
+            .result = .exists_with_different_flags,
+            .object = std.mem.zeroInit(Account, .{
+                .id = 10,
+                .timestamp = 5,
+                .flags = .{ .debits_must_not_exceed_credits = true },
+            }),
+        },
+        Vector{
+            .result = .ok,
+            .object = std.mem.zeroInit(Account, .{
+                .id = 11,
+                .timestamp = 5,
+                .user_data = 'U',
+            }),
+        },
+        Vector{
+            .result = .exists_with_different_user_data,
+            .object = std.mem.zeroInit(Account, .{
+                .id = 11,
+                .timestamp = 6,
+                .user_data = 'D',
+            }),
+        },
+    };
+
+    var state_machine = try StateMachine.init(allocator, vectors.len, 0, 0);
+    defer state_machine.deinit();
+
+    for (vectors) |vector| {
+        try testing.expectEqual(vector.result, state_machine.create_account(vector.object));
+        if (vector.result == .ok) {
+            try testing.expectEqual(vector.object, state_machine.get_account(vector.object.id).?.*);
+        }
+    }
+}
+
 test "linked accounts" {
     var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
     defer arena.deinit();
-    const allocator = &arena.allocator;
+
+    const allocator = arena.allocator();
 
     const accounts_max = 5;
     const transfers_max = 0;
     const commits_max = 0;
 
-    var state_machine = try StateMachine.init(allocator, accounts_max, transfers_max, commits_max);
-    defer state_machine.deinit();
-
     var accounts = [_]Account{
         // An individual event (successful):
         std.mem.zeroInit(Account, .{ .id = 7, .code = 200 }),
 
         // A chain of 4 events (the last event in the chain closes the chain with linked=false):
-        std.mem.zeroInit(Account, .{ .id = 0, .flags = .{ .linked = true } }), // Commit/rollback.
-        std.mem.zeroInit(Account, .{ .id = 1, .flags = .{ .linked = true } }), // Commit/rollback.
-        std.mem.zeroInit(Account, .{ .id = 0, .flags = .{ .linked = true } }), // Fail with .exists.
-        std.mem.zeroInit(Account, .{ .id = 2 }), // Fail without committing.
+        // Commit/rollback:
+        std.mem.zeroInit(Account, .{ .id = 0, .flags = .{ .linked = true } }),
+        // Commit/rollback:
+        std.mem.zeroInit(Account, .{ .id = 1, .flags = .{ .linked = true } }),
+        // Fail with .exists:
+        std.mem.zeroInit(Account, .{ .id = 0, .flags = .{ .linked = true } }),
+        // Fail without committing.
+        std.mem.zeroInit(Account, .{ .id = 2 }),
 
         // An individual event (successful):
-        // This should not see any effect from the failed chain above.
+        // This should not see any effect from the failed chain above:
         std.mem.zeroInit(Account, .{ .id = 0, .code = 200 }),
 
         // A chain of 2 events (the first event fails the chain):
@@ -558,10 +751,12 @@ test "linked accounts" {
         std.mem.zeroInit(Account, .{ .id = 3 }),
     };
 
+    var state_machine = try StateMachine.init(allocator, accounts_max, transfers_max, commits_max);
+    defer state_machine.deinit();
+
     const input = std.mem.asBytes(&accounts);
     const output = try allocator.alloc(u8, 4096);
 
-    // Use a timestamp of 0 since this is just a test
     state_machine.prepare(0, .create_accounts, input);
     const size = state_machine.commit(0, .create_accounts, input, output);
     const results = std.mem.bytesAsSlice(CreateAccountsResult, output[0..size]);
@@ -594,6 +789,636 @@ test "linked accounts" {
     // All our rollback handlers appear to be commutative.
 }
 
+test "create/lookup/rollback transfers" {
+    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena.deinit();
+
+    const allocator = arena.allocator();
+
+    var accounts = [_]Account{
+        std.mem.zeroInit(Account, .{ .id = 1 }),
+        std.mem.zeroInit(Account, .{ .id = 2 }),
+        std.mem.zeroInit(Account, .{ .id = 3, .unit = 1 }),
+        std.mem.zeroInit(Account, .{ .id = 4, .unit = 2 }),
+        std.mem.zeroInit(Account, .{ .id = 5, .flags = .{ .debits_must_not_exceed_credits = true } }),
+        std.mem.zeroInit(Account, .{ .id = 6, .flags = .{ .credits_must_not_exceed_debits = true } }),
+        std.mem.zeroInit(Account, .{ .id = 7 }),
+        std.mem.zeroInit(Account, .{ .id = 8 }),
+    };
+
+    var state_machine = try StateMachine.init(allocator, accounts.len, 1, 0);
+    defer state_machine.deinit();
+
+    const input = std.mem.asBytes(&accounts);
+    const output = try allocator.alloc(u8, 4096);
+
+    state_machine.prepare(0, .create_accounts, input);
+    const size = state_machine.commit(0, .create_accounts, input, output);
+
+    const errors = std.mem.bytesAsSlice(CreateAccountsResult, output[0..size]);
+    try testing.expectEqual(@as(usize, 0), errors.len);
+
+    for (accounts) |account| {
+        try testing.expectEqual(account, state_machine.get_account(account.id).?.*);
+    }
+
+    const Vector = struct { result: CreateTransferResult, object: Transfer };
+
+    const timestamp: u64 = (state_machine.commit_timestamp + 1);
+    const vectors = [_]Vector{
+        Vector{
+            .result = .amount_is_zero,
+            .object = std.mem.zeroInit(Transfer, .{
+                .id = 1,
+                .timestamp = timestamp,
+            }),
+        },
+        Vector{
+            .result = .reserved_flag_padding,
+            .object = std.mem.zeroInit(Transfer, .{
+                .id = 2,
+                .timestamp = timestamp,
+                .flags = .{ .padding = 1 },
+            }),
+        },
+        Vector{
+            .result = .two_phase_commit_must_timeout,
+            .object = std.mem.zeroInit(Transfer, .{
+                .id = 3,
+                .timestamp = timestamp,
+                .flags = .{ .two_phase_commit = true },
+            }),
+        },
+        Vector{
+            .result = .timeout_reserved_for_two_phase_commit,
+            .object = std.mem.zeroInit(Transfer, .{
+                .id = 4,
+                .timestamp = timestamp,
+                .timeout = 1,
+            }),
+        },
+        Vector{
+            .result = .reserved_field,
+            .object = std.mem.zeroInit(Transfer, .{
+                .id = 5,
+                .timestamp = timestamp,
+                .flags = .{ .condition = false },
+                .reserved = [_]u8{1} ** 32,
+            }),
+        },
+        Vector{
+            .result = .accounts_are_the_same,
+            .object = std.mem.zeroInit(Transfer, .{
+                .id = 6,
+                .timestamp = timestamp,
+                .amount = 10,
+                .debit_account_id = 1,
+                .credit_account_id = 1,
+            }),
+        },
+        Vector{
+            .result = .debit_account_not_found,
+            .object = std.mem.zeroInit(Transfer, .{
+                .id = 7,
+                .timestamp = timestamp,
+                .amount = 10,
+                .debit_account_id = 100,
+                .credit_account_id = 1,
+            }),
+        },
+        Vector{
+            .result = .credit_account_not_found,
+            .object = std.mem.zeroInit(Transfer, .{
+                .id = 8,
+                .timestamp = timestamp,
+                .amount = 10,
+                .debit_account_id = 1,
+                .credit_account_id = 100,
+            }),
+        },
+        Vector{
+            .result = .accounts_have_different_units,
+            .object = std.mem.zeroInit(Transfer, .{
+                .id = 9,
+                .timestamp = timestamp,
+                .amount = 10,
+                .debit_account_id = 3,
+                .credit_account_id = 4,
+            }),
+        },
+        Vector{
+            .result = .exceeds_credits,
+            .object = std.mem.zeroInit(Transfer, .{
+                .id = 10,
+                .timestamp = timestamp,
+                .amount = 1000,
+                .debit_account_id = 5,
+                .credit_account_id = 1,
+            }),
+        },
+        Vector{
+            .result = .exceeds_debits,
+            .object = std.mem.zeroInit(Transfer, .{
+                .id = 11,
+                .timestamp = timestamp,
+                .amount = 1000,
+                .debit_account_id = 1,
+                .credit_account_id = 6,
+            }),
+        },
+        Vector{
+            .result = .ok,
+            .object = std.mem.zeroInit(Transfer, .{
+                .id = 12,
+                .timestamp = timestamp,
+                .amount = 10,
+                .debit_account_id = 7,
+                .credit_account_id = 8,
+            }),
+        },
+        Vector{
+            .result = .exists,
+            .object = std.mem.zeroInit(Transfer, .{
+                .id = 12,
+                .timestamp = timestamp + 1,
+                .amount = 10,
+                .debit_account_id = 7,
+                .credit_account_id = 8,
+            }),
+        },
+        Vector{
+            .result = .exists_with_different_debit_account_id,
+            .object = std.mem.zeroInit(Transfer, .{
+                .id = 12,
+                .timestamp = timestamp + 1,
+                .amount = 10,
+                .debit_account_id = 8,
+                .credit_account_id = 7,
+            }),
+        },
+        Vector{
+            .result = .exists_with_different_credit_account_id,
+            .object = std.mem.zeroInit(Transfer, .{
+                .id = 12,
+                .timestamp = timestamp + 1,
+                .amount = 10,
+                .debit_account_id = 7,
+                .credit_account_id = 1,
+            }),
+        },
+        Vector{
+            .result = .exists_with_different_amount,
+            .object = std.mem.zeroInit(Transfer, .{
+                .id = 12,
+                .timestamp = timestamp + 1,
+                .amount = 11,
+                .debit_account_id = 7,
+                .credit_account_id = 8,
+            }),
+        },
+        Vector{
+            .result = .exists_with_different_flags,
+            .object = std.mem.zeroInit(Transfer, .{
+                .id = 12,
+                .timestamp = timestamp + 1,
+                .amount = 10,
+                .debit_account_id = 7,
+                .credit_account_id = 8,
+                .flags = .{ .condition = true },
+            }),
+        },
+        Vector{
+            .result = .exists_with_different_user_data,
+            .object = std.mem.zeroInit(Transfer, .{
+                .id = 12,
+                .timestamp = timestamp + 1,
+                .amount = 10,
+                .debit_account_id = 7,
+                .credit_account_id = 8,
+                .user_data = 'A',
+            }),
+        },
+        Vector{
+            .result = .ok,
+            .object = std.mem.zeroInit(Transfer, .{
+                .id = 13,
+                .timestamp = timestamp + 1,
+                .amount = 10,
+                .debit_account_id = 7,
+                .credit_account_id = 8,
+                .flags = .{ .condition = true },
+                .reserved = [_]u8{1} ** 32,
+            }),
+        },
+        Vector{
+            .result = .exists_with_different_reserved_field,
+            .object = std.mem.zeroInit(Transfer, .{
+                .id = 13,
+                .timestamp = timestamp + 2,
+                .amount = 10,
+                .debit_account_id = 7,
+                .credit_account_id = 8,
+                .flags = .{ .condition = true },
+                .reserved = [_]u8{2} ** 32,
+            }),
+        },
+        Vector{
+            .result = .timeout_reserved_for_two_phase_commit,
+            .object = std.mem.zeroInit(Transfer, .{
+                .id = 13,
+                .timestamp = timestamp + 2,
+                .amount = 10,
+                .debit_account_id = 7,
+                .credit_account_id = 8,
+                .flags = .{ .condition = true },
+                .reserved = [_]u8{1} ** 32,
+                .timeout = 10,
+            }),
+        },
+        Vector{
+            .result = .two_phase_commit_must_timeout,
+            .object = std.mem.zeroInit(Transfer, .{
+                .id = 14,
+                .timestamp = timestamp + 2,
+                .amount = 10,
+                .debit_account_id = 7,
+                .credit_account_id = 8,
+                .flags = .{ .two_phase_commit = true },
+                .timeout = 0,
+            }),
+        },
+        Vector{
+            .result = .ok,
+            .object = std.mem.zeroInit(Transfer, .{
+                .id = 15,
+                .timestamp = timestamp + 2,
+                .amount = 10,
+                .debit_account_id = 7,
+                .credit_account_id = 8,
+                .flags = .{ .two_phase_commit = true },
+                .timeout = 20,
+            }),
+        },
+        Vector{
+            .result = .exists_with_different_timeout,
+            .object = std.mem.zeroInit(Transfer, .{
+                .id = 15,
+                .timestamp = timestamp + 3,
+                .amount = 10,
+                .debit_account_id = 7,
+                .credit_account_id = 8,
+                .flags = .{ .two_phase_commit = true },
+                .timeout = 25,
+            }),
+        },
+    };
+
+    for (vectors) |vector| {
+        try testing.expectEqual(vector.result, state_machine.create_transfer(vector.object));
+        if (vector.result == .ok) {
+            try testing.expectEqual(vector.object, state_machine.get_transfer(vector.object.id).?.*);
+        }
+    }
+
+    // 2 phase commit [reserved]:
+    try testing.expectEqual(@as(u64, 10), state_machine.get_account(7).?.*.debits_reserved);
+    try testing.expectEqual(@as(u64, 0), state_machine.get_account(7).?.*.credits_reserved);
+    try testing.expectEqual(@as(u64, 10), state_machine.get_account(8).?.*.credits_reserved);
+    try testing.expectEqual(@as(u64, 0), state_machine.get_account(8).?.*.debits_reserved);
+    // 1 phase commit [accepted]:
+    try testing.expectEqual(@as(u64, 20), state_machine.get_account(7).?.*.debits_accepted);
+    try testing.expectEqual(@as(u64, 0), state_machine.get_account(7).?.*.credits_accepted);
+    try testing.expectEqual(@as(u64, 20), state_machine.get_account(8).?.*.credits_accepted);
+    try testing.expectEqual(@as(u64, 0), state_machine.get_account(8).?.*.debits_accepted);
+
+    // Rollback transfer with id [12], amount of 10:
+    state_machine.create_transfer_rollback(state_machine.get_transfer(vectors[11].object.id).?.*);
+    try testing.expectEqual(@as(u64, 10), state_machine.get_account(7).?.*.debits_accepted);
+    try testing.expectEqual(@as(u64, 0), state_machine.get_account(7).?.*.credits_accepted);
+    try testing.expectEqual(@as(u64, 10), state_machine.get_account(8).?.*.credits_accepted);
+    try testing.expectEqual(@as(u64, 0), state_machine.get_account(8).?.*.debits_accepted);
+    try testing.expect(state_machine.get_transfer(vectors[11].object.id) == null);
+
+    // Rollback transfer with id [15], amount of 10:
+    state_machine.create_transfer_rollback(state_machine.get_transfer(vectors[22].object.id).?.*);
+    try testing.expectEqual(@as(u64, 0), state_machine.get_account(7).?.*.debits_reserved);
+    try testing.expectEqual(@as(u64, 0), state_machine.get_account(8).?.*.credits_reserved);
+    try testing.expect(state_machine.get_transfer(vectors[22].object.id) == null);
+}
+
+test "create/lookup/rollback commits" {
+    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena.deinit();
+
+    const allocator = arena.allocator();
+
+    const Vector = struct { result: CommitTransferResult, object: Commit };
+
+    var accounts = [_]Account{
+        std.mem.zeroInit(Account, .{ .id = 1 }),
+        std.mem.zeroInit(Account, .{ .id = 2 }),
+        std.mem.zeroInit(Account, .{ .id = 3 }),
+        std.mem.zeroInit(Account, .{ .id = 4 }),
+    };
+
+    var transfers = [_]Transfer{
+        std.mem.zeroInit(Transfer, .{
+            .id = 1,
+            .amount = 15,
+            .debit_account_id = 1,
+            .credit_account_id = 2,
+        }),
+        std.mem.zeroInit(Transfer, .{
+            .id = 2,
+            .amount = 15,
+            .debit_account_id = 1,
+            .credit_account_id = 2,
+            .flags = .{ .two_phase_commit = true },
+            .timeout = 25,
+        }),
+        std.mem.zeroInit(Transfer, .{
+            .id = 3,
+            .amount = 15,
+            .debit_account_id = 1,
+            .credit_account_id = 2,
+            .flags = .{ .two_phase_commit = true },
+            .timeout = 25,
+        }),
+        std.mem.zeroInit(Transfer, .{
+            .id = 4,
+            .amount = 15,
+            .debit_account_id = 1,
+            .credit_account_id = 2,
+            .flags = .{ .two_phase_commit = true },
+            .timeout = 1,
+        }),
+        std.mem.zeroInit(Transfer, .{
+            .id = 5,
+            .amount = 15,
+            .debit_account_id = 1,
+            .credit_account_id = 2,
+            .flags = .{
+                .two_phase_commit = true,
+                .condition = true,
+            },
+            .timeout = 25,
+        }),
+        std.mem.zeroInit(Transfer, .{
+            .id = 6,
+            .amount = 15,
+            .debit_account_id = 1,
+            .credit_account_id = 2,
+            .flags = .{
+                .two_phase_commit = true,
+                .condition = false,
+            },
+            .timeout = 25,
+        }),
+        std.mem.zeroInit(Transfer, .{
+            .id = 7,
+            .amount = 15,
+            .debit_account_id = 3,
+            .credit_account_id = 4,
+            .flags = .{ .two_phase_commit = true },
+            .timeout = 25,
+        }),
+    };
+
+    var state_machine = try StateMachine.init(allocator, accounts.len, transfers.len, 1);
+    defer state_machine.deinit();
+
+    const input = std.mem.asBytes(&accounts);
+    const output = try allocator.alloc(u8, 4096);
+
+    // Accounts:
+    state_machine.prepare(0, .create_accounts, input);
+    const size = state_machine.commit(0, .create_accounts, input, output);
+    {
+        const errors = std.mem.bytesAsSlice(CreateAccountsResult, output[0..size]);
+        try testing.expectEqual(@as(usize, 0), errors.len);
+    }
+
+    for (accounts) |account| {
+        try testing.expectEqual(account, state_machine.get_account(account.id).?.*);
+    }
+
+    // Transfers:
+    const object_transfers = std.mem.asBytes(&transfers);
+    const output_transfers = try allocator.alloc(u8, 4096);
+
+    state_machine.prepare(0, .create_transfers, object_transfers);
+    const size_transfers = state_machine.commit(
+        0,
+        .create_transfers,
+        object_transfers,
+        output_transfers,
+    );
+    const errors = std.mem.bytesAsSlice(CreateTransfersResult, output_transfers[0..size_transfers]);
+    try testing.expectEqual(@as(usize, 0), errors.len);
+
+    for (transfers) |transfer| {
+        try testing.expectEqual(transfer, state_machine.get_transfer(transfer.id).?.*);
+    }
+
+    // Commits:
+    const timestamp: u64 = (state_machine.commit_timestamp + 1);
+    const vectors = [_]Vector{
+        Vector{
+            .result = .reserved_field,
+            .object = std.mem.zeroInit(Commit, .{
+                .id = 1,
+                .timestamp = timestamp,
+                .reserved = [_]u8{1} ** 32,
+            }),
+        },
+        Vector{
+            .result = .reserved_flag_padding,
+            .object = std.mem.zeroInit(Commit, .{
+                .id = 1,
+                .timestamp = timestamp,
+                .flags = .{ .padding = 1 },
+            }),
+        },
+        Vector{
+            .result = .transfer_not_found,
+            .object = std.mem.zeroInit(Commit, .{
+                .id = 777,
+                .timestamp = timestamp,
+            }),
+        },
+        Vector{
+            .result = .transfer_not_two_phase_commit,
+            .object = std.mem.zeroInit(Commit, .{
+                .id = 1,
+                .timestamp = timestamp,
+            }),
+        },
+        Vector{
+            .result = .ok,
+            .object = std.mem.zeroInit(Commit, .{
+                .id = 2,
+                .timestamp = timestamp,
+            }),
+        },
+        Vector{
+            .result = .already_committed_but_accepted,
+            .object = std.mem.zeroInit(Commit, .{
+                .id = 2,
+                .timestamp = timestamp + 1,
+                .flags = .{ .reject = true },
+            }),
+        },
+        Vector{
+            .result = .already_committed,
+            .object = std.mem.zeroInit(Commit, .{
+                .id = 2,
+                .timestamp = timestamp + 1,
+            }),
+        },
+        Vector{
+            .result = .ok,
+            .object = std.mem.zeroInit(Commit, .{
+                .id = 3,
+                .timestamp = timestamp + 1,
+                .flags = .{ .reject = true },
+            }),
+        },
+        Vector{
+            .result = .already_committed_but_rejected,
+            .object = std.mem.zeroInit(Commit, .{
+                .id = 3,
+                .timestamp = timestamp + 2,
+            }),
+        },
+        Vector{
+            .result = .transfer_expired,
+            .object = std.mem.zeroInit(Commit, .{
+                .id = 4,
+                .timestamp = timestamp + 2,
+            }),
+        },
+        Vector{
+            .result = .condition_requires_preimage,
+            .object = std.mem.zeroInit(Commit, .{
+                .id = 5,
+                .timestamp = timestamp + 2,
+            }),
+        },
+        Vector{
+            .result = .preimage_invalid,
+            .object = std.mem.zeroInit(Commit, .{
+                .id = 5,
+                .timestamp = timestamp + 2,
+                .flags = .{ .preimage = true },
+                .reserved = [_]u8{1} ** 32,
+            }),
+        },
+        Vector{
+            .result = .preimage_requires_condition,
+            .object = std.mem.zeroInit(Commit, .{
+                .id = 6,
+                .timestamp = timestamp + 2,
+                .flags = .{ .preimage = true },
+            }),
+        },
+    };
+
+    // Test balances BEFORE commit
+    // Account 1:
+    const account_1_before = state_machine.get_account(1).?.*;
+    try testing.expectEqual(@as(u64, 15), account_1_before.debits_accepted);
+    try testing.expectEqual(@as(u64, 75), account_1_before.debits_reserved);
+    try testing.expectEqual(@as(u64, 0), account_1_before.credits_accepted);
+    try testing.expectEqual(@as(u64, 0), account_1_before.credits_reserved);
+    // Account 2:
+    const account_2_before = state_machine.get_account(2).?.*;
+    try testing.expectEqual(@as(u64, 0), account_2_before.debits_accepted);
+    try testing.expectEqual(@as(u64, 0), account_2_before.debits_reserved);
+    try testing.expectEqual(@as(u64, 15), account_2_before.credits_accepted);
+    try testing.expectEqual(@as(u64, 75), account_2_before.credits_reserved);
+
+    for (vectors) |vector| {
+        try testing.expectEqual(vector.result, state_machine.commit_transfer(vector.object));
+        if (vector.result == .ok) {
+            try testing.expectEqual(vector.object, state_machine.get_commit(vector.object.id).?.*);
+        }
+    }
+
+    // Test balances AFTER commit
+    // Account 1:
+    const account_1_after = state_machine.get_account(1).?.*;
+    try testing.expectEqual(@as(u64, 30), account_1_after.debits_accepted);
+    // +15 (acceptance applied):
+    try testing.expectEqual(@as(u64, 45), account_1_after.debits_reserved);
+    // -15 (reserved moved):
+    try testing.expectEqual(@as(u64, 0), account_1_after.credits_accepted);
+    try testing.expectEqual(@as(u64, 0), account_1_after.credits_reserved);
+    // Account 2:
+    const account_2_after = state_machine.get_account(2).?.*;
+    try testing.expectEqual(@as(u64, 0), account_2_after.debits_accepted);
+    try testing.expectEqual(@as(u64, 0), account_2_after.debits_reserved);
+    // +15 (acceptance applied):
+    try testing.expectEqual(@as(u64, 30), account_2_after.credits_accepted);
+    // -15 (reserved moved):
+    try testing.expectEqual(@as(u64, 45), account_2_after.credits_reserved);
+
+    // Test COMMIT with invalid debit/credit accounts
+    state_machine.create_account_rollback(accounts[3]);
+    try testing.expect(state_machine.get_account(accounts[3].id) == null);
+    try testing.expectEqual(
+        state_machine.commit_transfer(std.mem.zeroInit(Commit, .{
+            .id = 7,
+            .timestamp = timestamp + 2,
+        })),
+        .credit_account_not_found,
+    );
+    state_machine.create_account_rollback(accounts[2]);
+    try testing.expect(state_machine.get_account(accounts[2].id) == null);
+    try testing.expectEqual(
+        state_machine.commit_transfer(std.mem.zeroInit(Commit, .{
+            .id = 7,
+            .timestamp = timestamp + 2,
+        })),
+        .debit_account_not_found,
+    );
+
+    // Rollback [id=2] not rejected:
+    state_machine.commit_transfer_rollback(vectors[4].object);
+
+    // Account 1:
+    const account_1_rollback = state_machine.get_account(1).?.*;
+    // -15 (rollback):
+    try testing.expectEqual(@as(u64, 15), account_1_rollback.debits_accepted);
+    try testing.expectEqual(@as(u64, 60), account_1_rollback.debits_reserved);
+    try testing.expectEqual(@as(u64, 0), account_1_rollback.credits_accepted);
+    try testing.expectEqual(@as(u64, 0), account_1_rollback.credits_reserved);
+    // Account 2:
+    const account_2_rollback = state_machine.get_account(2).?.*;
+    try testing.expectEqual(@as(u64, 0), account_2_rollback.debits_accepted);
+    try testing.expectEqual(@as(u64, 0), account_2_rollback.debits_reserved);
+    // -15 (rollback):
+    try testing.expectEqual(@as(u64, 15), account_2_rollback.credits_accepted);
+    try testing.expectEqual(@as(u64, 60), account_2_rollback.credits_reserved);
+
+    // Rollback [id=3] rejected:
+    state_machine.commit_transfer_rollback(vectors[7].object);
+    // Account 1:
+    const account_1_rollback_reject = state_machine.get_account(1).?.*;
+    try testing.expectEqual(@as(u64, 15), account_1_rollback_reject.debits_accepted);
+    // Remains unchanged:
+    try testing.expectEqual(@as(u64, 75), account_1_rollback_reject.debits_reserved);
+    // +15 rolled back:
+    try testing.expectEqual(@as(u64, 0), account_1_rollback_reject.credits_accepted);
+    try testing.expectEqual(@as(u64, 0), account_1_rollback_reject.credits_reserved);
+    // Account 2:
+    const account_2_rollback_reject = state_machine.get_account(2).?.*;
+    try testing.expectEqual(@as(u64, 0), account_2_rollback_reject.debits_accepted);
+    try testing.expectEqual(@as(u64, 0), account_2_rollback_reject.debits_reserved);
+    try testing.expectEqual(@as(u64, 15), account_2_rollback_reject.credits_accepted);
+    // +15 rolled back"
+    try testing.expectEqual(@as(u64, 75), account_2_rollback_reject.credits_reserved);
+}
+
 fn test_routine_zeroed(comptime len: usize) !void {
     const routine = switch (len) {
         32 => zeroed_32_bytes,