tiny.peer.TicketStorage

1pub const TicketStorage = struct {2    pub const storage_alignment: usize = @alignOf(Address);3    pub const Storage = []align(storage_alignment) u8;4    pub const Limits: type = TicketLimits;5    pub const Capacity: type = TicketCapacity;6    pub const Exhaustion = error{TooManyAddresses};7    pub const InitError = TicketCapacity.DeriveError || error{StorageTooShort};8    pub const work_limits: alloc_phase.capacity.WorkLimits = .{9        .transition_steps_max = 1,10        .cleanup_steps_per_call_max = 0,11        .cleanup_calls_at_capacity_max = 0,12    };1314    pub const claim: alloc_phase.capacity.Declaration = .{15        .source = .{16            .id = "peer.bootstrap_ticket",17            .kind = .phase_static,18            .limit_source = .caller,19            .storage = .{20                .covered = &.{.{21                    .id = "caller_bootstrap_address_slots",22                    .lifetime = .transferred,23                    .detail = "caller address slots including inline relay host bytes",24                }},25                .excluded = &.{26                    "fixed peer identifier, count, capacity, and phase fields",27                    "caller-owned wire, text, and codec scratch buffers",28                },29            },30            .capacity = .{31                .inputs = &.{32                    alloc_phase.capacity.bindInput(33                        TicketLimits,34                        "max_addresses",35                        "max_addresses",36                    ),37                },38                .type_selectors = &.{39                    alloc_phase.capacity.bindType(Address, "address"),40                },41                .nodes = &.{42                    .{ .input = 0 },43                    .{ .scale = .{44                        .node = 0,45                        .coefficient = .{ .size_of_concrete_type = 0 },46                    } },47                },48                .assertions = &.{.{49                    .scope = .closure_total,50                    .measure = .retained,51                    .relation = .exact,52                    .expression = 1,53                }},54            },55            .overload = .{56                .kind = .reject_before_mutation,57                .detail = "max-plus-one address admission rejects before storage mutation",58            },59            .risks = .{60                .transitive = .{61                    .status = .witnessed,62                    .detail = "ticket codecs and admission use caller slices and value operations",63                },64                .foreign = .{65                    .status = .excluded,66                    .detail = "ticket storage crosses no operating-system or foreign boundary",67                },68            },69            .work = .{70                .equation = "activate <= 1 and codec steps <= max_addresses",71            },72            .obligations = &.{73                .{ .key = "peer_ticket_capacity", .role = .capacity_model },74                .{ .key = "peer_ticket_overload", .role = .overload },75                .{ .key = "peer_ticket_transitive", .role = .transitive_risk },76                .{ .key = "peer_ticket_work", .role = .work_bound },77            },78        },79        .bindings = .{80            .owner = @This(),81            .seal = .{82                .family = alloc_phase.capacity.selector(@This().activate),83                .premise = .{84                    .class = .checked_semantic_fact,85                    .authority = .checker,86                },87            },88            .teardown = .{89                .family = alloc_phase.capacity.selector(@This().deinit),90                .premise = .{91                    .class = .checked_semantic_fact,92                    .authority = .checker,93                },94            },95        },96    };9798    phase: alloc_phase.capacity.Phase,99    capacity: TicketCapacity,100    storage: Storage,101    address_count: u8,102103    pub fn init(bytes: Storage, limits: TicketLimits) InitError!TicketStorage {104        const capacity = try TicketCapacity.derive(limits);105        if (bytes.len < capacity.storage_bytes) return error.StorageTooShort;106        return .{107            .phase = .initialization,108            .capacity = capacity,109            .storage = bytes[0..capacity.storage_bytes],110            .address_count = 0,111        };112    }113114    pub fn activate(self: *TicketStorage) void {115        std.debug.assert(self.phase == .initialization);116        self.phase = .steady;117    }118119    pub fn append(self: *TicketStorage, address: Address) Exhaustion!void {120        self.assertSteady();121        if (self.address_count >= self.capacity.max_addresses) {122            return error.TooManyAddresses;123        }124        self.slots()[self.address_count] = address;125        self.address_count += 1;126    }127128    pub fn items(self: *const TicketStorage) []const Address {129        self.assertSteady();130        const pointer: [*]const Address = @ptrCast(self.storage.ptr);131        return pointer[0..self.address_count];132    }133134    pub fn deinit(self: *TicketStorage) Storage {135        std.debug.assert(self.phase == .steady);136        self.phase = .teardown;137        const bytes = self.storage;138        self.* = undefined;139        return bytes;140    }141142    fn slots(self: *TicketStorage) []Address {143        self.assertSteady();144        const pointer: [*]Address = @ptrCast(self.storage.ptr);145        return pointer[0..self.capacity.max_addresses];146    }147148    fn assertSteady(self: *const TicketStorage) void {149        std.debug.assert(self.phase == .steady);150        std.debug.assert(self.address_count <= self.capacity.max_addresses);151        std.debug.assert(self.storage.len == self.capacity.storage_bytes);152    }153};

1pub const TicketStorage = ticket.TicketStorage;