feat(treeview): add defaultTreeview helper

GrapeBaBa · GrapeBaBa · commit 8337442508e6 · 2026-01-05T15:18:06.000+08:00
Signed-off-by: grapebaba &lt;grapebaba@grapebabadeMacBook-Pro.local&gt;
diff --git a/src/ssz/type/bit_list.zig b/src/ssz/type/bit_list.zig
@@ -587,6 +587,11 @@ pub fn BitListType(comptime _limit: comptime_int) type {
             }
             try deserializeFromBytes(allocator, bytes, out);
         }
+
+        pub fn defaultTreeView(allocator: std.mem.Allocator, pool: *Node.Pool) !TreeView {
+            const root = try tree.fromValue(allocator, pool, &default_value);
+            return try TreeView.init(allocator, pool, root);
+        }
     };
 }
 
diff --git a/src/ssz/type/bit_vector.zig b/src/ssz/type/bit_vector.zig
@@ -316,6 +316,11 @@ pub fn BitVectorType(comptime _length: comptime_int) type {
                 return error.trailingData;
             }
         }
+
+        pub fn defaultTreeView(allocator: std.mem.Allocator, pool: *Node.Pool) !TreeView {
+            const root = try tree.fromValue(pool, &default_value);
+            return try TreeView.init(allocator, pool, root);
+        }
     };
 }
 
diff --git a/src/ssz/type/byte_list.zig b/src/ssz/type/byte_list.zig
@@ -261,6 +261,11 @@ pub fn ByteListType(comptime _limit: comptime_int) type {
             try out.resize(allocator, hex_bytes_len);
             _ = try hexToBytes(out.items, hex_bytes);
         }
+
+        pub fn defaultTreeView(allocator: std.mem.Allocator, pool: *Node.Pool) !TreeView {
+            const root = try tree.fromValue(allocator, pool, &default_value);
+            return try TreeView.init(allocator, pool, root);
+        }
     };
 }
 test "clone" {
diff --git a/src/ssz/type/byte_vector.zig b/src/ssz/type/byte_vector.zig
@@ -168,6 +168,11 @@ pub fn ByteVectorType(comptime _length: comptime_int) type {
             }
             _ = try hexToBytes(out, hex_bytes);
         }
+
+        pub fn defaultTreeView(allocator: std.mem.Allocator, pool: *Node.Pool) !TreeView {
+            const root = try tree.fromValue(pool, &default_value);
+            return try TreeView.init(allocator, pool, root);
+        }
     };
 }
 
diff --git a/src/ssz/type/container.zig b/src/ssz/type/container.zig
@@ -252,6 +252,11 @@ pub fn FixedContainerType(comptime ST: type) type {
             const field_index = getFieldIndex(name);
             return comptime Gindex.fromDepth(chunk_depth, field_index);
         }
+
+        pub fn defaultTreeView(allocator: std.mem.Allocator, pool: *Node.Pool) !TreeView {
+            const root = try tree.fromValue(pool, &default_value);
+            return try TreeView.init(allocator, pool, root);
+        }
     };
 }
 
@@ -681,6 +686,11 @@ pub fn VariableContainerType(comptime ST: type) type {
                 else => return error.InvalidJson,
             }
         }
+
+        pub fn defaultTreeView(allocator: std.mem.Allocator, pool: *Node.Pool) !TreeView {
+            const root = try tree.fromValue(allocator, pool, &default_value);
+            return try TreeView.init(allocator, pool, root);
+        }
     };
 }
 
diff --git a/src/ssz/type/list.zig b/src/ssz/type/list.zig
@@ -395,6 +395,11 @@ pub fn FixedListType(comptime ST: type, comptime _limit: comptime_int) type {
                 }
             }
         };
+
+        pub fn defaultTreeView(allocator: std.mem.Allocator, pool: *Node.Pool) !TreeView {
+            const root = try tree.fromValue(allocator, pool, &default_value);
+            return try TreeView.init(allocator, pool, root);
+        }
     };
 }
 
@@ -728,6 +733,11 @@ pub fn VariableListType(comptime ST: type, comptime _limit: comptime_int) type {
             }
             return error.invalidLength;
         }
+
+        pub fn defaultTreeView(allocator: std.mem.Allocator, pool: *Node.Pool) !TreeView {
+            const root = try tree.fromValue(allocator, pool, &default_value);
+            return try TreeView.init(allocator, pool, root);
+        }
     };
 }
 
diff --git a/src/ssz/type/vector.zig b/src/ssz/type/vector.zig
@@ -237,6 +237,11 @@ pub fn FixedVectorType(comptime ST: type, comptime _length: comptime_int) type {
                 else => return error.InvalidJson,
             }
         }
+
+        pub fn defaultTreeView(allocator: std.mem.Allocator, pool: *Node.Pool) !TreeView {
+            const root = try tree.fromValue(pool, &default_value);
+            return try TreeView.init(allocator, pool, root);
+        }
     };
 }
 
@@ -447,6 +452,11 @@ pub fn VariableVectorType(comptime ST: type, comptime _length: comptime_int) typ
                 else => return error.InvalidJson,
             }
         }
+
+        pub fn defaultTreeView(allocator: std.mem.Allocator, pool: *Node.Pool) !TreeView {
+            const root = try tree.fromValue(allocator, pool, &default_value);
+            return try TreeView.init(allocator, pool, root);
+        }
     };
 }
 
diff --git a/test/int/ssz/tree_view/bit_vector.zig b/test/int/ssz/tree_view/bit_vector.zig
@@ -97,8 +97,7 @@ test "BitVectorTreeView clone isolates updates" {
     var pool = try Node.Pool.init(allocator, 2048);
     defer pool.deinit();
 
-    const root = try Bits.tree.fromValue(&pool, &Bits.default_value);
-    var v1 = try Bits.TreeView.init(allocator, &pool, root);
+    var v1 = try Bits.defaultTreeView(allocator, &pool);
     defer v1.deinit();
 
     var v2 = try v1.clone(.{});
@@ -118,8 +117,7 @@ test "BitVectorTreeView clone reads committed state" {
     var pool = try Node.Pool.init(allocator, 2048);
     defer pool.deinit();
 
-    const root = try Bits.tree.fromValue(&pool, &Bits.default_value);
-    var v1 = try Bits.TreeView.init(allocator, &pool, root);
+    var v1 = try Bits.defaultTreeView(allocator, &pool);
     defer v1.deinit();
 
     try v1.set(1, true);
@@ -138,8 +136,7 @@ test "BitVectorTreeView clone drops uncommitted changes" {
     var pool = try Node.Pool.init(allocator, 2048);
     defer pool.deinit();
 
-    const root = try Bits.tree.fromValue(&pool, &Bits.default_value);
-    var v = try Bits.TreeView.init(allocator, &pool, root);
+    var v = try Bits.defaultTreeView(allocator, &pool);
     defer v.deinit();
 
     try v.set(2, true);
diff --git a/test/int/ssz/tree_view/container.zig b/test/int/ssz/tree_view/container.zig
@@ -95,22 +95,15 @@ test "TreeView container nested types set/get/commit" {
         comp_list: CompList,
     });
 
-    var outer_value: Outer.Type = Outer.default_value;
-    defer Outer.deinit(allocator, &outer_value);
-
-    const root = try Outer.tree.fromValue(allocator, &pool, &outer_value);
-    var view = try Outer.TreeView.init(allocator, &pool, root);
+    var view = try Outer.defaultTreeView(allocator, &pool);
     defer view.deinit();
 
     try std.testing.expectEqual(@as(u64, 0), try view.get("n"));
     try view.set("n", @as(u64, 7));
     try std.testing.expectEqual(@as(u64, 7), try view.get("n"));
 
     {
-        var bytes_value: Bytes.Type = Bytes.default_value;
-        defer bytes_value.deinit(allocator);
-        const bytes_root = try Bytes.tree.fromValue(allocator, &pool, &bytes_value);
-        var bytes_view = try Bytes.TreeView.init(allocator, &pool, bytes_root);
+        var bytes_view = try Bytes.defaultTreeView(allocator, &pool);
 
         try bytes_view.push(@as(u8, 0xAA));
         try bytes_view.push(@as(u8, 0xBB));
@@ -124,9 +117,7 @@ test "TreeView container nested types set/get/commit" {
     }
 
     {
-        const basic_vec_value: BasicVec.Type = [_]u16{ 0, 0, 0, 0 };
-        const basic_vec_root = try BasicVec.tree.fromValue(&pool, &basic_vec_value);
-        var basic_vec_view = try BasicVec.TreeView.init(allocator, &pool, basic_vec_root);
+        var basic_vec_view = try BasicVec.defaultTreeView(allocator, &pool);
 
         try std.testing.expectEqual(@as(u16, 0), try basic_vec_view.get(0));
         try basic_vec_view.set(0, @as(u16, 1));
@@ -166,24 +157,15 @@ test "TreeView container nested types set/get/commit" {
     }
 
     {
-        var comp_list_value: CompList.Type = .empty;
-        defer CompList.deinit(allocator, &comp_list_value);
-        const comp_list_root = try CompList.tree.fromValue(allocator, &pool, &comp_list_value);
-        var comp_list_view = try CompList.TreeView.init(allocator, &pool, comp_list_root);
-
-        var inner_value: InnerVar.Type = InnerVar.default_value;
-        defer InnerVar.deinit(allocator, &inner_value);
-        const inner_root = try InnerVar.tree.fromValue(allocator, &pool, &inner_value);
-        var inner_view: ?InnerVar.TreeView = try InnerVar.TreeView.init(allocator, &pool, inner_root);
+        var comp_list_view = try CompList.defaultTreeView(allocator, &pool);
+
+        var inner_view: ?InnerVar.TreeView = try InnerVar.defaultTreeView(allocator, &pool);
         defer if (inner_view) |*v| v.deinit();
         const inner = &inner_view.?;
 
         try inner.set("id", @as(u32, 99));
 
-        var payload_value: InnerVar.TreeView.Field("payload").SszType.Type = InnerVar.TreeView.Field("payload").SszType.default_value;
-        defer payload_value.deinit(allocator);
-        const payload_root = try InnerVar.TreeView.Field("payload").SszType.tree.fromValue(allocator, &pool, &payload_value);
-        var payload_view = try InnerVar.TreeView.Field("payload").init(allocator, &pool, payload_root);
+        var payload_view = try InnerVar.TreeView.Field("payload").SszType.defaultTreeView(allocator, &pool);
         try payload_view.push(@as(u8, 0x5A));
         try inner.set("payload", payload_view);
 
diff --git a/test/int/ssz/tree_view/list_basic.zig b/test/int/ssz/tree_view/list_basic.zig
@@ -674,11 +674,7 @@ test "ListBasicTreeView - push and serialize" {
     var pool = try Node.Pool.init(allocator, 1024);
     defer pool.deinit();
 
-    var value: ListU8Type.Type = ListU8Type.default_value;
-    defer value.deinit(allocator);
-
-    const tree_node = try ListU8Type.tree.fromValue(allocator, &pool, &value);
-    var view = try ListU8Type.TreeView.init(allocator, &pool, tree_node);
+    var view = try ListU8Type.defaultTreeView(allocator, &pool);
     defer view.deinit();
 
     try view.push(1);
diff --git a/test/int/ssz/tree_view/list_composite.zig b/test/int/ssz/tree_view/list_composite.zig
@@ -379,33 +379,21 @@ test "TreeView list of list commits inner length updates" {
     const InnerListType = ssz.VariableListType(InnerElement, 16);
     const OuterListType = ssz.VariableListType(InnerListType, 8);
 
-    var outer_value: OuterListType.Type = .empty;
-    defer OuterListType.deinit(allocator, &outer_value);
-    const outer_root = try OuterListType.tree.fromValue(allocator, &pool, &outer_value);
-    var outer_view = try OuterListType.TreeView.init(allocator, &pool, outer_root);
+    var outer_view = try OuterListType.defaultTreeView(allocator, &pool);
     defer outer_view.deinit();
 
-    var inner_value: InnerListType.Type = .empty;
-    defer InnerListType.deinit(allocator, &inner_value);
-    const inner_root = try InnerListType.tree.fromValue(allocator, &pool, &inner_value);
-    var inner_view = try InnerListType.TreeView.init(allocator, &pool, inner_root);
+    var inner_view = try InnerListType.defaultTreeView(allocator, &pool);
     var transferred = false;
     defer if (!transferred) inner_view.deinit();
 
-    var e1_value: InnerElement.Type = InnerElement.default_value;
-    defer InnerElement.deinit(allocator, &e1_value);
-    const e1_root = try InnerElement.tree.fromValue(allocator, &pool, &e1_value);
-    var e1_view: ?InnerElement.TreeView = try InnerElement.TreeView.init(allocator, &pool, e1_root);
+    var e1_view: ?InnerElement.TreeView = try InnerElement.defaultTreeView(allocator, &pool);
     defer if (e1_view) |*view| view.deinit();
     const e1 = &e1_view.?;
 
     try e1.set("id", @as(u32, 11));
 
     // payload: ByteListType (list_basic) -> push + set + getAll + getAllInto
-    var payload_value: Bytes.Type = Bytes.default_value;
-    defer payload_value.deinit(allocator);
-    const payload_root = try Bytes.tree.fromValue(allocator, &pool, &payload_value);
-    var payload_view: ?Bytes.TreeView = try Bytes.TreeView.init(allocator, &pool, payload_root);
+    var payload_view: ?Bytes.TreeView = try Bytes.defaultTreeView(allocator, &pool);
     defer if (payload_view) |*view| view.deinit();
     const payload = &payload_view.?;
 
@@ -425,10 +413,7 @@ test "TreeView list of list commits inner length updates" {
     try e1.set("payload", payload_view.?);
     payload_view = null;
 
-    var numbers_value: Numbers.Type = .empty;
-    defer numbers_value.deinit(allocator);
-    const numbers_root = try Numbers.tree.fromValue(allocator, &pool, &numbers_value);
-    var numbers_view: ?Numbers.TreeView = try Numbers.TreeView.init(allocator, &pool, numbers_root);
+    var numbers_view: ?Numbers.TreeView = try Numbers.defaultTreeView(allocator, &pool);
     defer if (numbers_view) |*view| view.deinit();
     const numbers = &numbers_view.?;
 
@@ -451,9 +436,7 @@ test "TreeView list of list commits inner length updates" {
     try e1.set("numbers", numbers_view.?);
     numbers_view = null;
 
-    var vec_value: Vec2.Type = [_]u32{ 0, 0 };
-    const vec_root = try Vec2.tree.fromValue(&pool, &vec_value);
-    var vec_view: ?Vec2.TreeView = try Vec2.TreeView.init(allocator, &pool, vec_root);
+    var vec_view: ?Vec2.TreeView = try Vec2.defaultTreeView(allocator, &pool);
     defer if (vec_view) |*view| view.deinit();
     const vec = &vec_view.?;
 
@@ -478,19 +461,13 @@ test "TreeView list of list commits inner length updates" {
     try inner_view.push(e1_view.?);
     e1_view = null;
 
-    var e2_value: InnerElement.Type = InnerElement.default_value;
-    defer InnerElement.deinit(allocator, &e2_value);
-    const e2_root = try InnerElement.tree.fromValue(allocator, &pool, &e2_value);
-    var e2_view: ?InnerElement.TreeView = try InnerElement.TreeView.init(allocator, &pool, e2_root);
+    var e2_view: ?InnerElement.TreeView = try InnerElement.defaultTreeView(allocator, &pool);
     defer if (e2_view) |*view| view.deinit();
     const e2 = &e2_view.?;
 
     try e2.set("id", @as(u32, 22));
 
-    var e2_payload_value: Bytes.Type = Bytes.default_value;
-    defer e2_payload_value.deinit(allocator);
-    const e2_payload_root = try Bytes.tree.fromValue(allocator, &pool, &e2_payload_value);
-    var e2_payload_view: ?Bytes.TreeView = try Bytes.TreeView.init(allocator, &pool, e2_payload_root);
+    var e2_payload_view: ?Bytes.TreeView = try Bytes.defaultTreeView(allocator, &pool);
     defer if (e2_payload_view) |*view| view.deinit();
     const e2_payload = &e2_payload_view.?;
     try e2_payload.push(@as(u8, 0xBB));
@@ -501,10 +478,7 @@ test "TreeView list of list commits inner length updates" {
     e2_view = null;
 
     {
-        var e3_value: InnerElement.Type = InnerElement.default_value;
-        defer InnerElement.deinit(allocator, &e3_value);
-        const e3_root = try InnerElement.tree.fromValue(allocator, &pool, &e3_value);
-        var e3_view: ?InnerElement.TreeView = try InnerElement.TreeView.init(allocator, &pool, e3_root);
+        var e3_view: ?InnerElement.TreeView = try InnerElement.defaultTreeView(allocator, &pool);
         defer if (e3_view) |*view| view.deinit();
         const e3 = &e3_view.?;
         try e3.set("id", @as(u32, 33));
@@ -756,11 +730,7 @@ test "ListCompositeTreeView - push and serialize" {
     var pool = try Node.Pool.init(allocator, 1024);
     defer pool.deinit();
 
-    var value: ListRootsType.Type = ListRootsType.default_value;
-    defer value.deinit(allocator);
-
-    const tree_node = try ListRootsType.tree.fromValue(allocator, &pool, &value);
-    var view = try ListRootsType.TreeView.init(allocator, &pool, tree_node);
+    var view = try ListRootsType.defaultTreeView(allocator, &pool);
     defer view.deinit();
 
     const val1 = [_]u8{0xdd} ** 32;

Original file line number	Diff line number	Diff line change
`@@ -587,6 +587,11 @@ pub fn BitListType(comptime _limit: comptime_int) type {`
`587`	`587`	`}`
`588`	`588`	`try deserializeFromBytes(allocator, bytes, out);`
`589`	`589`	`}`
	`590`	`+`
	`591`	`+ pub fn defaultTreeView(allocator: std.mem.Allocator, pool: *Node.Pool) !TreeView {`
	`592`	`+ const root = try tree.fromValue(allocator, pool, &default_value);`
	`593`	`+ return try TreeView.init(allocator, pool, root);`
	`594`	`+ }`
`590`	`595`	`};`
`591`	`596`	`}`
`592`	`597`
Original file line number	Diff line number	Diff line change
`@@ -316,6 +316,11 @@ pub fn BitVectorType(comptime _length: comptime_int) type {`
`316`	`316`	`return error.trailingData;`
`317`	`317`	`}`
`318`	`318`	`}`
	`319`	`+`
	`320`	`+ pub fn defaultTreeView(allocator: std.mem.Allocator, pool: *Node.Pool) !TreeView {`
	`321`	`+ const root = try tree.fromValue(pool, &default_value);`
	`322`	`+ return try TreeView.init(allocator, pool, root);`
	`323`	`+ }`
`319`	`324`	`};`
`320`	`325`	`}`
`321`	`326`
Original file line number	Diff line number	Diff line change
`@@ -261,6 +261,11 @@ pub fn ByteListType(comptime _limit: comptime_int) type {`
`261`	`261`	`try out.resize(allocator, hex_bytes_len);`
`262`	`262`	`_ = try hexToBytes(out.items, hex_bytes);`
`263`	`263`	`}`
	`264`	`+`
	`265`	`+ pub fn defaultTreeView(allocator: std.mem.Allocator, pool: *Node.Pool) !TreeView {`
	`266`	`+ const root = try tree.fromValue(allocator, pool, &default_value);`
	`267`	`+ return try TreeView.init(allocator, pool, root);`
	`268`	`+ }`
`264`	`269`	`};`
`265`	`270`	`}`
`266`	`271`	`test "clone" {`
Original file line number	Diff line number	Diff line change
`@@ -168,6 +168,11 @@ pub fn ByteVectorType(comptime _length: comptime_int) type {`
`168`	`168`	`}`
`169`	`169`	`_ = try hexToBytes(out, hex_bytes);`
`170`	`170`	`}`
	`171`	`+`
	`172`	`+ pub fn defaultTreeView(allocator: std.mem.Allocator, pool: *Node.Pool) !TreeView {`
	`173`	`+ const root = try tree.fromValue(pool, &default_value);`
	`174`	`+ return try TreeView.init(allocator, pool, root);`
	`175`	`+ }`
`171`	`176`	`};`
`172`	`177`	`}`
`173`	`178`
Original file line number	Diff line number	Diff line change
`@@ -252,6 +252,11 @@ pub fn FixedContainerType(comptime ST: type) type {`
`252`	`252`	`const field_index = getFieldIndex(name);`
`253`	`253`	`return comptime Gindex.fromDepth(chunk_depth, field_index);`
`254`	`254`	`}`
	`255`	`+`
	`256`	`+ pub fn defaultTreeView(allocator: std.mem.Allocator, pool: *Node.Pool) !TreeView {`
	`257`	`+ const root = try tree.fromValue(pool, &default_value);`
	`258`	`+ return try TreeView.init(allocator, pool, root);`
	`259`	`+ }`
`255`	`260`	`};`
`256`	`261`	`}`
`257`	`262`
`@@ -681,6 +686,11 @@ pub fn VariableContainerType(comptime ST: type) type {`
`681`	`686`	`else => return error.InvalidJson,`
`682`	`687`	`}`
`683`	`688`	`}`
	`689`	`+`
	`690`	`+ pub fn defaultTreeView(allocator: std.mem.Allocator, pool: *Node.Pool) !TreeView {`
	`691`	`+ const root = try tree.fromValue(allocator, pool, &default_value);`
	`692`	`+ return try TreeView.init(allocator, pool, root);`
	`693`	`+ }`
`684`	`694`	`};`
`685`	`695`	`}`
`686`	`696`
Original file line number	Diff line number	Diff line change
`@@ -395,6 +395,11 @@ pub fn FixedListType(comptime ST: type, comptime _limit: comptime_int) type {`
`395`	`395`	`}`
`396`	`396`	`}`
`397`	`397`	`};`
	`398`	`+`
	`399`	`+ pub fn defaultTreeView(allocator: std.mem.Allocator, pool: *Node.Pool) !TreeView {`
	`400`	`+ const root = try tree.fromValue(allocator, pool, &default_value);`
	`401`	`+ return try TreeView.init(allocator, pool, root);`
	`402`	`+ }`
`398`	`403`	`};`
`399`	`404`	`}`
`400`	`405`
`@@ -728,6 +733,11 @@ pub fn VariableListType(comptime ST: type, comptime _limit: comptime_int) type {`
`728`	`733`	`}`
`729`	`734`	`return error.invalidLength;`
`730`	`735`	`}`
	`736`	`+`
	`737`	`+ pub fn defaultTreeView(allocator: std.mem.Allocator, pool: *Node.Pool) !TreeView {`
	`738`	`+ const root = try tree.fromValue(allocator, pool, &default_value);`
	`739`	`+ return try TreeView.init(allocator, pool, root);`
	`740`	`+ }`
`731`	`741`	`};`
`732`	`742`	`}`
`733`	`743`
Original file line number	Diff line number	Diff line change
`@@ -237,6 +237,11 @@ pub fn FixedVectorType(comptime ST: type, comptime _length: comptime_int) type {`
`237`	`237`	`else => return error.InvalidJson,`
`238`	`238`	`}`
`239`	`239`	`}`
	`240`	`+`
	`241`	`+ pub fn defaultTreeView(allocator: std.mem.Allocator, pool: *Node.Pool) !TreeView {`
	`242`	`+ const root = try tree.fromValue(pool, &default_value);`
	`243`	`+ return try TreeView.init(allocator, pool, root);`
	`244`	`+ }`
`240`	`245`	`};`
`241`	`246`	`}`
`242`	`247`
`@@ -447,6 +452,11 @@ pub fn VariableVectorType(comptime ST: type, comptime _length: comptime_int) typ`
`447`	`452`	`else => return error.InvalidJson,`
`448`	`453`	`}`
`449`	`454`	`}`
	`455`	`+`
	`456`	`+ pub fn defaultTreeView(allocator: std.mem.Allocator, pool: *Node.Pool) !TreeView {`
	`457`	`+ const root = try tree.fromValue(allocator, pool, &default_value);`
	`458`	`+ return try TreeView.init(allocator, pool, root);`
	`459`	`+ }`
`450`	`460`	`};`
`451`	`461`	`}`
`452`	`462`