fix: separate on-chain/off-chain paths in hasher modules to prevent stack overflow

Applied the same fix pattern to all hasher modules:
- sha256_hasher.zig
- keccak_hasher.zig
- blake3.zig

Each hashv() function now uses `if (comptime is_bpf_program)` to dispatch
to separate implementation functions:
- hashvSyscall() - on-chain, uses syscall, minimal stack
- hashvNative() - off-chain, uses Zig crypto, only compiled for native

This ensures the crypto hasher state (which can be several KB) is never
allocated on stack in BPF programs.

All 361 tests pass.

Author: DaviRain-Su

src/blake3.zig

@@ -18,24 +18,33 @@ const Hash = @import("solana_sdk").Hash;
 /// Rust equivalent: `solana_blake3_hasher::hashv`
 /// Source: https://github.com/anza-xyz/solana-sdk/blob/master/blake3-hasher/src/lib.rs
 pub fn hashv(vals: []const []const u8) Hash {
-    var result_hash: Hash = undefined;
-
-    if (syscalls.is_bpf_program) {
-        // BPF context: use syscall
-        const syscall_result = syscalls.sol_blake3(@ptrCast(vals.ptr), vals.len, &result_hash.bytes);
-        if (syscall_result != 0) {
-            log.print("failed to get blake3 hash: error code {}", .{syscall_result});
-            @panic("blake3 syscall failed");
-        }
+    // Use comptime to ensure off-chain code is not compiled into BPF
+    if (comptime syscalls.is_bpf_program) {
+        return hashvSyscall(vals);
     } else {
-        // Native context: use Zig's crypto library
-        var hasher = std.crypto.hash.Blake3.init(.{});
-        for (vals) |val| {
-            hasher.update(val);
-        }
-        hasher.final(&result_hash.bytes);
+        return hashvNative(vals);
+    }
+}
+
+/// On-chain implementation using syscall - minimal stack usage
+fn hashvSyscall(vals: []const []const u8) Hash {
+    var result_hash: Hash = undefined;
+    const syscall_result = syscalls.sol_blake3(@ptrCast(vals.ptr), vals.len, &result_hash.bytes);
+    if (syscall_result != 0) {
+        log.print("failed to get blake3 hash: error code {}", .{syscall_result});
+        @panic("blake3 syscall failed");
     }
+    return result_hash;
+}
 
+/// Off-chain implementation using Zig's crypto library - only compiled for native
+fn hashvNative(vals: []const []const u8) Hash {
+    var result_hash: Hash = undefined;
+    var hasher = std.crypto.hash.Blake3.init(.{});
+    for (vals) |val| {
+        hasher.update(val);
+    }
+    hasher.final(&result_hash.bytes);
     return result_hash;
 }
 

src/keccak_hasher.zig

@@ -20,24 +20,33 @@ const Hash = @import("solana_sdk").Hash;
 /// Rust equivalent: `solana_keccak_hasher::hashv`
 /// Source: https://github.com/anza-xyz/solana-sdk/blob/master/keccak-hasher/src/lib.rs
 pub fn hashv(vals: []const []const u8) Hash {
-    var result_hash: Hash = undefined;
-
-    if (syscalls.is_bpf_program) {
-        // BPF context: use syscall
-        const syscall_result = syscalls.sol_keccak256(@ptrCast(vals.ptr), vals.len, &result_hash.bytes);
-        if (syscall_result != 0) {
-            log.print("failed to get keccak256 hash: error code {}", .{syscall_result});
-            @panic("keccak256 syscall failed");
-        }
+    // Use comptime to ensure off-chain code is not compiled into BPF
+    if (comptime syscalls.is_bpf_program) {
+        return hashvSyscall(vals);
     } else {
-        // Native context: use Zig's crypto library
-        var hasher = std.crypto.hash.sha3.Keccak256.init(.{});
-        for (vals) |val| {
-            hasher.update(val);
-        }
-        hasher.final(&result_hash.bytes);
+        return hashvNative(vals);
+    }
+}
+
+/// On-chain implementation using syscall - minimal stack usage
+fn hashvSyscall(vals: []const []const u8) Hash {
+    var result_hash: Hash = undefined;
+    const syscall_result = syscalls.sol_keccak256(@ptrCast(vals.ptr), vals.len, &result_hash.bytes);
+    if (syscall_result != 0) {
+        log.print("failed to get keccak256 hash: error code {}", .{syscall_result});
+        @panic("keccak256 syscall failed");
     }
+    return result_hash;
+}
 
+/// Off-chain implementation using Zig's crypto library - only compiled for native
+fn hashvNative(vals: []const []const u8) Hash {
+    var result_hash: Hash = undefined;
+    var hasher = std.crypto.hash.sha3.Keccak256.init(.{});
+    for (vals) |val| {
+        hasher.update(val);
+    }
+    hasher.final(&result_hash.bytes);
     return result_hash;
 }
 

src/sha256_hasher.zig

@@ -18,24 +18,33 @@ const Hash = @import("solana_sdk").Hash;
 /// Rust equivalent: `solana_sha256_hasher::hashv`
 /// Source: https://github.com/anza-xyz/solana-sdk/blob/master/sha256-hasher/src/lib.rs
 pub fn hashv(vals: []const []const u8) Hash {
-    var result_hash: Hash = undefined;
-
-    if (syscalls.is_bpf_program) {
-        // BPF context: use syscall
-        const syscall_result = syscalls.sol_sha256(@ptrCast(vals.ptr), vals.len, &result_hash.bytes);
-        if (syscall_result != 0) {
-            log.print("failed to get sha256 hash: error code {}", .{syscall_result});
-            @panic("sha256 syscall failed");
-        }
+    // Use comptime to ensure off-chain code is not compiled into BPF
+    if (comptime syscalls.is_bpf_program) {
+        return hashvSyscall(vals);
     } else {
-        // Native context: use Zig's crypto library
-        var hasher = std.crypto.hash.sha2.Sha256.init(.{});
-        for (vals) |val| {
-            hasher.update(val);
-        }
-        hasher.final(&result_hash.bytes);
+        return hashvNative(vals);
+    }
+}
+
+/// On-chain implementation using syscall - minimal stack usage
+fn hashvSyscall(vals: []const []const u8) Hash {
+    var result_hash: Hash = undefined;
+    const syscall_result = syscalls.sol_sha256(@ptrCast(vals.ptr), vals.len, &result_hash.bytes);
+    if (syscall_result != 0) {
+        log.print("failed to get sha256 hash: error code {}", .{syscall_result});
+        @panic("sha256 syscall failed");
     }
+    return result_hash;
+}
 
+/// Off-chain implementation using Zig's crypto library - only compiled for native
+fn hashvNative(vals: []const []const u8) Hash {
+    var result_hash: Hash = undefined;
+    var hasher = std.crypto.hash.sha2.Sha256.init(.{});
+    for (vals) |val| {
+        hasher.update(val);
+    }
+    hasher.final(&result_hash.bytes);
     return result_hash;
 }