tigerbeetle-node 0.10.0 → 0.11.1

package/src/tigerbeetle/src/state_machine.zig

@@ -5,6 +5,7 @@ const mem = std.mem;
 const log = std.log.scoped(.state_machine);
 
 const tb = @import("tigerbeetle.zig");
+const snapshot_latest = @import("lsm/tree.zig").snapshot_latest;
 
 const Account = tb.Account;
 const AccountFlags = tb.AccountFlags;
@@ -18,7 +19,9 @@ const CreateTransfersResult = tb.CreateTransfersResult;
 const CreateAccountResult = tb.CreateAccountResult;
 const CreateTransferResult = tb.CreateTransferResult;
 
-pub fn StateMachineType(comptime Storage: type) type {
+pub fn StateMachineType(comptime Storage: type, comptime constants_: struct {
+    message_body_size_max: usize,
+}) type {
     return struct {
         const StateMachine = @This();
 
@@ -63,11 +66,35 @@ pub fn StateMachineType(comptime Storage: type) type {
             lookup_transfers,
         };
 
+        pub const constants = struct {
+            /// The maximum number of objects within a batch, by operation.
+            pub const batch_max = struct {
+                pub const create_accounts = operation_batch_max(.create_accounts);
+                pub const create_transfers = operation_batch_max(.create_transfers);
+                pub const lookup_accounts = operation_batch_max(.lookup_accounts);
+                pub const lookup_transfers = operation_batch_max(.lookup_transfers);
+
+                comptime {
+                    assert(create_accounts > 0);
+                    assert(create_transfers > 0);
+                    assert(lookup_accounts > 0);
+                    assert(lookup_transfers > 0);
+                }
+
+                fn operation_batch_max(comptime operation: Operation) usize {
+                    return @divFloor(constants_.message_body_size_max, std.math.max(
+                        @sizeOf(Event(operation)),
+                        @sizeOf(Result(operation)),
+                    ));
+                }
+            };
+        };
+
         pub const Options = struct {
             lsm_forest_node_count: u32,
-            cache_size_accounts: u32,
-            cache_size_transfers: u32,
-            cache_size_posted: u32,
+            cache_entries_accounts: u32,
+            cache_entries_transfers: u32,
+            cache_entries_posted: u32,
         };
 
         prepare_timestamp: u64,
@@ -92,20 +119,7 @@ pub fn StateMachineType(comptime Storage: type) type {
                 allocator,
                 grid,
                 options.lsm_forest_node_count,
-                .{
-                    .accounts = .{
-                        .cache_size = options.cache_size_accounts,
-                        .commit_count_max = 8191,
-                    },
-                    .transfers = .{
-                        .cache_size = options.cache_size_transfers,
-                        .commit_count_max = 8191 * 2,
-                    },
-                    .posted = .{
-                        .cache_size = options.cache_size_posted,
-                        .commit_count_max = 8191 * 2,
-                    },
-                },
+                forest_options(options),
             );
             errdefer forest.deinit(allocator);
 
@@ -207,11 +221,10 @@ pub fn StateMachineType(comptime Storage: type) type {
             self.prefetch_input = input;
             self.prefetch_callback = callback;
 
-            // We do this here instead of at the end of commit() to avoid the need to call
-            // prefetch() in the StateMachine unit tests below.
-            self.forest.grooves.accounts.prefetch_clear();
-            self.forest.grooves.transfers.prefetch_clear();
-            self.forest.grooves.posted.prefetch_clear();
+            // TODO(Snapshots) Pass in the target snapshot.
+            self.forest.grooves.accounts.prefetch_setup(null);
+            self.forest.grooves.transfers.prefetch_setup(null);
+            self.forest.grooves.posted.prefetch_setup(null);
 
             return switch (operation) {
                 .reserved, .root, .register => unreachable,
@@ -348,11 +361,11 @@ pub fn StateMachineType(comptime Storage: type) type {
             client: u128,
             op: u64,
             operation: Operation,
-            input: []const u8,
-            output: []u8,
+            input: []align(16) const u8,
+            output: []align(16) u8,
         ) usize {
             _ = client;
-            _ = op;
+            assert(op != 0);
 
             const result = switch (operation) {
                 .root => unreachable,
@@ -367,10 +380,6 @@ pub fn StateMachineType(comptime Storage: type) type {
             return result;
         }
 
-        pub fn tick(self: *StateMachine) void {
-            self.forest.tick();
-        }
-
         pub fn compact(self: *StateMachine, callback: fn (*StateMachine) void, op: u64) void {
             assert(self.compact_callback == null);
             assert(self.checkpoint_callback == null);
@@ -404,8 +413,8 @@ pub fn StateMachineType(comptime Storage: type) type {
         fn execute(
             self: *StateMachine,
             comptime operation: Operation,
-            input: []const u8,
-            output: []u8,
+            input: []align(16) const u8,
+            output: []align(16) u8,
         ) usize {
             comptime assert(operation != .lookup_accounts and operation != .lookup_transfers);
 
@@ -417,14 +426,21 @@ pub fn StateMachineType(comptime Storage: type) type {
             var chain_broken = false;
 
             for (events) |*event, index| {
-                if (event.flags.linked and chain == null) {
-                    chain = index;
-                    assert(chain_broken == false);
-                }
-                const result = if (chain_broken) .linked_event_failed else switch (operation) {
-                    .create_accounts => self.create_account(event),
-                    .create_transfers => self.create_transfer(event),
-                    else => unreachable,
+                const result = blk: {
+                    if (event.flags.linked) {
+                        if (chain == null) {
+                            chain = index;
+                            assert(chain_broken == false);
+                        }
+
+                        if (index == events.len - 1) break :blk .linked_event_chain_open;
+                    }
+
+                    break :blk if (chain_broken) .linked_event_failed else switch (operation) {
+                        .create_accounts => self.create_account(event),
+                        .create_transfers => self.create_transfer(event),
+                        else => unreachable,
+                    };
                 };
                 log.debug("{s} {}/{}: {}: {}", .{
                     @tagName(operation),
@@ -449,19 +465,17 @@ pub fn StateMachineType(comptime Storage: type) type {
                                 count += 1;
                             }
                         } else {
-                            assert(result == .linked_event_failed);
+                            assert(result == .linked_event_failed or result == .linked_event_chain_open);
                         }
                     }
                     results[count] = .{ .index = @intCast(u32, index), .result = result };
                     count += 1;
                 }
-                if (!event.flags.linked and chain != null) {
+                if (chain != null and (!event.flags.linked or result == .linked_event_chain_open)) {
                     chain = null;
                     chain_broken = false;
                 }
             }
-            // TODO client.zig: Validate that batch chains are always well-formed and closed.
-            // This is programming error and we should raise an exception for this in the client ASAP.
             assert(chain == null);
             assert(chain_broken == false);
 
@@ -505,6 +519,7 @@ pub fn StateMachineType(comptime Storage: type) type {
             assert(index == chain_start_index);
         }
 
+        // Accounts that do not fit in the response are omitted.
         fn execute_lookup_accounts(self: *StateMachine, input: []const u8, output: []u8) usize {
             const batch = mem.bytesAsSlice(u128, input);
             const output_len = @divFloor(output.len, @sizeOf(Account)) * @sizeOf(Account);
@@ -519,6 +534,7 @@ pub fn StateMachineType(comptime Storage: type) type {
             return results_count * @sizeOf(Account);
         }
 
+        // Transfers that do not fit in the response are omitted.
         fn execute_lookup_transfers(self: *StateMachine, input: []const u8, output: []u8) usize {
             const batch = mem.bytesAsSlice(u128, input);
             const output_len = @divFloor(output.len, @sizeOf(Transfer)) * @sizeOf(Transfer);
@@ -548,16 +564,14 @@ pub fn StateMachineType(comptime Storage: type) type {
                 return .mutually_exclusive_flags;
             }
 
-            if (sum_overflows(a.debits_pending, a.debits_posted)) return .overflows_debits;
-            if (sum_overflows(a.credits_pending, a.credits_posted)) return .overflows_credits;
-
-            // Opening balances may never exceed limits:
-            if (a.debits_exceed_credits(0)) return .exceeds_credits;
-            if (a.credits_exceed_debits(0)) return .exceeds_debits;
+            if (a.debits_pending != 0) return .debits_pending_must_be_zero;
+            if (a.debits_posted != 0) return .debits_posted_must_be_zero;
+            if (a.credits_pending != 0) return .credits_pending_must_be_zero;
+            if (a.credits_posted != 0) return .credits_posted_must_be_zero;
 
             if (self.get_account(a.id)) |e| return create_account_exists(a, e);
 
-            self.forest.grooves.accounts.put(a);
+            self.forest.grooves.accounts.put_no_clobber(a);
 
             self.commit_timestamp = a.timestamp;
             return .ok;
@@ -574,10 +588,6 @@ pub fn StateMachineType(comptime Storage: type) type {
             assert(zeroed_48_bytes(a.reserved) and zeroed_48_bytes(e.reserved));
             if (a.ledger != e.ledger) return .exists_with_different_ledger;
             if (a.code != e.code) return .exists_with_different_code;
-            if (a.debits_pending != e.debits_pending) return .exists_with_different_debits_pending;
-            if (a.debits_posted != e.debits_posted) return .exists_with_different_debits_posted;
-            if (a.credits_pending != e.credits_pending) return .exists_with_different_credits_pending;
-            if (a.credits_posted != e.credits_posted) return .exists_with_different_credits_posted;
             return .exists;
         }
 
@@ -643,6 +653,7 @@ pub fn StateMachineType(comptime Storage: type) type {
             if (sum_overflows(t.amount, cr.credits_pending + cr.credits_posted)) {
                 return .overflows_credits;
             }
+            if (sum_overflows(t.timestamp, t.timeout)) return .overflows_timeout;
 
             if (dr.debits_exceed_credits(t.amount)) return .exceeds_credits;
             if (cr.credits_exceed_debits(t.amount)) return .exceeds_debits;
@@ -899,6 +910,91 @@ pub fn StateMachineType(comptime Storage: type) type {
         fn get_posted(self: *const StateMachine, pending_id: u128) ?bool {
             return self.forest.grooves.posted.get(pending_id);
         }
+
+        pub fn forest_options(options: Options) Forest.GroovesOptions {
+            const batch_accounts_max = @intCast(u32, constants.batch_max.create_accounts);
+            const batch_transfers_max = @intCast(u32, constants.batch_max.create_transfers);
+            assert(batch_accounts_max == constants.batch_max.lookup_accounts);
+            assert(batch_transfers_max == constants.batch_max.lookup_transfers);
+
+            return .{
+                .accounts = .{
+                    .cache_entries_max = options.cache_entries_accounts,
+                    .prefetch_entries_max = std.math.max(
+                        // create_account()/lookup_account() looks up 1 account per item.
+                        batch_accounts_max,
+                        // create_transfer()/post_or_void_pending_transfer() looks up 2
+                        // accounts for every transfer.
+                        2 * batch_transfers_max,
+                    ),
+                    .tree_options_object = .{
+                        .commit_entries_max = math.max(
+                            batch_accounts_max,
+                            // ×2 because creating a transfer will update 2 accounts.
+                            2 * batch_transfers_max,
+                        ),
+                    },
+                    .tree_options_id = .{ .commit_entries_max = batch_accounts_max },
+                    .tree_options_index = .{
+                        .user_data = .{ .commit_entries_max = batch_accounts_max },
+                        .ledger = .{ .commit_entries_max = batch_accounts_max },
+                        .code = .{ .commit_entries_max = batch_accounts_max },
+                        // Transfers mutate the secondary indices for debits/credits pending/posted.
+                        //
+                        // * Each mutation results in a remove and an insert: the ×2 multiplier.
+                        // * Each transfer modifies two accounts. However, this does not
+                        //   necessitate an additional ×2 multiplier — the credits of the debit
+                        //   account and the debits of the credit account are not modified.
+                        .debits_pending = .{
+                            .commit_entries_max = math.max(
+                                batch_accounts_max,
+                                2 * batch_transfers_max,
+                            ),
+                        },
+                        .debits_posted = .{
+                            .commit_entries_max = math.max(
+                                batch_accounts_max,
+                                2 * batch_transfers_max,
+                            ),
+                        },
+                        .credits_pending = .{
+                            .commit_entries_max = math.max(
+                                batch_accounts_max,
+                                2 * batch_transfers_max,
+                            ),
+                        },
+                        .credits_posted = .{
+                            .commit_entries_max = math.max(
+                                batch_accounts_max,
+                                2 * batch_transfers_max,
+                            ),
+                        },
+                    },
+                },
+                .transfers = .{
+                    .cache_entries_max = options.cache_entries_transfers,
+                    // *2 to fetch pending and post/void transfer.
+                    .prefetch_entries_max = 2 * batch_transfers_max,
+                    .tree_options_object = .{ .commit_entries_max = batch_transfers_max },
+                    .tree_options_id = .{ .commit_entries_max = batch_transfers_max },
+                    .tree_options_index = .{
+                        .debit_account_id = .{ .commit_entries_max = batch_transfers_max },
+                        .credit_account_id = .{ .commit_entries_max = batch_transfers_max },
+                        .user_data = .{ .commit_entries_max = batch_transfers_max },
+                        .pending_id = .{ .commit_entries_max = batch_transfers_max },
+                        .timeout = .{ .commit_entries_max = batch_transfers_max },
+                        .ledger = .{ .commit_entries_max = batch_transfers_max },
+                        .code = .{ .commit_entries_max = batch_transfers_max },
+                        .amount = .{ .commit_entries_max = batch_transfers_max },
+                    },
+                },
+                .posted = .{
+                    .cache_entries_max = options.cache_entries_posted,
+                    .prefetch_entries_max = batch_transfers_max,
+                    .commit_entries_max = batch_transfers_max,
+                },
+            };
+        }
     };
 }
 
@@ -962,7 +1058,11 @@ const TestContext = struct {
     const MessagePool = @import("message_pool.zig").MessagePool;
     const SuperBlock = @import("vsr/superblock.zig").SuperBlockType(Storage);
     const Grid = @import("lsm/grid.zig").GridType(Storage);
-    const StateMachine = StateMachineType(Storage);
+    const StateMachine = StateMachineType(Storage, .{
+        // Overestimate the batch size (in order to overprovision commit_entries_max)
+        // because the test never compacts.
+        .message_body_size_max = 1000 * @sizeOf(Account),
+    });
 
     storage: Storage,
     message_pool: MessagePool,
@@ -970,36 +1070,41 @@ const TestContext = struct {
     grid: Grid,
     state_machine: StateMachine,
 
-    fn init(ctx: *TestContext, allocator: mem.Allocator, options: StateMachine.Options) !void {
+    fn init(ctx: *TestContext, allocator: mem.Allocator) !void {
         ctx.storage = try Storage.init(
             allocator,
             4096,
             .{
-                .seed = 0,
                 .read_latency_min = 0,
                 .read_latency_mean = 0,
                 .write_latency_min = 0,
                 .write_latency_mean = 0,
-                .read_fault_probability = 0,
-                .write_fault_probability = 0,
-            },
-            0,
-            .{
-                .first_offset = 0,
-                .period = 0,
             },
         );
         errdefer ctx.storage.deinit(allocator);
 
-        ctx.message_pool = .{ .free_list = null };
+        ctx.message_pool = .{
+            .free_list = null,
+            .messages_max = 0,
+        };
+        errdefer ctx.message_pool.deinit(allocator);
 
         ctx.superblock = try SuperBlock.init(allocator, &ctx.storage, &ctx.message_pool);
         errdefer ctx.superblock.deinit(allocator);
 
+        // Pretend that the superblock is open so that the Forest can initialize.
+        ctx.superblock.opened = true;
+        ctx.superblock.working.vsr_state.commit_min = 0;
+
         ctx.grid = try Grid.init(allocator, &ctx.superblock);
         errdefer ctx.grid.deinit(allocator);
 
-        ctx.state_machine = try StateMachine.init(allocator, &ctx.grid, options);
+        ctx.state_machine = try StateMachine.init(allocator, &ctx.grid, .{
+            .lsm_forest_node_count = 1,
+            .cache_entries_accounts = 2048,
+            .cache_entries_transfers = 2048,
+            .cache_entries_posted = 2048,
+        });
         errdefer ctx.state_machine.deinit(allocator);
     }
 
@@ -1024,10 +1129,6 @@ test "create/lookup/rollback accounts" {
                 .user_data = 2,
                 .ledger = 3,
                 .code = 4,
-                .debits_pending = 5,
-                .debits_posted = 6,
-                .credits_pending = 7,
-                .credits_posted = 8,
                 .timestamp = 1,
             }),
         },
@@ -1044,10 +1145,10 @@ test "create/lookup/rollback accounts" {
                     .debits_must_not_exceed_credits = true,
                     .credits_must_not_exceed_debits = true,
                 },
-                .debits_pending = math.maxInt(u64),
-                .debits_posted = math.maxInt(u64),
-                .credits_pending = math.maxInt(u64),
-                .credits_posted = math.maxInt(u64),
+                .debits_pending = 1,
+                .debits_posted = 1,
+                .credits_pending = 1,
+                .credits_posted = 1,
                 .timestamp = 2,
             }),
         },
@@ -1064,10 +1165,10 @@ test "create/lookup/rollback accounts" {
                     .debits_must_not_exceed_credits = true,
                     .credits_must_not_exceed_debits = true,
                 },
-                .debits_pending = math.maxInt(u64),
-                .debits_posted = math.maxInt(u64),
-                .credits_pending = math.maxInt(u64),
-                .credits_posted = math.maxInt(u64),
+                .debits_pending = 1,
+                .debits_posted = 1,
+                .credits_pending = 1,
+                .credits_posted = 1,
                 .timestamp = 2,
             }),
         },
@@ -1083,10 +1184,10 @@ test "create/lookup/rollback accounts" {
                     .debits_must_not_exceed_credits = true,
                     .credits_must_not_exceed_debits = true,
                 },
-                .debits_pending = math.maxInt(u64),
-                .debits_posted = math.maxInt(u64),
-                .credits_pending = math.maxInt(u64),
-                .credits_posted = math.maxInt(u64),
+                .debits_pending = 1,
+                .debits_posted = 1,
+                .credits_pending = 1,
+                .credits_posted = 1,
                 .timestamp = 2,
             }),
         },
@@ -1102,10 +1203,10 @@ test "create/lookup/rollback accounts" {
                     .debits_must_not_exceed_credits = true,
                     .credits_must_not_exceed_debits = true,
                 },
-                .debits_pending = math.maxInt(u64),
-                .debits_posted = math.maxInt(u64),
-                .credits_pending = math.maxInt(u64),
-                .credits_posted = math.maxInt(u64),
+                .debits_pending = 1,
+                .debits_posted = 1,
+                .credits_pending = 1,
+                .credits_posted = 1,
                 .timestamp = 2,
             }),
         },
@@ -1121,10 +1222,10 @@ test "create/lookup/rollback accounts" {
                     .debits_must_not_exceed_credits = true,
                     .credits_must_not_exceed_debits = true,
                 },
-                .debits_pending = math.maxInt(u64),
-                .debits_posted = math.maxInt(u64),
-                .credits_pending = math.maxInt(u64),
-                .credits_posted = math.maxInt(u64),
+                .debits_pending = 1,
+                .debits_posted = 1,
+                .credits_pending = 1,
+                .credits_posted = 1,
                 .timestamp = 2,
             }),
         },
@@ -1139,10 +1240,10 @@ test "create/lookup/rollback accounts" {
                     .debits_must_not_exceed_credits = true,
                     .credits_must_not_exceed_debits = true,
                 },
-                .debits_pending = math.maxInt(u64),
-                .debits_posted = math.maxInt(u64),
-                .credits_pending = math.maxInt(u64),
-                .credits_posted = math.maxInt(u64),
+                .debits_pending = 1,
+                .debits_posted = 1,
+                .credits_pending = 1,
+                .credits_posted = 1,
                 .timestamp = 2,
             }),
         },
@@ -1165,7 +1266,7 @@ test "create/lookup/rollback accounts" {
             }),
         },
         .{
-            .result = .overflows_debits,
+            .result = .debits_pending_must_be_zero,
             .object = mem.zeroInit(Account, .{
                 .id = 1,
                 .user_data = 20,
@@ -1174,32 +1275,31 @@ test "create/lookup/rollback accounts" {
                 .flags = .{
                     .debits_must_not_exceed_credits = true,
                 },
-                .debits_pending = math.maxInt(u64),
-                .debits_posted = 60,
-                .credits_pending = math.maxInt(u64),
-                .credits_posted = 80,
+                .debits_pending = 1,
+                .debits_posted = 1,
+                .credits_pending = 1,
+                .credits_posted = 1,
                 .timestamp = 2,
             }),
         },
         .{
-            .result = .overflows_credits,
+            .result = .debits_posted_must_be_zero,
             .object = mem.zeroInit(Account, .{
                 .id = 1,
                 .user_data = 20,
                 .ledger = 30,
                 .code = 40,
                 .flags = .{
-                    .credits_must_not_exceed_debits = true,
+                    .debits_must_not_exceed_credits = true,
                 },
-                .debits_pending = 50,
-                .debits_posted = 60,
-                .credits_pending = math.maxInt(u64),
-                .credits_posted = 80,
+                .debits_posted = 1,
+                .credits_pending = 1,
+                .credits_posted = 1,
                 .timestamp = 2,
             }),
         },
         .{
-            .result = .exceeds_credits,
+            .result = .credits_pending_must_be_zero,
             .object = mem.zeroInit(Account, .{
                 .id = 1,
                 .user_data = 20,
@@ -1208,27 +1308,22 @@ test "create/lookup/rollback accounts" {
                 .flags = .{
                     .debits_must_not_exceed_credits = true,
                 },
-                .debits_pending = 50,
-                .debits_posted = 60,
                 .credits_pending = 1,
-                .credits_posted = 109,
+                .credits_posted = 1,
                 .timestamp = 2,
             }),
         },
         .{
-            .result = .exceeds_debits,
+            .result = .credits_posted_must_be_zero,
             .object = mem.zeroInit(Account, .{
                 .id = 1,
                 .user_data = 20,
                 .ledger = 30,
                 .code = 40,
                 .flags = .{
-                    .credits_must_not_exceed_debits = true,
+                    .debits_must_not_exceed_credits = true,
                 },
-                .debits_pending = 50,
-                .debits_posted = 60,
-                .credits_pending = 1,
-                .credits_posted = 109,
+                .credits_posted = 1,
                 .timestamp = 2,
             }),
         },
@@ -1242,10 +1337,6 @@ test "create/lookup/rollback accounts" {
                 .flags = .{
                     .credits_must_not_exceed_debits = true,
                 },
-                .debits_pending = 50,
-                .debits_posted = 60,
-                .credits_pending = 0,
-                .credits_posted = 0,
                 .timestamp = 2,
             }),
         },
@@ -1256,10 +1347,6 @@ test "create/lookup/rollback accounts" {
                 .user_data = 20,
                 .ledger = 30,
                 .code = 40,
-                .debits_pending = 50,
-                .debits_posted = 60,
-                .credits_pending = 70,
-                .credits_posted = 80,
                 .timestamp = 2,
             }),
         },
@@ -1270,10 +1357,6 @@ test "create/lookup/rollback accounts" {
                 .user_data = 2,
                 .ledger = 30,
                 .code = 40,
-                .debits_pending = 50,
-                .debits_posted = 60,
-                .credits_pending = 70,
-                .credits_posted = 80,
                 .timestamp = 2,
             }),
         },
@@ -1284,66 +1367,6 @@ test "create/lookup/rollback accounts" {
                 .user_data = 2,
                 .ledger = 3,
                 .code = 40,
-                .debits_pending = 50,
-                .debits_posted = 60,
-                .credits_pending = 70,
-                .credits_posted = 80,
-                .timestamp = 2,
-            }),
-        },
-        .{
-            .result = .exists_with_different_debits_pending,
-            .object = mem.zeroInit(Account, .{
-                .id = 1,
-                .user_data = 2,
-                .ledger = 3,
-                .code = 4,
-                .debits_pending = 50,
-                .debits_posted = 60,
-                .credits_pending = 70,
-                .credits_posted = 80,
-                .timestamp = 2,
-            }),
-        },
-        .{
-            .result = .exists_with_different_debits_posted,
-            .object = mem.zeroInit(Account, .{
-                .id = 1,
-                .user_data = 2,
-                .ledger = 3,
-                .code = 4,
-                .debits_pending = 5,
-                .debits_posted = 60,
-                .credits_pending = 70,
-                .credits_posted = 80,
-                .timestamp = 2,
-            }),
-        },
-        .{
-            .result = .exists_with_different_credits_pending,
-            .object = mem.zeroInit(Account, .{
-                .id = 1,
-                .user_data = 2,
-                .ledger = 3,
-                .code = 4,
-                .debits_pending = 5,
-                .debits_posted = 6,
-                .credits_pending = 70,
-                .credits_posted = 80,
-                .timestamp = 2,
-            }),
-        },
-        .{
-            .result = .exists_with_different_credits_posted,
-            .object = mem.zeroInit(Account, .{
-                .id = 1,
-                .user_data = 2,
-                .ledger = 3,
-                .code = 4,
-                .debits_pending = 5,
-                .debits_posted = 6,
-                .credits_pending = 7,
-                .credits_posted = 80,
                 .timestamp = 2,
             }),
         },
@@ -1354,22 +1377,13 @@ test "create/lookup/rollback accounts" {
                 .user_data = 2,
                 .ledger = 3,
                 .code = 4,
-                .debits_pending = 5,
-                .debits_posted = 6,
-                .credits_pending = 7,
-                .credits_posted = 8,
                 .timestamp = 2,
             }),
         },
     };
 
     var context: TestContext = undefined;
-    try context.init(testing.allocator, .{
-        .lsm_forest_node_count = 1,
-        .cache_size_accounts = vectors.len,
-        .cache_size_transfers = 0,
-        .cache_size_posted = 0,
-    });
+    try context.init(testing.allocator);
     defer context.deinit(testing.allocator);
 
     const state_machine = &context.state_machine;
@@ -1391,10 +1405,6 @@ test "create/lookup/rollback accounts" {
 }
 
 test "linked accounts" {
-    const accounts_max = 5;
-    const transfers_max = 0;
-    const transfers_pending_max = 0;
-
     var accounts = [_]Account{
         // An individual event (successful):
         mem.zeroInit(Account, .{ .id = 7, .code = 1, .ledger = 1 }),
@@ -1430,23 +1440,18 @@ test "linked accounts" {
     };
 
     var context: TestContext = undefined;
-    try context.init(testing.allocator, .{
-        .lsm_forest_node_count = 1,
-        .cache_size_accounts = accounts_max,
-        .cache_size_transfers = transfers_max,
-        .cache_size_posted = transfers_pending_max,
-    });
+    try context.init(testing.allocator);
     defer context.deinit(testing.allocator);
 
     const state_machine = &context.state_machine;
 
     const input = mem.asBytes(&accounts);
 
-    const output = try testing.allocator.alloc(u8, 4096);
+    const output = try testing.allocator.alignedAlloc(u8, 16, 4096);
     defer testing.allocator.free(output);
 
     _ = state_machine.prepare(.create_accounts, input);
-    const size = state_machine.commit(0, 0, .create_accounts, input, output);
+    const size = state_machine.commit(0, 1, .create_accounts, input, output);
     const results = mem.bytesAsSlice(CreateAccountsResult, output[0..size]);
 
     try expectEqualSlices(
@@ -1474,6 +1479,124 @@ test "linked accounts" {
     // All our rollback handlers appear to be commutative.
 }
 
+test "linked_event_chain_open" {
+    var accounts = [_]Account{
+        // A chain of 3 events (the last event in the chain closes the chain with linked=false):
+        mem.zeroInit(Account, .{ .id = 1, .code = 1, .ledger = 1, .flags = .{ .linked = true } }),
+        mem.zeroInit(Account, .{ .id = 2, .code = 1, .ledger = 1, .flags = .{ .linked = true } }),
+        mem.zeroInit(Account, .{ .id = 3, .code = 1, .ledger = 1 }),
+
+        // An open chain of 2 events:
+        mem.zeroInit(Account, .{ .id = 4, .code = 1, .ledger = 1, .flags = .{ .linked = true } }),
+        mem.zeroInit(Account, .{ .id = 5, .code = 1, .ledger = 1, .flags = .{ .linked = true } }),
+    };
+
+    var context: TestContext = undefined;
+    try context.init(testing.allocator);
+    defer context.deinit(testing.allocator);
+
+    const state_machine = &context.state_machine;
+
+    const input = mem.asBytes(&accounts);
+
+    const output = try testing.allocator.alignedAlloc(u8, 16, 4096);
+    defer testing.allocator.free(output);
+
+    _ = state_machine.prepare(.create_accounts, input);
+    const size = state_machine.commit(0, 1, .create_accounts, input, output);
+    const results = mem.bytesAsSlice(CreateAccountsResult, output[0..size]);
+
+    try expectEqualSlices(
+        CreateAccountsResult,
+        &[_]CreateAccountsResult{
+            .{ .index = 3, .result = .linked_event_failed },
+            .{ .index = 4, .result = .linked_event_chain_open },
+        },
+        results,
+    );
+
+    try expectEqual(accounts[0], state_machine.get_account(accounts[0].id).?.*);
+    try expectEqual(accounts[1], state_machine.get_account(accounts[1].id).?.*);
+    try expectEqual(accounts[2], state_machine.get_account(accounts[2].id).?.*);
+
+    try expectEqual(@as(?*const Account, null), state_machine.get_account(accounts[3].id));
+    try expectEqual(@as(?*const Account, null), state_machine.get_account(accounts[4].id));
+}
+
+test "linked_event_chain_open for an already failed batch" {
+    var accounts = [_]Account{
+        // An individual event (successful):
+        mem.zeroInit(Account, .{ .id = 1, .code = 1, .ledger = 1 }),
+
+        // An open chain of 3 events (the second one fails):
+        mem.zeroInit(Account, .{ .id = 2, .code = 1, .ledger = 1, .flags = .{ .linked = true } }),
+        mem.zeroInit(Account, .{ .id = 1, .code = 1, .ledger = 1, .flags = .{ .linked = true } }),
+        mem.zeroInit(Account, .{ .id = 3, .code = 1, .ledger = 1, .flags = .{ .linked = true } }),
+    };
+
+    var context: TestContext = undefined;
+    try context.init(testing.allocator);
+    defer context.deinit(testing.allocator);
+
+    const state_machine = &context.state_machine;
+
+    const input = mem.asBytes(&accounts);
+
+    const output = try testing.allocator.alignedAlloc(u8, 16, 4096);
+    defer testing.allocator.free(output);
+
+    _ = state_machine.prepare(.create_accounts, input);
+    const size = state_machine.commit(0, 1, .create_accounts, input, output);
+    const results = mem.bytesAsSlice(CreateAccountsResult, output[0..size]);
+
+    try expectEqualSlices(
+        CreateAccountsResult,
+        &[_]CreateAccountsResult{
+            .{ .index = 1, .result = .linked_event_failed },
+            .{ .index = 2, .result = .exists_with_different_flags },
+            .{ .index = 3, .result = .linked_event_chain_open },
+        },
+        results,
+    );
+
+    try expectEqual(accounts[0], state_machine.get_account(accounts[0].id).?.*);
+
+    try expectEqual(@as(?*const Account, null), state_machine.get_account(accounts[1].id));
+    try expectEqual(@as(?*const Account, null), state_machine.get_account(accounts[3].id));
+}
+
+test "linked_event_chain_open for a batch of 1" {
+    var accounts = [_]Account{
+        // Just one event with linked = true
+        mem.zeroInit(Account, .{ .id = 1, .code = 1, .ledger = 1, .flags = .{ .linked = true } }),
+    };
+
+    var context: TestContext = undefined;
+    try context.init(testing.allocator);
+    defer context.deinit(testing.allocator);
+
+    const state_machine = &context.state_machine;
+
+    const input = mem.asBytes(&accounts);
+
+    const output = try testing.allocator.alignedAlloc(u8, 16, 4096);
+    defer testing.allocator.free(output);
+
+    _ = state_machine.prepare(.create_accounts, input);
+    const size = state_machine.commit(0, 1, .create_accounts, input, output);
+    const results = mem.bytesAsSlice(CreateAccountsResult, output[0..size]);
+
+    try expectEqualSlices(
+        CreateAccountsResult,
+        &[_]CreateAccountsResult{
+            .{ .index = 0, .result = .linked_event_chain_open },
+        },
+        results,
+    );
+
+    try expectEqual(@as(?*const Account, null), state_machine.get_account(accounts[0].id));
+}
+
 // The goal is to ensure that:
 // 1. all CreateTransferResult enums are covered, with
 // 2. enums tested in the order that they are defined, for easier auditing of coverage, and that
@@ -1518,34 +1641,26 @@ test "create/lookup/rollback transfers" {
     };
 
     var context: TestContext = undefined;
-    try context.init(testing.allocator, .{
-        .lsm_forest_node_count = 1,
-        .cache_size_accounts = accounts.len,
-        .cache_size_transfers = 1,
-        .cache_size_posted = 0,
-    });
+    try context.init(testing.allocator);
     defer context.deinit(testing.allocator);
 
     const state_machine = &context.state_machine;
 
     const input = mem.asBytes(&accounts);
 
-    const output = try testing.allocator.alloc(u8, 4096);
+    const output = try testing.allocator.alignedAlloc(u8, 16, 4096);
     defer testing.allocator.free(output);
 
     _ = state_machine.prepare(.create_accounts, input);
-    const size = state_machine.commit(0, 0, .create_accounts, input, output);
-
-    const errors = mem.bytesAsSlice(CreateAccountsResult, output[0..size]);
-    try expect(errors.len == 0);
 
     for (accounts) |account| {
+        state_machine.forest.grooves.accounts.put(&account);
         try expectEqual(account, state_machine.get_account(account.id).?.*);
     }
 
     const Vector = struct { result: CreateTransferResult, object: Transfer };
 
-    const timestamp: u64 = (state_machine.commit_timestamp + 1);
+    const timestamp: u64 = state_machine.prepare_timestamp + 1;
     const vectors = [_]Vector{
         .{
             .result = .reserved_flag,
@@ -1719,7 +1834,7 @@ test "create/lookup/rollback transfers" {
                 .id = 1,
                 .debit_account_id = 100,
                 .credit_account_id = 200,
-                .timeout = 1,
+                .timeout = (std.math.maxInt(u64) - timestamp) + 1,
                 .ledger = 0,
                 .code = 0,
                 .amount = 0,
@@ -1732,7 +1847,7 @@ test "create/lookup/rollback transfers" {
                 .id = 1,
                 .debit_account_id = 100,
                 .credit_account_id = 200,
-                .timeout = 1,
+                .timeout = (std.math.maxInt(u64) - timestamp) + 1,
                 .ledger = 0,
                 .code = 0,
                 .flags = .{ .pending = true },
@@ -1746,7 +1861,7 @@ test "create/lookup/rollback transfers" {
                 .id = 1,
                 .debit_account_id = 100,
                 .credit_account_id = 200,
-                .timeout = 1,
+                .timeout = (std.math.maxInt(u64) - timestamp) + 1,
                 .ledger = 100,
                 .code = 0,
                 .flags = .{ .pending = true },
@@ -1760,7 +1875,7 @@ test "create/lookup/rollback transfers" {
                 .id = 1,
                 .debit_account_id = 100,
                 .credit_account_id = 200,
-                .timeout = 1,
+                .timeout = (std.math.maxInt(u64) - timestamp) + 1,
                 .ledger = 100,
                 .code = 1,
                 .flags = .{ .pending = true },
@@ -1774,7 +1889,7 @@ test "create/lookup/rollback transfers" {
                 .id = 1,
                 .debit_account_id = 100,
                 .credit_account_id = 200,
-                .timeout = 1,
+                .timeout = (std.math.maxInt(u64) - timestamp) + 1,
                 .ledger = 100,
                 .code = 1,
                 .flags = .{ .pending = true },
@@ -1788,7 +1903,7 @@ test "create/lookup/rollback transfers" {
                 .id = 1,
                 .debit_account_id = 1,
                 .credit_account_id = 200,
-                .timeout = 1,
+                .timeout = (std.math.maxInt(u64) - timestamp) + 1,
                 .ledger = 100,
                 .code = 1,
                 .flags = .{ .pending = true },
@@ -1802,9 +1917,11 @@ test "create/lookup/rollback transfers" {
                 .id = 1,
                 .debit_account_id = 1,
                 .credit_account_id = 2,
+                .timeout = (std.math.maxInt(u64) - timestamp) + 1,
                 .ledger = 100,
                 .code = 1,
                 .amount = 1,
+                .flags = .{ .pending = true },
                 .timestamp = timestamp,
             }),
         },
@@ -1814,9 +1931,11 @@ test "create/lookup/rollback transfers" {
                 .id = 1,
                 .debit_account_id = 1,
                 .credit_account_id = 3,
+                .timeout = (std.math.maxInt(u64) - timestamp) + 1,
                 .ledger = 100,
                 .code = 1,
                 .amount = 1,
+                .flags = .{ .pending = true },
                 .timestamp = timestamp,
             }),
         },
@@ -1826,7 +1945,7 @@ test "create/lookup/rollback transfers" {
                 .id = 1,
                 .debit_account_id = 1,
                 .credit_account_id = 3,
-                .timeout = 30000,
+                .timeout = (std.math.maxInt(u64) - timestamp) + 1,
                 .ledger = 1,
                 .code = 1,
                 .flags = .{ .pending = true },
@@ -1840,7 +1959,7 @@ test "create/lookup/rollback transfers" {
                 .id = 1,
                 .debit_account_id = 1,
                 .credit_account_id = 3,
-                .timeout = 30000,
+                .timeout = (std.math.maxInt(u64) - timestamp) + 1,
                 .ledger = 1,
                 .code = 1,
                 .flags = .{ .pending = true },
@@ -1854,8 +1973,10 @@ test "create/lookup/rollback transfers" {
                 .id = 1,
                 .debit_account_id = 1,
                 .credit_account_id = 3,
+                .timeout = (std.math.maxInt(u64) - timestamp) + 1,
                 .ledger = 1,
                 .code = 1,
+                .flags = .{ .pending = true },
                 .amount = math.maxInt(u64) - accounts[1 - 1].debits_posted + 1,
                 .timestamp = timestamp,
             }),
@@ -1866,8 +1987,10 @@ test "create/lookup/rollback transfers" {
                 .id = 1,
                 .debit_account_id = 1,
                 .credit_account_id = 3,
+                .timeout = (std.math.maxInt(u64) - timestamp) + 1,
                 .ledger = 1,
                 .code = 1,
+                .flags = .{ .pending = true },
                 .amount = math.maxInt(u64) - accounts[3 - 1].credits_posted + 1,
                 .timestamp = timestamp,
             }),
@@ -1878,8 +2001,10 @@ test "create/lookup/rollback transfers" {
                 .id = 1,
                 .debit_account_id = 1,
                 .credit_account_id = 3,
+                .timeout = (std.math.maxInt(u64) - timestamp) + 1,
                 .ledger = 1,
                 .code = 1,
+                .flags = .{ .pending = true },
                 .amount = math.maxInt(u64) -
                     accounts[1 - 1].debits_pending -
                     accounts[1 - 1].debits_posted + 1,
@@ -1892,14 +2017,32 @@ test "create/lookup/rollback transfers" {
                 .id = 1,
                 .debit_account_id = 1,
                 .credit_account_id = 3,
+                .timeout = (std.math.maxInt(u64) - timestamp) + 1,
                 .ledger = 1,
                 .code = 1,
+                .flags = .{ .pending = true },
                 .amount = math.maxInt(u64) -
                     accounts[3 - 1].credits_pending -
                     accounts[3 - 1].credits_posted + 1,
                 .timestamp = timestamp,
             }),
         },
+        .{
+            .result = .overflows_timeout,
+            .object = mem.zeroInit(Transfer, .{
+                .id = 1,
+                .debit_account_id = 4,
+                .credit_account_id = 5,
+                .timeout = (std.math.maxInt(u64) - timestamp) + 1,
+                .ledger = 1,
+                .code = 1,
+                .flags = .{ .pending = true },
+                .amount = accounts[4 - 1].credits_posted -
+                    accounts[4 - 1].debits_pending -
+                    accounts[4 - 1].debits_posted + 1,
+                .timestamp = timestamp,
+            }),
+        },
         .{
             .result = .exceeds_credits,
             .object = mem.zeroInit(Transfer, .{
@@ -2132,11 +2275,6 @@ test "create/lookup/rollback transfers" {
     try test_account_balances(state_machine, 1, 100, 200, 0, 0);
     try test_account_balances(state_machine, 3, 0, 0, 110, 210);
     try expect(state_machine.get_transfer(1) == null);
-
-    for (accounts) |account| {
-        state_machine.create_account_rollback(&account);
-        try expect(state_machine.get_account(account.id) == null);
-    }
 }
 
 test "create/lookup/rollback 2-phase transfers" {
@@ -2198,12 +2336,7 @@ test "create/lookup/rollback 2-phase transfers" {
     };
 
     var context: TestContext = undefined;
-    try context.init(testing.allocator, .{
-        .lsm_forest_node_count = 1,
-        .cache_size_accounts = accounts.len,
-        .cache_size_transfers = 100,
-        .cache_size_posted = 1,
-    });
+    try context.init(testing.allocator);
     defer context.deinit(testing.allocator);
 
     const state_machine = &context.state_machine;
@@ -2211,12 +2344,12 @@ test "create/lookup/rollback 2-phase transfers" {
     // Create accounts:
     const accounts_input = mem.asBytes(&accounts);
 
-    const accounts_output = try testing.allocator.alloc(u8, 4096);
+    const accounts_output = try testing.allocator.alignedAlloc(u8, 16, 4096);
     defer testing.allocator.free(accounts_output);
 
     const accounts_timestamp = state_machine.prepare(.create_accounts, accounts_input);
     {
-        const size = state_machine.commit(0, 0, .create_accounts, accounts_input, accounts_output);
+        const size = state_machine.commit(0, 1, .create_accounts, accounts_input, accounts_output);
         const errors = mem.bytesAsSlice(CreateAccountsResult, accounts_output[0..size]);
         try expectEqual(@as(usize, 0), errors.len);
     }
@@ -2227,13 +2360,13 @@ test "create/lookup/rollback 2-phase transfers" {
     // Create pending transfers:
     const transfers_input = mem.asBytes(&transfers);
 
-    const transfers_output = try testing.allocator.alloc(u8, 4096);
+    const transfers_output = try testing.allocator.alignedAlloc(u8, 16, 4096);
     defer testing.allocator.free(transfers_output);
 
     const transfers_timestamp = state_machine.prepare(.create_transfers, transfers_input);
     try testing.expect(transfers_timestamp > accounts_timestamp);
     {
-        const size = state_machine.commit(0, 1, .create_transfers, transfers_input, transfers_output);
+        const size = state_machine.commit(0, 2, .create_transfers, transfers_input, transfers_output);
         const errors = mem.bytesAsSlice(CreateTransfersResult, transfers_output[0..size]);
         try expectEqual(@as(usize, 0), errors.len);
     }
@@ -2901,7 +3034,9 @@ fn test_equal_n_bytes(comptime n: usize) !void {
 
 test "StateMachine: ref all decls" {
     const Storage = @import("storage.zig").Storage;
-    const StateMachine = StateMachineType(Storage);
+    const StateMachine = StateMachineType(Storage, .{
+        .message_body_size_max = 1000 * @sizeOf(Account),
+    });
 
     std.testing.refAllDecls(StateMachine);
 }