tigerbeetle-node 0.11.8 → 0.11.10

package/src/tigerbeetle/src/vsr/superblock_quorums_fuzz.zig

@@ -3,10 +3,10 @@ const assert = std.debug.assert;
 const log = std.log.scoped(.fuzz_vsr_superblock_quorums);
 
 const superblock = @import("./superblock.zig");
-const SuperBlockSector = superblock.SuperBlockSector;
+const SuperBlockHeader = superblock.SuperBlockHeader;
 const SuperBlockVersion = superblock.SuperBlockVersion;
 
-const fuzz = @import("../test/fuzz.zig");
+const fuzz = @import("../testing/fuzz.zig");
 const superblock_quorums = @import("superblock_quorums.zig");
 const QuorumsType = superblock_quorums.QuorumsType;
 
@@ -21,7 +21,7 @@ pub fn main() !void {
     try fuzz_quorums_working(prng.random());
 
     try fuzz_quorum_repairs(prng.random(), .{ .superblock_copies = 4 });
-    // TODO: Enable these once SuperBlockSector is generic over its Constants.
+    // TODO: Enable these once SuperBlockHeader is generic over its Constants.
     // try fuzz_quorum_repairs(prng.random(), .{ .superblock_copies = 6 });
     // try fuzz_quorum_repairs(prng.random(), .{ .superblock_copies = 8 });
 }
@@ -108,18 +108,18 @@ fn test_quorums_working(
     const Quorums = QuorumsType(.{ .superblock_copies = 4 });
     const misdirect = random.boolean(); // true:cluster false:replica
     var quorums: Quorums = undefined;
-    var sectors: [4]SuperBlockSector = undefined;
+    var headers: [4]SuperBlockHeader = undefined;
     // TODO(Zig): Ideally this would be a [6]?u128 and the access would be
     // "checksums[i] orelse random.int(u128)", but that currently causes the compiler to segfault
     // during code generation.
     var checksums: [6]u128 = undefined;
     for (checksums) |*c| c.* = random.int(u128);
 
-    // Create sectors in ascending-sequence order to build the checksum/parent hash chain.
+    // Create headers in ascending-sequence order to build the checksum/parent hash chain.
     std.sort.sort(CopyTemplate, copies, {}, CopyTemplate.less_than);
 
-    for (sectors) |*sector, i| {
-        sector.* = std.mem.zeroInit(SuperBlockSector, .{
+    for (headers) |*header, i| {
+        header.* = std.mem.zeroInit(SuperBlockHeader, .{
             .copy = @intCast(u8, i),
             .version = SuperBlockVersion,
             .replica = 1,
@@ -131,32 +131,32 @@ fn test_quorums_working(
         var checksum: ?u128 = null;
         switch (copies[i].variant) {
             .valid => {},
-            .valid_high_copy => sector.copy = 4,
+            .valid_high_copy => header.copy = 4,
             .invalid_broken => {
                 if (random.boolean() and i > 0) {
-                    // Error: duplicate sector (if available).
-                    sector.* = sectors[random.uintLessThanBiased(usize, i)];
+                    // Error: duplicate header (if available).
+                    header.* = headers[random.uintLessThanBiased(usize, i)];
                     checksum = random.int(u128);
                 } else {
                     // Error: invalid checksum.
                     checksum = random.int(u128);
                 }
             },
-            .invalid_fork => sector.storage_size_max += 1, // Ensure we have a different checksum.
-            .invalid_parent => sector.parent += 1,
+            .invalid_fork => header.storage_size_max += 1, // Ensure we have a different checksum.
+            .invalid_parent => header.parent += 1,
             .invalid_misdirect => {
                 if (misdirect) {
-                    sector.cluster += 1;
+                    header.cluster += 1;
                 } else {
-                    sector.replica += 1;
+                    header.replica += 1;
                 }
             },
-            .invalid_vsr_state => sector.vsr_state.view += 1,
+            .invalid_vsr_state => header.vsr_state.view += 1,
         }
-        sector.checksum = checksum orelse sector.calculate_checksum();
+        header.checksum = checksum orelse header.calculate_checksum();
 
         if (copies[i].variant == .valid or copies[i].variant == .invalid_vsr_state) {
-            checksums[sector.sequence] = sector.checksum;
+            checksums[header.sequence] = header.checksum;
         }
     }
 
@@ -165,7 +165,7 @@ fn test_quorums_working(
     } else {
         // Shuffling copies can only change the working quorum when we have a corrupt copy index,
         // because we guess that the true index is the slot.
-        random.shuffle(SuperBlockSector, &sectors);
+        random.shuffle(SuperBlockHeader, &headers);
     }
 
     const threshold = switch (threshold_count) {
@@ -175,8 +175,8 @@ fn test_quorums_working(
     };
     assert(threshold.count() == threshold_count);
 
-    if (quorums.working(&sectors, threshold)) |working| {
-        try std.testing.expectEqual(result, working.sector.sequence);
+    if (quorums.working(&headers, threshold)) |working| {
+        try std.testing.expectEqual(result, working.header.sequence);
     } else |err| {
         try std.testing.expectEqual(result, err);
     }
@@ -238,7 +238,7 @@ pub const CopyTemplate = struct {
     }
 };
 
-// Verify that a torn sector write during repair never compromises the existing quorum.
+// Verify that a torn header write during repair never compromises the existing quorum.
 pub fn fuzz_quorum_repairs(
     random: std.rand.Random,
     comptime options: superblock_quorums.Options,
@@ -249,66 +249,66 @@ pub fn fuzz_quorum_repairs(
     var q1: Quorums = undefined;
     var q2: Quorums = undefined;
 
-    const sectors_valid = blk: {
-        var sectors: [superblock_copies]SuperBlockSector = undefined;
-        for (&sectors) |*sector, i| {
-            sector.* = std.mem.zeroInit(SuperBlockSector, .{
+    const headers_valid = blk: {
+        var headers: [superblock_copies]SuperBlockHeader = undefined;
+        for (&headers) |*header, i| {
+            header.* = std.mem.zeroInit(SuperBlockHeader, .{
                 .copy = @intCast(u8, i),
                 .version = SuperBlockVersion,
                 .replica = 1,
                 .storage_size_max = superblock.data_file_size_min,
                 .sequence = 123,
             });
-            sector.set_checksum();
+            header.set_checksum();
         }
-        break :blk sectors;
+        break :blk headers;
     };
 
-    const sector_invalid = blk: {
-        var sector = sectors_valid[0];
-        sector.checksum = 456;
-        break :blk sector;
+    const header_invalid = blk: {
+        var header = headers_valid[0];
+        header.checksum = 456;
+        break :blk header;
     };
 
     // Generate a random valid 2/4 quorum.
-    // 1 bits indicate valid sectors.
-    // 0 bits indicate invalid sectors.
+    // 1 bits indicate valid headers.
+    // 0 bits indicate invalid headers.
     var valid = std.bit_set.IntegerBitSet(superblock_copies).initEmpty();
     while (valid.count() < Quorums.Threshold.open.count() or random.boolean()) {
         valid.set(random.uintLessThan(usize, superblock_copies));
     }
 
-    var working_sectors: [superblock_copies]SuperBlockSector = undefined;
-    for (&working_sectors) |*sector, i| {
-        sector.* = if (valid.isSet(i)) sectors_valid[i] else sector_invalid;
+    var working_headers: [superblock_copies]SuperBlockHeader = undefined;
+    for (&working_headers) |*header, i| {
+        header.* = if (valid.isSet(i)) headers_valid[i] else header_invalid;
     }
-    random.shuffle(SuperBlockSector, &working_sectors);
-    var repair_sectors = working_sectors;
+    random.shuffle(SuperBlockHeader, &working_headers);
+    var repair_headers = working_headers;
 
-    const working_quorum = q1.working(&working_sectors, .open) catch unreachable;
+    const working_quorum = q1.working(&working_headers, .open) catch unreachable;
     var quorum_repairs = working_quorum.repairs();
     while (quorum_repairs.next()) |repair_copy| {
         {
-            // Simulate a torn sector write, crash, recover sequence.
-            var damaged_sectors = repair_sectors;
-            damaged_sectors[repair_copy] = sector_invalid;
-            const damaged_quorum = q2.working(&damaged_sectors, .open) catch unreachable;
-            assert(damaged_quorum.sector.checksum == working_quorum.sector.checksum);
+            // Simulate a torn header write, crash, recover sequence.
+            var damaged_headers = repair_headers;
+            damaged_headers[repair_copy] = header_invalid;
+            const damaged_quorum = q2.working(&damaged_headers, .open) catch unreachable;
+            assert(damaged_quorum.header.checksum == working_quorum.header.checksum);
         }
 
         // "Finish" the write so that we can test the next repair.
-        repair_sectors[repair_copy] = sectors_valid[repair_copy];
+        repair_headers[repair_copy] = headers_valid[repair_copy];
 
-        const quorum_repaired = q2.working(&repair_sectors, .open) catch unreachable;
-        assert(quorum_repaired.sector.checksum == working_quorum.sector.checksum);
+        const quorum_repaired = q2.working(&repair_headers, .open) catch unreachable;
+        assert(quorum_repaired.header.checksum == working_quorum.header.checksum);
     }
 
     // At the end of all repairs, we expect to have every copy of the superblock.
     // They do not need to be in their home slot.
     var copies = Quorums.QuorumCount.initEmpty();
-    for (repair_sectors) |repair_sector| {
-        assert(repair_sector.checksum == working_quorum.sector.checksum);
-        copies.set(repair_sector.copy);
+    for (repair_headers) |repair_header| {
+        assert(repair_header.checksum == working_quorum.header.checksum);
+        copies.set(repair_header.copy);
     }
-    assert(repair_sectors.len == copies.count());
+    assert(repair_headers.len == copies.count());
 }

package/src/tigerbeetle/src/vsr.zig

@@ -17,6 +17,7 @@ pub const tigerbeetle = @import("tigerbeetle.zig");
 pub const time = @import("time.zig");
 pub const tracer = @import("tracer.zig");
 pub const config = @import("config.zig");
+pub const stdx = @import("stdx.zig");
 pub const superblock = @import("vsr/superblock.zig");
 pub const lsm = .{
     .tree = @import("lsm/tree.zig"),
@@ -25,6 +26,9 @@ pub const lsm = .{
     .forest = @import("lsm/forest.zig"),
     .posted_groove = @import("lsm/posted_groove.zig"),
 };
+pub const testing = .{
+    .cluster = @import("testing/cluster.zig"),
+};
 
 pub const ReplicaType = @import("vsr/replica.zig").ReplicaType;
 pub const format = @import("vsr/replica_format.zig").format;
@@ -34,7 +38,7 @@ pub const Clock = @import("vsr/clock.zig").Clock;
 pub const JournalType = @import("vsr/journal.zig").JournalType;
 pub const SlotRange = @import("vsr/journal.zig").SlotRange;
 pub const SuperBlockType = superblock.SuperBlockType;
-pub const VSRState = superblock.SuperBlockSector.VSRState;
+pub const VSRState = superblock.SuperBlockHeader.VSRState;
 
 /// The version of our Viewstamped Replication protocol in use, including customizations.
 /// For backwards compatibility through breaking changes (e.g. upgrading checksums/ciphers).
@@ -102,9 +106,6 @@ pub const Command = enum(u8) {
     do_view_change,
     start_view,
 
-    recovery,
-    recovery_response,
-
     request_start_view,
     request_headers,
     request_prepare,
@@ -319,8 +320,6 @@ pub const Header = extern struct {
             .start_view_change => self.invalid_start_view_change(),
             .do_view_change => self.invalid_do_view_change(),
             .start_view => self.invalid_start_view(),
-            .recovery => self.invalid_recovery(),
-            .recovery_response => self.invalid_recovery_response(),
             .request_start_view => self.invalid_request_start_view(),
             .request_headers => self.invalid_request_headers(),
             .request_prepare => self.invalid_request_prepare(),
@@ -523,29 +522,6 @@ pub const Header = extern struct {
         return null;
     }
 
-    fn invalid_recovery(self: *const Header) ?[]const u8 {
-        assert(self.command == .recovery);
-        if (self.parent != 0) return "parent != 0";
-        if (self.client != 0) return "client != 0";
-        if (self.request != 0) return "request != 0";
-        if (self.view != 0) return "view != 0";
-        if (self.op != 0) return "op != 0";
-        if (self.commit != 0) return "commit != 0";
-        if (self.timestamp != 0) return "timestamp != 0";
-        if (self.operation != .reserved) return "operation != .reserved";
-        return null;
-    }
-
-    fn invalid_recovery_response(self: *const Header) ?[]const u8 {
-        assert(self.command == .recovery_response);
-        if (self.parent != 0) return "parent != 0";
-        if (self.client != 0) return "client != 0";
-        if (self.request != 0) return "request != 0";
-        if (self.timestamp != 0) return "timestamp != 0";
-        if (self.operation != .reserved) return "operation != .reserved";
-        return null;
-    }
-
     fn invalid_request_start_view(self: *const Header) ?[]const u8 {
         assert(self.command == .request_start_view);
         if (self.parent != 0) return "parent != 0";
@@ -826,8 +802,6 @@ pub fn exponential_backoff_with_jitter(
 }
 
 test "exponential_backoff_with_jitter" {
-    const testing = std.testing;
-
     var prng = std.rand.DefaultPrng.init(0);
     const random = prng.random();
 
@@ -838,8 +812,8 @@ test "exponential_backoff_with_jitter" {
     var attempt = max - attempts;
     while (attempt < max) : (attempt += 1) {
         const ebwj = exponential_backoff_with_jitter(random, min, max, attempt);
-        try testing.expect(ebwj >= min);
-        try testing.expect(ebwj <= max);
+        try std.testing.expect(ebwj >= min);
+        try std.testing.expect(ebwj <= max);
     }
 }
 
@@ -1024,3 +998,95 @@ pub fn quorums(replica_count: u8) struct {
         .view_change = quorum_view_change,
     };
 }
+
+/// The SuperBlock's persisted VSR headers.
+/// One of the following:
+///
+/// - SV headers (consecutive chain)
+/// - DVC headers (disjoint chain)
+pub const ViewChangeHeaders = struct {
+    /// Headers are ordered from high-to-low op.
+    slice: []const Header,
+
+    pub const BoundedArray = std.BoundedArray(Header, constants.pipeline_prepare_queue_max);
+
+    pub fn init(slice: []const Header) ViewChangeHeaders {
+        ViewChangeHeaders.verify(slice);
+
+        return .{ .slice = slice };
+    }
+
+    pub fn verify(slice: []const Header) void {
+        assert(slice.len > 0);
+        assert(slice.len <= constants.pipeline_prepare_queue_max);
+
+        var child: ?*const Header = null;
+        for (slice) |*header| {
+            assert(header.valid_checksum());
+            assert(header.command == .prepare);
+
+            if (child) |child_header| {
+                assert(header.op < child_header.op);
+                assert(header.view <= child_header.view);
+                assert((header.op + 1 == child_header.op) ==
+                    (header.checksum == child_header.parent));
+                assert(header.timestamp < child_header.timestamp);
+            }
+            child = header;
+        }
+    }
+
+    const ViewRange = struct {
+        min: u32, // inclusive
+        max: u32, // inclusive
+
+        pub fn contains(range: ViewRange, view: u32) bool {
+            return range.min <= view and view <= range.max;
+        }
+    };
+
+    /// Returns the range of possible views (of prepare, not commit) for a message that is part of
+    /// the same log_view as these headers.
+    ///
+    /// - When these are DVC headers for a log_view=V, we must be in view_change status working to
+    ///   transition to a view beyond V. So we will never prepare anything else as part of view V.
+    /// - When these are SV headers for a log_view=V, we can continue to add to them (by preparing
+    ///   more ops), but those ops will laways be part of the log_view. If they were prepared during
+    ///   a view prior to the log_view, they would already be part of the headers.
+    pub fn view_for_op(headers: ViewChangeHeaders, op: u64, log_view: u32) ViewRange {
+        const header_newest = &headers.slice[0];
+        const header_oldest = &headers.slice[headers.slice.len - 1];
+
+        if (op < header_oldest.op) return .{ .min = 0, .max = header_oldest.view };
+        if (op > header_newest.op) return .{ .min = log_view, .max = log_view };
+
+        for (headers.slice) |*header| {
+            if (header.op == op) return .{ .min = header.view, .max = header.view };
+        }
+
+        for (headers.slice[0 .. headers.slice.len - 1]) |*header_next, header_next_index| {
+            const header_prev = headers.slice[header_next_index + 1];
+            if (header_prev.op < op and op < header_next.op) {
+                return .{ .min = header_prev.view, .max = header_next.view };
+            }
+        }
+        unreachable;
+    }
+};
+
+test "ViewChangeHeaders.view_for_op" {
+    var headers_array = [_]Header{
+        std.mem.zeroInit(Header, .{ .op = 9, .view = 10 }),
+        std.mem.zeroInit(Header, .{ .op = 6, .view = 7 }),
+    };
+
+    const headers = ViewChangeHeaders{ .slice = &headers_array };
+    try std.testing.expect(std.meta.eql(headers.view_for_op(11, 12), .{ .min = 12, .max = 12 }));
+    try std.testing.expect(std.meta.eql(headers.view_for_op(10, 12), .{ .min = 12, .max = 12 }));
+    try std.testing.expect(std.meta.eql(headers.view_for_op(9, 12), .{ .min = 10, .max = 10 }));
+    try std.testing.expect(std.meta.eql(headers.view_for_op(8, 12), .{ .min = 7, .max = 10 }));
+    try std.testing.expect(std.meta.eql(headers.view_for_op(7, 12), .{ .min = 7, .max = 10 }));
+    try std.testing.expect(std.meta.eql(headers.view_for_op(6, 12), .{ .min = 7, .max = 7 }));
+    try std.testing.expect(std.meta.eql(headers.view_for_op(5, 12), .{ .min = 0, .max = 7 }));
+    try std.testing.expect(std.meta.eql(headers.view_for_op(0, 12), .{ .min = 0, .max = 7 }));
+}

package/src/tigerbeetle/src/demo.zig

@@ -1,132 +0,0 @@
-const std = @import("std");
-const assert = std.debug.assert;
-
-const constants = @import("constants.zig");
-
-const tb = @import("tigerbeetle.zig");
-const Account = tb.Account;
-const Transfer = tb.Transfer;
-
-const CreateAccountsResult = tb.CreateAccountsResult;
-const CreateTransfersResult = tb.CreateTransfersResult;
-
-const util = @import("util.zig");
-const IO = @import("io.zig").IO;
-const Storage = @import("storage.zig").Storage;
-const MessagePool = @import("message_pool.zig").MessagePool;
-const MessageBus = @import("message_bus.zig").MessageBusClient;
-const StateMachine = @import("state_machine.zig").StateMachineType(Storage, .{
-    .message_body_size_max = constants.message_body_size_max,
-});
-
-const vsr = @import("vsr.zig");
-const Header = vsr.Header;
-const Client = vsr.Client(StateMachine, MessageBus);
-
-pub const log_level: std.log.Level = .alert;
-
-pub fn request(
-    operation: StateMachine.Operation,
-    batch: anytype,
-    on_reply: fn (
-        user_data: u128,
-        operation: StateMachine.Operation,
-        results: Client.Error![]const u8,
-    ) void,
-) !void {
-    const allocator = std.heap.page_allocator;
-    const client_id = std.crypto.random.int(u128);
-    const cluster_id: u32 = 0;
-    var addresses = [_]std.net.Address{try std.net.Address.parseIp4("127.0.0.1", constants.port)};
-
-    var io = try IO.init(32, 0);
-    defer io.deinit();
-
-    var message_pool = try MessagePool.init(allocator, .client);
-    defer message_pool.deinit(allocator);
-
-    var client = try Client.init(
-        allocator,
-        client_id,
-        cluster_id,
-        @intCast(u8, addresses.len),
-        &message_pool,
-        .{
-            .configuration = &addresses,
-            .io = &io,
-        },
-    );
-    defer client.deinit(allocator);
-
-    const message = client.get_message();
-    defer client.unref(message);
-
-    const body = std.mem.asBytes(&batch);
-    util.copy_disjoint(.inexact, u8, message.buffer[@sizeOf(Header)..], body);
-
-    client.request(
-        0,
-        on_reply,
-        operation,
-        message,
-        body.len,
-    );
-
-    while (client.request_queue.count > 0) {
-        client.tick();
-        try io.run_for_ns(constants.tick_ms * std.time.ns_per_ms);
-    }
-}
-
-pub fn on_create_accounts(
-    user_data: u128,
-    operation: StateMachine.Operation,
-    results: Client.Error![]const u8,
-) void {
-    _ = user_data;
-    _ = operation;
-
-    print_results(CreateAccountsResult, results);
-}
-
-pub fn on_lookup_accounts(
-    user_data: u128,
-    operation: StateMachine.Operation,
-    results: Client.Error![]const u8,
-) void {
-    _ = user_data;
-    _ = operation;
-
-    print_results(Account, results);
-}
-
-pub fn on_lookup_transfers(
-    user_data: u128,
-    operation: StateMachine.Operation,
-    results: Client.Error![]const u8,
-) void {
-    _ = user_data;
-    _ = operation;
-
-    print_results(Transfer, results);
-}
-
-pub fn on_create_transfers(
-    user_data: u128,
-    operation: StateMachine.Operation,
-    results: Client.Error![]const u8,
-) void {
-    _ = user_data;
-    _ = operation;
-
-    print_results(CreateTransfersResult, results);
-}
-
-fn print_results(comptime Results: type, results: Client.Error![]const u8) void {
-    const body = results catch unreachable;
-    const slice = std.mem.bytesAsSlice(Results, body);
-    for (slice) |result| {
-        std.debug.print("{}\n", .{result});
-    }
-    if (slice.len == 0) std.debug.print("OK\n", .{});
-}

package/src/tigerbeetle/src/demo_01_create_accounts.zig

@@ -1,35 +0,0 @@
-const tb = @import("tigerbeetle.zig");
-const demo = @import("demo.zig");
-
-const Account = tb.Account;
-
-pub fn main() !void {
-    const accounts = [_]Account{
-        Account{
-            .id = 1,
-            .user_data = 0,
-            .reserved = [_]u8{0} ** 48,
-            .ledger = 710, // Let's use the ISO-4217 Code Number for ZAR
-            .code = 1000, // A chart of accounts code to describe this as a clearing account.
-            .flags = .{ .debits_must_not_exceed_credits = true },
-            .debits_pending = 0,
-            .debits_posted = 0,
-            .credits_pending = 0,
-            .credits_posted = 0,
-        },
-        Account{
-            .id = 2,
-            .user_data = 0,
-            .reserved = [_]u8{0} ** 48,
-            .ledger = 710, // Let's use the ISO-4217 Code Number for ZAR
-            .code = 2000, // A chart of accounts code to describe this as a payable account.
-            .flags = .{},
-            .debits_pending = 0,
-            .debits_posted = 0,
-            .credits_pending = 0,
-            .credits_posted = 0,
-        },
-    };
-
-    try demo.request(.create_accounts, accounts, demo.on_create_accounts);
-}

package/src/tigerbeetle/src/demo_02_lookup_accounts.zig

@@ -1,7 +0,0 @@
-const demo = @import("demo.zig");
-
-pub fn main() !void {
-    const ids = [_]u128{ 1, 2 };
-
-    try demo.request(.lookup_accounts, ids, demo.on_lookup_accounts);
-}

package/src/tigerbeetle/src/demo_03_create_transfers.zig

@@ -1,37 +0,0 @@
-const tb = @import("tigerbeetle.zig");
-const demo = @import("demo.zig");
-
-const Transfer = tb.Transfer;
-
-pub fn main() !void {
-    const transfers = [_]Transfer{
-        Transfer{
-            .id = 1,
-            .debit_account_id = 2,
-            .credit_account_id = 1,
-            .user_data = 0,
-            .reserved = 0,
-            .pending_id = 0,
-            .timeout = 0,
-            .ledger = 710, // Let's use the ISO-4217 Code Number for ZAR
-            .code = 1,
-            .flags = .{},
-            .amount = 10000, // Let's start with some liquidity in account 1.
-        },
-        Transfer{
-            .id = 2,
-            .debit_account_id = 1,
-            .credit_account_id = 2,
-            .user_data = 0,
-            .reserved = 0,
-            .pending_id = 0,
-            .timeout = 0,
-            .ledger = 710, // Let's use the ISO-4217 Code Number for ZAR
-            .code = 1,
-            .flags = .{},
-            .amount = 1000,
-        },
-    };
-
-    try demo.request(.create_transfers, transfers, demo.on_create_transfers);
-}

package/src/tigerbeetle/src/demo_04_create_pending_transfers.zig

@@ -1,61 +0,0 @@
-const std = @import("std");
-
-const tb = @import("tigerbeetle.zig");
-const demo = @import("demo.zig");
-
-const Transfer = tb.Transfer;
-
-pub fn main() !void {
-    const transfers = [_]Transfer{
-        Transfer{
-            .id = 1001,
-            .debit_account_id = 1,
-            .credit_account_id = 2,
-            .user_data = 0,
-            .reserved = 0,
-            .pending_id = 0,
-            .timeout = std.time.ns_per_hour,
-            .ledger = 710,
-            .code = 1,
-            .flags = .{
-                .pending = true, // Set this transfer to be two-phase.
-            },
-            .amount = 8000,
-        },
-        Transfer{
-            .id = 1002,
-            .debit_account_id = 1,
-            .credit_account_id = 2,
-            .user_data = 0,
-            .reserved = 0,
-            .pending_id = 0,
-            .timeout = std.time.ns_per_hour,
-            .ledger = 710,
-            .code = 1,
-            .flags = .{
-                .pending = true, // Set this transfer to be two-phase.
-                .linked = true, // Link this transfer with the next transfer 1003.
-            },
-            .amount = 500,
-        },
-        Transfer{
-            .id = 1003,
-            .debit_account_id = 1,
-            .credit_account_id = 2,
-            .user_data = 0,
-            .reserved = 0,
-            .pending_id = 0,
-            .timeout = std.time.ns_per_hour,
-            .ledger = 710,
-            .code = 1,
-            .flags = .{
-                .pending = true, // Set this transfer to be two-phase.
-                // The last transfer in a linked chain has .linked set to false to close the chain.
-                // This transfer will succeed or fail together with transfer 1002 above.
-            },
-            .amount = 500,
-        },
-    };
-
-    try demo.request(.create_transfers, transfers, demo.on_create_transfers);
-}