Steem Virtual Machine — Update: Goodbye Cosmos SDK, Hello Layer 2 on revm

Some of you have been following my work on bringing smart contracts to STEEM. Today I want to give you a major update — including a hard decision I made, why I made it, and a detailed look at what I've built instead. The short version: the Steem Virtual Machine is now a Layer 2 anchored directly to the Steem blockchain, built on revm, with no consensus protocol of its own — and it's going open source in 1–2 weeks.

---

Why I abandoned the Cosmos SDK approach

My original plan was to build the SVM as a Cosmos SDK chain. The deeper I got, the more the architecture fought me:

• A redundant validator set. Cosmos chains need their own validators, their own staking token, their own slashing economics, and their own governance — an entire security budget that has to be bootstrapped from zero. But Steem already has battle-tested block production, ordering, and finality. Building a second consensus layer on top of that isn't security, it's duplication.
• Operational weight. Recruiting validators, coordinating upgrades, managing IBC, keeping a fork of a large framework in sync upstream — that's a full-time team's workload, not a path to something the STEEM community can actually run and verify.
• The trust story got worse, not better. A small new validator set is less trustworthy than Steem's existing witness infrastructure. Why would users trust 5 unknown validators more than the chain they already use?

So I threw it out and asked a simpler question: what is the minimum machinery needed for EVM contracts on Steem? The answer turned out to be: none of the consensus, all of the execution.

The new architecture: a Layer 2 with no consensus protocol

The design is radically simple, and that simplicity is the security model:

Steem L1 (ordering + timestamps + data availability)
        │  custom_json operations
        ▼
SVM Node (one Rust binary)
  1. Block streamer  — follows only IRREVERSIBLE Steem blocks
  2. Op filter       — extracts SVM transactions + bridge deposits
  3. revm executor   — full Ethereum Virtual Machine (Prague rules)
  4. RocksDB state   — atomic, crash-safe, deterministic
  5. eth_* JSON-RPC  — MetaMask / Foundry / ethers.js just work

• Users submit ordinary signed Ethereum transactions, wrapped inside Steem custom_json operations.
• Every SVM node replays the same irreversible Steem blocks in the same order through the same pinned EVM — so every node independently derives byte-identical state. There is nothing to vote on. Agreement is a mathematical consequence of replay, not a protocol.
• No reorgs, ever. The node only processes blocks past Steem's irreversibility point, so every SVM block is final the moment it exists. latest = finalized, always.
• One EVM block per Steem block (~3 second cadence), with end-to-end confirmation in ~45–60 seconds (Steem's irreversibility lag).
• Permissionless inclusion. Transactions normally flow through my RPC relayer for convenience — but anyone can wrap their raw transaction in a custom_json from their own Steem account. Nobody, including me, can stop a transaction from being included.

And because execution is revm — the same Rust EVM used by major Ethereum infrastructure — this isn't "EVM-like." It's the full instruction set. Every Solidity contract that runs on Ethereum runs here, unmodified.

Inside the codebase

The node is a single Rust binary (~5,000 lines plus a comprehensive test suite), organized so every piece is independently verifiable:

Component	What it does
Steem streamer	Follows last_irreversible_block with retry/backoff and automatic failover across multiple Steem API endpoints
Op filter	Extracts SVM transactions and bridge deposits; malformed/hostile ops are logged and skipped deterministically — nothing can halt the chain
EVM executor	revm pinned to Prague hardfork rules; decodes legacy (EIP-155), EIP-2930, and EIP-1559 transactions; sender recovered from the signature, so only your key spends your funds
State database	RocksDB where each block's state changes, records, receipts, and sync height commit in one atomic WriteBatch — you can kill -9 the node at any moment and it resumes cleanly
Block deriver	Turns each Steem block into an EVM block: deposits mint first, transactions execute in Steem order, block hashes computed over a fixed binary serialization
JSON-RPC server	The full eth_* read/write surface: balances, blocks, receipts, logs, eth_call, eth_estimateGas, eth_sendRawTransaction — MetaMask and Foundry work against it out of the box
Bridge in	Send STEEM to the gateway account with your EVM address as the memo → wSTEEM (18 decimals) mints to that address
Bridge out	Send wSTEEM to the burn address with your Steem username as calldata → your transaction signature itself authorizes the withdrawal; payout arrives with the burn tx hash as memo for full auditability
Payout worker	Per-transaction and hourly caps, strict one-payout-per-burn idempotency, and a dead-letter queue — engineering that assumes bugs will happen and bounds their damage
Multisig stack	A 2-of-3 gateway signer system: a proposer that cannot broadcast alone, and an independent co-signer on separate infrastructure that re-verifies every single burn against its own node before adding the second signature
Ops tooling	Health endpoint, bridge-invariant checker (total_supply == deposits − gas burned, checked continuously), runbook, systemd units, and Docker/compose packaging

How it's been tested

I'm not shipping "trust me" software. The claims are checked by machines:

• Determinism proven twice. Two completely independent nodes synced fresh from genesis against live Steem mainnet and produced byte-identical block hashes — and served byte-identical JSON-RPC responses across a 4,700-block range.
• Crash safety proven. Force-killed mid-sync repeatedly; resumes from the exact committed height every time.
• Adversarial suite. A single block stuffed with every attack I could think of — malformed JSON, garbage hex, wrong-chain transactions, replayed duplicates, oversized payloads, fake deposits — derives identically on independent nodes with exactly the valid transactions included.
• Real tooling compatibility. Contracts compiled with Foundry deploy and run; transactions built with cast execute identically to natively-signed ones; the full deposit → deploy → interact → withdraw lifecycle is covered end-to-end in tests.
• 25+ automated tests run the entire pipeline offline — anyone will be able to verify everything with one cargo test.

Open source in 1–2 weeks 📅

I'm currently running the final testing phase: extended unattended operation, the live MetaMask end-to-end flow, and hardening the bridge with the multisig gateway. Once that soak completes — 1 to 2 weeks from now — the entire codebase goes open source: node, bridge, signer stack, ops tooling, install guides (bare metal + Docker), and honest trust-model documentation.

And here's the part I care most about: because consensus is replay, anyone will be able to run a verifying node with zero permission, zero stake, and zero keys — clone, build, sync, and independently confirm every balance on the chain. The more independent verifiers, the stronger the system. When the repo opens, I'll be asking you to run one.

What this unlocks for STEEM: Solidity smart contracts, DeFi primitives, NFTs, and the entire Ethereum tooling ecosystem — settled on and secured by the chain we already use, with STEEM itself as the gas token.

More details, chain parameters, and the repository link coming in the launch post. Questions, skepticism, and feature requests are all welcome in the comments — especially skepticism.

---

If you value proactive engineering, UX polish, and performance optimizations for the STEEM ecosystem, please consider supporting my witness: blaze.apps

🗳️ Vote Here:
Vote for blaze.apps Witness