feat: add minimal framework for spec test

.gitignore

@@ -5,3 +5,4 @@ test/bun/benchmark_data/
 bun/node_modules/
 bun/benchmark_data/
 test/spec/spec_tests/
+test/spec/test_case/operations_tests.zig

build.zig

@@ -10,6 +10,8 @@ pub fn build(b: *std.Build) void {
 
     const dep_ssz = b.dependency("ssz", .{});
 
+    const dep_snappy = b.dependency("snappy", .{});
+
     const options_build_options = b.addOptions();
     const option_preset = b.option([]const u8, "preset", "") orelse "mainnet";
     options_build_options.addOption([]const u8, "preset", option_preset);
@@ -89,6 +91,29 @@ pub fn build(b: *std.Build) void {
     const tls_run_exe_download_spec_tests = b.step("run:download_spec_tests", "Run the download_spec_tests executable");
     tls_run_exe_download_spec_tests.dependOn(&run_exe_download_spec_tests.step);
 
+    const module_write_spec_tests = b.createModule(.{
+        .root_source_file = b.path("test/spec/write_spec_tests.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+    b.modules.put(b.dupe("write_spec_tests"), module_write_spec_tests) catch @panic("OOM");
+
+    const exe_write_spec_tests = b.addExecutable(.{
+        .name = "write_spec_tests",
+        .root_module = module_write_spec_tests,
+    });
+
+    const install_exe_write_spec_tests = b.addInstallArtifact(exe_write_spec_tests, .{});
+
+    const tls_install_exe_write_spec_tests = b.step("build-exe:write_spec_tests", "Install the write_spec_tests executable");
+    tls_install_exe_write_spec_tests.dependOn(&install_exe_write_spec_tests.step);
+    b.getInstallStep().dependOn(&install_exe_write_spec_tests.step);
+
+    const run_exe_write_spec_tests = b.addRunArtifact(exe_write_spec_tests);
+    if (b.args) |args| run_exe_write_spec_tests.addArgs(args);
+    const tls_run_exe_write_spec_tests = b.step("run:write_spec_tests", "Run the write_spec_tests executable");
+    tls_run_exe_write_spec_tests.dependOn(&run_exe_write_spec_tests.step);
+
     const tls_run_test = b.step("test", "Run all tests");
 
     const test_hex = b.addTest(.{
@@ -189,6 +214,20 @@ pub fn build(b: *std.Build) void {
     tls_run_test_download_spec_tests.dependOn(&run_test_download_spec_tests.step);
     tls_run_test.dependOn(&run_test_download_spec_tests.step);
 
+    const test_write_spec_tests = b.addTest(.{
+        .name = "write_spec_tests",
+        .root_module = module_write_spec_tests,
+        .filters = &[_][]const u8{},
+    });
+    const install_test_write_spec_tests = b.addInstallArtifact(test_write_spec_tests, .{});
+    const tls_install_test_write_spec_tests = b.step("build-test:write_spec_tests", "Install the write_spec_tests test");
+    tls_install_test_write_spec_tests.dependOn(&install_test_write_spec_tests.step);
+
+    const run_test_write_spec_tests = b.addRunArtifact(test_write_spec_tests);
+    const tls_run_test_write_spec_tests = b.step("test:write_spec_tests", "Run the write_spec_tests test");
+    tls_run_test_write_spec_tests.dependOn(&run_test_write_spec_tests.step);
+    tls_run_test.dependOn(&run_test_write_spec_tests.step);
+
     const module_int = b.createModule(.{
         .root_source_file = b.path("test/int/root.zig"),
         .target = target,
@@ -210,6 +249,27 @@ pub fn build(b: *std.Build) void {
     tls_run_test_int.dependOn(&run_test_int.step);
     tls_run_test.dependOn(&run_test_int.step);
 
+    const module_spec_tests = b.createModule(.{
+        .root_source_file = b.path("test/spec/root.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+    b.modules.put(b.dupe("spec_tests"), module_spec_tests) catch @panic("OOM");
+
+    const test_spec_tests = b.addTest(.{
+        .name = "spec_tests",
+        .root_module = module_spec_tests,
+        .filters = &[_][]const u8{},
+    });
+    const install_test_spec_tests = b.addInstallArtifact(test_spec_tests, .{});
+    const tls_install_test_spec_tests = b.step("build-test:spec_tests", "Install the spec_tests test");
+    tls_install_test_spec_tests.dependOn(&install_test_spec_tests.step);
+
+    const run_test_spec_tests = b.addRunArtifact(test_spec_tests);
+    const tls_run_test_spec_tests = b.step("test:spec_tests", "Run the spec_tests test");
+    tls_run_test_spec_tests.dependOn(&run_test_spec_tests.step);
+    tls_run_test.dependOn(&run_test_spec_tests.step);
+
     module_config.addImport("build_options", options_module_build_options);
     module_config.addImport("preset", module_preset);
     module_config.addImport("consensus_types", module_consensus_types);
@@ -234,11 +294,25 @@ pub fn build(b: *std.Build) void {
 
     module_download_spec_tests.addImport("spec_test_options", options_module_spec_test_options);
 
+    module_write_spec_tests.addImport("spec_test_options", options_module_spec_test_options);
+    module_write_spec_tests.addImport("config", module_config);
+    module_write_spec_tests.addImport("preset", module_preset);
+    module_write_spec_tests.addImport("consensus_types", module_consensus_types);
+    module_write_spec_tests.addImport("state_transition", module_state_transition);
+
     module_int.addImport("build_options", options_module_build_options);
     module_int.addImport("ssz", dep_ssz.module("ssz"));
     module_int.addImport("state_transition", module_state_transition);
     module_int.addImport("config", module_config);
     module_int.addImport("consensus_types", module_consensus_types);
     module_int.addImport("preset", module_preset);
     module_int.addImport("constants", module_constants);
+
+    module_spec_tests.addImport("consensus_types", module_consensus_types);
+    module_spec_tests.addImport("config", module_config);
+    module_spec_tests.addImport("preset", module_preset);
+    module_spec_tests.addImport("snappy", dep_snappy.module("snappy"));
+    module_spec_tests.addImport("state_transition", module_state_transition);
+    module_spec_tests.addImport("ssz", dep_ssz.module("ssz"));
+    module_spec_tests.addImport("blst", dep_blst.module("blst"));
 }

build.zig.zon

@@ -11,9 +11,13 @@
             .hash = "blst_z-0.0.0-td3FNDOMAACf6Apg5icx1KkzpVeIR-9oOSK0WSILFHx8",
         },
         .ssz = .{
-            .url = "git+https://github.com/chainsafe/ssz-z#76cde3c7ea23b33d2789e8e372003272abe0e335",
+            .url = "git+https://github.com/ChainSafe/ssz-z.git#76cde3c7ea23b33d2789e8e372003272abe0e335",
             .hash = "ssz-0.1.0-yORmzN0NBQDTFE4aEPt3iwqZCa66VEPtpWTZ9_eS3cYO",
         },
+        .snappy = .{
+            .url = "git+https://github.com/chainsafe/snappy.zig#ede2ad602ac9ffa506e3724a2bf5fc14c806187f",
+            .hash = "snappy-0.1.0-n4AaqtMYAACgB1kHWQ2_CFI-gbtYEUCbXyYlQZ2ENyfd",
+        },
     },
     .paths = .{ "build.zig", "build.zig.zon", "src" },
 }

src/config/chain/networks/minimal.zig

@@ -0,0 +1,88 @@
+const std = @import("std");
+const hex_utils = @import("hex");
+const Preset = @import("preset").Preset;
+const ChainConfig = @import("../chain_config.zig").ChainConfig;
+const BlobScheduleEntry = @import("../chain_config.zig").BlobScheduleEntry;
+const b = hex_utils.hexToBytesComptime;
+
+pub const minimal_chain_config = ChainConfig{
+    .PRESET_BASE = Preset.minimal,
+    .CONFIG_NAME = "minimal",
+
+    .TERMINAL_TOTAL_DIFFICULTY = 115792089237316195423570985008687907853269984665640564039457584007913129638912,
+    .TERMINAL_BLOCK_HASH = b(32, "0x0000000000000000000000000000000000000000000000000000000000000000"),
+    .TERMINAL_BLOCK_HASH_ACTIVATION_EPOCH = std.math.maxInt(u64),
+
+    // Genesis
+    .MIN_GENESIS_ACTIVE_VALIDATOR_COUNT = 64,
+    .MIN_GENESIS_TIME = 1578009600,
+    .GENESIS_FORK_VERSION = b(4, "0x00000001"),
+    .GENESIS_DELAY = 300,
+
+    // Forking
+    .ALTAIR_FORK_VERSION = b(4, "0x01000001"),
+    .ALTAIR_FORK_EPOCH = 74240,
+    .BELLATRIX_FORK_VERSION = b(4, "0x02000001"),
+    .BELLATRIX_FORK_EPOCH = std.math.maxInt(u64),
+    .CAPELLA_FORK_VERSION = b(4, "0x03000001"),
+    .CAPELLA_FORK_EPOCH = std.math.maxInt(u64),
+    .DENEB_FORK_VERSION = b(4, "0x04000001"),
+    .DENEB_FORK_EPOCH = std.math.maxInt(u64),
+    .ELECTRA_FORK_VERSION = b(4, "0x05000001"),
+    .ELECTRA_FORK_EPOCH = std.math.maxInt(u64),
+    .FULU_FORK_VERSION = b(4, "0x06000001"),
+    .FULU_FORK_EPOCH = std.math.maxInt(u64),
+
+    // Time parameters
+    .SECONDS_PER_SLOT = 6,
+    .SECONDS_PER_ETH1_BLOCK = 14,
+    .MIN_VALIDATOR_WITHDRAWABILITY_DELAY = 256,
+    .SHARD_COMMITTEE_PERIOD = 64,
+    .ETH1_FOLLOW_DISTANCE = 16,
+
+    // Validator cycle
+    .INACTIVITY_SCORE_BIAS = 4,
+    .INACTIVITY_SCORE_RECOVERY_RATE = 16,
+    .EJECTION_BALANCE = 16000000000,
+    .MIN_PER_EPOCH_CHURN_LIMIT = 2,
+    .MAX_PER_EPOCH_ACTIVATION_CHURN_LIMIT = 4,
+    .CHURN_LIMIT_QUOTIENT = 32,
+
+    // Fork choice
+    .PROPOSER_SCORE_BOOST = 40,
+    .REORG_HEAD_WEIGHT_THRESHOLD = 20,
+    .REORG_PARENT_WEIGHT_THRESHOLD = 160,
+    .REORG_MAX_EPOCHS_SINCE_FINALIZATION = 2,
+
+    // Deposit contract
+    .DEPOSIT_CHAIN_ID = 5,
+    .DEPOSIT_NETWORK_ID = 5,
+    .DEPOSIT_CONTRACT_ADDRESS = b(20, "0x1234567890123456789012345678901234567890"),
+
+    // Networking
+    .MIN_EPOCHS_FOR_BLOCK_REQUESTS = 272,
+
+    // Deneb
+    .MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS = 4096,
+    .BLOB_SIDECAR_SUBNET_COUNT = 6,
+    .MAX_BLOBS_PER_BLOCK = 6,
+    .MAX_REQUEST_BLOB_SIDECARS = 768,
+
+    // Electra
+    .MAX_PER_EPOCH_ACTIVATION_EXIT_CHURN_LIMIT = 128000000000,
+    .MIN_PER_EPOCH_CHURN_LIMIT_ELECTRA = 64000000000,
+    .BLOB_SIDECAR_SUBNET_COUNT_ELECTRA = 9,
+    .MAX_BLOBS_PER_BLOCK_ELECTRA = 9,
+    .MAX_REQUEST_BLOB_SIDECARS_ELECTRA = 1152,
+
+    // Fulu
+    .MIN_EPOCHS_FOR_DATA_COLUMN_SIDECARS_REQUESTS = 4096,
+    .SAMPLES_PER_SLOT = 8,
+    .CUSTODY_REQUIREMENT = 4,
+    .NODE_CUSTODY_REQUIREMENT = 1,
+    .VALIDATOR_CUSTODY_REQUIREMENT = 8,
+    .BALANCE_PER_ADDITIONAL_CUSTODY_GROUP = 32000000000,
+
+    // Blob Scheduling
+    .BLOB_SCHEDULE = &[_]BlobScheduleEntry{},
+};

src/config/root.zig

@@ -7,6 +7,7 @@ pub const ForkInfo = @import("./fork.zig").ForkInfo;
 pub const forkSeqByForkName = @import("./fork.zig").forkSeqByForkName;
 pub const TOTAL_FORKS = @import("./fork.zig").TOTAL_FORKS;
 pub const mainnet_chain_config = @import("./chain/networks/mainnet.zig").mainnet_chain_config;
+pub const minimal_chain_config = @import("./chain/networks/minimal.zig").minimal_chain_config;
 pub const gnosis_chain_config = @import("./chain/networks/gnosis.zig").gnosis_chain_config;
 pub const chiado_chain_config = @import("./chain/networks/chiado.zig").chiado_chain_config;
 pub const sepolia_chain_config = @import("./chain/networks/sepolia.zig").sepolia_chain_config;

src/state_transition/block/process_attestation_phase0.zig

@@ -73,8 +73,9 @@ pub fn validateAttestation(comptime AT: type, cached_state: *const CachedBeaconS
         if (data.index != 0) {
             return error.InvalidAttestationNonZeroDataIndex;
         }
-        var committee_indices: []usize = undefined;
-        _ = try attestation.committee_bits.getTrueBitIndexes(committee_indices[0..]);
+        var committee_indices_buffer: [preset.MAX_COMMITTEES_PER_SLOT]usize = undefined;
+        const committee_indices_len = try attestation.committee_bits.getTrueBitIndexes(committee_indices_buffer[0..]);
+        const committee_indices = committee_indices_buffer[0..committee_indices_len];
         if (committee_indices.len == 0) {
             return error.InvalidAttestationCommitteeBitsEmpty;
         }
@@ -85,12 +86,17 @@ pub fn validateAttestation(comptime AT: type, cached_state: *const CachedBeaconS
             return error.InvalidAttestationInvalidLstCommitteeIndex;
         }
 
-        var aggregation_bits_array: []bool = undefined;
-        try attestation.aggregation_bits.toBoolSlice(&aggregation_bits_array);
+        var aggregation_bits_buffer: [preset.MAX_VALIDATORS_PER_COMMITTEE * preset.MAX_COMMITTEES_PER_SLOT]bool = undefined;
+        var aggregation_bits_slice = aggregation_bits_buffer[0..attestation.aggregation_bits.bit_len];
+        try attestation.aggregation_bits.toBoolSlice(&aggregation_bits_slice);
+        const aggregation_bits_array = aggregation_bits_slice;
         // instead of implementing/calling getBeaconCommittees(slot, committee_indices.items), we call getBeaconCommittee(slot, index)
         var committee_offset: usize = 0;
         for (committee_indices) |committee_index| {
             const committee_validators = try epoch_cache.getBeaconCommittee(slot, committee_index);
+            if (committee_offset + committee_validators.len > aggregation_bits_array.len) {
+                return error.InvalidAttestationCommitteeAggregationBitsLengthTooShort;
+            }
             const committee_aggregation_bits = aggregation_bits_array[committee_offset..(committee_offset + committee_validators.len)];
 
             // Assert aggregation bits in this committee have at least one true bit

src/state_transition/block/process_proposer_slashing.zig

@@ -37,6 +37,10 @@ pub fn assertValidProposerSlashing(
         return error.InvalidProposerSlashingProposerIndexMismatch;
     }
 
+    if (header_1.proposer_index >= state.validators().items.len) {
+        return error.InvalidProposerSlashingProposerIndexOutOfRange;
+    }
+
     // verify headers are different
     if (ssz.phase0.BeaconBlockHeader.equals(&header_1, &header_2)) {
         return error.InvalidProposerSlashingHeadersEqual;

src/state_transition/block/process_voluntary_exit.zig

@@ -23,6 +23,11 @@ pub fn isValidVoluntaryExit(cached_state: *CachedBeaconStateAllForks, signed_vol
     const epoch_cache = cached_state.getEpochCache();
     const config = cached_state.config.chain;
     const voluntary_exit = signed_voluntary_exit.message;
+
+    if (voluntary_exit.validator_index >= state.validators().items.len) {
+        return false;
+    }
+
     const validator = state.validators().items[voluntary_exit.validator_index];
     const current_epoch = epoch_cache.epoch;
 

src/state_transition/block/process_withdrawals.zig

@@ -9,6 +9,7 @@ const Withdrawal = ssz.capella.Withdrawal.Type;
 const Withdrawals = ssz.capella.Withdrawals.Type;
 const ValidatorIndex = ssz.primitive.ValidatorIndex.Type;
 const ExecutionAddress = ssz.primitive.ExecutionAddress.Type;
+const PendingPartialWithdrawal = ssz.electra.PendingPartialWithdrawal.Type;
 const ExecutionPayload = @import("../types/execution_payload.zig").ExecutionPayload;
 const hasExecutionWithdrawalCredential = @import("../utils/electra.zig").hasExecutionWithdrawalCredential;
 const hasEth1WithdrawalCredential = @import("../utils/capella.zig").hasEth1WithdrawalCredential;
@@ -38,7 +39,10 @@ pub fn processWithdrawals(
 
     if (state.isPostElectra()) {
         const pending_partial_withdrawals = state.pendingPartialWithdrawals();
-        @memcpy(pending_partial_withdrawals.items, state.pendingPartialWithdrawals().items[processed_partial_withdrawals_count..]);
+        const keep_len = pending_partial_withdrawals.items.len - processed_partial_withdrawals_count;
+
+        std.mem.copyForwards(PendingPartialWithdrawal, pending_partial_withdrawals.items[0..keep_len], pending_partial_withdrawals.items[processed_partial_withdrawals_count..]);
+        pending_partial_withdrawals.shrinkRetainingCapacity(keep_len);
     }
 
     const next_withdrawal_index = state.nextWithdrawalIndex();
@@ -134,7 +138,7 @@ pub fn getExpectedWithdrawals(
         const withdraw_balance: u64 = if (withdraw_balance_gop.found_existing) withdraw_balance_gop.value_ptr.* else 0;
         const balance = if (state.isPostElectra())
             // Deduct partially withdrawn balance already queued above
-            balances.items[validator_index] - withdraw_balance
+            if (balances.items[validator_index] > withdraw_balance) balances.items[validator_index] - withdraw_balance else 0
         else
             balances.items[validator_index];
 

src/state_transition/cache/epoch_cache.zig

@@ -546,8 +546,9 @@ pub const EpochCache = struct {
         // In the spec it means a list of committee indices according to committeeBits
         // This `committeeIndices` refers to the latter
         // TODO Electra: resolve the naming conflicts
-        var committee_indices: []usize = undefined;
-        _ = try committee_bits.getTrueBitIndexes(committee_indices[0..]);
+        var committee_indices_buffer: [preset.MAX_COMMITTEES_PER_SLOT]usize = undefined;
+        const committee_indices_len = try committee_bits.getTrueBitIndexes(committee_indices_buffer[0..]);
+        const committee_indices = committee_indices_buffer[0..committee_indices_len];
 
         var total_len: usize = 0;
         for (committee_indices) |committee_index| {

src/state_transition/root.zig

@@ -37,13 +37,22 @@ pub const processSyncCommitteeUpdates = @import("./epoch/process_sync_committee_
 // Block
 pub const processBlockHeader = @import("./block/process_block_header.zig").processBlockHeader;
 pub const processWithdrawals = @import("./block/process_withdrawals.zig").processWithdrawals;
-pub const getExpectedWithdrawalsResult = @import("./block/process_withdrawals.zig").getExpectedWithdrawals;
+pub const getExpectedWithdrawals = @import("./block/process_withdrawals.zig").getExpectedWithdrawals;
 pub const processExecutionPayload = @import("./block/process_execution_payload.zig").processExecutionPayload;
 pub const processRandao = @import("./block/process_randao.zig").processRandao;
 pub const processEth1Data = @import("./block/process_eth1_data.zig").processEth1Data;
 pub const processOperations = @import("./block/process_operations.zig").processOperations;
 pub const processSyncAggregate = @import("./block/process_sync_committee.zig").processSyncAggregate;
 pub const processBlobKzgCommitments = @import("./block/process_blob_kzg_commitments.zig").processBlobKzgCommitments;
+pub const processAttestations = @import("./block/process_attestations.zig").processAttestations;
+pub const processAttesterSlashing = @import("./block/process_attester_slashing.zig").processAttesterSlashing;
+pub const processDeposit = @import("./block/process_deposit.zig").processDeposit;
+pub const processProposerSlashing = @import("./block/process_proposer_slashing.zig").processProposerSlashing;
+pub const processVoluntaryExit = @import("./block/process_voluntary_exit.zig").processVoluntaryExit;
+pub const processBlsToExecutionChange = @import("./block/process_bls_to_execution_change.zig").processBlsToExecutionChange;
+pub const processDepositRequest = @import("./block/process_deposit_request.zig").processDepositRequest;
+pub const processWithdrawalRequest = @import("./block/process_withdrawal_request.zig").processWithdrawalRequest;
+pub const processConsolidationRequest = @import("./block/process_consolidation_request.zig").processConsolidationRequest;
 
 pub const WithdrawalsResult = @import("./block/process_withdrawals.zig").WithdrawalsResult;
 
@@ -55,6 +64,7 @@ pub const state_transition = @import("./state_transition.zig");
 const EpochShuffling = @import("./utils/epoch_shuffling.zig");
 pub const SignedBlock = @import("./types/signed_block.zig").SignedBlock;
 pub const SignedBeaconBlock = @import("./types/beacon_block.zig").SignedBeaconBlock;
+pub const Attestations = @import("./types/attestation.zig").Attestations;
 
 test {
     testing.refAllDecls(@This());