LatticePress intercepts, compresses, and decompresses EVM transactions entirely in memory — shrinking Monad's state bloat by 75%.
At 10,000 TPS with ~500-byte average transactions, Monad's network history grows at a staggering rate — making long-term node operation increasingly expensive.
Monad's parallel execution engine processes transactions at blazing speed.
Average transaction payload including selector, arguments, and padding.
Of raw state bloat accumulating every single hour on-chain.
LatticePress operates as an off-chain/on-chain compression pipeline that reconstructs calldata directly in EVM memory using hand-tuned Yul.
The Rust sidecar daemon intercepts raw transaction payloads from the RPC mempool before they hit the network.
4-byte function selectors are replaced with 1-byte dictionary IDs. The remaining payload is Zstd-compressed off-chain.
The LatticeGateway contract expands the dictionary ID back into the full selector in-memory using
pure Yul, then executes via delegatecall.
Real metrics from our Monad Testnet deployment. Every transaction saves bytes. At scale, it saves terabytes.
Watch the bytes pile up. At 10,000 TPS, LatticePress saves storage every millisecond.
Send a real transaction payload to the local LatticePress interceptor running on port 3000. It will ZSTD-compress the payload to prove exact sizes, then submit it to the live Monad test gateway.
The on-chain gateway uses hand-written Yul assembly to decompress payloads directly in EVM memory — zero storage reads, zero copies.
// Read Dictionary ID from first byte of calldata
let dictId := shr(248, calldataload(0))
// 0x01 → transfer(address,uint256) [0xa9059cbb]
if eq(dictId, 0x01) {
mstore(mem, shl(224, 0xa9059cbb))
calldatacopy(add(mem, 4), 1, sub(calldatasize(), 1))
}
// Execute via delegatecall — state lives on the gateway
let ok := delegatecall(gas(), target, mem, len, 0, 0)