fix: state transition binding exports

bench/state_transition/process_epoch.zig

@@ -658,7 +658,7 @@ fn runBenchmark(
     state_bytes: []const u8,
     chain_config: config.ChainConfig,
 ) !void {
-    defer state_transition.deinitStateTransition(io);
+    defer state_transition.deinitReusedEpochTransitionCache(io);
 
     var beacon_state: ?*AnyBeaconState = try loadState(fork, allocator, pool, state_bytes);
     defer if (beacon_state) |state| {

bindings/napi/root.zig

@@ -5,6 +5,7 @@ pub const pool = @import("./pool.zig");
 pub const shuffle = @import("./shuffle.zig");
 pub const config = @import("./config.zig");
 pub const metrics = @import("./metrics.zig");
+pub const stateTransition = @import("./stateTransition.zig");
 pub const BeaconStateView = @import("./BeaconStateView.zig");
 pub const blst = @import("./blst.zig");
 pub const pubkeys = @import("./pubkeys.zig");

bindings/napi/stateTransition.zig

@@ -0,0 +1,6 @@
+const napi_io = @import("./io.zig");
+const st = @import("state_transition");
+
+pub fn deinitReusedEpochTransitionCache() void {
+    st.deinitReusedEpochTransitionCache(napi_io.get());
+}

bindings/src/index.d.ts

@@ -369,6 +369,7 @@ export declare class BeaconStateView {
   createMultiProof(descriptor: Uint8Array): CompactMultiProof;
 
   processSlots(slot: number, options?: ProcessSlotsOpts): BeaconStateView;
+  stateTransition(signedBlockBytes: Uint8Array, options?: TransitionOpts): BeaconStateView;
 }
 
 declare const bindings: {
@@ -382,11 +383,7 @@ declare const bindings: {
     innerShuffleList: (out: Uint32Array, seed: Uint8Array, rounds: number, forwards: boolean) => void;
   };
   stateTransition: {
-    stateTransition: (
-      preState: BeaconStateView,
-      signedBlockBytes: Uint8Array,
-      options?: TransitionOpts
-    ) => BeaconStateView;
+    deinitReusedEpochTransitionCache: () => void;
   };
   metrics: {
     init: () => void;

bindings/src/state-transition.d.ts

@@ -7,10 +7,4 @@ export type {
   VoluntaryExitValidity,
 } from "./index.js";
 
-import type {BeaconStateView, TransitionOpts} from "./index.js";
-
-export declare function stateTransition(
-  preState: BeaconStateView,
-  signedBlockBytes: Uint8Array,
-  options?: TransitionOpts
-): BeaconStateView;
+export declare function deinitReusedEpochTransitionCache(): void;

bindings/src/state-transition.js

@@ -1,6 +1,4 @@
-import bindings from "./bindings.js";
-
-const native = bindings.stateTransition;
+import bindings from "./index.js";
 
 export const BeaconStateView = bindings.BeaconStateView;
-export const stateTransition = native.stateTransition;
+export const deinitReusedEpochTransitionCache = bindings.stateTransition.deinitReusedEpochTransitionCache;

bindings/test/beaconStateView.test.ts

@@ -699,15 +699,13 @@ describe("BeaconStateView", () => {
         {dataAvailabilityStatus: "available"}, // TS enum value is "Available"
       ];
       for (const opts of invalidOpts) {
-        expect(() => bindings.stateTransition.stateTransition(state, dummyBlockBytes, opts)).toThrow();
+        expect(() => state.stateTransition(dummyBlockBytes, opts)).toThrow();
       }
     });
 
     // TODO: remove once Zig models DataAvailabilityStatus.NotRequired
     it("rejects gloas-only NotRequired", () => {
-      expect(() =>
-        bindings.stateTransition.stateTransition(state, dummyBlockBytes, {dataAvailabilityStatus: "NotRequired"})
-      ).toThrow();
+      expect(() => state.stateTransition(dummyBlockBytes, {dataAvailabilityStatus: "NotRequired"})).toThrow();
     });
   });
 

bindings/test/demo.ts

@@ -54,7 +54,7 @@ const signedBlockBytes = (await printDurationAsync("read serialized block", () =
   nextReader.readSerializedBlock(state.slot + 1)
 )) as Uint8Array;
 
-printDuration("state transition", () => bindings.stateTransition.stateTransition(state, signedBlockBytes));
+printDuration("state transition", () => state.stateTransition(signedBlockBytes));
 
 printDuration("write pkix to disk", () => pubkeyCache.save(PKIX_FILE));
 

src/state_transition/cache/epoch_transition_cache.zig

@@ -13,7 +13,6 @@ const BeaconState = @import("fork_types").BeaconState;
 
 const TestCachedBeaconState = @import("../test_utils/root.zig").TestCachedBeaconState;
 const upgradeStateToFulu = @import("../slot/upgrade_state_to_fulu.zig").upgradeStateToFulu;
-const deinitStateTransition = @import("../root.zig").deinitStateTransition;
 
 const attester_status = @import("../utils/attester_status.zig");
 const FLAG_CURR_HEAD_ATTESTER = attester_status.FLAG_CURR_HEAD_ATTESTER;
@@ -625,5 +624,5 @@ test "EpochTransitionCache.beforeProcessEpoch" {
         defer epoch_transition_cache.deinit(allocator);
     }
 
-    deinitStateTransition(std.testing.io);
+    deinitReusedEpochTransitionCache(std.testing.io);
 }

src/state_transition/root.zig

@@ -87,7 +87,7 @@ pub const getBlockRootAtSlot = @import("./utils/block_root.zig").getBlockRootAtS
 pub const computeSlotsSinceEpochStart = @import("./utils/epoch.zig").computeSlotsSinceEpochStart;
 pub const computeStartSlotAtEpoch = @import("./utils/epoch.zig").computeStartSlotAtEpoch;
 pub const AnchorCheckpoint = @import("./AnchorCheckpoint.zig");
-pub const deinitStateTransition = @import("./state_transition.zig").deinitStateTransition;
+pub const deinitReusedEpochTransitionCache = @import("./state_transition.zig").deinitReusedEpochTransitionCache;
 pub const isExecutionEnabled = @import("./utils/execution.zig").isExecutionEnabled;
 pub const isMergeTransitionComplete = @import("./utils/execution.zig").isMergeTransitionComplete;
 pub const getRandaoMix = @import("./utils/seed.zig").getRandaoMix;

src/state_transition/state_transition.zig

@@ -22,14 +22,15 @@ const EpochTransitionCache = @import("cache/epoch_transition_cache.zig").EpochTr
 const processEpoch = @import("epoch/process_epoch.zig").processEpoch;
 const computeEpochAtSlot = @import("utils/epoch.zig").computeEpochAtSlot;
 const processSlot = @import("slot/process_slot.zig").processSlot;
-const deinitReusedEpochTransitionCache = @import("cache/epoch_transition_cache.zig").deinitReusedEpochTransitionCache;
 const upgradeStateToAltair = @import("slot/upgrade_state_to_altair.zig").upgradeStateToAltair;
 const upgradeStateToBellatrix = @import("slot/upgrade_state_to_bellatrix.zig").upgradeStateToBellatrix;
 const upgradeStateToCapella = @import("slot/upgrade_state_to_capella.zig").upgradeStateToCapella;
 const upgradeStateToDeneb = @import("slot/upgrade_state_to_deneb.zig").upgradeStateToDeneb;
 const upgradeStateToElectra = @import("slot/upgrade_state_to_electra.zig").upgradeStateToElectra;
 const upgradeStateToFulu = @import("slot/upgrade_state_to_fulu.zig").upgradeStateToFulu;
 
+pub const deinitReusedEpochTransitionCache = @import("cache/epoch_transition_cache.zig").deinitReusedEpochTransitionCache;
+
 pub const ExecutionPayloadStatus = enum(u8) {
     invalid,
     valid,
@@ -259,10 +260,6 @@ pub fn stateTransition(
     return post_cached_state;
 }
 
-pub fn deinitStateTransition(io: std.Io) void {
-    deinitReusedEpochTransitionCache(io);
-}
-
 const TestCase = struct {
     transition_opt: TransitionOpts,
     expect_error: bool,
@@ -323,14 +320,14 @@ test "state transition - electra block" {
         }
     }
 
-    defer deinitStateTransition(std.testing.io);
+    deinitReusedEpochTransitionCache(std.testing.io);
 }
 
 test "state transition - a rejected block leaves the pre-state unchanged" {
     const allocator = std.testing.allocator;
     var pool = try Node.Pool.init(.{ .page_allocator = allocator, .allocator = allocator, .pool_size = 256 * 5 });
     defer pool.deinit();
-    defer deinitStateTransition(std.testing.io);
+    defer deinitReusedEpochTransitionCache(std.testing.io);
 
     var test_state = try TestCachedBeaconState.init(allocator, &pool, 256);
     defer test_state.deinit();

src/state_transition/test_utils/generate_state.zig

@@ -245,7 +245,7 @@ pub const TestCachedBeaconState = struct {
         self.allocator.destroy(self.pubkey_index_map);
         self.index_pubkey_cache.deinit(self.allocator);
         self.epoch_transition_cache.deinit(self.allocator);
-        @import("../state_transition.zig").deinitStateTransition(std.testing.io);
+        @import("../state_transition.zig").deinitReusedEpochTransitionCache(std.testing.io);
         self.allocator.destroy(self.epoch_transition_cache);
         self.allocator.destroy(self.index_pubkey_cache);
         self.allocator.destroy(self.config);

test/spec/runner/epoch_processing.zig

@@ -77,7 +77,7 @@ pub fn TestCase(comptime fork: ForkSeq, comptime epoch_process_fn: EpochProcessi
                 post.deinit();
                 self.pre.allocator.destroy(post);
             }
-            state_transition.deinitStateTransition(std.testing.io);
+            state_transition.deinitReusedEpochTransitionCache(std.testing.io);
         }
 
         fn runTest(self: *Self) !void {

test/spec/runner/fork.zig

@@ -51,7 +51,7 @@ pub fn TestCase(comptime target_fork: ForkSeq) type {
             var tc = try Self.init(allocator, &pool, dir);
             defer {
                 tc.deinit();
-                state_transition.deinitStateTransition(std.testing.io);
+                state_transition.deinitReusedEpochTransitionCache(std.testing.io);
             }
 
             try tc.runTest();

test/spec/runner/operations.zig

@@ -92,7 +92,7 @@ pub fn TestCase(comptime fork: ForkSeq, comptime operation: Operation) type {
             var tc = try Self.init(allocator, &pool, dir);
             defer {
                 tc.deinit();
-                state_transition.deinitStateTransition(std.testing.io);
+                state_transition.deinitReusedEpochTransitionCache(std.testing.io);
             }
 
             try tc.runTest();

test/spec/runner/rewards.zig

@@ -46,7 +46,7 @@ pub fn TestCase(comptime fork: ForkSeq) type {
             var tc = try Self.init(allocator, &pool, dir);
             defer {
                 tc.deinit();
-                state_transition.deinitStateTransition(std.testing.io);
+                state_transition.deinitReusedEpochTransitionCache(std.testing.io);
             }
 
             try tc.runTest();

test/spec/runner/sanity.zig

@@ -39,7 +39,7 @@ pub fn SlotsTestCase(comptime fork: ForkSeq) type {
             var tc = try Self.init(allocator, pool, dir);
             defer {
                 tc.deinit();
-                state_transition.deinitStateTransition(std.testing.io);
+                state_transition.deinitReusedEpochTransitionCache(std.testing.io);
             }
 
             try tc.runTest();
@@ -110,7 +110,7 @@ pub fn BlocksTestCase(comptime fork: ForkSeq) type {
             var tc = try Self.init(allocator, pool, dir);
             defer {
                 tc.deinit();
-                state_transition.deinitStateTransition(std.testing.io);
+                state_transition.deinitReusedEpochTransitionCache(std.testing.io);
             }
 
             try tc.runTest();

test/spec/runner/transition.zig

@@ -29,7 +29,7 @@ pub fn Transition(comptime fork: ForkSeq) type {
             var tc = try Self.init(allocator, &pool, dir);
             defer {
                 tc.deinit();
-                state_transition.deinitStateTransition(std.testing.io);
+                state_transition.deinitReusedEpochTransitionCache(std.testing.io);
             }
             try tc.runTest();
         }