14 posts tagged with "Ethereum"

Introduction​

Rollups-as-a-Service (RaaS) and modular blockchain frameworks have become critical in 2025 for scaling Ethereum and building custom blockchains. Leading frameworks – Optimism’s OP Stack, zkSync’s ZK Stack (Hyperchains), Arbitrum Orbit, Polygon’s Chain Development Kit (CDK), and related solutions – allow developers to launch their own Layer-2 (L2) or Layer-3 (L3) chains with varying approaches (optimistic vs zero-knowledge). These frameworks share a philosophy of modularity: they separate concerns like execution, settlement, data availability, and consensus, enabling customization of each component. This report compares the frameworks across key dimensions – data availability options, sequencer design, fee models, ecosystem support – and examines their architecture, tooling, developer experience, and current adoption in both public and enterprise contexts.

Comparison Overview​

The table below summarizes several core features of each framework:

Aspect	OP Stack (Optimism)	ZK Stack (zkSync)	Arbitrum Orbit	Polygon CDK (AggLayer)
Rollup Type	Optimistic Rollup	Zero-Knowledge (Validity)	Optimistic Rollup	Zero-Knowledge (Validity)
Proof System	Fault proofs (fraud proofs)	ZK-SNARK validity proofs	Fault proofs (fraud proofs)	ZK-SNARK validity proofs
EVM Compatibility	EVM-equivalent (geth)	High – zkEVM (LLVM-based)	EVM-equivalent (Arbitrum Nitro) + WASM via Stylus	Polygon zkEVM (EVM-equivalent)
Data Availability	Ethereum L1 (on-chain); pluggable Alt-DA modules (Celestia, etc.)	Ethereum L1; also Validium options off-chain (Celestia, Avail, EigenDA)	Ethereum L1 (rollup) or AnyTrust committee (off-chain DAC); supports Celestia, Avail	Ethereum L1 (rollup) or off-chain (validium via Avail or Celestia); hybrid possible
Sequencer Design	Single sequencer (default); multi-sequencer possible with customization. Shared sequencer vision for Superchain (future).	Configurable: can be centralized or decentralized; priority L1 queue supported.	Configurable: single operator or decentralized validators.	Flexible: single sequencer or multiple validators (e.g. PoS committee).
Sequencer Access	Centralized today (each OP chain’s sequencer is run by its operator); not permissionless yet. Plans for a shared, permissionless sequencer network among OP Chains. L1 backup queue allows trustless tx submission if sequencer fails.	zkSync Era uses a centralized sequencer (Matter Labs), but ZK Stack allows custom sequencer logic (even external consensus). Priority L1 sequencing supported for fairness. Decentralized sequencer options under development.	Arbitrum One uses a centralized sequencer (Offchain Labs), with failover via L1 inbox. Arbitrum Orbit chains can run their own sequencer (initially centralized) or institute a validator set. BoLD upgrade (2025) enables permissionless validation to decentralize Orbit chains.	Polygon zkEVM began with a single sequencer (Polygon Labs). CDK allows launching a chain with a permissioned validator set or other consensus for decentralization. Many CDK chains start centralized for simplicity, with roadmap for later community-run sequencers.
Fee Token	ETH by default on OP-based L2s (to ease UX). Custom gas token technically supported, but most OP Chains opt for ETH or a standard token for interoperability. (OP Stack’s recent guidance favors common tokens across the Superchain).	Custom base tokens are supported – developers can choose ETH or any ERC-20 as the native gas. (This flexibility enables project-specific economies on zkSync-based chains.)	Custom gas token supported (upgrade in late 2023). Chains may use ETH, Arbitrum’s ARB, or their own token for fees. Example: Ape Chain uses APE as gas.	Custom native token is supported. Many Polygon CDK chains use MATIC or another token as gas. Polygon’s ecosystem encourages MATIC for cross-chain consistency, but it’s not required.
Fee Model & Costs	Users pay L2 gas (collected by sequencer) plus L1 data posting costs. The sequencer must post transaction data (calldata or blobs) to Ethereum, so a portion of fees covers L1 gas. Revenue sharing: OP Chains in the Superchain commit ~2.5% of revenue to Optimism Collective (funding public goods).	Users pay fees (often in ETH or chosen token) which cover L1 proof verification and data. No protocol-level “tax” on fees – each chain’s sequencer keeps revenue to incentivize operators. ZK prover costs are a factor: operators might charge slightly higher fees or use efficient provers to manage costs. Finality is fast (no delay), so users don’t need third-party fast exits.	Users pay gas (in ETH or chain’s token) covering L2 execution + L1 batch cost. Sequencers/validators retain the fee revenue; no mandatory revenue-share to Arbitrum DAO or L1 (aside from L1 gas costs). To avoid the optimistic 7-day delay, many Orbit chains integrate liquidity providers or official fast-withdrawal bridges (Arbitrum supports 15-min fast exits on some Orbit chains via liquidity networks).	Users pay gas fees which cover proving and posting costs. Sequencers or validators earn those fees; Polygon does not impose any rent or tax on CDK chain revenue. Using off-chain DA (validium mode) can cut fees by >100× (storing data on Celestia or Avail instead of Ethereum), at the cost of some trust assumptions.

Table: High-level comparison of key technical features of OP Stack, zkSync’s ZK Stack, Arbitrum Orbit, and Polygon CDK.

Data Availability Layers​

Data Availability (DA) is where rollups store their transaction data so that anyone can reconstruct the chain’s state. All these frameworks support using Ethereum L1 as a DA (posting calldata or blob data on Ethereum for maximum security). However, to reduce costs, they also allow alternative DA solutions:

• OP Stack: By default, OP chains publish data on Ethereum (as calldata or blobs). Thanks to a modular “Alt-DA” interface, OP Stack chains can plug into other DA layers easily. For example, an OP chain could use Celestia (a dedicated DA blockchain) instead of Ethereum. In 2023 OP Labs and Celestia released a beta where an OP Stack rollup settles on Ethereum but stores bulk data on Celestia. This reduces fees while inheriting Celestia’s data availability guarantees. In general, any EVM or non-EVM chain – even Bitcoin or a centralized store – can be configured as the DA layer in OP Stack. (Of course, using a less secure DA trades off some security for cost.) Ethereum remains the predominant choice for production OP chains, but projects like Caldera’s Taro testnet have demonstrated OP Stack with Celestia DA.

• ZK Stack (zkSync Hyperchains): The ZK Stack offers both rollup and validium modes. In rollup mode, all data is on-chain (Ethereum). In validium mode, data is kept off-chain (with only validity proofs on-chain). Matter Labs is integrating Avail, Celestia, and EigenDA as first-class DA options for ZK Stack chains. This means a zkSync Hyperchain could post transaction data to Celestia or an EigenLayer-powered network instead of L1, massively increasing throughput. They even outline volition, where a chain can decide per-transaction whether to treat it as a rollup (on-chain data) or validium (off-chain). This flexibility allows developers to balance security and cost. For example, a gaming hyperchain might use Celestia to cheaply store data, while relying on Ethereum for periodic proofs. The ZK Stack’s design makes DA pluggable via a DA client/dispatcher component in the node software. Overall, Ethereum remains default, but zkSync’s ecosystem strongly emphasizes modular DA to achieve “hyperscale” throughput.

• Arbitrum Orbit: Orbit chains can choose between Arbitrum’s two data modes: rollup (data posted on Ethereum) or AnyTrust (data availability committee). In Rollup configuration, an Orbit L3 will post its call data to the L2 (Arbitrum One or Nova) or L1, inheriting full security at higher cost. In AnyTrust mode, data is kept off-chain by a committee (as used in Arbitrum Nova, which uses a Data Availability Committee). This greatly lowers fees for high-volume apps (gaming, social) at the cost of trusting a committee (if all committee members collude to withhold data, the chain could halt). Beyond these, Arbitrum is also integrating with emerging modular DA networks. Notably, Celestia and Polygon Avail are supported for Orbit chains as alternative DA layers. Projects like AltLayer have worked on Orbit rollups that use EigenDA (EigenLayer’s DA service) as well. In summary, Arbitrum Orbit offers flexible data availability: on-chain via Ethereum, off-chain via DACs or specialized DA chains, or hybrids. Many Orbit adopters choose AnyTrust for cost savings, especially if they have a known set of validators or partners ensuring data is available.

• Polygon CDK: Polygon’s CDK is inherently modular with respect to DA. A Polygon CDK chain can operate as a rollup (all data on Ethereum) or a validium (data on a separate network). Polygon has its own DA solution called Avail (a blockchain for data availability), and CDK chains can use Avail or any similar service. In late 2024, Polygon announced direct integration of Celestia into CDK – making Celestia an “easily-pluggable” DA option in the toolkit. This integration is expected in early 2024, enabling CDK chains to store compressed data on Celestia seamlessly. Polygon cites that using Celestia could reduce transaction fees by >100× compared to posting all data on Ethereum. Thus, a CDK chain creator can simply toggle the DA module to Celestia (or Avail) instead of Ethereum. Some Polygon chains (e.g. Polygon zkEVM) currently post all data to Ethereum (for maximal security), while others (perhaps certain enterprise chains) run as validiums with external DA. The CDK supports “hybrid” modes as well – for instance, critical transactions could go on Ethereum while others go to Avail. This modular DA approach aligns with Polygon’s broader Polygon 2.0 vision of multiple ZK-powered chains with unified liquidity but varied data backends.

In summary, all frameworks support multiple DA layers to various degrees. Ethereum remains the gold standard DA (especially with blob space from EIP-4844 making on-chain data cheaper), but new specialized DA networks (Celestia, Avail) and schemes (EigenLayer’s EigenDA, data committees) are being embraced across the board. This modularity allows rollup creators in 2025 to make trade-offs between cost and security by simply configuring a different DA module rather than building a new chain from scratch.

Sequencer Design and Decentralization​

The sequencer is the node (or set of nodes) that orders transactions and produces blocks for a rollup. How the sequencer is designed – centralized vs decentralized, permissionless vs permissioned – affects the chain’s throughput and trust assumptions:

• OP Stack (Optimism): Today, most OP Stack chains run a single sequencer operated by the chain’s core team or sponsor. For example, Optimism Mainnet’s sequencer is run by OP Labs, and Base’s sequencer is run by Coinbase. This yields low latency and simplicity at the cost of centralization (users must trust the sequencer to include their transactions fairly). However, Optimism has built in mechanisms for trust-minimization: there is an L1 transaction queue contract where users can submit transactions on Ethereum which the sequencer must include in the L2 chain. If the sequencer goes down or censors txs, users can rely on L1 to eventually get included (albeit with some delay). This provides a safety valve against a malicious or failed sequencer. In terms of decentralization, OP Stack is modular and theoretically allows multiple sequencers – e.g. one could implement a round-robin or proof-of-stake based block proposer set using the OP Stack code. In practice, this requires customization and is not the out-of-the-box configuration. The long-term Superchain roadmap envisions a shared sequencer for all OP Chains, which would be a set of validators sequencing transactions for many chains at once. A shared sequencer could enable cross-chain atomicity and reduce MEV across the Superchain. It’s still in development as of 2025, but the OP Stack’s design does not preclude plugging in such a consensus. For now, sequencer operations remain permissioned (run by whitelisted entities), but Optimism governance plans to decentralize this (possibly via staking or committee rotation) once the technology and economics are ready. In short: OP Stack chains start with centralized sequencing (with L1 as fallback), and a path to gradual decentralization is charted (moving from “Stage 0” to “Stage 2” maturity with no training wheels).

• ZK Stack (zkSync Hyperchains): zkSync Era (the L2) currently uses a centralized sequencer operated by Matter Labs. However, the ZK Stack is built to allow various sequencing modes for new chains. Options include a centralized sequencer (easy start), a decentralized sequencer set (e.g. multiple nodes reaching consensus on ordering), a priority transaction queue from L1, or even an external sequencer service. In Matter Labs’ Elastic Chains vision, chains remain independent but interoperability is handled by the L1 contracts and a “ZK Router/Gateway” – this implies each chain can choose its own sequencer model as long as it meets the protocols for submitting state roots and proofs. Because ZK-rollups don’t require a consensus on L2 for security (validity proofs ensure correctness), decentralizing the sequencer is more about liveness and censorship-resistance. A Hyperchain could implement a round-robin block producer or even hook into a high-performance BFT consensus for its sequencers if desired. That said, running a single sequencer is far simpler and remains the norm initially. The ZK Stack docs mention that a chain could use an “external protocol” for sequencing – for instance, one could imagine using Tendermint or SU consensus as the block producer and then generating zk proofs for the blocks. Also, like others, zkSync has an L1 priority queue mechanism: users can send transactions to the zkSync contract with a priority fee to guarantee L1->L2 inclusion in a timely manner (mitigating censorship). Overall, permissionless participation in sequencing is not yet realized on zkSync chains (no public slot auction or staking-based sequencer selection in production), but the architecture leaves room for it. As validity proofs mature, we might see zkSync chains with community-run sequencer nodes that collectively decide ordering (once performance allows).

• Arbitrum Orbit: On Arbitrum One (the main L2), the sequencer is centralized (run by Offchain Labs), though the chain’s state progression is ultimately governed by the Arbitrum validators and fraud proofs. Arbitrum has similarly provided an L1 queue for users as a backstop against sequencer issues. In Orbit (the L3 framework), each Orbit chain can have its own sequencer or validator set. Arbitrum’s Nitro tech includes the option to run a rollup with a decentralized sequencer: essentially, one could have multiple parties run the Arbitrum node software and use a leader election (possibly via the Arbitrum permissionless proof-of-stake chain in the future, or a custom mechanism). Out of the box, Orbit chains launched to date have been mostly centralized (e.g. the Xai gaming chain is run by a foundation in collaboration with Offchain Labs) – but this is a matter of configuration and governance. A noteworthy development is the introduction of BoLD (Bounded Liquidity Delay) in early 2025, which is a new protocol to make Arbitrum’s validation more permissionless. BoLD allows anyone to become a validator (prover) for the chain, resolving fraud challenges in a fixed time frame without a whitelist. This moves Arbitrum closer to trustless operation, although the sequencer role (ordering transactions day-to-day) might still be assigned or elected. Offchain Labs has expressed focus on advancing decentralization in 2024-2025 for Arbitrum. We also see multi-sequencer efforts: for example, an Orbit chain could use a small committee of known sequencers to get some fault tolerance (one goes down, another continues). Another angle is the idea of a shared sequencer for Orbit chains, though Arbitrum hasn’t emphasized this as much as Optimism. Instead, interoperability is achieved via L3s settling on Arbitrum L2 and using standard bridges. In summary, Arbitrum Orbit gives flexibility in sequencer design (from one entity to many), and the trend is toward opening the validator/sequencer set as the tech and community governance matures. Today, it’s fair to say Orbit chains start centralized but have a roadmap for permissionless validation.

• Polygon CDK: Polygon CDK chains (sometimes referred to under the umbrella “AggLayer” in late 2024) can similarly choose their sequencer/consensus setup. Polygon’s zkEVM chain (operated by Polygon Labs) began with a single sequencer and centralized prover, with plans to progressively decentralize both. The CDK, being modular, allows a chain to plug in a consensus module – for instance, one could launch a CDK chain with a Proof-of-Stake validator set producing blocks, effectively decentralizing sequencing from day one. In fact, Polygon’s earlier framework (Polygon Edge) was used for permissioned enterprise chains using IBFT consensus; CDK chains could take a hybrid approach (run Polygon’s zkProver but have a committee of nodes propose blocks). By default, many CDK chains might run with a single operator for simplicity and then later adopt a consensus as they scale. Polygon is also exploring a shared sequencer or aggregator concept through the AggLayer hub, which is intended to connect all Polygon chains. While AggLayer primarily handles cross-chain messaging and liquidity, it could evolve into a shared sequencing service in the future (Polygon co-founder has discussed sequencer decentralization as part of Polygon 2.0). In general, permissionlessness is not yet present – one cannot spontaneously become a sequencer for someone’s CDK chain unless that project allows it. But projects like dYdX V4 (which is building a standalone chain with a form of decentralized consensus) and others show the appetite for validator-based L2s. Polygon CDK makes it technically feasible to have many block producers, but the exact implementation is left to the chain deployer. Expect Polygon to roll out more guidance or even infrastructure for decentralized sequencers as more enterprises and communities launch CDK chains.

To summarize the sequencer comparison: All frameworks currently rely on a relatively centralized sequencer model in their live deployments, to ensure efficiency. However, each provides a route to decentralization – whether via shared sequencing networks (OP Stack), pluggable consensus (CDK, ZK Stack), or permissionless validators (Arbitrum’s BoLD). Table below highlights sequencer designs:

Sequencer Design	OP Stack	ZK Stack (zkSync)	Arbitrum Orbit	Polygon CDK
Default operator model	Single sequencer (project-run)	Single sequencer (Matter Labs or project-run)	Single sequencer (project-run/Offchain Labs)	Single sequencer (project or Polygon-run)
Decentralization options	Yes – can customize consensus, e.g. multiple sequencers or future shared set	Yes – configurable; can integrate external consensus or priority queues	Yes – configurable; can use multi-validator (AnyTrust committee or custom)	Yes – can integrate PoS validators or IBFT consensus (project’s choice)
Permissionless participation	Planned: Superchain shared sequencer (not yet live). Fraud provers are permissionless on L1 (anyone can challenge).	Not yet (no public sequencer auction yet). Validity proofs don’t need challengers. Community can run read-nodes, but not produce blocks unless chosen.	Emerging: BoLD enables anyone to validate fraud proofs. Sequencer still chosen by chain (could be via DAO in future).	Not yet. Sequencers are appointed by chain owners or validators are permissioned/staked. Polygon’s roadmap includes community validation eventually.
Censorship resistance	L1 queue for users ensures inclusion. Training-wheels governance can veto sequencer misconduct.	L1 priority queue for inclusion. Validium mode needs trust in DA committee for data availability.	L1 inbox ensures inclusion if sequencer stalls. DAC mode requires ≥1 honest committee member to supply data.	Depends on chain’s consensus – e.g. if using a validator set, need ≥2/3 honest. Rollup mode fallback is L1 Ethereum inclusion.

As seen, Optimism and Arbitrum include on-chain fallback queues, which is a strong censorship-resistance feature. ZK-based chains rely on the fact that a sequencer can’t forge state (thanks to ZK proofs), but if it censors, a new sequencer could be appointed by governance – an area still being refined. The trend in 2025 is that we’ll likely see more decentralized sequencer pools and possibly shared sequencer networks coming online, complementing these RaaS frameworks. Each project is actively researching this: e.g. Astria and others are building general shared sequencing services, and OP Labs, Polygon, and Offchain have all mentioned plans to decentralize the sequencer role.

Fee Models and Economics​

Fee models determine who pays what in these rollup frameworks and how the economic incentives align for operators and the ecosystem. Key considerations include: What token are fees paid in? Who collects the fees? What costs (L1 posting, proving) must be covered? Are there revenue-sharing or kickback arrangements? How customizable are fee parameters?

• Gas Token and Fee Customization: All compared frameworks allow customizing the native gas token, meaning a new chain can decide which currency users pay fees in. By default, rollups on Ethereum often choose ETH as the gas token for user convenience (users don’t need a new token to use the chain). For instance, Base (OP Stack) uses ETH for gas, as does zkSync Era and Polygon zkEVM. OP Stack technically supports replacing ETH with another ERC-20, but in the context of the OP Superchain, there’s a push to keep a standard (to make interoperability smoother). In fact, some OP Stack chains that initially considered a custom token opted for ETH – e.g., Worldcoin’s OP-chain uses ETH for fees even though the project has its own token WLD. On the other hand, Arbitrum Orbit launched without custom token support but quickly added it due to demand. Now Orbit chains can use ARB or any ERC-20 as gas. The Ape Chain L3 chose APE coin as its gas currency, showcasing this flexibility. Polygon CDK likewise lets you define the token; many projects lean towards using MATIC to align with Polygon’s ecosystem (and MATIC will upgrade to POL token under Polygon 2.0), but it’s not enforced. zkSync’s ZK Stack explicitly supports custom base tokens as well (the docs even have a “Custom base token” tutorial). This is useful for enterprise chains that might want, say, a stablecoin or their own coin for fees. It’s also crucial for app-chains that have their own token economy – they can drive demand for their token by making it the gas token. In summary, fee token is fully configurable in all frameworks, although using a widely-held token like ETH can lower user friction.

• Fee Collection and Distribution: Generally, the sequencer (block producer) collects transaction fees on the L2/L3. This is a primary incentive for running a sequencer. For example, Optimism’s sequencer earns all the gas fees users pay on Optimism, but must then pay for posting batches to Ethereum. Usually, the sequencer will take the user-paid L2 fees, subtract the L1 costs, and keep the remainder as profit. On a well-run chain, L1 costs are a fraction of L2 fees, leaving some profit margin. For ZK-rollups, there’s an extra cost: generating the ZK proof. This can be significant (requiring specialized hardware or cloud compute). Currently, some ZK rollup operators subsidize proving costs (spending VC funds) to keep user fees low during growth phase. Over time, proving costs are expected to drop with better algorithms and hardware. Framework-wise: zkSync and Polygon both allow the sequencer to charge a bit more to cover proving – and if a chain uses an external prover service, they might have a revenue split with them. Notably, no framework except OP Superchain has an enforced revenue-sharing at protocol level. The Optimism Collective’s Standard Rollup Revenue scheme requires OP Chains to remit either 2.5% of gross fees or 15% of net profits (whichever is greater) to a collective treasury. This is a voluntary-but-expected agreement under the Superchain charter, rather than a smart contract enforcement, but all major OP Stack chains (Base, opBNB, Worldcoin, etc.) have agreed to it. Those fees (over 14,000 ETH so far) fund public goods via Optimism’s governance. In contrast, Arbitrum does not charge Orbit chains any fee; Orbit is permissionless to use. Arbitrum DAO could potentially ask for some revenue sharing in the future (to fund its own ecosystem), but none exists as of 2025. Polygon CDK similarly does not impose a tax; Polygon’s approach is to attract users into its ecosystem (thus raising MATIC value and usage) rather than charge per-chain fees. Polygon co-founder Sandeep Nailwal explicitly said AggLayer “does not seek rent” from chains. zkSync also hasn’t announced any fee sharing – Matter Labs likely focuses on growing usage of zkSync Era and hyperchains, which indirectly benefits them via network effects and possibly future token value.

• L1 Settlement Costs: A big part of the fee model is who pays for L1 transactions (posting data or proofs). In all cases, ultimately users pay, but the mechanism differs. In Optimistic rollups, the sequencer periodically posts batches of transactions (with calldata) to L1. The gas cost for those L1 transactions is paid by the sequencer using ETH. However, sequencers factor that into the L2 gas pricing. Optimism and Arbitrum have gas pricing formulas that estimate how much a transaction’s call-data will cost on L1 and include that in the L2 gas fee (often called the “amortized L1 cost” per tx). For example, a simple Optimism tx might incur 21,000 L2 gas for execution and maybe an extra few hundred for L1 data – the user’s fee covers both. If the pricing is misestimated, the sequencer might lose money on that batch or gain if usage is high. Sequencers typically adjust fees dynamically to match L1 conditions (raising L2 fees when L1 gas is expensive). In Arbitrum, the mechanism is similar, though Arbitrum has separate “L1 pricing” and “L2 pricing” components. In zkSync/Polygon (ZK), the sequencer must post a validity proof to L1 (costing a fixed gas amount to verify) plus either call data (if rollup) or state root (if validium). The proof verification cost is usually constant per batch (on zkSync Era it’s on the order of a few hundred thousand gas), so zkSync’s fee model spreads that cost across transactions. They might charge a slight overhead on each tx for proving. Notably, zkSync introduced features like state diffs and compression to minimize L1 data published. Polygon zkEVM likewise uses recursive proofs to batch many transactions into one proof, amortizing the verification cost. If a chain uses an alternative DA (Celestia/Avail), then instead of paying Ethereum for calldata, they pay that DA provider. Celestia, for instance, has its own gas token (TIA) to pay for data blobs. So a chain might need to convert part of fees to pay Celestia miners. Frameworks are increasingly abstracting these costs: e.g., an OP Stack chain could pay a Celestia DA node via an adapter, and include that cost in user fees.

• Costs to Users (Finality and Withdrawal): For optimistic rollups (OP Stack, Arbitrum Orbit in rollup mode), users face the infamous challenge period for withdrawals – typically 7 days on Ethereum L1. This is a usability hit, but most ecosystems have mitigations. Fast bridges (liquidity networks) allow users to swap their L2 tokens for L1 tokens instantly for a small fee, while arbitrageurs wait the 7 days. Arbitrum has gone further for Orbit chains, working with teams to enable fast withdrawals in as little as 15 minutes via liquidity providers integrated at the protocol level. This effectively means users don’t wait a week except in worst-case scenarios. ZK-rollups don’t have this delay – once a validity proof is accepted on L1, the state is final. So zkSync and Polygon users get faster finality (often minutes to an hour) depending on how often proofs are submitted. The trade-off is that proving might introduce a bit of delay between when a transaction is accepted on L2 and when it’s included in an L1 proof (could be a few minutes). But generally, ZK rollups are offering 10–30 minute withdrawals in 2025, which is a huge improvement over 7 days. Users may pay a slightly higher fee for immediate finality (to cover prover costs), but many deem it worth it. Fee Customization is also worth noting: frameworks allow custom fee schedules (like free transactions or gas subsidies) if projects want. For example, an enterprise could subsidize all user fees on their chain by running the sequencer at a loss (perhaps for a game or social app). Or they could set up a different gas model (some have toyed with no gas for certain actions, or alternative gas accounting). Since most frameworks aim for Ethereum-equivalence, such deep changes are rare, but possible with code modification. Arbitrum’s Stylus could enable different fee metering for WASM contracts (not charging for certain ops to encourage WASM usage, for instance). The Polygon CDK being open source and modular means if a project wanted to implement a novel fee mechanism (like fee burning or dynamic pricing), they could.

In essence, all rollup frameworks strive to align economic incentives: make it profitable to operate a sequencer (via fee revenue), keep fees reasonable for users by leveraging cheaper DA, and (optionally) funnel some value to their broader ecosystem. Optimism’s model is unique in explicitly sharing revenue for public goods, while others rely on growth and token economics (e.g., more chains -> more MATIC/ETH usage, increasing those token’s value).

Architecture and Modularity​

All these frameworks pride themselves on a modular architecture, meaning each layer of the stack (execution, settlement, consensus, DA, proofs) is swappable or upgradable. Let’s briefly note each:

• OP Stack: Built as a series of modules corresponding to Ethereum’s layers – execution engine (OP EVM, derived from geth), consensus/rollup node (op-node), settlement smart contracts, and soon fraud prover. The OP Stack’s design goal was EVM equivalence (no custom gas schedule or opcode changes) and ease of integration with Ethereum tooling. The Bedrock upgrade in 2023 further modularized Optimism’s stack, making it easier to swap out components (e.g., to implement ZK proofs in the future, or use a different DA). Indeed, OP Stack is not limited to optimistic fraud proofs – the team has said it’s open to integrating validity proofs when they mature, essentially turning OP Stack chains into ZK rollups without changing the developer experience. The Superchain concept extends the architecture to multiple chains: standardizing inter-chain communication, bridging, and maybe shared sequencing. OP Stack comes with a rich set of smart contracts on L1 (for deposits, withdrawals, fraud proof verification, etc.), which chains inherit out-of-the-box. It’s effectively a plug-and-play L2 chain template – projects like Base launched by forking the OP Stack repos and configuring them to point at their own contracts.

• ZK Stack: The ZK Stack is the framework underlying zkSync Era and future “Hyperchains.” Architecturally, it includes the zkEVM execution environment (an LLVM-based VM that allows running Solidity code with minimal changes), the prover system (the circuits and proof generation for transactions), the sequencer node, and the L1 contracts (the zkSync smart contracts that verify proofs and manage state roots). Modularity is seen in how it separates the ZK proof circuit from the execution – theoretically one could swap in a different proving scheme or even a different VM (though not trivial). The ZK Stack introduces the Elastic Chain Architecture with components like ZK Router and ZK Gateway. These act as an interoperability layer connecting multiple ZK Chains. It’s a bit like an “internet of ZK rollups” concept, where the Router (on Ethereum) holds a registry of chains and facilitates shared bridging/liquidity, and the Gateway handles messages between chains off-chain. This is modular because a new chain can plug into that architecture simply by deploying with the standard contracts. ZK Stack also embraces account abstraction at the protocol level (contracts as accounts, native meta-transactions), which is an architectural choice to improve UX. Another modular aspect: as discussed in DA, it can operate in rollup or validium mode – essentially flipping a switch in config. Also, the stack has a notion of Pluggable consensus for sequencing (as noted prior). Settlement layer can be Ethereum or potentially another chain: zkSync’s roadmap even floated settling hyperchains on L2 (e.g., an L3 that posts proofs to zkSync Era L2 instead of L1) – indeed they launched a prototype called “ZK Portal” for L3 settlement on L2. This gives a hierarchical modularity (L3->L2->L1). Overall, ZK Stack is a bit less turnkey for non-Matter-Labs teams as of 2025 (since running a ZK chain involves coordinating provers, etc.), but it’s highly flexible in capable hands.

• Arbitrum Orbit: Arbitrum’s architecture is built on the Arbitrum Nitro stack, which includes the ArbOS execution layer (Arbitrum’s interpretation of EVM with some small differences), the Sequencer/Relay, the AnyTrust component for alternative DA, and the fraud proof machinery (interactive fraud proofs). Orbit essentially lets you use that same stack but configure certain parameters (like chain ID, L2 genesis state, choice of rollup vs AnyTrust). Modularity: Arbitrum introduced Stylus, a new WASM-compatible smart contract engine that runs alongside the EVM. Stylus allows writing contracts in Rust, C, C++ which compile to WASM and run with near-native speed on Arbitrum chains. This is an optional module – Orbit chains can enable Stylus or not. It’s a differentiator for Arbitrum’s stack, making it attractive for high-performance dApps (e.g., gaming or trading apps might write some logic in Rust for speed). The data availability module is also pluggable as discussed (Arbitrum chains can choose on-chain or DAC). Another module is the L1 settlement: Orbit chains can post their proofs to either Ethereum (L1) or to Arbitrum One (L2). If the latter, they effectively are L3s anchored in Arbitrum One’s security (with slightly different trust assumptions). Many Orbit chains are launching as L3s (to inherit Arbitrum One’s lower fees and still ultimately Ethereum security). Arbitrum’s codebase is fully open source now, and projects like Caldera, Conduit build on it to provide user-friendly deployment – they might add their own modules (like monitoring, chain management APIs). It’s worth noting Arbitrum’s fraud proofs were historically not permissionless (only whitelisted validators could challenge), but with BoLD, that part of the architecture is changing to allow anyone to step in. So the fraud proof component is becoming more decentralized (which is a modular upgrade in a sense). One might say Arbitrum is less of a “lego kit” than OP Stack or Polygon CDK, in that Offchain Labs hasn’t released a one-click chain launcher (though they did release an Orbit deployment GUI on GitHub). But functionally, it’s modular enough that third parties have automated deployments for it.

• Polygon CDK (AggLayer): Polygon CDK is explicitly described as a “modular framework” for ZK-powered chains. It leverages Polygon’s ZK proving technology (from Polygon zkEVM, which is based on Plonky2 and recursive SNARKs). The architecture separates the execution layer (which is an EVM – specifically a fork of Geth adjusted for zkEVM) from the prover layer and the bridge/settlement contracts. Because it’s modular, a developer can choose different options for each: e.g. Execution – presumably always EVM for now (to use existing tooling), DA – as discussed (Ethereum or others), Sequencer consensus – single vs multi-node, Prover – one can run the prover Type1 (validity proofs posted to Ethereum) or a Type2 (validium proofs) etc., and AggLayer integration – yes or no (AggLayer for interop). Polygon even provided a slick interface (shown below) to visualize these choices:

Polygon CDK’s configuration interface, illustrating modular choices – e.g. Rollups vs Validium (scaling solution), decentralized vs centralized sequencer, local/Ethereum/3rd-party DA, different prover types, and whether to enable AggLayer interoperability.

Under the hood, Polygon CDK uses zk-Proofs with recursion to allow high throughput and a dynamic validator set. The AggLayer is an emerging part of the architecture that will connect chains for trustless messaging and shared liquidity. The CDK is built in a way that future improvements in Polygon’s ZK tech (like faster proofs, or new VM features) can be adopted by all CDK chains via upgrades. Polygon has a concept of “Type 1 vs Type 2” zkEVM – Type 1 is fully Ethereum-equivalent, Type 2 is almost equivalent with minor changes for efficiency. A CDK chain could choose a slightly modified EVM for more speed (sacrificing some equivalence) – this is an architectural option projects have. Overall, CDK is very lego-like: one can assemble a chain choosing components suitable for their use case (e.g., an enterprise might choose validium + permissioned sequencers + private Tx visibility; a public DeFi chain might choose rollup + decentralized sequencer + AggLayer enabled for liquidity). This versatility has attracted many projects to consider CDK for launching their own networks.

• Images and diagrams: The frameworks often provide visual diagrams of their modular architecture. For example, zkSync’s UI shows toggles for Rollup/Validium, L2/L3, centralized/decentralized, etc., highlighting the ZK Stack’s flexibility:

An example configuration for a zkSync “Hyperchain.” The ZK Stack interface allows selecting chain mode (Rollup vs Validium vs Volition), layer (L2 or L3), transaction sequencing (decentralized, centralized, or shared), data availability source (Ethereum, third-party network, or custom), data visibility (public or private chain), and gas token (ETH, custom, or gasless). This modular approach is designed to support a variety of use cases, from public DeFi chains to private enterprise chains.

In summary, all these stacks are highly modular and upgradable, which is essential given the pace of blockchain innovation. They are converging in some sense: OP Stack adding validity proofs, Polygon adding shared sequencing (OP Stack ideas), Arbitrum adding interoperable L3s (like others), zkSync pursuing L3s (like Orbit and OPStack do). This cross-pollination means modular frameworks in 2025 are more alike than different in philosophy – each wants to be the one-stop toolkit to launch scalable chains without reinventing the wheel.

Developer Experience and Tooling​

A critical factor for adoption is how easy and developer-friendly these frameworks are. This includes documentation, SDKs/APIs, CLIs for deployment, monitoring tools, and the learning curve for developers:

• OP Stack – Developer Experience: Optimism’s OP Stack benefits from being EVM-equivalent, so Ethereum developers can use familiar tools (Remix, Hardhat, Truffle, Solidity, Vyper) without modification. Smart contracts deployed to an OP chain behave exactly as on L1. This drastically lowers the learning curve. Optimism provides extensive documentation: the official Optimism docs have sections on the OP Stack, running an L2 node, and even an “OP Stack from scratch” tutorial. There are community-written guides as well (for example, QuickNode’s step-by-step guide on deploying an Optimism L2 rollup). In terms of tooling, OP Labs has released the op-node client (for the rollup node) and op-geth (execution engine). To launch a chain, a developer typically needs to configure these and deploy the L1 contracts (Standard Bridge, etc.). This was non-trivial but is becoming easier with provider services. Deployment-as-a-service: companies like Caldera, Conduit, and Infura/Alchemy offer managed OP Stack rollup deployments, which abstracts away much of the DevOps. For monitoring, because an OP Stack chain is essentially a geth chain plus a rollup coordinator, standard Ethereum monitoring tools (ETH metrics dashboards, block explorers like Etherscan/Blockscout) can be used. In fact, Etherscan supports OP Stack chains such as Optimism and Base, providing familiar block explorer interfaces. Developer tooling specifically for OP Chains includes the Optimism SDK for bridging (facilitating deposits/withdrawals in apps) and Bedrock’s integration with Ethereum JSON-RPC (so tools like MetaMask just work by switching network). The OP Stack code is MIT licensed, inviting developers to fork and experiment. Many did – e.g. BNB Chain’s team used OP Stack to build opBNB with their own modifications to consensus and gas token (they use BNB gas on opBNB). The OP Stack’s adherence to Ethereum standards makes the developer experience arguably the smoothest among these: essentially “Ethereum, but cheaper” from a contract developer’s perspective. The main new skills needed are around running the infrastructure (for those launching a chain) and understanding cross-chain bridging nuances. Optimism’s community and support (Discord, forums) are active to help new chain teams. Additionally, Optimism has funded ecosystem tools like Magi (an alternative Rust rollup client) to diversify the stack and make it more robust for developers.

• zkSync ZK Stack – Developer Experience: On the contract development side, zkSync’s ZK Stack offers a zkEVM that is intended to be high compatibility but currently not 100% bytecode-equivalent. It supports Solidity and Vyper contracts, but there are subtle differences (for example, certain precompiles or gas costs). That said, Matter Labs built an LLVM compiler that takes Solidity and produces zkEVM bytecode, so most Solidity code works with little to no change. They also natively support account abstraction, which devs can leverage to create gasless transactions, multi-sig wallets, etc., more easily than on Ethereum (no need for ERC-4337). The developer docs for zkSync are comprehensive (docs.zksync.io) and cover how to deploy contracts, use the Hyperchain CLI (if any), and configure a chain. However, running a ZK rollup is inherently more complex than an optimistic one – you need a proving setup. The ZK Stack provides the prover software (e.g. the GPU provers for zkSync’s circuits), but a chain operator must have access to serious hardware or cloud services to generate proofs continuously. This is a new DevOps challenge; to mitigate it, some companies are emerging that provide prover services or even Proof-as-a-Service. If a developer doesn’t want to run their own provers, they might be able to outsource it (with trust or crypto-economic assurances). Tooling: zkSync provides a bridge and wallet portal by default (the zkSync Portal) which can be forked for a new chain, giving users a UI to move assets and view accounts. For block exploration, Blockscout has been adapted to zkSync, and Matter Labs built their own block explorer for zkSync Era which could likely be used for new chains. The existence of the ZK Gateway and Router means that if a developer plugs into that, they get some out-of-the-box interoperability with other chains – but they need to follow Matter Labs’ standards. Overall, for a smart contract dev, building on zkSync is not too difficult (just Solidity, with perhaps minor differences like gasleft() might behave slightly differently due to not having actual Ethereum gas cost). But for a chain operator, the ZK Stack has a steeper learning curve than OP Stack or Orbit. In 2025, Matter Labs is focusing on improving this – for instance, simplifying the process of launching a Hyperchain, possibly providing scripts or cloud images to spin up the whole stack. There is also an emerging community of devs around ZK Stack; e.g., the ZKSync Community Edition is an initiative where community members run test L3 chains and share tips. We should note that language support for zkSync’s ecosystem might expand – they’ve talked about allowing other languages via the LLVM pipeline (e.g., a Rust-to-zkEVM compiler in the future), but Solidity is the main one now. In summary, zkSync’s dev experience: great for DApp devs (nearly Ethereum-like), moderate for chain launchers (need to handle prover and new concepts like validiums).

• Arbitrum Orbit – Developer Experience: For Solidity developers, Arbitrum Orbit (and Arbitrum One) is fully EVM-compatible at the bytecode level (Arbitrum Nitro uses geth-derived execution). Thus, deploying and interacting with contracts on an Arbitrum chain is just like Ethereum (with some small differences like slightly different L1 block number access, chainID, etc., but nothing major). Where Arbitrum stands out is Stylus – developers can write smart contracts in languages like Rust, C, C++ (compiled to WebAssembly) and deploy those alongside EVM contracts. This opens blockchain development to a wider pool of programmers and enables high-performance use cases. For example, an algorithmic intensive logic could be written in C for speed. Stylus is still in beta on Arbitrum mainnet, but Orbit chains can experiment with it. This is a unique boon for developer experience, albeit those using Stylus will need to learn new tooling (e.g., Rust toolchains, and Arbitrum’s libraries for interfacing WASM with the chain). The Arbitrum docs provide guidance on using Stylus and even writing Rust smart contracts. For launching an Orbit chain, Offchain Labs has provided Devnet scripts and an Orbit deployment UI. The process is somewhat technical: one must set up an Arbitrum node with --l3 flags (if launching an L3) and configure the genesis, chain parameters, etc.. QuickNode and others have published guides (“How to deploy your own Arbitrum Orbit chain”). Additionally, Orbit partnerships with Caldera, AltLayer, and Conduit mean these third parties handle a lot of the heavy lifting. A developer can essentially fill out a form or run a wizard with those services to get a customized Arbitrum chain, instead of manually modifying the Nitro code. In terms of debugging and monitoring, Arbitrum chains can use Arbiscan (for those that have it) or community explorers. There’s also Grafana/Prometheus integrations for node metrics. One complexity is the fraud proof system – developers launching an Orbit chain should ensure there are validators (maybe themselves or trusted others) who run the off-chain validator software to watch for fraud. Offchain Labs likely provides default scripts for running such validators. But since fraud proofs rarely trigger, it’s more about having the security process in place. Arbitrum’s large developer community (projects building on Arbitrum One) is an asset – resources like tutorials, stackexchange answers, etc., often apply to Orbit as well. Also, Arbitrum is known for its strong developer education efforts (workshops, hackathons), which presumably extend to those interested in Orbit.

• Polygon CDK – Developer Experience: Polygon CDK is newer (announced mid/late 2023), but it builds on familiar components. For developers writing contracts, Polygon CDK chains use a zkEVM that’s intended to be equivalent to Ethereum’s EVM (Polygon’s Type 2 zkEVM is nearly identical with a few edge cases). So, Solidity and Vyper are the go-to languages, with full support for standard Ethereum dev tools. If you’ve deployed on Polygon zkEVM or Ethereum, you can deploy on a CDK chain similarly. The challenge is more on the chain operations side. Polygon’s CDK is open-source on GitHub and comes with documentation on how to configure a chain. It likely provides a command-line tool to scaffold a new chain (similar to how one might use Cosmos SDK’s starport or Substrate’s node template). Polygon Labs has invested in making the setup as easy as possible – one quote: “launch a high-throughput ZK-powered Ethereum L2 as easily as deploying a smart contract”. While perhaps optimistic, this indicates tools or scripts exist to simplify deployment. Indeed, there have been early adopters like Immutable (for gaming) and OKX (exchange chain) that have worked with Polygon to launch CDK chains, suggesting a fairly smooth process with Polygon’s team support. The CDK includes SDKs and libraries to interact with the bridge (for deposits/withdrawals) and to enable AggLayer if desired. Monitoring a CDK chain can leverage Polygon’s block explorer (Polygonscan) if they integrate it, or Blockscout. Polygon is also known for robust SDKs for gaming and mobile (e.g., Unity SDKs) – those can be used on any Polygon-based chain. Developer support is a big focus: Polygon has academies, grants, hackathons regularly, and their Developer Relations team helps projects one-on-one. An example of enterprise developer experience: Libre, an institutional chain launched with CDK, presumably had custom requirements – Polygon was able to accommodate things like identity modules or compliance features on that chain. This shows the CDK can be extended for specific use cases by developers with help from the framework. As for learning materials, Polygon’s docs site and blog have guides on CDK usage, and because CDK is essentially the evolution of their zkEVM, those familiar with Polygon’s zkEVM design can pick it up quickly. One more tooling aspect: Cross-chain tools – since many Polygon CDK chains will coexist, Polygon provides the AggLayer for messaging, but also encourages use of standard cross-chain messaging like LayerZero (indeed Rarible’s Orbit chain integrated LayerZero for NFT transfers and Polygon chains can too). So, devs have options to integrate interoperability plugins easily. All told, the CDK developer experience is aimed to be turnkey for launching Ethereum-level chains with ZK security, benefiting from Polygon’s years of L2 experience.

In conclusion, developer experience has dramatically improved for launching custom chains: what once required a whole team of protocol engineers can now be done with guided frameworks and support. Optimism’s and Arbitrum’s offerings leverage familiarity (EVM equivalence), zkSync and Polygon offer cutting-edge tech with increasing ease-of-use, and all have growing ecosystems of third-party tools to simplify development (from block explorers to monitoring dashboards and devops scripts). The documentation quality is generally high – official docs plus community guides (Medium articles, QuickNode/Alchemy guides) cover a lot of ground. There is still a non-trivial learning curve to go from smart contract developer to “rollup operator,” but it’s getting easier as best practices emerge and the community of rollup builders expands.

Ecosystem Support and Go-to-Market Strategies​

Building a technology is one thing; building an ecosystem is another. Each of these frameworks is backed by an organization or community investing in growth through grants, funding, marketing, and partnership support. Here we compare their ecosystem support strategies – how they attract developers and projects, and how they help those projects succeed:

• OP Stack (Optimism) Ecosystem: Optimism has a robust ecosystem strategy centered on its Optimism Collective and ethos of public goods funding. They pioneered Retroactive Public Goods Funding (RPGF) – using OP token treasury to reward developers and projects that benefit the ecosystem. Through multiple RPGF rounds, Optimism has distributed millions in funding to infrastructure projects, dev tools, and applications on Optimism. Any project building with OP Stack (especially if aligning with the Superchain vision) is eligible to apply for grants from the Collective. Additionally, Optimism’s governance can authorize incentive programs (earlier in 2022, they had an airdrop and governance fund that projects could tap to distribute OP rewards to users). In 2024, Optimism established the Superchain Revenue Sharing model, where each OP Chain contributes a small portion of fees to a shared treasury. This creates a flywheel: as more chains (like Base, opBNB, Worldcoin’s chain, etc.) generate usage, they collectively fund more public goods that improve the OP Stack, which in turn attracts more chains. It’s a positive-sum approach unique to Optimism. On the go-to-market side, Optimism has actively partnered with major entities: getting Coinbase to build Base was a huge validation of OP Stack, and Optimism Labs provided technical help and support to Coinbase during that process. Similarly, they’ve worked with Worldcoin’s team, and Celo’s migration to an OP Stack L2 was done with consultation from OP Labs. Optimism does a lot of developer outreach – from running hackathons (often combined with ETHGlobal events) to maintaining a Developer Hub with tutorials. They also invest in tooling: e.g., funding teams to build alternative clients, monitoring tools, and providing an official faucet and block explorer integration for new chains. Marketing-wise, Optimism coined the term “Superchain” and actively promotes the vision of many chains uniting under one interoperable umbrella, which has attracted projects that want to be part of a broader narrative rather than an isolated appchain. There’s also the draw of shared liquidity: with the upcoming OPCraft (Superchain interoperability), apps on one OP Chain can easily interact with another, making it appealing to launch a chain that’s not an island. In essence, OP Stack’s ecosystem play is about community and collaboration – join the Superchain, get access to a pool of users (via easy bridging), funding, and collective branding. They even created a “Rollup Passport” concept where users can have a unified identity across OP Chains. All these efforts lower the barrier for new chains to find users and devs. Finally, Optimism’s own user base and reputation (being one of the top L2s) means any OP Stack chain can somewhat piggyback on that (Base did, by advertising itself as part of the Optimism ecosystem, for instance).

• zkSync (ZK Stack/Hyperchains) Ecosystem: Matter Labs (the team behind zkSync) secured large funding rounds (over $200M) to fuel its ecosystem. They have set up funds like the ** zkSync Ecosystem Fund**, often in collaboration with VCs, to invest in projects building on zkSync Era. For the ZK Stack specifically, they have started to promote the concept of Hyperchains to communities that need their own chain. One strategy is targeting specific verticals: for example, gaming. zkSync has highlighted how a game studio could launch its own Hyperchain to get customizability and still be connected to Ethereum. They are likely offering close support to initial partners (in the way Polygon did with some enterprises). The mention in the Zeeve article about a “Swiss bank; world’s largest bank” interested in ZK Stack suggests Matter Labs is courting enterprise use cases that need privacy (ZK proofs can ensure correctness while keeping some data private, a big deal for institutions). If zkSync lands a major enterprise chain, that would boost their credibility. Developer support on zkSync is quite strong: they run accelerators (e.g., an program with Blockchain Founders Fund was announced), hackathons (often zk themed ones), and have an active community on their Discord providing technical help. While zkSync doesn’t have a live token (as of 2025) for governance or incentives, there’s speculation of one, and projects might anticipate future incentive programs. Matter Labs has also been working on bridging support: they partnered with major bridges like Across, LayerZero, Wormhole to ensure assets and messages can move easily to and from zkSync and any hyperchains. In fact, Across Protocol integrated zkSync’s ZK Stack, boasting support across “all major L2 frameworks”. This interoperability focus means a project launching a hyperchain can readily connect to Ethereum mainnet and other L2s, crucial for attracting users (nobody wants to be siloed). Marketing-wise, zkSync pushes the slogan “Web3 without compromise” and emphasizes being first to ZK mainnet. They publish roadmaps (their 2025 roadmap blog) to keep excitement high. If we consider ecosystem funds: aside from direct Matter Labs grants, there’s also the Ethereum Foundation and other ZK-focused funds that favor zkSync development due to the general importance of ZK tech. Another strategy: zkSync is open source and neutral (no licensing fees), which appeals to projects that might be wary of aligning with a more centralized ecosystem. The ZK Stack is trying to position itself as the decentralizer’s choice – e.g., highlighting full decentralization and no training wheels, whereas OP Stack and others still have some centralization in practice. Time will tell if that resonates, but certainly within the Ethereum community, zkSync has supporters who want a fully trustless stack. Finally, Matter Labs and BitDAO’s Windranger have a joint initiative called “ZK DAO” which might deploy capital or incentives for the ZK Stack adoption. Overall, zkSync’s ecosystem efforts are a mix of technical superiority messaging (ZK is the future) and building practical bridges (both figurative and literal) for projects to come onboard.

• Arbitrum Orbit Ecosystem: Arbitrum has a huge existing ecosystem on its L2 (Arbitrum One), with the highest DeFi TVL among L2s in 2024. Offchain Labs leverages this by encouraging successful Arbitrum dApps to consider Orbit chains for sub-applications or L3 expansions. They announced that over 50 Orbit chains were in development by late 2023, expecting perhaps 100+ by end of 2024 – indicating substantial interest. To nurture this, Offchain Labs adopted a few strategies. First, partnerships with RaaS providers: They realized not every team can handle the rollup infra, so they enlisted Caldera, Conduit, and AltLayer to streamline it. These partners often have their own grant or incentive programs (sometimes co-sponsored by Arbitrum) to entice projects. For example, there might be an Arbitrum x AltLayer grant for gaming chains. Second, Offchain Labs provides direct technical support and co-development for key projects. The case of Xai Chain is illustrative: it’s a gaming L3 where Offchain Labs co-developed the chain and provides ongoing tech and even marketing support. They basically helped incubate Xai to showcase Orbit’s potential in gaming. Similarly, Rarible’s RARI NFT chain got integrated with many partners (Gelato for gasless, LayerZero for cross-chain NFTs, etc.) with presumably Arbitrum’s guidance. Offchain Labs also sometimes uses its war chest (Arbitrum DAO has a huge treasury of ARB tokens) to fund initiatives. While the Arbitrum DAO is separate, Offchain Labs can coordinate with it for ecosystem matters. For instance, if an Orbit chain heavily uses ARB token or benefits Arbitrum, the DAO could vote grants. However, a more direct approach: Offchain Labs launched Arbitrum Orbit Challenge hackathons and prizes to encourage developers to try making L3s. On marketing: Arbitrum’s brand is developer-focused, and they promote Orbit’s advantages like Stylus (fast, multi-language contracts) and no 7-day withdrawal (with fast bridging). They also highlight successful examples: e.g., Treasure DAO’s Bridgeworld announced an Orbit chain, etc. One more support angle: liquidity and Defi integration. Arbitrum is working with protocols so that if you launch an Orbit chain, you can tap into liquidity from Arbitrum One easily (via native bridging or LayerZero). The easier it is to get assets and users moving to your new chain, the more likely you’ll succeed. Arbitrum has a very large, active community (on Reddit, Discord, etc.), and by extending that to Orbit, new chains can market to existing Arbitrum users (for example, an Arbitrum user might get an airdrop on a new Orbit chain to try it out). In summary, Arbitrum’s ecosystem strategy for Orbit is about leveraging their L2 dominance – if you build an L3, you’re effectively an extension of the largest L2, so you get to share in that network effect. Offchain Labs is actively removing hurdles (technical and liquidity hurdles) and even directly helping build some early L3s to set precedents for others to follow.

• Polygon CDK (AggLayer) Ecosystem: Polygon has been one of the most aggressive in ecosystem and business development. They have a multi-pronged approach:

  • Grants and Funds: Polygon established a $100M Ecosystem Fund a while back, and has invested in hundreds of projects. They also had specific vertical funds (e.g., Polygon Gaming Fund, Polygon DeFi Fund). For CDK chains, Polygon announced incentives such as covering part of the cost of running a chain or providing liquidity support. The CoinLaw stats mention “More than 190 dApps are leveraging Polygon CDK to build their own chains” – which implies Polygon has gotten a vast pipeline of projects (likely many still in development). They’ve likely offered grants or resource sharing to these teams.
  • Enterprise and Institutional Onboarding: Polygon’s BizDev team has on-boarded major companies (Starbucks, Reddit, Nike, Disney for NFTs on Polygon POS). Now with CDK, they pitch enterprises to launch dedicated chains. E.g., Immutable (gaming platform) partnering to use CDK for game-specific chains, Franklin Templeton launching a fund on Polygon, and Walmart’s trial of a supply chain on a private Polygon chain. Polygon provides white-glove support to these partners: technical consulting, custom feature development (privacy, compliance), and co-marketing. The introduction of Libre (by JP Morgan/Siemens) built on Polygon CDK shows how they cater to financial institutions with specialized needs.
  • Go-to-Market and Interoperability: Polygon is creating the AggLayer as an interoperability and liquidity hub connecting all Polygon chains. This means if you launch a CDK chain, you’re not on your own – you become part of “Polygon 2.0,” a constellation of chains with unified liquidity. They promise things like one-click token transfer between CDK chains and Ethereum (via AggLayer). They are also not charging any protocol fees (no rent), which they tout as a competitive advantage against, say, Optimism’s fee sharing. Polygon’s marketing highlights that launching a CDK chain can give you “the best of both worlds”: custom sovereignty and performance plus access to the large user base and developer base of Polygon/Ethereum. They often cite that Polygon (POS+zkEVM) combined processed 30%+ of all L2 transactions, to assure potential chain builders that the flow of users on Polygon is huge.
  • Developer Support: Polygon runs perhaps the most hackathons and DevRel events in the blockchain space. They have a dedicated Polygon University, online courses, and they frequently sponsor ETHGlobal and other hackathons with challenges around using CDK, zkEVM, etc. So developers can win prizes building prototypes of CDK chains or cross-chain dapps. They also maintain a strong presence in developer communities and provide quick support (the Polygon Discord has channels for technical questions where core devs answer).
  • Community and Governance: Polygon is transitioning to Polygon 2.0 with a new POL token and community governance that spans all chains. This could mean community treasuries or incentive programs that apply to CDK chains. For example, there may be a Polygon Ecosystem Mining program where liquidity mining rewards are offered to projects that deploy on new CDK chains to bootstrap usage. The idea is to ensure new chains aren’t ghost towns.
  • Success Stories: Already, several CDK chains are live or announced: OKX’s OKB Chain (X Layer), Gnosis Pay’s chain, Astar’s zkEVM, Palm Network migrating, GameSwift (gaming chain), etc.. Polygon actively publicizes these and shares knowledge from them to others.

Overall, Polygon’s strategy is “we will do whatever it takes to help you succeed if you build on our stack.” That includes financial incentives, technical manpower, marketing exposure (speaking slots in conferences, press releases on CoinTelegraph like we saw), and integration into a larger ecosystem. It’s very much a business development-driven approach in addition to grassroots dev community, reflecting Polygon’s more corporate style relative to the others.

To summarize ecosystem support: All these frameworks understand that attracting developers and projects requires more than tech – it needs funding, hand-holding, and integration into a larger narrative. Optimism pushes a collaborative public-goods-focused narrative with fair revenue sharing. zkSync pushes the cutting-edge tech angle and likely will announce incentives aligned with a future token. Arbitrum leverages its existing dominance and provides partner networks to make launching easy, plus possibly the deepest DeFi liquidity to tap into. Polygon arguably goes the furthest in smoothing the path for both crypto-native and enterprise players, effectively subsidizing and co-marketing chains.

An illustrative comparative snapshot:

Framework	Notable Ecosystem Programs	Developer/Partner Support	Ecosystem Size (2025)
OP Stack (Optimism)	RetroPGF grants (OP token); Superchain fee sharing for public goods; Multiple grant waves for tooling & dapps.	OP Labs offers direct tech support to new chains (e.g. Base); strong dev community; Superchain branding & interoperability to attract users. Regular hackathons (often Optimism-sponsored tracks).	Optimism mainnet ~160+ dapps, Base gaining traction, 5+ OP Chains live (Base, opBNB, Worldcoin, Zora, others) and more announced (Celo). Shared $14k+ ETH revenue to Collective. Large community via Optimism and Coinbase users.
zkSync ZK Stack	zkSync Ecosystem Fund (>$200M raised for dev financing); possible future airdrops; targeted vertical programs (e.g. gaming, AI agents on Hyperchains).	Matter Labs provides technical onboarding for early Hyperchain pilots; detailed docs and open-source code. Partnered with bridge protocols for connectivity. Developer incentives mostly through hackathons and VC investments (no token incentives yet).	zkSync Era L2 has 160+ protocols, ~$100M TVL. Early hyperchains in test (no major live L3 yet). Enterprise interest signals future growth (e.g. pilot with a large bank). Strong ZK developer community and growing recognition.
Arbitrum Orbit	Arbitrum DAO $ARB treasury ($3B+) for potential grants; Offchain Labs partnership with RaaS (Caldera, AltLayer) subsidizing chain launches; Orbit Accelerator programs.	Offchain Labs co-developed flagship Orbit chains (Xai, etc.); assists with marketing (Binance Launchpad for Xai’s token). Dev support via Arbitrum’s extensive documentation and direct engineering help for integration (Stylus, custom gas). Fast bridge support for user experience.	Arbitrum One: largest L2 TVL (~$5B); ~50 Orbit chains in dev as of late 2023, ~16 launched by early 2025. Notable live chains: Xai, Rari Chain, Frame, etc. DeFi heavy ecosystem on L2 can extend liquidity to L3s. Large, loyal community (Arbitrum airdrop had >250k participants).
Polygon CDK (AggLayer)	Polygon Ecosystem Fund & many vertical funds (NFTs, gaming, enterprise); Polygon 2.0 Treasury for incentives; offering to cover certain infra costs for new chains. AggLayer liquidity/reward programs expected.	Polygon Labs team works closely with partners (e.g. Immutable, enterprises) for custom needs; extensive devrel (Polygon University, hackathons, tutorials). Integration of CDK chains with Polygon’s zkEVM and PoS infrastructure (shared wallets, bridges). Marketing via big brand partnerships (public case studies of Nike, Reddit on Polygon) to lend credibility.	Polygon PoS: huge adoption (4B+ txns); Polygon zkEVM growing (100+ dapps). CDK: 20+ chains either live (OKX, Gnosis Pay, etc.) or in pipeline by end 2024. ~190 projects exploring CDK. Enterprise adoption notable (financial institutions, retail giants). One of the largest developer ecosystems due to Polygon PoS history, now funneled into CDK.

As the table suggests, each ecosystem has its strengths – Optimism with collaborative ethos and Coinbase’s weight, zkSync with ZK leadership and innovation focus, Arbitrum with proven adoption and technical prowess (Stylus), Polygon with corporate connections and comprehensive support. All are pumping significant resources into growing their communities, because ultimately the success of a rollup framework is measured by the apps and users on the chains built with it.

Deployments and Adoption in 2025​

Finally, let’s look at where these frameworks stand in terms of real-world adoption as of 2025 – both in the crypto-native context (public networks, DeFi/NFT/gaming projects) and enterprise or institutional use:

• OP Stack Adoption: The OP Stack has powered Optimism Mainnet, which itself is one of the top Ethereum L2s with a thriving DeFi ecosystem (Uniswap, Aave, etc.) and tens of thousands of daily users. In 2023–2024, OP Stack was chosen by Coinbase for their Base network – Base launched in August 2023 and quickly onboarded popular apps (Coinbase’s own wallet integration, friend.tech social app) and reached high activity (at times even surpassing Optimism in transactions). Base’s success validated OP Stack for many; Base had 800M transactions in 2024, making it the second-highest chain by tx count that year. Another major OP Stack deployment is opBNB – Binance’s BNB Chain team created an L2 using OP Stack (but settling to BNB Chain instead of Ethereum). opBNB went live in 2023, indicating OP Stack’s flexibility to use a non-Ethereum settlement. Worldcoin’s World ID chain went live on OP Stack (settling on Ethereum) in 2023 to handle its unique biometric identity transactions. Zora Network, an NFT-centric chain by Zora, launched on OP Stack as well, tailored for creator economy use cases. Perhaps the most ambitious is Celo’s migration: Celo voted to transition from an independent L1 to an Ethereum L2 built on OP Stack – as of 2025, this migration is underway, effectively bringing a whole existing ecosystem (Celo’s DeFi and phone-focused apps) into the OP Stack fold. We also have smaller projects like Mode (Bybit’s side chain), Mantle (BitDAO’s chain) – actually Mantle opted for a modified OP Stack too. And many more are rumored or in development, given Optimism’s open-source approach (anyone can fork and launch without permission). On enterprise side, we haven’t seen much explicit OP Stack enterprise chain (enterprises seem drawn more to Polygon or custom). However, Base is an enterprise (Coinbase) backing, and that’s significant. The Superchain vision implies that even enterprise chains might join as OP Chains to benefit from shared governance – for instance, if some fintech wanted to launch a compliant chain, using OP Stack and plugging into Superchain could give it ready connectivity. As of 2025, OP Stack chains collectively (Optimism, Base, others) handle a significant portion of L2 activity, and the Superchain aggregated throughput is presented as a metric (Optimism often publishes combined stats). With Bedrock upgrade and further improvements, OP Stack chains are proving high reliability (Optimism had negligible downtime). The key measure of adoption: OP Stack is arguably the most forked rollup framework so far, given Base, BNB, Celo, etc., which are high-profile. In total, ~5-10 OP Stack chains are live mainnets, and many more testnets. If we include devnets and upcoming launches, the number grows.

• zkSync Hyperchains Adoption: zkSync Era mainnet (L2) itself launched in March 2023 and by 2025 it’s among the top ZK rollups, with ~$100M TVL and dozens of projects. Notable apps like Curve, Uniswap, Chainlink deployed or announced deployment on zkSync. Now, regarding Hyperchains (L3 or sovereign chains), this is very cutting-edge. In late 2024, Matter Labs launched a program for teams to experiment with L3s on top of zkSync. One example: the Rollup-as-a-Service provider Decentriq was reportedly testing a private Hyperchain for data sharing. Also, Blockchain Capital (VC) hinted at experimenting with an L3. We have mention that an ecosystem of 18+ protocols is leveraging ZK Stack for things like AI agents and specialized use cases – possibly on testnets. No major Hyperchain is publicly serving users yet (as far as known by mid-2025). However, interest is high in specific domains: gaming projects have shown interest in ZK hyperchains for fast finality and customizability, and privacy-oriented chains (a Hyperchain could include encryption and use zkProofs to hide data – something an optimistic rollup can’t offer as easily). The comment about a “Swiss bank” suggests maybe UBS or a consortium is testing a private chain using ZK Stack, likely attracted by throughput (~10k TPS) and privacy. If that moves to production, it would be a flagship enterprise case. In summary, zkSync’s Hyperchain adoption in 2025 is in an early pilot stage: developer infrastructure is ready (as evidenced by documentation and some test deployments), but we’re waiting for the first movers to go live. It’s comparable to where Optimism was in early 2021 – proven tech but just starting adoption. By end of 2025, we could expect a couple of Hyperchains live, possibly one community-driven (maybe a gaming Hyperchain spun out of a popular zkSync game) and one enterprise-driven. Another factor: there’s talk of Layer3s on zkSync Era as well – essentially permissionless L3s where anyone can deploy an app-chain atop zkSync’s L2. Matter Labs has built the contracts to allow that, so we may see user-driven L3s (like someone launching a mini rollup for their specific app) which counts as adoption of the ZK Stack.

• Arbitrum Orbit Adoption: Arbitrum Orbit saw a surge of interest after its formal introduction in mid-2023. By late 2023, around 18 Orbit chains were publicly disclosed, and Offchain Labs indicated over 50 in progress. As of 2025, some of the prominent ones:

  • Xai Chain: A gaming-focused L3, now live (mainnet launched late 2023). It’s used by game developers (like Ex Populus studio) and had a token launch via Binance Launchpad. This indicates decent adoption (Binance Launchpad involvement suggests lots of user interest). Xai uses AnyTrust mode (for high TPS).
  • Rari Chain: An NFT-centric L3 by Rarible. Launched mainnet Jan 2024. It’s focused on NFT marketplaces with features like credit card payments for gas (via Stripe) and gasless listings. This chain is a good showcase of customizing user experience (as noted, Gelato provides gasless transactions, etc. on Rari Chain).
  • Frame: A creator-focused L2 (though called L2, it’s likely an Orbit chain settling on Ethereum or Arbitrum). It launched early 2024 after raising funding.
  • EduChain (by Camelot/GMX communities): The Zeeve article mentions an EDU chain with a large number of projects – possibly an ecosystem for on-chain education and AI, built on Orbit.
  • Ape Chain: Not explicitly mentioned above, but the context from Zeeve suggests an “Ape chain” (maybe Yuga Labs or ApeCoin DAO chain) exists with $9.86M TVL and uses APE for gas. That could be an Orbit chain in the ApeCoin ecosystem (this would be significant given Yuga’s influence in NFTs).
  • Other gaming chains: e.g., Cometh’s “Muster” L3 was announced (a gaming platform partnering with AltLayer). Syndr Chain for an options trading protocol is on testnet as Orbit L3. Meliora (DeFi credit protocol) building an Orbit L3.
  • Many of these are in early stages (testnet or recently launched mainnet), but collectively they indicate Orbit is gaining adoption among specialized dApps that outgrew a shared L2 environment or wanted their own governance.
  • On enterprise: not as much noise here. Arbitrum is known more for DeFi/gaming adoption. However, the technology could appeal to enterprise if they want an Ethereum-secured chain with flexible trust (via AnyTrust). It’s possible some enterprise quietly used Arbitrum technology for a private chain, but not publicized.
  • By the numbers, Arbitrum Orbit’s biggest user so far might be Ape Chain (if confirmed) with ~$10M TVL and 17 protocols on it (according to Zeeve). Another is EDU chain with 1.35M TVL and 30+ projects.
  • Arbitrum One and Nova themselves are part of this narrative – the fact Orbit chains can settle on Nova (ultra-cheap social/gaming chain) or One means adoption of Orbit also drives activity to those networks. Nova has seen usage for Reddit points etc. If Orbit chains plug into Nova’s AnyTrust committee, Nova’s role grows.
  • In sum, Arbitrum Orbit has moved beyond theory: dozens of real projects are building on it, focusing on gaming, social, and custom DeFi. Arbitrum’s approach of showing real use-cases (like Xai, Rari) has paid off, and we can expect by end of 2025 there will be possibly 50+ Orbit chains live, some with significant user bases (especially if one of the gaming chains hits a popular game release).

• Polygon CDK Adoption: Polygon only announced CDK in H2 2023, but it piggybacks on the success of Polygon’s existing networks. Already, Polygon zkEVM (mainnet beta) itself is essentially a CDK chain run by Polygon Labs. It has seen decent adoption (over $50M TVL, major protocols deployed). But beyond that, numerous independent chains are in motion:

  • Immutable X (a large Web3 gaming platform) declared support for Polygon CDK to let game studios spin up their own zk-rollups that connect to Immutable and Polygon liquidity. This alliance means possibly dozens of games using CDK via Immutable in 2025.
  • OKX (exchange) launched OKB Chain (aka X Chain) using Polygon CDK in late 2024. An exchange chain can drive a lot of transactions (cex-to-dex flows, etc.). OKX chose Polygon presumably for scalability and because many of their users already use Polygon.
  • Canto (DeFi chain) and Astar (Polkadot sidechain) are mentioned as migrating to or integrating with Polygon CDK. Canto moving from Cosmos to Polygon layer indicates the appeal of sharing security with Ethereum via Polygon’s ZK.
  • Gnosis Pay: launched Gnosis Card chain with CDK – it’s a chain to allow fast stablecoin payments connected to a Visa card. This is live and an innovative fintech use.
  • Palm Network: a NFT-specialized chain originally on Ethereum is moving to Polygon CDK (Palm was co-founded by ConsenSys for NFTs with DC Comics, etc.).
  • dYdX: This is interesting – dYdX was building its own Cosmos chain, but Zeeve’s info lists dYdX under AggLayer CDK chains. If dYdX were to consider Polygon instead, that would be huge (though as of known info, dYdX V4 is Cosmos-based; perhaps they plan cross-chain or future pivot).
  • Nubank: one of the largest digital banks in Brazil, appears in Zeeve’s list. Nubank had launched a token on Polygon earlier; a CDK chain for their rewards or CBDC-like program could be in testing.
  • Wirex, IDEX, GameSwift, Aavegotchi, Powerloom, Manta… these names in Zeeve’s list show how cross-ecosystem the CDK reach is: e.g., Manta (a Polkadot privacy project) might use CDK for an Ethereum-facing ZK solution; Aavegotchi (an NFT game originally on Polygon POS) might get its own chain for game logic.
  • The Celestia integration in early 2024 will likely attract projects that want the Polygon tech but with Celestia DA – possibly some Cosmos projects (since Celestia is Cosmos-based) will choose Polygon CDK for execution and Celestia for DA.
  • Enterprises: Polygon has a dedicated enterprise team. Apart from those mentioned (Stripe on stablecoins, Franklin Templeton fund on Polygon, country governments minting stamps, etc.), with CDK they can promise enterprises their own chain with custom rules. We might see pilots like “Polygon Siemens Chain” or government chains emerging, though often those start private.
  • Polygon’s approach of being chain-agnostic (they even support an “OP Stack mode” now in CDK per Zeeve!) and not charging rent, has meant a rapid onboarding – they claim 190+ projects using or considering CDK by Q1 2025. If even a quarter of those go live, Polygon will have an expansive network of chains. They envision themselves not just as one chain but as an ecosystem of many chains (Polygon 2.0), possibly the largest such network if successful.
  • By numbers: as of early 2025, 21+ chains are either in mainnet or testnet using CDK according to the AggLayer site. This should accelerate through 2025 as more migrate or launch.
  • We can expect some high-profile launches, e.g. a Reddit chain (Reddit’s avatars on Polygon POS were huge; a dedicated Polygon L2 for Reddit could happen). Also, if any central bank digital currencies (CBDCs) or government projects choose a scaling solution, Polygon is often in those conversations – a CDK chain could be their choice for a permissioned L2 with zk proofs.

In summary, 2025 adoption status: OP Stack and Arbitrum Orbit have multiple live chains with real users and TVL, zkSync’s hyperchains are on the cusp with strong test pilots, and Polygon CDK has many lined up and a few live successes in both crypto and enterprise. The space is evolving rapidly, and projects often cross-consider these frameworks before choosing. It’s not zero-sum either – e.g., an app might use an OP Stack chain and a Polygon CDK chain for different regions or purposes. The modular blockchain future likely involves interoperability among all these frameworks. It’s notable that efforts like LayerZero and bridge aggregators now ensure assets move relatively freely between Optimism, Arbitrum, Polygon, zkSync, etc., so users might not even realize which stack a chain is built on under the hood.

Conclusion​

Rollups-as-a-Service in 2025 offers a rich menu of options. OP Stack provides a battle-tested optimistic rollup framework with Ethereum alignment and the backing of a collaborative Superchain community. ZK Stack (Hyperchains) delivers cutting-edge zero-knowledge technology with modular validity and data choices, aiming for massive scalability and new use-cases like private or Layer-3 chains. Arbitrum Orbit extends a highly optimized optimistic rollup architecture to developers, with flexibility in data availability and the exciting addition of Stylus for multi-language smart contracts. Polygon CDK empowers projects to launch zkEVM chains with out-of-the-box interoperability (AggLayer) and the full support of Polygon’s ecosystem and enterprise ties. zkSync Hyperchains (via ZK Stack) promise to unlock Web3 at scale – multiple hyperchains all secured by Ethereum, each optimized for its domain (be it gaming, DeFi, or social), with seamless connectivity through zkSync’s Elastic framework.

In comparing data availability, we saw all frameworks embracing modular DA – Ethereum for security, and newer solutions like Celestia, EigenDA, or committees for throughput. Sequencer designs are initially centralized but moving toward decentralization: Optimism and Arbitrum provide L1 fallback queues and are enabling multi-sequencer or permissionless validator models, while Polygon and zkSync allow custom consensus deployment for chains that desire it. Fee models differ mainly in ecosystem philosophy – Optimism’s revenue share vs others’ self-contained economies – but all allow custom tokens and aim to minimize user costs by leveraging cheaper DA and fast finality (especially ZK chains).

On ecosystem support, Optimism fosters a collective where each chain contributes to shared goals (funding public goods) and benefits from shared upgrades. Arbitrum leverages its thriving community and liquidity, actively helping projects launch Orbit chains and integrating them with its DeFi hub. Polygon goes all-in with resources, courting both crypto projects and corporates, providing perhaps the most hands-on support and boasting an extensive network of partnerships and funds. Matter Labs (zkSync) drives innovation and appeals to those who want the latest ZK tech, and while its incentive programs are less publicly structured (pending a token), it has significant funding to deploy and a strong pull for ZK-minded builders.

From a developer’s perspective, launching a rollup in 2025 is more accessible than ever. Whether one’s priority is EVM-equivalence and ease (OP Stack, Arbitrum) or maximum performance and future-proof tech (ZK Stack, Polygon CDK), the tools and documentation are in place. Even monitoring and dev-tools have grown to support these custom chains – for instance, Alchemy and QuickNode’s RaaS platforms support Optimism, Arbitrum, and zkSync stacks out-of-the-box. This means teams can focus on their application and leave much of the heavy lifting to these frameworks.

Looking at public and enterprise adoption, it’s clear that modular rollups are moving from experimental to mainstream. We have global brands like Coinbase, Binance, and OKX running their own chains, major DeFi protocols like Uniswap expanding to multiple L2s and possibly their own rollups, and even governments and banks exploring these technologies. The competition (and collaboration) between OP Stack, ZK Stack, Orbit, CDK, etc., is driving rapid innovation – ultimately benefiting Ethereum by scaling it to reach millions of new users through tailored rollups.

Each framework has its unique value proposition:

• OP Stack: Easy on-ramp to L2, shared Superchain network effects, and a philosophy of “impact = profit” via public goods.
• ZK Stack: Endgame scalability with ZK integrity, flexibility in design (L2 or L3, rollup or validium), and prevention of liquidity fragmentation through the Elastic chain model.
• Arbitrum Orbit: Proven tech (Arbitrum One never had a major failure), high performance (Nitro + Stylus), and the ability to customize trust assumptions (full rollup security or faster AnyTrust) for different needs.
• Polygon CDK: Turnkey zk-rollups backed by one of the largest ecosystems, with immediate connectivity to Polygon/Ethereum assets and the promise of future “unified liquidity” via AggLayer – effectively a launchpad not just for a chain, but for a whole economy on that chain.
• zkSync Hyperchains: A vision of Layer-3 scalability where even small apps can have their own chain secured by Ethereum, with minimal overhead, enabling Web2-level performance in a Web3 environment.

As of mid-2025, we are seeing the multi-chain modular ecosystem materialize: dozens of app-specific or sector-specific chains coexisting, many built with these stacks. L2Beat and similar sites now track not just L2s but L3s and custom chains, many of which use OP Stack, Orbit, CDK, or ZK Stack. Interoperability standards are being developed so that whether a chain uses Optimism or Polygon tech, they can talk to each other (projects like Hyperlane, LayerZero, and even OP and Polygon collaboration on shared sequencing).

In conclusion, Rollups-as-a-Service in 2025 has matured into a competitive landscape with OP Stack, ZK Stack, Arbitrum Orbit, Polygon CDK, and zkSync Hyperchains each offering robust, modular blockchain frameworks. They differ in technical approach (Optimistic vs ZK), but all aim to empower developers to launch scalable, secure chains tailored to their needs. The choice of stack may depend on a project’s specific priorities – EVM compatibility, finality speed, customization, community alignment, etc. – as outlined above. The good news is that there is no shortage of options or support. Ethereum’s rollup-centric roadmap is being realized through these frameworks, heralding an era where launching a new chain is not a monumental feat, but rather a strategic decision akin to choosing a cloud provider or tech stack in Web2. The frameworks will continue to evolve (e.g. we anticipate more convergence, like OP Stack embracing ZK proofs, Polygon’s AggLayer connecting to non-Polygon chains, etc.), but even now they collectively ensure that Ethereum’s scalability and ecosystem growth are limited only by imagination, not infrastructure.

Sources:

• Optimism OP Stack – Documentation and Mirror posts
• zkSync ZK Stack – zkSync docs and Matter Labs posts
• Arbitrum Orbit – Arbitrum docs, Offchain Labs announcements
• Polygon CDK – Polygon Tech docs, CoinTelegraph report
• General comparison – QuickNode Guides (Mar 2025), Zeeve and others for ecosystem stats, plus various project blogs as cited above.

For years, the conventional wisdom in the blockchain space has been that bigger is better. The Ethereum Global Network (EGN), the vast peer-to-peer (P2P) layer supporting thousands of services from the Ethereum mainnet to countless other projects, was built on this very idea[cite: 4, 25]. The theory was simple: a massive, blended network where everyone shares the same space would boost node discovery and make the ecosystem more resilient to attacks[cite: 34, 35].

However, a critical research paper, "A Place for Everyone vs Everyone in its Place: Measuring and Attacking the Ethereum Global Network," challenges this foundational belief. The study reveals that this "place for everyone" architecture, rather than being a source of strength, introduces severe inefficiencies and alarming security vulnerabilities that could impact services with a collective market cap of over $500 billion[cite: 6, 24].

The Efficiency Nightmare: Shouting into a Crowd​

The promise of EGN was that nodes could easily find and connect with peers offering the same service[cite: 34]. The reality is the complete opposite. The study found that nodes desperately struggle to find their counterparts in the vast, noisy sea of the EGN[cite: 8].

The inefficiency is staggering:

• Wasted Connections: Over 75% of a node's connection attempts are directed at peers from entirely different services[cite: 8].
• Extreme Connection Costs: In one startling case, a node had to make an average of 45,908 connection attempts just to find a single valid neighbor[cite: 9]. This stands in stark contrast to Bitcoin's estimated success rate of one in four[cite: 54].
• A Step Backward: The newer discovery protocol, Discv5, which was intended to be an improvement, performs even more poorly. In a 12-hour test, nodes using Discv5 established three or fewer connections, largely because a crucial "topic discovery mechanism" designed to advertise services remains unimplemented in all major clients[cite: 57, 59].

The core issue is that the vast majority of nodes in the EGN have routing tables (their "address books") filled with irrelevant peers. The research found that most Discv4 nodes maintain less than 5% of same-service peers in their DHTs (Distributed Hash Tables)[cite: 44].

The Security Illusion: A Vulnerable Giant​

The second pillar of the "bigger is better" argument was security—that EGN's sheer size would dilute any attacker's influence[cite: 35]. The paper demolishes this assumption by simulating a DHT pollution attack, a foundational attack where malicious nodes flood the network's address books with their own entries[cite: 61, 62].

The results show that EGN's blended nature is not a defense, but a critical vulnerability[cite: 10, 65]:

• Devastatingly Effective: With just 300 malicious nodes (less than 0.3% of the network), an attacker can pollute the network so effectively that connection success rates for most services plummet to below 1%[cite: 11, 63].
• Mass Isolation: After just 24 hours, this small-scale attack was able to successfully partition the network, isolating thousands of honest nodes from their services[cite: 11, 64].
• Design, Not a Flaw: This vulnerability isn't due to a bug but is an inherent consequence of the blended architecture[cite: 65]. When the same attack was simulated on separate, dedicated networks for each service, it proved "largely ineffective" because the routing tables were clean and filled only with relevant peers[cite: 66].

The Path Forward: "Everyone in its Place"​

The research concludes that the EGN's blended architecture is detrimental, especially to smaller services that become collateral damage in this inefficient and insecure environment[cite: 37]. The solution is not to abandon the global network but to organize it better, shifting from "a place for everyone" to ensuring "everyone is in its place"[cite: 522].

The paper proposes two key solutions:

1. Service-Specific DHTs: Mandate that all nodes include their service information directly in their Ethereum Node Record (ENR)[cite: 490, 491]. This simple change would allow nodes to filter for and prioritize same-service peers, dramatically improving discovery efficiency and security without sacrificing decentralization[cite: 495].
2. More Reliable Bootnodes: The simulations highlighted the critical role of bootnodes as a last line of defense against network partitioning[cite: 496]. The paper recommends that services increase the number of their bootnodes and configure them to prioritize storing same-service peers, creating a resilient backbone for network recovery[cite: 499].

For developers and the health of the entire ecosystem, these findings are a crucial wake-up call. A robust and efficient P2P layer is the bedrock of any decentralized service. By implementing these proposed fixes, the community can move toward a more organized, secure, and truly global network that works for everyone.

Plume Network: Overview and Value Proposition​

Plume Network is a blockchain platform purpose-built for Real-World Assets (RWA). It is a public, Ethereum-compatible chain designed to tokenize a wide range of real-world financial assets – from private credit and real estate to carbon credits and even collectibles – and make them as usable as native crypto assets. In other words, Plume doesn’t just put assets on-chain; it allows users to hold and utilize tokenized real assets in decentralized finance (DeFi) – enabling familiar crypto activities like staking, lending, borrowing, swapping, and speculative trading on assets that originate in traditional finance.

The core value proposition of Plume is to bridge TradFi and DeFi by turning traditionally illiquid or inaccessible assets into programmable, liquid tokens. By integrating institutional-grade assets (e.g. private credit funds, ETFs, commodities) with DeFi infrastructure, Plume aims to make high-quality investments – which were once limited to large institutions or specific markets – permissionless, composable, and a click away for crypto users. This opens the door for crypto participants to earn “real yield” backed by stable real-world cash flows (such as loan interest, rental income, bond yields, etc.) rather than relying on inflationary token rewards. Plume’s mission is to drive “RWA Finance (RWAfi)”, creating a transparent and open financial system where anyone can access assets like private credit, real estate debt, or commodities on-chain, and use them freely in novel ways.

In summary, Plume Network serves as an “on-chain home for real-world assets”, offering a full-stack ecosystem that transforms off-chain assets into globally accessible financial tools with true crypto-native utility. Users can stake stablecoins to earn yields from top fund managers (Apollo, BlackRock, Blackstone, etc.), loop and leverage RWA-backed tokens as collateral, and trade RWAs as easily as ERC-20 tokens. By doing so, Plume stands out as a platform striving to make alternative assets more liquid and programmable, bringing fresh capital and investment opportunities into Web3 without sacrificing transparency or user experience.

Technology and Architecture​

Plume Network is implemented as an EVM-compatible blockchain with a modular Layer-2 architecture. Under the hood, Plume operates similarly to an Ethereum rollup (comparable to Arbitrum’s technology), utilizing Ethereum for data availability and security. Every transaction on Plume is eventually batch-posted to Ethereum, which means users pay a small extra fee to cover the cost of publishing calldata on Ethereum. This design leverages Ethereum’s robust security while allowing Plume to have its own high-throughput execution environment. Plume runs a sequencer that aggregates transactions and commits them to Ethereum periodically, giving the chain faster execution and lower fees for RWA use-cases, but anchored to Ethereum for trust and finality.

Because Plume is EVM-compatible, developers can deploy Solidity smart contracts on Plume just as they would on Ethereum, with almost no changes. The chain supports the standard Ethereum RPC methods and Solidity operations, with only minor differences (e.g. Plume’s block number and timestamp semantics mirror Arbitrum’s conventions due to the Layer-2 design). In practice, this means Plume can easily integrate existing DeFi protocols and developer tooling. The Plume docs note that cross-chain messaging is supported between Ethereum (the “parent” chain) and Plume (the L2), enabling assets and data to move between the chains as needed.

Notably, Plume describes itself as a “modular blockchain” optimized for RWA finance. The modular approach is evident in its architecture: it has dedicated components for bridging assets (called Arc for bringing anything on-chain), for omnichain yield routing (SkyLink) across multiple blockchains, and for on-chain data feeds (Nexus, an “onchain data highway”). This suggests Plume is building an interconnected system where real-world asset tokens on Plume can interact with liquidity on other chains and where off-chain data (like asset valuations, interest rates, etc.) is reliably fed on-chain. Plume’s infrastructure also includes a custom wallet called Plume Passport (the “RWAfi Wallet”) which likely handles identity/AML checks necessary for RWA compliance, and a native stablecoin (pUSD) for transacting in the ecosystem.

Importantly, Plume’s current iteration is often called a Layer-2 or rollup chain – it is built atop Ethereum for security. However, the team has hinted at ambitious plans to evolve the tech further. Plume’s CTO noted that they started as a modular L2 rollup but are now pushing “down the stack” toward a fully sovereign Layer-1 architecture, optimizing a new chain from scratch with high performance, privacy features “comparable to Swiss banks,” and a novel crypto-economic security model to secure the next trillion dollars on-chain. While specifics are scant, this suggests that over time Plume may transition to a more independent chain or incorporate advanced features like FHE (Fully Homomorphic Encryption) or zk-proofs (the mention of zkTLS and privacy) to meet institutional requirements. For now, though, Plume’s mainnet leverages Ethereum’s security and EVM environment to rapidly onboard assets and users, providing a familiar but enhanced DeFi experience for RWAs.

Tokenomics and Incentives​

PLUME ($PLUME) is the native utility token of the Plume Network. The $PLUME token is used to power transactions, governance, and network security on Plume. As the gas token, $PLUME is required to pay transaction fees on the Plume chain (similar to how ETH is gas on Ethereum). This means all operations – trading, staking, deploying contracts – consume $PLUME for fees. Beyond gas, $PLUME has several utility and incentive roles:

• Governance: $PLUME holders can participate in governance decisions, presumably voting on protocol parameters, upgrades, or asset onboarding decisions.
• Staking/Security: The token can be staked, which likely supports the network’s validator or sequencer operations. Stakers help secure the chain and in return earn staking rewards in $PLUME. (Even as a rollup, Plume may use a proof-of-stake mechanism for its sequencer or for eventual decentralization of block production).
• Real Yield and DeFi utility: Plume’s docs mention that users can use $PLUME across dApps to “unlock real yield”. This suggests that holding or staking $PLUME might confer higher yields in certain RWA yield farms or access to exclusive opportunities in the ecosystem.
• Ecosystem Incentives: $PLUME is also used to reward community engagement – for example, users might earn tokens via community quests, referral programs, testnet participation (such as the “Take Flight” developer program or the testnet “Goons” NFTs). This incentive design is meant to bootstrap network effects by distributing tokens to those who actively use and grow the platform.

Token Supply & Distribution: Plume has a fixed total supply of 10 billion $PLUME tokens. At the Token Generation Event (mainnet launch), the initial circulating supply is 20% of the total (i.e. 2 billion tokens). The allocation is heavily weighted toward community and ecosystem development:

• 59% to Community, Ecosystem & Foundation – this large share is reserved for grants, liquidity incentives, community rewards, and a foundation pool to support the ecosystem’s long-term growth. This ensures a majority of tokens are available to bootstrap usage (and potentially signals commitment to decentralization over time).
• 21% to Early Backers – these tokens are allocated to strategic investors and partners who funded Plume’s development. (As we’ll see, Plume raised capital from prominent crypto funds; this allocation likely vests over time as per investor agreements.)
• 20% to Core Contributors (Team) – allocated to the founding team and core developers driving Plume. This portion incentivizes the team and aligns them with the network’s success, typically vesting over a multi-year period.

Besides $PLUME, Plume’s ecosystem includes a stablecoin called Plume USD (pUSD). pUSD is designed as the RWAfi ecosystem stablecoin for Plume. It serves as the unit of account and primary trading/collateral currency within Plume’s DeFi apps. Uniquely, pUSD is fully backed 1:1 by USDC – effectively a wrapped USDC for the Plume network. This design choice (wrapping USDC) was made to reduce friction for traditional institutions: if an organization is already comfortable holding and minting USDC, they can seamlessly mint and use pUSD on Plume under the same frameworks. pUSD is minted and redeemed natively on both Ethereum and Plume, meaning users or institutions can deposit USDC on Ethereum and receive pUSD on Plume, or vice versa. By tying pUSD 1:1 to USDC (and ultimately to USD reserves), Plume ensures its stablecoin remains fully collateralized and liquid, which is critical for RWA transactions (where predictability and stability of the medium of exchange are required). In practice, pUSD provides a common stable liquidity layer for all RWA apps on Plume – whether it’s buying tokenized bonds, investing in RWA yield vaults, or trading assets on a DEX, pUSD is the stablecoin that underpins value exchange.

Overall, Plume’s tokenomics aim to balance network utility with growth incentives. $PLUME ensures the network is self-sustaining (through fees and staking security) and community-governed, while large allocations to ecosystem funds and airdrops help drive early adoption. Meanwhile, pUSD anchors the financial ecosystem in a trustworthy stable asset, making it easier for traditional capital to enter Plume and for DeFi users to measure returns on real-world investments.

Founding Team and Backers​

Plume Network was founded in 2022 by a trio of entrepreneurs with backgrounds in crypto and finance: Chris Yin (CEO), Eugene Shen (CTO), and Teddy Pornprinya (CBO). Chris Yin is described as the visionary product leader of the team, driving the platform’s strategy and thought leadership in the RWA space. Eugene Shen leads the technical development as CTO (previously having worked on modular blockchain architectures, given his note about “customizing geth” and building from the ground up). Teddy Pornprinya, as Chief Business Officer, spearheads partnerships, business development, and marketing – he was instrumental in onboarding dozens of projects into the Plume ecosystem early on. Together, the founders identified the gap in the market for an RWA-optimized chain and quit their prior roles to build Plume, officially launching the project roughly a year after conception.

Plume has attracted significant backing from both crypto-native VCs and traditional finance giants, signaling strong confidence in its vision:

• In May 2023, Plume raised a $10 million seed round led by Haun Ventures (the fund of former a16z partner Katie Haun). Other participants in the seed included Galaxy Digital, Superscrypt (Temasek’s crypto arm), A Capital, SV Angel, Portal Ventures, and Reciprocal Ventures. This diverse investor base gave Plume a strong start, combining crypto expertise and institutional connections.

• By late 2024, Plume secured a $20 million Series A funding to accelerate its development. This round was backed by top-tier investors such as Brevan Howard Digital, Haun Ventures (returning), Galaxy, and Faction VC. The inclusion of Brevan Howard, one of the world’s largest hedge funds with a dedicated crypto arm, is especially notable and underscored the growing Wall Street interest in RWAs on blockchain.

• In April 2025, Apollo Global Management – one of the world’s largest alternative asset managers – made a strategic investment in Plume. Apollo’s investment was a seven-figure (USD) amount intended to help Plume scale its infrastructure and bring more traditional financial products on-chain. Apollo’s involvement is a strong validation of Plume’s approach: Christine Moy, Apollo’s Head of Digital Assets, said their investment “underscores Apollo’s focus on technologies that broaden access to institutional-quality products… Plume represents a new kind of infrastructure focused on digital asset utility, investor engagement, and next-generation financial solutions”. In other words, Apollo sees Plume as key infrastructure to make private markets more liquid and accessible via blockchain.

• Another strategic backer is YZi Labs, formerly Binance Labs. In early 2025, YZi (Binance’s venture arm rebranded) announced a strategic investment in Plume Network as well. YZi Labs highlighted Plume as a “cutting-edge Layer-2 blockchain designed for scaling real world assets”, and their support signals confidence that Plume can bridge TradFi and DeFi at a large scale. (It’s worth noting Binance Labs’ rebranding to YZi Labs indicates continuity of their investments in core infrastructure projects like Plume.)

• Plume’s backers also include traditional fintech and crypto institutions through partnerships (detailed below) – for example, Mercado Bitcoin (Latin America’s largest digital asset platform) and Anchorage Digital (a regulated crypto custodian) are ecosystem partners, effectively aligning themselves with Plume’s success. Additionally, Grayscale Investments – the world’s largest digital asset manager – has taken notice: in April 2025, Grayscale officially added $PLUME to its list of assets “Under Consideration” for future investment products. Being on Grayscale’s radar means Plume could potentially be included in institutional crypto trusts or ETFs, a major nod of legitimacy for a relatively new project.

In summary, Plume’s funding and support comes from a who’s-who of top investors: premier crypto VCs (Haun, Galaxy, a16z via GFI’s backing of Goldfinch, etc.), hedge funds and TradFi players (Brevan Howard, Apollo), and corporate venture arms (Binance/YZi). This mix of backers brings not just capital but also strategic guidance, regulatory expertise, and connections to real-world asset originators. It has also provided Plume with war-chest funding (at least $30M+ over seed and Series A) to build out its specialized blockchain and onboard assets. The strong backing serves as a vote of confidence that Plume is positioned as a leading platform in the fast-growing RWA sector.

Ecosystem Partners and Integrations​

Plume has been very active in forging ecosystem partnerships across both crypto and traditional finance, assembling a broad network of integrations even before (and immediately upon) mainnet launch. These partners provide the assets, infrastructure, and distribution that make Plume’s RWA ecosystem functional:

• Nest Protocol (Nest Credit): An RWA yield platform that operates on Plume, allowing users to deposit stablecoins into vaults and receive yield-bearing tokens backed by real-world assets. Nest is essentially a DeFi frontend for RWA yields, offering products like tokenized U.S. Treasury Bills, private credit, mineral rights, etc., but abstracting away the complexity so they “feel like crypto.” Users swap USDC (or pUSD) for Nest-issued tokens that are fully backed by regulated, audited assets held by custodians. Nest works closely with Plume – a testimonial from Anil Sood of Anemoy (a partner) highlights that “partnering with Plume accelerates our mission to bring institutional-grade RWAs to every investor… This collaboration is a blueprint for the future of RWA innovation.”. In practice, Nest is Plume’s native yield marketplace (sometimes called “Nest Yield” or RWA staking platform), and many of Plume’s big partnerships funnel into Nest vaults.

• Mercado Bitcoin (MB): The largest digital asset exchange in Latin America (based in Brazil) has partnered with Plume to tokenize ~$40 million of Brazilian real-world assets. This initiative, announced in Feb 2025, involves MB using Plume’s blockchain to issue tokens representing Brazilian asset-backed securities, consumer credit portfolios, corporate debt, and accounts receivable. The goal is to connect global investors with yield-bearing opportunities in Brazil’s economy – effectively opening up Brazilian credit markets to on-chain investors worldwide through Plume. These Brazilian RWA tokens will be available from day one of Plume’s mainnet on the Nest platform, providing stable on-chain returns backed by Brazilian small-business loans and credit receivables. This partnership is notable because it gives Plume a geographic reach (LATAM) and a pipeline of emerging-market assets, showcasing how Plume can serve as a hub connecting regional asset originators to global liquidity.

• Superstate: Superstate is a fintech startup founded by Robert Leshner (former founder of Compound), focused on bringing regulated U.S. Treasury fund products on-chain. In 2024, Superstate launched a tokenized U.S. Treasury fund (approved as a 1940 Act mutual fund) targeted at crypto users. Plume was chosen by Superstate to power its multi-chain expansion. In practice, this means Superstate’s tokenized T-bill fund (which offers stable yield from U.S. government bonds) is being made available on Plume, where it can be integrated into Plume’s DeFi ecosystem. Leshner himself said: “by expanding to Plume – the unique RWAfi chain – we can demonstrate how purpose-built infrastructure can enable great new use-cases for tokenized assets. We’re excited to build on Plume.”. This indicates Superstate will deploy its fund tokens (e.g., maybe an on-chain share of a Treasuries fund) on Plume, allowing Plume users to hold or use them in DeFi (perhaps as collateral for borrowing, or in Nest vaults for auto-yield). It is a strong validation that Plume’s chain is seen as a preferred home for regulated asset tokens like Treasuries.

• Ondo Finance: Ondo is a well-known DeFi project that pivoted into the RWA space by offering tokenized bonds and yield products (notably, Ondo’s OUSG token, which represents shares in a short-term U.S. Treasury fund, and USDY, representing an interest-bearing USD deposit product). Ondo is listed among Plume’s ecosystem partners, implying a collaboration where Ondo’s yield-bearing tokens (like OUSG, USDY) can be used on Plume. In fact, Ondo’s products align closely with Plume’s goals: Ondo established legal vehicles (SPVs) to ensure compliance, and its OUSG token is backed by BlackRock’s tokenized money market fund (BUIDL), providing ~4.5% APY from Treasuries. By integrating Ondo, Plume gains blue-chip RWA assets like U.S. Treasuries on-chain. Indeed, as of late 2024, Ondo’s RWA products had a market value around $600+ million, so bridging them to Plume adds significant TVL. This synergy likely allows Plume users to swap into Ondo’s tokens or include them in Nest vaults for composite strategies.

• Centrifuge: Centrifuge is a pioneer in RWA tokenization (operating its own Polkadot parachain for RWA pools). Plume’s site lists Centrifuge as a partner, suggesting collaboration or integration. This could mean that Centrifuge’s pools of assets (trade finance, real estate bridge loans, etc.) might be accessible from Plume, or that Centrifuge will use Plume’s infrastructure for distribution. For example, Plume’s SkyLink omnichain yield might route liquidity from Plume into Centrifuge pools on Polkadot, or Centrifuge could tokenize certain assets directly onto Plume for deeper DeFi composability. Given Centrifuge leads the private credit RWA category with ~$409M TVL in its pools, its participation in Plume’s ecosystem is significant. It indicates an industry-wide move toward interoperability among RWA platforms, with Plume acting as a unifying layer for RWA liquidity across chains.

• Credbull: Credbull is a private credit fund platform that partnered with Plume to launch a large tokenized credit fund. According to CoinDesk, Credbull is rolling out up to a $500M private credit fund on Plume, offering a fixed high yield to on-chain investors. This likely involves packaging private credit (loans to mid-sized companies or other credit assets) into a vehicle where on-chain stablecoin holders can invest for a fixed return. The significance is twofold: (1) It adds a huge pipeline of yield assets (~half a billion dollars) to Plume’s network, and (2) it exemplifies how Plume is attracting real asset managers to originate products on its chain. Combined with other pipeline assets, Plume said it planned to tokenize about $1.25 billion worth of RWAs by late 2024, including Credbull’s fund, plus $300M of renewable energy assets (solar farms via Plural Energy), ~$120M of healthcare receivables (Medicaid-backed invoices), and even oil & gas mineral rights. This large pipeline shows that at launch, Plume isn’t empty – it comes with tangible assets ready to go.

• Goldfinch: Goldfinch is a decentralized credit protocol that provided undercollateralized loans to fintech lenders globally. In 2023, Goldfinch pivoted to “Goldfinch Prime”, targeting accredited and institutional investors by offering on-chain access to top private credit funds. Plume and Goldfinch announced a strategic partnership to bring Goldfinch Prime’s offerings to Plume’s Nest platform, effectively marrying Goldfinch’s institutional credit deals with Plume’s user base. Through this partnership, institutional investors on Plume can stake stablecoins into funds managed by Apollo, Golub Capital, Aries, Stellus, and other leading private credit managers via Goldfinch’s integration. The ambition is massive: collectively these managers represent over $1 trillion in assets, and the partnership aims to eventually make portions of that available on-chain. In practical terms, a user on Plume could invest in a diversified pool that earns yield from hundreds of real-world loans made by these credit funds, all tokenized through Goldfinch Prime. This not only enhances Plume’s asset diversity but also underscores Plume’s credibility to partner with top-tier RWA platforms.

• Infrastructure Partners (Custody and Connectivity): Plume has also integrated key infrastructure players. Anchorage Digital, a regulated crypto custodian bank, is a partner – Anchorage’s involvement likely means institutional users can custody their tokenized assets or $PLUME securely in a bank-level custody solution (a must for big money). Paxos is another listed partner, which could relate to stablecoin infrastructure (Paxos issues USDP stablecoin and also provides custody and brokerage services – possibly Paxos could be safeguarding the reserves for pUSD or facilitating asset tokenization pipelines). LayerZero is mentioned as well, indicating Plume uses LayerZero’s interoperability protocol for cross-chain messaging. This would allow assets on Plume to move to other chains (and vice versa) in a trust-minimized way, complementing Plume’s rollup bridge.

• Other DeFi Integrations: Plume’s ecosystem page cites 180+ protocols, including RWA specialists and mainstream DeFi projects. For instance, names like Nucleus Yield (a platform for tokenized yields), and possibly on-chain KYC providers or identity solutions, are part of the mix. By the time of mainnet, Plume had over 200 integrated protocols in its testnet environment – meaning many existing dApps (DEXs, money markets, etc.) have deployed or are ready to deploy on Plume. This ensures that once real-world assets are tokenized, they have immediate utility: e.g., a tokenized solar farm revenue stream could be traded on an order-book exchange, or used as collateral for a loan, or included in an index – because the DeFi “money lego” pieces (DEXs, lending platforms, asset management protocols) are available on the chain from the start.

In summary, Plume’s ecosystem strategy has been aggressive and comprehensive: secure anchor partnerships for assets (e.g. funds from Apollo, BlackRock via Superstate/Ondo, private credit via Goldfinch and Credbull, emerging market assets via Mercado Bitcoin), ensure infrastructure and compliance in place (Anchorage custody, Paxos, identity/AML tooling), and port over the DeFi primitives to allow a flourishing of secondary markets and leverage. The result is that Plume enters 2025 as potentially the most interconnected RWA network in Web3 – a hub where various RWA protocols and real-world institutions plug in. This “network-of-networks” effect could drive significant total value locked and user activity, as indicated by early metrics (Plume’s testnet saw 18+ million unique wallets and 280+ million transactions in a short span, largely due to incentive campaigns and the breadth of projects testing the waters).

Roadmap and Development Milestones​

Plume’s development has moved at a rapid clip, with a phased approach to scaling up real-world assets on-chain:

• Testnet and Community Growth (2023): Plume launched its incentivized testnet (code-named “Miles”) in mid-late 2023. The testnet campaign was extremely successful in attracting users – over 18 million testnet wallet addresses were created, executing 280 million+ transactions. This was likely driven by testnet “missions” and an airdrop campaign (Season 1 of Plume’s airdrop was claimed by early users). The testnet also onboarded over 200 protocols and saw 1 million NFTs (“Goons”) minted, indicating a vibrant trial ecosystem. This massive testnet was a milestone proving out Plume’s tech scalability and generating buzz (and a large community: Plume now counts ~1M Twitter followers and hundreds of thousands in Discord/Telegram).

• Mainnet Launch (Q1 2025): Plume targeted the end of 2024 or early 2025 for mainnet launch. Indeed, by February 2025, partners like Mercado Bitcoin announced their tokenized assets would go live “from the first day of Plume’s mainnet launch.”. This implies Plume mainnet went live or was scheduled to go live around Feb 2025. Mainnet launch is a crucial milestone, bringing the testnet’s lessons to production along with the initial slate of real assets (~$1B+ worth) ready to be tokenized. The launch likely included the release of Plume’s core products: the Plume Chain (mainnet), Arc for asset onboarding, pUSD stablecoin, and Plume Passport wallet, as well as initial DeFi dApps (DEXs, money markets) deployed by partners.

• Phased Asset Onboarding: Plume has indicated a “phased onboarding” strategy for assets to ensure a secure, liquid environment. In early phases, simpler or lower-risk assets (like fully backed stablecoins, tokenized bonds) come first, alongside controlled participation (perhaps whitelisted institutions) to build trust and liquidity. Each phase then unlocks more use cases and asset classes as the ecosystem proves itself. For example, Phase 1 might focus on on-chain Treasuries and private credit fund tokens (relatively stable, yield-generating assets). Subsequent phases could bring more esoteric or higher-yield assets like renewable energy revenue streams, real estate equity tokens, or even exotic assets (the docs amusingly mention “GPUs, uranium, mineral rights, durian farms” as eventual on-chain asset possibilities). Plume’s roadmap thus expands the asset menu over time, parallel with developing the needed market depth and risk management on-chain.

• Scaling and Decentralization: Following mainnet, a key development goal is to decentralize the Plume chain’s operations. Currently, Plume has a sequencer model (likely run by the team or a few nodes). Over time, they plan to introduce a robust validator/sequencer set where $PLUME stakers help secure the network, and possibly even transition to a fully independent consensus. The founder’s note about building an optimized L1 with a new crypto-economic model hints that Plume might implement a novel Proof-of-Stake or hybrid security model to protect high-value RWAs on-chain. Milestones in this category would include open-sourcing more of the stack, running incentivized testnet for node operators, and implementing fraud proofs or zk-proofs (if moving beyond an optimistic rollup).

• Feature Upgrades: Plume’s roadmap also includes adding advanced features demanded by institutions. This could involve:

  • Privacy enhancements: e.g., integrating zero-knowledge proofs for confidential transactions or identity, so that sensitive financial details of RWAs (like borrower info or cashflow data) can be kept private on a public ledger. The mention of FHE and zkTLS suggests research in enabling private yet verifiable asset handling.
  • Compliance and Identity: Plume already has AML screening and compliance modules, but future work will refine on-chain identity (perhaps DID integration in Plume Passport) so that RWA tokens can enforce transfer restrictions or only be held by eligible investors when required.
  • Interoperability: Further integrations with cross-chain protocols (expanding on LayerZero) and bridges so that Plume’s RWA liquidity can seamlessly flow into major ecosystems like Ethereum mainnet, Layer-2s, and even other app-chains. The SkyLink omnichain yield product is likely part of this, enabling users on other chains to tap yields from Plume’s RWA pools.

• Growth Targets: Plume’s leadership has publicly stated goals like “tokenize $3 billion+ in assets by Q4 2024” and eventually far more. While $1.25B was the short-term pipeline at launch, the journey to $3B in tokenized RWAs is an explicit milestone. Longer term, given the trillions in institutional assets potentially tokenizable, Plume will measure success in how much real-world value it brings on-chain. Another metric is TVL and user adoption: by April 2025 the RWA tokenization market crossed $20B in TVL overall, and Plume aspires to capture a significant share of that. If its partnerships mature (e.g., if even 5% of that $1 trillion Goldfinch pipeline comes on-chain), Plume’s TVL could grow exponentially.

• Recent Highlights: By spring 2025, Plume had several noteworthy milestones:

  • The Apollo investment (Apr 2025) – which not only brought funding but also the opportunity to work with Apollo’s portfolio (Apollo manages $600B+ including credit, real estate, and private equity assets that could eventually be tokenized).
  • Grayscale consideration (Apr 2025) – being added to Grayscale’s watchlist is a milestone in recognition, potentially paving the way for a Plume investment product for institutions.
  • RWA Market Leadership: Plume’s team frequently publishes the “Plumeberg” Newsletters noting RWA market trends. In one, they celebrated RWA protocols surpassing $10B TVL and noted Plume’s key role in the narrative. They have positioned Plume as core infrastructure as the sector grows, which suggests a milestone of becoming a reference platform in the RWA conversation.

In essence, Plume’s roadmap is about scaling up and out: scale up in terms of assets (from hundreds of millions to billions tokenized), and scale out in terms of features (privacy, compliance, decentralization) and integrations (connecting to more assets and users globally). Each successful asset onboarding (be it a Brazilian credit deal or an Apollo fund tranche) is a development milestone in proving the model. If Plume can maintain momentum, upcoming milestones might include major financial institutions launching products directly on Plume (e.g., a bank issuing a bond on Plume), or government entities using Plume for public asset auctions – all part of the longer-term vision of Plume as a global on-chain marketplace for real-world finance.

Metrics and Traction​

While still early, Plume Network’s traction can be gauged by a combination of testnet metrics, partnership pipeline, and the overall growth of RWA on-chain:

• Testnet Adoption: Plume’s incentivized testnet (2023) saw extraordinary participation. 18 million+ unique addresses and 280 million transactions were recorded – numbers rivaling or exceeding many mainnets. This was driven by an enthusiastic community drawn by Plume’s airdrop incentives and the allure of RWAs. It demonstrates a strong retail interest in the platform (though many may have been speculators aiming for rewards, it nonetheless seeded a large user base). Additionally, over 200 DeFi protocols deployed contracts on the testnet, signaling broad developer interest. This effectively primed Plume with a large user and developer community even before launch.

• Community Size: Plume quickly built a social following in the millions (e.g., 1M followers on X/Twitter, 450k in Discord, etc.). They brand their community members as “Goons” – over 1 million “Goon” NFTs were minted as a part of testnet achievements. Such gamified growth reflects one of the fastest community buildups in recent Web3 memory, indicating that the narrative of real-world assets resonates with a wide audience in crypto.

• Ecosystem and TVL Pipeline: At mainnet launch, Plume projected having over $1 billion in real-world assets tokenized or available on day one. In a statement, co-founder Chris Yin highlighted proprietary access to high-yield, privately held assets that are “exclusively” coming to Plume. Indeed, specific assets lined up included:

  • $500M from a Credbull private credit fund,
  • $300M in solar energy farms (Plural Energy),
  • $120M in healthcare (Medicaid receivables),
  • plus mineral rights and other esoteric assets. These sum to ~$1B, and Yin stated the aim to reach $3B tokenized by end of 2024. Such figures, if realized, would place Plume among the top chains for RWA TVL. By comparison, the entire RWA sector’s on-chain TVL was about $20B as of April 2025, so $3B on one platform would be a very significant share.

• Current TVL / Usage: Since mainnet launch is recent, concrete TVL figures on Plume aren’t yet publicly reported like on DeFiLlama. However, we know several integrated projects bring their own TVL:

  • Ondo’s products (OUSG, etc.) had $623M in market value around early 2024 – some of that may now reside or be mirrored on Plume.
  • The tokenized assets via Mercado Bitcoin (Brazil) add $40M pipeline.
  • Goldfinch Prime’s pool could attract large deposits (Goldfinch’s legacy pools originated ~$100M+ of loans; Prime could scale higher with institutions).
  • If Nest vaults aggregate multiple yields, that could quickly accumulate nine-figure TVL on Plume as stablecoin holders seek 5-10% yields from RWAs. As a qualitative metric, demand for RWA yields has been high even in bear markets – for instance, tokenized Treasury funds like Ondo’s saw hundreds of millions in a few months. Plume, concentrating many such offerings, could see a rapid uptick in TVL as DeFi users rotate into more “real” yields.

• Transactions and Activity: We might anticipate relatively lower on-chain transaction counts on Plume compared to say a gaming chain, because RWA transactions are higher-value but less frequent (e.g., moving millions in a bond token vs. many micro-transactions). That said, if secondary trading picks up (on an order book exchange or AMM on Plume), we could see steady activity. The presence of 280M test txns suggests Plume can handle high throughput if needed. With Plume’s low fees (designed to be cheaper than Ethereum) and composability, it encourages more complex strategies (like looping collateral, automated yield strategies by smart contracts) which could drive interactions.

• Real-World Impact: Another “metric” is traditional participation. Plume’s partnership with Apollo and others means institutional AuM (Assets under Management) connected to Plume is in the tens of billions (just counting Apollo’s involved funds, BlackRock’s BUIDL fund, etc.). While not all that value is on-chain, even a small allocation from each could quickly swell Plume’s on-chain assets. For example, BlackRock’s BUIDL fund (tokenized money market) hit $1B AUM within a year. Franklin Templeton’s on-chain government money fund reached $368M. If similar funds launch on Plume or existing ones connect, those figures reflect potential scale.

• Security/Compliance Metrics: It’s worth noting Plume touts being fully onchain 24/7, permissionless yet compliant. One measure of success will be zero security incidents or defaults in the initial cohorts of RWA tokens. Metrics like payment yields delivered to users (e.g., X amount of interest paid out via Plume smart contracts from real assets) will build credibility. Plume’s design includes real-time auditing and on-chain verification of asset collateral (some partners provide daily transparency reports, as Ondo does for USDY). Over time, consistent, verified yield payouts and perhaps credit ratings on-chain could become key metrics to watch.

In summary, early indicators show strong interest and a robust pipeline for Plume. The testnet numbers demonstrate crypto community traction, and the partnerships outline a path to significant on-chain TVL and usage. As Plume transitions to steady state, we will track metrics like how many asset types are live, how much yield is distributed, and how many active users (especially institutional) engage on the platform. Given that the entire RWA category is growing fast (over $22.4B TVL as of May 2025, with a 9.3% monthly growth rate), Plume’s metrics should be viewed in context of this expanding pie. There is a real possibility that Plume could emerge as a leading RWA hub capturing a multi-billion-dollar share of the market if it continues executing.

---

Real-World Assets (RWA) in Web3: Overview and Significance​

Real-World Assets (RWAs) refer to tangible or financial assets from the traditional economy that are tokenized on blockchain – in other words, digital tokens that represent ownership or rights to real assets or cash flows. These can include assets like real estate properties, corporate bonds, trade invoices, commodities (gold, oil), stocks, or even intangible assets like carbon credits and intellectual property. RWA tokenization is arguably one of the most impactful trends in crypto, because it serves as a bridge between traditional finance (TradFi) and decentralized finance (DeFi). By bringing real-world assets on-chain, blockchain technology can inject transparency, efficiency, and broader access into historically opaque and illiquid markets.

The significance of RWAs in Web3 has grown dramatically in recent years:

• They unlock new sources of collateral and yield for the crypto ecosystem. Instead of relying on speculative token trading or purely crypto-native yield farming, DeFi users can invest in tokens that derive value from real economic activity (e.g., revenue from a real estate portfolio or interest from loans). This introduces “real yield” and diversification, making DeFi more sustainable.
• For traditional finance, tokenization promises to increase liquidity and accessibility. Assets like commercial real estate or loan portfolios, which typically have limited buyers and cumbersome settlement processes, can be fractionalized and traded 24/7 on global markets. This can reduce financing costs and democratize access to investments that were once restricted to banks or large funds.
• RWAs also leverage blockchain’s strengths: transparency, programmability, and efficiency. Settlement of tokenized securities can be near-instant and peer-to-peer, eliminating layers of intermediaries and reducing settlement times from days to seconds. Smart contracts can automate interest payments or enforce covenants. Additionally, the immutable audit trail of blockchains enhances transparency – investors can see exactly how an asset is performing (especially when coupled with oracle data) and trust that the token supply matches real assets (with on-chain proofs of reserve, etc.).
• Importantly, RWA tokenization is seen as a key driver of the next wave of institutional adoption of blockchain. Unlike the largely speculative DeFi summer of 2020 or the NFT boom, RWAs appeal directly to the finance industry’s core, by making familiar assets more efficient. A recent report by Ripple and BCG projected that the market for tokenized assets could reach **$18.9 trillion** by 2033, underscoring the vast addressable market. Even nearer term, growth is rapid – as of May 2025, RWA projects’ TVL was $22.45B (up ~9.3% in one month) and projected to hit ~$50B by end of 2025. Some estimates foresee **$1–$3 trillion tokenized by 2030**, with upper scenarios as high as $30T if adoption accelerates.

In short, RWA tokenization is transforming capital markets by making traditional assets more liquid, borderless, and programmable. It represents a maturation of the crypto industry – moving beyond purely self-referential assets toward financing the real economy. As one analysis put it, RWAs are “rapidly shaping up to be the bridge between traditional finance and the blockchain world”, turning the long-hyped promise of blockchain disrupting finance into a reality. This is why 2024–2025 has seen RWAs touted as the growth narrative in Web3, attracting serious attention from big asset managers, governments, and Web3 entrepreneurs alike.

Key Protocols and Projects in the RWA Space​

The RWA landscape in Web3 is broad, comprising various projects each focusing on different asset classes or niches. Here we highlight some key protocols and platforms leading the RWA movement, along with their focus areas and recent progress:

Project / Protocol	Focus & Asset Types	Blockchain	Notable Metrics / Highlights
Centrifuge	Decentralized securitization of private credit – tokenizing real-world payment assets like invoices, trade receivables, real estate bridge loans, royalties, etc. via asset pools (Tinlake). Investors earn yield from financing these assets.	Polkadot parachain (Centrifuge Chain) with Ethereum dApp (Tinlake) integration	TVL ≈ $409M in pools; pioneered RWA DeFi with MakerDAO (Centrifuge pools back certain DAI loans). Partners with institutions like New Silver and FortunaFi for asset origination. Launching Centrifuge V3 for easier cross-chain RWA liquidity.
Maple Finance	Institutional lending platform – initially undercollateralized crypto loans (to trading firms), now pivoted to RWA-based lending. Offers pools where accredited lenders provide USDC to borrowers (now often backed by real-world collateral or revenue). Launched a Cash Management Pool for on-chain U.S. Treasury investments and Maple Direct for overcollateralized BTC/ETH loans.	Ethereum (V2 & Maple 2.0), previously Solana (deprecated)	$2.46B in total loans originated to date; shifted to fully collateralized lending after defaults in unsecured lending. Maple’s new Treasury pool allows non-US investors to earn ~5% on T-Bills via USDC. Its native token MPL (soon converting to SYRUP) captures protocol fees; Maple ranks #2 in private credit RWA TVL and is one of few with a liquid token.
Goldfinch	Decentralized private credit – originally provided undercollateralized loans to fintech lenders in emerging markets (Latin America, Africa, etc.) by pooling stablecoin from DeFi investors. Now launched Goldfinch Prime, targeting institutional investors to provide on-chain access to multi-billion-dollar private credit funds (managed by Apollo, Ares, Golub, etc.) in one diversified pool. Essentially brings established private debt funds on-chain for qualified investors.	Ethereum	Funded ~$100M in loans across 30+ borrowers since inception. Goldfinch Prime (2023) is offering exposure to top private credit funds (Apollo, Blackstone, T. Rowe Price, etc.) with thousands of underlying loans. Backed by a16z, Coinbase Ventures, etc. Aims to merge DeFi capital with proven TradFi credit strategies, with yields often 8-10%. GFI token governs the protocol.
Ondo Finance	Tokenized funds and structured products – pivoted from DeFi services to focusing on on-chain investment funds. Issuer of tokens like OUSG (Ondo Short-Term Government Bond Fund token – effectively tokenized shares of a U.S. Treasury fund) and OSTB/OMMF (money market fund tokens). Also offers USDY (tokenized deposit yielding ~5% from T-bills + bank deposits). Ondo also built Flux, a lending protocol to allow borrowing against its fund tokens.	Ethereum (tokens also deployed on Polygon, Solana, etc. for accessibility)	$620M+ in tokenized fund AUM (e.g. OUSG, USDY, etc.). OUSG is one of the largest on-chain Treasury products, at ~$580M AUM providing ~4.4% APY. Ondo’s funds are offered under SEC Reg D/S exemptions via a broker-dealer, ensuring compliance. Ondo’s approach of using regulated SPVs and partnering with BlackRock’s BUIDL fund has set a model for tokenized securities in the US. ONDO token (governance) has a ~$2.8B FDV with 15% in circulation (indicative of high investor expectations).
MakerDAO (RWA Program)	Decentralized stablecoin issuer (DAI) that has increasingly allocated its collateral to RWA investments. Maker’s RWA effort involves vaults that accept real-world collateral (e.g. loans via Huntingdon Valley Bank, or tokens like CFG (Centrifuge) pools, DROP tokens, and investments into short-term bonds through off-chain structures with partners like BlockTower and Monetalis). Maker essentially invests DAI into RWA to earn yield, which shores up DAI’s stability.	Ethereum	As of late 2023, Maker had over $1.6B in RWA exposure, including >$1B in U.S. Treasury and corporate bonds and hundreds of millions in loans to real estate and banks (Maker’s Centrifuge vaults, bank loans, and Société Générale bond vault). This now comprises a significant portion of DAI’s collateral, contributing real yield (~4-5% on those assets) to Maker. Maker’s pivot to RWA (part of “Endgame” plan) has been a major validation for RWA in DeFi. However, Maker does not tokenize these assets for broader use; it holds them in trust via legal entities to back DAI.
TruFi & Credix	(Grouping two similar credit protocols) TruFi – a protocol for uncollateralized lending to crypto and TradFi borrowers, with a portion of its book in real-world loans (e.g. lending to fintechs). Credix – a Solana-based private credit marketplace connecting USDC lenders to Latin American credit deals (often receivables and SME loans, tokenized as bonds). Both enable underwriters to create loan pools that DeFi users can fund, thus bridging to real economy lending.	Ethereum (TruFi), Solana (Credix)	TruFi facilitated ~$500M in loans (crypto + some RWA) since launch, though faced defaults; its focus is shifting to credit fund tokenization. Credix has funded tens of millions in receivables in Brazil/Colombia, and in 2023 partnered with Circle and VISA on a pilot to convert receivables to USDC for faster financing. These are notable but smaller players relative to Maple/Goldfinch. Credix’s model influenced Goldfinch’s design.
Securitize & Provenance (Figure)	These are more CeFi-oriented RWA platforms: Securitize provides tokenization technology for enterprises (it tokenized private equity funds, stocks, and bonds for clients, operating under full compliance; recently partnered with Hamilton Lane to tokenzie parts of its $800M funds). Provenance Blockchain (Figure), built by Figure Technologies, is a fintech platform mainly for loan securitization and trading (they’ve done HELOC loans, mortgage-backed securities, etc. on their private chain).	Private or permissioned chains (Provenance is a Cosmos-based chain; Securitize issues tokens on Ethereum, Polygon, etc.)	Figure’s Provenance has facilitated over $12B in loan originations on-chain (mostly between institutions) and is arguably one of the largest by volume (it is the “Figure” noted as top in private credit sector). Securitize has tokenized multiple funds and even enabled retail to buy tokenized equity in companies like Coinbase pre-IPO. They aren’t “DeFi” platforms but are key bridges for RWAs – often working with regulated entities and focusing on compliance (Securitize is a registered broker-dealer/transfer agent). Their presence underscores that RWA tokenization spans both decentralized and enterprise realms.

(Table sources: Centrifuge TVL, Maple transition and loan volume, Goldfinch Prime description, Ondo stats, Ondo–BlackRock partnership, Maker & market projection, Maple rank.)

Centrifuge: Often cited as the first RWA DeFi protocol (launched 2019), Centrifuge allows asset originators (like financing companies) to pool real-world assets and issue ERC-20 tokens called DROP (senior tranche) and TIN (junior tranche) representing claims on the asset pool. These tokens can be used as collateral in MakerDAO or held for yield. Centrifuge operates its own chain for efficiency but connects to Ethereum for liquidity. It currently leads the pack in on-chain private credit TVL (~$409M), demonstrating product-market fit in areas like invoice financing. A recent development is Centrifuge partnering with Clearpool’s upcoming RWA chain (Ozea) to expand its reach, and working on Centrifuge V3 which will enable assets to be composable across any EVM chain (so Centrifuge pools could be tapped by protocols on chains like Ethereum, Avalanche, or Plume).

Maple Finance: Maple showed the promise and perils of undercollateralized DeFi lending. It provided a platform for delegate managers to run credit pools lending to market makers and crypto firms on an unsecured basis. After high-profile defaults in 2022 (e.g. Orthogonal Trading’s collapse related to FTX) which hit Maple’s liquidity, Maple chose to reinvent itself with a safer model. Now Maple’s focus is twofold: (1) RWA “cash management” – giving stablecoin lenders access to Treasury yields, and (2) overcollateralized crypto lending – requiring borrowers to post liquid collateral (BTC/ETH). The Treasury pool (in partnership with Icebreaker Finance) was launched on Solana in 2023, then on Ethereum, enabling accredited lenders to earn ~5% on USDC by purchasing short-duration U.S. Treasury notes. Maple also introduced Maple Direct pools that lend to institutions against crypto collateral, effectively becoming a facilitator for more traditional secured lending. The Maple 2.0 architecture (launched Q1 2023) improved transparency and control for lenders. Despite setbacks, Maple has facilitated nearly $2.5B in loans cumulatively and remains a key player, now straddling both crypto and RWA lending. Its journey underscores the importance of proper risk management and has validated the pivot to real-world collateral for stability.

Goldfinch: Goldfinch’s innovation was to allow “borrower pools” where real-world lending businesses (like microfinance institutions or fintech lenders) could draw stablecoin liquidity from DeFi without posting collateral, instead relying on the “trust-through-consensus” model (where backers stake junior capital to vouch for the borrower). It enabled loans in places like Kenya, Nigeria, Mexico, etc., delivering yields often above 10%. However, to comply with regulations and attract larger capital, Goldfinch introduced KYC gating and Prime. Now with Goldfinch Prime, the protocol is basically onboarding well-known private credit fund managers and letting non-US accredited users provide capital to them on-chain. For example, rather than lending to a single fintech lender, a Goldfinch Prime user can invest in a pool that aggregates many senior secured loans managed by Ares or Apollo – essentially investing in slices of those funds (which off-chain are massive, e.g. Blackstone’s private credit fund is $50B+). This moves Goldfinch upmarket: it’s less about frontier market fintech loans and more about giving crypto investors an entry to institutional-grade yield (with lower risk). Goldfinch’s GFI token and governance remain, but the user base and pool structures have shifted to a more regulated stance. This reflects a broader trend: RWA protocols increasingly working directly with large TradFi asset managers to scale.

Ondo Finance: Ondo’s transformation is a case study in adapting to demand. When DeFi degen yields dried up in the bear market, the thirst for safe yield led Ondo to tokenize T-bills and money market funds. Ondo set up a subsidiary (Ondo Investments) and registered offerings so that accredited and even retail (in some regions) could buy regulated fund tokens. Ondo’s flagship OUSG token is effectively tokenized shares of a short-term US Treasuries ETF; it grew quickly to over half a billion in circulation, confirming huge demand for on-chain Treasuries. Ondo also created USDY, which takes a step further by mixing T-bills and bank deposits to approximate a high-yield savings account on-chain. At ~4.6% APY and a low $500 entry, USDY aims for mass market within crypto. To complement these, Ondo’s Flux protocol lets holders of OUSG or USDY borrow stablecoins against them (solving liquidity since these tokens might otherwise be lockups). Ondo’s success has made it a top-3 RWA issuer by TVL. It’s a prime example of working within regulatory frameworks (SPVs, broker-dealers) to bring traditional securities on-chain. It also collaborates (e.g., using BlackRock’s fund) rather than competing with incumbents, which is a theme in RWA: partnership over disruption.

MakerDAO: While not a standalone RWA platform, Maker deserves mention because it effectively became one of the largest RWA investors in crypto. Maker realized that diversifying DAI’s collateral beyond volatile crypto could both stabilize DAI and generate revenue (through real-world yields). Starting with small experiments (like a loan to a U.S. bank, and vaults for Centrifuge pool tokens), Maker ramped up in 2022-2023 by allocating hundreds of millions of DAI to buy short-term bonds and invest in money market funds via custody accounts. By mid-2023 Maker had allocated $500M to a BlackRock-managed bond fund and a similar amount to a startup (Monetalis) to invest in Treasuries – these are analogous to Ondo’s approach but done under Maker governance. Maker also onboarded loans like the Societe Generale $30M on-chain bond, and vaults for Harbor Trade’s Trade Finance pool, etc. The revenue from these RWA investments has been substantial – by some reports, Maker’s RWA portfolio generates tens of millions in annualized fees, which has made DAI’s system surplus grow (and MKR token started buybacks using those profits). This RWA strategy is central to Maker’s “Endgame” plan, where eventually Maker might spin out specialized subDAOs to handle RWA. The takeaway is that even a decentralized stablecoin protocol sees RWA as key to sustainability, and Maker’s scale (with DAI ~$5B supply) means it can materially impact real-world markets by deploying liquidity there.

Others: There are numerous other projects in the RWA space, each carving out a niche:

• Tokenized Commodities: Projects like Paxos Gold (PAXG) and Tether Gold (XAUT) have made gold tradable on-chain (combined market cap of ~$1.4B). These tokens give the convenience of crypto with the stability of gold and are fully backed by physical gold in vaults.
• Tokenized Stocks: Firms like Backed Finance and Synthesized (formerly Mirror, etc.) have issued tokens mirroring equity like Apple (bAAPL) or Tesla. Backed’s tokens (e.g., bNVDA for Nvidia) are 100% collateralized by shares held by a custodian and available under EU regulatory sandbox exemptions, enabling 24/7 trading of stocks on DEXs. The total for tokenized stocks is still small (~$0.46B), but growing as interest in around-the-clock trading and fractional ownership picks up.
• Real Estate Platforms: Lofty AI (Algorand-based) allows fractional ownership of rental properties with tokens as low as $50 per fraction. RealT (Ethereum) offers tokens for shares in rental homes in Detroit and elsewhere (paying rental income as USDC dividends). Real estate is a huge market ($300T+ globally), so even a fraction coming on-chain could dwarf other categories; projections see $3–4 Trillion in tokenized real estate by 2030-2035 if adoption accelerates. While current on-chain real estate is small, pilots are underway (e.g., Hong Kong’s government sold tokenized green bonds; Dubai is running a tokenized real estate sandbox).
• Institutional Funds: Beyond Ondo, traditional asset managers are launching tokenized versions of their funds. We saw BlackRock’s BUIDL (a tokenized money market fund that grew from $100M to $1B AUM in one year). WisdomTree issued 13 tokenized ETFs by 2025. Franklin Templeton’s government money fund (BENJI token on Polygon) approached $370M AUM. These efforts indicate that large asset managers view tokenization as a new distribution channel. It also means competition for crypto-native issuers, but overall it validates the space. Many of these tokens target institutional or accredited investors initially (to comply with securities laws), but over time could open to retail as regulations evolve.

Why multiple approaches? The RWA sector has a diverse cast because the space “real-world assets” is extremely broad. Different asset types have different risk, return, and regulatory profiles, necessitating specialized platforms:

• Private credit (Maple, Goldfinch, Centrifuge) focuses on lending and debt instruments, requiring credit assessment and active management.
• Tokenized securities/funds (Ondo, Backed, Franklin) deal with regulatory compliance to represent traditional securities on-chain one-to-one.
• Real estate involves property law, titles, and often local regulations – some platforms work on REIT-like structures or NFTs that confer ownership of an LLC that owns a property.
• Commodities like gold have simpler one-to-one backing models but require trust in custody and audits.

Despite this fragmentation, we see a trend of convergence and collaboration: e.g., Centrifuge partnering with Clearpool, Goldfinch partnering with Plume (and indirectly Apollo), Ondo’s assets being used by Maker and others, etc. Over time, we may get interoperability standards (perhaps via projects like RWA.xyz, which is building a data aggregator for all RWA tokens).

Common Asset Types Being Tokenized​

Almost any asset with an income stream or market value can, in theory, be tokenized. In practice, the RWA tokens we see today largely fall into a few categories:

• Government Debt (Treasuries & Bonds): This has become the largest category of on-chain RWA by value. Tokenized U.S. Treasury bills and bonds are highly popular as they carry low risk and ~4-5% yield – very attractive to crypto holders in a low DeFi yield environment. Multiple projects offer this: Ondo’s OUSG, Matrixdock’s treasury token (MTNT), Backed’s TBILL token, etc. As of May 2025, government securities dominate tokenized assets with ~$6.79B TVL on-chain, making it the single biggest slice of the RWA pie. This includes not just U.S. Treasuries, but also some European government bonds. The appeal is global 24/7 access to a safe asset; e.g., a user in Asia can buy a token at 3 AM that effectively puts money in U.S. T-Bills. We also see central banks and public entities experimenting: e.g., the Monetary Authority of Singapore (MAS) ran Project Guardian to explore tokenized bonds and forex; Hong Kong’s HSBC and CSOP launched a tokenized money market fund. Government bonds are likely the “killer app” of RWA to date.

• Private Credit & Corporate Debt: These include loans to businesses, invoices, supply chain finance, consumer loans, etc., as well as corporate bonds and private credit funds. On-chain private credit (via Centrifuge, Maple, Goldfinch, Credix, etc.) is a fast-growing area and forms over 50% of the RWA market by count of projects (though not by value due to Treasuries being big). Tokenized private credit often offers higher yields (8-15% APY) because of higher risk and less liquidity. Examples: Centrifuge tokens (DROP/TIN) backed by loan portfolios; Goldfinch’s pools of fintech loans; Maple’s pools to market makers; JPMorgan’s private credit blockchain pilot (they did intraday repo on-chain); and startups like Flowcarbon (tokenizing carbon credit-backed loans). Even trade receivables from governments (Medicaid claims) are being tokenized (as Plume highlighted). Additionally, corporate bonds are being tokenized: e.g., European Investment Bank issued digital bonds on Ethereum; companies like Siemens did a €60M on-chain bond. There’s about $23B of tokenized “global bonds” on-chain as of early 2025 – a figure that’s still small relative to the $100+ trillion bond market, but the trajectory is upward.

• Real Estate: Tokenized real estate can mean either debt (e.g., tokenized mortgages, real estate loans) or equity/ownership (fractional ownership of properties). Thus far, more activity has been in tokenized debt (because it fits into DeFi lending models easily). For instance, parts of a real estate bridge loan might be turned into DROP tokens on Centrifuge and used to generate DAI. On the equity side, projects like Lofty have tokenized residential rental properties (issuing tokens that entitle holders to rental income and a share of sale proceeds). We’ve also seen a few REIT-like tokens (RealT’s properties, etc.). Real estate is highly illiquid traditionally, so tokenization’s promise is huge – one could trade fractions of a building on Uniswap, or use a property token as collateral for a loan. That said, legal infrastructure is tricky (you often need each property in an LLC and the token represents LLC shares). Still, given projections of $3-4 Trillion tokenized real estate by 2030-35, many are bullish that this sector will take off as legal frameworks catch up. A notable example: RedSwan tokenized portions of commercial real estate (like student housing complexes) and raised millions via token sales to accredited investors.

• Commodities: Gold is the poster child here. Paxos Gold (PAXG) and Tether Gold (XAUT) together have over $1.4B market cap, offering investors on-chain exposure to physical gold (each token = 1 fine troy ounce stored in vault). These have become popular as a way to hedge in crypto markets. Other commodities tokenized include silver, platinum (e.g., Tether has XAGT, XAUT, etc.), and even oil to some extent (there were experiments with tokens for oil barrels or hash-rate futures). Commodity-backed stablecoins like Ditto’s eggs or soybean tokens have popped up, but gold remains dominant due to its stable demand. We can also include carbon credits and other environmental assets: tokens like MCO2 (Moss Carbon Credit) or Toucan’s nature-based carbon tokens had a wave of interest in 2021 as corporates looked at on-chain carbon offsets. In general, commodities on-chain are straightforward as they’re fully collateralized, but they require trust in custodians and auditors.

• Equities (Stocks): Tokenized stocks allow 24/7 trading and fractional ownership of equities. Platforms like Backed (out of Switzerland) and DX.Exchange / FTX (earlier) issued tokens mirroring popular stocks (Tesla, Apple, Google, etc.). Backed’s tokens are fully collateralized (they hold the actual shares via a custodian and issue ERC-20 tokens representing them). These tokens can be traded on DEXs or held in DeFi wallets, which is novel since conventional stock trading is weekdays only. As of 2025, about $460M of tokenized equities are circulating – still a tiny sliver of the multi-trillion stock market, but it’s growing. Notably, in 2023, MSCI launched indices tracking tokenized assets including tokenized stocks, signaling mainstream monitoring. Another angle is synthetic equities (Mirroring stock price via derivatives without holding the stock, as projects like Synthetix did), but regulatory pushback (they can be seen as swaps) made the fully backed approach more favored now.

• Stablecoins (fiat-backed): It’s worth mentioning that fiat-backed stablecoins like USDC, USDT are essentially tokenized real-world assets (each USDC is backed by $1 in bank accounts or T-bills). In fact, stablecoins are the largest RWA by far – over $200B in stablecoins outstanding (USDT, USDC, BUSD, etc.), mostly backed by cash, Treasury bills, or short-term corporate debt. This has often been cited as the first successful RWA use-case in crypto: tokenized dollars became the lifeblood of crypto trading and DeFi. However, in the RWA context, stablecoins are usually considered separately, because they are currency tokens, not investment products. Still, the existence of stablecoins has paved the way for other RWA tokens (and indeed, projects like Maker and Ondo effectively channel stablecoin capital into real assets).

• Miscellaneous: We are starting to see even more exotic assets:

  • Fine Art and Collectibles: Platforms like Maecenas and Masterworks explored tokenizing high-end artworks (each token representing a share of a painting). NFTs have proven digital ownership, so it’s conceivable real art or luxury collectibles can be fractionalized similarly (though legal custody and insurance are considerations).
  • Revenue-Sharing Tokens: e.g., CityDAO and other DAOs experimented with tokens that give rights to a revenue stream (like a cut of city revenue or business revenue). These blur the line between securities and utility tokens.
  • Intellectual Property and Royalties: There are efforts to tokenize music royalties (so fans can invest in an artist’s future streaming income) or patents. Royalty Exchange and others have looked into this, allowing tokens that pay out when, say, a song is played (using smart contracts to distribute royalties).
  • Infrastructure and Physical assets: Companies have considered tokenizing things like data center capacity, mining hashpower, shipping cargo space, or even infrastructure projects (some energy companies looked at tokenizing ownership in solar farms or oil wells – Plume itself mentioned “uranium, GPUs, durian farms” as possibilities). These remain experimental but show the broad range of what could be brought on-chain.

In summary, virtually any asset that can be legally and economically ring-fenced can be tokenized. The current focus has been on financial assets with clear cash flows or store-of-value properties (debt, commodities, funds) because they fit well with investor demand and existing law (e.g., an SPV can hold bonds and issue tokens relatively straightforwardly). More complex assets (like direct property ownership or IP rights) will likely take longer due to legal intricacies. But the tide is moving in that direction, as the technology proves itself with simpler assets first and then broadens.

It’s also important to note that each asset type’s tokenization must grapple with how to enforce rights off-chain: e.g., if you hold a token for a property, how do you ensure legal claim on that property? Solutions involve legal wrappers (LLCs, trust agreements) that recognize token holders as beneficiaries. Standardization efforts (like the ERC-1400 standard for security tokens or initiatives by the Interwork Alliance for tokenized assets) are underway to make different RWA tokens more interoperable and legally sound.

Recent Trends, Innovations, and Challenges in RWA​

Trends & Innovations:

• Institutional Influx: Perhaps the biggest trend is the entrance of major financial institutions and asset managers into the RWA blockchain space. In the past two years, giants like BlackRock, JPMorgan, Goldman Sachs, Fidelity, Franklin Templeton, WisdomTree, and Apollo have either invested in RWA projects or launched tokenization initiatives. For example, BlackRock’s CEO Larry Fink publicly praised “the tokenization of securities” as the next evolution. BlackRock’s own tokenized money market fund (BUIDL) reaching $1B AUM in one year is a proof-point. WisdomTree creating 13 tokenized index funds by 2025 shows traditional ETFs coming on-chain. Apollo not only invested in Plume but also partnered on tokenized credit (Apollo and Hamilton Lane worked with Figure’s Provenance to tokenize parts of their funds). The involvement of such institutions has a flywheel effect: it legitimizes RWA in the eyes of regulators and investors and accelerates development of compliant platforms. It’s telling that surveys show 67% of institutional investors plan to allocate an average 5.6% of their portfolio to tokenized assets by 2026. High-net-worth individuals similarly are showing ~80% interest in exposure via tokenization. This is a dramatic shift from the 2017-2018 ICO era, as now the movement is institution-led rather than purely grassroots crypto-led.

• Regulated On-Chain Funds: A notable innovation is bringing regulated investment funds directly on-chain. Instead of creating new instruments from scratch, some projects register traditional funds with regulators and then issue tokens that represent shares. Franklin Templeton’s OnChain U.S. Government Money Fund is a SEC-registered mutual fund whose share ownership is tracked on Stellar (and now Polygon) – investors buy a BENJI token which is effectively a share in a regulated fund, subject to all the usual oversight. Similarly, ARB ETF (Europe) launched a fully regulated digital bond fund on a public chain. This trend of tokenized regulated funds is crucial because it marries compliance with blockchain’s efficiency. It basically means the traditional financial products we know (funds, bonds, etc.) can gain new utility by existing as tokens that trade anytime and integrate with smart contracts. Grayscale’s consideration of $PLUME and similar moves by other asset managers to list crypto or RWA tokens in their offerings also indicates convergence of TradFi and DeFi product menus.

• Yield Aggregation and Composability: As more RWA yield opportunities emerge, DeFi protocols are innovating to aggregate and leverage them. Plume’s Nest is one example of aggregating multiple yields into one interface. Another example is Yearn Finance beginning to deploy vaults into RWA products (Yearn considered investing in Treasuries through protocols like Notional or Maple). Index Coop created a yield index token that included RWA yield sources. We are also seeing structured products like tranching on-chain: e.g., protocols that issue a junior-senior split of yield streams (Maple explored tranching pools to offer safer vs. riskier slices). Composability means you could one day do things like use a tokenized bond as collateral in Aave to borrow a stablecoin, then use that stablecoin to farm elsewhere – complex strategies bridging TradFi yield and DeFi yield. This is starting to happen; for instance, Flux Finance (by Ondo) lets you borrow against OUSG and then you could deploy that into a stablecoin farm. Leveraged RWA yield farming may become a theme (though careful risk management is needed).

• Real-Time Transparency & Analytics: Another innovation is the rise of data platforms and standards for RWA. Projects like RWA.xyz aggregate on-chain data to track the market cap, yields, and composition of all tokenized RWAs across networks. This provides much-needed transparency – one can see how big each sector is, track performance, and flag anomalies. Some issuers provide real-time asset tracking: e.g., a token might be updated daily with NAV (net asset value) data from the TradFi custodian, and that can be shown on-chain. The use of oracles is also key – e.g., Chainlink oracles can report interest rates or default events to trigger smart contract functions (like paying out insurance if a debtor defaults). The move towards on-chain credit ratings or reputations is also starting: Goldfinch experimented with off-chain credit scoring for borrowers, Centrifuge has models to estimate pool risk. All of this is to make on-chain RWAs as transparent (or more so) than their off-chain counterparts.

• Integration with CeFi and Traditional Systems: We see more blending of CeFi and DeFi in RWA. For instance, Coinbase introduced “Institutional DeFi” where they funnel client funds into protocols like Maple or Compound Treasury – giving institutions a familiar interface but yield sourced from DeFi. Bank of America and others have discussed using private blockchain networks to trade tokenized collateral with each other (for faster repo markets, etc.). On the retail front, fintech apps may start offering yields that under the hood come from tokenized assets. This is an innovation in distribution: users might not even know they’re interacting with a blockchain, they just see better yields or liquidity. Such integration will broaden the reach of RWA beyond crypto natives.

Challenges:

Despite the excitement, RWA tokenization faces several challenges and hurdles:

• Regulatory Compliance and Legal Structure: Perhaps the number one challenge. By turning assets into digital tokens, you often turn them into securities in the eyes of regulators (if they weren’t already). This means projects must navigate securities laws, investment regulations, money transmitter rules, etc. Most RWA tokens (especially in the US) are offered under Reg D (private placement to accredited investors) or Reg S (offshore) exemptions. This limits participation: e.g., retail US investors usually cannot buy these tokens legally. Additionally, each jurisdiction has its own rules – what’s allowed in Switzerland (like Backed’s stock tokens) might not fly in the US without registration. There’s also the legal enforceability angle: a token is a claim on a real asset; ensuring that claim is recognized by courts is crucial. This requires robust legal structuring (LLCs, trusts, SPVs) behind the scenes. It’s complex and costly to set up these structures, which is why many RWA projects partner with legal firms or get acquired by existing players with licenses (for example, Securitize handles a lot of heavy lifting for others). Compliance also means KYC/AML: unlike DeFi’s permissionless nature, RWA platforms often require investors to undergo KYC and accreditation checks, either at token purchase or continuously via whitelists. This friction can deter some DeFi purists and also means these platforms can’t be fully open to “anyone with a wallet” in many cases.

• Liquidity and Market Adoption: Tokenizing an asset doesn’t automatically make it liquid. Many RWA tokens currently suffer from low liquidity/low trading volumes. For instance, if you buy a tokenized loan, there may be few buyers when you want to sell. Market makers are starting to provide liquidity for certain assets (like stablecoins or Ondo’s fund tokens on DEXes), but order book depth is a work in progress. In times of market stress, there’s concern that RWA tokens could become hard to redeem or trade, especially if underlying assets themselves aren’t liquid (e.g., a real estate token might effectively only be redeemable when the property is sold, which could take months/years). Solutions include creating redemption mechanisms (like Ondo’s funds allow periodic redemptions through the Flux protocol or directly with the issuer), and attracting a diverse investor base to trade these tokens. Over time, as more traditional investors (who are used to holding these assets) come on-chain, liquidity should improve. But currently, fragmentation across different chains and platforms also hinders liquidity – efforts to standardize and maybe aggregate exchanges for RWA tokens (perhaps a specialized RWA exchange or more cross-listings on major CEXes) are needed.

• Trust and Transparency: Ironically for blockchain-based assets, RWAs often require a lot of off-chain trust. Token holders must trust that the issuer actually holds the real asset and won’t misuse funds. They must trust the custodian holding collateral (in case of stablecoins or gold). They also must trust that if something goes wrong, they have legal recourse. There have been past failures (e.g., some earlier “tokenized real estate” projects that fizzled, leaving token holders in limbo). So, building trust is key. This is done through audits, on-chain proof-of-reserve, reputable custodians (e.g., Coinbase Custody, etc.), and insurance. For example, Paxos publishes monthly audited reports of PAXG reserves, and USDC publishes attestations of its reserves. MakerDAO requires overcollateralization and legal covenants when engaging in RWA loans to mitigate risk of default. Nonetheless, a major default or fraud in a RWA project could set the sector back significantly. This is why, currently, many RWA protocols focus on high-credit quality assets (government bonds, senior secured loans) to build a track record before venturing into riskier territory.

• Technological Integration: Some challenges are technical. Integrating real-world data on-chain requires robust oracles. For example, pricing a loan portfolio or updating NAV of a fund requires data feeds from traditional systems. Any lag or manipulation in oracles can lead to incorrect valuations on-chain. Additionally, scalability and transaction costs on mainnets like Ethereum can be an issue – moving potentially thousands of real-world payments (think of a pool of hundreds of loans, each with monthly payments) on-chain can be costly or slow. This is partly why specialized chains or Layer-2 solutions (like Plume, or Polygon for some projects, or even permissioned chains) are being used – to have more control and lower cost for these transactions. Interoperability is another technical hurdle: a lot of RWA action is on Ethereum, but some on Solana, Polygon, Polkadot, etc. Bridging assets between chains securely is still non-trivial (though projects like LayerZero, as used by Plume, are making progress). Ideally, an investor shouldn’t have to chase five different chains to manage a portfolio of RWAs – smoother cross-chain operability or a unified interface will be important.

• Market Education and Perception: Many crypto natives originally were skeptical of RWAs (seeing them as bringing “off-chain risk” into DeFi’s pure ecosystem). Meanwhile, many TradFi people are skeptical of crypto. There is an ongoing need to educate both sides about the benefits and risks. For crypto users, understanding that a token is not just another meme coin but a claim on a legal asset with maybe lock-up periods, etc., is crucial. We’ve seen cases where DeFi users got frustrated that they couldn’t instantly withdraw from a RWA pool because off-chain loan settlements take time – managing expectations is key. Similarly, institutional players often worry about issues like custody of tokens (how to hold them securely), compliance (avoiding wallets that interact with sanctioned addresses, etc.), and volatility (ensuring the token technology is stable). Recent positive developments, like Binance Research showing RWA tokens have lower volatility and even considered “safer than Bitcoin” during certain macro events, help shift perception. But broad acceptance will require time, success stories, and likely regulatory clarity that holding or issuing RWA tokens is legally safe.

• Regulatory Uncertainty: While we covered compliance, a broader uncertainty is regulatory regimes evolving. The U.S. SEC has not yet given explicit guidance on many tokenized securities beyond enforcing existing laws (which is why most issuers use exemptions or avoid U.S. retail). Europe introduced MiCA (Markets in Crypto Assets) regulation which mostly carves out how crypto (including asset-referenced tokens) should be handled, and launched a DLT Pilot Regime to let institutions trade securities on blockchain with some regulatory sandboxes. That’s promising but not permanent law yet. Countries like Singapore, UAE (Abu Dhabi, Dubai), Switzerland are being proactive with sandboxes and digital asset regulations to attract tokenization business. A challenge is if regulations become too onerous or fragmented: e.g., if every jurisdiction demands a slightly different compliance approach, it adds cost and complexity. On the flip side, regulatory acceptance (like Hong Kong’s recent encouragement of tokenization or Japan exploring on-chain securities) could be a boon. In the U.S., a positive development is that certain tokenized funds (like Franklin’s) got SEC approval, showing that it’s possible within existing frameworks. But the looming question: will regulators eventually allow wider retail access to RWA tokens (perhaps through qualified platforms or raising the caps on crowdfunding exemptions)? If not, RWAfi might remain predominantly an institutional play behind walled gardens, which limits the “open finance” dream.

• Scaling Trustlessly: Another challenge is how to scale RWA platforms without introducing central points of failure. Many current implementations rely on a degree of centralization (an issuer that can pause token transfers to enforce KYC, a central party that handles asset custody, etc.). While this is acceptable to institutions, it’s philosophically at odds with DeFi’s decentralization. Over time, projects will need to find the right balance: e.g., using decentralized identity solutions for KYC (so it’s not one party controlling the whitelist but a network of verifiers), or using multi-sig/community governance to control issuance and custody operations. We’re seeing early moves like Maker’s Centrifuge vaults where MakerDAO governance approves and oversees RWA vaults, or Maple decentralizing pool delegate roles. But full “DeFi” RWA (where even legal enforcement is trustless) is a hard problem. Eventually, maybe smart contracts and real-world legal systems will interface directly (for example, a loan token smart contract that can automatically trigger legal action via a connected legal API if default occurs – this is futuristic but conceivable).

In summary, the RWA space is rapidly innovating to tackle these challenges. It’s a multi-disciplinary effort: requiring savvy in law, finance, and blockchain tech. Each success (like a fully repaid tokenized loan pool, or a smoothly redeemed tokenized bond) builds confidence. Each challenge (like a regulatory action or an asset default) provides lessons to strengthen the systems. The trajectory suggests that many of these hurdles will be overcome: the momentum of institutional involvement and the clear benefits (efficiency, liquidity) mean tokenization is likely here to stay. As one RWA-focused newsletter put it, “tokenized real-world assets are emerging as the new institutional standard… the infrastructure is finally catching up to the vision of on-chain capital markets.”

Regulatory Landscape and Compliance Considerations​

The regulatory landscape for RWAs in crypto is complex and still evolving, as it involves the intersection of traditional securities/commodities laws with novel blockchain technology. Key points and considerations include:

• Securities Laws: In most jurisdictions, if an RWA token represents an investment in an asset with an expectation of profit (which is often the case), it is deemed a security. For example, in the U.S., tokens representing fractions of income-generating real estate or loan portfolios squarely fall under the definition of investment contracts (Howey Test) or notes, and thus must be registered or offered under an exemption. This is why nearly all RWA offerings to date in the U.S. use private offering exemptions (Reg D 506(c) for accredited investors, Reg S for offshore, Reg A+ for limited public raises, etc.). Compliance with these means restricting token sales to verified investors, implementing transfer restrictions (tokens can only move between whitelisted addresses), and providing necessary disclosures. For instance, Ondo’s OUSG and Maple’s Treasury pool required investors to clear KYC/AML and accreditation checks, and tokens are not freely transferable to unapproved wallets. This creates a semi-permissioned environment, quite different from open DeFi. Europe under MiFID II/MiCA similarly treats tokenized stocks or bonds as digital representations of traditional financial instruments, requiring prospectuses or using the DLT Pilot regime for trading venues. Bottom line: RWA projects must integrate legal compliance from day one – many have in-house counsel or work with legal-tech firms like Securitize, because any misstep (like selling a security token to the public without exemption) could invite enforcement.

• Consumer Protection and Licensing: Some RWA platforms may need additional licenses. For example, if a platform holds customer fiat to convert into tokens, it might need a money transmitter license or equivalent. If it provides advice or brokerage (matching borrowers and lenders), it might need broker-dealer or ATS (Alternative Trading System) licensing (this is why some partner with broker-dealers – Securitize, INX, Oasis Pro etc., which have ATS licenses to run token marketplaces). Custody of assets (like real estate deeds or cash reserves) might require trust or custody licenses. Anchorage being a partner to Plume is significant because Anchorage is a qualified custodian – institutions feel more at ease if a licensed bank is holding the underlying asset or even the private keys of tokens. In Asia and the Middle East, regulators have been granting specific licenses for tokenization platforms (e.g., the Abu Dhabi Global Market’s FSRA issues permissions for crypto assets including RWA tokens, MAS in Singapore gives project-specific approvals under its sandbox).

• Regulatory Sandboxes and Government Initiatives: A positive trend is regulators launching sandboxes or pilot programs for tokenization. The EU’s DLT Pilot Regime (2023) allows approved market infrastructures to test trading tokenized securities up to certain sizes without full compliance with every rule – this has led to several European exchanges piloting blockchain bond trading. Dubai announced a tokenization sandbox to boost its digital finance hub. Hong Kong in 2023-24 made tokenization a pillar of its Web3 strategy, with Hong Kong’s SFC exploring tokenized green bonds and art. The UK in 2024 consulted on recognizing digital securities under English law (they already recognize crypto as property). Japan updated its laws to allow security tokens (they call them “electronically recorded transferable rights”) and several tokenized securities have been issued there under that framework. These official programs indicate a willingness by regulators to modernize laws to accommodate tokenization – which could eventually simplify compliance (e.g., creating special categories for tokenized bonds that streamline approval).

• Travel Rule / AML: Crypto’s global nature triggers AML laws. FATF’s “travel rule” requires that when crypto (including tokens) above a certain threshold is transferred between VASPs (exchanges, custodians), identifying info travels with it. If RWA tokens are mainly transacted on KYC’ed platforms, this is manageable, but if they enter the wider crypto ecosystem, compliance gets tricky. Most RWA platforms currently keep a tight grip: transfers are often restricted to whitelisted addresses whose owners have done KYC. This mitigates AML concerns (as every holder is known). Still, regulators will expect robust AML programs – e.g., screening wallet addresses against sanctions (OFAC lists, etc.). There was a case of a tokenized bond platform in the UK that had to unwind some trades because a token holder became a sanctioned entity – such scenarios will test protocols’ ability to comply. Many platforms build in pause or freeze functions to comply with law enforcement requests (this is controversial in DeFi, but for RWA it’s often non-negotiable to have the ability to lock tokens tied to wrongdoing).

• Taxation and Reporting: Another compliance consideration: how are these tokens taxed? If you earn yield from a tokenized loan, is it interest income? If you trade a tokenized stock, do wash sale rules apply? Tax authorities have yet to issue comprehensive guidance. In the interim, platforms often provide tax reports to investors (e.g., a Form 1099 in the US for interest or dividends earned via tokens). The transparency of blockchain can help here, as every payment can be recorded and categorized. But cross-border taxation (if someone in Europe holds a token paying US-source interest) can be complex – requiring things like digital W-8BEN forms, etc. This is more of an operational challenge than a roadblock, but it adds friction that automated compliance tech will need to solve.

• Enforcement and Precedents: We’ve not yet seen many high-profile enforcement actions specifically for RWA tokens – likely because most are trying to comply. However, we have seen enforcement in adjacent areas: e.g., the SEC’s actions against crypto lending products (BlockFi, etc.) underscore that offering yields without registering can be a violation. If an RWA platform slipped up and, say, allowed retail to buy security tokens freely, it could face similar action. There’s also the question of secondary trading venues: If a decentralized exchange allows trading of a security token between non-accredited investors, is that unlawful? Likely yes in the US. This is why a lot of RWA tokens are not listed on Uniswap or are wrapped in a way that restricts addresses. It’s a fine line to walk between DeFi liquidity and compliance – many are erring on the side of compliance, even if it reduces liquidity.

• Jurisdiction and Conflict of Laws: RWAs by nature connect to specific jurisdictions (e.g., a tokenized real estate in Germany falls under German property law). If tokens trade globally, there can be conflicts of law. Smart contracts might need to encode which law governs. Some platforms choose friendly jurisdictions for incorporation (e.g., the issuer entity in the Cayman Islands and the assets in the U.S., etc.). It’s complex but solvable with careful legal structuring.

• Investor Protection and Insurance: Regulators will also care about investor protection: ensuring that token holders have clear rights. For example, if a token is supposed to be redeemable for a share of asset proceeds, the mechanism for that must be legally enforceable. Some tokens represent debt securities that can default – what disclosures were given about that risk? Platforms often publish offering memorandums or prospectuses (Ondo did for its tokens). Over time, regulators might require standardized risk disclosures for RWA tokens, much like mutual funds provide. Also, insurance might be mandated or at least expected – for instance, insuring a building in a real estate token, or having crime insurance for a custodian holding collateral.

• Decentralization vs Regulation: There’s an inherent tension: the more decentralized and permissionless you make an RWA platform, the more it rubs against current regulations which assume identifiable intermediaries. One evolving strategy is to use Decentralized Identities (DID) and verifiable credentials to square this circle. E.g., a wallet could hold a credential that proves the owner is accredited without revealing their identity on-chain, and smart contracts could check for that credential before allowing transfer – making compliance automated and preserving some privacy. Projects like Xref (on XDC network) and Astra Protocol are exploring this. If successful, regulators might accept these novel approaches, which could allow permissionless trading among vetted participants. But that’s still in nascent stages.

In essence, regulation is the make-or-break factor for RWA adoption. The current landscape shows regulators are interested and cautiously supportive, but also vigilant. The RWA projects that thrive will be those that proactively embrace compliance yet innovate to make it as seamless as possible. Jurisdictions that provide clear, accommodative rules will attract more of this business (we’ve seen significant tokenization activity gravitate to places like Switzerland, Singapore, and the UAE due to clarity there). Meanwhile, the industry is engaging with regulators – for instance, by forming trade groups or responding to consultations – to help shape sensible policies. A likely outcome is that regulated DeFi will emerge as a category: platforms like those under Plume’s umbrella could become Alternative Trading Systems (ATS) or registered digital asset securities exchanges for tokenized assets, operating under licenses but with blockchain infrastructure. This hybrid approach may satisfy regulators’ objectives while still delivering the efficiency gains of crypto rails.

Investment and Market Size Data​

The market for tokenized real-world assets has grown impressively and is projected to explode in the coming years, reaching into the trillions of dollars if forecasts hold true. Here we’ll summarize some key data points on market size, growth, and investment trends:

• Current On-Chain RWA Market Size: As of mid-2025, the total on-chain Real-World Asset market (excluding traditional stablecoins) is in the tens of billions. Different sources peg slightly different totals depending on inclusion criteria, but a May 2025 analysis put it at $22.45 billion in Total Value Locked. This figure was up ~9.3% from the previous month, showcasing rapid growth. The composition of that ~$22B (as previously discussed) includes around $6.8B in government bonds, $1.5B in commodity tokens, $0.46B in equities, $0.23B in other bonds, and a few billion in private credit and funds. For perspective, this is still small relative to the broader crypto market (which is ~$1.2T in market cap as of 2025, largely driven by BTC and ETH), but it’s the fastest-growing segment of crypto. It’s also worth noting stablecoins (~$226B) if counted would dwarf these numbers, but usually they’re kept separate.

• Growth Trajectory: The RWA market has shown a 32% annual growth rate in 2024. If we extrapolate or consider accelerating adoption, some estimate $50B by end of 2025 as plausible. Beyond that, industry projections become very large:

  • BCG and others (2030+): The often-cited BCG/Ripple report projected $16 trillion by 2030 (and ~$19T by 2033) in tokenized assets. This includes broad tokenization of financial markets (not just DeFi-centric usage). This figure would represent about 10% of all assets tokenized, which is aggressive but not unthinkable given tokenization of cash (stablecoins) is already mainstream.
  • Citi GPS Report (2022) talked about $4–5 trillion tokenized by 2030 as a base case, with higher scenarios if institutional adoption is faster.
  • The LinkedIn analysis we saw noted projections ranging from $1.3 trillion to $30 trillion by 2030 – indicating a lot of uncertainty but consensus that trillions are on the table.
  • Even the conservative end (say $1-2T by 2030) would mean a >50x increase from today’s ~$20B level, which gives a sense of the strong growth expectations.

• Investment into RWA Projects: Venture capital and investment is flowing into RWA startups:

  • Plume’s own funding ($20M Series A, etc.) is one example of VC conviction.
  • Goldfinch raised ~$25M (led by a16z in 2021). Centrifuge raised ~$4M in 2021 and more via token sales; it’s also backed by Coinbase and others.
  • Maple raised $10M Series A in 2021, then additional in 2022.
  • Ondo raised $20M in 2022 (from Founders Fund and Pantera) and more recently did a token sale.
  • There’s also new dedicated funds: e.g., a16z’s crypto fund and others earmarked portions for RWA; Franklin Templeton in 2022 joined a $20M round for a tokenization platform; Matrixport launched a $100M fund for tokenized Treasuries.
  • Traditional finance is investing: Nasdaq Ventures invested in a tokenization startup (XYO Network), London Stock Exchange Group acquired TORA (with tokenization capabilities), etc.
  • We see mergers too: Securitize acquired Distributed Technology Markets to get a broker-dealer; INX (token exchange) raising money to expand offerings.

  Overall, tens of millions have been invested into the leading RWA protocols, and larger financial institutions are acquiring stakes or forming joint ventures in this arena. Apollo’s direct investment in Plume and Hamilton Lane partnering with Securitize to tokenize funds (with Hamilton Lane’s funds being multi-billion themselves) show that this is not just VC bets but real money engagement.

• Notable On-Chain Assets and Performance: Some data on specific tokens can illustrate traction:

  • Ondo’s OUSG: launched early 2023, by early 2025 it had >$580M outstanding, delivering ~4-5% yield. It rarely deviates in price because it’s fully collateralized and redeemable.
  • Franklin’s BENJI: by mid-2023 reached $270M, and by 2024 ~$368M. It’s one of the first instances of a major US mutual fund being reflected on-chain.
  • MakerDAO’s RWA earnings: Maker, through its ~$1.6B RWA investments, was earning on the order of $80M+ annualized in yield by late 2023 (mostly from bonds). This turned Maker’s finances around after crypto yields dried up.
  • Maple’s Treasury pool: in its pilot, raised ~$22M for T-bill investments from <10 participants (institutions). Maple’s total lending after restructuring is smaller now (~$50-100M active loans), but it’s starting to tick up as trust returns.
  • Goldfinch: funded ~$120M loans and repaid ~$90M with ~<$1M in defaults (they had one notable default from a lender in Kenya but recovered partially). GFI token once peaked at a $600M market cap in late 2021, now much lower (~$50M), indicating market re-rating of risk but still interest.
  • Centrifuge: about 15 active pools. Some key ones (like ConsolFreight’s invoice pool, New Silver’s real estate rehab loan pool) each in the $5-20M range. Centrifuge’s token (CFG) has a market cap around $200M in 2025.
  • Overall RWA Returns: Many RWA tokens offer yields in the 4-10% range. For example, Aave’s yield on stablecoins might be ~2%, whereas putting USDC into Goldfinch’s senior pool yields ~8%. This spread draws DeFi capital gradually into RWA. During crypto market downturns, RWA yields looked especially attractive as they were stable, leading analysts to call RWAs a “safe haven” or “hedge” in Web3.

• Geographical/Market Segments: A breakdown by region: A lot of tokenized Treasuries are US-based assets offered by US or global firms (Ondo, Franklin, Backed). Europe’s contributions are in tokenized ETFs and bonds (several German and Swiss startups, and big banks like Santander and SocGen doing on-chain bond issues). Asia: Singapore’s Marketnode platform is tokenizing bonds; Japan’s SMBC tokenized some credit products. The Middle East: Dubai’s DFSA approved a tokenized fund. Latin America: a number of experiments, e.g., Brazil’s central bank is tokenizing a portion of bank deposits (as part of their CBDC project, they consider tokenizing assets). Africa: projects like Kotani Pay looked at tokenized micro-asset financing. These indicate tokenization is a global trend, but the US remains the biggest source of underlying assets (due to Treasuries and large credit funds) while Europe is leading on regulatory clarity for trading.

• Market Sentiment: The narrative around RWAs has shifted very positively in 2024-2025. Crypto media, which used to focus mostly on pure DeFi, now regularly reports on RWA milestones (e.g., “RWA market surpasses $20B despite crypto downturn”). Ratings agencies like Moody’s are studying on-chain assets; major consulting firms (BCG, Deloitte) publish tokenization whitepapers. The sentiment is that RWAfi could drive the next bull phase of crypto by bringing in trillions of value. Even Grayscale considering a Plume product suggests investor appetite for RWA exposure packaged in crypto vehicles. There’s also recognition that RWA is partly counter-cyclical to crypto – when crypto yields are low, people seek RWAs; when crypto booms, RWA provides stable diversification. This makes many investors view RWA tokens as a way to hedge crypto volatility (e.g., Binance research found RWA tokens remained stable and even considered “safer than Bitcoin” during certain macro volatility).

To conclude this section with hard numbers: $20-22B on-chain now, heading to $50B+ in a year or two, and potentially $1T+ within this decade. Investment is pouring in, with dozens of projects collectively backed by well over $200M in venture funding. Traditional finance is actively experimenting, with over $2-3B in real assets already issued on public or permissioned chains by big institutions (including multiple $100M+ bond issues). If even 1% of the global bond market (~$120T) and 1% of global real estate (~$300T) gets tokenized by 2030, that’d be several trillion dollars – which aligns with those bullish projections. There are of course uncertainties (regulation, interest rate environments, etc. can affect adoption), but the data so far supports the idea that tokenization is accelerating. As Plume’s team noted, “the RWA sector is now leading Web3 into its next phase” – a phase where blockchain moves from speculative assets to the backbone of real financial infrastructure. The deep research and alignment of heavyweights behind RWAs underscore that this is not a fleeting trend but a structural evolution of both crypto and traditional finance.

---

Sources:

• Plume Network Documentation and Blog
• News and Press: CoinDesk, The Block, Fortune (via LinkedIn)
• RWA Market Analysis: RWA.xyz, LinkedIn RWA Report
• Odaily/ChainCatcher Analysis
• Goldfinch and Prime info, Ondo info, Centrifuge info, Maple info, Apollo quote, Binance research mention, etc.

One of the core promises of blockchain technology like Ethereum is a degree of anonymity. Participants, known as validators, are supposed to operate behind a veil of cryptographic pseudonyms, protecting their real-world identity and, by extension, their security.

However, a recent research paper titled "Deanonymizing Ethereum Validators: The P2P Network Has a Privacy Issue" from researchers at ETH Zurich and other institutions reveals a critical flaw in this assumption. They demonstrate a simple, low-cost method to link a validator's public identifier directly to the IP address of the machine it's running on.

In short, Ethereum validators are not nearly as anonymous as many believe. The findings were significant enough to earn the researchers a bug bounty from the Ethereum Foundation, acknowledging the severity of the privacy leak.

How the Vulnerability Works: A Flaw in the Gossip​

To understand the vulnerability, we first need a basic picture of how Ethereum validators communicate. The network consists of over a million validators who constantly "vote" on the state of the chain. These votes are called attestations, and they are broadcast across a peer-to-peer ($P2P$) network to all other nodes.

With so many validators, having everyone broadcast every vote to everyone else would instantly overwhelm the network. To solve this, Ethereum’s designers implemented a clever scaling solution: the network is divided into 64 distinct communication channels, known as subnets.

• By default, each node (the computer running the validator software) subscribes to only two of these 64 subnets. Its primary job is to diligently relay all messages it sees on those two channels.
• When a validator needs to cast a vote, its attestation is randomly assigned to one of the 64 subnets for broadcast.

This is where the vulnerability lies. Imagine a node whose job is to manage traffic for channels 12 and 13. All day, it faithfully forwards messages from just those two channels. But then, it suddenly sends you a message that belongs to channel 45.

This is a powerful clue. Why would a node handle a message from a channel it's not responsible for? The most logical conclusion is that the node itself generated that message. This implies that the validator who created the attestation for channel 45 is running on that very machine.

The researchers exploited this exact principle. By setting up their own listening nodes, they monitored the subnets from which their peers sent attestations. When a peer sent a message from a subnet it wasn't officially subscribed to, they could infer with high confidence that the peer hosted the originating validator.

The method proved shockingly effective. Using just four nodes over three days, the team successfully located the IP addresses of over 161,000 validators, representing more than 15% of the entire Ethereum network.

Why This Matters: The Risks of Deanonymization​

Exposing a validator's IP address is not a trivial matter. It opens the door for targeted attacks that threaten individual operators and the health of the Ethereum network as a whole.

1. Targeted Attacks and Reward Theft Ethereum announces which validator is scheduled to propose the next block a few minutes in advance. An attacker who knows this validator's IP address can launch a Denial-of-Service (DDoS) attack, flooding it with traffic and knocking it offline. If the validator misses its four-second window to propose the block, the opportunity passes to the next validator in line. If the attacker is that next validator, they can then claim the block rewards and valuable transaction fees (MEV) that should have gone to the victim.

2. Threats to Network Liveness and Safety A well-resourced attacker could perform these "sniping" attacks repeatedly, causing the entire blockchain to slow down or halt (a liveness attack). In a more severe scenario, an attacker could use this information to launch sophisticated network-partitioning attacks, potentially causing different parts of the network to disagree on the chain's history, thus compromising its integrity (a safety attack).

3. Revealing a Centralized Reality The research also shed light on some uncomfortable truths about the network's decentralization:

• Extreme Concentration: The team found peers hosting a staggering number of validators, including one IP address running over 19,000. The failure of a single machine could have an outsized impact on the network.
• Dependence on Cloud Services: Roughly 90% of located validators run on cloud providers like AWS and Hetzner, not on the computers of solo home stakers. This represents a significant point of centralization.
• Hidden Dependencies: Many large staking pools claim their operators are independent. However, the research found instances where validators from different, competing pools were running on the same physical machine, creating hidden systemic risks.

Mitigations: How Can Validators Protect Themselves?​

Fortunately, there are ways to defend against this deanonymization technique. The researchers proposed several mitigations:

• Create More Noise: A validator can choose to subscribe to more than two subnets—or even all 64. This makes it much harder for an observer to distinguish between relayed messages and self-generated ones.
• Use Multiple Nodes: An operator can separate validator duties across different machines with different IPs. For example, one node could handle attestations while a separate, private node is used only for proposing high-value blocks.
• Private Peering: Validators can establish trusted, private connections with other nodes to relay their messages, obscuring their true origin within a small, trusted group.
• Anonymous Broadcasting Protocols: More advanced solutions like Dandelion, which obfuscates a message's origin by passing it along a random "stem" before broadcasting it widely, could be implemented.

Conclusion​

This research powerfully illustrates the inherent trade-off between performance and privacy in distributed systems. In its effort to scale, Ethereum's $P2P$ network adopted a design that compromised the anonymity of its most critical participants.

By bringing this vulnerability to light, the researchers have given the Ethereum community the knowledge and tools needed to address it. Their work is a crucial step toward building a more robust, secure, and truly decentralized network for the future.

We're thrilled to announce a significant expansion to BlockEden.xyz's API Marketplace with the addition of three cutting-edge blockchain networks: Base, Berachain, and Blast. These new offerings reflect our commitment to providing developers with comprehensive access to the most innovative blockchain infrastructures, enabling seamless development across multiple ecosystems.

Base: Coinbase's Ethereum L2 Solution​

Base is an Ethereum Layer 2 (L2) solution developed by Coinbase, designed to bring millions of users into the onchain ecosystem. As a secure, low-cost, developer-friendly Ethereum L2, Base combines the robust security of Ethereum with the scalability benefits of optimistic rollups.

Our new Base API endpoint lets developers:

• Access Base's infrastructure without managing their own nodes
• Leverage high-performance RPC connections with 99.9% uptime
• Build applications that benefit from Ethereum's security with lower fees
• Seamlessly interact with Base's expanding ecosystem of applications

Base is particularly appealing for developers looking to create consumer-facing applications that require Ethereum's security but at a fraction of the cost.

Berachain: Performance Meets EVM Compatibility​

Berachain brings a unique approach to blockchain infrastructure, combining high performance with complete Ethereum Virtual Machine (EVM) compatibility. As an emerging network gaining significant attention from developers, Berachain offers:

• EVM compatibility with enhanced throughput
• Advanced smart contract capabilities
• A growing ecosystem of innovative DeFi applications
• Unique consensus mechanisms optimized for transaction speed

Our Berachain API provides developers with immediate access to this promising network, allowing teams to build and test applications without the complexity of managing infrastructure.

Blast: The First Native Yield L2​

Blast stands out as the first Ethereum L2 with native yield for ETH and stablecoins. This innovative approach to yield generation makes Blast particularly interesting for DeFi developers and applications focused on capital efficiency.

Key benefits of our Blast API include:

• Direct access to Blast's native yield mechanisms
• Support for building yield-optimized applications
• Simplified integration with Blast's unique features
• High-performance RPC connections for seamless interactions

Blast's focus on native yield represents an exciting direction for Ethereum L2 solutions, potentially setting new standards for capital efficiency in the ecosystem.

Seamless Integration Process​

Getting started with these new networks is straightforward with BlockEden.xyz:

1. Visit our API Marketplace and select your desired network
2. Create an API key through your BlockEden.xyz dashboard
3. Integrate the endpoint into your development environment using our comprehensive documentation
4. Start building with confidence, backed by our 99.9% uptime guarantee

Why Choose BlockEden.xyz for These Networks?​

BlockEden.xyz continues to distinguish itself through several core offerings:

• High Availability: Our infrastructure maintains 99.9% uptime across all supported networks
• Developer-First Approach: Comprehensive documentation and support for seamless integration
• Unified Experience: Access multiple blockchain networks through a single, consistent interface
• Competitive Pricing: Our compute unit credit (CUC) system ensures cost-effective scaling

Looking Forward​

The addition of Base, Berachain, and Blast to our API Marketplace represents our ongoing commitment to supporting the diverse and evolving blockchain ecosystem. As these networks continue to mature and attract developers, BlockEden.xyz will be there to provide the reliable infrastructure needed to build the next generation of decentralized applications.

We invite developers to explore these new offerings and provide feedback as we continue to enhance our services. Your input is invaluable in helping us refine and expand our API marketplace to meet your evolving needs.

Ready to start building on Base, Berachain, or Blast? Visit BlockEden.xyz API Marketplace today and create your access key to begin your journey!

For the latest updates and announcements, connect with us on Twitter or join our community on Discord.

In the rapidly evolving landscape of blockchain technology, a familiar name has stepped into the arena with a bold vision. Sony, the entertainment and technology giant, has launched Soneium—an Ethereum Layer-2 blockchain designed to bridge the gap between cutting-edge Web3 innovations and mainstream internet services. But what exactly is Soneium, and why should you care? Let's dive in.

What is Soneium?​

Soneium is a Layer-2 blockchain built on top of Ethereum, developed by Sony Block Solutions Labs—a joint venture between Sony Group and Startale Labs. Launched in January 2025 after a successful testnet phase, Soneium aims to "realize the open internet that transcends boundaries" by making blockchain technology accessible, scalable, and practical for everyday use.

Think of it as Sony's attempt to make blockchain as user-friendly as its PlayStations and Walkmans once made gaming and music.

The Tech Behind Soneium​

For the tech-curious among us, Soneium is built on Optimism's OP Stack, which means it uses the same optimistic rollup framework as other popular Layer-2 solutions. In plain English? It processes transactions off-chain and only periodically posts compressed data back to Ethereum, making transactions faster and cheaper while maintaining security.

Soneium is fully compatible with the Ethereum Virtual Machine (EVM), so developers familiar with Ethereum can easily deploy their applications on the platform. It also joins Optimism's "Superchain" ecosystem, allowing it to communicate easily with other Layer-2 networks like Coinbase's Base.

What Makes Soneium Special?​

While there are already several Layer-2 solutions on the market, Soneium stands out for its focus on entertainment, creative content, and fan engagement—areas where Sony has decades of experience and vast resources.

Imagine buying a movie ticket and receiving an exclusive digital collectible that grants access to bonus content. Or attending a virtual concert where your NFT ticket becomes a memento with special perks. These are the kinds of experiences Sony envisions building on Soneium.

The platform is designed to support:

• Gaming experiences with faster transactions for in-game assets
• NFT marketplaces for digital collectibles
• Fan engagement apps where communities can interact with creators
• Financial tools for creators and fans
• Enterprise blockchain solutions

Sony's Partnerships Power Soneium​

Sony isn't going it alone. The company has forged strategic partnerships to bolster Soneium's development and adoption:

• Startale Labs, a Singapore-based blockchain startup led by Sota Watanabe (co-founder of Astar Network), is Sony's key technical partner
• Optimism Foundation provides the underlying technology
• Circle ensures that USD Coin (USDC) serves as a primary currency on the network
• Samsung has made a strategic investment through its venture arm
• Alchemy, Chainlink, Pyth Network, and The Graph provide essential infrastructure services

Sony is also leveraging its internal divisions—including Sony Pictures, Sony Music Entertainment, and Sony Music Publishing—to pilot Web3 fan engagement projects on Soneium. For example, the platform has already hosted NFT campaigns for the "Ghost in the Shell" franchise and various music artists under Sony's label.

Early Signs of Success​

Despite being just a few months old, Soneium has shown promising traction:

• Its testnet phase saw over 15 million active wallets and processed over 47 million transactions
• Within the first month of mainnet launch, Soneium attracted over 248,000 on-chain accounts and about 1.8 million addresses interacting with the network
• The platform has successfully launched several NFT drops, including a collaboration with Web3 music label Coop Records

To fuel growth, Sony and Astar Network launched a 100-day incentive campaign with a 100 million token reward pool, encouraging users to try out apps, supply liquidity, and be active on the platform.

Security and Scalability: A Balancing Act​

Security is paramount for Sony, especially as it carries its trusted brand into the blockchain space. Soneium inherits Ethereum's security while adding its own protective measures.

Interestingly, Sony has taken a somewhat controversial approach by blacklisting certain smart contracts and tokens deemed to infringe on intellectual property. While this has raised questions about decentralization, Sony argues that some curation is necessary to protect creators and build trust with mainstream users.

On the scalability front, Soneium's very purpose is to enhance Ethereum's throughput. By processing transactions off-chain, it can handle a much higher volume of transactions at much lower costs—crucial for mass adoption of applications like games or large NFT drops.

The Road Ahead​

Sony has outlined a multi-phase roadmap for Soneium:

1. First year: Onboarding Web3 enthusiasts and early adopters
2. Within two years: Integrating Sony products like Sony Bank, Sony Music, and Sony Pictures
3. Within three years: Expanding to enterprises and general applications beyond Sony's ecosystem

The company is gradually rolling out its NFT-driven Fan Marketing Platform, which will allow brands and artists to easily issue NFTs to fans, offering perks like exclusive content and event access.

While Soneium currently relies on ETH for gas fees and uses ASTR (Astar Network's token) for incentives, there's speculation about a potential Soneium native token in the future.

How Soneium Compares to Other Layer-2 Networks​

In the crowded Layer-2 market, Soneium faces competition from established players like Arbitrum, Optimism, and Polygon. However, Sony is carving a unique position by leveraging its entertainment empire and focusing on creative use cases.

Unlike purely community-driven Layer-2 networks, Soneium benefits from Sony's brand trust, access to content IP, and a potentially huge user base from existing Sony services.

The trade-off is less decentralization (at least initially) compared to networks like Optimism and Arbitrum, which have issued tokens and implemented community governance.

The Big Picture​

Sony's Soneium represents a significant step toward blockchain mass adoption. By focusing on content and fan engagement—areas where Sony excels—the company is positioning Soneium as a bridge between Web3 enthusiasts and everyday consumers.

If Sony can successfully convert even a fraction of its millions of customers into Web3 participants, Soneium could become one of the first truly mainstream blockchain platforms.

The experiment has just begun, but the potential is enormous. As the lines between entertainment, technology, and blockchain continue to blur, Soneium may well be at the forefront of this convergence, bringing blockchain technology to the masses one gaming avatar or music NFT at a time.

Restaking Explained: In Ethereum’s proof-of-stake model, validators normally stake ETH to secure the network and earn rewards, with the risk of slashing if they misbehave. Restaking allows this same staked ETH (or its liquid staking derivatives) to be reused to secure additional protocols or services. EigenLayer introduced restaking via smart contracts that let ETH stakers opt in to extend their security to new systems in exchange for extra yield. In practice, an Ethereum validator can register with EigenLayer and grant its contracts permission to impose additional slashing conditions specified by external protocols. If the validator performs maliciously on any opted-in service, the EigenLayer contracts can slash their staked ETH, just as Ethereum would for consensus violations. This mechanism effectively transforms Ethereum’s robust staking security into a composable “Security-as-a-Service”: developers can borrow Ethereum’s economic security to bootstrap new projects, rather than starting their own validator network from scratch. By leveraging the 31M+ ETH already securing Ethereum, EigenLayer’s restaking creates a “pooled security” marketplace where multiple services share the same trusted capital base.

EigenLayer’s Approach: EigenLayer is implemented as a set of Ethereum smart contracts that coordinate this restaking process. Validators (or ETH holders) who wish to restake either deposit their liquid staking tokens or, in the case of native stakers, redirect their withdrawal credentials to an EigenLayer-managed contract (often called an EigenPod). This ensures EigenLayer can enforce slashing by locking or burning the underlying ETH if needed. Restakers always retain ownership of their ETH (withdrawable after an exit/escrow period), but they opt-in to new slashing rules on top of Ethereum’s. In return, they become eligible for additional restaking rewards paid by the services they secure. The end result is a modular security layer: Ethereum’s validator set and stake are “rented out” to external protocols. As EigenLayer’s founder Sreeram Kannan puts it, this creates a “Verifiable Cloud” for Web3 – analogous to how AWS offers computing services, EigenLayer offers security as a service to developers. Early adoption has been strong: by mid-2024 over 4.9 million ETH (~$15B) was restaked into EigenLayer, demonstrating demand from stakers to maximize yield and from new protocols to bootstrap with minimal overhead. In summary, restaking on Ethereum repurposes existing trust (staked ETH) to secure new applications, and EigenLayer provides the infrastructure to make this process composable and permissionless.

Design Patterns of Actively Validated Services (AVSs)​

What are AVSs? Actively Validated Services (AVSs) refer to any decentralized service or network that requires its own set of validators and consensus rules, but can outsource security to a restaking platform like EigenLayer. In other words, an AVS is an external protocol (outside the Ethereum L1) that hires Ethereum’s validators to perform some verification work. Examples include sidechains or rollups, data availability layers, oracle networks, bridges, shared sequencers, decentralized compute modules, and more. Each AVS defines a unique distributed validation task – for instance, an oracle might require signing price feeds, while a data availability chain (like EigenDA) requires storing and attesting to data blobs. These services run their own software and possibly their own consensus among participating operators, but rely on shared security: the economic stake backing them is provided by restaked ETH (or other assets) from Ethereum validators, rather than a native token for each new network.

Architecture and Roles: EigenLayer’s architecture cleanly separates the roles in this shared security model:

• Restakers – ETH stakers (or LST holders) who opt in to secure AVSs. They deposit into EigenLayer contracts, extending their staked capital as collateral for multiple services. Restakers can choose which AVSs to support, directly or via delegation, and earn rewards from those services. Crucially, they bear slashing risk if any supported AVS reports misbehavior.

• Operators – Node operators who actually run the off-chain client software for each AVS. They are analogous to miners/validators for the AVS’s network. In EigenLayer, an operator must register and be approved (initially whitelisted) to join, and can then opt in to serve specific AVSs. Restakers delegate their stake to operators (if they don’t run nodes themselves), so operators aggregate stake from potentially many restakers. Each operator is subject to the slashing conditions of whatever AVS they support, and they earn fees or rewards for their service. This creates a marketplace of operators competing on performance and trustworthiness, since AVSs will prefer competent operators and restakers will prefer those who maximize rewards without incurring slashing.

• AVS (Actively Validated Service) – The external protocol or service itself, which typically consists of two components: (1) an off-chain binary or client that operators run to perform the service (e.g. a sidechain node software), and (2) an on-chain AVS contract deployed on Ethereum that interfaces with EigenLayer. The AVS’s Ethereum contract encodes the rules for that service’s slashing and reward distribution. For example, it might define that if two conflicting signatures are submitted (proof of equivocation by an operator), a slash of X ETH is executed on that operator’s stake. The AVS contract hooks into EigenLayer’s slashing managers to actually penalize restaked ETH when violations occur. Thus, each AVS can have custom validation logic and fault conditions, while relying on EigenLayer to enforce economic punishments using the shared stake. This design lets AVS developers innovate on new trust models (even new consensus mechanisms or cryptographic services) without reinventing a bonding/slashing token for security.

• AVS Consumers/Users – Finally, the end-users or other protocols that consume the AVS’s output. For instance, a dApp might use an oracle AVS for price data or a rollup might post data to a data availability AVS. Consumers pay fees to the AVS (often funding the rewards restakers/operators earn) and depend on its correctness, which is assured by the economic security the AVS has leased from Ethereum.

Leveraging Shared Security: The beauty of this model is that even a brand-new service can start life with Ethereum-grade security guarantees. Instead of recruiting and incentivizing a fresh set of validators, an AVS taps into an experienced, economically bonded validator set from day one. Smaller chains or modules that would be insecure alone become secure by piggybacking on Ethereum. This pooled security significantly raises the cost to attack any single AVS – an attacker would need to acquire and stake large amounts of ETH (or other whitelisted collateral) and then risk losing it via slashing. Because many services share the same pool of restaked ETH, they effectively form a shared security umbrella: the combined economic weight of the stake deters attacks on any one of them. From a developer’s perspective, this modularizes the consensus layer – you focus on your service’s functionality while EigenLayer handles securing it with an existing validator set. AVSs can thus be very diverse. Some are general-purpose “horizontal” services that many dApps could use (e.g. a generic decentralized sequencer or an off-chain compute network), while others are “vertical” or application-specific (tailored to a niche like a particular bridge or a DeFi oracle). Early examples of AVSs on EigenLayer span data availability (e.g. EigenDA), shared sequencing for rollups (e.g. Espresso, Radius), oracle networks (e.g. eOracle), cross-chain bridges (e.g. Polymer, Hyperlane), off-chain computation (e.g. Lagrange for ZK proofs), and more. All of these leverage the same Ethereum trust base. In summary, an AVS is essentially a pluggable module that outsources trust to Ethereum: it defines what validators must do and what constitutes a slashable fault, and EigenLayer enforces those rules on a pool of ETH that is globally used to secure many such modules.

Incentive Mechanisms for Restakers, Operators, and Developers​

A robust incentive design is critical to align all parties in a restaking ecosystem. EigenLayer and similar platforms create a “win-win-win” by offering new revenue to stakers and operators while lowering costs for emerging protocols. Let’s break down incentives by role:

• Incentives for Restakers: Restakers are primarily motivated by yield. By opting into EigenLayer, an ETH staker can earn extra rewards on top of their standard Ethereum staking yield. For example, a validator with 32 ETH staked in Ethereum’s beacon chain continues earning the ~4-5% base APR, but if they restake via EigenLayer, they can simultaneously earn fees or token rewards from multiple AVSs that they help secure. This “double dipping” dramatically increases potential returns for validators. In EigenLayer’s early rollout, restakers received incentive points that converted into EIGEN token airdrops (for bootstrap); later a continuous reward mechanism (Programmatic Incentives) was launched, distributing millions of EIGEN tokens to restakers as liquidity mining. Beyond token incentives, restakers benefit from diversification of income – instead of relying solely on Ethereum block rewards, they can earn in various AVS tokens or fees. Of course, these higher rewards come with higher risk (greater slashing exposure), so rational restakers will only opt into AVSs they believe are well-managed. This creates a market-driven check: AVSs must offer attractive enough rewards to compensate for risk, or restakers will avoid them. In practice, many restakers delegate to professional operators, so they may also pay a commission to the operator out of their rewards. Even so, restakers stand to gain significantly by monetizing the otherwise idle security capacity of their staked ETH. (Notably, EigenLayer reports that over 88% of all distributed EIGEN went straight into being staked/delegated again – indicating restakers are eagerly compounding their positions.)

• Incentives for Operators: Operators in EigenLayer are the service providers who do the heavy lifting of running nodes for each AVS. Their incentive is the fee revenue or reward share paid by those AVSs. Typically, an AVS will pay out rewards (in ETH, stablecoins, or its own token) to all validators securing it; operators receive those rewards on behalf of the stake they host, and often take a cut (like a commission) for providing infrastructure. EigenLayer allows restakers to delegate to operators, so operators compete to attract as much restaked ETH as possible – more stake delegated means more tasks they can do and more fees earned. This dynamic encourages operators to be highly reliable and specialize in AVSs they can run efficiently (to avoid getting slashed and to maximize uptime). An operator with a good reputation may secure a larger delegation and thus greater total rewards. Importantly, operators face slashing penalties for misconduct just as restakers do (since the stake they carry can be slashed), aligning their behavior with honest execution. EigenLayer’s design effectively creates an open marketplace for validator services: AVS teams can “hire” operators by offering rewards, and operators will choose AVSs that are profitable relative to risk. For instance, one operator might focus on running an oracle AVS if it has high fees, while another might run a data layer AVS that requires lots of bandwidth but pays well. Over time, we expect a free-market equilibrium where operators choose the best mix of AVSs and set an appropriate fee split with their delegators. This contrasts with traditional single-chain staking where validators have fixed duties – here, they can multitask across services to stack earnings. The incentive for operators is thus to maximize their earnings per unit of staked collateral, without overloading to the point of slashing. It’s a delicate balance that should drive professionalization and maybe even insurance or hedging solutions (operators might insure against slashing to protect their delegators, etc.).

• Incentives for AVS Developers: Protocol developers (the teams building new AVSs or chains) arguably have the most to gain from restaking’s “security outsourcing” model. Their primary incentive is cost and time savings: they do not need to launch a new token with high inflation or persuade thousands of independent validators to secure their network from scratch. Bootstrapping a PoS network normally requires giving early validators large token rewards (diluting the supply) and can still result in weak security if the token’s market cap is low. With shared security, a new AVS can come online secured by Ethereum’s $200B+ economic security, instantly making attacks economically unviable. This is a huge draw for infrastructure projects like bridges or oracles that need strong safety guarantees. Moreover, developers can focus on their application logic and rely on EigenLayer (or Karak, etc.) for the validator set management, greatly reducing complexity. Economically, while the AVS must pay for security, it can often do so in a more sustainable way. Instead of huge inflation, it might redirect protocol fees or offer a modest native token stipend. For example, a bridge AVS could charge users fees in ETH and use those to pay restakers, achieving security without printing unbacked tokens. A recent analysis notes that eliminating the need for “highly dilutive reward mechanisms” was a key motivation behind Karak’s universal restaking design. Essentially, shared security allows “bootstrapping on a budget.” Additionally, if the AVS does have a token, it can be used more for governance or utility rather than purely for security spend. Developers are also incentivized by network effects: by plugging into a restaking hub, their service can more easily interoperate with other AVSs (shared users and operators) and gain exposure to the large community of Ethereum stakers. The flip side is that AVS teams must design compelling reward schemes to attract restakers and operators in the open market. This often means initially offering generous yields or token incentives to kickstart participation – much like liquidity mining in DeFi. For instance, EigenLayer itself distributed the EIGEN token widely to early stakers/operators to encourage participation. We see similar patterns with new restaking platforms (e.g. Karak’s XP campaign for future $KAR tokens). In summary, AVS developers trade off giving some rewards to Ethereum stakers in return for avoiding the dead-start problem of securing a new network. The strategic gain is faster time-to-market and higher security from day one, which can be a decisive advantage especially for critical infrastructure like cross-chain bridges or financial services that require trust.

Regulatory Risks and Governance Concerns​

Regulatory Uncertainty: The novel restaking model exists in a legal gray area, raising several regulatory questions. One concern is whether offering “security-as-a-service” could be seen by regulators as an unregistered security offering or a form of high-risk investment product. For example, the distribution of the EIGEN token via a staker airdrop and ongoing rewards has drawn scrutiny about compliance with securities laws. Projects must be careful that their tokens or reward schemes don’t trigger securities definitions (e.g. Howey test in the U.S.). Additionally, restaking protocols aggregate and reallocate stakes across networks, which might be viewed as a form of pooled investment or even a bank-like activity if not properly decentralized. EigenLayer’s team acknowledges the regulatory risk, noting that changing laws could impact the feasibility of restaking and that EigenLayer “might be classified as an illegal financial activity in some regions”. This means regulators could determine that handing off slashing control to third-party services (AVSs) violates financial or consumer-protection rules, especially if retail users are involved. Another angle is sanctions/AML: restaking moves stake into contracts that then validate other chains – if one of those chains is processing illicit transactions or is sanctioned, could Ethereum validators inadvertently fall foul of compliance? This remains untested. So far, no clear regulations target restaking specifically, but the evolving stance on crypto staking (e.g. the SEC’s actions against centralized staking services) suggests that restaking may attract scrutiny as it grows. Projects like EigenLayer have taken a cautious approach – for instance, the EIGEN token was initially non-transferrable upon launch to avoid speculative trading and potential regulatory issues. Nonetheless, until frameworks are defined, restaking platforms operate with the risk that new laws or enforcement could impose constraints (such as requiring participant accreditation, disclosures, or even prohibiting certain types of cross-chain staking).

Governance and Consensus Concerns: Restaking introduces complex governance challenges both at the protocol level and for the broader Ethereum ecosystem:

• Overloading Ethereum’s Social Consensus: A prominent worry, voiced by Vitalik Buterin, is that extended uses of Ethereum’s validator set could inadvertently drag Ethereum itself into external disputes. Vitalik’s admonition: “Dual-use of validator staked ETH, while it has some risks, is fundamentally fine, but attempting to ‘recruit’ Ethereum’s social consensus for your application’s own purposes is not.”. In plain terms, it’s acceptable if Ethereum validators also validate, say, an oracle network and get slashed individually for misbehavior there (no effect on Ethereum’s consensus). What’s dangerous is if an external protocol expects the Ethereum community or core protocol to step in to resolve some issue (for example, to fork out validators who behaved badly on the external service). EigenLayer’s design consciously tries to avoid this scenario by keeping slashable faults objective and isolated. Slashing conditions are cryptographic (e.g. double-signing proof) and do not require Ethereum governance intervention – thus any punishment is self-contained to the EigenLayer contract and doesn’t involve Ethereum altering its state or rules. In cases of subjective faults (where human judgment is needed, say for an oracle pricing dispute), EigenLayer plans to use its own governance (e.g. an EIGEN token vote or a council) rather than burden Ethereum’s social layer. This separation is critical to maintain Ethereum’s neutrality. However, as restaking grows, there is a systemic risk that if a major incident occurred (such as a bug causing mass slashing of a huge portion of validators), the Ethereum community might be pressured to respond (for instance, by reversing slashes). That would entangle Ethereum in the fate of external AVSs – exactly what Vitalik warns against. The social consensus risk is thus mostly about extreme “black swan” cases, but it underscores the importance of keeping Ethereum’s core minimal and uninvolved in restaking governance.

• Slashing Cascades and Ethereum Security: Relatedly, there is concern that slashing events in restaking could cascade and compromise Ethereum. If a very popular AVS (with many validators) suffered a catastrophic failure leading to mass slashing, thousands of ETH validators might lose stake or get forced out. In a worst-case scenario, if enough stake is slashed, Ethereum’s own validator set could shrink or centralize rapidly. For example, imagine a top EigenLayer operator running 10% of all validators is slashed on an AVS – those validators could go offline after losing funds, reducing Ethereum’s security. Chorus One (a staking service) analyzed EigenLayer and noted this cascade risk is exacerbated if the restaking market leads to only a few large operators dominating. The good news is that historically, slashing on Ethereum is rare and usually small-scale. EigenLayer also initially limited the amount of stake and disabled slashing while the system was new. By April 2025, EigenLayer enabled slashing on mainnet with careful monitoring. To further mitigate unintended slashes (e.g. due to bugs), EigenLayer introduced “slashing veto committees” – essentially a multi-sig of experts who can override a slashing if it appears to be a mistake or an attack on the protocol. This is a temporary centralizing measure, but it addresses the risk of a flawed AVS smart contract wreaking havoc. In time, such committees could be replaced by more decentralized governance or fail-safes.

• Centralization of Restaking and Governance: A key governance concern is who controls the restaking protocol and its parameters. In EigenLayer’s early stages, upgrades and critical decisions were controlled by a multisig of the team and close community (e.g. a 9-of-13 multisig). This is practical for rapid development safety, but it’s a centralization risk – those key holders could collude or be compromised to maliciously change rules (for instance, to steal staked funds). Recognizing this, EigenLayer established a more formal EigenGov framework in late 2024, introducing a Protocol Council of experts and a community governance process for changes. The council now controls upgrades via a 3-of-5 multisig, with community oversight. Over time, the intent is to evolve to token-holder governance or a fully decentralized model. Still, in any restaking system, governance decisions (like which new collateral to support, what AVS to “bless” with official status, how slashing disputes are resolved) carry high stakes. There’s a potential conflict of interest: large staking providers (like Lido or exchanges) could influence governance to favor their operators or assets. Indeed, competition is emerging – e.g. Lido’s founders backing Symbiotic, a multi-asset restaking platform – and one can imagine governance wars if, say, a proposal arises to ban a certain AVS that is seen as risky. The restaking layer itself needs robust governance to manage such issues transparently.

• Validator Centralization: On the operational side, there is concern that AVSs will preferentially choose big operators, causing centralization in who actually validates most of the restaked services. If, for efficiency, many AVS teams all select a handful of professional validators (e.g. major staking companies) to service them, those entities gain outsized power and share of rewards. They could then undercut others by offering better terms (thanks to economies of scale), potentially snowballing into an oligopoly. This mirrors concerns in vanilla Ethereum staking (e.g. Lido’s dominance). Restaking could amplify it since operators that run multiple AVSs have more revenue streams. This is as much an economic concern as a governance one – it might require community-imposed limits or incentives to encourage decentralization (for instance, EigenLayer could cap how much stake one operator can control, or AVSs could be required to distribute their assignments). Without checks, the “rich get richer” dynamic could lead to a few node operators effectively controlling large swathes of the Ethereum validator set across many services, which is unhealthy for decentralization. The community is actively discussing such issues, and some have proposed that restaking protocols include mechanisms to favor smaller operators or enforce diversity (perhaps via the delegation strategy or through social coordination by staker communities).

In summary, while restaking unlocks tremendous innovation, it also introduces new vectors of risk. Regulators are eyeing whether this represents unregulated yield products or poses systemic dangers. Ethereum’s leadership stresses the importance of not entangling base-layer governance in these new uses. The EigenLayer community and others have responded with careful design (objective slashing only, two-tier tokens for different fault types, vetting AVSs, etc.) and interim central control to prevent accidents. Ongoing governance challenges include decentralizing control without sacrificing safety, ensuring open participation rather than concentration, and establishing clear legal frameworks. As these restaking networks mature, expect improved governance structures and possibly industry standards or regulations to emerge that address these concerns.

EigenLayer vs. Karak vs. Babylon: A Comparative Analysis​

The restaking/shared-security landscape now includes several frameworks with different designs. Here we compare EigenLayer, Karak Network, and Babylon – highlighting their technical architectures, economic models, and strategic focus:

Technical Architecture & Security Base: EigenLayer is an Ethereum-native protocol (smart contracts on Ethereum L1) that leverages staked ETH (and equivalent Liquid Staking Tokens) as the security collateral. It “piggybacks” on Ethereum’s beacon chain – validators opt in via Ethereum contracts, and slashing is enforced on their ETH stake. This means EigenLayer’s security is fundamentally tied to Ethereum’s PoS and the value of ETH. In contrast, Karak positions itself as a “universal restaking layer” not tied to a single base chain. Karak launched its own L1 blockchain (with EVM compatibility) optimized for shared security services. Karak’s model is chain-agnostic and asset-agnostic: it allows restaking of many types of assets across multiple chains, not just ETH. Supported collateral reportedly includes ETH and LSTs plus other ERC-20s (stablecoins like USDC/sDAI, LP tokens, even other L1 tokens). This means Karak’s security base is a diversified basket; validation in Karak could be backed by, say, some combination of staked ETH, staked SOL (if bridged in), stablecoins, etc., depending on what the AVS (or “VaaS” in Karak’s terminology) accepts. Babylon takes a different route: it harnesses the security of Bitcoin (BTC) – the largest crypto asset – to secure other chains. Babylon is built as a Cosmos-based chain (Babylon Chain) that connects to Bitcoin and PoS chains via the IBC protocol. BTC holders lock native BTC on the Bitcoin mainnet (in a clever time-locked vault) and thereby “stake” BTC to Babylon, which then uses that as collateral to secure consumer PoS chains. Thus, Babylon’s security base is the value of Bitcoin (over $500B market cap), tapped in a trustless way (no wrapped BTC or custodians – it uses Bitcoin scripts to enforce slashing). In summary, EigenLayer relies on Ethereum’s economic security, Karak is multi-asset and multi-chain (a generic layer for any collateral), and Babylon extends Bitcoin’s proof-of-work security into PoS ecosystems.

Restaking Mechanism: In EigenLayer, restaking is opt-in via Ethereum contracts; slashing is programmatic and enforced by Ethereum consensus (honoring the EigenLayer contracts). Karak, as an independent L1, maintains its own restaking logic on its chain. Karak introduced the concept of Validation-as-a-Service (VaaS) – analogous to Eigen’s AVS – but with a universal validator marketplace across chains. Karak’s validators (operators) run its chain and any number of Distributed Secure Services (DSS), which are Karak’s equivalent of AVSs. A DSS might be a new app-specific blockchain or service that rents security from Karak’s staked asset pool. Karak’s innovation is standardizing requirements so that any chain or app (Ethereum, Solana, an L2, etc.) could plug in and use its validator network and varied collateral. Slashing in Karak would be handled by its protocol rules – since it can stake e.g. USDC, it presumably slashes a validator’s USDC if they misbehave on a service (the exact multi-asset slashing mechanics are complex and not public, but the idea is similar: each collateral can be taken away if violations are proven). Babylon’s mechanism is unique due to Bitcoin’s limitations: Bitcoin doesn’t support smart contracts to auto-slash, so Babylon uses cryptographic tricks. BTC is locked in a special output that requires a key. If a BTC-staking participant cheats (e.g. signs two conflicting blocks on a client chain), the protocol leverages an extractable one-time signature (EOTS) scheme to reveal the participant’s private key, allowing their locked BTC to be swept to a burn address. In simpler terms, misbehavior causes the BTC staker to effectively slash themselves, as the act of cheating gives away control of their deposit (which is then destroyed). Babylon’s Cosmos-based chain coordinates this process and communicates with partner chains (via IBC) to provide services like checkpointing and finality using BTC’s timestamps. In Babylon, the validators of the Babylon chain (called finality providers) are separate – they run the Babylon consensus and assist in relaying information to Bitcoin – but don’t provide economic security; the economic security comes purely from locked BTC.

Economic Model & Rewards: EigenLayer’s economic model is centered on Ethereum’s staking economy. Restakers earn AVS-specific rewards – these could be paid in ETH fees, the AVS’s own token, or other tokens depending on each AVS’s design. EigenLayer itself introduced the $EIGEN token largely for governance and to reward early participants, but AVSs are not required to use or pay in EIGEN (it’s not a gas token for them). The platform targets a free-market equilibrium where each AVS sets a reward rate to attract sufficient security. Karak appears to be launching its native token $KAR (not yet live as of early 2025) as the primary asset in its ecosystem. Karak raised $48M and was backed by major investors, implying $KAR will have value and likely be used for governance and possibly fee payments on the Karak network. However, Karak’s main promise is “no inflation” for new networks leveraging it – instead of issuing their own tokens for security, they tap into existing assets via Karak. So a new chain using Karak might pay validators in, say, its transaction fees (which could be in a stablecoin or in the chain’s native token if it has one) but would not need to continuously mint new tokens for staking rewards. Karak set up a validator marketplace where developers can post bounties/rewards for validators to restake assets and secure their service. This marketplace approach aims to make rewards more competitive and consistent rather than extremely high inflation followed by crash – theoretically reducing costs for developers and giving validators steady multi-chain income. Babylon’s economics differ as well: BTC stakers who lock their Bitcoin earn yield in the tokens of the networks they are securing. For example, if you stake BTC to help secure a Cosmos zone (one of Babylon’s client chains), you receive that zone’s staking rewards (its native staking token) as if you were a delegator there. Those partner chains benefit by getting an extra layer of security (checkpoints on Bitcoin, etc.), and in return they allocate a portion of their inflation or fees to BTC stakers via Babylon. In effect, Babylon acts as a hub where BTC holders can delegate security to many chains and get paid in many tokens. The Babylon chain itself has a token called $BABY, used to stake in Babylon’s own consensus (Babylon still needs its own PoS validators to run the chain’s infrastructure). $BABY is also likely used in governance and maybe to align incentives (for instance, finality providers stake BABY). But importantly, $BABY does not replace BTC as the source of security – it’s more for running the chain – whereas BTC is the collateral that backs the shared security service. As of May 2025, Babylon had successfully bootstrapped with over 50,000 BTC staked (~$5.5 billion) by BTC holders, making it one of the most secure Cosmos chains by capital. Those BTC stakers then earn staking rewards from multiple connected chains (e.g. Cosmos Hub’s ATOM, Osmosis’s OSMO, etc.), achieving diversified yield while holding BTC.

Strategic Focus and Use Cases: EigenLayer’s strategy has been Ethereum-centric, aiming to accelerate innovation within the Ethereum ecosystem. Its early target use cases (data availability, middleware like oracles, rollup sequencing) all enhance Ethereum or its rollups. It essentially supercharges Ethereum as a meta-layer of services, and now with its planned “multi-chain” support (added in 2025), EigenLayer will allow AVSs to run on other EVM chains or L2s while still using Ethereum’s validator set. This cross-chain verification means EigenLayer is evolving into a cross-chain security provider, but anchored in Ethereum (validators and staking still live on Ethereum for slashing). Karak positions itself as a globally extensible base layer for all kinds of applications – not just crypto infrastructure, but also real-world assets, financial markets, even government services, according to its marketing. The name “Global Base Layer for Programmable GDP” hints at an ambition to work with institutions and nation-states. Karak emphasizes integration of traditional finance and AI, suggesting it will pursue partnerships beyond the crypto-native realm. Technically, by supporting assets like stablecoins and potentially government currencies, Karak could enable, for example, a government to launch a blockchain secured by its own fiat token staked via Karak’s validators. Its support for enterprise and multiple jurisdictions is a differentiator. In essence, Karak is trying to be “restaking for everyone, on any chain, with any asset” – a broader net than EigenLayer’s Ethereum-first approach. Babylon’s focus is on bridging the Bitcoin and Cosmos (and broader PoS) ecosystems. It specifically enhances inter-chain security by providing Bitcoin’s immutability and economic weight to otherwise smaller proof-of-stake chains. One of Babylon’s killer apps is adding Bitcoin finality checkpoints to PoS chains, making it extremely hard for those chains to be attacked or reorganized without also attacking Bitcoin. Babylon thus markets itself as bringing “Bitcoin’s security to all of crypto”. Its near-term focus has been Cosmos SDK chains (which it calls Bitcoin Supercharged Networks in Phase 3), but the design is meant to be interoperable with Ethereum and rollups as well. Strategically, Babylon taps into the vast BTC holder base, giving them a yield option (BTC is otherwise a non-yielding asset) and at the same time offering chains access to the “gold standard” of crypto security (BTC + PoW). This is quite distinct from EigenLayer and Karak, which are more about leveraging PoS assets.

Table: EigenLayer vs Karak vs Babylon

Feature	EigenLayer (Ethereum)	Karak Network (Universal L1)	Babylon (Bitcoin–Cosmos)
Base Security Asset	ETH (Ethereum stake) and whitelisted LSTs.	Multi-asset: ETH, LSTs, stablecoins, ERC-20s, etc.. Also cross-chain assets (Arbitrum, Mantle, etc.).	BTC (native Bitcoin) locked on Bitcoin mainnet. Uses Bitcoin’s high market cap as security.
Platform Architecture	Smart contracts on Ethereum L1. Uses Ethereum validators/clients; slashing enforced by Ethereum consensus. Now expanding to support AVSs on other chains via Ethereum proofs.	Independent Layer-1 chain (“Karak L1”) with EVM. Provides a restaking framework (KNS) to launch new blockchains or services with instant validator sets. Not a rollup or L2 – a separate network bridging multiple ecosystems.	Cosmos-based chain (Babylon Chain) connecting to Bitcoin via cryptographic protocols. Uses IBC to link with PoS chains. Babylon validators run a Tendermint consensus, and Bitcoin network is leveraged for timestamps & slashing logic.
Security Model	Opt-in restaking: Ethereum stakers delegate stake to EigenLayer and opt into AVS-specific slashing conditions. Slashing conditions are objective (cryptographic proofs) to avoid Ethereum social consensus issues.	Universal validation: Karak validators can stake various assets and are assigned to secure Distributed Secure Services (DSS) (similar to AVSs) across many chains. Slashing and rewards handled by Karak’s chain logic; standardizes security as a service for any chain.	“Remote staking” BTC: Bitcoin holders lock BTC in self-custody vaults (timelocked UTXOs) and if they misbehave on a client chain, their private key can be exposed to slash (burn) their BTC. Uses Bitcoin’s own mechanics (no token wrapping). Babylon chain coordinates this and provides checkpointing (BTC finality) to client chains.
Token & Rewards	EIGEN token: Used for governance and to reward early participants (via airdrop, incentives). Restakers mainly earn in AVS fees or tokens (could be ETH, stablecoins, or AVS-native tokens). EigenLayer itself doesn’t mandate a cut for EIGEN token holders in AVS revenue (though EIGEN may have future utility in subjective validation tasks).	KAR token: Not yet launched (expected in 2025). Will be main utility/governance token in Karak’s ecosystem. Karak touts no native inflation for new chains – validators earn consistent rewards by securing many services. New protocols can incentivize validators via the Karak marketplace rather than high inflation tokens. Likely KAR will be used for Karak chain security and governance decisions.	BABY token: Native to Babylon Chain (for staking its validators, governance). BTC stakers do not receive BABY for their service, instead they earn yield in the tokens of the connected PoS chains they secure. (E.g. stake BTC to secure Chain X, earn Chain X’s staking rewards). This keeps BTC stakers’ exposure mostly to existing tokens. BABY’s role is to secure the Babylon hub and possibly as gas or governance in the Babylon ecosystem.
Notable Use Cases	Ethereum-aligned infrastructure: e.g. EigenDA (data availability for rollups), oracle networks (e.g. Tellor/eOracle), cross-chain bridges (LayerZero integrating), shared sequencers for rollups (Espresso, Radius), off-chain compute (Risc Zero, etc.). Also exploring decentralized MEV relay services and liquid restaking derivatives. Essentially, extends Ethereum’s capabilities (scaling, interoperability, DeFi middleware) by providing a decentralized trust layer.	Broad focus including traditional finance integration: tokenized real-world assets, 24/7 trading markets, even government and AI applications on bespoke chains. For example, KUDA (data availability marketplace) and others are being built in Karak’s ecosystem. Could host enterprise consortia chains that use USD stablecoins as staking collateral, etc. Karak is targeting multi-chain developers who want security without being limited to Ethereum validators or ETH only. Also emphasizes interoperability and capital efficiency – e.g. using lower-opportunity-cost assets (like smaller L1 tokens) for restaking so that yields can be higher without competing with ETH’s yield.	Security for Cosmos chains and beyond: e.g. using BTC to secure Cosmos Hub, Osmosis, and other zones (enhancing their security without those zones increasing inflation). Provides Bitcoin timestamp finality – any chain that opts in can have important transactions hashed onto Bitcoin for censorship-resistance and finality. Especially useful for new PoS chains that want to prevent long-range attacks or add a Bitcoin “root of trust.” Babylon effectively creates a bridge between Bitcoin and PoS networks: Bitcoin holders gain yield from PoS, and PoS chains gain BTC’s security and community. It’s complementary to restaking with ETH; for instance, a chain might use EigenLayer for ETH economic security and Babylon for BTC robustness.

Strategic Differences: EigenLayer benefits from Ethereum’s massive decentralized validator set and credibility, but it is limited to ETH-based security. It excels at serving Ethereum-oriented projects (many AVSs are Ethereum rollup or middleware projects). Karak’s strategy is to capture a larger market by being flexible in asset support and chain support – it’s not married to Ethereum and even pitches that developers can avoid being “confined exclusively to Ethereum for security”. This could attract projects in ecosystems like Arbitrum, Polygon, or even non-EVM chains that want a neutral security provider. Karak’s multi-asset approach also means it can tap into assets that have lower yields elsewhere; as co-founder Raouf Ben-Har noted, “Many assets have lower opportunity costs versus ETH… meaning [our services] have an easier path to sustainable yields.”. For example, staked ARB (Arbitrum’s token) currently has few uses; Karak could let ARB holders restake into securing new dApps, creating a win-win (yield for ARB holders, security for the dApp). This strategy, however, comes with technical complexity (managing different asset risks) and trust assumptions (bridging assets into Karak’s platform safely). Babylon’s strategy is distinct by focusing on Bitcoin – it is leveraging the largest crypto asset by market cap, which also has a very different community and use profile (long-term holders). Babylon basically unlocked a new staking source that was previously untapped: $1.2 trillion of BTC that could not natively stake. By doing so, it addresses a huge security pool and targets chains that value Bitcoin’s assurances. It also appeals to Bitcoin holders by giving them a way to earn yield without giving up custody of BTC. One might say Babylon is almost the inverse of EigenLayer: instead of extending Ethereum’s security outward, it is importing Bitcoin’s security into PoS networks. Strategically, it could unify the historically separate Bitcoin and DeFi worlds.

Each of these frameworks has trade-offs. EigenLayer currently enjoys a first-mover advantage in Ethereum restaking and a large TVL (~$20B restaked by late 2024), plus deeply integrated Ethereum community support. Karak is newer (mainnet launched April 2024) and aims to grow by covering niches EigenLayer doesn’t (non-ETH collateral, non-Ethereum chains). Babylon operates in the Cosmos arena and taps Bitcoin – it doesn’t compete with EigenLayer for ETH stakers, but rather offers an orthogonal service (some projects might use both). We are seeing a convergence where multiple restaking layers could even interoperate: e.g. an Ethereum L2 could use EigenLayer for ETH-based security and also accept BTC security via Babylon – demonstrating that these models are not mutually exclusive but part of a broader “shared security market”.

Recent Developments and Ecosystem Updates (2024–2025)​

EigenLayer’s Progress: Since its inception in 2021, EigenLayer has rapidly evolved from concept to a live network. It launched on Ethereum mainnet in stages – Stage 1 in mid-2023 enabled basic restaking, and by April 2024 the full EigenLayer protocol (with support for operators and initial AVSs) was deployed. The ecosystem growth has been substantial: as of early 2025 EigenLayer reports 29 AVSs live on mainnet (and 130+ in development) ranging from data layers to oracles. Over 200 operators and tens of thousands of restakers are participating, contributing to a restaked TVL that reached ~$20 billion by late 2024. A major milestone was the introduction of slashing and reward enforcement on mainnet in April 2025, marking the final step of EigenLayer’s security model coming into effect. This means AVSs can now truly penalize misbehavior and pay out rewards trustlessly, moving past the “trial phase” where these were turned off. Alongside this, EigenLayer implemented a series of upgrades: for example, the MOOCOW upgrade (July 2025) improved validator efficiency by allowing easier restake withdrawals and consolidation (leveraging Ethereum’s Pectra fork). Perhaps the most significant new feature is Multi-Chain Verification, launched in July 2025, which enables AVSs to operate across multiple chains (including L2s) while still using Ethereum-based security. This was demonstrated on Base Sepolia testnet and will roll out to mainnet, effectively turning EigenLayer into a cross-chain security provider (not just for Ethereum L1 apps). It addresses a prior limitation that EigenLayer AVSs had to post all data on Ethereum; now an AVS can run on, say, an Optimistic Rollup or another L1, and EigenLayer will verify proofs (using Merkle roots) back on Ethereum to slash or reward as needed. This greatly expands EigenLayer’s reach and performance (AVSs can run where it’s cheaper while keeping Ethereum security). In terms of community and governance, EigenLayer rolled out EigenGov in late 2024 – a council and ELIP (EigenLayer Improvement Proposal) framework to decentralize decision-making. The Protocol Council (5 members) now oversees critical changes with community input. Additionally, EigenLayer has been conscious of concerns raised by Ethereum’s core community. In response to Vitalik’s warnings, the team has published materials explaining how they avoid overloading Ethereum’s consensus, for instance by using the EIGEN token for any “subjective” services and leaving ETH restaking for purely objective slashing cases. This two-tier approach (ETH for clear-cut faults, EIGEN for more subjective or governance-led decisions) is still being refined, but shows EigenLayer’s commitment to aligning with Ethereum’s ethos.

On the ecosystem side, EigenLayer’s emergence has inspired a wave of innovation and discussion. By mid-2024, analysts noted restaking had become “a leading narrative within the Ethereum community”. Many DeFi and infrastructure projects started plotting how to leverage EigenLayer for security or additional yield. At the same time, community members are debating risk management: for example, Chorus One’s detailed risk report (April 2024) brought attention to operator centralization and cascade slashing risks, prompting further research and possibly features like stake distribution monitoring. The EIGEN token distribution was also a hot topic – in Q4 2024 EigenLayer conducted a “stake drop” where active Ethereum users and early EigenLayer participants received EIGEN, but it was non-transferrable initially. Some community members were unhappy with aspects of the drop (e.g. large portions allocated to VCs, and some DeFi protocols that integrated EigenLayer not being directly rewarded). This feedback has led the team to emphasize more community-centric incentives moving forward, and indeed the Programmatic Incentives introduced aim to continuously reward those actually restaking and operating. By 2025, EigenLayer is one of the fastest-growing developer ecosystems – even recognized in an Electric Capital report – and has secured major partnerships (e.g. with LayerZero, ConsenSys, Risc0) to drive adoption of AVSs. Overall, EigenLayer’s trajectory in 2024–2025 shows a maturing platform addressing early concerns and expanding functionality, solidifying its position as the pioneer of Ethereum restaking.

Karak and Other Competitors: Karak Network stepped into the spotlight with its mainnet launch in April 2024 and quickly positioned itself as a notable EigenLayer rival on Ethereum and beyond. Backed by large investors and even certain Ethereum stakeholders (Coinbase Ventures, among others), Karak’s promise of “restaking for everyone, on any chain, with any asset” garnered attention. In late 2024, Karak upgraded to a V2 mainnet with enhanced features for universal security, completing migrations across Arbitrum and Ethereum by November 2024. This indicates Karak expanded support for more assets and possibly improved its smart contracts or consensus. By early 2025, Karak had grown its user base via an XP incentive program (encouraging testnet participation, staking, etc., with the hope of a future $KAR airdrop). Community discussions around Karak often compare it to EigenLayer: Bankless noted in May 2024 that while Karak’s total value staked was still “nowhere near the size of EigenLayer,” it had seen rapid growth (4x in a month) possibly due to users seeking higher rewards or diversifying away from EigenLayer. Karak’s appeal lies in supporting assets like Pendle yield tokens, Arbitrum’s ARB, Mantle’s token, etc., which broadens the restaking market. As of 2025, Karak is likely focusing on onboarding more “Validation-as-a-Service” clients and possibly preparing the launch of its KAR token (its documentation suggests following official channels for token updates). The competition between EigenLayer and Karak remains friendly but significant – both aim to attract stakers and projects. If EigenLayer holds the ETH maximalist segment, Karak is appealing to multi-chain users and those with non-ETH assets looking for yield. We can expect Karak to announce partnerships in the coming year, perhaps with Layer2 networks or even institutional players given its “institutional-grade” branding. The restaking market is thus not a monopoly; rather, multiple platforms are finding niches, which could lead to a fragmented but rich ecosystem of shared security providers.

Babylon’s Launch and the BTC Staking Frontier: Babylon completed a major milestone in 2025 by activating its core functionality – Bitcoin staking for shared security. After a Phase-1 testnet and gradual rollout, Babylon’s Phase-2 mainnet went live in April 2025, and by May 2025 it reported over 50k BTC staked in the protocol. This is a remarkable achievement, effectively plugging in ~$5B of Bitcoin into the interchain security market. Babylon’s early adopter chains (the first “Bitcoin Supercharged Networks”) include several Cosmos-based chains that integrated Babylon’s light client and started relying on BTC checkpoint finality. The Babylon Genesis chain itself launched on April 10, 2025, secured by the new $BABY token staking, and one day later (April 11) the trustless BTC staking was piloted with an initial 1000 BTC cap. By April 24, 2025, BTC staking opened permissionlessly to all, and the cap was lifted. The smooth operation for the first weeks led the team to declare Bitcoin staking “successfully bootstrapped,” calling Babylon Genesis now “among the most secure L1s in the world in terms of staking market cap.”. With Phase-2 complete, Phase-3 aims to onboard many external networks as clients, turning them into BSNs (Bitcoin Supercharged Networks). This will involve interoperability modules so that Ethereum, its rollups, and any Cosmos chain can all use Babylon to draw security from BTC. The Babylon community – comprising Bitcoin holders, Cosmos devs, and others – has been actively discussing governance of the $BABY token (ensuring the Babylon chain remains neutral and reliable for all connected chains) and the economics (for instance, balancing BTC staking rewards among many consumer chains so that it’s attractive to BTC holders without over-subsidizing). One interesting development is Babylon’s support for things like Nexus Mutual cover (as per a May 2025 post) to offer insurance on BTC staking slashing, which could further entice participants. This shows the ecosystem maturing around risk management for this new paradigm.

Community and Cross-Project Discussions: As of 2025, a broader conversation is taking place about the future of shared security in crypto. Ethereum’s community largely welcomes EigenLayer but remains cautious; Vitalik’s blog post (May 2023) set the tone for careful delineation of what is acceptable. EigenLayer regularly engages the community via its forum, addressing questions like “Is EigenLayer overloading Ethereum’s consensus?” (short answer: they argue it is not, due to design safeguards). In the Cosmos community, Babylon sparked excitement as it potentially solves long-standing security issues (e.g. small zones suffering 51% attacks) without requiring them to join a shared-security hub like Polkadot or Cosmos Hub’s ICS. There is also interesting convergence: some Cosmos folks ask if Ethereum staking could ever power Cosmos chains (which is more EigenLayer’s domain), while Ethereum folks wonder if Bitcoin staking could secure Ethereum rollups (Babylon’s concept). We are seeing early signs of cross-pollination: for instance, ideas of using EigenLayer to restake ETH onto non-Ethereum chains (Symbiotic and Karak are steps in that direction) and using Babylon’s BTC staking as an option for Ethereum L2s. Even Solana has a restaking project (Solayer) that launched a soft test and hit caps quickly, showing the interest spans multiple ecosystems.

Governance developments across these projects include increasing community representation. EigenLayer’s council includes external community members now, and it has funded grants (via the Eigen Foundation) to Ethereum core devs, signaling goodwill back to Ethereum’s core. Karak’s governance is likely to revolve around the KAR token – currently, they run an off-chain XP system, but one can expect a more formal DAO once KAR is liquid. Babylon’s governance will be crucial as it coordinates between Bitcoin (which has no formal governance) and Cosmos chains (which have on-chain governance). It set up a Babylon Foundation and community forum to discuss parameters like unbonding periods for BTC, which require careful alignment with Bitcoin’s constraints.

In summary, by mid-2025 the restaking and shared security market has gone from theory to practice. EigenLayer is fully operational with real services and slashing, proving out the model on Ethereum. Karak has introduced a compelling multi-chain variant, broadening the design space and targeting new assets. Babylon has demonstrated that even Bitcoin can join the shared security party via clever cryptography, addressing a completely different segment of the market. The ecosystem is vibrant: new competitors (e.g. Symbiotic on Ethereum, Solayer on Solana, BounceBit using custodial BTC) are emerging, each experimenting with different trade-offs (Symbiotic aligning with Lido to use stETH and any ERC-20, BounceBit taking a regulated approach with wrapped BTC, etc.). This competitive landscape is driving rapid innovation – and importantly, discussion about standards and safety. Community forums and research groups are actively debating questions like: Should there be limits on restaked stake per operator? How to best implement cross-chain slashing proofs? Could restaking unintentionally increase systemic correlation between chains? All of these are being studied. The governance models are also evolving – EigenLayer’s move to a semi-decentralized council is one example of balancing agility and security in governance.

Looking ahead, the restaking paradigm is poised to become a foundation of Web3 infrastructure, much like how cloud services became essential in Web2. By commoditizing security, it enables smaller projects to launch with confidence and larger projects to optimize their capital use. The developments through 2025 show a promising yet cautious trajectory: the technology works and is scaling, but all players are mindful of risks. With Ethereum’s core devs, Cosmos builders, and even Bitcoiners now involved in shared security initiatives, it’s clear this market will only grow. We can expect closer collaboration across ecosystems (perhaps joint security pools or standardized slashing proofs) and, inevitably, regulatory clarity as regulators catch up to these multi-chain, multi-asset constructs. In the meantime, researchers and developers have a trove of new data from EigenLayer, Karak, Babylon, and others to analyze and improve upon, ensuring that the “restaking revolution” continues in a safe and sustainable manner.

Sources:

1. EigenLayer documentation and whitepaper – definition of restaking and AVS
2. Coinbase Cloud blog (May 2024) – EigenLayer overview, roles of restakers/operators/AVSs
3. Blockworks News (April 2024) – Karak founders on “universal restaking” vs EigenLayer
4. Ditto research (2023) – Comparison of EigenLayer, Symbiotic, Karak asset support
5. Messari Research (Apr 2024) – “Babylon: Bitcoin Shared Security”, BTC staking mechanism
6. HashKey Research (Jul 2024) – Babylon vs EigenLayer restaking yields
7. EigenLayer Forum (Dec 2024) – Discussion of Vitalik’s “Don’t overload Ethereum’s consensus” and EigenLayer’s approach
8. Blockworks News (Apr 2024) – Chorus One report on EigenLayer risks (slashing cascade, centralization)
9. Kairos Research (Oct 2023) – EigenLayer AVS overview and regulatory risk note
10. EigenCloud Blog (Jan 2025) – “2024 Year in Review” (EigenLayer stats, governance updates)
11. Blockworks News (Apr 2024) – Karak launch coverage and asset support
12. Babylon Labs Blog (May 2025) – “Phase-2 launch round-up” (Bitcoin staking live, 50k BTC staked)
13. Bankless (May 2024) – “The Restaking Competition” (EigenLayer vs Karak vs others)
14. Vitalik Buterin, “Don’t Overload Ethereum’s Consensus”, May 2023 – Guidance on validator reuse vs social consensus
15. Coinbase Developer Guide (Apr 2024) – Technical details on EigenLayer operation (EigenPods, delegation, AVS structure).

The Speed Revolution Ethereum Has Been Waiting For?​

In the high-stakes world of blockchain scaling solutions, a new contender has emerged that's generating both excitement and controversy. MegaETH is positioning itself as Ethereum's answer to ultra-fast chains like Solana—promising sub-millisecond latency and an astonishing 100,000 transactions per second (TPS).

But these claims come with significant trade-offs. MegaETH is making calculated sacrifices to "Make Ethereum Great Again," raising important questions about the balance between performance, security, and decentralization.

As infrastructure providers who've seen many promising solutions come and go, we at BlockEden.xyz have conducted this analysis to help developers and builders understand what makes MegaETH unique—and what risks to consider before building on it.

What Makes MegaETH Different?​

MegaETH is an Ethereum Layer-2 solution that has reimagined blockchain architecture with a singular focus: real-time performance.

While most L2 solutions improve on Ethereum's ~15 TPS by a factor of 10-100x, MegaETH aims for 1,000-10,000x improvement—speeds that would put it in a category of its own.

Revolutionary Technical Approach​

MegaETH achieves its extraordinary speed through radical engineering decisions:

1. Single Sequencer Architecture: Unlike most L2s that use multiple sequencers or plan to decentralize, MegaETH uses a single sequencer for ordering transactions, deliberately choosing performance over decentralization.

2. Optimized State Trie: A completely redesigned state storage system that can handle terabyte-level state data efficiently, even on nodes with limited RAM.

3. JIT Bytecode Compilation: Just-in-time compilation of Ethereum smart contract bytecode, bringing execution closer to "bare-metal" speed.

4. Parallel Execution Pipeline: A multi-core approach that processes transactions in parallel streams to maximize throughput.

5. Micro Blocks: Targeting ~1ms block times through continuous "streaming" block production rather than batch processing.

6. EigenDA Integration: Using EigenLayer's data availability solution instead of posting all data to Ethereum L1, reducing costs while maintaining security through Ethereum-aligned validation.

This architecture delivers performance metrics that seem almost impossible for a blockchain:

• Sub-millisecond latency (10ms target)
• 100,000+ TPS throughput
• EVM compatibility for easy application porting

Testing the Claims: MegaETH's Current Status​

As of March 2025, MegaETH's public testnet is live. The initial deployment began on March 6th with a phased rollout, starting with infrastructure partners and dApp teams before opening to broader user onboarding.

Early testnet metrics show:

• ~1.68 Giga-gas per second throughput
• ~15ms block times (significantly faster than other L2s)
• Support for parallel execution that will eventually push performance even higher

The team has indicated that the testnet is running in a somewhat throttled mode, with plans to enable additional parallelization that could double gas throughput to around 3.36 Ggas/sec, moving toward their ultimate target of 10 Ggas/sec (10 billion gas per second).

The Security and Trust Model​

MegaETH's approach to security represents a significant departure from blockchain orthodoxy. Unlike Ethereum's trust-minimized design with thousands of validating nodes, MegaETH embraces a centralized execution layer with Ethereum as its security backstop.

The "Can't Be Evil" Philosophy​

MegaETH employs an optimistic rollup security model with some unique characteristics:

1. Fraud Proof System: Like other optimistic rollups, MegaETH allows observers to challenge invalid state transitions through fraud proofs submitted to Ethereum.

2. Verifier Nodes: Independent nodes replicate the sequencer's computations and would initiate fraud proofs if discrepancies are found.

3. Ethereum Settlement: All transactions are eventually settled on Ethereum, inheriting its security for final state.

This creates what the team calls a "can't be evil" mechanism—the sequencer can't produce invalid blocks or alter state incorrectly without being caught and punished.

The Centralization Trade-off​

The controversial aspect: MegaETH runs with a single sequencer and explicitly has "no plans to ever decentralize the sequencer." This brings two significant risks:

1. Liveness Risk: If the sequencer goes offline, the network could halt until it recovers or a new sequencer is appointed.

2. Censorship Risk: The sequencer could theoretically censor certain transactions or users in the short term (though users could ultimately exit via L1).

MegaETH argues these risks are acceptable because:

• The L2 is anchored to Ethereum for final security
• Data availability is handled by multiple nodes in EigenDA
• Any censorship or fraud can be seen and challenged by the community

Use Cases: When Ultra-Fast Execution Matters​

MegaETH's real-time capabilities unlock use cases that were previously impractical on slower blockchains:

1. High-Frequency Trading and DeFi​

MegaETH enables DEXs with near-instant trade execution and order book updates. Projects already building include:

• GTE: A real-time spot DEX combining central limit order books and AMM liquidity
• Teko Finance: A money market for leveraged lending with rapid margin updates
• Cap: A stablecoin and yield engine that arbitrages across markets
• Avon: A lending protocol with orderbook-based loan matching

These DeFi applications benefit from MegaETH's throughput to operate with minimal slippage and high-frequency updates.

2. Gaming and Metaverse​

The sub-second finality makes fully on-chain games viable without waiting for confirmations:

• Awe: An open-world 3D game with on-chain actions
• Biomes: An on-chain metaverse similar to Minecraft
• Mega Buddies and Mega Cheetah: Collectible avatar series

Such applications can deliver real-time feedback in blockchain games, enabling fast-paced gameplay and on-chain PvP battles.

3. Enterprise Applications​

MegaETH's performance makes it suitable for enterprise applications requiring high throughput:

• Instantaneous payments infrastructure
• Real-time risk management systems
• Supply chain verification with immediate finality
• High-frequency auction systems

The key advantage in all these cases is the ability to run compute-intensive applications with immediate feedback while still being connected to Ethereum's ecosystem.

The Team Behind MegaETH​

MegaETH was co-founded by a team with impressive credentials:

• Li Yilong: PhD in computer science from Stanford specializing in low-latency computing systems
• Yang Lei: PhD from MIT researching decentralized systems and Ethereum connectivity
• Shuyao Kong: Former Head of Global Business Development at ConsenSys

The project has attracted notable backers, including Ethereum co-founders Vitalik Buterin and Joseph Lubin as angel investors. Vitalik's involvement is particularly noteworthy, as he rarely invests in specific projects.

Other investors include Sreeram Kannan (founder of EigenLayer), VC firms like Dragonfly Capital, Figment Capital, and Robot Ventures, and influential community figures such as Cobie.

Token Strategy: The Soulbound NFT Approach​

MegaETH introduced an innovative token distribution method through "soulbound NFTs" called "The Fluffle." In February 2025, they created 10,000 non-transferable NFTs representing at least 5% of the total MegaETH token supply.

Key aspects of the tokenomics:

• 5,000 NFTs were sold at 1 ETH each (raising ~$13-14 million)
• The other 5,000 NFTs were allocated to ecosystem projects and builders
• The NFTs are soulbound (cannot be transferred), ensuring long-term alignment
• Implied valuation of around $540 million, extremely high for a pre-launch project
• The team has raised approximately $30-40 million in venture funding

Eventually, the MegaETH token is expected to serve as the native currency for transaction fees and possibly for staking and governance.

How MegaETH Compares to Competitors​

vs. Other Ethereum L2s​

Compared to Optimism, Arbitrum, and Base, MegaETH is significantly faster but makes bigger compromises on decentralization:

• Performance: MegaETH targets 100,000+ TPS vs. Arbitrum's ~250 ms transaction times and lower throughput
• Decentralization: MegaETH uses a single sequencer vs. other L2s' plans for decentralized sequencers
• Data Availability: MegaETH uses EigenDA vs. other L2s posting data directly to Ethereum

vs. Solana and High-Performance L1s​

MegaETH aims to "beat Solana at its own game" while leveraging Ethereum's security:

• Throughput: MegaETH targets 100k+ TPS vs. Solana's theoretical 65k TPS (typically a few thousand in practice)
• Latency: MegaETH ~10 ms vs. Solana's ~400 ms finality
• Decentralization: MegaETH has 1 sequencer vs. Solana's ~1,900 validators

vs. ZK-Rollups (StarkNet, zkSync)​

While ZK-rollups offer stronger security guarantees through validity proofs:

• Speed: MegaETH offers faster user experience without waiting for ZK proof generation
• Trustlessness: ZK-rollups don't require trust in a sequencer's honesty, providing stronger security
• Future Plans: MegaETH may eventually integrate ZK proofs, becoming a hybrid solution

MegaETH's positioning is clear: it's the fastest option within the Ethereum ecosystem, sacrificing some decentralization to achieve Web2-like speeds.

The Infrastructure Perspective: What Builders Should Consider​

As an infrastructure provider connecting developers to blockchain nodes, BlockEden.xyz sees both opportunities and challenges in MegaETH's approach:

Potential Benefits for Builders​

1. Exceptional User Experience: Applications can offer instant feedback and high throughput, creating Web2-like responsiveness.

2. EVM Compatibility: Existing Ethereum dApps can port over with minimal changes, unlocking performance without rewrites.

3. Cost Efficiency: High throughput means lower per-transaction costs for users and applications.

4. Ethereum Security Backstop: Despite centralization at the execution layer, Ethereum settlement provides a security foundation.

Risk Considerations​

1. Single Point of Failure: The centralized sequencer creates liveness risk—if it goes down, so does your application.

2. Censorship Vulnerability: Applications could face transaction censorship without immediate recourse.

3. Early-Stage Technology: MegaETH's novel architecture hasn't been battle-tested at scale with real value.

4. Dependency on EigenDA: Using a newer data availability solution adds an additional trust assumption.

Infrastructure Requirements​

Supporting MegaETH's throughput will require robust infrastructure:

• High-capacity RPC nodes capable of handling the firehose of data
• Advanced indexing solutions for real-time data access
• Specialized monitoring for the unique architecture
• Reliable bridge monitoring for cross-chain operations

Conclusion: Revolution or Compromise?​

MegaETH represents a bold experiment in blockchain scaling—one that deliberately prioritizes performance over decentralization. Whether this approach succeeds depends on whether the market values speed more than decentralized execution.

The coming months will be critical as MegaETH transitions from testnet to mainnet. If it delivers on its performance promises while maintaining sufficient security, it could fundamentally reshape how we think about blockchain scaling. If it stumbles, it will reinforce why decentralization remains a core blockchain value.

For now, MegaETH stands as one of the most ambitious Ethereum scaling solutions to date. Its willingness to challenge orthodoxy has already sparked important conversations about what trade-offs are acceptable in pursuit of mainstream blockchain adoption.

At BlockEden.xyz, we're committed to supporting developers wherever they build, including high-performance networks like MegaETH. Our reliable node infrastructure and API services are designed to help applications thrive across the multi-chain ecosystem, regardless of which approach to scaling ultimately prevails.

---

Looking to build on MegaETH or need reliable node infrastructure for high-throughput applications? Contact Email: info@BlockEden.xyz to learn how we can support your development with our 99.9% uptime guarantee and specialized RPC services across 27+ blockchains.

The Web3 Scaling Problem​

The blockchain industry faces a persistent challenge: how do we scale to support millions of users without sacrificing security or decentralization?

Ethereum, the leading smart contract platform, processes roughly 15 transactions per second on its base layer. During periods of high demand, this limitation has led to exorbitant gas fees—sometimes exceeding $100 per transaction during NFT mints or DeFi farming frenzies.

This scaling bottleneck presents an existential threat to Web3 adoption. Users accustomed to the instant responsiveness of Web2 applications won't tolerate paying $50 and waiting 3 minutes just to swap tokens or mint an NFT.

Enter the solution that's rapidly reshaping blockchain architecture: Rollups-as-a-Service (RaaS).

Understanding Rollups-as-a-Service (RaaS)​

RaaS platforms enable developers to deploy their own custom blockchain rollups without the complexity of building everything from scratch. These services transform what would normally require a specialized engineering team and months of development into a streamlined, sometimes one-click deployment process.

Why does this matter? Because rollups are the key to blockchain scaling.

Rollups work by:

• Processing transactions off the main chain (Layer 1)
• Batching these transactions together
• Submitting compressed proofs of these transactions back to the main chain

The result? Drastically increased throughput and significantly reduced costs while inheriting security from the underlying Layer 1 blockchain (like Ethereum).

"Rollups don't compete with Ethereum—they extend it. They're like specialized Express lanes built on top of Ethereum's highway."

This approach to scaling is so promising that Ethereum officially adopted a "rollup-centric roadmap" in 2020, acknowledging that the future isn't a single monolithic chain, but rather an ecosystem of interconnected, purpose-built rollups.

Caldera: Leading the RaaS Revolution​

Among the emerging RaaS providers, Caldera stands out as a frontrunner. Founded in 2023 and having raised $25M from prominent investors including Dragonfly, Sequoia Capital, and Lattice, Caldera has quickly positioned itself as a leading infrastructure provider in the rollup space.

What Makes Caldera Different?​

Caldera distinguishes itself in several key ways:

1. Multi-Framework Support: Unlike competitors who focus on a single rollup framework, Caldera supports major frameworks like Optimism's OP Stack and Arbitrum's Orbit/Nitro technology, giving developers flexibility in their technical approach.

2. End-to-End Infrastructure: When you deploy with Caldera, you get a complete suite of components: reliable RPC nodes, block explorers, indexing services, and bridge interfaces.

3. Rich Integration Ecosystem: Caldera comes pre-integrated with 40+ Web3 tools and services, including oracles, faucets, wallets, and cross-chain bridges (LayerZero, Axelar, Wormhole, Connext, and more).

4. The Metalayer Network: Perhaps Caldera's most ambitious innovation is its Metalayer—a network that connects all Caldera-powered rollups into a unified ecosystem, allowing them to share liquidity and messages seamlessly.

5. Multi-VM Support: In late 2024, Caldera became the first RaaS to support the Solana Virtual Machine (SVM) on Ethereum, enabling Solana-like high-performance chains that still settle to Ethereum's secure base layer.

Caldera's approach is creating what they call an "everything layer" for rollups—a cohesive network where different rollups can interoperate rather than exist as isolated islands.

Real-World Adoption: Who's Using Caldera?​

Caldera has gained significant traction, with over 75 rollups in production as of late 2024. Some notable projects include:

• Manta Pacific: A highly scalable network for deploying zero-knowledge applications that uses Caldera's OP Stack combined with Celestia for data availability.

• RARI Chain: Rarible's NFT-focused rollup that processes transactions in under a second and enforces NFT royalties at the protocol level.

• Kinto: A regulatory-compliant DeFi platform with on-chain KYC/AML and account abstraction capabilities.

• Injective's inEVM: An EVM-compatible rollup that extends Injective's interoperability, connecting the Cosmos ecosystem with Ethereum-based dApps.

These projects highlight how application-specific rollups enable customization not possible on general-purpose Layer 1s. By late 2024, Caldera's collective rollups had reportedly processed over 300 million transactions for 6+ million unique wallets, with nearly $1 billion in total value locked (TVL).

How RaaS Compares: Caldera vs. Competitors​

The RaaS landscape is becoming increasingly competitive, with several notable players:

Conduit​

• Focuses exclusively on Optimism and Arbitrum ecosystems
• Emphasizes a fully self-serve, no-code experience
• Powers approximately 20% of Ethereum's mainnet rollups, including Zora

AltLayer​

• Offers "Flashlayers"—disposable, on-demand rollups for temporary needs
• Focuses on elastic scaling for specific events or high-traffic periods
• Demonstrated impressive throughput during gaming events (180,000+ daily transactions)

Sovereign Labs​

• Building a Rollup SDK focused on zero-knowledge technologies
• Aims to enable ZK-rollups on any base blockchain, not just Ethereum
• Still in development, positioning for the next wave of multi-chain ZK deployment

While these competitors excel in specific niches, Caldera's comprehensive approach—combining a unified rollup network, multi-VM support, and a focus on developer experience—has helped establish it as a market leader.

The Future of RaaS and Blockchain Scaling​

RaaS is poised to reshape the blockchain landscape in profound ways:

1. The Proliferation of App-Specific Chains​

Industry research suggests we're moving toward a future with potentially millions of rollups, each serving specific applications or communities. With RaaS lowering deployment barriers, every significant dApp could have its own optimized chain.

2. Interoperability as the Critical Challenge​

As rollups multiply, the ability to communicate and share value between them becomes crucial. Caldera's Metalayer represents an early attempt to solve this challenge—creating a unified experience across a web of rollups.

3. From Isolated Chains to Networked Ecosystems​

The end goal is a seamless multi-chain experience where users hardly need to know which chain they're on. Value and data would flow freely through an interconnected web of specialized rollups, all secured by robust Layer 1 networks.

4. Cloud-Like Blockchain Infrastructure​

RaaS is effectively turning blockchain infrastructure into a cloud-like service. Caldera's "Rollup Engine" allows dynamic upgrades and modular components, treating rollups like configurable cloud services that can scale on demand.

What This Means for Developers and BlockEden.xyz​

At BlockEden.xyz, we see enormous potential in the RaaS revolution. As an infrastructure provider connecting developers to blockchain nodes securely, we're positioned to play a crucial role in this evolving landscape.

The proliferation of rollups means developers need reliable node infrastructure more than ever. A future with thousands of application-specific chains demands robust RPC services with high availability—precisely what BlockEden.xyz specializes in providing.

We're particularly excited about the opportunities in:

1. Specialized RPC Services for Rollups: As rollups adopt unique features and optimizations, specialized infrastructure becomes crucial.

2. Cross-Chain Data Indexing: With value flowing between multiple rollups, developers need tools to track and analyze cross-chain activities.

3. Enhanced Developer Tools: As rollup deployment becomes simpler, the need for sophisticated monitoring, debugging, and analytics tools grows.

4. Unified API Access: Developers working across multiple rollups need simplified, unified access to diverse blockchain networks.

Conclusion: The Modular Blockchain Future​

The rise of Rollups-as-a-Service represents a fundamental shift in how we think about blockchain scaling. Rather than forcing all applications onto a single chain, we're moving toward a modular future with specialized chains for specific use cases, all interconnected and secured by robust Layer 1 networks.

Caldera's approach—creating a unified network of rollups with shared liquidity and seamless messaging—offers a glimpse of this future. By making rollup deployment as simple as spinning up a cloud server, RaaS providers are democratizing access to blockchain infrastructure.

At BlockEden.xyz, we're committed to supporting this evolution by providing the reliable node infrastructure and developer tools needed to build in this multi-chain future. As we often say, the future of Web3 isn't a single chain—it's thousands of specialized chains working together.

---

Looking to build on a rollup or need reliable node infrastructure for your blockchain project? Contact Email: info@BlockEden.xyz to learn how we can support your development with our 99.9% uptime guarantee and specialized RPC services across 27+ blockchains.