bitpro가 원문에서 글자만 모은 내용이에요. 표·그림·수식은 빠지거나 깨질 수 있어요. 전체 13쪽 중 1쪽
On this page
The Era of Expressivity is Here
Fluent is the first
blended execution network
where EVM, WASM, and SVM (soon) contracts talk to each other like they're written in the same language. No bridges. No friction. Just pure
expressivity
.
💡
The Fluent Advantage
EVM, SVM and Wasm blended into one chain. Build 10x apps with a 10x toolkit.
Target Audience
The main audience for this documentation are smart contract developers deploying on Fluent, using the
gblend
CLI tool and Fluentbase SDK. To a lesser extent, the documentation also serves infra operators and protocol engineers.
Choose your adventure and start blending!
Connect to Fluent
You know what to do? Connect to Fluent and blend it.
Developer Guides
Deploy blended apps in minutes. Rust ↔ Solidity made simple.
Study the Tech
Dive deep into rWasm and blended execution architecture.
Connect to Fluent
You know what to do? Connect to Fluent and blend it.
Developer Guides
Deploy blended apps in minutes. Rust ↔ Solidity made simple.
Study the Tech
Dive deep into rWasm and blended execution architecture.
gblend
: Your New Best Friend
If you're an application developer on Fluent, no matter your language of choice, the
gblend
CLI tool handles everything from project scaffolding to deployment.
🔍
Start Blending
Get started in just a few commands with the
quick install
.
Why Developers Choose Fluent
🚀 Write in Your Favorite Language
Build with Solidity's ecosystem maturity, Rust's performance, or just blend it all in one app.
⚡ True Cross-VM Composability
Your Rust contract calls your Solidity contract directly. No complex bridging or state synchronization.
🔧 Ethereum L2 Benefits
Same security guarantees, familiar tooling, existing wallet support—but with
multi-VM
blended VM
superpowers.
🔍
Info
Currently in public testnet with Solidity and Rust support. More languages coming soon.
The Era of Expressivity is Here
Target Audience
gblend
: Your New Best Friend
Why Developers Choose Fluent
## /connect-to-fluent
On this page
Connect to Fluent
Fluent, the blended execution network, is now on testnet. Fluent and the Fluentbase SDK are explicitly designed for deploying and interacting with EVM and Rust-based smart contracts. Solidity and Rust contracts can be deployed independently, or call each other as part of a
blended application
that utilizes both types of contracts.
Fluent Mainnet
Network Parameters
Network Name:
Fluent Mainnet
HTTPS RPC URL:
https://rpc.fluent.xyz/
Chain ID:
25363
Symbol:
ETH
Explorer:
https://fluentscan.xyz/
Portal (Bridge):
https://portal.fluent.xyz/
Fluent Testnet
⚠️
Warning
The Fluent Testnet is more stable than Devnet, but it is still under active development and may experience occasional resets or downtime. While less frequent, network changes can still result in the loss of deployed contracts and data. Please use Testnet for development and testing only—do not rely on it for production use.
Network Parameters
Network Name:
Fluent Testnet
HTTPS RPC URL:
https://rpc.testnet.fluent.xyz/
Chain ID:
20994
Symbol:
ETH
Explorer:
https://testnet.fluentscan.xyz/
Network Resources
Faucet:
https://portal.fluent.xyz/builder/faucet
Websocket RPC URL:
wss://rpc.testnet.fluent.xyz/ws
Fluent Devnet
Devnet (Fluent Developer Preview) will also remain available to developers with slightly different service levels (see the dedicated sections below for more info).
🚨
Danger
The Fluent Devnet is experimental and may be reset at any time to apply upgrades or improve stability. Please be aware that network resets can result in the loss of deployed contracts and data.
Network Parameters
Network Name:
Fluent Developer Preview
HTTPS RPC URL:
https://rpc.devnet.fluent.xyz/
Chain ID:
20993
Symbol:
ETH
Explorer:
https://devnet.fluentscan.xyz/
Network Resources
Faucet:
https://portal.fluent.xyz/builder/faucet
Websocket RPC URL:
wss://rpc.dev.gblend.xyz/ws
Quickstart Testnet Connect
To quickly integrate Fluent with your wallet, visit the
Fluent Developer Portal
and add network info:
Or add manually with the network info you find below.
Connect to Fluent
Fluent Mainnet
Network Parameters
Fluent Testnet
Network Parameters
Network Resources
Fluent Devnet
Network Parameters
Network Resources
Quickstart Testnet Connect
## /system-architecture/overview
On this page
Fluent is an Ethereum-aligned L2 that runs EVM, Wasm, and (soon) SVM contracts on a single shared state machine. This section skips the pitch for blended execution —
Blended 101
covers that — and describes what the system actually looks like once a transaction lands on a node: who runs the code, where state lives, how privileged operations are gated, and how effects get committed.
Three layers
A Fluent node has three cooperating layers, and most of the interesting engineering lives at their boundaries.
Node and consensus shell.
A modified
Reth
stack handles networking, the mempool, block and transaction pipelines, and every JSON-RPC endpoint a wallet or indexer would expect. To an external client, a Fluent node looks like an Ethereum execution client — for most RPC calls, it behaves like one.
Execution coordination.
REVM plus its host handlers. This layer owns frame lifecycle (how a call's context is set up, nested, and torn down), the journal that records tentative state changes, and the syscall boundary where the runtime asks the host for things it cannot do itself. Every consensus-critical commit path lives here.
Runtime execution.
Contract code runs under Fluent's rWasm-centered executor in one of two modes:
contract mode
for untrusted user code (isolated, strict bounds, strict fuel), and
system mode
for the protocol's own delegated runtimes — EVM, Wasm, SVM, Universal Token. Both compile to the same substrate. The difference is how tightly bounded each mode is, and how deeply it hooks into the host.
Why execution and commit are split
Running code and committing its effects are deliberately separate steps. A runtime executes until it needs something it cannot do — touch shared state, read another account, spawn a nested call — and then it yields. The host takes over, validates the request, performs the operation, and hands control back with a result.
That split is why one chain can safely host multiple execution environments. The environments never mutate state directly; they speak to the host over a fixed protocol. The host is the only place consensus rules are enforced, and every runtime is an isolated consumer of that service.
🔍
Info
The yield-and-resume mechanism is called the
interruption protocol
. Every privileged operation on Fluent flows through it. Details in
Interruption and Syscalls
.
What rWasm brings to the picture
rWasm — reduced WebAssembly — is Fluent's execution substrate. It's a Wasm-derived bytecode optimized for zero-knowledge proving, with deterministic semantics and engine-metered fuel. Wasm contracts map to it directly. EVM bytecode runs under a delegated EVM runtime that itself runs on rWasm. SVM ELF payloads go through their own delegated runtime. Everything converges on one proving surface.
Day to day, app developers don't see this. You write Solidity or Rust, you deploy, and the runtime router picks the right execution path based on your init code. rWasm becomes visible at the edges: when a Solidity contract calls a Rust contract atomically, when you query raw account data for a proof, or when you notice that gas accounting has a second unit called fuel sitting underneath it.
What this section covers
Execution Model
— normal call lifecycle, contract vs system modes, and the structured envelopes system runtimes use to hand state changes to the host.
Runtime Routing and Ownable Accounts
— how one state machine hosts many execution environments without duplicating runtime logic per account.
Precompiles
— the full set of system precompiles installed at genesis: delegated runtimes, system contracts, and standard EVM precompiles.
Interruption and Syscalls
— the
exec
/
resume
handshake and the two syscall surfaces on top of it.
Gas and Fuel
— why Fluent has two metering units and how they settle against each other.
State and RPC Compatibility
— shared state, ownable-account wrapping, and the two RPC views the node exposes.
Runtime Upgrade
— how privileged runtime bytecode is replaced, and what stops anyone else from doing it.
Security Invariants
— the consensus-critical boundaries that hold the system together.
Rollup Architecture
— how Fluent batches, commits, and settles to Ethereum.
Three layers
Why execution and commit are split
What rWasm brings to the picture
What this section covers
## /system-architecture/execution-model
On this page
Fluent doesn't execute every contract with a single uniform engine. A transaction routes through REVM, REVM picks the runtime that should run the logic, and from that point REVM coordinates every state change that runtime makes. That's how EVM, Wasm, the Universal Token runtime, and future additions like SVM all live behind one commit model.
This page walks through what that looks like during a normal call.
The components in play
Five pieces of the execution layer do the heavy lifting inside a running node:
REVM integration layer
— frame setup, the journal of tentative state changes, and the host side of every syscall.
Runtime executor
— runs rWasm modules in either
contract mode
(isolated, strict bounds, user contracts) or
system mode
(cached compiled executors, structured outputs, protocol-owned runtimes) and tracks the resumable context interruption uses.
Interruptible EVM runtime
— the delegated runtime contract that executes EVM bytecode inside Fluent, itself running under rWasm.
SDK and runtime-context layer
— contract-facing APIs and the structured envelope handling that system runtimes use to report side effects back to the host.
Shared types and constants
— syscall indexes, address maps, runtime limits, gas and fuel constants, wire structs. These define the protocol-level contract between runtime and host.
Every concrete behavior on this page comes out of how those pieces interact. The other pages in this section zoom in on each one.
The normal call lifecycle
A transaction lands on the node, REVM invokes the runtime, and the flow goes:
REVM prepares the frame: input bytes, caller, value, context flags, a fuel budget derived from remaining gas.
It invokes the runtime with that input and fuel limit.
The runtime returns either a final result or an interruption request. The distinction is in the exit code:
<= 0
is a final status (success, revert, or an error class);
> 0
is an interruption, and its numeric value is the runtime's
call_id
— a handle into a saved execution context.
On a final result, REVM maps the exit code into an instruction result and applies the journal.
On an interruption, the host performs the requested operation — a storage read, a nested call, a metadata update, whatever the runtime asked for — then resumes the runtime with the answer, the fuel accounting delta, and any returned data.
The journal commits only when a frame completes successfully.
Step 3 is the choke point. Every privileged operation in the system funnels through the same protocol, and that's what lets one state machine host multiple runtimes safely: each runtime is a deterministic function that yields to the host for anything it shouldn't do on its own.
Two execution modes
Not every runtime is treated the same. The executor runs in one of two modes, and the choice affects everything from how fuel is metered to how side effects are transported.
Contract mode
runs untrusted user contracts. The execution context is isolated, all bounds and fuel are strictly enforced, and nothing about the call assumes privilege. Every ordinary Solidity or Rust contract takes this path.
System mode
is reserved for the small set of runtimes the protocol itself ships: the delegated EVM runtime, the delegated Wasm runtime, the Universal Token runtime, the runtime-upgrade precompile, the fee manager, the bridge. These get cached compiled executors (the runtime stays hot, not recompiled per call) and produce
structured output envelopes
instead of opaque return buffers.
Mode selection is address-based: if the callee belongs to the system-runtime set defined in shared constants, the executor runs in system mode. Otherwise, contract mode.
Structured envelopes
System runtimes need to say more than "here are my return bytes." One system call might need to report storage diffs, emitted logs, metadata transitions, and the outcome of a nested frame — all in a form the host can apply deterministically. The envelope contract is what gets that across the runtime-host boundary without ambiguity.
There are three envelope shapes, one per lifecycle point:
New-frame input envelope
— how a system runtime describes a new frame it wants the host to create (target, value, input, call kind).
Interruption outcome envelope
— the payload the host produces for the runtime to consume after a privileged action.
Final execution outcome envelope
— what a completed system call produces: return value, storage diff, logs, metadata updates, and the frame's final status.
Contract-mode calls don't use envelopes. Their return path is a plain bytes buffer; state changes are journal entries the host writes during interruption handling.
🔍
Info
Envelope decoding is part of the consensus surface. A malformed envelope or a misinterpreted field can commit wrong side effects. Changing envelope shapes is a protocol change, not a refactor.
The address map is part of consensus
One subtlety: the set of addresses that triggers system mode is fixed in shared constants. That set includes the delegated runtime owners for each supported VM family (EVM, Wasm, SVM, Universal Token) and the protocol-owned contracts that run under privilege — runtime upgrade, fee manager, bridge, and so on. The full inventory is in
Precompiles
.
Changing this map changes routing. Adding an address pulls a new runtime into the privileged set; removing one breaks every deployment that relied on it. That's why the address map is versioned at the protocol level and never modified as an incidental change.
The components in play
The normal call lifecycle
Two execution modes
Structured envelopes
The address map is part of consensus
## /system-architecture/runtime-routing-and-ownable-accounts
On this page
Fluent hosts multiple execution environments on one state machine without duplicating runtime logic for every account. It does that by separating two things most chains conflate:
who owns the state
and
which engine runs the code
. An account always owns its storage, but its executable behavior is delegated to a runtime picked at deployment.
This routing mechanism — ownable accounts — is what makes cross-VM composability work. A Solidity contract and a Rust contract end up in the same state trie, each with isolated storage, calling each other atomically, but each executed by the runtime that knows how to interpret its bytecode.
The ownable account format
Most contracts deployed on Fluent live in an account whose code field is an
ownable-account wrapper
(magic prefix
0xEF44
). Wasm contracts are the exception: their account code is the compiled rWasm directly (magic prefix
0xEF52
), with the wrapper replaced during deploy — see
The Wasm-wrapper deploy rewrite
below. For wrapped accounts, the wrapper carries three things:
a
magic and version header
identifying the account as runtime-owned,
an
owner_address
— the delegated runtime that should execute this account,
runtime metadata
bytes — context the runtime needs to interpret the account (original bytecode, compilation flags, class markers, anything runtime-family-specific).
owner_address
is the load-bearing field. When a call targets this account, REVM doesn't load code from the account itself. It loads code from the owner, and forwards the call into that delegated runtime with the account as the state target.
Create-time routing
Which runtime owns a new account is decided at deployment. When init code arrives, the routing layer inspects the leading bytes for a magic prefix and picks a runtime accordingly:
Init code prefix
Delegated runtime
Wasm / rWasm magic
Wasm delegated runtime
SVM ELF payload
(feature-gated)
SVM delegated runtime
(reserved — see
Precompiles
)
UNIVERSAL_TOKEN_MAGIC_BYTES = 0x45524320
(
"ERC "
)
Universal Token runtime
Anything else
Delegated EVM runtime
Two things happen next. The new account's code is set to the ownable-account wrapper pointing at the chosen runtime, and the original init payload is passed to the delegated runtime for whatever deploy-time logic that runtime defines — constructor execution, storage initialization, role assignment. Wasm contracts undergo one extra step at the end of this flow that swaps the wrapper for compiled rWasm — see
The Wasm-wrapper deploy rewrite
below.
After that, the account's execution class is frozen. There's no later toggle that switches a Solidity contract to the Wasm runtime. Ownership is established at deploy and is part of the account's identity.
Execution-time behavior
When a routed account is called during a transaction:
REVM sees the call target is an ownable account.
It reads
owner_address
from the wrapper.
It loads the delegated runtime's code from that owner address.
It keeps the original callee as the
state target
— storage reads and writes hit the callee's slots, not the runtime's.
It forwards the call input to the delegated runtime.
The delegated runtime executes the account's logic from there. It can read and write the callee's storage, emit logs under the callee's address, and yield to the host for privileged operations like any other runtime frame.
That's why many accounts can share one runtime implementation without leaking state between them: runtime code loads from the owner, but the storage domain is always the called account.
Direct calls to delegated runtime addresses are blocked
An obvious attack is to target the delegated runtime address directly and skip the wrapper. If a user could call
owner_address
like a regular contract, they could execute runtime logic in the runtime's own storage domain instead of an ownable account's.
The execution path rejects this. Delegated runtime addresses aren't callable as normal contracts; the router forces user-facing flows to go through an ownable account.
⚠️
Warning
A call that targets a delegated runtime address directly is rejected at execution time. User flows must go through an ownable account, not bypass it. This is a consensus-safety boundary, not a UX preference.
Metadata ownership rules
The runtime metadata attached to an ownable account is mutable, but only by the runtime that owns the account. When a runtime frame tries to mutate metadata on a target account, two checks run:
The target must be an ownable account.
The target's
owner_address
must match the caller's delegated runtime.
If either check fails, the operation is rejected. That keeps one runtime family — say, the EVM runtime — from rewriting metadata on accounts owned by another family like the Wasm runtime. It's the mechanism that stops cross-runtime privilege bugs from becoming cross-runtime state corruption.
Static-context mutations — anything invoked from a
STATICCALL
frame — are rejected for metadata operations regardless of ownership.
The Wasm-wrapper deploy rewrite
Wasm contracts take a different storage path. After the Wasm runtime's
deploy_entry
returns the compiled rWasm module (plus any constructor tail), the executor replaces the temporary ownable wrapper at the deployed address with the rWasm bytes directly. The on-chain code at that address starts with the rWasm magic prefix
0xEF52
instead of the wrapper's
0xEF44
. The 프로젝트로 돌아가기