Welcome to Opacus Docs 🐙

Agent Kernel Engine

The central execution runtime (Node.js / Python) that dispatches agent tasks to OpenClaw runtimes. Manages local state, enforces session tokens, and validates USDC budgets before task initiation.

H3 Geospatial Indexing System

Integrates Uber's H3 Hexagonal Hierarchical Spatial Indexing for spatial awareness.

• Hexagonal Mesh (Res 8/9): Maps coordinates into discrete hex cells for fast spatial lookups
• Geofenced Spending: Restrict agent transactions to specific physical hex zones
• Proximity Discovery: Query nearby agents within an N-ring radius of hex cells

Intent Engine & Resolution Protocol

Agents publish high-level Declarative Intents instead of constructing raw smart contract calls.

• Intent Declaration: e.g., "Bridge 50 USDC from Base to Arbitrum, max 0.2% slippage"
• Solver Competition: Off-chain solvers compete for optimal execution routes
• Escrow Settlement: Funds released only on verified proof of completion

OpacusPay & API Credit Billing

Automated payment layer allowing agents to consume AI model APIs (OpenAI, Anthropic, Gemini) directly from allocated USDC budget — no credit cards stored.

0G Decentralized Storage & Compute

Agent execution state snapshots and telemetry logs are permanently stored and cryptographically verified on the 0G decentralized storage network.

Kinetic Score & DRS (Decision Reliability Score)

A mathematical trust index computed from agent task completion rates, ZK proof verifications, and escrow delivery success.

DeFi & Cross-Chain Yield Trading

Problem:

Traditional crypto trading bots require full private key access to wallet funds. Unhandled market volatility or buggy LLM logic can drain entire wallet balances or suffer massive slippage from front-running.

Opacus Solution:

Lock funds into an Opacus USDC Escrow Contract with a strict budget cap. Publish goal intents to the Opacus Intent DAG Mempool. Solvers compete off-chain to deliver optimal execution. Funds are only released upon cryptographic ZK proof verification.

Opacus Modules Used:

• X402PaymentManager: Escrow locking & zero-drain execution caps
• IntentDAGSDK / DAGMempool: Intent-based route publication
• ZKOracleSDK: ZK price range verification before execution

SDK Implementation Example:

import { OpacusClient, IntentBuilder, X402PaymentManager } from 'opacus-sdk';

const client = new OpacusClient({ apiKey: process.env.OPACUS_KEY, network: 'base-mainnet' });

// 1. Lock 100 USDC maximum budget into Opacus Escrow
const escrow = await client.escrow.create({
  amountUsdc: 100,
  maxSlippageBps: 20, // 0.2% max slippage
  expiryBlocks: 300
});

// 2. Publish Declarative Trading Intent
const intent = new IntentBuilder()
  .setTargetChain('arbitrum')
  .setAction('SWAP_AND_STAKE')
  .setParams({ tokenIn: 'USDC', tokenOut: 'ARB', minYieldApy: 12.5 })
  .setEscrowLock(escrow.id)
  .build();

const result = await client.intentMempool.publish(intent);
console.log(`Trade executed securely via Solver: ${result.solverId}, TxHash: ${result.txHash}`);

Autonomous Logistics & H3 Spatial Geofencing

Problem:

Autonomous drone delivery services and smart fleets require real-time location verification before releasing payments. Centralized GPS databases are vulnerable to spoofing and outages.

Opacus Solution:

Integrate Uber H3 Spatial Mesh (Res 8/9). The delivery agent's wallet authority and spending caps are cryptographically bound to specific physical hex cells. When the drone enters the destination hex, spatial consensus triggers automatic micro-payment settlement via H3DAC Payment V2.

Opacus Modules Used:

• H3AgentIdentity / H3AgentUtils: H3 Hexagonal spatial indexing & DID generation
• H3DACClient: High-speed QUIC + eBPF kernel-bypass transport for spatial telemetry
• H3DACPaymentV2: Location-proof triggered USDC escrow settlement

SDK Implementation Example:

import { H3AgentIdentity, H3DACClient, H3AgentUtils } from 'opacus-sdk';

// 1. Map physical latitude/longitude to Uber H3 Hexagon (Resolution 9)
const destLat = 37.7749, destLng = -122.4194;
const destinationHex = H3AgentUtils.geoToH3(destLat, destLng, 9);

// 2. Initialize H3-Geofenced Agent Identity
const droneAgent = new H3AgentIdentity({
  agentId: 'drone-express-99',
  allowedHexes: [destinationHex], // Bound execution exclusively to target hex cell
  maxBudgetCap: 25 // 25 USDC payment upon delivery
});

// 3. Connect to H3DAC QUIC Transport Network
const h3dac = await H3DACClient.connect({ peerEndpoint: 'quic://spatial.opacus.xyz:9000' });

// 4. Verify Spatial Proof & Release Escrow Payment
h3dac.on('spatial-proof', async (proof) => {
  if (proof.hexCell === destinationHex && proof.isValidSignature) {
    const settlement = await droneAgent.releasePayment(proof);
    console.log(`Package Delivered to Hex ${destinationHex}. Settlement Tx: ${settlement.txHash}`);
  }
});

Multi-Agent Swarms & 0G Storage Archival

Problem:

Distributing complex AI tasks across hundreds of sub-agent workers leads to state divergence, race conditions, unmonitored model API expenses, and lost execution records.

Opacus Solution:

Use CRDT (Conflict-Free Replicated Data Types) for zero-latency state synchronization across distributed worker agents. Automated OpacusPay x402 converts USDC to LLM credits (OpenAI/Anthropic) on demand. Complete state snapshots and telemetry are immutably archived on 0G Storage & Data Availability network.

Opacus Modules Used:

• CRDTStateSDK / CRDTStateManager: Conflict-free state synchronization across agent swarms
• ZeroGDAClient: Immutable storage of state snapshots & execution traces on 0G DA
• OpacusPayFacilitator: Automated USDC-to-LLM API credit auto-refills

SDK Implementation Example:

import { CRDTStateSDK, ZeroGDAClient, OpacusPayFacilitator } from 'opacus-sdk';

// 1. Initialize CRDT Swarm State Manager
const swarmState = new CRDTStateSDK({ nodeId: 'worker-node-04' });
swarmState.registerCounter('processed_documents');

// 2. Setup OpacusPay Auto-Refill for OpenAI API Credits
const payFacilitator = new OpacusPayFacilitator({
  escrowWallet: '0x123...',
  minCreditThresholdUsdc: 5.0,
  autoRefillAmountUsdc: 20.0
});

// 3. Process Task & Sync Swarm State
await swarmState.incrementCounter('processed_documents', 1);
await payFacilitator.ensureApiCredits({ provider: 'openai', requiredModel: 'gpt-4o' });

// 4. Archive State Snapshot permanently to 0G Decentralized Storage
const zerog = new ZeroGDAClient({ network: '0g-mainnet' });
const archiveReceipt = await zerog.uploadBlob(swarmState.getSnapshot());
console.log(`Swarm State Snapshot archived on 0G Storage. Blob ID: ${archiveReceipt.blobId}`);

Autonomous E-Commerce & Merchant Escrow

Problem:

AI buyer agents purchasing goods, software licenses, or cloud services from AI seller agents face fraud risks, counterfeit digital assets, or unfulfilled service agreements.

Opacus Solution:

Lock buyer purchase funds in an Opacus Bounded Escrow. The merchant provides service proofs verified using BLS Multi-Signatures. Opacus Kinetic Score (DRS) dynamically adjusts required collateral and dispute periods based on the merchant's historical reliability.

Opacus Modules Used:

• ReputationSystem: Kinetic Score & Decision Reliability Score (DRS) calculation
• BLSCryptoSDK: Multi-party signature aggregation for proof of service
• OpacusClient: Automated escrow release upon verified multi-sig consensus

SDK Implementation Example:

import { OpacusClient, ReputationSystem, BLSSigner } from 'opacus-sdk';

const client = new OpacusClient({ apiKey: process.env.OPACUS_KEY });
const reputation = new ReputationSystem();

// 1. Verify Merchant's Kinetic Score before transaction
const merchantRep = await reputation.getScore('did:opacus:merchant:8842');
console.log(`Merchant Kinetic Trust Score: ${merchantRep.score} / 100 (${merchantRep.trustLevel})`);

if (merchantRep.score >= 80) {
  // 2. Lock Purchase Amount in Escrow with 24-hour Auto-Release
  const orderEscrow = await client.escrow.createOrder({
    merchantDid: 'did:opacus:merchant:8842',
    itemUsdcValue: 50.00,
    autoReleaseHours: 24
  });

  // 3. Merchant returns BLS-signed delivery proof
  const isProofValid = BLSSigner.verifyAggregateProof(orderEscrow.deliveryProof);
  if (isProofValid) {
    await client.escrow.release(orderEscrow.id);
    await reputation.recordEvent({ did: 'did:opacus:merchant:8842', type: 'SUCCESSFUL_DELIVERY' });
    console.log('Order fulfilled and escrow payment released to merchant.');
  }
}

Enterprise Risk Management & Compliance Auditing

Problem:

Large corporations deploying autonomous AI agents face severe regulatory compliance requirements (EU AI Act, SOC2, Financial Audits). Unmonitored financial spending or untracked agent decision loops create corporate liability.

Opacus Solution:

Enforce strict corporate spending caps and domain access policies via the Opacus Agent Kernel Engine. All agent thought logs, API calls, and financial disbursements are cryptographically signed and permanently recorded on 0G Data Availability, producing tamper-proof audit trails for compliance officers.

Opacus Modules Used:

• SecurityManager: Enterprise key isolation & policy enforcement
• ZeroGDAClient: Immutable 0G audit log anchoring
• GPUCryptoSDK: High-throughput batch signature verification for enterprise compliance monitoring

SDK Implementation Example:

import { SecurityManager, ZeroGDAClient, GPUSignatureVerifier } from 'opacus-sdk';

// 1. Define Corporate Risk Policy
const security = new SecurityManager({
  dailySpendLimitUsdc: 500.00,
  allowedDomains: ['api.openai.com', 'api.anthropic.com', 'opacus.xyz'],
  requireMultiSigOverUsdc: 100.00
});

// 2. Enforce Policy on Agent Action Request
const actionRequest = { amountUsdc: 45.00, targetDomain: 'api.openai.com' };
const isAuthorized = security.validateAction(actionRequest);

if (isAuthorized) {
  // 3. Execute & Audit-log transaction on 0G Storage
  const zerog = new ZeroGDAClient();
  const auditEntry = {
    timestamp: new Date().toISOString(),
    agentId: 'corp-fin-agent-01',
    action: actionRequest,
    policyHash: security.getPolicyHash()
  };
  
  const logResult = await zerog.uploadAuditLog(auditEntry);
  console.log(`Corporate Audit Log Anchored on 0G. Transaction Verified: ${logResult.txHash}`);
}

SDK Code Example

import { OpacusClient } from 'opacus-sdk';

const opacus = new OpacusClient({
  apiKey: process.env.OPACUS_API_KEY,
  network: 'base-mainnet'
});

const agent = await opacus.agents.create({
  template: 'bridge-agent',
  budgetCap: 50,
  goal: 'Bridge 25 USDC to Arbitrum with slippage < 0.2%'
});

console.log(`Agent launched: ${agent.id}`);