Pharos Network's Q1 2026 Mainnet: How Ant Group's Blockchain Veterans Are Building the $10 Trillion RealFi Layer
When former Ant Group CTO Alex Zhang and his blockchain engineering team left the company in July 2024, they didn't join another fintech giant. They built Pharos Network—a Layer-1 blockchain targeting the convergence of traditional finance and DeFi with a singular focus: unlocking the $10 trillion real-world asset (RWA) market projected for 2030.
Pharos isn't another EVM clone promising marginally faster transactions. It's a purpose-built infrastructure for "RealFi" (Real-World Finance)—blockchain systems directly tied to tangible assets like private credit, tokenized treasuries, real estate, and corporate bonds. The technical foundation: 30,000 TPS with sub-second finality, powered by Smart Access List Inferring (SALI)—a novel parallel execution engine that statically or dynamically infers state access patterns to execute disjoint transactions simultaneously.
With $8 million in seed funding from Lightspeed Faction and Hack VC, a $10 million RealFi incubator backed by Draper Dragon, and a Q1 2026 mainnet launch on the horizon, Pharos represents a bet that institutional finance's migration on-chain won't happen on Ethereum's L2s or Solana's high-speed infrastructure—it'll happen on a compliance-first, RWA-optimized chain designed by the team that built Ant Chain, the blockchain powering Alibaba's $2+ trillion annual GMV.
The RealFi Thesis: Why $10 Trillion Moves On-Chain by 2030
RealFi isn't crypto speculation—it's the tokenization of finance itself. The sector currently stands at $17.6 billion, with projections reaching $10 trillion by 2030—a 54× growth multiplier. Two forces drive this:
Private credit tokenization: Traditional private credit markets (loans to mid-market companies, real estate financing, asset-backed lending) are opaque, illiquid, and accessible only to accredited institutions. Tokenization transforms these into programmable, 24/7 tradeable instruments. Investors can fractionalize exposure, exit positions instantly, and automate yield distribution via smart contracts. Over 90% of RWA growth in 2025 came from private credit.
Tokenized treasuries and institutional liquidity: Stablecoins unlocked $300 billion in on-chain liquidity, but they're just USD-backed IOUs. Tokenized U.S. Treasuries (like BlackRock's BUIDL fund) bring yield-bearing government debt on-chain. Institutions can collateralize DeFi positions with AAA-rated assets, earn risk-free returns, and settle trades in minutes instead of T+2. This is the bridge bringing institutional capital—pension funds, endowments, sovereign wealth—to blockchain.
The bottleneck? Existing chains aren't designed for RWA workflows. Ethereum's base layer is too slow and expensive for high-frequency trading. Solana lacks built-in compliance primitives. L2s fragment liquidity. RWA applications need:
- Sub-second finality for real-time settlement (matching TradFi expectations)
- Parallel execution to handle thousands of concurrent asset transfers without congestion
- Modular compliance allowing permissioned assets (e.g., accredited-investor-only bonds) to coexist with permissionless DeFi
- Interoperability with legacy financial rails (SWIFT, ACH, securities depositories)
Pharos was architected from day one to satisfy these requirements. The team's experience tokenizing real assets at Ant Group—projects like Xiexin Energy Technology and Langxin Group RWA—informed every design decision.
SALI: Rethinking Parallel Execution for Financial Markets
Blockchains struggle with parallelization because transactions often conflict—two transfers touching the same account can't execute simultaneously without causing double-spends or inconsistent state. Traditional chains serialize conflicting transactions, creating bottlenecks.
Pharos solves this with Smart Access List Inferring (SALI)—a method to statically or dynamically infer which state entries a contract will access, allowing the execution engine to group transactions with disjoint access patterns and execute them in parallel without conflicts.
Here's how SALI works:
Static analysis (compile-time inference): For standard ERC-20 transfers, the smart contract's logic is deterministic. A transfer from Alice to Bob only touches balances[Alice] and balances[Bob]. SALI analyzes the contract code before execution and generates an access list: [Alice's balance, Bob's balance]. If another transaction touches Carol and Dave, those two transfers run in parallel—no conflict.
Dynamic inference (runtime profiling): Complex contracts (like AMM pools or lending protocols) have state access patterns that depend on runtime data. SALI uses speculative execution: tentatively run the transaction, record which storage slots were accessed, then retry in parallel if conflicts are detected. This is similar to optimistic concurrency control in databases.
Conflict resolution and transaction ordering: When conflicts arise (e.g., two users swapping in the same Uniswap-style pool), SALI falls back to serial execution for conflicting transactions while still parallelizing non-overlapping ones. This is dramatically more efficient than serializing everything.
The result: 30,000 TPS with sub-second finality. For context, Ethereum processes ~15 TPS (base layer), Solana peaks at ~65,000 TPS but lacks EVM compatibility, and most EVM L2s top out at 2,000-5,000 TPS. Pharos matches Solana's speed while maintaining EVM compatibility—critical for institutional adoption, since most DeFi infrastructure (Aave, Uniswap, Curve) is EVM-native.
SALI's edge becomes clear in RWA use cases:
- Tokenized bond trading: A corporate bond issuance might involve thousands of simultaneous buys/sells across different tranches. SALI parallelizes trades in tranche A while executing tranche B trades concurrently—no waiting for sequential settlement.
- Automated portfolio rebalancing: A DAO managing a diversified RWA portfolio (real estate, commodities, private credit) can execute rebalancing across 20+ assets simultaneously, instead of batching transactions.
- Cross-border payments: Pharos can settle hundreds of international transfers in parallel, each touching different sender-receiver pairs, without blockchain congestion delaying finality.
This isn't theoretical. Ant Chain processed over 1 billion transactions annually for Alibaba's supply chain finance and cross-border trade settlement. The Pharos team brings that battle-tested execution expertise to public blockchain.
Dual VM Architecture: EVM + WASM for Maximum Compatibility
Pharos supports both the Ethereum Virtual Machine (EVM) and WebAssembly (WASM)—a dual-VM architecture enabling developers to deploy Solidity contracts (EVM) or high-performance Rust/C++ contracts (WASM) on the same chain.
Why does this matter for RWA?
EVM compatibility attracts existing DeFi ecosystems: Most institutional DeFi integrations (Aave institutional lending, Uniswap liquidity pools, Compound borrowing) run on Solidity. If Pharos forced developers to rewrite contracts in a new language, adoption would stall. By supporting EVM, Pharos inherits the entire Ethereum tooling ecosystem—MetaMask, Etherscan-style explorers, Hardhat deployment scripts.
WASM enables performance-critical financial applications: High-frequency trading bots, algorithmic market makers, and real-time risk engines need lower-level control than Solidity provides. WASM compiles to near-native machine code, offering 10-100× speed improvements over EVM bytecode for compute-intensive tasks. Institutional traders deploying sophisticated strategies can optimize execution in Rust while still interoperating with EVM-based liquidity.
Modular compliance via WASM contracts: Financial regulations vary by jurisdiction (SEC rules differ from MiCA, which differs from Hong Kong's SFC). Pharos allows compliance logic—KYC checks, accredited investor verification, geographic restrictions—to be implemented as WASM modules that plug into EVM contracts. A tokenized bond can enforce "only U.S. accredited investors" without hardcoding compliance into every DeFi protocol.
This dual-VM design mirrors Polkadot's approach but optimized for finance. Where Polkadot targets general-purpose cross-chain interoperability, Pharos targets RWA-specific workflows: custody integrations, settlement finality guarantees, and regulatory reporting.
Modular Architecture: Application-Specific Networks (SPNs)
Pharos introduces Subnet-like Partitioned Networks (SPNs)—application-specific chains that integrate tightly with the Pharos mainnet while operating independently. Each SPN has:
- Its own execution engine (EVM or WASM)
- Its own validator set (for permissioned assets requiring approved node operators)
- Its own restaking incentives (validators can earn rewards from both mainnet and SPN fees)
- Its own governance (token-weighted voting or DAO-based decision-making)
SPNs solve a critical RWA problem: regulatory isolation. A tokenized U.S. Treasury fund requires SEC compliance—only accredited investors, no privacy coins, full AML/KYC. But permissionless DeFi (like a public Uniswap fork) can't enforce those rules. If both run on the same monolithic chain, compliance leakage occurs—a user could trade a regulated asset into a non-compliant protocol.
Pharos's SPN model allows:
Permissioned SPN for regulated assets: The tokenized Treasury SPN has a whitelist of validators (e.g., Coinbase Custody, Fireblocks, BitGo). Only KYC-verified wallets can transact. The SPN's governance is controlled by the asset issuer (e.g., BlackRock) and regulators.
Permissionless mainnet for public DeFi: The Pharos mainnet remains open—anyone can deploy contracts, trade tokens, or provide liquidity. No KYC required.
Bridge between SPNs and mainnet: A regulated SPN can expose specific assets (e.g., yield-bearing stablecoins collateralized by Treasuries) to the mainnet via a compliance-checked bridge. This enables capital efficiency: institutions bring liquidity from the permissioned world into permissionless DeFi, but only through audited, regulated pathways.
This architecture mirrors Cosmos's app-chains but with financial compliance baked in. Avalanche's subnets offer similar isolation, but Pharos adds restaking incentives—validators secure both mainnet and SPNs, earning compounded rewards. This economic alignment ensures robust security for high-value RWA applications.
The $10 Million RealFi Incubator: Building the Application Layer
Infrastructure alone doesn't drive adoption—applications do. Pharos launched "Native to Pharos", a $10+ million incubator backed by Draper Dragon, Lightspeed Faction, Hack VC, and Centrifuge. The program targets early-stage teams building RWA-focused DeFi applications, with priority given to projects leveraging:
Deep parallel execution: Applications exploiting SALI's throughput—like high-frequency trading desks, automated portfolio managers, or real-time settlement layers.
Modular compliance design: Tools integrating Pharos's SPN architecture for regulatory-compliant asset issuance—think bond platforms requiring accredited investor verification.
Cross-border payment infrastructure: Stablecoin rails, remittance protocols, or merchant settlement systems using Pharos's sub-second finality.
The inaugural cohort's focus areas reveal Pharos's thesis:
Tokenized private credit: Platforms enabling fractional ownership of corporate loans, real estate mortgages, or trade finance. This is where 90% of RWA growth occurred in 2025—Pharos wants to own this vertical.
Institutional DeFi primitives: Lending protocols for RWA collateral (e.g., borrow against tokenized Treasuries), derivatives markets for commodities, or liquidity pools for corporate bonds.
Compliance-as-a-Service (CaaS): Middleware enabling other chains to plug into Pharos's compliance infrastructure—think Chainalysis for AML, but on-chain and cryptographically verifiable.
Centrifuge's participation is strategic—they pioneered on-chain private credit with $500+ million in assets financed. Integrating Centrifuge's credit infrastructure with Pharos's high-throughput execution creates a formidable RealFi stack.