The RWA market has surged from roughly $1 billion in 2023 to over $27 billion as of March 2026. Yet current blockchain infrastructure still faces structural limitations in performance, compliance, and interoperability when it comes to handling institutional-grade financial assets. Pharos is a finance-focused Layer 1 blockchain designed to close this infrastructure gap.
Pharos defines its own framework called the "Degree of Parallelism" (DP), which maps the evolution of blockchain performance across stages from DP0 to DP5. While most high-performance blockchains today sit between DP2 and DP3, Pharos targets DP4 and beyond. To get there, it implements asynchronous BFT consensus where all validators propose blocks simultaneously, a dual VM supporting both EVM and WASM, a six-stage block processing pipeline for concurrent execution, and Pharos Store, which achieves up to 80% reduction in storage costs compared to conventional blockchain storage.
Pharos's SPNs (Special Processing Networks) are modular extension layers that share the security of the mainnet while independently handling workloads such as high-frequency trading, privacy computation, and AI inference. They can be read as a blockchain-native reimagining of the institutional specialization structure found in traditional finance.
Pharos has formed the RealFi Alliance with partners including Chainlink, LayerZero, and Centrifuge, building an ecosystem that spans from asset tokenization to distribution and settlement. It is also advancing real-world asset integration through a partnership with Hong Kong-listed GCL New Energy, covering energy revenue right tokenization, decentralized energy trading, and more.
The word "finance" derives from the Latin finis, meaning end, conclusion, completion. Passing through medieval French, it came to denote the "final settlement" of a monetary transaction, and later expanded into its modern sense of raising and managing capital.
At its core, finance is about bringing a transaction to its end: a state in which both parties can confirm that the promised asset has been transferred under the promised conditions at the promised time. That is settlement, and that is why finance exists.
Blockchain is a technology that declared it would guarantee that "end" through technical means. It is no coincidence that finality became a central design metric for blockchains. Once a transaction is confirmed, it cannot be reversed. No one's permission is required, and settlement is completed without intermediaries. In theory, blockchain is the technology best equipped to fulfill the etymological promise of finance.
But how does reality measure up? Nearly a decade has passed since blockchain declared its ambitions in finance, yet the experience of real-world assets actually settling on-chain remains extremely limited. The tokenized U.S. Treasury market has surpassed $10 billion, and BlackRock's BUIDL fund manages several billion dollars, but these are still small fragments relative to the scale of global financial markets. Projections that trillions of dollars in traditional financial assets could eventually move on-chain persist, but reality has not kept pace with expectations.
What does it take to solve this problem beyond simply issuing tokens? This article examines Pharos, a project that offers one concrete answer to that question.
The growth of the RWA (Real-World Assets) tokenization market is undeniable. Excluding stablecoins, the on-chain RWA market has grown from roughly $1 billion in early 2023 to over $27 billion as of March 2026. Tokenized U.S. Treasuries were the fastest-growing category, while private credit has become the largest segment by share.
Institutional activity is accelerating as well. JP Morgan's Kinexys platform processes over $2 billion in daily transactions. Robinhood has launched tokenized U.S. equities on Arbitrum for European users. BCG projects the tokenized RWA market to reach approximately $18.9 trillion by 2033.
On the surface, the numbers paint a bright future for RWA. But look behind them, and it becomes clear how much of the current growth depends on a specific set of conditions.
The areas where RWA tokenization has succeeded so far share common traits. Tokenized U.S. Treasuries have simple risk structures, well-established legal frameworks, and low regulatory complexity. The same goes for stablecoins. In other words, the successes to date have occurred with "the easiest assets to tokenize," not because blockchain is ready to absorb finance at large.
Handling more complex assets on-chain, such as real estate, private debt, structured products, and energy assets, exposes four structural bottlenecks that current infrastructure cannot easily overcome.
First, near-real-time processing speed and deterministic finality are essential. For institutional-grade financial transactions, the critical question is: "Exactly when is this trade finalized?" Transactions must be confirmed within one second (sub-second finality), and that speed must remain consistent even under network congestion. Most general-purpose blockchains today see fees spike and transactions queue up when traffic surges, with confirmation times varying unpredictably. If you cannot predict when a transaction will reach its "end," it is hard to call the system financial infrastructure.
Second, a data storage architecture capable of supporting billions of accounts and assets is needed. Existing blockchains, including Ethereum, suffer from "state bloat," where performance degrades as data accumulates. Think of it as a ledger that turns pages more slowly the thicker it gets. To manage assets at global financial scale, a new storage approach is needed, one that maintains performance regardless of how much data is stored.
Third, the system must flexibly accommodate differing regulatory and privacy requirements across institutions. On the same blockchain, KYC-mandated institutional asset pools and permissionless DeFi protocols must coexist. Satisfying both worlds within a single execution environment is inherently difficult.
Fourth, interoperability must be established to connect assets and liquidity scattered across chains. Most tokenized assets today remain trapped on the chain where they were issued. Capital fragmented across different blockchains reduces capital efficiency, and this is one of the key reasons institutional investors have been reluctant to enter on-chain finance.
These four points ultimately converge into a single observation: the conditions that blockchain must meet to guarantee finance's "end" have not yet been fulfilled.
Pharos starts from precisely this recognition. Rather than adding features on top of existing chains, its approach is to work backward from what finance requires and redesign each layer of consensus, execution, storage, and scalability from the ground up. That is why Pharos is building its own Layer 1 blockchain.
Pharos addresses each of the four conditions through distinct layers of the chain. Section 2 focuses on the first and second conditions: speed and scale.
Pharos positions itself as a modular & full-stack parallel L1. The network is composed of three layers.
L1-Base: The foundational layer responsible for data availability and hardware acceleration. In a blockchain, the question of "can every node access all data?" is a prerequisite for security and verifiability. L1-Base ensures this by optimizing at the hardware level. Since compromised data availability in financial infrastructure would make settlement verification impossible, this layer constitutes the physical foundation of the Pharos architecture.
L1-Core: The high-performance core layer where consensus, execution, and storage take place. The technical essence of Pharos, delivering sub-second finality and high throughput, is concentrated here.
L1-Extension: The modular extension layer built on top of L1-Core. The creation of SPNs (Special Processing Networks), interoperability between SPNs, and security sharing through native restaking all occur within this layer.
These three layers are each independently optimized while operating as a single unified network. The following sections first examine the technical responses to speed and scale that correspond to L1-Core.
To understand Pharos's technology, one must first understand the framework through which the team views the evolution of blockchain performance. Pharos defines performance stages from DP0 to DP5 using a concept it calls the "Degree of Parallelism" (DP).
DP0: The most basic model, processing transactions sequentially
DP1: Improved consensus mechanism scalability
DP2: Transaction-level parallel processing introduced
DP3: Pipelining added, significantly increasing throughput
DP4: Storage and Merkle verification are also processed concurrently, so performance is maintained even as data grows
DP5: Computational resources from diverse hardware, including GPUs, secure hardware (TEE), and zero-knowledge proof accelerators, are utilized simultaneously
According to Pharos, most high-performance blockchains today sit between DP2 and DP3. Pharos targets DP4 as its baseline in L1-Core and aims to reach DP5 through SPNs in L1-Extension. The following sections examine in greater detail how Pharos has achieved its implementation up to DP4.
2.3.1 A Fast and Flexible Consensus Mechanism
The first condition outlined in Section 1.2, the one finance demands of blockchain, was fast and predictable transaction finality. Transactions must be fast, predictable, and definitive.
The typical structure of existing blockchain consensus works as follows: in each round, one validator proposes a block, and the remaining validators vote on it. In this structure, the proposer becomes a bottleneck. If there are 100 validators, the single proposer must transmit the entire block data to all of them while the other 99 send only small vote messages, creating an asymmetric structure. As the number of validators grows, the proposer's burden increases, and block production speed hits a ceiling.
Pharos's consensus mechanism fundamentally changes this structure. The protocol is based on a paper presented at SOSP 2023, a top-tier conference in operating systems, and achieves two major improvements.
The first is the elimination of fixed wait times. Ethereum produces blocks every 12 seconds; Bitcoin, every 10 minutes. Pharos removes fixed intervals entirely. If the network is fast, blocks are produced accordingly; if slow, the system adjusts. Blocks are generated at the optimal timing based on actual network speed. With unnecessary waiting eliminated, processing speed converges toward the physical limits of the network.
The second is nonblocking communication, where all validators propose blocks simultaneously. The bottleneck of relying on a single proposer disappears, so as the number of validators grows, total network throughput scales with it. Previously, adding more validators meant degraded performance; Pharos inverts this tradeoff. Of course, when all validators submit blocks at once, new challenges arise around duplicate transaction handling and ordering between blocks. Pharos addresses these using a DAG (directed acyclic graph) structure.
Additionally, even if a geographically distant validator operates slowly due to network latency, the overall system does not slow down to match. This is thanks to a Flexible Advancement structure, where each node independently proposes blocks at its own pace. For a blockchain to serve as global financial infrastructure, validators must be distributed worldwide, making this property practically significant.
In addition to these structural improvements, Pharos implements a fast-path execution mechanism. Transactions that achieve early quorum agreement among validators can bypass the full consensus pipeline and enter the confirmation stage directly, without waiting for the remaining stages to complete. This effectively creates a shortcut within the consensus process: routine, non-contentious transactions, which make up the majority of financial operations, are settled at significantly lower latency, while more complex or contested transactions still go through the complete consensus flow.
This mechanism has direct implications for the staged finality model that will be described in section 2.3.3. For instance, in high-frequency trading scenarios where microsecond-level ordering is critical, fast-path transactions can reach ordering finality almost immediately. Meanwhile, regulatory settlement requiring full block-level guarantees proceeds through the standard pipeline. By combining a fast path with staged finality, Pharos allows different classes of financial transactions to find their optimal trade-off between speed and completeness of confirmation within the same network.
The Pharos team reports achieving over 130,000 transactions per second on a global testnet of 100 nodes, with production targets of 50,000 TPS and sub-second finality.
2.3.2 Block Processing Pipelining
On top of this, Pharos pipelines the entire block processing flow. Completing a single block requires six stages: transaction ordering, execution, data retrieval, Merkle hash generation for tamper prevention, block assembly, and final storage. Conventional blockchains perform these stages sequentially, one block at a time.
Pharos reorganizes this process like a factory assembly line. While block A is being executed, the Merkle hash for an earlier block B is being generated, and at the same time the ordering for the next block C is being finalized. Different stages of different blocks proceed in parallel. Because the resources responsible for each stage operate without idle time, the number of blocks that can be processed per unit of time increases substantially.
Naturally, processing multiple blocks concurrently carries the risk of breaking data consistency. Common issues include one block referencing intermediate results from another block that has not yet been finalized, or a value changing between two reads of the same state. Pharos prevents this by separating disk-intensive operations from compute-intensive operations within each stage and strictly blocking access to uncommitted data. Multiple blocks flow through the pipeline simultaneously, but the correctness of results is guaranteed to be identical to sequential, single-block processing.
2.3.3 Staged Separation of Finality
From a financial perspective, a particularly noteworthy aspect is that Pharos divides transaction finality into three stages.
Ordering Finality: The point at which the processing order of transactions is determined. After this, the same order is guaranteed regardless of which node executes them.
Transaction Finality: The point at which the execution result of a transaction is confirmed. Users can immediately check changes to their balances.
Block Finality: The point at which the entire block is completed. Infrastructure such as oracles (external data providers) and data indexers can now access complete block information.
The reason for this separation is that different use cases require different levels of "finality." For ultra-high-speed trading, ordering confirmation alone is sufficient. For asset settlement, full block-level finality is necessary. A DeFi exchange can give users immediate feedback with just transaction finality. This staged design can be interpreted as an architectural reflection of the diverse requirements of finance.
The second condition is a scalable execution and storage architecture that can accommodate massive numbers of accounts and assets. Even if transactions are confirmed quickly, the system is unsuitable as financial infrastructure if performance degrades as it scales.
2.4.1 Execution: DTVM Stack and Compiler-Level Optimization
Pharos adopts a dual VM architecture that simultaneously supports EVM, the most widely used execution engine today, and WASM, which is gaining traction as a next-generation standard.
This is not simply running two VMs side by side. DTVM (DeTerministic Virtual Machine), Pharos's core execution engine, uses a unified intermediate language called dMIR. Whether code is written for EVM or WASM, it is first compiled into this common intermediate representation, on top of which various optimizations are applied uniformly. This design is built on the LLVM/MLIR framework, a widely used approach in compiler technology.
Thanks to this architecture, EVM compatibility is not mere interpreter-level emulation but high-performance execution refined through compiler-level optimization. According to Pharos's benchmarks, major Ethereum standard contracts such as ERC-20, ERC-721, and ERC-1155 showed up to 2x performance improvement over evmone, compute-intensive workloads (Fibonacci) showed 3.6x improvement, and JIT mode achieved over 58x improvement compared to the interpreter.
There is one more property that is especially important in the context of handling financial assets: deterministic execution. This means that running the same transaction on any node must always produce the same result. Standard WASM runtimes can introduce subtle differences in floating-point calculations, memory layout ordering, and other areas. DTVM eliminates such non-determinism at the intermediate language (dMIR) stage. If the balance of a financial asset were calculated even one cent differently across nodes, the consequences would be severe. This property is a fundamental requirement for financial infrastructure.
DTVM supports six frontend languages: Solidity, C/C++, Rust, Java, Go, and AssemblyScript. It maintains compatibility with the Ethereum ecosystem while providing an environment where institutional developers can write high-performance smart contracts using existing system code and libraries. DTVM also supports cross-calls between the two VMs, so developers can choose the optimal tool for each situation.
2.4.2 Parallel Scheduling: SALI and Hybrid Execution
The core challenge of parallel execution on a blockchain is determining "which transactions can safely be processed simultaneously." For example, a transfer from A to B and a transfer from C to D are independent and can run concurrently. But a transfer from A to B and a transfer from B to C both touch B's balance, so order matters.
Pharos addresses this with a technique called SALI (Smart Access List Inference). SALI analyzes smart contract code in advance to predict which data each transaction will read and write. Based on this prediction ("parallelism hints"), transactions with no conflicts are sorted into optimal groups and executed concurrently.
Since static analysis cannot be 100% accurate, Pharos also employs optimistic execution. Transactions are executed first, and only those where actual conflicts are detected are re-executed at minimal cost. By using static analysis to avoid most conflicts upfront and handling the remainder after the fact, this hybrid approach minimizes re-execution overhead.
2.4.3 Storage: Pharos Store (LETUS)
The centerpiece of Pharos's storage architecture is Pharos Store. Its storage engine, LETUS, is based on a paper published at ACM SIGMOD 2024, a top-tier database conference. It has been validated in production at Ant Group's AntChain, where it reduced storage costs by approximately 75%.
Most blockchains, including Ethereum, use a two-tier structure: a Merkle tree for verifying data integrity and a key-value database (based on LSM trees) for storing the actual data. Reading a single value requires traversing multiple layers of the Merkle tree, with each layer potentially requiring multiple disk reads from the database. In Ethereum, reading a single value can require 8 to 10 disk accesses. As data accumulates, this inefficiency compounds and degrades performance.
Pharos Store solves these problems by dismantling the conventional two-tier structure entirely and adopting a single-layer architecture. Internally, it consists of three components.
DMM-Tree: The Merkle tree is embedded directly inside the storage engine, so it can point directly to data locations. Combined with a delta encoding approach that records only changes, it further reduces storage consumption. Disk accesses drop from 8–10 to 1–3.
LSVPS: Incrementally records data changes and periodically generates full snapshots, maintaining read performance.
VDLS: Stores data in an append-only log structure, ensuring tamper resistance and data integrity.
On top of this, a version-based addressing scheme replaces the conventional hash-based addressing. Since blockchain data has a continuously incrementing block number (version), storing it in that order eliminates the compaction operations required by traditional approaches. In its own benchmarks, Pharos reports up to 15.8x throughput improvement and 80.3% reduction in storage costs compared to conventional architectures.
The previous sections examined how Pharos addresses the issues of speed and scale. But the conditions for financial infrastructure do not end there. An execution environment that can flexibly accommodate differing regulations and privacy requirements across institutions: that is the third condition.
Real-world finance does not operate in a single environment.
KYC/AML regulations differ from country to country.
Trading rules vary by asset class.
The level of privacy required varies with the nature of the institution.
The "end" that high-frequency trading requires is microsecond-level order confirmation. The "end" that an institutional RWA pool requires is regulatory-compliant settlement among KYC-verified participants. The "end" that privacy computation requires is a state that proves the result is valid without revealing the input data. Accommodating all these types of "end" optimally within a single execution environment is inherently difficult.
Previous approaches fell broadly into two categories: creating independent chains like Avalanche's Subnets, or operating sovereign chains connected via IBC, as in the Cosmos app-chain model. The former carries the burden of bootstrapping its own security, while the latter limits cross-chain communication to simple message passing, making it difficult to guarantee atomic processing of complex transactions (where everything either succeeds or fails entirely).
Pharos's SPNs offer a distinct solution that sits between these two approaches. SPNs are execution environments tightly integrated with the Pharos mainnet, yet each possesses its own independent execution engine, validator set, and governance rules. Each SPN can be thought of as a dedicated space optimized for settling a different type of "end." This structure is implemented within the L1-Extension layer described earlier.
Source: Pharos
Understanding the SPN structure requires familiarity with the three types of nodes in the Pharos network.
Validator nodes: Core nodes that participate in consensus to produce and verify blocks. They operate at a scale of several hundred.
Full nodes: Store all blocks and state but do not participate directly in consensus. They provide fast data synchronization to other nodes and supply analysis information (SALI hints) to validators for parallel processing.
Relayer nodes: Lightweight nodes that retain only the latest state, can participate with lower hardware requirements, and handle message passing between SPNs.
The key differentiator of SPNs is their "shared security" model. Validators on the Pharos mainnet stake Pharos coin to secure the mainnet, and re-staked into SPNs. Each SPN sets its own requirements for validator count, hardware specifications, and other parameters; once these conditions are met, the mainnet automatically creates the SPN.
What is particularly noteworthy is that Pharos's restaking is not confined to internal use. Pharos is designed to interoperate with external restaking protocols such as Babylon and EigenCloud through its own restaking interaction protocol. This means that external assets like stBTC and stETH can circulate within the Pharos ecosystem, opening up the structural possibility for Pharos to leverage not only its own economic security but also the security of the Bitcoin and Ethereum networks.
Under this structure, SPNs operate independently but inherit the economic security of the mainnet. If a validator acts maliciously, their re-staked assets are slashed, eliminating the need to build a separate security system from scratch.
Communication between SPNs is handled through a mailbox-based messaging framework. When a message is recorded on the originating SPN, validators' consensus signatures are attached. The destination SPN verifies these signatures before processing the message. Relayer nodes efficiently relay this process, enabling trustless inter-network communication. This communication supports not only simple message passing but also atomic execution, data sharing, and cross-calls between different VMs.
The flexibility of SPNs enables responses to a wide range of financial workloads. A few concrete forms include:
TEE (Trusted Execution Environment) SPN: Uses hardware-level security modules to ensure transaction confidentiality and prevent MEV (the practice of validators manipulating transaction ordering for profit).
ZK (Zero-Knowledge Proof) SPN: Handles regulatory compliance verification based on zero-knowledge proofs, which prove that "this condition is met" without revealing the actual data.
FHE (Fully Homomorphic Encryption) SPN: Leverages homomorphic encryption, which enables computation on data while it remains encrypted. For example, it can perform transfer operations on encrypted balances and finalize the results without decryption. For financial computations where inter-institutional privacy is of utmost importance, such as multi-party portfolio valuation or credit scoring, an FHE SPN can play a role complementary to ZK SPNs.
GPU SPN: Runs AI model inference or large-scale data analysis directly within a blockchain environment.
Beyond these, various other forms are possible, including IoT private networks, multi-party privacy computation (MPC), and lightweight networks for oracles or data storage.
If the modular architecture of SPNs is a design for accommodating "internal diversity," the Decentralized Data Exchange Protocol is a design for "connecting with the outside world." Positioned within Pharos's Data Layer, this protocol enables synchronization and collaboration with external data centers.
The importance of external data in finance cannot be overstated. Most of the data that forms the basis of financial transactions, including asset prices, interest rates, exchange rates, credit ratings, corporate financial information, exists outside the blockchain. Existing oracle networks have been filling this gap, but Pharos aims to provide structured integration with external data sources at the protocol level, thereby more directly supporting advanced onchain use cases such as AI inference and FHE computation.
The structure of SPNs bears a resemblance to the structure of traditional finance. Over centuries, traditional finance has differentiated its functions into exchanges, clearinghouses, custodians, and settlement institutions. Each operates under different regulations and uses different technologies, yet they are all connected as a single financial system through shared legal frameworks and settlement infrastructure.
SPNs can be interpreted as a blockchain replication of this structure. Each SPN handles a specialized financial function while sharing the mainnet's security and settlement infrastructure. This is, in effect, a programmable reimplementation of the institutional specialization found in traditional finance.
The preceding sections examined how Pharos technically addresses three conditions: speed, scale, and flexible regulatory accommodation. But the fourth condition, connecting fragmented assets and liquidity, cannot be solved by technology alone. No matter how fast and flexible a chain may be, if there are no assets circulating on it and the participants connecting issuance, trading, and settlement are scattered across disparate standards, finance's "end" remains incomplete. Pharos responds to this final condition through ecosystem building.
RealFi is a core concept originally introduced by Pharos, representing a broader paradigm than conventional RWA tokenization and signaling a systemic evolution of onchain finance. Rather than focusing solely on bringing assets onchain, RealFi addresses the full lifecycle of real-world assets within a blockchain-based financial system; from issuance and verification to circulation and value creation. Pharos argues that the mere presence of assets on-chain is insufficient; what matters is whether these assets can be credibly verified, compliantly structured, and actively utilized within a composable financial environment.
Within this framework, RealFi extends beyond tokenization itself and is underpinned by three foundational capabilities:
Verified and compliant asset representation: ensuring that tokenized assets are credibly linked to real-world value through enforceable legal structures and transparent validation mechanisms;
Composability and capital efficiency: enabling assets to be actively traded, collateralized, and integrated across protocols to generate new financial products with meaningful yield and risk pricing;
Global accessibility and distribution: connecting real-world assets to a broader base of onchain participants, allowing capital to flow more efficiently across geographies and user segments.
In essence, RealFi is not just about putting real-world assets onchain, but about transforming them into productive, interoperable financial primitives that can circulate within a unified onchain system and generate sustainable, real economic value.
The most fundamental prerequisite for institutional capital to enter on-chain is regulatory compliance. On most blockchains, KYC/AML is handled individually by each application. This approach results in inconsistent standards across apps and confusion arising from conflicting requirements across jurisdictions.
Pharos takes a different approach by embedding a ZK-KYC/AML module at the protocol level. ZK-based KYC allows verification on-chain that "this user meets regulatory requirements" without revealing the user's actual identity information.
This is where the connection to SPNs, described earlier, becomes important. KYC verification itself can be processed in a dedicated zero-knowledge proof SPN, so institutional compliance requirements can be met without compromising the mainnet's open nature. Pursuing both openness and compliance, two values that appear to be in tension, through the modular architecture of SPNs is central to Pharos's design philosophy.
Source: Pharos
The most notable strategic move Pharos has made to realize its vision is the formation of the RealFi Alliance. In February 2026, Pharos officially launched the RealFi Alliance together with Chainlink, LayerZero, Centrifuge, Asseto Finance, Ember, Faroo, R25, Re7 Labs, and TopNod.
The RealFi Alliance operates around four pillars.
Asset Enablement: Bringing real-world assets on-chain in secure, composable form
Infrastructure & Compliance Alignment: Leveraging Pharos's parallel execution and embedded compliance modules to meet institutional-grade security standards
Liquidity & Utility Design: Enabling tokenized assets to be utilized across diverse use cases and traded near their market value
Market Transparency: Allowing participants to accurately assess risk
Source: Pharos
In March 2026, an Intelligence Partner Cohort was added, featuring participants from research, data, and institutional infrastructure, including Dune, Four Pillars, Web3Caff Research, Anchorage Digital, and Alchemy. These partners plan to co-develop a standardized RealFi research framework to establish on-chain data standards for measuring RWA performance, risk, and compliance.
Source: Pharos
The most notable concrete example of RealFi in practice is the strategic partnership with GCL New Energy. A company listed on the Hong Kong Stock Exchange, GCL New Energy confirmed its investment in Pharos at an approximately $1 billion valuation in March 2026. The fact that this transaction went through the Hong Kong Stock Exchange's regulatory disclosure process distinguishes it from typical intra-crypto fundraising.
Understanding the specific context of this partnership requires familiarity with GCL's business strategy. GCL New Energy is a Chinese smart energy solutions company that started with solar power plant operations and now pursues a "Power-Compute Integration" strategy combining AI computing with energy infrastructure. With data center power demand surging, the company is adopting a vertically integrated model in which an energy producer directly operates computing infrastructure.
The collaboration with Pharos spans three areas: energy revenue right tokenization (tokenizing future revenue from power plants for financing), decentralized energy trading (settling peer-to-peer energy transactions on blockchain), and carbon footprint tracking (transparent issuance and distribution of renewable energy certificates). Energy asset tokenization, in particular, is a representative case of what Pharos calls "bringing complex assets on-chain," and the modular structure of SPNs can be applied to accommodate the specialized regulatory requirements of energy trading.
Source: Centrifuge
Another significant partnership is the collaboration with Centrifuge. Centrifuge is a protocol that has been tokenizing institutional-grade real-world assets on-chain since 2017 and was the first to supply real-world asset collateral to MakerDAO's RWA vaults. It has a track record of tokenizing assets worth hundreds of millions of dollars.
The collaboration focuses on building infrastructure to distribute tokenized U.S. Treasuries (JTRSY) and AAA-rated credit products, among other real-world assets, through the Pharos network. This demonstrates Pharos's intention to implement the entire financial value chain, from asset issuance through distribution and settlement, on its own infrastructure.
In the blockchain industry, positioning as "a chain for X" has been a recurring theme: chains for gaming, chains for AI, chains for social. Most were effectively general-purpose chains with domain-specific tools layered on top. Where Pharos's claim to be a "finance-focused L1" may differ from previous attempts lies in the fact that every layer of the chain, from consensus to storage, was reverse-engineered from the requirements of finance; that its core technologies are grounded in research validated at top-tier academic conferences; and that compliance is embedded at the protocol level.
Of course, whether this actually works can only be verified after mainnet launch. Testnet performance has been encouraging, but performance under the pressure of real financial transactions is a different matter. What matters in financial infrastructure is not peak performance but consistent performance: the assurance that settlement delays will not occur even when traffic spikes. Proving this under live conditions remains the challenge ahead for Pharos.
The SPN model is the most compelling part of Pharos's architecture. If it truly replicates the institutional specialization of traditional finance, where trade execution, clearing, custody, and settlement are handled by different entities linked through shared infrastructure, its value extends beyond that of a mere scalability solution.
However, for this model to work in practice, several prerequisites must be met. Enough validators must re-stake into SPNs, the economic incentives of each SPN must be sustainable, and message passing speed between SPNs must meet the demands of financial use cases. Validator re-staking participation, in particular, depends directly on the initial circulating supply of Pharos reward structure, and this too can only be substantively validated after mainnet launch.
Let us return to the opening of this article. Finance is, at its core, the confirmation that a promised asset has been transferred under promised conditions. The word's origin in finis, meaning "end," reflects precisely this.
Pharos has identified what the conditions for that finality are and designed its chain by working backward from them. Sub-second finality-based consensus and storage with scalability to support billions of accounts have been validated in academia. Deterministic execution through DTVM delivers compiler-level performance. And the modular architecture of SPNs enables different financial workloads, each demanding different types of finality, to be served in individually optimized environments.
Yet infrastructure sophistication is a necessary condition, not a sufficient one. What Pharos must ultimately prove is not how many TPS the chain can handle or how many seconds finality takes, but whether the infrastructure can deliver the experience of real financial transactions reaching completion. The path Pharos has chosen, simultaneously achieving permissionless openness and institutional-grade compliance, is both the most ambitious and the most difficult to prove.
RealFi must be proven by results, not technology. Pharos's journey is only beginning.
Dive into 'Narratives' that will be important in the next year
Solana
EthereumEthereum
Pharos