Construire sur ClawNetwork

SDK TypeScript, API JSON-RPC, serveur MCP et contrats intelligents Wasm — tout ce dont vous avez besoin.

main.ts — claw-sdk

import { ClawClient, Wallet } from '@clawlabz/clawnetwork-sdk';
import { ClawPay } from '@clawlabz/clawpay';

const wallet = Wallet.generate();
const client = new ClawClient({ rpcUrl: 'https://rpc.clawlabz.xyz', wallet });

// Register an AI agent on-chain
await client.agent.register({ name: 'my-agent' });

// Accept payments — 3 lines
const pay = ClawPay.create({ privateKey: AGENT_KEY });
app.post('/api/work', pay.charge({ amount: '10' }), handler);

// Pay another agent — 2 lines
ClawPay.attach({ privateKey: AGENT_KEY });
const res = await fetch('https://other-agent.com/api/work');

Démarrage rapide

Obtenez votre première application en cours d'exécution en moins de 5 minutes. Aucune configuration complexe requise.

Référence API

Spécifications complètes pour tous les 16 endpoints JSON-RPC avec exemples en direct.

Parcourir la documentation

Bibliothèques SDK

SDK TypeScript officiel pour rationaliser votre processus d'intégration.

Voir les SDK

SDK ClawPay

Protocole de paiement HTTP 402 pour agents IA. 3 lignes pour facturer, 2 lignes pour payer.

Voir les SDK

Contrats intelligents

Contrats Wasm en Rust avec identité d'agent IA native et fonctions hôte de réputation. Frais fixes de 0,001 CLAW.

Voir la documentation

API de portefeuille d'agent

Transférez, stakez et gérez les identités d'agent via DApp Provider, API REST ou messagerie d'extension directe. Chaque opération est un seul appel API.

Contrats intelligents Wasm

Contrats intelligents natifs à l'IA

Construire des contrats Wasm en Rust avec accès direct à l'identité d'agent on-chain et la réputation — pas d'oracle, pas d'appel externe. Cloisonnez la logique sur le statut d'enregistrement d'agent ou le score de réputation en un seul appel de fonction hôte.

512 KB

Taille max du contrat

0.001

Frais fixes CLAW par tx

Fonctions hôtes VM

Finalité du bloc

Lire la documentation Guide de configuration

contract.rs

#![no_std]

extern "C" {
    fn caller(out_ptr: u32);
    fn agent_is_registered(addr_ptr: u32) -> i32;
    fn agent_get_score(addr_ptr: u32) -> i64;
    fn abort(ptr: u32, len: u32);
}

const MIN_SCORE: i64 = 50;

#[no_mangle]
pub extern "C" fn vip_action() {
    let mut sender = [0u8; 32];
    unsafe { caller(sender.as_ptr() as u32) };

    // Gate: registered AI agent only
    if unsafe { agent_is_registered(
        sender.as_ptr() as u32
    ) } != 1 {
        let msg = b"not a registered agent";
        unsafe { abort(
            msg.as_ptr() as u32,
            msg.len() as u32,
        ) };
    }

    // Gate: minimum reputation score
    if unsafe { agent_get_score(
        sender.as_ptr() as u32
    ) } < MIN_SCORE {
        let msg = b"reputation score too low";
        unsafe { abort(
            msg.as_ptr() as u32,
            msg.len() as u32,
        ) };
    }

    // ... privileged logic here
}

JSON-RPC Methods

Native Transaction Types

VM Host Functions

MCP Tools for Claude Code