Proof of Claw Documentation

# Build the Rust agent runtime
cd agent
cargo build --release

# Compile zkVM guest and host programs
cd zkvm
cargo build --release

cd contracts
forge build
forge script script/Deploy.s.sol --rpc-url $RPC_URL --broadcast

cd agent
cargo run

import { createZGServingNetworkBroker } from '@0glabs/0g-serving-broker';

// Initialize broker with agent's wallet
const broker = await createZGServingNetworkBroker(wallet);
const services = await broker.inference.listService();
const provider = services.find(s => s.verifiability === 'TeeML');

// OpenAI-compatible call through 0G Compute
const headers = await broker.inference.getRequestHeaders(provider.provider, prompt);
const response = await fetch(`${endpoint}/chat/completions`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json', ...headers },
  body: JSON.stringify({ messages, model }),
});

// Verify attestation
const verified = await broker.inference.verifyResponse(response);

import { createEnvelop } from '@dm3-org/dm3-lib';

// Publish DM3 profile to ENS text record
await ensContract.setText(
  namehash('alice-agent.proofclaw.eth'),
  'eth.dm3.profile',
  toDataURI(deliveryServiceProfile)
);

// Send encrypted message to another agent
async function sendAgentMessage(recipientEns, message) {
  const recipientProfile = await resolveDm3Profile(recipientEns);
  const { encryptedEnvelope } = await createEnvelop(
    JSON.stringify(message),
    keys.signingKey,
    recipientProfile.publicEncryptionKey,
    recipientProfile.deliveryServiceUrl
  );
  await fetch(recipientProfile.deliveryServiceUrl, {
    method: 'POST',
    body: JSON.stringify(createJsonRpcCallSubmitMessage(encryptedEnvelope)),
  });
}

// Runs inside RISC Zero zkVM — produces cryptographic receipt
fn main() {
    let trace: ExecutionTrace = risc0_zkvm::guest::env::read();
    let policy: AgentPolicy = risc0_zkvm::guest::env::read();

    // Verify every tool invocation against declared policy
    let mut all_passed = true;
    for invocation in &trace.tool_invocations {
        if !policy.allowed_tools.contains(&invocation.tool_name) {
            all_passed = false;
        }
    }

    // Check if Ledger approval is required
    let requires_approval = trace.action_value() > policy.max_value_autonomous;

    // Public output — anyone can verify on-chain
    risc0_zkvm::guest::env::commit(&VerifiedOutput {
        agent_id: trace.agent_id,
        all_checks_passed: all_passed,
        requires_ledger_approval: requires_approval,
        output_commitment: trace.output_commitment,
    });
}

import { DeviceManagementKitBuilder } from '@ledgerhq/device-management-kit';
import { SignerEthBuilder } from '@ledgerhq/device-signer-kit-ethereum';

// Initialize Ledger DMK + Ethereum signer
const dmk = new DeviceManagementKitBuilder()
  .addTransport(webHidTransportFactory).build();
const sessionId = await dmk.connect({ deviceId });
const signerEth = new SignerEthBuilder({ dmk, sessionId }).build();

// When agent action exceeds autonomous threshold:
async function requestLedgerApproval(action, proofReceipt) {
  const signature = await signerEth.signTransaction({
    to: VERIFIER_ADDRESS,
    data: encodeApproveAction(action.agentId, action.outputCommitment),
  });
  return signature;
}

AGENT_ID=alice-agent
ENS_NAME=alice.proofclaw.eth
PRIVATE_KEY=0x...
RPC_URL=https://eth-sepolia.g.alchemy.com/v2/...
ZERO_G_INDEXER_RPC=https://indexer-storage-testnet.0g.ai
ZERO_G_COMPUTE_ENDPOINT=https://broker-testnet.0g.ai
DM3_DELIVERY_SERVICE_URL=http://localhost:3001
ALLOWED_TOOLS=swap_tokens,transfer,query
MAX_VALUE_AUTONOMOUS_WEI=1000000000000000000

proof-of-claw/
├── agent/                      # Rust agent runtime
│   └── src/
│       ├── core/               # Agent loop, intent router, job scheduler
│       ├── tools/              # WASM sandbox, tool registry, capabilities
│       ├── safety/             # Policy engine, sanitizer, injection detector
│       └── integrations/       # 0G, ENS/DM3, Ledger integrations
├── zkvm/                       # RISC Zero zkVM programs
│   ├── guest/                  # Guest program (policy verification)
│   └── host/                   # Host program (proof generation)
├── contracts/                  # Solidity smart contracts
│   ├── src/
│   │   └── ProofOfClawVerifier.sol
│   ├── clear-signing/
│   │   └── proofofclaw.json    # ERC-7730 metadata
│   └── script/Deploy.s.sol
├── frontend/                   # Web UI
│   ├── index.html              # Landing page
│   ├── docs.html               # Documentation (this page)
│   ├── agents.html             # Agent management
│   ├── dashboard.html          # Monitoring dashboard
│   ├── deploy.html             # Agent deployment
│   ├── messages.html           # DM3 message viewer
│   └── proofs.html             # ZK proof explorer
└── spec.md                     # Full technical specification