Obscura Whitepaper

OBSCURA: Decentralized Dark Pool for Sovereign AI Compute

Obscura introduces a decentralized, privacy-preserving dark pool architecture for GPU compute resources on the Solana blockchain. By implementing cryptographic commitments, commit-reveal protocols, scheduled batch clearing auctions, and zero-knowledge (ZK) match validation, Obscura mitigates the systemic issues of compute front-running, information leakage, and censorship in public marketplaces. This protocol enables autonomous AI agents and modern enterprises to acquire high-performance compute capacity (e.g., NVIDIA H100s, H200s, H800s, B200s) programmatically and privately. The microstructure ensures that compute allocation parameters, bidding prices, capacity sizes, and leasing schedules remain confidential until the exact moment of match settlement.

1. Introduction & The AI Compute Crisis

The exponential growth of Large Language Models (LLMs) and agentic AI systems has turned raw high-performance compute into the primary commodity of the 21st century. Despite this, compute markets remain highly centralized, governed by a small cartel of hyperscale cloud providers (AWS, Azure, GCP) and specialized retail clouds.

This centralized model introduces significant structural risks for developers and enterprises:

• Supply Cartelization & Censorship: Centralized hosting providers gate compute access behind strict KYC verification, geographical sanctions, and political alignment criteria. AI models that diverge from platform policies face sudden, unilateral compute lease terminations.
• Corporate Espionage & Information Leakage: Publicly leasing compute requires exposing model configurations, cluster scales, training durations, and bidding budgets. Competitors can scrape public marketplaces to front-run model launch windows, map corporate AI development pipelines, and disrupt capital allocations.
• Front-running on Open Ledgers: In public decentralized compute platforms, buy orders hit transparent mempools. Attackers can intercept these orders, buy up the required GPU time on-demand, and resell it to the original bidder at a premium (latency arbitrage).

Obscura addresses these vulnerabilities by building a cryptographic dark pool on Solana. By encrypting the order book, executing scheduled batch auctions, and verifying match authenticity using zero-knowledge proofs (zk-SNARKs), Obscura guarantees that compute buyers can secure hardware permissionlessly, privately, and at fair market value.

2. Protocol Microstructure & Cryptographic Commit-Reveal

2.1 The Continuous Leakage Problem

In standard double-auction order books, bidding parameters are public. If a buyer places a large bid for a cluster of 512 H100s, the entire market observes the demand. Sellers immediately increase ask prices, and rival buyers rush to secure remaining capacity, resulting in severe slippage and artificial price spikes. Obscura solves order-book leakage through a two-phase cryptographic commit-reveal system.

2.2 The Commit-Reveal Framework

1. Commit Phase: A user compiles their transaction parameters into a private order vector O = {G, P, Q, T} where G is the GPU model identifier, P is the max price, Q is the quantity, and T is the lease duration.

   To bind the order without revealing its contents, the client generates a 256-bit secure pseudorandom salt S. The client then computes the cryptographic commitment hash:

   H = SHA-256( G || P || Q || T || S )
   Only H and an escrow lock deposit of P × Q × T USDC are submitted to the Solana Commitment Program. The on-chain ledger records only the hash and the locked funds, keeping all variables completely hidden.
2. Reveal Phase: At the designated batch clearing block, the buyer reveals the cleartext values and the salt. The Solana Commitment Program re-hashes the revealed parameters and verifies that the output matches the committed hash H. Successful validations enter the matching pool. Bidders who fail to reveal their parameters forfeit a percentage of their escrowed deposit (commitment fee) to prevent spam.

3. Scheduled Batch Clearing Auctions

Rather than clearing transactions continuously (which leaks order timing and size information), Obscura utilizes scheduled batch auctions executed every B = 45 seconds.

3.1 Single Clearing Price Discovery

All revealed orders for a specific GPU class within a batch are aggregated to build supply and demand curves. Instead of executing orders at individual bid prices, the matching engine calculates a single, uniform clearing price P_clear for the entire batch. The clearing price is calculated as the price that maximizes the matched transaction volume. Executing all matches at this uniform clearing price prevents latency-based sniping, guarantees fair market pricing, and ensures that bidders are not penalized for submitting their true limit valuations.

4. zk-SNARK Matching Constraints & Verification

To maintain privacy during matching, the actual matching allocation is calculated off-chain by specialized matching nodes. To prove that the matches are correct and honest without leaking private bid parameters, nodes must submit a zero-knowledge proof (zk-SNARK) to the Solana Verifier Program.

The zk-SNARK circuit enforces the following constraints:

• Clearing Price Legitimacy: The calculated clearing price sits at the valid intersection of the revealed supply and demand curves.
• Valuation Enforcement: No buyer order was matched if its bid price was below the clearing price, and no provider order was matched if its limit price was above the clearing price.
• Conservation of Allocation: The sum of allocated compute units to buyers matches the sum of activated hardware capacity.
• Escrow Integrity: The funds released to a provider do not exceed the clearing price rate multiplied by the allocated duration.

The Solana Verifier Program validates this proof in a single transaction. If the proof is valid, the contract releases the USDC to the providers, keeping individual wallet connections and bid amounts private.

5. Tokenomics ($OBSC) & Sovereign Agent Service (SAS)

5.1 Protocol Fee Dynamics & Deflationary Loops

Obscura collects a 2.5% protocol fee on all settled compute leases. This fee is routed through automated on-chain contracts:

• 20% Buyback and Burn: 20% of protocol fees are automatically converted to $OBSC tokens via decentralized exchanges (DEXs) and permanently burned, reducing supply.
• 80% USDC Staking Yield: 80% of protocol fees are distributed directly to $OBSC token stakers as real yield in USDC, aligning holders with protocol transaction volume.

5.2 Node Operator Staking & SAS Passports

Operators running matching engines or hosting compute capacity are required to lock up a minimum stake of $OBSC. If an operator reports a fraudulent match, drops hardware availability during a lease, or breaches ZK constraints, their staked $OBSC is slashed.

To support autonomous AI agents, Obscura provides programmatic access via the Sovereign Agent Service (SAS). Agents generate SAS Passports that enforce hard spending caps, lease limits, and GPU model policies. API access rate limits are determined by the agent's staked $OBSC balance (Bronze, Silver, Gold Tiers).

6. Screened Settlement & Zero-Knowledge Compliance

A major risk for private compute networks is regulatory compliance. Obscura addresses this using Screened Settlement via Association-Set Proofs (ASPs). Before a wallet can withdraw settled funds or establish a lease, it must provide a zero-knowledge membership proof. This proof verifies that the user's wallet address belongs to a pre-screened list of compliant, non-sanctioned addresses. The proof is verified without exposing the wallet's identity, history, or balance, ensuring compliance while preserving privacy.

7. Conclusion

Obscura bridges the gap between raw hardware markets and cutting-edge cryptography. By combining Solana's high-speed transaction speeds with commit-reveal protocols and zk-SNARK verifications, Obscura establishes a private, permissionless, and capital-efficient marketplace for the next generation of AI compute.