tigerbeetle-node 0.3.3 → 0.5.0

package/src/tigerbeetle/src/state_machine.zig

@@ -8,22 +8,25 @@ const HashMapAccounts = std.AutoHashMap(u128, Account);
 const HashMapTransfers = std.AutoHashMap(u128, Transfer);
 const HashMapCommits = std.AutoHashMap(u128, Commit);
 
-pub const Operation = packed enum(u8) {
-    // We reserve command "0" to detect an accidental zero byte being interpreted as an operation:
-    reserved,
-    init,
-
-    create_accounts,
-    create_transfers,
-    commit_transfers,
-    lookup_accounts,
-
-    pub fn jsonStringify(self: Command, options: StringifyOptions, writer: anytype) !void {
-        try std.fmt.format(writer, "\"{}\"", .{@tagName(self)});
-    }
-};
-
 pub const StateMachine = struct {
+    pub const Operation = enum(u8) {
+        /// Operations reserved by VR protocol (for all state machines):
+        reserved,
+        init,
+        register,
+
+        /// Operations exported by TigerBeetle:
+        create_accounts,
+        create_transfers,
+        commit_transfers,
+        lookup_accounts,
+        lookup_transfers,
+
+        pub fn jsonStringify(self: Command, options: StringifyOptions, writer: anytype) !void {
+            try std.fmt.format(writer, "\"{}\"", .{@tagName(self)});
+        }
+    };
+
     allocator: *std.mem.Allocator,
     prepare_timestamp: u64,
     commit_timestamp: u64,
@@ -74,6 +77,7 @@ pub const StateMachine = struct {
             .create_transfers => Transfer,
             .commit_transfers => Commit,
             .lookup_accounts => u128,
+            .lookup_transfers => u128,
             else => unreachable,
         };
     }
@@ -84,25 +88,36 @@ pub const StateMachine = struct {
             .create_transfers => CreateTransfersResult,
             .commit_transfers => CommitTransfersResult,
             .lookup_accounts => Account,
+            .lookup_transfers => Transfer,
             else => unreachable,
         };
     }
 
-    pub fn prepare(self: *StateMachine, operation: Operation, input: []u8) void {
+    pub fn prepare(self: *StateMachine, realtime: i64, operation: Operation, input: []u8) void {
         switch (operation) {
-            .create_accounts => self.prepare_timestamps(.create_accounts, input),
-            .create_transfers => self.prepare_timestamps(.create_transfers, input),
-            .commit_transfers => self.prepare_timestamps(.commit_transfers, input),
+            .init => unreachable,
+            .register => {},
+            .create_accounts => self.prepare_timestamps(realtime, .create_accounts, input),
+            .create_transfers => self.prepare_timestamps(realtime, .create_transfers, input),
+            .commit_transfers => self.prepare_timestamps(realtime, .commit_transfers, input),
             .lookup_accounts => {},
+            .lookup_transfers => {},
             else => unreachable,
         }
     }
 
-    fn prepare_timestamps(self: *StateMachine, comptime operation: Operation, input: []u8) void {
+    fn prepare_timestamps(
+        self: *StateMachine,
+        realtime: i64,
+        comptime operation: Operation,
+        input: []u8,
+    ) void {
         // Guard against the wall clock going backwards by taking the max with timestamps issued:
         self.prepare_timestamp = std.math.max(
-            self.prepare_timestamp,
-            @intCast(u64, std.time.nanoTimestamp()),
+            // The cluster `commit_timestamp` may be ahead of our `prepare_timestamp` because this
+            // may be our first prepare as a recently elected leader:
+            std.math.max(self.prepare_timestamp, self.commit_timestamp) + 1,
+            @intCast(u64, realtime),
         );
         assert(self.prepare_timestamp > self.commit_timestamp);
         var sum_reserved_timestamps: usize = 0;
@@ -120,16 +135,19 @@ pub const StateMachine = struct {
 
     pub fn commit(
         self: *StateMachine,
+        client: u128,
         operation: Operation,
         input: []const u8,
         output: []u8,
     ) usize {
         return switch (operation) {
-            .init => 0,
+            .init => unreachable,
+            .register => 0,
             .create_accounts => self.execute(.create_accounts, input, output),
             .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,
         };
     }
@@ -140,7 +158,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);
@@ -242,8 +260,8 @@ 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| {
             if (self.get_account(id)) |result| {
@@ -254,6 +272,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, index| {
+            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);
 
@@ -326,8 +358,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;
@@ -424,6 +455,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).?;
@@ -503,6 +535,161 @@ 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();
@@ -512,21 +699,22 @@ test "linked accounts" {
     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):
@@ -545,11 +733,14 @@ test "linked accounts" {
         std.mem.zeroInit(Account, .{ .id = 3 }),
     };
 
+    var state_machine = try StateMachine.init(allocator, accounts.len, transfers_max, commits_max);
+    defer state_machine.deinit();
+
     const input = std.mem.asBytes(&accounts);
     const output = try allocator.alloc(u8, 4096);
 
-    state_machine.prepare(.create_accounts, input);
-    const size = state_machine.commit(.create_accounts, input, output);
+    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]);
 
     try testing.expectEqualSlices(
@@ -580,6 +771,623 @@ 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 results = std.mem.bytesAsSlice(CreateAccountsResult, output[0..size]);
+
+    for (accounts) |account, i| {
+        try testing.expectEqual(accounts[i], state_machine.get_account(accounts[i].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 results = std.mem.bytesAsSlice(CreateAccountsResult, output[0..size]);
+
+    for (accounts) |account, i| {
+        try testing.expectEqual(accounts[i], state_machine.get_account(accounts[i].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 results_transfers = std.mem.bytesAsSlice(CreateTransfersResult, output_transfers[0..size_transfers]);
+
+    for (transfers) |transfer, i| {
+        try testing.expectEqual(transfers[i], state_machine.get_transfer(transfers[i].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,