tigerbeetle-node 0.5.0 → 0.6.0

package/src/tigerbeetle/src/message_pool.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const builtin = @import("builtin");
 const assert = std.debug.assert;
 const mem = std.mem;
 
@@ -16,15 +17,55 @@ comptime {
 /// message to be shifted to make space for 0 padding to vsr.sector_ceil.
 const message_size_max_padded = config.message_size_max + config.sector_size;
 
-/// A pool of reference-counted Messages, memory for which is allocated only once
-/// during initialization and reused thereafter. The config.message_bus_messages_max
-/// and config.message_bus_headers_max values determine the size of this pool.
+/// The number of full-sized messages allocated at initialization by the replica message pool.
+/// There must be enough messages to ensure that the replica can always progress, to avoid deadlock.
+pub const messages_max_replica = messages_max: {
+    var sum: usize = 0;
+
+    sum += config.io_depth_read + config.io_depth_write; // Journal I/O
+    sum += config.clients_max; // Replica.client_table
+    sum += 1; // Replica.loopback_queue
+    sum += config.pipelining_max; // Replica.pipeline
+    sum += config.replicas_max; // Replica.do_view_change_from_all_replicas quorum (all others are bitsets)
+    sum += config.connections_max; // Connection.recv_message
+    sum += config.connections_max * config.connection_send_queue_max_replica; // Connection.send_queue
+    sum += 1; // Handle bursts (e.g. Connection.parse_message)
+    // Handle Replica.commit_op's reply:
+    // (This is separate from the burst +1 because they may occur concurrently).
+    sum += 1;
+    sum += 20; // TODO Our network simulator allows up to 20 messages for path_capacity_max.
+
+    break :messages_max sum;
+};
+
+/// The number of full-sized messages allocated at initialization by the client message pool.
+pub const messages_max_client = messages_max: {
+    var sum: usize = 0;
+
+    sum += config.replicas_max; // Connection.recv_message
+    sum += config.replicas_max * config.connection_send_queue_max_client; // Connection.send_queue
+    sum += config.client_request_queue_max; // Client.request_queue
+    // Handle bursts (e.g. Connection.parse_message, or sending a ping when the send queue is full).
+    sum += 1;
+    sum += 20; // TODO Our network simulator allows up to 20 messages for path_capacity_max.
+
+    break :messages_max sum;
+};
+
+comptime {
+    // These conditions are necessary (but not sufficient) to prevent deadlocks.
+    assert(messages_max_replica > config.replicas_max);
+    assert(messages_max_client > config.client_request_queue_max);
+}
+
+/// A pool of reference-counted Messages, memory for which is allocated only once during
+/// initialization and reused thereafter. The messages_max values determine the size of this pool.
 pub const MessagePool = struct {
     pub const Message = struct {
         // TODO: replace this with a header() function to save memory
         header: *Header,
-        /// Unless this Message is header only, this buffer is in aligned to config.sector_size
-        /// and casting to that alignment in order to perform Direct I/O is safe.
+        /// This buffer is aligned to config.sector_size and casting to that alignment in order
+        /// to perform Direct I/O is safe.
         buffer: []u8,
         references: u32 = 0,
         next: ?*Message,
@@ -38,27 +79,23 @@ pub const MessagePool = struct {
         pub fn body(message: *Message) []u8 {
             return message.buffer[@sizeOf(Header)..message.header.size];
         }
-
-        fn header_only(message: Message) bool {
-            const ret = message.buffer.len == @sizeOf(Header);
-            assert(ret or message.buffer.len == message_size_max_padded);
-            return ret;
-        }
     };
 
     /// List of currently unused messages of message_size_max_padded
     free_list: ?*Message,
-    /// List of currently usused header-sized messages
-    header_only_free_list: ?*Message,
 
-    pub fn init(allocator: *mem.Allocator) error{OutOfMemory}!MessagePool {
+    pub fn init(allocator: mem.Allocator, process_type: vsr.ProcessType) error{OutOfMemory}!MessagePool {
+        const messages_max: usize = switch (process_type) {
+            .replica => messages_max_replica,
+            .client => messages_max_client,
+        };
+
         var ret: MessagePool = .{
             .free_list = null,
-            .header_only_free_list = null,
         };
         {
             var i: usize = 0;
-            while (i < config.message_bus_messages_max) : (i += 1) {
+            while (i < messages_max) : (i += 1) {
                 const buffer = try allocator.allocAdvanced(
                     u8,
                     config.sector_size,
@@ -74,59 +111,29 @@ pub const MessagePool = struct {
                 ret.free_list = message;
             }
         }
-        {
-            var i: usize = 0;
-            while (i < config.message_bus_headers_max) : (i += 1) {
-                const header = try allocator.create(Header);
-                const message = try allocator.create(Message);
-                message.* = .{
-                    .header = header,
-                    .buffer = mem.asBytes(header),
-                    .next = ret.header_only_free_list,
-                };
-                ret.header_only_free_list = message;
-            }
-        }
 
         return ret;
     }
 
-    /// Get an unused message with a buffer of config.message_size_max. If no such message is
-    /// available, an error is returned. The returned message has exactly one reference.
-    pub fn get_message(pool: *MessagePool) ?*Message {
-        const ret = pool.free_list orelse return null;
-        pool.free_list = ret.next;
-        ret.next = null;
-        assert(!ret.header_only());
-        assert(ret.references == 0);
-        ret.references = 1;
-        return ret;
-    }
+    /// Get an unused message with a buffer of config.message_size_max.
+    /// The returned message has exactly one reference.
+    pub fn get_message(pool: *MessagePool) *Message {
+        const message = pool.free_list.?;
+        pool.free_list = message.next;
+        message.next = null;
+        assert(message.references == 0);
 
-    /// Get an unused message with a buffer only large enough to hold a header. If no such message
-    /// is available, an error is returned. The returned message has exactly one reference.
-    pub fn get_header_only_message(pool: *MessagePool) ?*Message {
-        const ret = pool.header_only_free_list orelse return null;
-        pool.header_only_free_list = ret.next;
-        ret.next = null;
-        assert(ret.header_only());
-        assert(ret.references == 0);
-        ret.references = 1;
-        return ret;
+        message.references = 1;
+        return message;
     }
 
     /// Decrement the reference count of the message, possibly freeing it.
     pub fn unref(pool: *MessagePool, message: *Message) void {
         message.references -= 1;
         if (message.references == 0) {
-            if (std.builtin.mode == .Debug) mem.set(u8, message.buffer, undefined);
-            if (message.header_only()) {
-                message.next = pool.header_only_free_list;
-                pool.header_only_free_list = message;
-            } else {
-                message.next = pool.free_list;
-                pool.free_list = message;
-            }
+            if (builtin.mode == .Debug) mem.set(u8, message.buffer, undefined);
+            message.next = pool.free_list;
+            pool.free_list = message;
         }
     }
 };

package/src/tigerbeetle/src/ring_buffer.zig

@@ -76,6 +76,13 @@ pub fn RingBuffer(comptime T: type, comptime size: usize) type {
             self.advance_tail();
         }
 
+        /// Add an element to a RingBuffer, and assert that the capacity is sufficient.
+        pub fn push_assume_capacity(self: *Self, item: T) void {
+            self.push(item) catch |err| switch (err) {
+                error.NoSpaceLeft => unreachable,
+            };
+        }
+
         /// Remove and return the next item, if any.
         pub fn pop(self: *Self) ?T {
             const result = self.head() orelse return null;

package/src/tigerbeetle/src/simulator.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const builtin = @import("builtin");
 const assert = std.debug.assert;
 const mem = std.mem;
 
@@ -17,7 +18,7 @@ const output = std.log.scoped(.state_checker);
 
 /// Set this to `false` if you want to see how literally everything works.
 /// This will run much slower but will trace all logic across the cluster.
-const log_state_transitions_only = std.builtin.mode != .Debug;
+const log_state_transitions_only = builtin.mode != .Debug;
 
 /// You can fine tune your log levels even further (debug/info/notice/warn/err/crit/alert/emerg):
 pub const log_level: std.log.Level = if (log_state_transitions_only) .info else .debug;
@@ -40,13 +41,13 @@ pub fn main() !void {
         break :seed_from_arg parse_seed(arg_two);
     };
 
-    if (std.builtin.mode == .ReleaseFast or std.builtin.mode == .ReleaseSmall) {
+    if (builtin.mode == .ReleaseFast or builtin.mode == .ReleaseSmall) {
         // We do not support ReleaseFast or ReleaseSmall because they disable assertions.
         @panic("the simulator must be run with -OReleaseSafe");
     }
 
     if (seed == seed_random) {
-        if (std.builtin.mode != .ReleaseSafe) {
+        if (builtin.mode != .ReleaseSafe) {
             // If no seed is provided, than Debug is too slow and ReleaseSafe is much faster.
             @panic("no seed provided: the simulator must be run with -OReleaseSafe");
         }
@@ -56,53 +57,53 @@ pub fn main() !void {
     }
 
     var prng = std.rand.DefaultPrng.init(seed);
-    const random = &prng.random;
+    const random = prng.random();
 
-    const replica_count = 1 + prng.random.uintLessThan(u8, config.replicas_max);
-    const client_count = 1 + prng.random.uintLessThan(u8, config.clients_max);
+    const replica_count = 1 + random.uintLessThan(u8, config.replicas_max);
+    const client_count = 1 + random.uintLessThan(u8, config.clients_max);
     const node_count = replica_count + client_count;
 
     const ticks_max = 100_000_000;
     const transitions_max = config.journal_size_max / config.message_size_max;
-    const request_probability = 1 + prng.random.uintLessThan(u8, 99);
-    const idle_on_probability = prng.random.uintLessThan(u8, 20);
-    const idle_off_probability = 10 + prng.random.uintLessThan(u8, 10);
+    const request_probability = 1 + random.uintLessThan(u8, 99);
+    const idle_on_probability = random.uintLessThan(u8, 20);
+    const idle_off_probability = 10 + random.uintLessThan(u8, 10);
 
-    cluster = try Cluster.create(allocator, &prng.random, .{
+    cluster = try Cluster.create(allocator, random, .{
         .cluster = 0,
         .replica_count = replica_count,
         .client_count = client_count,
-        .seed = prng.random.int(u64),
+        .seed = random.int(u64),
         .network_options = .{
             .packet_simulator_options = .{
                 .replica_count = replica_count,
                 .client_count = client_count,
                 .node_count = node_count,
 
-                .seed = prng.random.int(u64),
-                .one_way_delay_mean = 3 + prng.random.uintLessThan(u16, 10),
-                .one_way_delay_min = prng.random.uintLessThan(u16, 3),
-                .packet_loss_probability = prng.random.uintLessThan(u8, 30),
-                .path_maximum_capacity = 20 + prng.random.uintLessThan(u8, 20),
-                .path_clog_duration_mean = prng.random.uintLessThan(u16, 500),
-                .path_clog_probability = prng.random.uintLessThan(u8, 2),
-                .packet_replay_probability = prng.random.uintLessThan(u8, 50),
+                .seed = random.int(u64),
+                .one_way_delay_mean = 3 + random.uintLessThan(u16, 10),
+                .one_way_delay_min = random.uintLessThan(u16, 3),
+                .packet_loss_probability = random.uintLessThan(u8, 30),
+                .path_maximum_capacity = 2 + random.uintLessThan(u8, 19),
+                .path_clog_duration_mean = random.uintLessThan(u16, 500),
+                .path_clog_probability = random.uintLessThan(u8, 2),
+                .packet_replay_probability = random.uintLessThan(u8, 50),
 
                 .partition_mode = random_partition_mode(random),
-                .partition_probability = prng.random.uintLessThan(u8, 3),
-                .unpartition_probability = 1 + prng.random.uintLessThan(u8, 10),
-                .partition_stability = 100 + prng.random.uintLessThan(u32, 100),
-                .unpartition_stability = prng.random.uintLessThan(u32, 20),
+                .partition_probability = random.uintLessThan(u8, 3),
+                .unpartition_probability = 1 + random.uintLessThan(u8, 10),
+                .partition_stability = 100 + random.uintLessThan(u32, 100),
+                .unpartition_stability = random.uintLessThan(u32, 20),
             },
         },
         .storage_options = .{
-            .seed = prng.random.int(u64),
-            .read_latency_min = prng.random.uintLessThan(u16, 3),
-            .read_latency_mean = 3 + prng.random.uintLessThan(u16, 10),
-            .write_latency_min = prng.random.uintLessThan(u16, 3),
-            .write_latency_mean = 3 + prng.random.uintLessThan(u16, 10),
-            .read_fault_probability = prng.random.uintLessThan(u8, 10),
-            .write_fault_probability = prng.random.uintLessThan(u8, 10),
+            .seed = random.int(u64),
+            .read_latency_min = random.uintLessThan(u16, 3),
+            .read_latency_mean = 3 + random.uintLessThan(u16, 10),
+            .write_latency_min = random.uintLessThan(u16, 3),
+            .write_latency_mean = 3 + random.uintLessThan(u16, 10),
+            .read_fault_probability = random.uintLessThan(u8, 10),
+            .write_fault_probability = random.uintLessThan(u8, 10),
         },
     });
     defer cluster.destroy();
@@ -206,23 +207,23 @@ pub fn main() !void {
     }
 
     if (cluster.state_checker.transitions < transitions_max) {
-        output.emerg("you can reproduce this failure with seed={}", .{seed});
+        output.err("you can reproduce this failure with seed={}", .{seed});
         @panic("unable to complete transitions_max before ticks_max");
     }
 
     assert(cluster.state_checker.convergence());
 
-    output.info("\n          PASSED", .{});
+    output.info("\n          PASSED ({} ticks)", .{tick});
 }
 
 /// Returns true, `p` percent of the time, else false.
-fn chance(random: *std.rand.Random, p: u8) bool {
+fn chance(random: std.rand.Random, p: u8) bool {
     assert(p <= 100);
     return random.uintLessThan(u8, 100) < p;
 }
 
 /// Returns the next argument for the simulator or null (if none available)
-fn args_next(args: *std.process.ArgIterator, allocator: *std.mem.Allocator) ?[:0]const u8 {
+fn args_next(args: *std.process.ArgIterator, allocator: std.mem.Allocator) ?[:0]const u8 {
     const err_or_bytes = args.next(allocator) orelse return null;
     return err_or_bytes catch @panic("Unable to extract next value from args");
 }
@@ -232,7 +233,7 @@ fn on_change_replica(replica: *Replica) void {
     cluster.state_checker.check_state(replica.replica);
 }
 
-fn send_request(random: *std.rand.Random) bool {
+fn send_request(random: std.rand.Random) bool {
     const client_index = random.uintLessThan(u8, cluster.options.client_count);
 
     const client = &cluster.clients[client_index];
@@ -243,7 +244,7 @@ fn send_request(random: *std.rand.Random) bool {
     if (client.request_queue.full()) return false;
     if (checker_request_queue.full()) return false;
 
-    const message = client.get_message() orelse return false;
+    const message = client.get_message();
     defer client.unref(message);
 
     const body_size_max = config.message_size_max - @sizeOf(Header);
@@ -264,7 +265,7 @@ fn send_request(random: *std.rand.Random) bool {
     // While hashing the client ID with the request body prevents input collisions across clients,
     // it's still possible for the same client to generate the same body, and therefore input hash.
     const client_input = StateMachine.hash(client.id, body);
-    checker_request_queue.push(client_input) catch unreachable;
+    checker_request_queue.push_assume_capacity(client_input);
     std.log.scoped(.test_client).debug("client {} sending input={x}", .{
         client_index,
         client_input,
@@ -280,11 +281,14 @@ fn client_callback(
     operation: StateMachine.Operation,
     results: Client.Error![]const u8,
 ) void {
+    _ = operation;
+    _ = results catch unreachable;
+
     assert(user_data == 0);
 }
 
 /// Returns a random partitioning mode, excluding .custom
-fn random_partition_mode(random: *std.rand.Random) PartitionMode {
+fn random_partition_mode(random: std.rand.Random) PartitionMode {
     const typeInfo = @typeInfo(PartitionMode).Enum;
     var enumAsInt = random.uintAtMost(typeInfo.tag_type, typeInfo.fields.len - 2);
     if (enumAsInt >= @enumToInt(PartitionMode.custom)) enumAsInt += 1;
@@ -310,8 +314,8 @@ pub fn log(
     const prefix = if (log_state_transitions_only) "" else prefix_default;
 
     // Print the message to stdout, silently ignoring any errors
-    const held = std.debug.getStderrMutex().acquire();
-    defer held.release();
     const stderr = std.io.getStdErr().writer();
+    std.debug.getStderrMutex().lock();
+    defer std.debug.getStderrMutex().unlock();
     nosuspend stderr.print(prefix ++ format ++ "\n", args) catch return;
 }

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);
@@ -21,13 +39,9 @@ pub const StateMachine = struct {
         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,
+    allocator: std.mem.Allocator,
     prepare_timestamp: u64,
     commit_timestamp: u64,
     accounts: HashMapAccounts,
@@ -35,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).
@@ -140,6 +154,8 @@ pub const StateMachine = struct {
         input: []const u8,
         output: []u8,
     ) usize {
+        _ = client;
+
         return switch (operation) {
             .init => unreachable,
             .register => 0,
@@ -263,7 +279,7 @@ pub const StateMachine = struct {
         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;
@@ -277,7 +293,7 @@ pub const StateMachine = struct {
         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| {
+        for (batch) |id| {
             if (self.get_transfer(id)) |result| {
                 results[results_count] = result.*;
                 results_count += 1;
@@ -538,7 +554,8 @@ 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 allocator = arena.allocator();
 
     const Vector = struct { result: CreateAccountResult, object: Account };
 
@@ -693,7 +710,8 @@ test "create/lookup accounts" {
 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;
@@ -733,7 +751,7 @@ test "linked accounts" {
         std.mem.zeroInit(Account, .{ .id = 3 }),
     };
 
-    var state_machine = try StateMachine.init(allocator, accounts.len, transfers_max, commits_max);
+    var state_machine = try StateMachine.init(allocator, accounts_max, transfers_max, commits_max);
     defer state_machine.deinit();
 
     const input = std.mem.asBytes(&accounts);
@@ -774,7 +792,8 @@ test "linked accounts" {
 test "create/lookup/rollback transfers" {
     var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
     defer arena.deinit();
-    const allocator = &arena.allocator;
+
+    const allocator = arena.allocator();
 
     var accounts = [_]Account{
         std.mem.zeroInit(Account, .{ .id = 1 }),
@@ -795,10 +814,12 @@ test "create/lookup/rollback transfers" {
 
     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 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 };
@@ -1088,7 +1109,8 @@ test "create/lookup/rollback transfers" {
 test "create/lookup/rollback commits" {
     var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
     defer arena.deinit();
-    const allocator = &arena.allocator;
+
+    const allocator = arena.allocator();
 
     const Vector = struct { result: CommitTransferResult, object: Commit };
 
@@ -1171,10 +1193,13 @@ test "create/lookup/rollback commits" {
     // 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]);
+    {
+        const errors = std.mem.bytesAsSlice(CreateAccountsResult, output[0..size]);
+        try testing.expectEqual(@as(usize, 0), errors.len);
+    }
 
-    for (accounts) |account, i| {
-        try testing.expectEqual(accounts[i], state_machine.get_account(accounts[i].id).?.*);
+    for (accounts) |account| {
+        try testing.expectEqual(account, state_machine.get_account(account.id).?.*);
     }
 
     // Transfers:
@@ -1182,11 +1207,17 @@ test "create/lookup/rollback commits" {
     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]);
+    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, i| {
-        try testing.expectEqual(transfers[i], state_machine.get_transfer(transfers[i].id).?.*);
+    for (transfers) |transfer| {
+        try testing.expectEqual(transfer, state_machine.get_transfer(transfer.id).?.*);
     }
 
     // Commits: