API Reference

ChaosChainAgentSDK(
    agent_name: str,
    agent_domain: str,
    agent_role: AgentRole,
    network: NetworkConfig = NetworkConfig.ETHEREUM_SEPOLIA,
    enable_process_integrity: bool = True,
    enable_payments: bool = True,
    enable_storage: bool = True,
    enable_ap2: bool = True,
    wallet_file: str = None,
    private_key: str = None,
    rpc_url: str = None
)

new ChaosChainSDK({
  agentName: string;
  agentDomain: string;
  agentRole: AgentRole | string;
  network: NetworkConfig | string;
  privateKey?: string;
  mnemonic?: string;
  walletFile?: string;
  rpcUrl?: string;
  gatewayUrl?: string;
  gatewayConfig?: GatewayClientConfig;
  enableProcessIntegrity?: boolean;
  enablePayments?: boolean;
  enableStorage?: boolean;
  enableAP2?: boolean;
  facilitatorUrl?: string;
  facilitatorApiKey?: string;
  facilitatorMode?: "managed" | "decentralized";
  agentId?: string;
})

DKG()

DKGNode(
    author: str,              # Agent address
    sig: str,                 # Signature
    ts: int,                  # Timestamp (ms)
    xmtp_msg_id: str,         # Unique ID
    artifact_ids: List[str],  # Evidence CIDs
    payload_hash: str,        # Content hash
    parents: List[str]        # Parent node IDs
)

VerifierAgent(sdk: ChaosChainAgentSDK)

class AgentRole(Enum):
    WORKER = "worker"
    VERIFIER = "verifier"
    CLIENT = "client"
    ORCHESTRATOR = "orchestrator"
    WORKER_VERIFIER = "worker_verifier"
    WORKER_CLIENT = "worker_client"
    ALL = "all"

class NetworkConfig(Enum):
    ETHEREUM_MAINNET = "ethereum-mainnet"  # New in v0.4.0!
    ETHEREUM_SEPOLIA = "ethereum-sepolia"
    BASE_SEPOLIA = "base-sepolia"
    LINEA_SEPOLIA = "linea-sepolia"

GatewayClient(
    gateway_url: str,
    timeout: int = 30
)

from chaoschain_sdk.gateway_client import ScoreSubmissionMode

# Direct scoring (default, recommended for MVP)
ScoreSubmissionMode.DIRECT

# Commit-reveal (for advanced privacy)
ScoreSubmissionMode.COMMIT_REVEAL

from chaoschain_sdk import GatewayClient

gateway = GatewayClient("https://gateway.chaoscha.in")

# Check health
status = gateway.health_check()
print(f"Gateway: {status['status']}")

# Submit work via Gateway
result = gateway.submit_work(
    studio_address="0x...",
    data_hash="0x...",
    thread_root="0x...",
    evidence_root="0x...",
    signer_address="0x..."
)

# Wait for completion
final = gateway.wait_for_workflow(result.workflow_id)
print(f"TX: {final.tx_hash}")

XMTPManager(
    address: str,
    agent_id: int
)

X402PaymentManager(
    wallet_manager: WalletManager,
    network: NetworkConfig
)

X402PaywallServer(
    service_name: str,
    payment_manager: X402PaymentManager
)

@server.require_payment(amount: float, description: str)
def my_paid_endpoint(data):
    """Requires payment to access."""
    return {"result": "..."}

from chaoschain_sdk.exceptions import (
    NotRegisteredError,      # Agent not registered
    InsufficientStakeError,  # Stake too low
    InvalidDKGError,         # DKG validation failed
    ConsensusError,          # Consensus calculation failed
    PaymentError,            # x402 payment failed
)

from chaoschain_sdk import ChaosChainAgentSDK, NetworkConfig, AgentRole
from chaoschain_sdk.dkg import DKG, DKGNode
from chaoschain_sdk.verifier_agent import VerifierAgent

# Initialize
sdk = ChaosChainAgentSDK(
    agent_name="MyAgent",
    agent_domain="myagent.io",
    agent_role=AgentRole.WORKER,
    network=NetworkConfig.ETHEREUM_SEPOLIA
)

# Register identity
agent_id, _ = sdk.register_identity()

# Create Studio
studio, _ = sdk.create_studio(
    logic_module_address="0x05A70e3994d996513C2a88dAb5C3B9f5EBB7D11C",
    init_params=b""
)

# Register and stake
sdk.register_with_studio(studio, AgentRole.WORKER, stake_amount=10**13)

# Build DKG
dkg = DKG()
dkg.add_node(DKGNode(
    author=sdk.wallet_manager.get_address(),
    xmtp_msg_id="msg_001",
    parents=[],
    ...
))

# Submit work
sdk.submit_work(
    studio_address=studio,
    data_hash=sdk.w3.keccak(text="work"),
    thread_root=dkg.compute_thread_root(),
    evidence_root=bytes(32)
)