Merge pull request #5 from 10d9e/feat/impl-precompiles

chore: Release version 0.3.1 with new features and fixes

Author: 10d9e

CHANGELOG.md

@@ -25,7 +25,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Security
 - Nothing yet
 
-## [0.3.0] - 2025-12-20
+## [0.3.1] - 2025-12-02
+
+### Added
+- **PrecompileId.Custom variant**: Added support for custom precompile identifiers via `PrecompileId.custom("id")`
+- **PrecompileId.name() method**: Returns EIP-7910 standardized names for all precompiles (e.g., "SHA256", "BN254_ADD")
+- **PrecompileId.precompile() method**: Convenience method to get the appropriate precompile implementation for a given spec, handling spec-specific variants automatically
+
+### Fixed
+- **ModExp Osaka gas calculation**: Fixed gas calculation formula to use `max(500, complexity * iteration_count)` instead of `500 + complexity * iteration_count` to match EIP-7883 specification
+- **ModExp Osaka complexity calculation**: Fixed to use `max(base_len, mod_len)` instead of `max(base_len, exp_len, mod_len)` for complexity calculation
+- **EIP-7823 input size limit**: Corrected ModExp input size limit from 32768 bytes to 1024 bytes per parameter as specified in EIP-7823
+
+### Changed
+- **PrecompileId type**: Changed from `enum` to `union(enum)` to support Custom variant while maintaining backward compatibility with all existing precompile IDs
+
+## [0.3.0] - 2025-12-01
 
 ### Added
 - **Cross-Platform Makefile**: Comprehensive build system with OS detection and automated dependency installation

src/precompile/main.zig

@@ -1,6 +1,17 @@
 const std = @import("std");
 const primitives = @import("primitives");
 
+// Import precompile modules (needed for PrecompileId.precompile method)
+pub const identity = @import("identity.zig");
+pub const hash = @import("hash.zig");
+pub const secp256k1 = @import("secp256k1.zig");
+pub const secp256r1 = @import("secp256r1.zig");
+pub const modexp = @import("modexp.zig");
+pub const bn254 = @import("bn254.zig");
+pub const blake2 = @import("blake2.zig");
+pub const kzg_point_evaluation = @import("kzg_point_evaluation.zig");
+pub const bls12_381 = @import("bls12_381.zig");
+
 /// Precompile error type
 pub const PrecompileError = error{
     OutOfGas,
@@ -71,7 +82,7 @@ pub const PrecompileOutput = struct {
 pub const PrecompileFn = *const fn (input: []const u8, gas_limit: u64) PrecompileResult;
 
 /// Precompile identifier
-pub const PrecompileId = enum {
+pub const PrecompileId = union(enum) {
     /// Elliptic curve digital signature algorithm (ECDSA) public key recovery function.
     EcRec,
     /// SHA2-256 hash function.
@@ -108,6 +119,88 @@ pub const PrecompileId = enum {
     Bls12MapFp2ToGp2,
     /// ECDSA signature verification over the secp256r1 elliptic curve.
     P256Verify,
+    /// Custom precompile identifier.
+    Custom: []const u8,
+
+    /// Create new custom precompile ID.
+    pub fn custom(id: []const u8) PrecompileId {
+        return PrecompileId{ .Custom = id };
+    }
+
+    /// Returns the name of the precompile as defined in EIP-7910.
+    pub fn name(self: PrecompileId) []const u8 {
+        return switch (self) {
+            .EcRec => "ECREC",
+            .Sha256 => "SHA256",
+            .Ripemd160 => "RIPEMD160",
+            .Identity => "ID",
+            .ModExp => "MODEXP",
+            .Bn254Add => "BN254_ADD",
+            .Bn254Mul => "BN254_MUL",
+            .Bn254Pairing => "BN254_PAIRING",
+            .Blake2F => "BLAKE2F",
+            .KzgPointEvaluation => "KZG_POINT_EVALUATION",
+            .Bls12G1Add => "BLS12_G1ADD",
+            .Bls12G1Msm => "BLS12_G1MSM",
+            .Bls12G2Add => "BLS12_G2ADD",
+            .Bls12G2Msm => "BLS12_G2MSM",
+            .Bls12Pairing => "BLS12_PAIRING_CHECK",
+            .Bls12MapFpToGp1 => "BLS12_MAP_FP_TO_G1",
+            .Bls12MapFp2ToGp2 => "BLS12_MAP_FP2_TO_G2",
+            .P256Verify => "P256VERIFY",
+            .Custom => |id| id,
+        };
+    }
+
+    /// Returns the precompile function for the given spec.
+    ///
+    /// If case of Custom it will return null.
+    ///
+    /// For case where precompile was still not introduced in the spec,
+    /// it will return the fork closest to activation.
+    pub fn precompile(self: PrecompileId, spec: PrecompileSpecId) ?Precompile {
+        return switch (self) {
+            .EcRec => secp256k1.ECRECOVER,
+            .Sha256 => hash.SHA256,
+            .Ripemd160 => hash.RIPEMD160,
+            .Identity => identity.FUN,
+            .ModExp => blk: {
+                // ModExp changes gas calculation based on spec
+                const mod_exp_precompile: Precompile = if (@intFromEnum(spec) < @intFromEnum(PrecompileSpecId.Berlin)) modexp.BYZANTIUM else if (@intFromEnum(spec) < @intFromEnum(PrecompileSpecId.Osaka)) modexp.BERLIN else modexp.OSAKA;
+                break :blk mod_exp_precompile;
+            },
+            .Bn254Add => blk: {
+                // BN254 add - gas cost changes in Istanbul
+                const bn254_add_precompile: Precompile = if (@intFromEnum(spec) < @intFromEnum(PrecompileSpecId.Istanbul)) bn254.add.BYZANTIUM else bn254.add.ISTANBUL;
+                break :blk bn254_add_precompile;
+            },
+            .Bn254Mul => blk: {
+                // BN254 mul - gas cost changes in Istanbul
+                const bn254_mul_precompile: Precompile = if (@intFromEnum(spec) < @intFromEnum(PrecompileSpecId.Istanbul)) bn254.mul.BYZANTIUM else bn254.mul.ISTANBUL;
+                break :blk bn254_mul_precompile;
+            },
+            .Bn254Pairing => blk: {
+                // BN254 pairing - gas cost changes in Istanbul
+                const bn254_pair_precompile: Precompile = if (@intFromEnum(spec) < @intFromEnum(PrecompileSpecId.Istanbul)) bn254.pair.BYZANTIUM else bn254.pair.ISTANBUL;
+                break :blk bn254_pair_precompile;
+            },
+            .Blake2F => blake2.FUN,
+            .KzgPointEvaluation => kzg_point_evaluation.POINT_EVALUATION,
+            .Bls12G1Add => bls12_381.g1_add.PRECOMPILE,
+            .Bls12G1Msm => bls12_381.g1_msm.PRECOMPILE,
+            .Bls12G2Add => bls12_381.g2_add.PRECOMPILE,
+            .Bls12G2Msm => bls12_381.g2_msm.PRECOMPILE,
+            .Bls12Pairing => bls12_381.pairing.PRECOMPILE,
+            .Bls12MapFpToGp1 => bls12_381.map_fp_to_g1.PRECOMPILE,
+            .Bls12MapFp2ToGp2 => bls12_381.map_fp2_to_g2.PRECOMPILE,
+            .P256Verify => blk: {
+                // P256 verify - gas cost changes in Osaka
+                const p256_precompile: Precompile = if (@intFromEnum(spec) < @intFromEnum(PrecompileSpecId.Osaka)) secp256r1.P256VERIFY else secp256r1.P256VERIFY_OSAKA;
+                break :blk p256_precompile;
+            },
+            .Custom => return null,
+        };
+    }
 };
 
 /// Precompile specification ID
@@ -309,16 +402,6 @@ pub const Precompiles = struct {
     }
 };
 
-// Import precompile modules
-pub const identity = @import("identity.zig");
-pub const hash = @import("hash.zig");
-pub const secp256k1 = @import("secp256k1.zig");
-pub const secp256r1 = @import("secp256r1.zig");
-pub const modexp = @import("modexp.zig");
-pub const bn254 = @import("bn254.zig");
-pub const blake2 = @import("blake2.zig");
-pub const kzg_point_evaluation = @import("kzg_point_evaluation.zig");
-pub const bls12_381 = @import("bls12_381.zig");
 
 // Import test module
 pub const tests = @import("tests.zig");

src/precompile/modexp.zig

@@ -113,9 +113,12 @@ fn berlinGasCalc(base_len: u64, exp_len: u64, mod_len: u64, exp_highp: primitive
     return 200 + @as(u64, @intCast(complexity * iteration_count / 3));
 }
 
-/// Calculate gas cost for Osaka (EIP-7823)
+/// Calculate gas cost for Osaka (EIP-7823 and EIP-7883)
+/// Formula: max(500, complexity * iteration_count)
+/// where complexity is based on max(base_len, mod_len), not exp_len
 fn osakaGasCalc(base_len: u64, exp_len: u64, mod_len: u64, exp_highp: primitives.U256) u64 {
-    const max_len = @max(@max(base_len, exp_len), mod_len);
+    // Use max(base_len, mod_len) for complexity, not exp_len
+    const max_len = @max(base_len, mod_len);
     const iteration_count = calculateIterationCount(exp_len, exp_highp, 16);
 
     var complexity: u64 = 0;
@@ -126,7 +129,8 @@ fn osakaGasCalc(base_len: u64, exp_len: u64, mod_len: u64, exp_highp: primitives
         complexity = 2 * words * words;
     }
 
-    return 500 + @as(u64, @intCast(complexity * iteration_count));
+    const gas = complexity * iteration_count;
+    return @max(@as(u64, @intCast(500)), gas);
 }
 
 /// Run modexp with specific gas calculation
@@ -155,8 +159,8 @@ fn runInner(
     const exp_len_u256 = extractU256(&exp_len_bytes);
     const mod_len_u256 = extractU256(&mod_len_bytes);
 
-    // Check EIP-7823 limits for Osaka
-    const EIP7823_LIMIT: u64 = 32768;
+    // Check EIP-7823 limits for Osaka (1024 bytes per parameter)
+    const EIP7823_LIMIT: u64 = 1024;
     if (is_osaka) {
         if (base_len_u256 > EIP7823_LIMIT or exp_len_u256 > EIP7823_LIMIT or mod_len_u256 > EIP7823_LIMIT) {
             return main.PrecompileResult{ .err = main.PrecompileError.ModexpEip7823LimitSize };

src/version.zig

@@ -1,10 +1,10 @@
 // Version information for ZEVM
-pub const VERSION = "0.3.0";
+pub const VERSION = "0.3.1";
 pub const VERSION_MAJOR = 0;
 pub const VERSION_MINOR = 3;
-pub const VERSION_PATCH = 0;
+pub const VERSION_PATCH = 1;
 pub const VERSION_STRING = "ZEVM v" ++ VERSION;
-pub const RELEASE_DATE = "2025-12-20";
+pub const RELEASE_DATE = "2025-12-02";
 
 // Build information
 pub const BUILD_DATE = @compileError("Build date should be set by build system");