💻 computer science

n-VM: A Multi-VM Layer-1 Architecture with Shared Identity and Token State

The paper introduces n-VM, a novel Layer-1 architecture that unifies multiple heterogeneous virtual machines under a shared consensus, identity, and token state to eliminate cross-chain fragmentation while achieving high throughput through parallel execution and context-based sharding.

Original authors: Jian Sheng Wang

Published 2026-03-26

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Jian Sheng Wang

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine the current blockchain world as a continent divided by oceans.

On one island, you have Ethereum (EVM). On another, Solana (SVM). On a third, Bitcoin (Script). Each island has its own language, its own currency, and its own rules for who owns what.

If you live on the Ethereum island and want to visit Solana, you have to:

Get a new passport (a new wallet).
Build a fragile bridge to cross the ocean.
Hope the bridge doesn't collapse (which happens often, costing billions).

n-VM is a proposal to build a supercontinent. Instead of separate islands, it creates one giant landmass where all these different "islands" (Virtual Machines) exist side-by-side, sharing the same soil, the same water, and the same government.

Here is how it works, broken down into simple concepts:

1. The "Universal Passport" (Unified Identity)

Right now, if you have a Bitcoin address, it looks nothing like your Ethereum address. They are unrelated.

n-VM introduces a Master ID.

The Analogy: Imagine you have one "Master Key" (a 32-byte code).
When you walk into the Ethereum room, the Master Key automatically generates a specific key for that door.
When you walk into the Solana room, the same Master Key generates a different specific key for that door.
The Magic: You don't need to carry 5 different wallets. You just carry the Master Key. The system knows that "Key A" in the Ethereum room and "Key B" in the Solana room both belong to you. If someone steals your Solana key, they still can't figure out your Ethereum key.

2. The "Traffic Cop" (Opcode Routing)

How does the system know which "room" a transaction belongs to?

The Analogy: Imagine a giant post office. Every letter (transaction) has a colored stamp on the very top corner.
- Red Stamp: Go to the Ethereum room.
- Blue Stamp: Go to the Solana room.
- Green Stamp: Go to the Bitcoin room.
The "Traffic Cop" (the Dispatcher) just looks at the stamp. It takes less than a second to decide where the letter goes. This is incredibly fast and allows the system to handle thousands of letters per second.

3. The "Single Bank Vault" (Unified Token Ledger)

Currently, moving money between chains requires "bridges" that lock your money on one side and print fake "wrapped" money on the other. This is risky.

n-VM has one giant bank vault for everyone.

The Analogy: Imagine a bank where you can speak English, Spanish, or Mandarin.
- If you speak English (EVM), you ask for your balance in "Dollars."
- If you speak Spanish (SVM), you ask for your balance in "Pesos."
- The Reality: The bank teller looks at the same ledger. There is no "wrapped" money. The money is just sitting in the vault. When you transfer from the English side to the Spanish side, the teller just moves the number from one column to another. It happens instantly, with no bridge, and no risk of the bridge getting hacked.

4. The "Parallel Assembly Line" (Speed)

Old blockchains process transactions one by one, like a single cashier at a grocery store.
n-VM is like a supermarket with 64 checkout lanes.

If you are buying apples (EVM transaction) and I am buying milk (Solana transaction), and we aren't buying the same items, we can check out at the same time.
The system checks if our "shopping carts" overlap. If they don't, it processes us simultaneously. This allows the system to handle 16,000 to 66,000 transactions per second (compared to Ethereum's ~15-30).

5. The "Time Travel" Safety Net (Isolation)

What if a program crashes or tries to steal money?

The Analogy: Before the cashier starts scanning your items, they take a photo of the empty counter.
If you try to buy something illegal or the system glitches, they just snap back to the photo. The counter is empty again. No damage is done to the other lanes, and the rest of the store keeps running smoothly.

Why Does This Matter?

No More Bridges: The biggest source of hacks in crypto (bridges) disappears because there is only one chain.
One Wallet: You don't need to manage 10 different apps. One identity works everywhere.
Speed: It's fast enough to handle global traffic (like Visa or Mastercard).
Flexibility: If a new "island" (a new programming language or VM) is invented in the future, you can just add a new "stamp color" to the system without rebuilding the whole continent.

In short: n-VM is the operating system that finally lets Ethereum, Solana, Bitcoin, and others live in the same house, speak their own languages, but share the same bank account and the same security system.

1. Problem Statement

The current blockchain ecosystem is characterized by fragmentation across incompatible execution environments (e.g., Ethereum's EVM, Solana's SVM, Bitcoin's Script, Tron's TVM). This fragmentation leads to three critical issues:

Fragmented Identity: Users must manage separate wallets and key pairs for each ecosystem.
Siloed Liquidity: Assets cannot move freely between chains without relying on third-party bridges.
Security Risks: Cross-chain bridges have historically been the largest source of security failures in DeFi, with over $2.8 billion lost to exploits between 2021 and 2024.

Existing multi-VM solutions (e.g., Movement Labs, Eclipse, Sei v2) typically treat one VM as a subordinate layer (rollup or compatibility layer) to another, failing to unify identity or eliminate bridge dependencies.

2. Methodology: The n-VM Architecture

The paper proposes n-VM, a Layer-1 architecture that hosts $n$ heterogeneous virtual machines as co-equal execution environments over a single consensus mechanism and shared state. The architecture relies on three core components:

A. Opcode-Based Transaction Routing

Mechanism: Transactions are routed to specific VMs based on the first byte (opcode) of the payload.
Design: The 256-value opcode space is partitioned into contiguous, disjoint ranges for each VM (e.g., 0x01–0x0F for Native, 0x10–0x1F for EVM).
Benefit: This allows for $O(1)$ routing with negligible overhead, ensuring deterministic dispatch and extensibility (new VMs can be added without modifying existing engines).

B. Unified Identity Layer (Based on Ace-Gf)

Core Concept: Separation of Identity Binding and Transaction Authorization.
Identity: A single 32-byte commitment (id_com) is derived from a Root Entropy Value (REV) using the Ace-Gf framework:
$id\_com = \text{Poseidon}(REV, salt, domain)$
Address Derivation: VM-specific addresses are deterministically derived from id_com using domain-separated hashing (e.g., SHA-256("evm:" || id_com)).
Legacy Support: A "Raw Chain Ingress" mechanism allows users to interact using existing wallets (MetaMask, Phantom, etc.) by verifying native signatures and mapping them to the unified id_com.

C. Unified Token Ledger

Single Source of Truth: Instead of separate token states per VM, all token balances are stored in a single built-in program account within the shared state tree.
Multi-Interface Access: The ledger exposes native interfaces (ERC-20 for EVM, SPL for SVM) as views over the same underlying data.
Atomicity: Cross-VM token transfers are executed as a single state transition on the unified ledger, eliminating the need for lock-mint-burn bridge cycles.

D. Parallel Execution & Sharding

Write-Set Scheduler: The system extracts write sets from transactions. Transactions with disjoint write sets are batched and executed in parallel (using Rayon), while conflicting transactions are serialized.
Context Sharding: Transactions carry a 16-byte context tag to assign them to specific shards (default 64), enabling massive parallelism for intra-shard operations.

3. Key Contributions

Generalized n-VM Framework: A formal definition for hosting $n$ co-equal VMs on a single L1 chain with opcode-based routing and a pluggable engine interface.
Unified Identity Formalization: Proof of context isolation and deterministic address derivation from a single identity commitment, ensuring that a compromise in one VM does not reveal addresses in others.
Unified Token Ledger: A design proving that cross-VM token transfers are atomic and bridge-free, as they operate on a single balance store.
Parallel Execution Model: A conflict detection scheduler and context-based sharding scheme that scales throughput.
Concrete Instantiation: A Rust implementation supporting 5 VMs:
- Native: Custom runtime.
- EVM: Full Solidity/Vyper support (revm).
- SVM: Solana Program Library support.
- BVM: Bitcoin Script interpreter.
- TVM: Tron compatibility (via EVM opcode remapping).

4. Results and Performance

Throughput Projections: Under analytical models assuming 16-core commodity hardware and 400ms block times:
- Sequential: ~5,000 TPS.
- Parallel Batching: ~16,000 TPS.
- Context Sharding (64 shards): ~33,000 to 66,000 TPS.
Security: The architecture guarantees execution isolation (failures in one VM do not corrupt the shared state) and deterministic block execution across all validators.
Implementation: The ace-n-vm crate consists of ~5,000 lines of Rust code with 3,000 lines of tests, successfully integrating the five VM engines.

5. Significance

The n-VM architecture represents a paradigm shift in blockchain design by moving from multi-chain (fragmented, bridge-dependent) to multi-VM (unified, bridge-free) ecosystems.

Elimination of Bridges: By unifying identity and token state, it removes the primary attack surface for DeFi hacks (bridges).
User Experience: Users can interact with multiple ecosystems (Bitcoin, Ethereum, Solana, Tron) using a single identity and wallet.
Extensibility: The architecture is parametric; adding new VMs (e.g., Move, WASM) requires only implementing an engine interface and registering an opcode range, without altering the core consensus or identity layers.
Scalability: The combination of write-set conflict detection and context sharding offers a viable path to high-throughput Layer-1 blockchains capable of handling tens of thousands of transactions per second on standard hardware.

In conclusion, n-VM provides a robust, secure, and scalable foundation for a unified global blockchain economy where diverse execution environments coexist without fragmentation.