Executive Summary

This report compares four high-performance Layer-1 blockchains—Pharos, Solana, Sui, and Monad—in the context of RealFi (tokenized real-world assets and institutional-grade DeFi). Pharos is explicitly designed for RealFi, featuring built‑in compliance (ZK‑KYC/AML) and Chainlink-based cross-chain infrastructure. Solana is a mature, ultra-fast PoS chain (Proof‑of‑History + Tower BFT) with widespread adoption of stablecoins and real-time apps, but relies on external services for institutional compliance. Sui (Mysten Labs) uses an object-centric, DAG‑based consensus (Narwhal/Tusk) with extreme parallelism, achieving sub‑second finality, though its ecosystem is nascent for RWAs. Monad is a newly launched EVM‑compatible chain with innovative “MonadBFT” consensus and parallel execution, targeting 10,000 TPS and sub‑second finality.

Performance: Pharos’s testnet has demonstrated 30,000 TPS with 1s finality (targeting 50k TPS), far above Solana’s 1,500–4,000 TPS in practice (0.4s blocks, <1s finality). Sui has achieved up to 297,000 TPS in benchmarks (100 validators) with 480ms finality, leveraging massive parallelism. Monad aims for 10,000 TPS, 0.3s blocks, 0.6s finality. All four chains use parallel or pipelined execution: Pharos and Sui execute transactions speculatively in parallel (Pharos even has dual EVM+WASM VMs), Solana’s Sealevel engine runs parallel smart-contracts, and Monad supports parallel JIT‑compiled EVM execution.

Architecture and Consensus: Pharos employs an async BFT consensus with a dual‑VM (EVM+WASM) and a modular SPN (Special Processing Network) architecture for scalability. Solana uses Proof-of-History (PoH) for global time and Tower BFT (a PBFT variant) for consensus; validators form clusters to aggregate transactions in 400ms slots. Sui’s Narwhal & Tusk is an asynchronous DAG‑based consensus: Narwhal handles data availability, Tusk orders transactions. This lets Sui attain 480ms finality and throughput up to hundreds of thousands TPS in tests. Monad introduces MonadBFT, a new HotStuff-derived BFT protocol with tail-forking resistance and speculative single-round finality. Monad also features RaptorCast (efficient block gossiping), asynchronous pipelining of consensus and execution, and MonadDB for state storage.

Throughput & Finality (Illustrative): The chains’ peak numbers vary widely. Pharos touts 30,000 TPS on testnet with 1s commit-finality (aiming for 50k TPS). Solana’s real-world TPS is 1.5k–4k (versus a 65k theoretical maximum), with 0.4s block time and near‑instant economic finality (votes quickly build finality). Sui’s optimized object model yields hundreds of thousands TPS in benchmarks, with 480ms transaction finality. Monad targets 10,000 TPS with 300ms blocks and 600ms finality. In summary, all chains offer sub‑second finality; Sui’s model achieves the lowest latency (0.5s), followed by Monad (0.6s), Solana (<1s), and Pharos (1s).

RealFi Features: Pharos is built for RealFi: its protocol layer integrates zk‑KYC/AML, compliance, and deep SPN modularity to bridge institutional finance and crypto. It adopts Chainlink CCIP and Data Streams for secure cross-chain value transfer and real-time price data, explicitly targeting tokenized RWAs. Solana’s high throughput and stablecoin liquidity make it suitable for payment rails and tokenized assets (e.g. USDC on Solana, cross-chain via Wormhole), though it lacks native KYC; it relies on ecosystem solutions like Chainalysis KYT integration for compliance. Sui’s high performance could support high-frequency RWA trading and instant settlement, but it has no built‑in compliance or stablecoin infrastructure (so far). Monad, being EVM‑compatible, aims at fintech-grade use but also lacks native compliance modules; however, its compatibility makes it easy to adopt existing Ethereum toolchains and oracles for RealFi (e.g. migrating Solidity DeFi apps).

Cross-Chain & Oracles: Pharos natively embraces cross-chain interoperability. It uses Chainlink’s CCIP/CCTP and its own cross-SPN messaging to move tokens and data atomically between chains. For example, Pharos has announced USDC integration via Circle’s CCTP, enabling secure USDC transfers across 20+ chains. Solana similarly relies on bridges (e.g. Wormhole, Axelar) and has oracles (Pyth, Chainlink) but does not standardize one protocol. Sui and Monad would use bridges (e.g. Hop, Axelar) and oracle networks, but no single canonical solution is established. Notably, Pharos chose Chainlink CCIP as a “canonical” solution for institutional RWAs.

Developer Ecosystems: Pharos provides dual VMs (EVM and WASM), so Solidity and Rust developers can migrate on-chain finance apps; it supports common tools (Hardhat, Foundry) and aims for low transaction fees (EIP-1559 gas model). Solana development is Rust/C‑oriented (with Anchor framework), offering extremely low fees ($0.00025/tx). Sui uses the Move language (MoveVM) and introduces Programmable Transaction Blocks (composable sequences of Move calls) to leverage its parallelism. Monad is fully EVM‑compatible: Solidity smart contracts and Ethereum tooling work out-of-the-box, easing adoption by existing DeFi developers.

Security and Storage: Pharos claims an “80% lower storage overhead” via a compressed Merkle‑tree + log‑structured store. Solana’s Cloudbreak database (sharded accounts DB) and archival archivers manage state, but it has faced network interruptions (though recent improvements like Firedancer and DoubleZero are mitigating these issues). Sui’s object-centric ledger reduces unnecessary work: only objects touched by a transaction require consensus, enabling parallel execution. Monad uses a custom backend (MonadDB) optimized for Ethereum state. All four rely on PoS security; Pharos and Monad enhance this with multi-protocol staking (e.g. EigenLayer restaking) for added security.

Institutional Readiness: Pharos uniquely embeds compliance: built-in ZK‑KYC/AML modules mean transactions can be permissioned by design. It partners for regulated stablecoins (Circle USDC) and custodied assets, emphasizing RWA issuance pipelines. Solana’s ecosystem is pursuing compliance via analytics (Chainalysis) and approved stablecoins (USDC is fully reserved, and custodian partnerships exist), but the protocol itself remains permissionless. Sui and Monad currently lack protocol-level regulatory features; they would rely on off-chain solutions.

Comparative Table: The table below summarizes key metrics and design choices:

Metric/Feature	Pharos	Solana	Sui	Monad
Consensus	Async BFT (tailorable HotStuff); ≥2/3 vote commit, no coordinator. Tail‑fork resistant.	PoH + Tower BFT (PBFT variant). Global clock via PoH VDF, ⅔ votes finalize blocks.	Narwhal (data availability) + Tusk (asynch. BFT). DAG-based mempool+consensus (Bullshark family).	MonadBFT (pipelined HotStuff extension) with tail‑fork protection.
VM/Language	Dual VM: EVM (Solidity) + WASM (e.g. Rust).	Non-EVM: BPF bytecode (native Rust/C programs). Parallel Sealevel runtime.	MoveVM (Move language); object-centric model.	EVM bytecode compatible (Solidity/Rust-EVM). EVM RPC/API native.
Throughput (TPS)	30k (testnet); aiming 50k.	1,500–4,000 real-world (65k theoretical).	10k–297k (benchmark range) (100-node testnet).	10,000 (target) (mainnet launched Nov 2025).
Block Time / Finality	<1s block, 1s finality (sub-sec intended).	400ms block, <1s economic finality, 12–13s full probabilistic finality.	200–500ms block; 480ms finality. (Transactions commit in one round.)	300ms block, 600ms finality (single-round finality with MonadBFT).
Gas Model/Fees	EIP-1559 style; base fee burned. Claims 2 billion gas/sec capacity. Fees expected ≪$0.01.	Fixed minimal fee (e.g. 5k lamports); $0.0005 per TX. Validators stake SOL as gas token.	BFT gas pricing with Move; fees currently low (microdollars), set by validators.	Base fee ≈100 Mono-gwei; block gas limit 200M. Gas model optimized (storage cheaper than Ethereum).
Parallelization	Speculative parallel execution across accounts/VMs; GPU-like pipelining.	Sealevel: parallel runtime runs many txns simultaneously (parallel state access).	Fully parallel by object: disjoint objects execute in parallel. (PTBs allow batched ops.)	Parallel EVM execution with JIT compilation; asynchronous pipelining of consensus & execution.
Data Availability	Multi-layer modular stack: L1-Base for DA (hardware accel.), L1-Core PoS consensus, L1-Extension SPNs.	Fully on-chain: uses cloudbreak DB sharding, Turbine propagation. (Plans for external DA (e.g., Celestia) exist).	Full data on-chain (every object state on Sui chain). Narwhal/Tusk handle DA via DAG.	MonadDB: compact on-chain database. Can integrate external DA (e.g. EigenDA) in future.
Security	PoS, multi-asset restaking (EigenLayer/Babylon) for shared security. AsyncBFT ensures instant finality assuming ≥2/3 honest.	PoS with hundreds of validators; recent upgrades (Firedancer client, DoubleZero network) improve resilience.	PoS (100+ validators in mainnet) with Narwhal/Tusk BFT; asynchronous consensus tolerates network lag.	PoS with many validators (consumer-hardware capable); optimized BFT protects against certain attacks (tail-forks).
Cross-Chain / Oracles	Chainlink CCIP/CCTP canonical bridging (e.g. USDC via Circle CCTP); native cross-SPN messaging.	Bridges like Wormhole, Axelar, etc. Oracles: Pyth (price feeds), Chainlink. No single standard CCIP usage.	Bridges in development (Axelar, Hop); can use Chainlink or Band for oracles once integrated.	Can leverage Ethereum bridges (e.g. Router Protocol) and Ethereum oracles (Chainlink). EVM makes porting easy.
RealFi / Compliance	Built-in compliance (ZK-KYC/AML modules at protocol level). Backed by institutional investors (Sumitomo, etc.). RWA alliance.	Ecosystem compliance via partners (Chainalysis KYT/KYC, TRM Labs). Major stablecoins (USDC, USDT) issued on Solana.	No native compliance. Focus is on high-speed asset chains; could support RWAs via tokens, but limited enterprise support today.	No native compliance layers; relies on trad-fi integration off-chain. Focus is on performance; suitable for digital asset rails but needs external vetting.
Dev Tooling & Languages	Solidity, Vyper (EVM), Rust/Go/C++ (WASM). Supports Hardhat, Foundry, Truffle. JSON-RPC compatible.	Rust/C (Solana’s BPF). Anchor framework (Rust), Solana CLI, Serum DEX. Extensive SDKs.	Move language, sui-cli. WebAssembly VM. Sui Move offers safety for assets.	Solidity/Vyper (EVM). Full Ethereum toolchain: Remix, Hardhat, Foundry, MetaMask, etc. JSON-RPC identical to Ethereum.
Ecosystem Liquidity	Early stage (testnet), but partners building RWA bridges. USDC/CCTP integration planned. A growing RealFi alliance.	Large ecosystem: DEXs (Serum, Raydium), lending, NFTs. >$5B TVL (2024). USDC/USDT widely used.	New ecosystem; a few DeFi apps (e.g. NativeSoul for lending). Liquidity limited but growing (Reddit’s investment, etc.).	Very nascent (Mainnet mid-2025). EVM-compatibility may attract Arbitrum-like liquidity bridges. TVL negligible currently.

Architecture Highlights: All four chains prioritize parallelism. Pharos explicitly uses a GPU-like pipeline and Speculative Parallel Execution (executing independent transactions concurrently). Solana’s architecture (Proof-of-History clock + Turbine, Gulfstream, Cloudbreak, Sealevel) is designed for throughput: e.g., Solana has sustained >50k TPS in test with GPUs. Sui’s model lifts Ethereum’s “transaction” to a Programmable Transaction Block of chained Move calls, enabling complex multi-object transactions to commit atomically. Monad likewise pipelines consensus and execution and uses erasure-coded block transmission (RaptorCast) to reduce latency and bandwidth.

Security Considerations: Pharos, Solana, and Sui use standard PoS safety (≥3f+1 validators for f faults) though via different protocols. Pharos and Sui aim for “instant” finality once ≥2/3 votes are recorded (asynchronous BFT gives deterministic finality), whereas Solana’s tower BFT makes finalized votes unlikely to revert after 12s. MonadBFT introduces tail-fork resistance (re-proposing blocks if leaders miss slots) to ensure block proposals are not lost. In practice, all rely on broadly distributed validators. Pharos and Monad emphasize decentralization on commodity hardware; Solana historically had performance-optimized hardware (though new clients reduce that need).

Developer Experience: Solidity developers will find Pharos and Monad familiar (Ethereum tools just work). Solana requires Rust/Serum knowledge; Sui requires learning Move. Pharos uniquely offers dual-VMs so developers can mix EVM and WASM contracts (e.g. call Rust-compiled contracts from Solidity). Pharos and Monad have tutorials on “getting started” similar to Ethereum’s ecosystem. All support JSON-RPC or gRPC APIs.

RealFi Use Cases: In RealFi applications like tokenized bonds, carbon credits, or real estate, low latency and high throughput matter to support 24/7 markets. Pharos was explicitly built for these: its testnet launch paper touted “efficient payment solutions, unlocking tokenized asset use cases” and cites use cases from renewable energy finance to real estate. Solana’s speed and existing stablecoin liquidity make it a strong payment/investment layer (e.g. remittances, stock tokenization attempts, DeFi trading). Sui’s sub‑second finality suits high-frequency trading of tokenized assets (if bridges enable real-world data). Monad, as a high-speed EVM, could support payment rails and DeFi with minimal migration friction.

Conclusion: Pharos’s architecture and integrations make it uniquely tailored for institutional RealFi: it combines high throughput with built-in compliance and industry-standard oracles. Solana offers proven performance and liquidity, and is increasingly aligning with regulatory tools (Chainalysis KYT on its developer platform), making it fit for tokenized assets albeit without native KYC. Sui achieves the highest technical throughput and instant settlement, but remains experimental for RealFi, lacking maturity in compliance and liquidity. Monad brings Ethereum familiarity and strong performance, but as a newcomer its ecosystem is still forming.

Evidence-based Assessment: For high-frequency RWA trading and DeFi, Sui and Pharos (with ~0.5–1s finality) are advantageous; Solana also suffices (<1s) with a larger ecosystem. For payment rails and stablecoin transactions, Solana’s mature bridges (Wormhole, Circle) and Pharos’s CCIP integration are both compelling. For regulated token issuance (e.g. bond issuances, green finance), Pharos’s compliance modules and Chainlink support give it an edge. Monad is promising for any use case needing Ethereum compatibility at scale, but it is too new for major production RealFi deployments yet.

Key Open Risks: All these chains must prove resiliency at scale. Solana’s history of outages raises concerns for mission-critical settlements. Sui and Monad (younger networks) need to establish robust validator sets and real-world stress tests. Pharos’s ambitious modular design (SPNs and cross-chain sync) will need to validate its claims under adversarial conditions. Finally, institutional RealFi also depends on regulation: even if the tech allows compliant KYC, legal frameworks and custodian support must mature.

The table and sources above summarize the quantitative and technical comparisons. The Appendix below provides relevant formulas and references for deeper technical details.

---

Comparative Table of Key Metrics and Features

Feature / Metric	Pharos	Solana	Sui	Monad
Consensus Algorithm	AsyncBFT (HotStuff variant); 2/3 majority finalize. Fork- and liveness-optimized.	PoH + TowerBFT (PBFT variant). Trusted timestamp + ⅔ vote threshold.	Narwhal (DAG mempool) + Tusk (asynch. BFT). High-throughput DAG consensus.	MonadBFT (HotStuff variant); adds tail-fork resistance, speculative finality.
Execution Model	Speculative parallel execution; dual VM (EVM + WASM).	Single global ledger but parallelizable Sealevel runtime (accounts can process in parallel).	Fully parallel by object. Disjoint objects txns do not conflict.	Parallel EVM execution (JIT-optimized); asynchronous pipelining of consensus and execution.
Throughput (TPS)	30,000 (testnet); aiming 50k.	1.5k–4k (real mainnet) (65k theoretical).	10k–297k (100-node testnet, depending on tx complexity).	10,000 (target).
Block Time	<1 sec (target, testnet ≈1s).	400 ms.	200–500 ms (slot √ at 450ms with 100 validators).	300 ms.
Finality	≈1 sec (sub-second economic finality with ⅔ votes).	Near-instant economic finality (<1s), full finality 12–13s.	480 ms (full finality in one round of votes).	600 ms (single-round commit after 2/3 votes).
Gas & Fees	EIP-1559; “2 gigagas/s” capacity. Fees expected ≪$0.01 per tx.	$0.00025 per tx (5,000 lamports at $100/SOL). On-chain storage costs reflect Solana’s Cloudbreak design.	Move gas. Fees low (microdollar); gas pays for storage and execution.	Base fee 100 Mono-gwei; block gas limit 200M. Gas weights rebalanced (storage 300× cheaper vs ETH).
Storage / State	Delta-encoded Merkle tree + versioned LSM store. “80% lower” space.	Cloudbreak horizontally-scaled accounts DB; archivers store history.	Object-centric state; only mutated objects (by Move operations) update chain.	MonadDB: compact state DB optimized for EVM state; plans for future DA solutions.
Cross-Chain / Bridges	Chainlink CCIP/CCTP as canonical bridge; supports atomic swaps. SPN-to-SPN messaging.	Bridges (Wormhole, Axelar, IBC, etc.) allow asset/message transfer. Chainlink/Pyth for oracles.	Bridges via Axelar/Hop under development; on-chain oracles (Chainlink porting planned).	EVM bridges (e.g. AnySwap, Hop); uses Ethereum oracles (Chainlink) naturally.
Oracles & Data Feeds	Chainlink Data Streams (low-latency price feeds) integrated.	Chainlink, Pyth oracles available (used by DeFi apps).	Chainlink support (via host chain); data availability via Narwhal DAG.	Ethereum’s oracles (Chainlink, etc.) fully compatible.
Compliance / KYC	Integrated zk-KYC/AML at protocol layer; permissioned modules.	No built-in KYC. Compliance via analytics (Chainalysis KYT on Solana Dev. Platform).	None native; chain is permissionless. External tools only.	None native; permissionless.
Native Stablecoins	Upcoming: USDC via Circle CCTP; native CCTP token standard.	Yes – USDC, USDT issued on Solana; full USDC reserves.	Not yet (no major stable on Sui as of 2026).	Will inherit Ethereum stablecoin liquidity via bridges.
Programming Language	Solidity/Vyper (EVM) and Rust/Go/C++ (WASM).	Rust/C with BPF; on-chain programs compiled to BPF.	Move (Sui Move).	Solidity/Vyper (EVM), plus any Ethereum-compatible languages.
Developer Tools	Hardhat, Foundry, Truffle, JSON-RPC, GraphQL.	Anchor (Rust framework), Solana CLI, Lens/API, JSON-RPC.	Sui CLI, JSON-RPC, Sui Studio, Move Playground.	Remix, Hardhat, Foundry, ethers.js, web3.js, JSON-RPC (same as Ethereum).
Security (Decentralization)	PoS with planned 1000+ validators; restaking (EigenLayer) for shared security.	400 validators (solana labs + community). Recent diversification efforts (DoubleZero, Firedancer) enhance resilience.	100 validators (mainnet). Nakamoto distributed but young ecosystem.	Hundreds planned; open validator requirements (commodity hw).
Mainnet Launch	In development (testnet mid-2025; mainnet planned late 2025).	Mainnet since 2020.	Mainnet launched 2023.	Mainnet Nov 24, 2025.

Table: Comparison of key metrics and design features. (Sources in text above.)

Appendix: Technical Formulas and Benchmarks

• Byzantine Fault Tolerance (BFT) Threshold: Classical BFT consensus (PBFT/HotStuff) requires n ≥ 3f+1 total validators to tolerate f Byzantine faults. Finalization occurs once 2f+1 (≈⅔) votes agree on a block. For example, in Solana’s TowerBFT, each PoH hash is canonicalized after ⅔ of validators vote on it. MonadBFT similarly requires a supermajority but ensures that any “tail-forked” block (one supported by enough votes) is eventually reproposed.

• Consensus Complexity: MonadBFT and others achieve linear communication complexity in the happy path: one leader broadcasts a block to n validators, then each validator sends a vote to the next leader. Solana’s TowerBFT (pBFT variant) leverages PoH to encode timeouts, reducing the need for elaborate view-change messaging. Sui’s Narwhal/Tusk uses a DAG-based mempool: multiple parallel leaders (workers) can produce blocks whose headers form a DAG, yielding >130k TPS in wide-area benchmarks.

• Performance Benchmarks: In category testing, Pharos has demonstrated 30k TPS with 1s finality. In Sui’s April 2023 testnet evaluation, 100 validators with 24‑core machines achieved peaks of up to 297,000 TPS on simple workloads (though realistic heterogeneous workloads were lower). Solana’s mainnet data shows sustained 2k–4k TPS under load; theoretical limits on a gigabit network are >65k TPS. Monad’s targeted parameters (10k TPS, 0.3s blocks, 0.6s finality) have been validated in testnets and described in its docs.

• Finality vs. Latency: The reported “finality” times correspond to one round of protocol commit. Pharos and Monad target 1 block (<1s) to irreversible finality. Sui reports ≈480ms to finality. Solana’s economic finality is “near-instant” (often sub-second) once a vote is recorded, with full finality (the point of ⅔ lock-in) around 12–13s.

• Storage Efficiency: Pharos’s “80% lower storage overhead” claim comes from its delta-encoded multi-version Merkle tree combined with a versioned log-structured store. This means that only state changes (deltas) are stored between versions, greatly reducing disk usage.

• Gas and Fees: All chains use variants of Ethereum’s gas concept. Pharos follows EIP-1559 with a base fee (burned) and tip model, with a very high theoretical gas budget (2e9 gas/sec). Solana uses a flat fee per instruction (5,000 lamports) regardless of block utilization. Sui’s Move gas model weights by compute and storage usage. Monad’s gas pricing rebalances EVM opcode costs (e.g. making storage 1/300th of ETH’s cost) to reflect modern hardware.

Sources: Citations are given in brackets corresponding to official docs, research blogs, and whitepapers for each project (see linked references). Key references include Pharos’s testnet press release, Solana’s developer posts, Sui’s performance blog, and Monad’s official documentation and technical blog. These provide the quantitative and architectural details summarized above.

Conclusion

The comparison does not produce a single universal winner, because RealFi is not one workload. Solana remains particularly compelling for high-throughput financial markets where execution speed, deep liquidity, and a mature trading-oriented ecosystem matter most. Sui takes a different route, with its object-centric model offering an elegant fit for applications where individual assets, ownership, and transaction dependencies are central to the design. Monad is arguably one of the most interesting options for teams that want to preserve Ethereum’s EVM development environment while pushing much further into parallel execution and high-performance infrastructure. Pharos, meanwhile, is especially interesting when the starting point is RealFi itself: its architecture and ecosystem strategy are being developed around the requirements of tokenized assets, financial applications, and scalable on-chain settlement. The practical choice therefore depends less on which chain has the highest headline TPS and more on which architecture, liquidity environment, execution model, and interoperability stack best match a particular financial workload.

More importantly, the emergence of RealFi changes what we should expect from blockchains. Tokenized bonds, stablecoins, credit, funds, commodities, and other real-world assets are not simply another category of DeFi tokens. They introduce requirements closer to financial-market infrastructure: deterministic settlement, predictable latency, robust liquidity, reliable oracles, institutional-grade custody, compliance mechanisms, and the ability to move value across multiple networks. In that environment, raw throughput becomes only one variable in a much larger equation. The chains most likely to succeed in RealFi will be those that can combine performance with credible settlement, composability with risk controls, and technical scalability with actual economic liquidity. Solana, Sui, Monad, and Pharos are each approaching that problem from different architectural directions, and the next stage of competition will ultimately be decided not by benchmark charts alone, but by which of those architectures can support real financial activity at meaningful scale.