ClawChain RPC Client

Connect EvoClaw agents to the ClawChain blockchain for on-chain reputation tracking, token economics, and governance participation.

Quick Start

use clawchain::ClawChainClient;

#[tokio::main]
async fn main() -> anyhow::Result\x3C()> {
    // Connect to local node
    let client = ClawChainClient::new("ws://127.0.0.1:9944").await?;
    
    // Query agent reputation
    let did = "did:claw:1a2b3c4d...";
    let reputation = client.get_agent_reputation(did).await?;
    println!("Reputation score: {}", reputation);
    
    // Check token balance
    let balance = client.get_token_balance(did).await?;
    println!("CLAW tokens: {}", balance);
    
    Ok(())
}

Prerequisites

1. ClawChain node running:

   clawchain-node --dev --rpc-external --ws-external
   

2. Rust dependencies in Cargo.toml:

   [dependencies]
   clawchain = { path = "/path/to/clawchain-skill" }
   

Architecture

┌─────────────────────────────────────────────────┐
│              EvoClaw Edge Agent                │
├─────────────────────────────────────────────────┤
│  ┌────────────────────────────────────────┐   │
│  │  ClawChain Skill (this skill)         │   │
│  │  └─ Substrate RPC client              │   │
│  └────────────────────────────────────────┘   │
└─────────────────────────────────────────────────┘
          ↓ WebSocket
┌─────────────────────────────────────────────────┐
│         ClawChain Node (Substrate)             │
│  ┌───────────────────────────────────────────┐  │
│  │ AgentRegistry Pallet                      │  │
│  │ ClawToken Pallet                           │  │
│  │ Governance Pallet                           │  │
│  └───────────────────────────────────────────┘  │
└─────────────────────────────────────────────────┘

Key Concepts

Agent DIDs

Agent identifiers follow the format:

did:claw:\x3Chash>

Where \x3Chash> is SHA-256(agent metadata + owner address).

Reputation Scores

Reputation is computed from:

score = (commits * 1000) + (pull_requests * 5000) + (docs * 2000)

Token Economics

• Total Supply: 1 billion $CLAW
• Distribution: 40% airdrop, 30% validators, 20% treasury, 10% team
• Inflation: 5% annual (floor 2%) for gas subsidies

API Reference

Connection

let client = ClawChainClient::new("ws://localhost:9944").await?;

Parameters:

• url: WebSocket URL (ws:// or wss://)
• Returns: Connected client

Query Agent

let agent = client.get_agent("did:claw:...").await?;

Returns: AgentInfo struct with:

• did: Agent DID
• owner: Owner address
• metadata: IPFS hash
• reputation: Reputation score
• verifications: Number of attestations

Get Token Balance

let balance = client.get_token_balance("did:claw:...").await?;

Returns: Token balance (u128)

Register Agent

let did = client.register_agent(metadata_ipfs_hash).await?;

Returns: Newly created DID

Vote on Proposal

client.vote(proposal_id, true).await?;

Parameters:

• proposal_id: Proposal identifier
• approve: true (approve) or false (reject)

Submit Transaction

let tx_hash = client.submit_extrinsic(call_data).await?;

Parameters:

• call_data: Encoded extrinsic
• Returns: Transaction hash

Error Handling

use clawchain::ClawChainError;

match client.get_agent(did).await {
    Ok(agent) => println!("Agent: {:?}", agent),
    Err(ClawChainError::NotFound) => println!("Agent not found"),
    Err(e) => eprintln!("Error: {:?}", e),
}

Example: Full Agent Integration

use clawchain::ClawChainClient;

#[tokio::main]
async fn main() -> anyhow::Result\x3C()> {
    let client = ClawChainClient::new("ws://127.0.0.1:9944").await?;
    
    // 1. Register this agent
    let metadata = b"{\"name\":\"pi1-edge\",\"type\":\"edge\"}";
    let did = client.register_agent(metadata).await?;
    println!("Registered: {}", did);
    
    // 2. Check reputation
    let rep = client.get_agent_reputation(&did).await?;
    println!("Reputation: {}", rep);
    
    // 3. Vote on governance proposal
    if rep > 1000 {
        client.vote(123, true).await?;
        println!("Voted on proposal #123");
    }
    
    Ok(())
}

Monitoring

Subscribe to chain events:

client.subscribe_events(|event| {
    match event {
        ChainEvent::Block(block) => println!("New block: {}", block.number),
        ChainEvent::AgentRegistered(did) => println!("Agent: {}", did),
        ChainEvent::ProposalPassed(id) => println!("Proposal {} passed", id),
    }
}).await?;

Testing

Mock RPC server for testing:

let mock = MockServer::new().await?;
let client = mock.client().await?;

Security Notes

• Never expose private keys in agent code
• Use programmatic signing for autonomous agents
• Validate all RPC responses
• Implement rate limiting for public RPC endpoints

References

• ClawChain Architecture
• Substrate RPC Docs
• Agent Registry Pallet