The paradigm of Verifiable Computing—“off-chain computation + on-chain verification”—has become the universal computational model for blockchain systems. It allows blockchain applications to achieve near-infinite computational freedom while maintaining decentralization and trustlessness as core security guarantees. Zero-knowledge proofs (ZKPs) form the backbone of this paradigm, with applications primarily in three foundational directions: scalability, privacy, and interoperability & data integrity. Scalability was the first ZK application to reach production, moving execution off-chain and verifying concise proofs on-chain for high throughput and low-cost trustless scaling.

The evolution of ZK verifiable computing can be summarized as L2 zkRollup → zkVM → zkCoprocessor → L1 zkEVM.

• L2 zkRollups moved execution off-chain while posting validity proofs on-chain, achieving scalability and cost efficiency.

• zkVMs expanded into general-purpose verifiable computing, enabling cross-chain validation, AI inference, and cryptographic workloads.

• zkCoprocessors modularized this model into plug-and-play proof services for DeFi, RWA, and risk management.

• L1 zkEVMs brought this to Layer 1 Realtime Proving (RTP), integrating proofs directly into Ethereum’s execution pipeline.

Together, these advances mark blockchain’s shift from scalability to verifiability—ushering in an era of trustless computation.

Ethereum’s zkEVM scalability journey can be divided into two phases:

• Phase 1 (2022–2024):  L2 zkRollups migrated execution to Layer 2 and posted validity proofs on Layer 1—achieving lower costs and higher throughput, but introducing liquidity and state fragmentation while L1 remained constrained by N-of-N re-execution.

• Phase 2 (2025– ):  L1 Realtime Proving (RTP) replaces full re-execution (N-of-N) with 1-of-N proof generation + lightweight network-wide verification, boosting throughput without compromising decentralization—an approach still under active development.

In the flourishing Layer 2 ecosystem of 2022, Ethereum co-founder Vitalik Buterin classified ZK-EVMs into four types—Type 1–4—highlighting the structural trade-offs between compatibility and performance. This framework established the coordinates for zkRollup design:

• Type 1: Fully Ethereum-equivalent — replicates Ethereum exactly with no protocol changes, ensuring perfect compatibility but resulting in the slowest proving performance (e.g., Taiko).

• Type 2: Fully EVM-equivalent — identical to the EVM at the execution level but allows limited modifications to data structures for faster proof generation (e.g., Scroll, Linea).

• Type 2.5: EVM-equivalent except for gas costs — adjusts gas pricing for ZK-unfriendly operations to improve prover efficiency while maintaining broad compatibility (e.g., Polygon zkEVM, Kakarot).

• Type 3: Almost EVM-equivalent — simplifies or removes some hard-to-prove features such as precompiles, enabling faster proofs but requiring minor app-level adjustments (e.g., zkSync Era).

• Type 4: High-level-language equivalent — compiles Solidity or Vyper directly to ZK-friendly circuits, achieving the best performance but sacrificing bytecode compatibility and requiring ecosystem rebuilds (e.g., StarkNet / Cairo).

Today, the L2 zkRollup model is mature: execution runs off-chain, proofs are verified on-chain, maintaining Ethereum’s ecosystem and tooling while delivering high throughput and low cost. Yet, liquidity fragmentation and L1’s re-execution bottleneck remain persistent issues.

In July 2025, the Ethereum Foundation published “Shipping an L1 zkEVM #1: Realtime Proving”, formally proposing the L1 zkEVM roadmap.

L1 zkEVM upgrades Ethereum from an N-of-N re-execution model to a 1-of-N proving + constant-time verification paradigm:  a small number of provers re-execute entire blocks to generate succinct proofs, and all other nodes verify them instantly. This enables Realtime Proving (RTP) at the L1 level—enhancing throughput, raising gas limits, and lowering hardware requirements—all while preserving decentralization. The rollout plan envisions zk clients running alongside traditional execution clients, eventually becoming the protocol default once performance, security, and incentive models stabilize.

L1 zkEVM Roadmap: Three Core Tracks

1. Realtime Proving (RTP): Achieving block-level proof generation within a 12-second slot via parallelization and hardware acceleration.

2. Client & Protocol Integration: Standardizing proof-verification interfaces—initially optional, later default.

3. Incentive & Security Design: Establishing a prover marketplace and fee model to reinforce censorship resistance and network liveness.

L1 zkEVM’s Realtime Proving (RTP) uses zkVMs to re-execute entire blocks off-chain and produce cryptographic proofs, allowing validators to verify results in under 10 seconds—replacing “re-execution” with “verify instead of execute” to drastically enhance Ethereum’s scalability and trustless validation efficiency.

According to the Ethereum Foundation’s zkEVM Tracker, the main teams participating in the L1 zkEVM RTP roadmap include:  SP1 Turbo (Succinct Labs), Pico (Brevis), Risc Zero, ZisK, Airbender (zkSync), OpenVM (Axiom), and Jolt (a16z).

Beyond the Ethereum ecosystem, zero-knowledge proof (ZKP) technology has expanded into the broader field of Verifiable Computing, giving rise to two core technical systems: zkVMs and zkCoprocessors.

A zkVM (zero-knowledge virtual machine) serves as a verifiable execution engine for arbitrary programs, typically built on instruction set architectures such as RISC-V, MIPS, or WASM.

Developers can compile business logic into the zkVM, where provers execute it off-chain and generate zero-knowledge proofs (ZKPs) that can be verified on-chain. This enables applications ranging from Ethereum L1 block proofs to cross-chain validation, AI inference, cryptographic computation, and complex algorithmic verification.

Its key advantages lie in generality and flexibility, supporting a wide range of use cases; however, it also entails high circuit complexity and proof generation costs, requiring multi-GPU parallelism and deep engineering optimization.
Representative projects include Risc Zero, Succinct SP1, and Brevis Pico / Prism.

A zkCoprocessor provides plug-and-play computation and proof services for specific business scenarios.
These platforms predefine data access and circuit logic—such as historical on-chain data queries, TVL calculations, yield settlement, and identity verification—so that applications can simply call SDKs or APIs to receive both computation results and on-chain proofs.

This model offers fast integration, high performance, and low cost, though it sacrifices generality.
Representative projects include Brevis zkCoprocessor, Axiom.

Overall, both zkVMs and zkCoprocessors follow the “off-chain computation + on-chain verification” paradigm of verifiable computing, where zero-knowledge proofs are used to validate off-chain results on-chain. Their economic logic rests on a simple premise: the cost of executing computations directly on-chain is significantly higher than the combined cost of off-chain proof generation and on-chain verification.

In terms of generality vs. engineering complexity:

• zkVM — a general-purpose computing infrastructure suitable for complex, cross-domain, or AI-driven tasks, offering maximum flexibility.

• zkCoprocessor — a modular verification service tailored for high-frequency, reusable scenarios such as DeFi, RWA, and risk management, offering low-cost, directly callable proof interfaces.

In terms of business models:

• zkVM follows a Proving-as-a-Service model, charging per proof (ZKP). It mainly serves L2 Rollups and infrastructure providers, characterized by large contracts, long cycles, and stable gross margins.

• zkCoprocessor operates under a Proof-API-as-a-Service model, charging per task via API or SDK integration—similar to SaaS—targeting DeFi and application-layer protocols with fast integration and high scalability.

Overall, zkVMs are the foundational engines of verifiable computation, while zkCoprocessors are the application-layer verification modules. The former builds the technical moat, and the latter drives commercial adoption—together forming a universal trustless computing network.

Starting from Ethereum’s L1 Realtime Proving (RTP), zero-knowledge (ZK) technology is evolving toward an era of Verifiable Computing built upon the architectures of general-purpose zkVMs and zkCoprocessors. 

Brevis Network represents a fusion of these two paradigms — a universal verifiable computing infrastructure that combines high performance, programmability, and zero-knowledge verification — an Infinite Compute Layer for Everything.

In 2024, Vitalik Buterin proposed the concept of “Glue and Coprocessor Architectures”, envisioning a structure that separates general-purpose execution layers from specialized coprocessor acceleration layers.  Complex computations can thus be divided into flexible business logic (e.g., EVM, Python, RISC-V) and performance-focused structured operations (e.g., GPU, ASIC, hash modules).

This “general + specialized” dual-layer model is now converging across blockchain, AI, and cryptographic computing: EVM accelerates via precompiles; AI leverages GPU parallelism; ZK proofs combine general-purpose VMs with specialized circuits. The future lies in optimizing the “glue layer” for security and developer experience, while letting the “coprocessor layer” focus on efficient execution—achieving a balance among performance, security, and openness.

Pico zkVM, developed by Brevis, is a representative realization of this idea.
It integrates a general-purpose zkVM with hardware-accelerated coprocessors, merging programmability with high-performance ZK computation.

• Its modular architecture supports multiple proof backends (KoalaBear, BabyBear, Mersenne31), freely combining execution, recursion, and compression modules into a ProverChain.

• Developers can write business logic in Rust, automatically generating cryptographic proofs without prior ZK knowledge—significantly lowering the entry barrier.

• The architecture supports continuous evolution by introducing new proof systems and application-level coprocessors (for on-chain data, zkML, or cross-chain verification).

Compared to Succinct’s SP1 (a relatively monolithic RISC-V zkVM) and Risc Zero R0VM (a universal RISC-V execution model), Pico’s Modular zkVM + Coprocessor System decouples execution, recursion, and compression phases, supports backend switching, and enables coprocessor integration—yielding superior performance and extensibility.

Pico Prism marks a major leap for Brevis in multi-server GPU architecture, setting new records under the Ethereum Foundation’s RTP (Realtime Proving) framework.
It achieves 6.9-second average proof time and 96.8% RTP coverage on a 64×RTX 5090 GPU cluster, leading the zkVM performance benchmarks.

This demonstrates the transition of zkVMs from research prototypes to production-grade infrastructure through optimizations at the architectural, engineering, hardware, and system levels.

• Architecture: Traditional zkVMs (SP1, R0VM) focus on single-machine GPU optimization. Pico Prism pioneers cluster-level zkProving—multi-server, multi-GPU parallel proving—scaling ZK computation through multithreading and sharding orchestration.

• Engineering: Implements an asynchronous multi-stage pipeline (Execution / Recursion / Compression), cross-layer data reuse (proof chunk caching, embedding reuse), and multi-backend flexibility—boosting throughput dramatically.

• Hardware: On a 64×RTX 5090 ($128K) setup, achieves 6.0–6.9s average proving time and 96.8% RTP coverage, delivering a 3.4× performance-to-cost improvement over SP1 Hypercube (160×4090, 10.3s).

• System Evolution: As the first zkVM to meet EF RTP benchmarks (>96% sub-10s proofs, <$100K hardware), Pico Prism establishes zk proving as mainnet-ready infrastructure for Rollups, DeFi, AI, and cross-chain verification scenarios.
  

Traditional smart contracts “lack memory”—they cannot access historical states, recognize user behavior over time, or analyze cross-chain data.  Brevis addresses this with a high-performance ZK Data Coprocessor, enabling contracts to query, compute, and verify historical blockchain data in a trustless way. This empowers data-driven DeFi, active liquidity management, reward distribution, and cross-chain identity verification.

Brevis workflow:

1. Data Access: Contracts call APIs to retrieve historical data trustlessly.

2. Computation Execution: Developers define logic via SDK; Brevis performs off-chain computation and generates ZK proofs.

3. Result Verification: Proofs are verified on-chain, triggering subsequent contract logic.

Brevis supports both Pure-ZK and coChain (Optimistic) models:

• The former achieves full trustlessness at higher cost.

• The latter introduces PoS verification with ZK challenge-response, lowering costs while maintaining verifiability.

Validators stake on Ethereum and are slashed if ZK challenges succeed—striking a balance between security and efficiency. Through the integration of ZK + PoS + SDK, Brevis builds a scalable and verifiable data computation layer. Currently, Brevis powers PancakeSwap, Euler, Usual, Linea, and other protocols. All zkCoprocessor partnerships operate under the Pure-ZK model, providing trusted data support for DeFi incentives, reward distribution, and on-chain identity systems, enabling smart contracts to truly gain “memory and intelligence.”

Incentra, built on the Brevis zkCoprocessor, is a verifiable incentive platform that uses ZK proofs for secure, transparent, and on-chain reward distribution. It enables trustless, low-cost, cross-chain automation, allowing anyone to verify rewards directly while supporting compliant, access-controlled execution.

Supported incentive models:

• Token Holding: Rewards based on ERC-20 time-weighted average balances (TWA).

• Concentrated Liquidity: Rewards tied to AMM DEX fee ratios; compatible with Gamma, Beefy, and other ALM protocols.

• Lending & Borrowing: Rewards derived from average balances and debt ratios.

Already integrated by PancakeSwap, Euler, Usual, and Linea, Incentra enables a fully verifiable on-chain incentive loop—a foundational ZK-level infrastructure for DeFi rewards.

The Ethereum Foundation (EF)’s L1 zkEVM Realtime Proving (RTP) standard has become the de facto benchmark and entry threshold for zkVMs seeking mainnet integration. Its core evaluation criteria include:

• Latency: <= 10s for P99 of mainnet blocks

• On-prem CAPEX: <= 100k USD

• On-prem power: <= 10kW

• Code: Fully open source

• Security: >= 128 bits

• Proof size: <= 300KiB with no trusted setups

In October 2025, Brevis released the report “Pico Prism — 99.6% Real-Time Proving for 45M Gas Ethereum Blocks on Consumer Hardware,” announcing that Pico Prism became the first zkVM to fully meet the Ethereum Foundation’s RTP standard for block-level proving.

Running on a 64×RTX 5090 GPU cluster (~$128K), Pico Prism achieved:

• Average latency: 6.9 seconds

• 96.8% <10s coverage, 99.6% <12s coverage for 45M gas blocks, significantly outperforming Succinct SP1 Hypercube (36M gas, 10.3s average, 40.9% <10s coverage) With 71% lower latency and half the hardware cost, Pico Prism demonstrated a 3.4× improvement in performance-per-dollar efficiency.

• Public recognition from Ethereum Foundation, Vitalik Buterin, and Justin Drake.

The Brevis zkCoprocessor handles complex computations that dApps cannot efficiently perform—such as analyzing historical user behavior, aggregating cross-chain data, or performing large-scale analytics—and outputs zero-knowledge proofs (ZKPs) that can be verified on-chain. This allows on-chain applications to trustlessly consume results by verifying a small proof, dramatically reducing gas, latency, and trust costs. Unlike traditional oracles that merely deliver data, Brevis provides mathematical assurance that the data is correct.  Its application scenarios can be broadly categorized as follows:

• Intelligent DeFi: Data-driven incentives and personalized user experiences based on behavioral and market history (e.g., PancakeSwap, Uniswap, MetaMask).

• RWA & Stable Token Growth: Automated distribution of real-world yield and stablecoin income via ZK verification (e.g., OpenEden, Usual Money, MetaMask USD).

• Privacy-Preserving DEX (Dark Pools): Off-chain matching with on-chain verification—upcoming deployment.

• Cross-Chain Interoperability: Cross-chain restaking and Rollup–L1 verification, building a shared security layer (e.g., Kernel, Celer, 0G).

• Blockchain Bootstrap: ZK-based incentive mechanisms accelerating new chain ecosystems (e.g., Linea, TAC).

• High-Performance Blockchains (100× Faster L1s): Leveraging Realtime Proving (RTP) to enhance mainnet throughput (e.g., Ethereum, BNB Chain).

• Verifiable AI: Privacy-preserving and verifiable inference for the AgentFi and data-intelligence economy (e.g., Kaito, Trusta).

Network Scale and Metrics, According to Brevis Explorer (as of October 2025):

• Over 125 million ZK proofs generated

• Covering ~95,000 on-chain addresses and ~96,000 application requests

• Cumulative incentive distribution: $223 million+

• TVL supported: >$2.8 billion

• Total verified transaction volume: >$1 billion

Brevis’s ecosystem currently focuses on DeFi incentive distribution and liquidity optimization, with computing power mainly consumed by Usual Money, PancakeSwap, Linea Ignition, and Incentra, which together account for over 85% of network load.

• Usual Money (46.6M proofs): Demonstrates long-term stability in large-scale incentive distribution.

• PancakeSwap (20.6M): Highlights Brevis’s performance in real-time fee and discount computation.

• Linea Ignition (20.4M): Validates Brevis’s high-concurrency capacity for L2 ecosystem campaigns.

• Incentra (15.2% share): Marks Brevis’s transition from SDK toolkit to standardized incentive platform.

DeFi Incentive Layer: Through Incentra, Brevis supports multiple protocols with transparent and continuous reward allocation:

• Usual Money — Annual incentives exceeding $300M, sustaining stablecoin and LP yields.

• OpenEden & Bedrock — CPI-based models for automated U.S. Treasury and Restaking yield distribution.

• Euler, Aave, BeraBorrow — ZK-verified lending positions and reward calculations.

Liquidity Optimization: Protocols such as PancakeSwap, QuickSwap, THENA, and Beefy employ Brevis’s dynamic fee and ALM incentive plugins for trade discounts and cross-chain yield aggregation.  Jojo Exchange and the Uniswap Foundation use ZK verification to build safer, auditable trading incentive systems.

Cross-Chain & Infrastructure Layer: Brevis has expanded from Ethereum to BNB Chain, Linea, Kernel DAO, TAC, and 0G, offering verifiable computation and cross-chain proof capabilities across multiple ecosystems.  Projects like Trusta AI, Kaito AI, and MetaMask are integrating Brevis’s ZK Data Coprocessor to power privacy-preserving loyalty programs, reputation scoring, and reward systems, advancing data intelligence within Web3.

At the infrastructure level, Brevis leverages the EigenLayer AVS network for restaking security, and integrates NEBRA’s Universal Proof Aggregation (UPA) to compress multiple ZK proofs into single submissions—reducing on-chain verification cost and latency.

Overall, Brevis now spans the full application cycle—from long-term incentive programs and event-based rewards to transaction verification and platform-level services. Its high-frequency verification tasks and reusable circuit templates provide Pico/Prism with real-world performance pressure and optimization feedback, which in turn can reinforce the L1 zkVM Realtime Proving (RTP) system at both the engineering and ecosystem levels—forming a two-way flywheel between technology and application

Mo Dong | Co-founder, Brevis Network
Dr. Mo Dong is the co-founder of Brevis Network. He holds a Ph.D. in Computer Science from the University of Illinois at Urbana–Champaign (UIUC). His research has been published in top international conferences, adopted by major technology companies such as Google, and cited thousands of times.

As an expert in algorithmic game theory and protocol mechanism design, Dr. Dong focuses on integrating zero-knowledge computation (ZK) with decentralized incentive mechanisms, aiming to build a trustless Verifiable Compute Economy. He also serves as a Venture Partner at IOSG Ventures, where he actively supports early-stage investments in Web3 infrastructure.

The Brevis team was founded by cryptography and computer science Ph.D. holders from UIUC, MIT, and UC Berkeley. The core members have years of research experience in zero-knowledge proof systems (ZKP) and distributed systems, with multiple peer-reviewed publications in the field.  Brevis has received technical recognition from the Ethereum Foundation, with its core modules regarded as foundational components for on-chain scalability infrastructure.

In November 2024, Brevis completed a $7.5 million seed round, co-led by Polychain Capital and Binance Labs, with participation from IOSG Ventures, Nomad Capital, HashKey, Bankless Ventures, and strategic angel investors from Kyber, Babylon, Uniswap, Arbitrum, and AltLayer.

The Ethereum Foundation–backed ETHProofs.org has become the primary public platform tracking the L1 zkEVM Realtime Proving (RTP) roadmap, providing open data on zkVM performance, security, and mainnet readiness.

1. Maturity: Succinct SP1 leads in production deployment; Brevis Pico demonstrates the strongest performance, nearing mainnet readiness; RISC Zero is stable but has not yet disclosed RTP benchmarks.

2. Performance: Pico’s proof size (~990 kB) is about 33% smaller than SP1’s (1.48 MB), reducing cost and latency.

3. Security & Audit: RISC Zero and SP1 have both undergone independent audits; Pico is currently completing its formal audit process.

4. Developer Ecosystem:Most zkVMs use the RISC-V instruction set; SP1 leverages its Succinct Rollup SDK for broad ecosystem integration; Pico supports Rust-based auto proof generation, with a rapidly maturing SDK.

• Tier 1 — Brevis Pico (+ Prism) & Succinct SP1 Hypercube  Both target the EF RTP P99 ≤ 10 s benchmark.

  • Pico innovates through a distributed multi-GPU architecture, delivering superior performance and cost efficiency.

  • SP1 maintains robustness with a monolithic system and ecosystem maturity.
    → Pico represents architectural innovation and performance leadership, while SP1 represents *production readiness and ecosystem dominance.
    
    

• Tier 2 — RISC Zero, ZisK, ZKM  These projects focus on lightweight and compatibility-first designs but have not published complete RTP metrics (latency, power, CAPEX, security bits, proof size, reproducibility).  Scroll (Ceno) and Matter Labs (Airbender) are extending Rollup proof systems to the L1 verification layer, signaling a shift from L2 scaling toward L1 verifiable computing.

2025 zkVM field has converged on RISC-V standardization, modular evolution, recursive proof standardization, and parallel hardware acceleration.  The Verifiable Compute Layer can be categorized into three main archetypes:

• Performance-oriented: Brevis Pico, SP1, Jolt, ZisK — focus on low-latency, realtime proving via recursive STARKs and GPU acceleration.

• Modular / Extensible: OpenVM, Pico, SP1 — emphasize plug-and-play modularity and coprocessor integration.

• Ecosystem / Developer-friendly: RISC Zero, SP1, ZisK — prioritize SDK completeness and language compatibility for mass adoption.

The zk-Coprocessor market is now led by Brevis, Axiom, Herodotus, and Lagrange.

• Brevis stands out with a hybrid architecture combining a ZK Data Coprocessor + General-Purpose zkVM, enabling historical data access, programmable computation, and L1 Realtime Proving (RTP) capability.

• Axiom specializes in verifiable queries and circuit callbacks.

• Herodotus focuses on provable access to historical blockchain states.

• Lagrange adopts a ZK + Optimistic hybrid design to improve cross-chain computation efficiency.

Overall, zk-Coprocessors are emerging as “Verifiable Service Layers” that bridge DeFi, RWA, AI, and digital identity through trustless computational APIs.

Brevis builds a multi-chain verifiable computing layer by integrating its general-purpose zkVM (Pico/Prism) with a data coprocessor (zkCoprocessor).

• zkVM addresses verifiability of arbitrary computation,

• zkCoprocessor enables business deployment for historical and cross-chain data.

This creates a “Performance → Ecosystem → Cost” positive feedback loop:
as Pico Prism’s RTP performance attracts leading protocol integrations, proof volume scales up and per-proof cost declines, forming a self-reinforcing dual flywheel.

Brevis’s core competitive advantages can be summarized as:

• Reproducible performance — verified within the Ethereum Foundation’s ETHProofs RTP framework;

• Architectural moat — modular design with multi-GPU parallel scalability;

• Commercial validation — large-scale deployment across incentive distribution, dynamic fee modeling, and cross-chain verification.

Through its Pico zkVM and Prism parallel proving framework, Brevis achieves 6.9-second average latency and P99 < 10 seconds for 45M gas blocks (on a 64×5090 GPU setup, <$130K CAPEX) — maintaining top-tier performance and cost efficiency. The zkCoprocessor module supports historical data access, circuit generation, and on-chain proof verification, flexibly switching between Pure-ZK and Hybrid (Optimistic + ZK) modes.  Overall, its performance now aligns closely with the Ethereum RTP hardware and latency benchmarks.

Potential Risks and Key Considerations

• Technical & Compliance: Brevis must validate power use, security level, proof size, and trusted setup via third-party audits. Performance tuning and potential EIP changes remain key challenges.

• Competition: Succinct (SP1/Hypercube) leads in ecosystem maturity, while RISC Zero, Axiom, OpenVM, Scroll, and zkSync continue to compete strongly.

• Revenue Concentration: Proof volume is ~80% concentrated in four apps; diversification across chains and sectors is needed. GPU price volatility may also affect margins.

Overall, Brevis has established an initial moat across both technical reproducibility and commercial deployment: Pico/Prism firmly leads the L1 RTP track, while the zkCoprocessor unlocks high-frequency, reusable business applications. Going forward, Brevis should aim to fully meet the Ethereum Foundation’s RTP benchmarks, continue to standardize coprocessor products and expand ecosystem integration, and advance third-party reproducibility, security audits, and cost transparency. By balancing infrastructure and SaaS-based revenues, Brevis can build a sustainable commercial growth loop.

Disclaimer:
This report was prepared with assistance from the AI tool ChatGPT-5. The author has made every effort to ensure factual accuracy and reliability; however, minor errors may remain.  Please note that crypto asset markets often show a disconnect between project fundamentals and secondary-market token performance.  All content herein is intended for informational and academic/research purposes only, and does not constitute investment advice or a recommendation to buy or sell any token.