ORACLE DASHBOARD
Real-time visibility into every query processed by the PixelOracle network. Each row below represents a discrete verification event, complete with its zero-knowledge proof hash and consensus status. The dashboard surfaces the full lifecycle of an oracle request, from initial submission through ZK circuit execution to final on-chain settlement.
Queries Processed
12.8K
ZK Proofs Generated
12.8K
Cross-Chain Verifications
3.3K
$PXCL Burned
420.0K
ORACLE SCANNER
Enter a contract address to run verification checks
QUERY FEED
LIVE -- 6 recentEvery query entering the PixelOracle pipeline is assigned a unique identifier and routed through the verification circuit. Solana-native assets are validated against on-chain program state, while cross-chain assets undergo bridge adapter reconciliation before proof generation begins. The feed above reflects the most recent queries in reverse chronological order. Verified entries have passed all consensus and freshness checks. Unverified entries failed at least one critical gate, typically proof verification or oracle node consensus, and are flagged for downstream consumers to handle accordingly.
SCAN RESULTS
Detailed verification breakdown
ZK Proof Valid
Proof verified on-chain
Cross-chain Match
Data consistent across Solana
Oracle Consensus
3/3 nodes agree
Freshness Check
Data age < 30s
Privacy Layer
Inputs masked via ZK circuit
Proof: 0x3f8a1c2d...e7b94f01
ZK Proof Valid
Proof verification failed
Cross-chain Match
Data mismatch detected
Oracle Consensus
1/3 nodes agree
Freshness Check
Data age < 30s
Privacy Layer
Inputs masked via ZK circuit
Proof: 0x7be4d9c1...a3f82b55
Scan results decompose the verification into its constituent checks. A single failed gate is sufficient to mark the entire query as unverified. The ZK Proof Valid check confirms that the Groth16 proof submitted by the oracle node passes the on-chain verifier contract. Cross-chain Match ensures data sourced from bridge adapters is consistent with the originating chain. Oracle Consensus requires a configurable threshold of nodes, currently three out of three, to agree on the result before it is accepted. Freshness Check enforces a maximum data age of thirty seconds, preventing stale oracle responses from propagating. The Privacy Layer confirms that query inputs were properly masked through the ZK circuit before any data left the submitting client.
ORACLE ARCHITECTURE
The PixelOracle stack is organized into three interdependent subsystems. Each operates at a different layer of the verification pipeline, yet they share a unified state commitment that anchors the entire flow to Solana finality. Understanding the architecture clarifies why certain queries fail verification and how the protocol maintains trustlessness even when individual oracle nodes behave adversarially.
QUERY ENGINE
The query engine is the ingress point for all oracle requests. It accepts queries via the Anchor program interface or through the TypeScript SDK, normalizes the input parameters, and routes each request to the appropriate verification pipeline. For Solana-native assets, the engine reads account state directly from the runtime. For cross-chain queries, it dispatches the request to the relevant bridge adapter and awaits a signed attestation before proceeding.
The engine maintains an in-memory queue with configurable concurrency limits, currently set to 256 parallel queries per node. Each query is tagged with a monotonically increasing nonce to prevent replay attacks. The nonce, combined with the query parameters, forms the preimage for the ZK circuit commitment hash. This design ensures that no two queries produce identical proof hashes, even if the underlying data is the same. Timeout enforcement at the engine level guarantees that stalled queries are evicted before they consume downstream resources.
PROOF GENERATOR
Once the query engine has assembled the necessary inputs, it passes them to the proof generator. This subsystem executes the Groth16 circuit over the BN254 elliptic curve, producing a succinct proof that the oracle result is correct without revealing the underlying query parameters. Proof generation typically completes in under two seconds on commodity hardware, though latency varies with circuit complexity.
The generator batches proofs when query volume exceeds a configurable threshold, amortizing the fixed cost of the trusted setup across multiple verifications. Batched proofs are aggregated into a single on-chain transaction using Light Protocol ZK compression, reducing per-query settlement cost by up to 1000x compared to naive proof submission. Each proof carries a TTL of 300 seconds. If the proof is not consumed within that window, it is discarded and the query must be resubmitted.
VERIFICATION LAYER
The verification layer is the final arbiter of query validity. It runs entirely on-chain within the Anchor program, accepting the generated proof and executing the Groth16 verifier against the stored verification key. A successful verification emits a program event that downstream consumers can subscribe to via websocket or polling.
Verification is deterministic and stateless. Given the same proof and verification key, any validator will arrive at the same accept or reject decision. This property is critical for composability: other Solana programs can invoke the oracle verifier via CPI and trust the result without relying on any off-chain infrastructure. The verification layer also enforces the oracle consensus threshold, rejecting any proof that was not co-signed by the minimum required number of nodes.
EXAMPLE ORACLE RESPONSE
Below is a representative JSON payload returned by the PixelOracle API after a successful query. The response includes the ZK proof metadata, consensus details, privacy layer status, and the actual result data. Integrators should check the status field before consuming the data object. The proof_hash field can be independently verified against the on-chain verifier at any time within the TTL window. All timestamps are ISO 8601 UTC. The nullifier_hash in the privacy block serves as a one-time identifier that prevents the same proof from being replayed in a different context.
{
"query_id": "pxcl_q_8f3a1c2d",
"chain": "solana",
"asset": "So1a...xK9f",
"status": "VERIFIED",
"zk_proof": {
"circuit": "oracle_query_v2",
"curve": "BN254",
"proof_hash": "0x3f8a1c2d...e7b94f01",
"verified_on_chain": true,
"verification_slot": 248917302,
"gas_cost": "0.00002 SOL"
},
"consensus": {
"nodes_queried": 3,
"nodes_agreed": 3,
"threshold_met": true
},
"privacy": {
"inputs_masked": true,
"circuit_type": "groth16",
"nullifier_hash": "0xa4c9...7e2f"
},
"data": {
"result_value": "verified_safe",
"risk_score": 12,
"freshness_ms": 1840,
"cross_chain_refs": []
},
"timestamp": "2025-03-15T14:22:08.441Z",
"ttl_seconds": 300
}