The data suggests a quiet but profound shift. According to a UBS report, the aggregate market capitalization of pure AI infrastructure stocks—GPU manufacturers, data center operators, energy suppliers—has surpassed that of the traditional hyperscaler oligopoly (AWS, Azure, GCP). This is not a quarterly fluctuation. It is a structural re-rating of where capital assigns value: away from platform abstraction and toward raw compute capacity. For the cryptocurrency space, this signal carries a double-edged implication. It validates the DePIN (Decentralized Physical Infrastructure Networks) narrative, yet it also introduces a capital allocation threat to the financial infrastructure layer—specifically, layer-2 rollups that have been designed for DeFi and NFTs but now face a demand side that cares less about composability and more about verifiable compute attestation. Tracing the gas cost anomaly back to the EVM, one finds that the bottleneck is not the L1 itself but the cost of proving that a piece of computation occurred correctly. This is where L2s must pivot or become irrelevant.
Context
The UBS report explicitly states: 'The rise of AI infrastructure equities has eclipsed the hyperscalers.' The implication is that investors now view the physical substrate of AI—chips, power, cooling, fiber—as more valuable than the cloud operating systems that sit on top. This parallels a debate inside blockchain circles between base layer and middleware. But the report goes further: it ties this pivot to broader asset tokenization. 'This structural shift will influence energy demand, crypto markets, and the tokenization of real-world assets.' In plain terms, the same capital flows that push NVIDIA's PE ratio to 50x are also searching for derivative exposure—tokenized compute credits, carbon offsets from AI data centers, and proof-of-work energy hedging.
For L2 research leads like myself, the immediate question is: which rollup architecture can actually settle tokenized compute efficiently? Traditional DeFi trades are simple state transitions. A swap, a borrow, a liquidation. Compute tokenization, by contrast, requires on-chain verification of off-chain GPU execution. An AI model inference must be proven to have run correctly before the payment in tokens is released. This is a fundamentally different workload. The gas cost of verifying a single ZK-SNARK proof of a 1000-step neural network forward pass is non-trivial. On Ethereum L1, the cost can exceed $50 per proof at 50 gwei. On a well-designed L2, that cost can drop below $1. But only if the L2’s state accumulator and proof aggregation handle the math efficiently.
Core Analysis
Tracing the gas cost anomaly back to the EVM reveals the first constraint. The EVM was designed for simple arithmetic and storage operations. Verifying a Groth16 proof on-chain consumes approximately 600,000 gas for pairings alone. For a DePIN marketplace processing 10,000 AI job completions per hour, that is 6 billion gas per hour—impossible on Ethereum L1. L2s reduce this by batching proofs, but they must also support non-native precompiles for curve operations. The OP Stack, with its fraud proof delay of 7 days, is unsuitable for instant settlement of compute jobs. A user who runs an inference on a decentralized GPU network does not want to wait a week for a challenge period. ZK Stack rollups, by contrast, offer immediate finality via validity proofs. However, the computational overhead of generating those proofs on the L2 itself—if the L2 is a general-purpose EVM—remains high.
In my 2020 fraud proof research on Optimistic L2s, I simulated malicious state root submissions and found that even with a 7-day window, a sophisticated attacker could extract value from time-sensitive compute markets. The same logic applies here. If the L2 cannot finalize a proof within seconds, the trust model breaks for real-time GPU markets. The math doesn't lie, but the implementation does. Most current ZK-rollup implementations sacrifice L1 compatibility for speed. The result is a fragmented environment where a DePIN dApp must choose between accuracy (OP, long finality) and velocity (ZK, but custom tooling).
Disassembling the economic incentive back to block space—the second signature of this analysis—shows a deeper problem. L2 revenue models today rely on sequencer fees from user transactions. A compute tokenization market would generate high transaction volumes but low fee per transaction if the proofs are batched efficiently. That creates a misalignment: the L2 token holders want high fees; the compute protocol wants low fees. Without a native compute attestation token or a fee market that separates L2 settlement from compute verification, the L2 may cannibalize its own network value.
Tokenization of GPU Cycles
Let us assume a DePIN project like Render Network or Akash decides to move its settlement to an L2. The dApp would issue an ERC-20 token representing 1 millisecond of GPU time on a specific node. To enforce trust, the node must submit a ZK proof that the computation was executed correctly. That proof, once verified on the L2, releases the payment. This creates a closed loop. For the L2, the value capture is in the settlement fees. But the real economic value—the compute itself—remains off-chain. This mirrors the RWA tokenization debate: are we tokenizing the asset or merely the claim to the asset?
From my line-by-line audit of the ERC-721A mint function in 2021, I learned that subtle integer overflows can break entire markets. Similarly, if the ZK proof verification contract on an L2 has a rounding error in the pairing check, an adversary could forge proofs of infinite compute. This is not a theoretical risk. In my prototype of the Proof-of-Inference consensus model in 2024, I integrated a TensorFlow model with a Polygon sidechain and found that even mature ZK libraries had edge cases where proof verification passed for incorrect inputs due to mismatched field modulus. The lesson: security of compute tokenization depends on the L2’s ability to securely aggregate and verify proofs at scale, which is a non-trivial distributed systems problem.
Cost Model Comparison
| Metric | OP Stack (Optimistic) | ZK Stack (Validity) | |--------|----------------------|--------------------| | Finality | ~7 days (challenge period) | minutes (proof generation + verification) | | Gas per verification on L1 (equivalent to batch of 100 proofs) | 200,000 (to post fraud proof) | 6 million (verify 100 aggregated proofs) | | Suitability for real-time compute | Low | Medium-high | | Developer onboarding | High (EVM equivalence) | Medium (requires custom circuits) |
The table shows that ZK Stack wins on finality but loses on gas per batch for high-volume verifications. However, the gap can be closed with proof recursion: a L2 can verify multiple proofs in one aggregated proof using a recursive SNARK. In my 2022 retreat in Prague, I spent eight months implementing a Groth16 prover in Rust and learned that recursive proof aggregation adds latency proportional to the depth of the recursion tree. For a chain handling 1000 compute jobs per second, the aggregation latency would be a few minutes—acceptable for most AI workloads.
Contrarian Angle
The UBS report might actually be bearish for decentralized compute. The very premise—that AI infrastructure equities have overtaken hyperscalers—implies that the market favors centralized, capital-intensive providers. The largest AI data centers are built by companies like Equinix, Digital Realty, and the cloud giants themselves. They enjoy economies of scale that no DePIN network can match in the short term. A decentralized GPU network of 10,000 spare RTX 4090s cannot compete with a cluster of 100,000 H100s owned by a single entity on latency, reliability, and cost per teraflop.
Therefore, the tokenization of compute may only be viable for niche use cases: censorship-resistant AI (e.g., models that are politically disallowed in certain regions), privacy-preserving inference (where the user does not want the data center to see the input), or GPU power for training open-source models where the provider wants token-based incentives. These markets are real but small. The capital rotation into AI could also starve L2 liquidity. If the same institutional investors who buy ETH for rollup yield now allocate to AI infrastructure stocks, the L2 ecosystem may face a liquidity squeeze. The contrarian truth: the UBS report validates the narrative but also highlights the existential risk that centralized compute will outcompete any decentralized alternative, making L2 settlement for compute a solution in search of a problem.
Takeaway
Tracing the capital flow back to the semiconductor fab, the next two years will test whether L2s can evolve from financial settlement layers to compute attestation layers. The winning L2 will not be the cheapest or the fastest in vacuum; it will be the one that builds direct bridges to physical data centers, partners with GPU aggregators, and offers a native token designed for staking on compute verification. The bear case: if centralized providers offer compute at $0.5 per GPU hour, no DePIN token can sustain a premium above that. The bull case: the demand for verifiable, trustless compute from AI models that cannot use centralized providers will grow 100x. I am betting on the bull case, but only if the L2 architecture addresses the Proof-of-Inference challenge before the central banks start tokenizing compute themselves.