Merge branch 'napi' into bing/blst-extended

Author: wemeetagain

.github/workflows/publish-bindings.yml

@@ -0,0 +1,39 @@
+name: Publish NAPI Bindings
+on:
+  workflow_dispatch:
+
+env:
+  ZIG_VERSION: "0.14.1"
+  NODE_VERSION: "24"
+
+jobs:
+  publish-bindings:
+    name: publish bindings
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v4
+      - name: Setup Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version: ${{ env.NODE_VERSION }}
+          cache: pnpm
+      - name: Install dependencies
+        run: |
+          pnpm install
+      - name: Run bindings formatter
+        run: |
+          pnpm biome ci
+      - name: Install Zig
+        uses: mlugg/setup-zig@v2
+        with:
+          version: ${{ env.ZIG_VERSION }}
+          cache-key: ubuntu-latest-${{ env.ZIG_VERSION }}
+      - name: Build and publish to npm
+        run: |
+          pnpm zapi build-artifacts --optimize ReleaseSafe
+          pnpm zapi prepublish
+          pnpm zapi publish --access public
+

bench/ssz/attestation.zig

@@ -1,7 +1,12 @@
 const std = @import("std");
-const Attestation = @import("consensus_types").deneb.Attestation;
+// TODO make this fork-agnostic
+const Attestation = @import("consensus_types").fulu.Attestation;
+const SignedBeaconBlock = @import("consensus_types").fulu.SignedBeaconBlock;
 const ssz = @import("ssz");
 const zbench = @import("zbench");
+const download_era_options = @import("download_era_options");
+const era = @import("era");
+const config = @import("config");
 
 // printf "Date: %s\nKernel: %s\nCPU: %s\nCPUs: %s\nMemory: %s\n" "$(date)" "$(uname -r)" "$(lscpu | grep 'Model name' | awk -F: '{print $2}' | xargs)" "$(lscpu | grep '^CPU(s):' | awk '{print $2}')" "$(free -h | grep Mem | awk '{print $2}')"
 // Date: Fri Apr 25 10:07:24 AM EDT 2025
@@ -115,13 +120,28 @@ pub fn main() !void {
     var bench = zbench.Benchmark.init(allocator, .{});
     defer bench.deinit();
 
-    const attestation_file = try std.fs.cwd().openFile("bench/attestation.ssz", .{});
-    defer attestation_file.close();
-    const attestation_bytes = try attestation_file.readToEndAlloc(allocator, 1_000_000_000);
+    const era_path = try std.fs.path.join(
+        allocator,
+        &[_][]const u8{ download_era_options.era_out_dir, download_era_options.era_files[1] },
+    );
+    defer allocator.free(era_path);
 
-    const attestation = allocator.create(Attestation.Type) catch unreachable;
-    attestation.* = Attestation.default_value;
-    Attestation.deserializeFromBytes(allocator, attestation_bytes, attestation) catch unreachable;
+    var era_reader = try era.Reader.open(allocator, config.mainnet.config, era_path);
+    defer era_reader.close(allocator);
+
+    const block_slot = try era.era.computeStartBlockSlotFromEraNumber(era_reader.era_number) + 1;
+
+    const block_bytes: []u8 = @constCast(try era_reader.readSerializedBlock(allocator, block_slot) orelse return error.InvalidEraFile);
+    defer allocator.free(block_bytes);
+
+    var block = SignedBeaconBlock.default_value;
+    defer block.deinit();
+    try SignedBeaconBlock.deserializeFromBytes(allocator, block_bytes, &block);
+
+    const attestation = &block.message.body.attestations.items[0];
+    const attestation_bytes = try allocator.alloc(u8, Attestation.serializedSize(attestation));
+    defer allocator.free(attestation_bytes);
+    _ = Attestation.serializeIntoBytes(attestation, attestation_bytes);
 
     const serialize_attestation = SerializeAttestation{ .attestation = attestation };
     try bench.addParam("serialize attestation", &serialize_attestation, .{});

bench/ssz/block.zig

@@ -1,7 +1,11 @@
 const std = @import("std");
-const BeaconBlock = @import("consensus_types").deneb.SignedBeaconBlock;
+// TODO make this fork-agnostic
+const BeaconBlock = @import("consensus_types").fulu.SignedBeaconBlock;
 const ssz = @import("ssz");
 const zbench = @import("zbench");
+const download_era_options = @import("download_era_options");
+const era = @import("era");
+const config = @import("config");
 
 // printf "Date: %s\nKernel: %s\nCPU: %s\nCPUs: %s\nMemory: %s\n" "$(date)" "$(uname -r)" "$(lscpu | grep 'Model name' | awk -F: '{print $2}' | xargs)" "$(lscpu | grep '^CPU(s):' | awk '{print $2}')" "$(free -h | grep Mem | awk '{print $2}')"
 // Date: Mon Apr 21 12:59:32 PM EDT 2025
@@ -107,9 +111,19 @@ pub fn main() !void {
     var bench = zbench.Benchmark.init(allocator, .{});
     defer bench.deinit();
 
-    const block_file = try std.fs.cwd().openFile("bench/block.ssz", .{});
-    defer block_file.close();
-    const block_bytes = try block_file.readToEndAlloc(allocator, 1_000_000_000);
+    const era_path = try std.fs.path.join(
+        allocator,
+        &[_][]const u8{ download_era_options.era_out_dir, download_era_options.era_files[1] },
+    );
+    defer allocator.free(era_path);
+
+    var era_reader = try era.Reader.open(allocator, config.mainnet.config, era_path);
+    defer era_reader.close(allocator);
+
+    const block_slot = try era.era.computeStartBlockSlotFromEraNumber(era_reader.era_number) + 1;
+
+    const block_bytes: []u8 = @constCast(try era_reader.readSerializedBlock(allocator, block_slot) orelse return error.InvalidEraFile);
+    defer allocator.free(block_bytes);
 
     const block = allocator.create(BeaconBlock.Type) catch unreachable;
     block.* = BeaconBlock.default_value;

bench/ssz/state.zig

@@ -1,7 +1,11 @@
 const std = @import("std");
-const BeaconState = @import("consensus_types").deneb.BeaconState;
+// TODO make this fork-agnostic
+const BeaconState = @import("consensus_types").fulu.BeaconState;
 const ssz = @import("ssz");
 const zbench = @import("zbench");
+const download_era_options = @import("download_era_options");
+const era = @import("era");
+const config = @import("config");
 
 // printf "Date: %s\nKernel: %s\nCPU: %s\nCPUs: %s\nMemory: %s\n" "$(date)" "$(uname -r)" "$(lscpu | grep 'Model name' | awk -F: '{print $2}' | xargs)" "$(lscpu | grep '^CPU(s):' | awk '{print $2}')" "$(free -h | grep Mem | awk '{print $2}')"
 // Date: Mon Apr 21 12:59:32 PM EDT 2025
@@ -107,9 +111,16 @@ pub fn main() !void {
     var bench = zbench.Benchmark.init(allocator, .{});
     defer bench.deinit();
 
-    const state_file = try std.fs.cwd().openFile("bench/state.ssz", .{});
-    defer state_file.close();
-    const state_bytes = try state_file.readToEndAlloc(allocator, 1_000_000_000);
+    const era_path = try std.fs.path.join(
+        allocator,
+        &[_][]const u8{ download_era_options.era_out_dir, download_era_options.era_files[0] },
+    );
+    defer allocator.free(era_path);
+    var era_reader = try era.Reader.open(allocator, config.mainnet.config, era_path);
+    defer era_reader.close(allocator);
+
+    const state_bytes: []u8 = @constCast(try era_reader.readSerializedState(allocator, null));
+    defer allocator.free(state_bytes);
 
     const state = allocator.create(BeaconState.Type) catch unreachable;
     state.* = BeaconState.default_value;

bench/state_transition/process_block.zig

@@ -186,6 +186,7 @@ fn ProcessOperationsBench(comptime fork: ForkSeq, comptime opts: BenchOpts) type
                 cloned.config,
                 cloned.getEpochCache(),
                 cloned.state.castToFork(fork),
+                &cloned.slashings_cache,
                 .full,
                 self.body,
                 .{ .verify_signature = opts.verify_signature },
@@ -236,6 +237,7 @@ fn ProcessBlockBench(comptime fork: ForkSeq, comptime opts: BenchOpts) type {
                 cloned.config,
                 cloned.getEpochCache(),
                 cloned.state.castToFork(fork),
+                &cloned.slashings_cache,
                 .full,
                 self.block,
                 external_data,
@@ -400,6 +402,7 @@ fn ProcessBlockSegmentedBench(comptime fork: ForkSeq) type {
                 cloned.config,
                 epoch_cache,
                 state,
+                &cloned.slashings_cache,
                 .full,
                 self.body,
                 .{ .verify_signature = true },
@@ -492,7 +495,7 @@ fn runBenchmark(comptime fork: ForkSeq, allocator: std.mem.Allocator, pool: *Nod
     const validators = try beacon_state.validatorsSlice(allocator);
     defer allocator.free(validators);
 
-    try state_transition.syncPubkeys(validators, pubkey_index_map, index_pubkey_cache);
+    try state_transition.syncPubkeys(validators, &pubkey_index_map, &index_pubkey_cache);
 
     const cached_state = try CachedBeaconState.createCachedBeaconState(allocator, beacon_state, .{
         .config = &beacon_config,
@@ -507,6 +510,7 @@ fn runBenchmark(comptime fork: ForkSeq, allocator: std.mem.Allocator, pool: *Nod
         .{},
     );
     try cached_state.state.commit();
+    try state_transition.buildSlashingsCacheFromStateIfNeeded(allocator, cached_state.state, &cached_state.slashings_cache);
     try stdout.print("State: slot={}, validators={}\n", .{ try cached_state.state.slot(), try beacon_state.validatorsCount() });
 
     var bench = zbench.Benchmark.init(allocator, .{

bench/state_transition/process_epoch.zig

@@ -53,6 +53,7 @@ fn ProcessInactivityUpdatesBench(comptime fork: ForkSeq) type {
             defer cache.deinit();
             state_transition.processInactivityUpdates(
                 fork,
+                allocator,
                 cloned.config,
                 cloned.getEpochCache(),
                 cloned.state.castToFork(fork),
@@ -81,6 +82,7 @@ fn ProcessRewardsAndPenaltiesBench(comptime fork: ForkSeq) type {
                 cloned.getEpochCache(),
                 cloned.state.castToFork(fork),
                 &cache,
+                null,
             ) catch unreachable;
         }
     };
@@ -121,12 +123,13 @@ fn ProcessSlashingsBench(comptime fork: ForkSeq) type {
             }
             var cache = EpochTransitionCache.init(allocator, cloned.config, cloned.getEpochCache(), cloned.state) catch unreachable;
             defer cache.deinit();
-            state_transition.processSlashings(
+            _ = state_transition.processSlashings(
                 fork,
                 allocator,
                 cloned.getEpochCache(),
                 cloned.state.castToFork(fork),
                 &cache,
+                true,
             ) catch unreachable;
         }
     };
@@ -462,6 +465,7 @@ fn ProcessEpochSegmentedBench(comptime fork: ForkSeq) type {
                 const inactivity_start = std.time.nanoTimestamp();
                 state_transition.processInactivityUpdates(
                     fork,
+                    allocator,
                     cloned.config,
                     epoch_cache,
                     fork_state,
@@ -481,12 +485,13 @@ fn ProcessEpochSegmentedBench(comptime fork: ForkSeq) type {
             recordSegment(.registry_updates, elapsedSince(registry_start));
 
             const slashings_start = std.time.nanoTimestamp();
-            state_transition.processSlashings(
+            const slashing_penalties = state_transition.processSlashings(
                 fork,
                 allocator,
                 epoch_cache,
                 fork_state,
                 &cache,
+                false,
             ) catch unreachable;
             recordSegment(.slashings, elapsedSince(slashings_start));
 
@@ -498,6 +503,7 @@ fn ProcessEpochSegmentedBench(comptime fork: ForkSeq) type {
                 epoch_cache,
                 fork_state,
                 &cache,
+                slashing_penalties,
             ) catch unreachable;
             recordSegment(.rewards_and_penalties, elapsedSince(rewards_start));
 
@@ -659,7 +665,7 @@ fn runBenchmark(
     const validators = try beacon_state.validatorsSlice(allocator);
     defer allocator.free(validators);
 
-    try state_transition.syncPubkeys(validators, pubkey_index_map, index_pubkey_cache);
+    try state_transition.syncPubkeys(validators, &pubkey_index_map, &index_pubkey_cache);
 
     const immutable_data = state_transition.EpochCacheImmutableData{
         .config = &beacon_config,