fix: resolve tree view API conflicts from cherry-pick

After cherry-picking "feat: tree view state (#168)", SSZ tree view conflicts
were resolved by keeping "ours", which lost new API functions the
state_transition code depends on. This commit adds back the missing APIs
and fixes all callers.

Key changes:
- Add missing tree view APIs: hashTreeRoot, fromValue, toValue, getReadonly,
  getValue, setValue, getFieldRoot, iteratorReadonly across container,
  array_basic, array_composite, list_basic, list_composite, bit_vector
- Fix CompositeChunks.get() to always mark changed (fixes attester_slashing
  failures where getReadonly cached a child without tracking, then get()
  returned the cached entry without marking it changed)
- Fix CompositeChunks.getAllValuesInto() to initialize variable-type values
  before toValue (fixes segfault from uninitialized BitList fields)
- Fix pointer type mismatches (*TreeView vs **TreeView) across callers
- Fix beacon_state field name bugs and return type mismatches
- Add @setEvalBranchQuota(20000) for comptime iteration over BeaconState

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: twoeths

src/ssz/root.zig

@@ -46,6 +46,7 @@ pub const ArrayBasicTreeView = tree_view.ArrayBasicTreeView;
 pub const ArrayCompositeTreeView = tree_view.ArrayCompositeTreeView;
 pub const ListBasicTreeView = tree_view.ListBasicTreeView;
 pub const ListCompositeTreeView = tree_view.ListCompositeTreeView;
+pub const CloneOpts = @import("tree_view/utils/clone_opts.zig").CloneOpts;
 
 test {
     testing.refAllDecls(@This());

src/ssz/tree_view/array_basic.zig

@@ -72,11 +72,27 @@ pub fn ArrayBasicTreeView(comptime ST: type) type {
             self.chunks.clearCache();
         }
 
-        pub fn hashTreeRoot(self: *Self, out: *[32]u8) !void {
+        pub fn hashTreeRootInto(self: *Self, out: *[32]u8) !void {
             try self.commit();
             out.* = self.chunks.root.getRoot(self.chunks.pool).*;
         }
 
+        pub fn hashTreeRoot(self: *Self) !*const [32]u8 {
+            try self.commit();
+            return self.chunks.root.getRoot(self.chunks.pool);
+        }
+
+        pub fn fromValue(allocator: Allocator, pool: *Node.Pool, value: *const ST.Type) !*Self {
+            const root = try ST.tree.fromValue(pool, value);
+            errdefer pool.unref(root);
+            return try Self.init(allocator, pool, root);
+        }
+
+        pub fn toValue(self: *Self, _: Allocator, out: *ST.Type) !void {
+            try self.commit();
+            try ST.tree.toValue(self.chunks.root, self.chunks.pool, out);
+        }
+
         pub fn getRoot(self: *const Self) Node.Id {
             return self.chunks.root;
         }
@@ -91,8 +107,8 @@ pub fn ArrayBasicTreeView(comptime ST: type) type {
             try self.chunks.set(index, value);
         }
 
-        pub fn getAll(self: *Self) ![]Element {
-            return try self.chunks.getAll(self.allocator, length);
+        pub fn getAll(self: *Self, allocator: ?Allocator) ![]Element {
+            return try self.chunks.getAll(allocator orelse self.allocator, length);
         }
 
         pub fn getAllInto(self: *Self, values: []Element) ![]Element {
@@ -149,7 +165,7 @@ test "TreeView vector element roundtrip" {
     try VectorType.hashTreeRoot(&expected, &expected_root);
 
     var actual_root: [32]u8 = undefined;
-    try view.hashTreeRoot(&actual_root);
+    try view.hashTreeRootInto(&actual_root);
 
     try std.testing.expectEqualSlices(u8, &expected_root, &actual_root);
 
@@ -197,7 +213,7 @@ test "TreeView vector getAllAlloc roundtrip" {
     var view = try VectorType.TreeView.init(allocator, &pool, root_node);
     defer view.deinit();
 
-    const filled = try view.getAll();
+    const filled = try view.getAll(null);
     defer allocator.free(filled);
 
     try std.testing.expectEqualSlices(u16, values[0..], filled);
@@ -216,13 +232,13 @@ test "TreeView vector getAllAlloc repeat reflects updates" {
     var view = try VectorType.TreeView.init(allocator, &pool, root_node);
     defer view.deinit();
 
-    const first = try view.getAll();
+    const first = try view.getAll(null);
     defer allocator.free(first);
     try std.testing.expectEqualSlices(u32, values[0..], first);
 
     try view.set(3, 99);
 
-    const second = try view.getAll();
+    const second = try view.getAll(null);
     defer allocator.free(second);
     values[3] = 99;
     try std.testing.expectEqualSlices(u32, values[0..], second);
@@ -396,7 +412,7 @@ test "ArrayBasicTreeView - serialize (uint64 vector)" {
         try std.testing.expectEqual(tc.expected_serialized.len, view_size);
 
         var hash_root: [32]u8 = undefined;
-        try view.hashTreeRoot(&hash_root);
+        try view.hashTreeRootInto(&hash_root);
         try std.testing.expectEqualSlices(u8, &tc.expected_root, &hash_root);
     }
 }

src/ssz/tree_view/array_composite.zig

@@ -74,11 +74,34 @@ pub fn ArrayCompositeTreeView(comptime ST: type) type {
             self.chunks.clearCache();
         }
 
-        pub fn hashTreeRoot(self: *Self, out: *[32]u8) !void {
+        pub fn hashTreeRootInto(self: *Self, out: *[32]u8) !void {
             try self.commit();
             out.* = self.chunks.root.getRoot(self.chunks.pool).*;
         }
 
+        pub fn hashTreeRoot(self: *Self) !*const [32]u8 {
+            try self.commit();
+            return self.chunks.root.getRoot(self.chunks.pool);
+        }
+
+        pub fn fromValue(allocator: Allocator, pool: *Node.Pool, value: *const ST.Type) !*Self {
+            const root = if (comptime isFixedType(ST))
+                try ST.tree.fromValue(pool, value)
+            else
+                try ST.tree.fromValue(allocator, pool, value);
+            errdefer pool.unref(root);
+            return try Self.init(allocator, pool, root);
+        }
+
+        pub fn toValue(self: *Self, allocator: Allocator, out: *ST.Type) !void {
+            try self.commit();
+            if (comptime isFixedType(ST)) {
+                try ST.tree.toValue(self.chunks.root, self.chunks.pool, out);
+            } else {
+                try ST.tree.toValue(allocator, self.chunks.root, self.chunks.pool, out);
+            }
+        }
+
         pub fn getRoot(self: *const Self) Node.Id {
             return self.chunks.root;
         }
@@ -89,10 +112,25 @@ pub fn ArrayCompositeTreeView(comptime ST: type) type {
         }
 
         pub fn getReadonly(self: *Self, index: usize) !Element {
-            // TODO: Implement read-only access after other PRs land.
-            _ = self;
-            _ = index;
-            return error.NotImplemented;
+            if (index >= length) return error.IndexOutOfBounds;
+            return self.chunks.getReadonly(index);
+        }
+
+        pub fn getValue(self: *Self, allocator: Allocator, index: usize, out: *ST.Element.Type) !void {
+            if (index >= length) return error.IndexOutOfBounds;
+            return self.chunks.getValue(allocator, index, out);
+        }
+
+        pub fn setValue(self: *Self, index: usize, value: *const ST.Element.Type) !void {
+            if (index >= length) return error.IndexOutOfBounds;
+            try self.chunks.setValue(index, value);
+        }
+
+        pub fn getFieldRoot(self: *Self, index: usize) !*const [32]u8 {
+            if (index >= length) return error.IndexOutOfBounds;
+            const elem = try self.chunks.get(index);
+            try elem.commit();
+            return elem.getRoot().getRoot(self.chunks.pool);
         }
 
         pub fn set(self: *Self, index: usize, value: Element) !void {
@@ -101,10 +139,11 @@ pub fn ArrayCompositeTreeView(comptime ST: type) type {
         }
 
         pub fn getAllReadonly(self: *Self, allocator: Allocator) ![]Element {
-            // TODO: Implement bulk read-only access after other PRs land.
-            _ = self;
-            _ = allocator;
-            return error.NotImplemented;
+            return self.chunks.getAllReadonly(allocator, length);
+        }
+
+        pub fn getAllReadonlyValues(self: *Self, allocator: Allocator) ![]ST.Element.Type {
+            return self.chunks.getAllValues(allocator, length);
         }
 
         /// Serialize the tree view into a provided buffer.
@@ -170,7 +209,7 @@ test "TreeView vector composite element set/get/commit" {
     try view.commit();
 
     var actual_root: [32]u8 = undefined;
-    try view.hashTreeRoot(&actual_root);
+    try view.hashTreeRootInto(&actual_root);
 
     var expected: VectorType.Type = .{ v0, replacement };
     var expected_root: [32]u8 = undefined;
@@ -237,7 +276,7 @@ test "TreeView vector composite clearCache does not break subsequent commits" {
     replacement_view = null;
 
     var actual_root: [32]u8 = undefined;
-    try view.hashTreeRoot(&actual_root);
+    try view.hashTreeRootInto(&actual_root);
 
     var expected: VectorType.Type = .{ replacement, v1 };
     var expected_root: [32]u8 = undefined;
@@ -498,7 +537,7 @@ test "ArrayCompositeTreeView - serialize (Container vector)" {
     try std.testing.expectEqualSlices(u8, &expected, &view_serialized);
 
     var hash_root: [32]u8 = undefined;
-    try view.hashTreeRoot(&hash_root);
+    try view.hashTreeRootInto(&hash_root);
     // 0xb1a797eb50654748ba239010edccea7b46b55bf740730b700684f48b0c478372
     const expected_root = [_]u8{ 0xb1, 0xa7, 0x97, 0xeb, 0x50, 0x65, 0x47, 0x48, 0xba, 0x23, 0x90, 0x10, 0xed, 0xcc, 0xea, 0x7b, 0x46, 0xb5, 0x5b, 0xf7, 0x40, 0x73, 0x0b, 0x70, 0x06, 0x84, 0xf4, 0x8b, 0x0c, 0x47, 0x83, 0x72 };
     try std.testing.expectEqualSlices(u8, &expected_root, &hash_root);

src/ssz/tree_view/bit_vector.zig

@@ -81,6 +81,17 @@ pub fn BitVectorTreeView(comptime ST: type) type {
             return try self.data.set(index, value, length);
         }
 
+        pub fn fromValue(allocator: Allocator, pool: *Node.Pool, value: *const ST.Type) !*Self {
+            const root = try ST.tree.fromValue(pool, value);
+            errdefer pool.unref(root);
+            return try Self.init(allocator, pool, root);
+        }
+
+        pub fn toValue(self: *Self, _: Allocator, out: *ST.Type) !void {
+            try self.commit();
+            try ST.tree.toValue(self.data.root, self.data.pool, out);
+        }
+
         /// Caller must free the returned slice.
         pub fn toBoolArray(self: *Self, allocator: Allocator) ![]bool {
             const values = try allocator.alloc(bool, length);

src/ssz/tree_view/chunks.zig

@@ -7,6 +7,8 @@ const Depth = hashing.Depth;
 const Node = @import("persistent_merkle_tree").Node;
 const Gindex = @import("persistent_merkle_tree").Gindex;
 
+const isFixedType = @import("../type/type_kind.zig").isFixedType;
+
 const tree_view_root = @import("root.zig");
 const ChildNodes = @import("utils/child_nodes.zig").ChildNodes;
 const CloneOpts = @import("utils/clone_opts.zig").CloneOpts;
@@ -290,16 +292,16 @@ pub fn CompositeChunks(
 
         pub fn get(self: *Self, index: usize) !ElementPtr {
             const gindex = Gindex.fromDepth(chunk_depth, index);
+            // Always mark as changed - the child may have been previously cached
+            // via getReadonly() without being tracked in changed.
+            try self.changed.put(self.allocator, gindex, {});
             const gop = try self.children_data.getOrPut(self.allocator, gindex);
             if (gop.found_existing) {
                 return gop.value_ptr.*;
             }
             const child_node = try self.getChildNode(gindex);
             const child_ptr = try Element.init(self.allocator, self.pool, child_node);
             gop.value_ptr.* = child_ptr;
-
-            // TODO only update changed if the subview is mutable
-            try self.changed.put(self.allocator, gindex, {});
             return child_ptr;
         }
 
@@ -319,6 +321,97 @@ pub fn CompositeChunks(
             }
         }
 
+        /// Get a child view without tracking changes (read-only access).
+        pub fn getReadonly(self: *Self, index: usize) !ElementPtr {
+            const gindex = Gindex.fromDepth(chunk_depth, index);
+            if (self.children_data.get(gindex)) |child_ptr| {
+                return child_ptr;
+            }
+            const child_node = try self.getChildNode(gindex);
+            const child_ptr = try Element.init(self.allocator, self.pool, child_node);
+            try self.children_data.put(self.allocator, gindex, child_ptr);
+            // Do NOT add to self.changed (read-only)
+            return child_ptr;
+        }
+
+        /// Get all child views without tracking changes (read-only).
+        pub fn getAllReadonly(self: *Self, allocator: Allocator, len: usize) ![]ElementPtr {
+            const views = try allocator.alloc(ElementPtr, len);
+            errdefer allocator.free(views);
+            for (0..len) |i| {
+                views[i] = try self.getReadonly(i);
+            }
+            return views;
+        }
+
+        pub const Value = ST.Element.Type;
+
+        /// Get a child value as an SSZ value type.
+        pub fn getValue(self: *Self, allocator: Allocator, index: usize, out: *Value) !void {
+            var child_view = try self.getReadonly(index);
+            if (comptime isFixedType(ST.Element)) {
+                try child_view.toValue(undefined, out);
+            } else {
+                try child_view.toValue(allocator, out);
+            }
+        }
+
+        /// Set a child from an SSZ value type.
+        pub fn setValue(self: *Self, index: usize, value: *const Value) !void {
+            const root = try ST.Element.tree.fromValue(self.pool, value);
+            errdefer self.pool.unref(root);
+            const child_view = try Element.init(self.allocator, self.pool, root);
+            errdefer child_view.deinit();
+            try self.set(index, child_view);
+        }
+
+        /// Get all element values in a single traversal.
+        /// Caller owns the returned slice and must free it with the same allocator.
+        pub fn getAllValues(self: *Self, allocator: Allocator, len: usize) ![]Value {
+            const values = try allocator.alloc(Value, len);
+            errdefer allocator.free(values);
+            return try self.getAllValuesInto(allocator, values);
+        }
+
+        /// Fills `values` with all element values.
+        pub fn getAllValuesInto(self: *Self, allocator: Allocator, values: []Value) ![]Value {
+            const len = values.len;
+            if (len == 0) return values;
+
+            if (self.changed.count() != 0) {
+                return error.MustCommitBeforeBulkRead;
+            }
+
+            const nodes = try allocator.alloc(Node.Id, len);
+            defer allocator.free(nodes);
+
+            try self.root.getNodesAtDepth(self.pool, chunk_depth, 0, nodes);
+
+            for (nodes, 0..) |node, i| {
+                if (comptime @hasDecl(ST.Element, "deinit")) {
+                    errdefer {
+                        for (values[0..i]) |*value| {
+                            ST.Element.deinit(allocator, value);
+                        }
+                    }
+                }
+                if (comptime isFixedType(ST.Element)) {
+                    try ST.Element.tree.toValue(node, self.pool, &values[i]);
+                } else {
+                    // Initialize value to default before toValue for variable types
+                    // (e.g. BitList fields need initialized ArrayListUnmanaged)
+                    if (comptime @hasDecl(ST.Element, "default_value")) {
+                        values[i] = ST.Element.default_value;
+                    } else {
+                        values[i] = std.mem.zeroes(Value);
+                    }
+                    try ST.Element.tree.toValue(allocator, node, self.pool, &values[i]);
+                }
+            }
+
+            return values;
+        }
+
         pub fn getChildNode(self: *Self, gindex: Gindex) !Node.Id {
             return ChildNodes.getChildNode(self, gindex);
         }