bitpro가 원문에서 글자만 모은 내용이에요. 표·그림·수식은 빠지거나 깨질 수 있어요. 전체 2쪽 중 1쪽
SOLAYER CHAIN : Infinitely Scalable Hardware-Accelerated
SVM Network
Jason Li, Chaofan Shou, Qi Su, Chaz Cui, and Tony Ke
(lxj,shou,changzecui)@berkeley.edu, qisu@cs.ucsb.edu,
yuanyu.ke@link.cuhk.edu.hk
January 7, 2025
Abstract
We introduce S OLAYER CHAIN , a next-generation blockchain architecture that scales a
single, global state machine to achieve unprecedented throughput, low latency, and robust
composability. Unlike conventional vertical scaling or sharded rollups, S OLAYER CHAIN
maintains atomic state transitions by distributing the workload a cross microservices and spe-
cialized hardware accelerators. It offloads signature checks, transaction filtering, pre-execution
simulation, scheduling, and storage to distinct scalable clusters, each optimized for its func-
tion. Transactions are speculatively executed before reaching the sequencer, then finalized
through a hybrid Proof-of-Authority-and-Stake consensus. The architecture leverages Infini-
band RDMA for near-microsecond inter-node communication and advanced concurrency con-
trol strategies to minimize re-execution. A shared-nothing key-value store, sharded across
multiple nodes, supports arbitrarily large account data with load balancing. S OLAYER CHAIN
pushes blockchain performance to hardware limits, targeting 1M+ TPS and 100Gbps+ net-
work bandwidth. This design provides a path for next-generation applications that require
high throughput, low fees, and a seamless composable environment. S OLAYER CHAIN also
introduces multiple user experience improvements. Hooks allow developers to embed post-
transaction logic—such as arbitrage, liquidations, and accounting—directly within the chain,
while jumbo transactions, cross-chain calls, and built-in OAuth support further enhance devel-
oper and user experience.
Disclaimer: The information contained in this paper is provided for informational and
research purposes only and does not constitute investment advice, financial advice, trading
advice, or any other form of advice. The implementation details are subject to change and may
differ from what is described here.
1
1 Introduction
Blockchain scalability remains a foundational challenge for decentralized systems, as rising trans-
action volumes demand faster processing, larger data storage, and robust consensus protocols—all
without compromising security or decentralization. High-performance blockchains can reduce
transaction times and fees, foster a positive user experience, and open the door to large-scale appli-
cations.
As the industry matures, the demand for block space continues to increase. On platforms like
Ethereum, heightened demand raises gas fees due to fee auctions; on Solana, a flooded network
can lead to dropped or expired transactions. Typical metrics such as transactions per second (TPS)
shed light on throughput, yet blockchains have grown beyond simple transfers to support Turing-
complete smart contracts and complex functionality. Meeting these demands requires rethinking
how block space is provisioned and how state is managed.
Horizontal scaling approaches, such as Ethereum’s Layer 2 (L2) rollups, move transaction
processing off the main chain into separate, independently updated states, posting final results
back on L1. While this boosts throughput, it fragments a once-unified global state, weakening
composability, atomic state transitions, and liquidity. For instance, if an asset is split across multiple
pools on different rollups, a cross-rollup swap can suffer higher slippage relative to a single, unified
liquidity pool. Vertical scaling strategies, exemplified by Solana, aim to maximize throughput
within a single-state machine by optimizing the virtual machine for parallel execution, writing
high-performance software, and running on powerful consumer-grade hardware. This preserves
transaction atomicity and streamlines execution, allowing the system to coordinate changes cleanly
and maintain composability. Solana’s success in hosting numerous token launches and generating
large on-chain trading volumes reflects the power of this design.
Despite its advantages, Solana’s approach now encounters inherent hardware limits. To keep
pace with current throughput, validators already require CPUs exceeding 3.1 GHz, more than 500
GB of high-speed RAM, and at least 2.5 TB of high-throughput NVMe storage. With CPU utiliza-
tion hovering around 30% under heavy load, further gains via software optimization alone are lim-
ited. Instead, additional acceleration—such as offloading certain tasks to FPGAs—becomes essen-
tial to push performance even higher. Moreover, validators must store and access ever-expanding
account data. Standard consumer-grade hardware will inevitably be replaced by specialized so-
lutions, like NVMe-oF, for scaling storage without sacrificing low latency. Network bandwidth
similarly faces pressure: peer-to-peer (P2P) communication already consumes around 0.8 Gbps
per validator, posing a risk of exceeding the 1 Gbps internet limits typical of consumer-grade net-
working environments if throughput continues to increase.
2
Figure 1: System architecture
To address these emerging bottlenecks, we advocate for a multi-executor, hardware-accelerated
SVM network. The design is shown in Figure 1. This design scales a single-state blockchain in-
finitely by distributing workload across specialized hardware and clusters while preserving a global
atomic state. The following sections outline how this architecture decomposes critical pipeline
stages into microservices to scale non-atomic components like ingress and state publishing, hard-
ware acceleration for scheduling and locking, a sharded database for scaling storage, and a new hy-
brid consensus protocol based on Solana that guarantees both security and low latency. To further
increase usability, SOLAYER CHAIN introduces chain-level supports of hooks, cross-chain contract
calls, jumbo transactions, seamless wallet support, and OAuth-based signers. Overall, S OLAYER
CHAIN aims to become the most user-friendly chain with 1M+ TPS and 100Gbps+ bandwidth.
2 Background
In the following subsections, we introduce the background of technology leveraged by S OLAYER
CHAIN .
3
2.1 Solana and SVM
Solana introduces a novel blockchain architecture that fundamentally departs from traditional con-
sensus mechanisms through its proof-of-history (PoH) protocol and parallel execution environ-
ment. The SVM employs a shared-nothing architecture where each transaction’s read and write sets
are determined prior to execution. This enables the runtime to construct a dependency graph that
maximizes parallel execution while maintaining serializability guarantees. Unlike the Ethereum
Virtual Machine’s sequential execution model, SVM processes non-conflicting transactions con-
currently across available CPU cores. The SVM’s memory model implements a multi-version
concurrency control (MVCC) mechanism, maintaining multiple versions of data to support con-
current read operations while ensuring write operations maintain strict serialization order based on
the PoH sequence.
The EVM and SVM exemplify contrasting approaches to concurrency control. The EVM em-
ploys optimistic concurrency control, where transactions are processed concurrently under the as-
sumption that conflicts will be rare. However, because transactions do not declare their state access
upfront, conflicts—such as multiple transactions attempting to modify the same state—are only
detected at runtime, requiring rollbacks and retries. In contrast, the SVM adopts pessimistic con-
currency control, where transactions must declare their state access patterns upfront. This allows
Solana’s Sealevel parallel execution engine to execute non-overlapping transactions concurrently,
avoiding conflicts altogether. By combining explicit state access declarations with advanced mem-
ory and execution models, Solana achieves unparalleled scalability and efficiency in blockchain
processing.
2.2 RDMA and Infiniband
Remote Direct Memory Access (RDMA) enables zero-copy data transfer directly between ap-
plication memory spaces across network-connected systems. Modern RDMA implementations
leverage specialized network interface cards (RNICs) that implement both the transport protocol
and direct memory operations in hardware. This architecture bypasses traditional operating system
networking stacks, eliminating context switches and CPU overhead associated with network I/O
processing. The RDMA protocol suite implements both connection-oriented (Reliable Connected)
and connectionless (Unreliable Datagram) transport modes, with the former providing guaranteed
in-order delivery and the latter optimizing for low-latency scenarios where applications can tolerate
potential packet loss. The protocol’s memory semantics enable remote memory operations to com-
plete without interrupting the remote CPU, achieving end-to-end latencies below one microsecond
for small messages in optimized deployments. This is achieved through a sophisticated protection
model where memory regions must be explicitly registered with the RNIC, which then maintains
page tables for direct virtual-to-physical address translation.
InfiniBand is a prominent implementation of RDMA, offering a high-speed, low-latency net-
working architecture tailored for high-performance computing and data center environments. It
utilizes Host Channel Adapters (HCAs) to offload protocol processing and memory translation to
4
hardware, thereby reducing CPU involvement in data transfer operations. InfiniBand supports data
transfer rates ranging from 10 Gb/s (Single Data Rate) up to 100 Gb/s per port, using both copper
and optical fiber connections. This high bandwidth, combined with ultra-low latencies—as low as
600 nanoseconds end-to-end—makes InfiniBand particularly effective for applications requiring
rapid data exchange, such as artificial intelligence and high-performance computing workloads.
Its efficiency and scalability have led to widespread adoption in distributed machine learning and
other data-intensive applications.
2.3 Software-defined Network
Software-defined Networking separates the control plane from the data plane, enabling program-
matic control over network behavior through a logically centralized controller. Modern SDN ar-
chitectures implement a three-tier model: the data plane consists of programmable forwarding ele-
ments that process packets based on match-action rules, the control plane implements network poli-
cies and path computation, and the management plane provides high-level network orchestration.
The forwarding plane has evolved from fixed-function match-action tables to fully programmable
packet processing pipelines through languages like P4, enabling custom protocol implementation
and complex packet transformations at line rate. SDN controllers implement distributed consensus
protocols to maintain network state consistency across controller replicas, while providing north-
bound APIs that abstract network complexity for applications. The forwarding plane typically
employs a pipeline architecture where packets traverse multiple match-action stages, with each
stage capable of performing arbitrary modifications to packet headers and maintaining local state.
This programmability enables implementation of complex network functions like load balancing,
traffic engineering, and network virtualization directly in the data plane while maintaining line-rate
performance.
3 Scaling Transaction Processing
Overall architecture of S OLAYER CHAIN is illustrated in Figure 1. Each transaction reaches an
initial ingress point that conducts sigverify and local deduplification. The verified transaction is
then sent to the pre-execution cluster that conducts pre-execution. We discuss this pipeline in sub-
section 3.1. Transaction effect and intermediate snapshots are sent to the sequencer via Infiniband.
The sequencer leverages SDN switch and additional FPGA to decide whether a transaction shall
go through simple path (i.e., all transaction accounts are at latest version when pre-executing) or
complex path (i.e., at least one account has a newer version). For simple path transaction, the state
change is directly applied via RDMA, with a local cache on the SDN. For complex path transac-
tion, it enters a local mempool with sub-millisecond processing speed. The sequencer schedules
the transactions in the local mempool to achieve fair and optimal parallel execution of all trans-
actions. The scheduling algorithm is described in subsection 3.2. We discuss distributed database
that stores account data in subsection 3.3. After the transaction is executed and state change has
been written, the transaction is propagated through a global PoPs.
5
Figure 2: Amount of transaction requiring re-execution versus the amount of transactions the ex-
ecutor is lagging behind.
3.1 Microservice Pipeline
SOLAYER CHAIN ’s transaction processing pipeline mirrors some of Solana’s core stages: signature
verification (sigverify), deduplication, scheduling, banking, and storage. Banking stages are inher-
ently sequential, requiring either coarse-grained locking or single-threaded execution to maintain
consistency. However, while Solana executes these stages in a monolithic architecture, signature
verification, deduplication, and storage operations can be decoupled and distributed. S OLAYER
CHAIN exploits this observation by decomposing these stages into independent microservices de-
ployed across an elastic compute fabric. Our system implements dynamic resource provisioning
through a feedback-driven control plane that monitors transaction ingress rates and automatically
scales processing capacity.
A key insight in our design is that a significant portion of transactions can be pre-executed inde-
pendently, provided they do not exhibit read-write dependencies on accounts accessed by concur-
rent transactions (i.e., no dirty read happens). According to Figure 2, a simulation of pre-executing
transactions from 1000 slots starting from 304992000, only 2% of the transaction needs to be re-
executed due to dirty read, even if the executor is significantly lagging behind the chain.
Building on this observation, S OLAYER CHAIN introduces a simulation stage that precedes
transaction scheduling. This stage, which can be horizontally scaled across nodes, performs spec-
ulative execution of transactions against the most recently committed state on the node. During
simulation, the system captures both the transaction effects and a set of intermediate execution
snapshots at account access boundaries. While some transactions may exhibit conflicts due to over-
lapping account access patterns, our approach allows parallel pre-execution of the non-conflicting
majority.
Notably, transactions that only perform read operations can be fully validated and confirmed
at the edge, bypassing the central banking stage entirely. To further reduce the congestion of con-
flicting transactions, transactions accessing hot accounts can be pre-executed for all possibilities
6
of the future value of those hot accounts. Each account has a short-term prediction model imple-
mented using Winter-Holt’s double exponential smoothing prediction (DESP) for each byte in the
account. Depending on the access frequency of an account, the pre-execution node operator could
manually inject a more accurate prediction model, and a transaction can be simulated millions of
times with different possible account data. For the remaining transactions that are still conflicting
with previous measures, when conflicts are detected, the subscriber of the simulation results can
rapidly reconstruct the correct execution state from the nearest valid snapshot in simulation results,
eliminating the need for complete transaction re-execution. This design significantly reduces the
computational overhead traditionally associated with the banking stage while maintaining strict
consistency guarantees.
3.2 Transaction Semantic Aware Scheduling
Solana’s transaction processing model employs account-level access pattern analysis to batch trans-
actions, preventing dirty reads through strict isolation. The scheduler partitions transactions into
batches based on their declared account access patterns, optimizing for parallel execution. While
this approach enables lock-free execution within batches during the banking stage, it is inherently
conservative, treating all account accesses within a transaction as concurrent. S OLAYER CHAIN
extends this model by introducing fine-grained sequence prediction of read-write operations. By
analyzing the temporal ordering of account accesses within transactions, our system constructs an
optimized locking schedule that permits concurrent execution of transactions accessing the same
accounts when their actual read-write sequences do not conflict during execution. This dynamic
scheduling approach significantly reduces lock contention while maintaining serializability guar-
antees.
SOLAYER CHAIN leverages its simulation stage to obtain estimated read-write sequences of
transactions before they enter the scheduling phase. Formally, for a transaction t, we define its
execution trace as a sequence:
E(t) = {(op1, a1, c1), (op2, a2, c2), ...,(opn, an, cn)}
where opi ∈ {read, write} represents the operation type, ai represents the accessed account, and
ci represents the predicted execution time cost between opi and opi+1. For any two transactions ti
and tj with overlapping accounts A(ti) ∩ A(tj), we define the temporal sequenceSa(t) for account
a as the ordered sequence of operations {(opk, tk)|ak = a} where tk is the relative timestamp. The
computational gap between consecutive operations is defined asGk = ck · α where α is the average
instruction execution time. Two transactions can execute in parallel if for alla ∈ A(ti)∩A(tj), their
sequences Sa(ti) and Sa(tj) have no write-write conflicts, and for any read-write pairs(read, tk) ∈
Sa(ti), (write, tl) ∈ Sa(tj), the gap satisfies Gk > δwhere δ is a tunable number representing the
estimation error that simulations can make. Note that while the goal is to find a lock free schedule,
lock is still used during execution as the schedule is based on estimation and may not be correct.
Given that this problem is analogous to bin-packing problem, the best algorithm to solve the
optimal schedule is NP-hard. To ensure the schedule can be found at sub-millisecond level, we
7
leverage Shortest Makespan First (SMF), a greedy algorithm that is widely used in database sys-
tems, for solving a near-optimal schedule.
In addition, S OLAYER CHAIN employs a parallel scheduler ensemble that concurrently ex-
plores multiple scheduling strategies to optimize transaction throughput. The ensemble includes
Solana’s multiple original account-based partitioning algorithms as a baseline, along with the SMF
algorithm. Each algorithm in the ensemble generates a candidate schedule with an estimated time
cost, and the scheduler selects the schedule with the least time cost.
3.3 Sharding Database with RDMA
Blockchain systems face significant scalability challenges due to their ever-growing state size.
For example, Ethereum’s state currently exceeds 1.1 TB, highlighting the need for efficient state
management solutions. While storing this data in memory is crucial for low-latency access, the
memory limitations of individual servers necessitate a distributed approach. S OLAYER CHAIN
implements a sophisticated sharding mechanism based on a key-value store architecture, mapping
32-byte account addresses to their corresponding state data. Unlike Solana, which imposes a 10MB
limit on account data size, SOLAYER CHAIN supports arbitrary data sizes per account.
Each database node in S OLAYER CHAIN stores a shard of data. The core architecture of each
database node of SOLAYER CHAIN consists of three primary components. First, a memory-resident
jump table maintains mappings between account address프로젝트로 돌아가기