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.proofofclaw.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.proofofclaw.eth
PRIVATE_KEY=0x...
SIGNER_MODE=private-key
RPC_URL=https://eth-sepolia.g.alchemy.com/v2/...
CHAIN_ID=11155111
ZERO_G_INDEXER_RPC=https://indexer-storage-testnet.0g.ai
ZERO_G_COMPUTE_ENDPOINT=https://broker-testnet.0g.ai
ZERO_G_CHAIN_RPC=https://evmrpc-testnet.0g.ai
ZERO_G_CHAIN_ID=16602
DM3_DELIVERY_SERVICE_URL=http://localhost:3001
ALLOWED_TOOLS=swap_tokens,transfer,query
ENDPOINT_ALLOWLIST=https://api.uniswap.org,https://api.0x.org
MAX_VALUE_AUTONOMOUS_WEI=1000000000000000000
API_PORT=8420

proof-of-claw/
├── agent/                      # Rust agent runtime (IronClaw workspace)
│   ├── crates/                 # Core crates (engine, safety, skills, common)
│   └── src/
│       ├── agent/              # Agent loop, dispatcher, sessions
│       ├── channels/           # Multi-channel input (HTTP, CLI, WebSocket, WASM)
│       ├── tools/              # WASM sandbox, tool registry, MCP
│       ├── safety/             # Policy engine, injection detector
│       └── integrations/       # 0G, ENS, DM3, Ledger, EIP-8004, iNFT
├── zkvm/                       # RISC Zero zkVM programs
│   ├── guest/                  # Guest program (policy verification)
│   └── host/                   # Host program (proof generation)
├── contracts/                  # Solidity smart contracts (Foundry)
│   ├── src/
│   │   ├── ProofOfClawVerifier.sol     # ZK proof verification + routing
│   │   ├── ProofOfClawINFT.sol         # ERC-7857 agent identity NFT
│   │   ├── SoulVaultSwarm.sol          # Epoch-based swarm coordination
│   │   ├── EIP8004Integration.sol      # EIP-8004 registry bridge
│   │   └── SoulVaultERC8004RegistryAdapter.sol
│   ├── clear-signing/
│   │   └── proofofclaw.json    # ERC-7730 Ledger Clear Signing
│   └── script/
│       ├── Deploy.s.sol        # Sepolia deployment
│       ├── Deploy0G.s.sol      # 0G Chain deployment
│       └── DeploySwarm.s.sol   # Swarm + identity deployment
├── frontend/                   # Web UI (vanilla HTML/CSS/JS)
│   ├── index.html              # Landing page
│   ├── agents.html             # Agent registry, wizard, chat
│   ├── dashboard.html          # Monitoring dashboard
│   ├── messages.html           # DM3 message threads
│   ├── proofs.html             # ZK proof explorer
│   ├── soul-vault.html         # Agent deployment interface
│   └── docs.html               # Documentation (this page)
├── cli/                        # TypeScript CLI tool (poc)
├── delivery-service/           # DM3 message delivery (port 3001)
├── swarm-bridge/               # Bridge to swarmprotocol.fun (port 3002)
├── 1claw-server/               # 1clawAI credential storage (port 3456)
├── spec.md                     # Full technical specification
├── ARCHITECTURE.md             # System architecture
└── .env.example                # Configuration reference