> ## Documentation Index
> Fetch the complete documentation index at: https://prophet.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# 0G Integration Depth
> A technical audit of every 0G module integration in Prophet — for judges and engineers evaluating the depth of 0G use.
This page is written for 0G Labs judges evaluating Track 2 (Agentic Trading Arena). It documents every 0G module Prophet uses, the specific SDK calls, the implementation files, and why each integration is non-superficial.
## Integration Summary
Prophet integrates three distinct 0G modules. Each module is used because the product cannot work without it — removing any one of them makes the system either centralized, unverifiable, or non-functional.
| 0G Module | SDK | Use Cases | Required for |
| ---------- | --------------------------------- | ------------------ | ------------------------------------------------------ |
| 0G Chain | ethers v6, viem, wagmi | All contract state | Market creation, trading, resolution, payouts |
| 0G Compute | `@0glabs/0g-serving-broker` | AI inference | Question validation, oracle resolution, market pricing |
| 0G Storage | `@0gfoundation/0g-storage-ts-sdk` | Permanent data | Market metadata, oracle reasoning, agent state |
***
## 0G Chain
### Why 0G Chain Specifically
Ethereum is economically infeasible for Prophet. The oracle agent submits multiple transactions per market resolution (postResolution, revealPositions). At Ethereum L1 gas prices, a single resolution cycle would cost $50–$200. This makes the oracle economically unviable for any market under \$10,000 in volume.
0G Chain provides:
* **11,000 TPS** — high enough to handle many concurrent market resolutions
* **Sub-second finality** — oracle reads resolution events quickly
* **Low gas cost** — oracle can submit transactions economically
* **EVM-compatible** — all existing Solidity tooling works without modification
* **Chain ID 16602** (Galileo testnet) / **16600** (mainnet)
### What Runs on 0G Chain
Every contract in Prophet lives on 0G Chain:
* `ProphetFactory.sol` — market registry and factory
* `MarketContract.sol` — per-market AMM and lifecycle
* `LiquidityPool.sol` — protocol-owned liquidity
* `PositionVault.sol` — encrypted position storage
* `PayoutDistributor.sol` — payout calculation and distribution
Every user transaction is on-chain:
* `createMarket()` — ProphetFactory
* `buyShares()`, `sellShares()` — MarketContract
* `commitPosition()` — PositionVault
* `triggerResolution()`, `postResolution()`, `finalizeResolution()` — MarketContract
* `revealPositions()` — PositionVault
* `redeemWinningShares()` — MarketContract
### Client SDKs
**Frontend**: wagmi v2 + viem configured for 0G Chain:
```typescript theme={null}
// frontendV2/src/lib/wagmi.ts
import { defineChain } from 'viem';
export const ogGalileo = defineChain({
id: 16602,
name: '0G Galileo Testnet',
nativeCurrency: { name: '0G', symbol: '0G', decimals: 18 },
rpcUrls: {
default: { http: ['https://evmrpc-testnet.0g.ai'] }
},
blockExplorers: {
default: {
name: '0G ChainScan',
url: 'https://chainscan-galileo.0g.ai'
}
},
testnet: true
});
```
**Agents**: ethers v6 with provider and wallet:
```typescript theme={null}
// agent/src/shared/chain.ts
import { ethers } from 'ethers';
const provider = new ethers.JsonRpcProvider(process.env.OG_CHAIN_RPC);
const oracleWallet = new ethers.Wallet(process.env.PRIVATE_KEY_ORACLE, provider);
const mmWallet = new ethers.Wallet(process.env.PRIVATE_KEY_MM, provider);
```
***
## 0G Compute
### The Problem It Solves
Prophet's oracle is only trustworthy if it is decentralized. A centralized AI backend (OpenAI, Anthropic API) would make the oracle dependent on a single company's uptime, pricing, and content policies. A single API key could be revoked, censored, or rate-limited — killing every market resolution simultaneously.
0G Compute provides **decentralized, pay-per-use AI inference** with TEE attestation — no single company controls it, and the inference provider cannot fake results without the TEE attestation being invalidated.
### SDK and Implementation
```
npm package: @0glabs/0g-serving-broker
```
**Primary implementation files:**
* `agent/src/shared/compute.ts` — broker initialization, provider management, inference function
* `agent/src/scripts/test-compute.ts` — integration test script
* `frontendV2/src/app/api/validate-question/route.ts` — server-side question validation endpoint
### Use Case 1: Question Validation at Market Creation
When a user creates a market, the frontend sends the question to `/api/validate-question`. This Next.js API route calls 0G Compute to determine if the question:
* Is binary (can only resolve YES or NO)
* Is specific and unambiguous
* Has a clear resolution criterion
* Is verifiable by public evidence
The model returns a JSON response: `{ valid: bool, reason: string, suggestedSources: string[] }`.
Invalid questions are rejected before the market is created — saving gas and preventing unresolvable markets from entering the system.
### Use Case 2: Oracle Resolution at Deadline
The primary use. After `triggerResolution` is called, the oracle agent:
```typescript theme={null}
// agent/src/shared/compute.ts
import { createZGServingNetworkBroker } from '@0glabs/0g-serving-broker';
import OpenAI from 'openai';
export async function callOracleInference(
question: string,
sources: string[],
deadline: string,
signer: ethers.Wallet
): Promise {
// Step 1: Initialize broker
const broker = await createZGServingNetworkBroker(signer);
// Step 2: Get provider endpoint
const providerAddress = process.env.COMPUTE_PROVIDER_ADDRESS;
const { endpoint, model } = await broker.getServiceMetadata(providerAddress);
// Step 3: Verify TEE attestation (configurable strict mode)
if (process.env.COMPUTE_REQUIRE_TEE === '1') {
await broker.verifyService(providerAddress);
}
// Step 4: Acknowledge provider (required before first call in session)
await broker.acknowledgeProviderSigner(providerAddress);
// Step 5: Call inference (OpenAI-compatible API)
const client = new OpenAI({ baseURL: endpoint, apiKey: '' });
const response = await client.chat.completions.create({
model,
messages: [
{ role: 'system', content: ORACLE_SYSTEM_PROMPT },
{ role: 'user', content: buildResolutionPrompt(question, sources, deadline) }
],
temperature: 0.1,
max_tokens: 1000
});
// Step 6: Extract and parse JSON (with retry on malformed response)
return extractJSON(response.choices[0].message.content);
}
```
### Use Case 3: Market Pricing Inference
The market-maker agent calls 0G Compute to get an initial price estimate for each new market — before any trades have occurred. The model assesses the market question and returns a starting YES probability, which the agent uses to set the initial AMM seed ratio.
### Provider Details
| Parameter | Testnet | Mainnet |
| ----------------- | -------------------------------------------- | ----------------------- |
| Provider address | `0xa48f01287233509FD694a22Bf840225062E67836` | `0x1B3AAe...` |
| Model | `qwen-2.5-7b-instruct` | `deepseek-chat-v3-0324` |
| Inference latency | 45–90 seconds | \~10 seconds |
### TEE Attestation
`broker.verifyService(providerAddress)` checks that the inference provider is running inside a TEE and that the TEE environment matches the published configuration. With `COMPUTE_REQUIRE_TEE=1`, the oracle will refuse to post a verdict if TEE verification fails.
### Billing Headers
The 0G Compute SDK handles billing automatically via payment headers attached to each API request. The oracle agent's wallet funds the ledger; the SDK deducts per-token costs. This means the oracle pays for its own compute in \$0G — no monthly API bills, no vendor relationship.
### Reliability Design
The compute integration includes:
* **Retry on timeout**: inference calls retry up to 3 times with exponential backoff
* **JSON extraction**: if the model returns markdown-wrapped JSON, the parser strips the fences before parsing
* **Confidence threshold**: responses below 70% confidence trigger a second pass rather than posting a low-confidence verdict
***
## 0G Storage
### The Problem It Solves
Prediction markets live and die on oracle credibility. If the oracle posts a verdict but no one can verify why, the market is no more trustworthy than a human committee.
0G Storage provides **permanent, decentralized, tamper-proof storage** where the oracle's full reasoning chain can live forever. The root hash stored on-chain commits to the exact content — anyone can download it and verify independently.
### SDK and Implementation
```
npm package: @0gfoundation/0g-storage-ts-sdk
```
**Critical note on indexers:**
* Standard indexer (`https://indexer-storage-testnet-standard.0g.ai`) returns 503 intermittently
* **Always use turbo indexer: `https://indexer-storage-testnet-turbo.0g.ai`**
**Primary implementation files:**
* `agent/src/shared/storage.ts` — upload/download helpers with retry and checksum verification
* `frontendV2/src/lib/server/og-storage.ts` — server-side storage client for API routes
* `frontendV2/src/app/api/og-storage/route.ts` — API route that proxies storage reads to the frontend
* `agent/src/scripts/test-storage.ts` — integration test script
### Upload with Retry and Verification
```typescript theme={null}
// agent/src/shared/storage.ts
import { Indexer, MemData } from '@0gfoundation/0g-storage-ts-sdk';
export async function uploadToStorage(
data: object,
signer: ethers.Wallet,
maxRetries = 3
): Promise {
const indexer = new Indexer(process.env.OG_INDEXER_URL);
const buffer = Buffer.from(JSON.stringify(data));
for (let attempt = 1; attempt <= maxRetries; attempt++) {
try {
const memData = new MemData(buffer);
const [tx, err] = await indexer.upload(memData, signer);
if (err) throw new Error(`Upload error: ${err}`);
// Read-after-write verification
const rootHash = tx;
const downloaded = await downloadFromStorage(rootHash);
const checksum = JSON.stringify(downloaded) === JSON.stringify(data);
if (!checksum) throw new Error('Read-after-write checksum mismatch');
return rootHash;
} catch (error) {
if (attempt === maxRetries) throw error;
await sleep(2000 * attempt); // exponential backoff
}
}
}
```
### Download with Retry
```typescript theme={null}
export async function downloadFromStorage(
rootHash: string,
maxRetries = 3
): Promise