@chaoschain/sdk 0.2.2 → 0.2.3

package/dist/index.d.ts

@@ -0,0 +1,2576 @@
+import { N as NetworkConfig, I as IntegrityProof, W as WalletConfig, a as NetworkInfo, C as ContractAddresses, G as GatewayClientConfig, b as GatewayHealthResponse, c as WorkflowStatus, S as ScoreSubmissionMode, P as PendingWorkResponse, d as WorkEvidenceResponse, A as AgentRole, e as ChaosChainSDKConfig, f as AgentMetadata, g as AgentRegistration, F as FeedbackParams, h as PaymentMethod, U as UploadOptions, i as UploadResult, j as WorkflowError } from './types-CEFAgoAM.js';
+export { M as AgencySignals, o as ComputeProvider, D as DKGNodeData, R as EngineeringStudioPolicy, J as EvidencePackage, k as FeedbackRecord, u as PendingWorkItem, Q as ScoreRange, Z as SignalExtractionContext, n as StorageProvider, T as TEEAttestation, p as TransactionResult, l as ValidationRequest, V as ValidationRequestParams, q as ValidationStatus, O as VerifierAssessment, K as WorkEvidenceVerificationResult, Y as WorkMandate, L as WorkVerificationResult, t as WorkflowProgress, s as WorkflowState, r as WorkflowType, m as X402Payment, X as X402PaymentParams, v as XMTPMessageData, E as composeScoreVector, w as computeDepth, x as derivePoAScores, B as extractAgencySignals, H as rangeFit, y as validateEvidenceGraph, z as verifyWorkEvidence } from './types-CEFAgoAM.js';
+import { ethers } from 'ethers';
+export { I as IPFSLocalStorage } from './IPFSLocal-BCIADaOU.js';
+
+/**
+ * X402 Payment Manager for ChaosChain SDK
+ *
+ * This module implements the Coinbase x402 HTTP 402 payment protocol with EIP-3009,
+ * enabling seamless, gasless cryptocurrency payments between AI agents via facilitators.
+ *
+ * Based on: https://www.x402.org/ and https://github.com/coinbase/x402
+ */
+
+interface X402PaymentRequest$1 {
+    payment_id: string;
+    from_agent: string;
+    to_agent: string;
+    amount: number;
+    currency: string;
+    service_description: string;
+    network: NetworkConfig;
+    protocol_fee: number;
+    created_at: string;
+    settlement_address?: string;
+}
+interface X402PaymentProof {
+    payment_id: string;
+    transaction_hash: string;
+    main_transaction_hash: string;
+    fee_transaction_hash?: string;
+    from_address: string;
+    to_address: string;
+    treasury_address: string;
+    amount: number;
+    currency: string;
+    protocol_fee: number;
+    network: NetworkConfig;
+    chain_id: number;
+    block_number?: number;
+    timestamp: Date;
+    status: string;
+    confirmations: number;
+    fee_amount?: string;
+    net_amount?: string;
+    evidence_hash?: string;
+}
+/**
+ * Official x402 Payment Requirements schema
+ * Spec: https://github.com/coinbase/x402
+ */
+interface X402PaymentRequirements {
+    scheme: string;
+    network: string;
+    maxAmountRequired: string;
+    resource: string;
+    description: string;
+    mimeType: string;
+    outputSchema?: object | null;
+    payTo: string;
+    maxTimeoutSeconds: number;
+    asset: string;
+    extra: object | null;
+}
+/**
+ * EIP-3009 Payment Header
+ * Transmitted as base64-encoded JSON in X-PAYMENT header
+ */
+interface PaymentHeader {
+    sender: string;
+    nonce: string;
+    validAfter?: string;
+    validBefore?: string;
+    signature?: string;
+}
+/**
+ * EIP-3009 Transfer Authorization Parameters
+ * Used for signing and on-chain execution
+ */
+interface TransferAuthorizationParams {
+    from: string;
+    to: string;
+    value: bigint;
+    validAfter: bigint;
+    validBefore: bigint;
+    nonce: string;
+}
+/**
+ * Facilitator Configuration
+ */
+interface X402FacilitatorConfig {
+    facilitatorUrl?: string;
+    apiKey?: string;
+    mode?: 'managed' | 'decentralized';
+    agentId?: string;
+}
+/**
+ * Facilitator Settlement Request
+ */
+interface SettleRequest {
+    x402Version: number;
+    paymentHeader: PaymentHeader | string;
+    paymentRequirements: X402PaymentRequirements;
+    agentId?: string;
+}
+/**
+ * Facilitator Settlement Response
+ */
+interface SettleResponse {
+    success: boolean;
+    error: string | null;
+    txHash: string | null;
+    txHashFee?: string;
+    networkId: string | null;
+    consensusProof?: string;
+    timestamp?: number;
+    feeAmount?: string;
+    netAmount?: string;
+    status?: 'pending' | 'partial_settlement' | 'confirmed' | 'failed';
+    evidenceHash?: string;
+    proofOfAgency?: string;
+}
+/**
+ * X402 Payment Manager - Coinbase HTTP 402 protocol with EIP-3009
+ *
+ * Features:
+ * - ✅ EIP-3009 gasless transfers via facilitator
+ * - ✅ Signature-based payment authorization
+ * - ✅ Automatic protocol fee collection
+ * - ✅ Multi-network support (Base, Ethereum, Optimism, Linea)
+ * - ✅ ChaosChain Proof-of-Agency integration
+ */
+declare class X402PaymentManager {
+    private wallet;
+    private provider;
+    private network;
+    private treasuryAddress;
+    private protocolFeePercentage;
+    private usdcAddresses;
+    private facilitatorUrl;
+    private facilitatorApiKey?;
+    private facilitatorMode;
+    private agentId?;
+    constructor(wallet: ethers.Wallet | ethers.HDNodeWallet, network: NetworkConfig, facilitatorConfig?: X402FacilitatorConfig);
+    /**
+     * Get ChaosChain treasury address for network
+     */
+    private getTreasuryAddress;
+    /**
+     * Get chain ID for network
+     */
+    private getChainId;
+    /**
+     * Generate unique nonce for EIP-3009 transfer authorization
+     * Returns 32-byte hex string (0x-prefixed)
+     */
+    private generateNonce;
+    /**
+     * Sign EIP-3009 Transfer Authorization
+     *
+     * This creates an EIP-712 signature for USDC's transferWithAuthorization function.
+     * The facilitator will use this signature to execute a gasless transfer on-chain.
+     *
+     * Spec: https://eips.ethereum.org/EIPS/eip-3009
+     */
+    signTransferAuthorization(params: TransferAuthorizationParams): Promise<string>;
+    /**
+     * Call facilitator API endpoint
+     */
+    private callFacilitator;
+    /**
+     * Settle payment with facilitator (EIP-3009 execution)
+     *
+     * The facilitator will:
+     * 1. Verify the EIP-712 signature
+     * 2. Call USDC.transferWithAuthorization() on-chain
+     * 3. Sponsor the gas fees
+     * 4. Return the transaction hash
+     */
+    settleWithFacilitator(paymentHeader: PaymentHeader, paymentRequirements: X402PaymentRequirements): Promise<SettleResponse>;
+    /**
+     * Create x402 payment request
+     */
+    createPaymentRequest(fromAgent: string, toAgent: string, amount: number, currency?: string, serviceDescription?: string): X402PaymentRequest$1;
+    /**
+     * Execute x402 payment (EIP-3009 mode)
+     *
+     * This method uses EIP-3009 + facilitator for gasless, signature-based payments
+     */
+    executePayment(paymentRequest: X402PaymentRequest$1, recipientAddress: string): Promise<X402PaymentProof>;
+    /**
+     * Execute native token (ETH) payment
+     */
+    private executeNativePayment;
+    /**
+     * Execute USDC payment using EIP-3009 + Facilitator
+     *
+     * NEW FLOW (EIP-3009 compliant):
+     * 1. Generate EIP-712 signature for transferWithAuthorization
+     * 2. Send signature to facilitator
+     * 3. Facilitator executes on-chain (gas-sponsored)
+     * 4. Return transaction hash
+     *
+     * Benefits:
+     * - ✅ Gasless (facilitator pays gas)
+     * - ✅ Single signature (no approve + transfer)
+     * - ✅ Facilitator manages fee collection
+     */
+    private executeUsdcPayment;
+    /**
+     * Verify x402 payment on-chain
+     */
+    verifyPayment(paymentProof: X402PaymentProof): Promise<boolean>;
+    /**
+     * Create payment requirements for receiving payments
+     * Official x402 spec: https://github.com/coinbase/x402
+     * Aligned with Python SDK
+     */
+    createPaymentRequirements(amount: number, currency?: string, serviceDescription?: string, evidenceCid?: string): X402PaymentRequirements;
+    /**
+     * Get payment history (from on-chain events)
+     */
+    getPaymentHistory(limit?: number): Promise<X402PaymentProof[]>;
+    /**
+     * Create cryptographic receipt for payment
+     */
+    createPaymentReceipt(paymentProof: X402PaymentProof): Record<string, any>;
+    /**
+     * Get payment statistics
+     */
+    getPaymentStats(): Record<string, any>;
+}
+
+/**
+ * X402 Paywall Server for ChaosChain SDK
+ *
+ * This module implements an HTTP 402 paywall server for protecting API endpoints
+ * with cryptocurrency payments.
+ */
+
+interface X402PaywallConfig {
+    port: number;
+    host?: string;
+    defaultCurrency?: string;
+}
+/**
+ * X402 Paywall Server - HTTP 402 payment-protected API
+ *
+ * Features:
+ * - HTTP 402 Payment Required responses
+ * - Automatic payment verification
+ * - Per-endpoint payment requirements
+ * - Payment receipt generation
+ */
+declare class X402Server {
+    private paymentManager;
+    private server;
+    private endpoints;
+    private paymentCache;
+    private config;
+    constructor(paymentManager: X402PaymentManager, config: X402PaywallConfig);
+    /**
+     * Register a payment-protected endpoint
+     */
+    requirePayment(amount: number, description: string, currency?: string): (handler: (data: any) => any) => (data: any) => any;
+    /**
+     * Start the HTTP 402 server
+     */
+    start(): void;
+    /**
+     * Stop the server
+     */
+    stop(): Promise<void>;
+    /**
+     * Handle incoming HTTP requests
+     */
+    private handleRequest;
+    /**
+     * Send HTTP 402 Payment Required response
+     * Official x402 spec: https://github.com/coinbase/x402
+     */
+    private sendPaymentRequired;
+    /**
+     * Verify payment from X-PAYMENT header
+     * Spec: X-PAYMENT contains base64 encoded JSON with:
+     * { x402Version: number, scheme: string, network: string, payload: <scheme-specific> }
+     */
+    private verifyPayment;
+    /**
+     * Get server statistics
+     */
+    getServerStats(): Record<string, any>;
+    /**
+     * Clear payment cache
+     */
+    clearPaymentCache(): void;
+}
+
+/**
+ * Google AP2 Integration for ChaosChain SDK
+ *
+ * This module integrates Google's official AP2 types with the ChaosChain protocol,
+ * providing real AP2 intent verification and mandate management.
+ */
+interface IntentMandate {
+    user_cart_confirmation_required: boolean;
+    natural_language_description: string;
+    merchants?: string[];
+    skus?: string[];
+    requires_refundability: boolean;
+    intent_expiry: string;
+}
+interface CartMandate {
+    contents: CartContents;
+    merchant_authorization: string;
+}
+interface CartContents {
+    id: string;
+    user_cart_confirmation_required: boolean;
+    payment_request: PaymentRequest;
+    cart_expiry: string;
+    merchant_name: string;
+}
+interface PaymentRequest {
+    method_data: PaymentMethodData[];
+    details: PaymentDetailsInit;
+}
+interface PaymentMethodData {
+    supported_methods: string;
+    data: Record<string, any>;
+}
+interface PaymentDetailsInit {
+    id: string;
+    display_items: PaymentItem[];
+    total: PaymentItem;
+}
+interface PaymentItem {
+    label: string;
+    amount: PaymentCurrencyAmount;
+}
+interface PaymentCurrencyAmount {
+    currency: string;
+    value: number | string;
+}
+interface GoogleAP2IntegrationResult {
+    intent_mandate?: IntentMandate;
+    cart_mandate?: CartMandate;
+    payment_mandate?: any;
+    jwt_token?: string;
+    success: boolean;
+    error?: string;
+}
+/**
+ * Production Google AP2 integration for ChaosChain SDK
+ *
+ * This integrates Google's official AP2 library for real intent verification
+ * and mandate management with production-grade security.
+ */
+declare class GoogleAP2Integration {
+    private agentName;
+    private privateKey;
+    private publicKey;
+    private merchantPrivateKeyValue;
+    constructor(agentName: string, merchantPrivateKey?: string);
+    /**
+     * Get merchant private key (for future use in payment verification)
+     */
+    getMerchantPrivateKey(): string;
+    /**
+     * Generate or load RSA keypair for production JWT signing
+     */
+    private getOrGenerateRsaKeypair;
+    /**
+     * Create an IntentMandate using Google's official AP2 types
+     */
+    createIntentMandate(userDescription: string, merchants?: string[], skus?: string[], requiresRefundability?: boolean, expiryMinutes?: number): GoogleAP2IntegrationResult;
+    /**
+     * Create a CartMandate using Google's official AP2 types with JWT signing
+     */
+    createCartMandate(cartId: string, items: Array<{
+        name: string;
+        price: number;
+    }>, totalAmount: number, currency?: string, merchantName?: string, expiryMinutes?: number): Promise<GoogleAP2IntegrationResult>;
+    /**
+     * Create a JWT token for merchant authorization as per Google's AP2 spec
+     */
+    private createMerchantJwt;
+    /**
+     * Verify a JWT token (for validation purposes)
+     */
+    verifyJwtToken(token: string): Promise<Record<string, any>>;
+    /**
+     * Get a summary of the Google AP2 integration capabilities
+     */
+    getIntegrationSummary(): Record<string, any>;
+}
+
+/**
+ * A2A-x402 Extension Implementation for ChaosChain SDK
+ *
+ * This module implements Google's A2A-x402 extension for cryptocurrency payments,
+ * enabling seamless crypto settlement within the AP2 framework.
+ *
+ * Based on: https://github.com/google-agentic-commerce/a2a-x402/blob/main/v0.1/spec.md
+ */
+
+interface X402PaymentMethod {
+    supported_methods: string[];
+    supported_networks: string[];
+    payment_endpoint: string;
+    verification_endpoint: string;
+    method_data?: Record<string, any>;
+}
+interface TraditionalPaymentResponse {
+    payment_id: string;
+    method: string;
+    amount: number;
+    currency: string;
+    status: string;
+    transaction_id?: string;
+    authorization_code?: string;
+    timestamp: string;
+    receipt_data?: Record<string, any>;
+}
+interface X402PaymentRequest {
+    id: string;
+    total: Record<string, any>;
+    display_items: Array<Record<string, any>>;
+    x402_methods: X402PaymentMethod[];
+    settlement_address: string;
+    network: string;
+    expires_at: string;
+}
+interface X402PaymentResponse {
+    payment_id: string;
+    transaction_hash: string;
+    network: string;
+    amount: number;
+    currency: string;
+    settlement_address: string;
+    confirmation_blocks: number;
+    status: string;
+    timestamp: string;
+    gas_fee?: number;
+    protocol_fee?: number;
+}
+/**
+ * A2A-x402 Extension for cryptocurrency payments within AP2 framework
+ *
+ * This class bridges Google's AP2 protocol with x402 crypto payments,
+ * enabling seamless crypto settlement for agent-to-agent commerce.
+ */
+declare class A2AX402Extension {
+    private agentName;
+    private network;
+    private paymentManager;
+    private supportedCryptoMethods;
+    private supportedNetworks;
+    private w3cPaymentMethods;
+    constructor(agentName: string, network: NetworkConfig, paymentManager: any);
+    /**
+     * Initialize W3C Payment Request API compliant payment methods
+     */
+    private initializeW3cPaymentMethods;
+    /**
+     * Create x402 payment method descriptor with W3C compliance
+     */
+    createX402PaymentMethod(settlementAddress: string): X402PaymentMethod;
+    /**
+     * Create enhanced payment request with x402 crypto support
+     */
+    createEnhancedPaymentRequest(cartId: string, totalAmount: number, currency: string, items: Array<Record<string, any>>, settlementAddress: string): X402PaymentRequest;
+    /**
+     * Execute x402 crypto payment using the real payment manager
+     */
+    executeX402Payment(paymentRequest: X402PaymentRequest, payerAgent: string, serviceDescription?: string): Promise<X402PaymentResponse>;
+    /**
+     * Execute traditional payment (cards, Google Pay, Apple Pay, etc.)
+     */
+    executeTraditionalPayment(paymentMethod: string, amount: number, currency: string, paymentData: Record<string, any>): TraditionalPaymentResponse;
+    /**
+     * Verify x402 payment on-chain
+     */
+    verifyX402Payment(paymentResponse: X402PaymentResponse): boolean;
+    /**
+     * Create cryptographic proof of x402 payment
+     */
+    createPaymentProof(paymentResponse: X402PaymentResponse): Record<string, any>;
+    /**
+     * Get A2A-x402 extension capabilities with W3C Payment Request API compliance
+     */
+    getExtensionCapabilities(): Record<string, any>;
+}
+
+/**
+ * Production-ready process integrity verification for ChaosChain agents.
+ *
+ * This module provides cryptographic proof of correct code execution,
+ * ensuring that agents perform work as intended with verifiable evidence.
+ *
+ * Features:
+ * - Local code hashing (SHA-256)
+ * - Optional TEE attestations (0G Compute, AWS Nitro, etc.)
+ * - Dual-layer verification: Code + Execution
+ * - Pluggable compute providers for maximum flexibility
+ */
+
+interface StorageProvider {
+    uploadJson(data: any, filename: string): Promise<string>;
+}
+interface ComputeProvider {
+    submit(task: any): Promise<string>;
+    status(jobId: string): Promise<{
+        state: string;
+        [key: string]: any;
+    }>;
+    result(jobId: string): Promise<{
+        success: boolean;
+        execution_hash: string;
+        verification_method: {
+            value: string;
+        };
+        proof?: Buffer;
+        metadata?: any;
+        error?: string;
+    }>;
+    attestation(jobId: string): Promise<any>;
+}
+/**
+ * Production-ready process integrity verifier for ChaosChain agents.
+ *
+ * Provides dual-layer cryptographic proof:
+ * 1. Local code hashing (SHA-256 of function code)
+ * 2. Optional TEE attestations (hardware-verified execution from 0G Compute, AWS Nitro, etc.)
+ *
+ * This enables the "Process Integrity" layer of the Triple-Verified Stack:
+ * - Layer 1: AP2 Intent Verification (Google)
+ * - Layer 2: Process Integrity (ChaosChain + TEE attestations) ← THIS MODULE
+ * - Layer 3: Accountability
+ */
+declare class ProcessIntegrity {
+    private agentName;
+    private storageManager;
+    private computeProvider;
+    private registeredFunctions;
+    private functionHashes;
+    constructor(agentName: string, storageManager?: StorageProvider | null, computeProvider?: ComputeProvider | null);
+    /**
+     * Register a function for integrity checking.
+     */
+    registerFunction(func: Function, functionName?: string): string;
+    /**
+     * Execute a registered function with integrity proof generation.
+     */
+    executeWithProof(functionName: string, inputs: Record<string, any>, requireProof?: boolean, useTee?: boolean): Promise<[any, IntegrityProof | null]>;
+    /**
+     * Generate a hash of the function's code.
+     */
+    private generateCodeHash;
+    /**
+     * Get TEE attestation from compute provider (e.g., 0G Compute).
+     */
+    private getTeeAttestation;
+    /**
+     * Generate a cryptographic integrity proof.
+     */
+    private generateIntegrityProof;
+    /**
+     * Store integrity proof on IPFS for persistence.
+     */
+    private storeProofOnIpfs;
+    /**
+     * Serialize function result for hashing.
+     */
+    private serializeResult;
+    /**
+     * Create a process insurance policy for a function.
+     */
+    createInsurancePolicy(functionName: string, coverageAmount: number, conditions: Record<string, any>): Record<string, any>;
+    /**
+     * Configure autonomous agent capabilities with integrity verification.
+     */
+    configureAutonomousAgent(capabilities: string[], constraints: Record<string, any>): Record<string, any>;
+}
+
+/**
+ * Wallet management for ChaosChain SDK
+ * Handles private keys, HD wallets, and secure key storage
+ */
+
+declare class WalletManager {
+    private wallet;
+    private provider?;
+    constructor(config: WalletConfig, provider?: ethers.Provider);
+    /**
+     * Initialize wallet from various sources
+     */
+    private initializeWallet;
+    /**
+     * Load wallet from encrypted file
+     */
+    private loadFromFile;
+    /**
+     * Save wallet to encrypted file
+     */
+    saveToFile(filePath: string, password?: string): Promise<void>;
+    /**
+     * Get wallet instance
+     */
+    getWallet(): ethers.Wallet | ethers.HDNodeWallet;
+    /**
+     * Get wallet address
+     */
+    getAddress(): string;
+    /**
+     * Get private key (use with caution)
+     */
+    getPrivateKey(): string;
+    /**
+     * Get mnemonic phrase (if available)
+     */
+    getMnemonic(): string | undefined;
+    /**
+     * Sign a message
+     */
+    signMessage(message: string): Promise<string>;
+    /**
+     * Sign typed data (EIP-712)
+     */
+    signTypedData(domain: ethers.TypedDataDomain, types: Record<string, ethers.TypedDataField[]>, value: Record<string, unknown>): Promise<string>;
+    /**
+     * Get balance
+     */
+    getBalance(): Promise<bigint>;
+    /**
+     * Get nonce
+     */
+    getNonce(): Promise<number>;
+    /**
+     * Connect to a new provider
+     */
+    connect(provider: ethers.Provider): void;
+    /**
+     * Generate a new random wallet
+     */
+    static createRandom(): WalletManager;
+    /**
+     * Create from mnemonic
+     */
+    static fromMnemonic(mnemonic: string, provider?: ethers.Provider): WalletManager;
+    /**
+     * Create from private key
+     */
+    static fromPrivateKey(privateKey: string, provider?: ethers.Provider): WalletManager;
+    /**
+     * Generate new mnemonic
+     */
+    static generateMnemonic(): string;
+    /**
+     * Validate mnemonic
+     */
+    static isValidMnemonic(mnemonic: string): boolean;
+    /**
+     * Validate private key
+     */
+    static isValidPrivateKey(privateKey: string): boolean;
+    /**
+     * Derive child wallet from HD path
+     */
+    static deriveChild(mnemonic: string, path: string): WalletManager;
+}
+
+declare class MandateManager {
+    private readonly agentName;
+    private readonly walletManager;
+    private readonly agentCaip10;
+    private readonly chainId;
+    private readonly mandatesCore;
+    constructor(agentName: string, walletManager: WalletManager, chainId: number);
+    get agent_caip10(): string;
+    get chain_id(): number;
+    private toCaip10;
+    buildCore(kind: string, payload: Record<string, unknown>, baseUrl?: string): Record<string, unknown>;
+    createMandate(params: {
+        intent: string;
+        core: Record<string, unknown>;
+        deadline: string;
+        client: string;
+        server?: string;
+        version?: string;
+        mandateId?: string;
+        createdAt?: string;
+    }): any;
+    mandateFromDict(data: any): any;
+    signAsServer(mandate: any, privateKey?: string): any;
+    signAsClient(mandate: any, privateKey: string): any;
+    verify(mandate: any): {
+        client_ok: boolean;
+        server_ok: boolean;
+        all_ok: boolean;
+        mandate_hash: string;
+    };
+}
+
+/**
+ * Network configurations for supported chains
+ */
+
+/**
+ * Get network info by name
+ */
+declare function getNetworkInfo(network: NetworkConfig | string): NetworkInfo;
+/**
+ * Get contract addresses for a network
+ */
+declare function getContractAddresses(network: NetworkConfig | string): ContractAddresses;
+
+declare class GatewayClient {
+    private gatewayUrl;
+    private timeout;
+    private maxPollTime;
+    private pollInterval;
+    private defaultHeaders?;
+    private auth?;
+    private retryConfig?;
+    constructor(config: GatewayClientConfig);
+    private _resolveTimeout;
+    private _resolveAuthMode;
+    private _buildHeaders;
+    private _classifyStatusCode;
+    private _normalizeError;
+    private _getRetryDelayMs;
+    private _sleep;
+    /**
+     * Make HTTP request to Gateway.
+     * Handles errors and transforms them to Gateway exceptions.
+     */
+    private _request;
+    /**
+     * Parse workflow status from API response.
+     */
+    private _parseWorkflowStatus;
+    healthCheck(): Promise<GatewayHealthResponse>;
+    isHealthy(): Promise<boolean>;
+    /**
+     * Create a work submission workflow.
+     * POST /workflows/work-submission
+     *
+     * SDK prepares inputs; Gateway handles:
+     * - Evidence upload to Arweave
+     * - Transaction submission
+     * - Confirmation waiting
+     *
+     * @param studioAddress - Ethereum address of the studio
+     * @param epoch - Epoch number
+     * @param agentAddress - Ethereum address of the submitting agent
+     * @param dataHash - Bytes32 hash of the work (as hex string)
+     * @param threadRoot - Bytes32 DKG thread root (as hex string)
+     * @param evidenceRoot - Bytes32 evidence Merkle root (as hex string)
+     * @param evidenceContent - Raw evidence bytes (will be base64 encoded)
+     * @param signerAddress - Ethereum address of the signer (must be registered in Gateway)
+     * @returns WorkflowStatus - Initial status of the created workflow
+     */
+    submitWork(studioAddress: string, epoch: number, agentAddress: string, dataHash: string, threadRoot: string, evidenceRoot: string, evidenceContent: Buffer | string, signerAddress: string): Promise<WorkflowStatus>;
+    /**
+     * Create a score submission workflow.
+     * POST /workflows/score-submission
+     *
+     * Supports two modes:
+     * - DIRECT (default): Simple direct scoring, requires workerAddress
+     * - COMMIT_REVEAL: Commit-reveal pattern, requires salt
+     *
+     * @param studioAddress - Ethereum address of the studio
+     * @param epoch - Epoch number
+     * @param validatorAddress - Ethereum address of the validator
+     * @param dataHash - Bytes32 hash of the work being scored (as hex string)
+     * @param scores - Array of dimension scores (0-10000 basis points)
+     * @param signerAddress - Ethereum address of the signer
+     * @param options - Additional options (workerAddress, salt, mode)
+     */
+    submitScore(studioAddress: string, epoch: number, validatorAddress: string, dataHash: string, scores: number[], signerAddress: string, options?: {
+        workerAddress?: string;
+        salt?: string;
+        mode?: ScoreSubmissionMode;
+    }): Promise<WorkflowStatus>;
+    /**
+     * Create a close epoch workflow.
+     * POST /workflows/close-epoch
+     *
+     * This is economically final — cannot be undone.
+     *
+     * @param studioAddress - Ethereum address of the studio
+     * @param epoch - Epoch number to close
+     * @param signerAddress - Ethereum address of the signer
+     */
+    closeEpoch(studioAddress: string, epoch: number, signerAddress: string): Promise<WorkflowStatus>;
+    /**
+     * Get workflow status by ID.
+     * GET /workflows/{id}
+     */
+    getWorkflow(workflowId: string): Promise<WorkflowStatus>;
+    /**
+     * List workflows with optional filters.
+     * GET /workflows?studio=&state=&type=
+     */
+    listWorkflows(options?: {
+        studio?: string;
+        state?: string;
+        workflowType?: string;
+    }): Promise<WorkflowStatus[]>;
+    /**
+     * Poll workflow until it reaches a terminal state.
+     *
+     * @param workflowId - UUID of the workflow
+     * @param options - Polling options
+     * @throws WorkflowFailedError - If workflow reaches FAILED state
+     * @throws GatewayTimeoutError - If maxWait exceeded
+     */
+    waitForCompletion(workflowId: string, options?: {
+        maxWait?: number;
+        pollInterval?: number;
+        onProgress?: (status: WorkflowStatus) => void;
+    }): Promise<WorkflowStatus>;
+    /**
+     * Submit work and wait for completion.
+     */
+    submitWorkAndWait(studioAddress: string, epoch: number, agentAddress: string, dataHash: string, threadRoot: string, evidenceRoot: string, evidenceContent: Buffer | string, signerAddress: string, options?: {
+        onProgress?: (status: WorkflowStatus) => void;
+    }): Promise<WorkflowStatus>;
+    /**
+     * Submit score and wait for completion.
+     */
+    submitScoreAndWait(studioAddress: string, epoch: number, validatorAddress: string, dataHash: string, scores: number[], signerAddress: string, options?: {
+        workerAddress?: string;
+        workAddress?: string;
+        salt?: string;
+        mode?: ScoreSubmissionMode;
+        onProgress?: (status: WorkflowStatus) => void;
+    }): Promise<WorkflowStatus>;
+    /**
+     * Close epoch and wait for completion.
+     */
+    closeEpochAndWait(studioAddress: string, epoch: number, signerAddress: string, options?: {
+        onProgress?: (status: WorkflowStatus) => void;
+    }): Promise<WorkflowStatus>;
+    /**
+     * Fetch pending (unfinalized) work for a studio from the gateway.
+     *
+     * @param studioAddress - 0x-prefixed studio contract address
+     * @param options - Optional limit/offset for pagination
+     * @returns Typed pending work response
+     */
+    getPendingWork(studioAddress: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<PendingWorkResponse>;
+    /**
+     * Fetch full evidence graph for a work submission.
+     * Endpoint: GET /v1/work/{hash}/evidence
+     */
+    getWorkEvidence(workHash: string): Promise<WorkEvidenceResponse>;
+}
+
+interface StudioClientConfig {
+    provider: ethers.Provider;
+    signer: ethers.Signer;
+    network: string;
+}
+declare class StudioClient {
+    private provider;
+    private signer;
+    private network;
+    constructor(config: StudioClientConfig);
+    /**
+     * Create a new Studio on the ChaosChain protocol.
+     *
+     * @param name - Name for the studio
+     * @param logicModuleAddress - Address of deployed LogicModule contract
+     * @returns Studio proxy address and studioId
+     */
+    createStudio(name: string, logicModuleAddress: string): Promise<{
+        proxyAddress: string;
+        studioId: bigint;
+    }>;
+    /**
+     * Register this agent with a Studio.
+     *
+     * @param studioAddress - Address of the Studio proxy
+     * @param agentId - Agent's ERC-8004 ID
+     * @param role - Agent role (1=WORKER, 2=VERIFIER, 3=CLIENT, etc.)
+     * @param stakeAmount - Amount to stake in wei (default: 0.0001 ETH)
+     */
+    registerWithStudio(studioAddress: string, agentId: string, role: number, stakeAmount?: bigint): Promise<string>;
+    /**
+     * Submit work to a Studio (direct, deprecated).
+     * @deprecated Use Gateway for production. Direct submission lacks crash recovery.
+     *
+     * @param studioAddress - Address of the Studio proxy
+     * @param dataHash - EIP-712 DataHash of the work (bytes32)
+     * @param threadRoot - VLC/Merkle root of XMTP thread (bytes32)
+     * @param evidenceRoot - Merkle root of artifacts (bytes32)
+     * @param feedbackAuth - Feedback authorization (deprecated, default empty)
+     * @returns Transaction hash
+     */
+    submitWork(studioAddress: string, dataHash: string, threadRoot: string, evidenceRoot: string, feedbackAuth?: string): Promise<string>;
+    /**
+     * Submit work with multi-agent attribution.
+     * @deprecated Use Gateway for production.
+     *
+     * @param studioAddress - Address of the Studio proxy
+     * @param dataHash - EIP-712 DataHash of the work (bytes32)
+     * @param threadRoot - VLC/Merkle root of XMTP thread (bytes32)
+     * @param evidenceRoot - Merkle root of artifacts (bytes32)
+     * @param participants - List of participant addresses (in order)
+     * @param contributionWeights - Contribution weights in basis points (must sum to 10000)
+     * @param evidenceCID - IPFS/Arweave CID of evidence package (optional)
+     * @returns Transaction hash
+     */
+    submitWorkMultiAgent(studioAddress: string, dataHash: string, threadRoot: string, evidenceRoot: string, participants: string[], contributionWeights: number[], evidenceCID?: string): Promise<string>;
+    /**
+     * Commit a score (commit phase of commit-reveal).
+     *
+     * NOTE: For production, use Gateway.submitScore() with mode=COMMIT_REVEAL.
+     * The Gateway handles workflow management, crash recovery, and proper sequencing.
+     *
+     * @param studioAddress - Address of the Studio proxy
+     * @param dataHash - DataHash of the work being scored (bytes32)
+     * @param commitment - keccak256(abi.encodePacked(scoreVector, salt, dataHash))
+     * @returns Transaction hash
+     */
+    commitScore(studioAddress: string, dataHash: string, commitment: string): Promise<string>;
+    /**
+     * Reveal a score (reveal phase of commit-reveal).
+     *
+     * NOTE: For production, use Gateway.submitScore() with mode=COMMIT_REVEAL.
+     * The Gateway handles the full commit-reveal lifecycle automatically.
+     *
+     * @param studioAddress - Address of the Studio proxy
+     * @param dataHash - DataHash of the work being scored (bytes32)
+     * @param scoreVector - ABI-encoded score array (bytes)
+     * @param salt - Random salt used in commitment (bytes32)
+     * @returns Transaction hash
+     */
+    revealScore(studioAddress: string, dataHash: string, scoreVector: string, salt: string): Promise<string>;
+    /**
+     * Submit score vector directly (simpler alternative to commit-reveal).
+     *
+     * NOTE: For production, use Gateway.submitScore() with mode=DIRECT.
+     * The Gateway handles workflow management and crash recovery.
+     *
+     * Use this direct method only for:
+     * - Local testing and development
+     * - Admin operations requiring low-level control
+     * - Studios that don't require commit-reveal protection
+     *
+     * @param studioAddress - Address of the Studio proxy
+     * @param dataHash - DataHash of the work being scored (bytes32)
+     * @param scores - Multi-dimensional scores [0-100 each]
+     * @returns Transaction hash
+     */
+    submitScoreVector(studioAddress: string, dataHash: string, scores: number[]): Promise<string>;
+    /**
+     * Submit score vector for a SPECIFIC WORKER in multi-agent tasks.
+     *
+     * NOTE: For production, use Gateway.submitScore() which handles per-worker
+     * scoring automatically based on DKG causal analysis.
+     *
+     * This direct method is for:
+     * - Local testing and development
+     * - Admin operations requiring low-level control
+     *
+     * How multi-agent scoring works:
+     * - Each verifier evaluates EACH WORKER from DKG causal analysis
+     * - Submits separate score vector for each worker
+     * - Contract calculates per-worker consensus
+     * - Each worker gets THEIR OWN reputation scores
+     *
+     * @param studioAddress - Address of the Studio proxy
+     * @param dataHash - DataHash of the work being scored (bytes32)
+     * @param workerAddress - Address of the worker being scored
+     * @param scores - Multi-dimensional scores for THIS worker [0-100 each]
+     * @returns Transaction hash
+     */
+    submitScoreVectorForWorker(studioAddress: string, dataHash: string, workerAddress: string, scores: number[]): Promise<string>;
+    /**
+     * Close an epoch and trigger reward distribution.
+     *
+     * NOTE: For production, use Gateway.closeEpoch() which handles
+     * workflow management, logging, and crash recovery.
+     *
+     * @param studioAddress - Address of the Studio proxy
+     * @param epoch - Epoch number to close
+     * @returns Transaction hash
+     */
+    closeEpoch(studioAddress: string, epoch: number): Promise<string>;
+    /**
+     * Get pending rewards for an account in a Studio.
+     *
+     * @param studioAddress - Address of the Studio proxy
+     * @param account - Address to check balance for
+     * @returns Pending reward amount in wei
+     */
+    getPendingRewards(studioAddress: string, account: string): Promise<bigint>;
+    /**
+     * Withdraw pending rewards from a Studio.
+     *
+     * @param studioAddress - Address of the Studio proxy
+     * @returns Transaction hash
+     */
+    withdrawRewards(studioAddress: string): Promise<string>;
+    /**
+     * Compute score commitment for commit-reveal pattern.
+     *
+     * @param scores - Array of scores (0-100 or 0-10000 depending on contract)
+     * @param salt - Random bytes32 salt
+     * @param dataHash - DataHash of the work being scored
+     * @returns bytes32 commitment hash
+     */
+    computeScoreCommitment(scores: number[], salt: string, dataHash: string): string;
+    /**
+     * Encode score vector for revealScore.
+     *
+     * @param scores - Array of scores
+     * @returns ABI-encoded bytes
+     */
+    encodeScoreVector(scores: number[]): string;
+    /**
+     * Generate random salt for commit-reveal.
+     *
+     * @returns bytes32 random salt
+     */
+    generateSalt(): string;
+}
+
+/**
+ * Main ChaosChain SDK Class - Complete TypeScript implementation
+ *
+ * Features:
+ * - ERC-8004 v1.0 on-chain identity, reputation, and validation
+ * - x402 crypto payments (USDC/ETH)
+ * - Traditional payments (cards, Google Pay, Apple Pay, PayPal)
+ * - Google AP2 intent verification
+ * - Process integrity with cryptographic proofs
+ * - Pluggable storage providers (IPFS, Pinata, Irys, 0G)
+ * - Pluggable compute providers
+ * - A2A-x402 extension for multi-payment support
+ * - HTTP 402 paywall server
+ */
+declare class ChaosChainSDK {
+    private static warnedGatewayMissing;
+    private static warnedStudioClientProduction;
+    private walletManager;
+    private chaosAgent;
+    private x402PaymentManager?;
+    private paymentManager?;
+    private storageBackend;
+    private computeProvider?;
+    private provider;
+    googleAP2?: GoogleAP2Integration;
+    a2aX402Extension?: A2AX402Extension;
+    processIntegrity?: ProcessIntegrity;
+    mandateManager?: MandateManager;
+    gateway: GatewayClient | null;
+    studio: StudioClient;
+    readonly agentName: string;
+    readonly agentDomain: string;
+    readonly agentRole: AgentRole | string;
+    readonly network: NetworkConfig | string;
+    readonly networkInfo: ReturnType<typeof getNetworkInfo>;
+    private _agentId?;
+    constructor(config: ChaosChainSDKConfig);
+    /**
+     * Register agent identity on-chain
+     */
+    registerIdentity(metadata?: AgentMetadata): Promise<AgentRegistration>;
+    /**
+     * Get agent metadata
+     */
+    getAgentMetadata(agentId: bigint): Promise<AgentMetadata | null>;
+    /**
+     * Update agent metadata
+     */
+    updateAgentMetadata(agentId: bigint, metadata: AgentMetadata): Promise<string>;
+    /**
+     * Get current agent ID
+     */
+    getAgentId(): bigint | undefined;
+    /**
+     * Generate feedback authorization (EIP-191 signing)
+     */
+    generateFeedbackAuthorization(agentId: bigint, clientAddress: string, indexLimit: bigint, expiry: bigint): Promise<string>;
+    /**
+     * Give feedback to an agent
+     */
+    giveFeedback(params: FeedbackParams): Promise<string>;
+    /**
+     * Submit feedback with payment proof (ERC-8004 reputation enrichment)
+     */
+    submitFeedbackWithPayment(agentId: bigint, score: number, feedbackData: Record<string, any>, paymentProof: Record<string, any>): Promise<{
+        feedbackTxHash: string;
+        feedbackUri: string;
+    }>;
+    /**
+     * Get agent reputation score (ERC-8004 v1.0)
+     */
+    getReputationScore(agentId: bigint): Promise<number>;
+    /**
+     * Read all feedback for an agent
+     */
+    readAllFeedback(agentId: bigint, clientAddresses?: string[], tag1?: string, tag2?: string, includeRevoked?: boolean): Promise<{
+        clients: string[];
+        feedbackIndexes: bigint[];
+        scores: number[];
+        valueDecimals: number[];
+        tag1s: string[];
+        tag2s: string[];
+        revokedStatuses: boolean[];
+    }>;
+    /**
+     * Get feedback summary statistics
+     */
+    getFeedbackSummary(agentId: bigint, clientAddresses?: string[], tag1?: string, tag2?: string): Promise<{
+        count: bigint;
+        averageScore: number;
+        averageScoreDecimals: number;
+    }>;
+    /**
+     * Get clients who gave feedback
+     */
+    getClients(agentId: bigint): Promise<string[]>;
+    /**
+     * Request validation from validator (ERC-8004 v1.0)
+     */
+    requestValidation(validatorAddress: string, agentId: bigint, requestUri: string, requestHash: string): Promise<string>;
+    /**
+     * Respond to validation request (ERC-8004 v1.0)
+     */
+    respondToValidation(requestHash: string, response: number, responseUri: string, responseHash: string, tag?: string): Promise<string>;
+    /**
+     * Get validation status
+     */
+    getValidationStatus(requestHash: string): Promise<{
+        validatorAddress: string;
+        agentId: bigint;
+        response: number;
+        responseHash: string;
+        tag: string;
+        lastUpdate: bigint;
+    }>;
+    /**
+     * Get validation summary for an agent
+     */
+    getValidationSummary(agentId: bigint, validatorAddresses?: string[], tag?: string): Promise<{
+        count: bigint;
+        avgResponse: number;
+    }>;
+    /**
+     * Get validation stats (alias for getValidationSummary)
+     */
+    getValidationStats(agentId: bigint): Promise<{
+        count: bigint;
+        avgResponse: number;
+    }>;
+    /**
+     * Create x402 payment request
+     */
+    createX402PaymentRequest(fromAgent: string, toAgent: string, amount: number, currency?: string, serviceDescription?: string): Record<string, any>;
+    /**
+     * Execute x402 crypto payment
+     */
+    executeX402Payment(paymentRequest: Record<string, any>, recipientAddress: string): Promise<Record<string, any>>;
+    /**
+     * Create x402 payment requirements (for receiving payments)
+     */
+    createX402PaymentRequirements(amount: number, currency?: string, serviceDescription?: string, evidenceCid?: string): Record<string, any>;
+    /**
+     * Create x402 paywall server
+     */
+    createX402PaywallServer(port?: number): X402Server;
+    /**
+     * Get x402 payment history
+     */
+    getX402PaymentHistory(limit?: number): Promise<any[]>;
+    /**
+     * Calculate total cost including protocol fee (2.5%)
+     */
+    calculateTotalCost(amount: string, currency?: string): {
+        amount: string;
+        fee: string;
+        total: string;
+        currency: string;
+    };
+    /**
+     * Get ETH balance
+     */
+    getETHBalance(): Promise<string>;
+    /**
+     * Get USDC balance (if USDC contract exists on network)
+     */
+    getUSDCBalance(): Promise<string>;
+    /**
+     * Execute traditional payment
+     */
+    executeTraditionalPayment(paymentMethod: PaymentMethod, amount: number, currency: string, paymentData: Record<string, any>): Record<string, any>;
+    /**
+     * Get supported payment methods
+     */
+    getSupportedPaymentMethods(): PaymentMethod[];
+    /**
+     * Get payment methods status
+     */
+    getPaymentMethodsStatus(): Record<string, boolean>;
+    /**
+     * Create Google AP2 intent mandate
+     */
+    createIntentMandate(userDescription: string, merchants?: string[], skus?: string[], requiresRefundability?: boolean, expiryMinutes?: number): GoogleAP2IntegrationResult;
+    /**
+     * Create Google AP2 cart mandate with JWT signing
+     */
+    createCartMandate(cartId: string, items: Array<{
+        name: string;
+        price: number;
+    }>, totalAmount: number, currency?: string, merchantName?: string, expiryMinutes?: number): Promise<GoogleAP2IntegrationResult>;
+    /**
+     * Verify JWT token
+     */
+    verifyJwtToken(token: string): Promise<Record<string, any>>;
+    /**
+     * Register function for integrity verification
+     */
+    registerFunction(func: (...args: any[]) => Promise<any>): void;
+    /**
+     * Execute function with integrity proof
+     */
+    executeWithIntegrityProof(functionName: string, args: Record<string, any>): Promise<{
+        result: any;
+        proof: Record<string, any>;
+    }>;
+    /**
+     * Verify integrity proof
+     */
+    verifyIntegrityProof(_proof: Record<string, any>): Promise<boolean>;
+    /**
+     * Upload data to storage
+     */
+    upload(data: any, _options?: UploadOptions): Promise<UploadResult>;
+    /**
+     * Download data from storage
+     */
+    download(cid: string): Promise<any>;
+    /**
+     * Store evidence (convenience method)
+     */
+    storeEvidence(evidenceData: Record<string, any>): Promise<string>;
+    /**
+     * Get wallet address
+     */
+    getAddress(): string;
+    /**
+     * Get wallet balance
+     */
+    getBalance(): Promise<bigint>;
+    /**
+     * Get network info
+     */
+    getNetworkInfo(): NetworkInfo;
+    /**
+     * Get SDK version
+     */
+    getVersion(): string;
+    /**
+     * Get SDK capabilities summary
+     */
+    getCapabilities(): Record<string, any>;
+    /**
+     * Check if Gateway is configured.
+     */
+    isGatewayEnabled(): boolean;
+    /**
+     * Get Gateway client instance.
+     * @throws Error if Gateway is not configured
+     */
+    getGateway(): GatewayClient;
+    /**
+     * Submit work via Gateway.
+     *
+     * The Gateway handles XMTP, DKG, Arweave archival, and on-chain submission.
+     */
+    submitWorkViaGateway(studioAddress: string, epoch: number, agentAddress: string, dataHash: string, threadRoot: string, evidenceRoot: string, evidenceContent: Buffer | string, signerAddress: string): Promise<WorkflowStatus>;
+    /**
+     * Submit score via Gateway.
+     */
+    submitScoreViaGateway(studioAddress: string, epoch: number, validatorAddress: string, dataHash: string, scores: number[], signerAddress: string, options?: {
+        workerAddress?: string;
+        salt?: string;
+        mode?: ScoreSubmissionMode;
+    }): Promise<WorkflowStatus>;
+    /**
+     * Close epoch via Gateway.
+     * WARNING: This is economically final and cannot be undone.
+     */
+    closeEpochViaGateway(studioAddress: string, epoch: number, signerAddress: string): Promise<WorkflowStatus>;
+    /**
+     * Wait for workflow completion.
+     */
+    waitWorkflow(workflowId: string, options?: {
+        maxWait?: number;
+        pollInterval?: number;
+        onProgress?: (status: WorkflowStatus) => void;
+    }): Promise<WorkflowStatus>;
+    buildMandateCore(kind: string, payload: Record<string, unknown>, baseUrl?: string): Record<string, unknown>;
+    createMandate(params: {
+        intent: string;
+        core: Record<string, unknown>;
+        deadline: string;
+        client: string;
+        server?: string;
+        version?: string;
+        mandateId?: string;
+        createdAt?: string;
+    }): any;
+    signMandateAsServer(mandate: any, privateKey?: string): any;
+    signMandateAsClient(mandate: any, privateKey: string): any;
+    verifyMandate(mandate: any): {
+        client_ok: boolean;
+        server_ok: boolean;
+        all_ok: boolean;
+        mandate_hash: string;
+    };
+    /**
+     * Create a new Studio on ChaosChain.
+     * @see StudioClient.createStudio for full documentation
+     */
+    createStudio(name: string, logicModuleAddress: string): Promise<{
+        proxyAddress: string;
+        studioId: bigint;
+    }>;
+    /**
+     * Register agent with a Studio.
+     * @see StudioClient.registerWithStudio for full documentation
+     */
+    registerWithStudio(studioAddress: string, agentId: string, role: number, stakeAmount?: bigint): Promise<string>;
+    /**
+     * Get pending rewards for an account.
+     * @see StudioClient.getPendingRewards for full documentation
+     */
+    getStudioPendingRewards(studioAddress: string, account: string): Promise<bigint>;
+    /**
+     * Withdraw pending rewards from a Studio.
+     * @see StudioClient.withdrawRewards for full documentation
+     */
+    withdrawStudioRewards(studioAddress: string): Promise<string>;
+}
+
+/**
+ * ChaosAgent - ERC-8004 v1.0 Contract Interactions
+ * Handles Identity, Reputation, and Validation Registry interactions
+ */
+
+declare class ChaosAgent {
+    private identityContract;
+    private reputationContract;
+    private validationContract;
+    private signer;
+    private _agentId;
+    constructor(addresses: ContractAddresses, signer: ethers.Signer, _provider: ethers.Provider);
+    /**
+     * Register a new agent identity (ERC-8004)
+     */
+    registerIdentity(metadata?: AgentMetadata): Promise<AgentRegistration>;
+    /**
+     * Get agent metadata
+     */
+    getAgentMetadata(agentId: bigint): Promise<AgentMetadata | null>;
+    /**
+     * Set agent URI
+     */
+    setAgentUri(agentId: bigint, uri: string): Promise<string>;
+    /**
+     * Update agent metadata
+     */
+    updateAgentMetadata(agentId: bigint, metadata: AgentMetadata): Promise<string>;
+    /**
+     * Check if agent exists
+     */
+    agentExists(agentId: bigint): Promise<boolean>;
+    /**
+     * Get agent owner
+     */
+    getAgentOwner(agentId: bigint): Promise<string>;
+    /**
+     * Get total number of agents
+     */
+    getTotalAgents(): Promise<bigint>;
+    /**
+     * Get the agent's on-chain ID (ERC-8004) with optional local caching.
+     *
+     * @param useCache - If true, check local cache first (default: true)
+     * @returns Agent ID if registered, null otherwise
+     */
+    getAgentId(useCache?: boolean): Promise<bigint | null>;
+    /**
+     * Manually set the agent ID (useful when known from external source).
+     * Sets both in-memory state AND saves to cache.
+     *
+     * @param agentId - The ERC-8004 agent ID to cache
+     */
+    setCachedAgentId(agentId: bigint): Promise<void>;
+    /**
+     * Transfer agent ownership
+     */
+    transferAgent(agentId: bigint, to: string): Promise<string>;
+    /**
+     * Generate EIP-191 signed feedback authorization (ERC-8004 v1.0)
+     *
+     * This signature allows a client to submit feedback to an agent's reputation.
+     * The agent owner signs to authorize the client to give feedback up to a certain index.
+     *
+     * @param agentId Target agent ID receiving feedback
+     * @param clientAddress Address of the client giving feedback
+     * @param indexLimit Maximum feedback index this authorization permits
+     * @param expiry Unix timestamp when authorization expires
+     * @returns Signed feedbackAuth bytes for use in giveFeedback()
+     */
+    generateFeedbackAuthorization(agentId: bigint, clientAddress: string, indexLimit: bigint, expiry: bigint): Promise<string>;
+    /**
+     * Give feedback to an agent (ERC-8004 Jan/Feb 2026)
+     *
+     * @param params Feedback parameters including agentId, rating, feedbackUri, and optional metadata
+     * @returns Transaction hash
+     */
+    giveFeedback(params: FeedbackParams): Promise<string>;
+    /**
+     * Revoke feedback (ERC-8004 v1.0)
+     * @param agentId Agent ID that received the feedback
+     * @param feedbackIndex Index of the feedback to revoke (uint64)
+     */
+    revokeFeedback(agentId: bigint, feedbackIndex: bigint): Promise<string>;
+    /**
+     * Append response to feedback (ERC-8004 v1.0)
+     * @param agentId Agent ID that received the feedback
+     * @param clientAddress Address of the client who gave feedback
+     * @param feedbackIndex Index of the feedback
+     * @param responseUri URI containing the response data
+     * @param responseHash Hash of the response content
+     */
+    appendResponse(agentId: bigint, clientAddress: string, feedbackIndex: bigint, responseUri: string, responseHash: string): Promise<string>;
+    /**
+     * Read specific feedback (ERC-8004 v1.0)
+     * @param agentId Agent ID that received the feedback
+     * @param clientAddress Address of the client who gave feedback
+     * @param index Index of the feedback
+     */
+    readFeedback(agentId: bigint, clientAddress: string, index: bigint): Promise<{
+        score: number;
+        value: bigint;
+        valueDecimals: number;
+        tag1: string;
+        tag2: string;
+        isRevoked: boolean;
+    }>;
+    /**
+     * Read all feedback for an agent (ERC-8004 v1.0)
+     * @param agentId Agent ID
+     * @param clientAddresses Array of client addresses (empty array for all clients)
+     * @param tag1 First tag filter (ZeroHash for no filter)
+     * @param tag2 Second tag filter (ZeroHash for no filter)
+     * @param includeRevoked Whether to include revoked feedback
+     */
+    readAllFeedback(agentId: bigint, clientAddresses?: string[], tag1?: string, tag2?: string, includeRevoked?: boolean): Promise<{
+        clients: string[];
+        feedbackIndexes: bigint[];
+        scores: number[];
+        valueDecimals: number[];
+        tag1s: string[];
+        tag2s: string[];
+        revokedStatuses: boolean[];
+    }>;
+    /**
+     * Get summary statistics (ERC-8004 v1.0)
+     * @param agentId Agent ID
+     * @param clientAddresses Array of client addresses (empty array for all clients)
+     * @param tag1 First tag filter (ZeroHash for no filter)
+     * @param tag2 Second tag filter (ZeroHash for no filter)
+     */
+    getSummary(agentId: bigint, clientAddresses?: string[], tag1?: string, tag2?: string): Promise<{
+        count: bigint;
+        averageScore: number;
+        averageScoreDecimals: number;
+    }>;
+    /**
+     * Get list of clients who gave feedback
+     * @param agentId Agent ID
+     */
+    getClients(agentId: bigint): Promise<string[]>;
+    /**
+     * Get last feedback index for a client
+     * @param agentId Agent ID
+     * @param clientAddress Client address
+     */
+    getLastIndex(agentId: bigint, clientAddress: string): Promise<bigint>;
+    /**
+     * Get identity registry address from reputation contract
+     */
+    getIdentityRegistry(): Promise<string>;
+    /**
+     * Request validation from a validator (ERC-8004 v1.0)
+     * @param validatorAddress Address of the validator
+     * @param agentId Agent ID requesting validation
+     * @param requestUri URI containing validation request data
+     * @param requestHash Hash of the request content (bytes32)
+     */
+    requestValidation(validatorAddress: string, agentId: bigint, requestUri: string, requestHash: string): Promise<string>;
+    /**
+     * Respond to validation request (ERC-8004 v1.0)
+     * @param requestHash Hash of the original validation request (bytes32)
+     * @param response Response score (0-100, where 100 = approved)
+     * @param responseUri URI containing response data
+     * @param responseHash Hash of the response content (bytes32)
+     * @param tag Optional tag for categorization (bytes32)
+     */
+    respondToValidation(requestHash: string, response: number, responseUri: string, responseHash: string, tag?: string): Promise<string>;
+    /**
+     * Get validation status (ERC-8004 v1.0)
+     * @param requestHash Hash of the validation request (bytes32)
+     */
+    getValidationStatus(requestHash: string): Promise<{
+        validatorAddress: string;
+        agentId: bigint;
+        response: number;
+        responseHash: string;
+        tag: string;
+        lastUpdate: bigint;
+    }>;
+    /**
+     * Get validation summary statistics (ERC-8004 v1.0)
+     * @param agentId Agent ID
+     * @param validatorAddresses Array of validator addresses (empty for all)
+     * @param tag Tag filter (ZeroHash for no filter)
+     */
+    getValidationSummary(agentId: bigint, validatorAddresses?: string[], tag?: string): Promise<{
+        count: bigint;
+        avgResponse: number;
+    }>;
+    /**
+     * Get all validation request hashes for an agent
+     * @param agentId Agent ID
+     */
+    getAgentValidations(agentId: bigint): Promise<string[]>;
+    /**
+     * Get all validation requests for a validator
+     * @param validatorAddress Validator address
+     */
+    getValidatorRequests(validatorAddress: string): Promise<string[]>;
+    /**
+     * Get identity registry address from validation contract
+     */
+    getValidationIdentityRegistry(): Promise<string>;
+    private getCachedFilePath;
+    private loadAgentIdFromCache;
+    private saveAgentIdTocache;
+    /**
+     * Listen for Registered events
+     */
+    onAgentRegistered(callback: (agentId: bigint, owner: string, uri: string) => void): void;
+    /**
+     * Listen for NewFeedback events (ERC-8004 v1.0)
+     */
+    onNewFeedback(callback: (agentId: bigint, clientAddress: string, score: number, tag1: string, tag2: string, feedbackUri: string, feedbackHash: string) => void): void;
+    /**
+     * Listen for ResponseAppended events (ERC-8004 v1.0)
+     */
+    onResponseAppended(callback: (agentId: bigint, clientAddress: string, feedbackIndex: bigint, responder: string, responseUri: string, responseHash: string) => void): void;
+    /**
+     * Listen for ValidationRequest events (ERC-8004 v1.0)
+     */
+    onValidationRequest(callback: (validatorAddress: string, agentId: bigint, requestUri: string, requestHash: string) => void): void;
+    /**
+     * Listen for ValidationResponse events (ERC-8004 v1.0)
+     */
+    onValidationResponse(callback: (validatorAddress: string, agentId: bigint, requestHash: string, response: number, responseUri: string, responseHash: string, tag: string) => void): void;
+    /**
+     * Remove all event listeners
+     */
+    removeAllListeners(): void;
+}
+
+/**
+ * Payment Manager for ChaosChain SDK
+ *
+ * This module manages traditional and crypto payment processing,
+ * supporting multiple payment methods (cards, Google Pay, Apple Pay, PayPal, crypto).
+ */
+
+interface TraditionalPaymentResult {
+    payment_id: string;
+    transaction_id: string;
+    status: string;
+    amount: number;
+    currency: string;
+    payment_method: PaymentMethod;
+    timestamp: string;
+    processor_response?: Record<string, any>;
+}
+interface PaymentMethodCredentials {
+    stripe_secret_key?: string;
+    google_pay_merchant_id?: string;
+    apple_pay_merchant_id?: string;
+    paypal_client_id?: string;
+    paypal_client_secret?: string;
+}
+/**
+ * Payment Manager - handles all payment types
+ *
+ * Supports:
+ * - Basic card payments (Visa, Mastercard via Stripe)
+ * - Google Pay
+ * - Apple Pay
+ * - PayPal
+ * - Cryptocurrency (via x402 protocol)
+ */
+declare class PaymentManager {
+    private agentName;
+    private network;
+    private wallet;
+    private credentials;
+    private stripeAxiosInstance?;
+    private paypalAccessToken?;
+    constructor(agentName: string, network: NetworkConfig, wallet: ethers.Wallet | ethers.HDNodeWallet, credentials?: PaymentMethodCredentials);
+    /**
+     * Initialize PayPal OAuth access token
+     */
+    private initializePayPal;
+    /**
+     * Execute traditional payment (cards, wallets, etc.)
+     */
+    executeTraditionalPayment(paymentMethod: PaymentMethod, amount: number, currency: string, paymentData: Record<string, any>): TraditionalPaymentResult;
+    /**
+     * Process Basic Card payment (Visa, Mastercard, Amex, etc.) via Stripe
+     */
+    private processBasicCard;
+    /**
+     * Process Google Pay payment
+     */
+    private processGooglePay;
+    /**
+     * Process Apple Pay payment
+     */
+    private processApplePay;
+    /**
+     * Process PayPal payment
+     */
+    private processPayPal;
+    /**
+     * Process A2A-x402 crypto payment
+     */
+    private processA2AX402;
+    /**
+     * Simulate traditional payment (for testing/fallback)
+     */
+    private simulateTraditionalPayment;
+    /**
+     * Get payment method configuration status
+     */
+    getPaymentMethodsStatus(): Record<string, boolean>;
+    /**
+     * Get supported payment methods
+     */
+    getSupportedPaymentMethods(): PaymentMethod[];
+    /**
+     * Validate payment method credentials
+     */
+    validateCredentials(): Promise<Record<string, boolean>>;
+    /**
+     * Create x402 payment request (for crypto payments)
+     */
+    createX402PaymentRequest(fromAgent: string, toAgent: string, amount: number, currency: string, serviceDescription: string): Record<string, any>;
+    /**
+     * Execute x402 crypto payment (delegated to X402PaymentManager)
+     */
+    executeX402Payment(paymentRequest: Record<string, any>): Record<string, any>;
+    /**
+     * Get payment statistics
+     */
+    getPaymentStats(): Record<string, any>;
+}
+
+/**
+ * Storage Backends for ChaosChain SDK
+ *
+ * This module provides a unified interface for multiple storage providers,
+ * allowing seamless switching between IPFS, Pinata, Irys, and 0G Storage.
+ */
+interface StorageResult {
+    cid: string;
+    url?: string;
+    size?: number;
+    provider: string;
+}
+interface StorageBackend {
+    put(data: Buffer | string, mime?: string): Promise<StorageResult>;
+    get(cid: string): Promise<Buffer>;
+    pin?(cid: string): Promise<void>;
+    unpin?(cid: string): Promise<void>;
+}
+/**
+ * Local IPFS Storage Backend
+ *
+ * Requires: ipfs daemon running locally
+ * Cost: Free
+ * Setup: brew install ipfs && ipfs daemon
+ */
+declare class LocalIPFSStorage implements StorageBackend {
+    private apiUrl;
+    constructor(apiUrl?: string);
+    put(data: Buffer | string, mime?: string): Promise<StorageResult>;
+    get(cid: string): Promise<Buffer>;
+    pin(cid: string): Promise<void>;
+    unpin(cid: string): Promise<void>;
+}
+/**
+ * Pinata Cloud IPFS Storage Backend
+ *
+ * Requires: Pinata API key
+ * Cost: Free tier + paid plans
+ * Setup: Get JWT from https://pinata.cloud
+ */
+declare class PinataStorage implements StorageBackend {
+    private jwtToken;
+    private gatewayUrl;
+    constructor(jwtToken: string, gatewayUrl?: string);
+    put(data: Buffer | string, mime?: string): Promise<StorageResult>;
+    get(cid: string): Promise<Buffer>;
+    pin(cid: string): Promise<void>;
+    unpin(cid: string): Promise<void>;
+}
+/**
+ * Irys (Arweave) Storage Backend
+ *
+ * Requires: Arweave wallet key
+ * Cost: Pay per upload (permanent storage)
+ * Setup: Fund wallet with AR tokens
+ */
+declare class IrysStorage implements StorageBackend {
+    private walletKey;
+    constructor(walletKey: string);
+    /** Get wallet key (for future SDK integration) */
+    getWalletKey(): string;
+    put(_data: Buffer | string, _mime?: string): Promise<StorageResult>;
+    get(cid: string): Promise<Buffer>;
+}
+/**
+ * 0G Storage Backend
+ *
+ * Requires: 0G CLI running as sidecar
+ * Cost: Gas fees on 0G Network
+ * Setup: Install 0G CLI and start sidecar
+ */
+declare class ZeroGStorage implements StorageBackend {
+    private grpcUrl;
+    private privateKey;
+    constructor(privateKey: string, grpcUrl?: string);
+    /** Get gRPC URL (for connection management) */
+    getGrpcUrl(): string;
+    /** Get private key (for signing) */
+    getPrivateKey(): string;
+    put(_data: Buffer | string, _mime?: string): Promise<StorageResult>;
+    get(_cid: string): Promise<Buffer>;
+}
+/**
+ * Auto-detecting Storage Manager
+ *
+ * Automatically selects the best available storage backend:
+ * 1. Try local IPFS first (fastest, free)
+ * 2. Fall back to Pinata if configured
+ * 3. Fall back to Irys if configured
+ * 4. Fall back to 0G Storage if configured
+ */
+declare class AutoStorageManager implements StorageBackend {
+    private backends;
+    private preferredBackend;
+    constructor();
+    private detectAvailableBackends;
+    put(data: Buffer | string, mime?: string): Promise<StorageResult>;
+    get(cid: string): Promise<Buffer>;
+    getAvailableBackends(): string[];
+}
+
+/**
+ * Exception classes for the ChaosChain SDK.
+ *
+ * This module defines all custom exceptions used throughout the SDK
+ * to provide clear error handling and debugging information.
+ */
+declare class ChaosChainSDKError extends Error {
+    details: Record<string, any>;
+    constructor(message: string, details?: Record<string, any>);
+    toString(): string;
+}
+declare class AgentRegistrationError extends ChaosChainSDKError {
+    constructor(message: string, details?: Record<string, any>);
+}
+declare class PaymentError extends ChaosChainSDKError {
+    constructor(message: string, details?: Record<string, any>);
+}
+declare class StorageError extends ChaosChainSDKError {
+    constructor(message: string, details?: Record<string, any>);
+}
+declare class IntegrityVerificationError extends ChaosChainSDKError {
+    constructor(message: string, details?: Record<string, any>);
+}
+declare class ContractError extends ChaosChainSDKError {
+    constructor(message: string, details?: Record<string, any>);
+}
+declare class ValidationError extends ChaosChainSDKError {
+    constructor(message: string, details?: Record<string, any>);
+}
+declare class ConfigurationError extends ChaosChainSDKError {
+    constructor(message: string, details?: Record<string, any>);
+}
+/**
+ * Options passed when constructing a GatewayError (statusCode, response, category, retryable).
+ */
+interface GatewayErrorDetails {
+    statusCode?: number;
+    response?: Record<string, any>;
+    category?: 'transient' | 'permanent' | 'auth' | 'unknown';
+    retryable?: boolean;
+}
+/**
+ * Base error from Gateway API.
+ */
+declare class GatewayError extends ChaosChainSDKError {
+    readonly statusCode?: number;
+    readonly response?: Record<string, any>;
+    readonly category?: 'transient' | 'permanent' | 'auth' | 'unknown';
+    readonly retryable?: boolean;
+    constructor(message: string, details?: GatewayErrorDetails);
+}
+/**
+ * Failed to connect to Gateway.
+ */
+declare class GatewayConnectionError extends GatewayError {
+    constructor(message: string);
+}
+/**
+ * Gateway request or polling timed out.
+ */
+declare class GatewayTimeoutError extends GatewayError {
+    readonly workflowId: string;
+    readonly lastStatus?: WorkflowStatus;
+    constructor(workflowId: string, message: string, lastStatus?: WorkflowStatus);
+}
+/**
+ * Workflow reached FAILED state.
+ */
+declare class WorkflowFailedError extends GatewayError {
+    readonly workflowId: string;
+    readonly workflowError: WorkflowError;
+    constructor(workflowId: string, error: WorkflowError);
+}
+
+/**
+ * ERC-8004 v1.0 Contract ABIs and Addresses
+ *
+ * Complete ABIs extracted from Python SDK (chaos_agent.py lines 155-637)
+ *
+ * This module contains the complete ABIs for all ERC-8004 v1.0 contracts.
+ * These are the official ABIs deployed on testnets.
+ */
+/**
+ * Get embedded Identity Registry ABI for ERC-8004 v1.0.
+ *
+ * v1.0 uses ERC-721 with URIStorage extension. Key changes:
+ * - register() functions replace newAgent()
+ * - Agents are ERC-721 NFTs with tokenURI
+ * - ownerOf() to get agent owner
+ * - tokenURI() to get registration file
+ */
+declare const IDENTITY_REGISTRY_ABI: ({
+    inputs: ({
+        name: string;
+        type: string;
+        components?: undefined;
+    } | {
+        name: string;
+        type: string;
+        components: {
+            name: string;
+            type: string;
+        }[];
+    })[];
+    name: string;
+    outputs: {
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+} | {
+    anonymous: boolean;
+    inputs: {
+        indexed: boolean;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    outputs?: undefined;
+    stateMutability?: undefined;
+})[];
+/**
+ * Get Reputation Registry ABI (ERC-8004 Feb 2026)
+ *
+ * Feb 2026 KEY CHANGES from Oct 2025:
+ * - REMOVED feedbackAuth parameter - feedback is now permissionless
+ * - ADDED endpoint parameter for endpoint being reviewed
+ * - CHANGED tag1, tag2 from bytes32 to string
+ * - ADDED feedbackIndex to NewFeedback event
+ * - readFeedback returns string tags and feedbackIndex parameter renamed
+ *
+ * Feb 2026 ABI UPDATE:
+ * - CHANGED score (uint8) to value (int128) + valueDecimals (uint8)
+ * - getSummary returns summaryValue (int128) + summaryValueDecimals (uint8)
+ * - readFeedback returns value (int128) + valueDecimals (uint8)
+ */
+declare const REPUTATION_REGISTRY_ABI: ({
+    inputs: {
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+} | {
+    anonymous: boolean;
+    inputs: {
+        indexed: boolean;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    outputs?: undefined;
+    stateMutability?: undefined;
+})[];
+/**
+ * Get Validation Registry ABI (ERC-8004 v1.0)
+ *
+ * v1.0 uses URI-based validation with off-chain evidence storage.
+ * Key changes:
+ * - validationRequest() uses validatorAddress instead of validatorAgentId
+ * - requestUri and requestHash for off-chain evidence
+ * - validationResponse() uses requestHash with response (0-100)
+ * - Support for multiple responses per request (progressive validation)
+ */
+declare const VALIDATION_REGISTRY_ABI: readonly [{
+    readonly inputs: readonly [{
+        readonly name: "validatorAddress";
+        readonly type: "address";
+    }, {
+        readonly name: "agentId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "requestUri";
+        readonly type: "string";
+    }, {
+        readonly name: "requestHash";
+        readonly type: "bytes32";
+    }];
+    readonly name: "validationRequest";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "requestHash";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "response";
+        readonly type: "uint8";
+    }, {
+        readonly name: "responseUri";
+        readonly type: "string";
+    }, {
+        readonly name: "responseHash";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "tag";
+        readonly type: "bytes32";
+    }];
+    readonly name: "validationResponse";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "requestHash";
+        readonly type: "bytes32";
+    }];
+    readonly name: "getValidationStatus";
+    readonly outputs: readonly [{
+        readonly name: "validatorAddress";
+        readonly type: "address";
+    }, {
+        readonly name: "agentId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "response";
+        readonly type: "uint8";
+    }, {
+        readonly name: "responseHash";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "tag";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "lastUpdate";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "agentId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "validatorAddresses";
+        readonly type: "address[]";
+    }, {
+        readonly name: "tag";
+        readonly type: "bytes32";
+    }];
+    readonly name: "getSummary";
+    readonly outputs: readonly [{
+        readonly name: "count";
+        readonly type: "uint64";
+    }, {
+        readonly name: "avgResponse";
+        readonly type: "uint8";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "agentId";
+        readonly type: "uint256";
+    }];
+    readonly name: "getAgentValidations";
+    readonly outputs: readonly [{
+        readonly name: "requestHashes";
+        readonly type: "bytes32[]";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "validatorAddress";
+        readonly type: "address";
+    }];
+    readonly name: "getValidatorRequests";
+    readonly outputs: readonly [{
+        readonly name: "requestHashes";
+        readonly type: "bytes32[]";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "getIdentityRegistry";
+    readonly outputs: readonly [{
+        readonly name: "registry";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "validatorAddress";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "agentId";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly name: "requestUri";
+        readonly type: "string";
+    }, {
+        readonly indexed: true;
+        readonly name: "requestHash";
+        readonly type: "bytes32";
+    }];
+    readonly name: "ValidationRequest";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "validatorAddress";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "agentId";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: true;
+        readonly name: "requestHash";
+        readonly type: "bytes32";
+    }, {
+        readonly indexed: false;
+        readonly name: "response";
+        readonly type: "uint8";
+    }, {
+        readonly indexed: false;
+        readonly name: "responseUri";
+        readonly type: "string";
+    }, {
+        readonly indexed: false;
+        readonly name: "responseHash";
+        readonly type: "bytes32";
+    }, {
+        readonly indexed: false;
+        readonly name: "tag";
+        readonly type: "bytes32";
+    }];
+    readonly name: "ValidationResponse";
+    readonly type: "event";
+}];
+/**
+ * ChaosCore ABI - Factory for creating Studios
+ *
+ * Methods:
+ * - createStudio(name, logicModule) -> (proxy, studioId)
+ */
+declare const CHAOS_CORE_ABI: readonly [{
+    readonly inputs: readonly [{
+        readonly name: "name";
+        readonly type: "string";
+    }, {
+        readonly name: "logicModule";
+        readonly type: "address";
+    }];
+    readonly name: "createStudio";
+    readonly outputs: readonly [{
+        readonly name: "proxy";
+        readonly type: "address";
+    }, {
+        readonly name: "studioId";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "studioId";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly name: "proxy";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly name: "logicModule";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "creator";
+        readonly type: "address";
+    }];
+    readonly name: "StudioCreated";
+    readonly type: "event";
+}];
+/**
+ * StudioProxy ABI - Main Studio contract for work submission and scoring
+ *
+ * Methods:
+ * - registerAgent(agentId, role) [payable] - Register agent with stake
+ * - submitWork(dataHash, threadRoot, evidenceRoot, feedbackAuth) - Submit single-agent work
+ * - submitWorkMultiAgent(dataHash, threadRoot, evidenceRoot, participants, contributionWeights, evidenceCID) - Multi-agent work
+ * - commitScore(dataHash, commitment) - Commit phase of commit-reveal
+ * - revealScore(dataHash, scoreVector, salt) - Reveal phase
+ * - getWithdrawableBalance(account) -> balance - Query pending rewards
+ * - withdrawRewards() - Withdraw pending rewards
+ */
+declare const STUDIO_PROXY_ABI: readonly [{
+    readonly inputs: readonly [{
+        readonly name: "agentId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "role";
+        readonly type: "uint8";
+    }];
+    readonly name: "registerAgent";
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "dataHash";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "threadRoot";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "evidenceRoot";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "feedbackAuth";
+        readonly type: "bytes";
+    }];
+    readonly name: "submitWork";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "dataHash";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "threadRoot";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "evidenceRoot";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "participants";
+        readonly type: "address[]";
+    }, {
+        readonly name: "contributionWeights";
+        readonly type: "uint16[]";
+    }, {
+        readonly name: "evidenceCID";
+        readonly type: "string";
+    }];
+    readonly name: "submitWorkMultiAgent";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "dataHash";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "commitment";
+        readonly type: "bytes32";
+    }];
+    readonly name: "commitScore";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "dataHash";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "scoreVector";
+        readonly type: "bytes";
+    }, {
+        readonly name: "salt";
+        readonly type: "bytes32";
+    }];
+    readonly name: "revealScore";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "dataHash";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "scoreVector";
+        readonly type: "bytes";
+    }];
+    readonly name: "submitScoreVector";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "dataHash";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "workerAddress";
+        readonly type: "address";
+    }, {
+        readonly name: "scoreVector";
+        readonly type: "bytes";
+    }];
+    readonly name: "submitScoreVectorForWorker";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+    }];
+    readonly name: "getWithdrawableBalance";
+    readonly outputs: readonly [{
+        readonly name: "balance";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "withdrawRewards";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "dataHash";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "feedbackAuth";
+        readonly type: "bytes";
+    }];
+    readonly name: "registerFeedbackAuth";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "agentId";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: true;
+        readonly name: "agentAddress";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly name: "role";
+        readonly type: "uint8";
+    }, {
+        readonly indexed: false;
+        readonly name: "stake";
+        readonly type: "uint256";
+    }];
+    readonly name: "AgentRegistered";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "dataHash";
+        readonly type: "bytes32";
+    }, {
+        readonly indexed: true;
+        readonly name: "submitter";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly name: "threadRoot";
+        readonly type: "bytes32";
+    }, {
+        readonly indexed: false;
+        readonly name: "evidenceRoot";
+        readonly type: "bytes32";
+    }];
+    readonly name: "WorkSubmitted";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "dataHash";
+        readonly type: "bytes32";
+    }, {
+        readonly indexed: true;
+        readonly name: "validator";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly name: "commitment";
+        readonly type: "bytes32";
+    }];
+    readonly name: "ScoreCommitted";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "dataHash";
+        readonly type: "bytes32";
+    }, {
+        readonly indexed: true;
+        readonly name: "validator";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly name: "scoreVector";
+        readonly type: "bytes";
+    }];
+    readonly name: "ScoreRevealed";
+    readonly type: "event";
+}];
+/**
+ * RewardsDistributor ABI - Manages epoch closure and reward distribution
+ *
+ * Methods:
+ * - closeEpoch(studio, epoch) - Close an epoch and trigger reward distribution
+ */
+declare const REWARDS_DISTRIBUTOR_ABI: readonly [{
+    readonly inputs: readonly [{
+        readonly name: "studio";
+        readonly type: "address";
+    }, {
+        readonly name: "epoch";
+        readonly type: "uint64";
+    }];
+    readonly name: "closeEpoch";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "studio";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "epoch";
+        readonly type: "uint64";
+    }, {
+        readonly indexed: false;
+        readonly name: "totalRewards";
+        readonly type: "uint256";
+    }];
+    readonly name: "EpochClosed";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "studio";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "recipient";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "RewardsDistributed";
+    readonly type: "event";
+}];
+/**
+ * StudioFactory ABI - Factory for creating Studios (alternative to ChaosCore)
+ */
+declare const STUDIO_FACTORY_ABI: readonly [{
+    readonly inputs: readonly [{
+        readonly name: "name";
+        readonly type: "string";
+    }, {
+        readonly name: "logicModule";
+        readonly type: "address";
+    }];
+    readonly name: "createStudio";
+    readonly outputs: readonly [{
+        readonly name: "proxy";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}];
+
+interface Task {
+    taskId: string;
+    studioAddress: string;
+    requirements: Record<string, any>;
+    status: string;
+    createdAt: Date;
+    assignedTo?: string;
+    assignedAt?: Date;
+}
+interface WorkerBid {
+    bidId: string;
+    taskId: string;
+    workerAddress: string;
+    workerAgentId: number;
+    proposedPrice: number;
+    estimatedTimeHours: number;
+    capabilities: string[];
+    reputationScore: number;
+    message: string;
+    submittedAt: Date;
+}
+interface StudioManagerConfig {
+    sdk: ChaosChainSDK;
+    messenger?: {
+        sendMessage: (params: {
+            toAgent: string;
+            messageType: string;
+            content: Record<string, any>;
+        }) => Promise<string>;
+    };
+}
+declare class StudioManager {
+    private sdk;
+    private messenger?;
+    private activeTasks;
+    private workerBids;
+    constructor(config: StudioManagerConfig);
+    getRegisteredWorkers(_studioAddress: string): string[];
+    broadcastTask(studioAddress: string, taskRequirements: Record<string, any>, registeredWorkers: string[]): Promise<string>;
+    collectBids(taskId: string, timeoutSeconds?: number): Promise<WorkerBid[]>;
+    submitBid(taskId: string, workerAddress: string, workerAgentId: number, proposedPrice: number, estimatedTimeHours: number, capabilities: string[], message?: string): string;
+    getWorkerReputations(workerAddresses: string[]): Record<string, number>;
+    selectWorker(bids: WorkerBid[], reputationScores: Record<string, number>, weights?: Record<string, number>): string;
+    assignTask(taskId: string, workerAddress: string, budget: number): Promise<string>;
+    private displayBids;
+}
+
+/**
+ * ChaosChain SDK - TypeScript Entry Point
+ *
+ * Complete TypeScript implementation with feature parity to Python SDK
+ *
+ * @packageDocumentation
+ */
+
+declare const SDK_VERSION = "0.2.3";
+declare const ERC8004_VERSION = "1.0";
+declare const X402_VERSION = "1.0";
+
+/**
+ * Initialize ChaosChain SDK with minimal configuration
+ *
+ * @example
+ * ```typescript
+ * import { initChaosChainSDK, ChaosChainSDK } from '@chaoschain/sdk';
+ *
+ * const sdk = initChaosChainSDK({
+ *   agentName: 'MyAgent',
+ *   agentDomain: 'myagent.example.com',
+ *   agentRole: 'server',
+ *   network: 'base-sepolia',
+ *   privateKey: process.env.PRIVATE_KEY
+ * });
+ *
+ * const { agentId } = await sdk.registerIdentity();
+ * console.log(`Agent registered with ID: ${agentId}`);
+ * ```
+ */
+declare function initChaosChainSDK(config: {
+    agentName: string;
+    agentDomain: string;
+    agentRole: string;
+    network: string;
+    privateKey?: string;
+    mnemonic?: string;
+    rpcUrl?: string;
+    enablePayments?: boolean;
+    enableAP2?: boolean;
+    enableProcessIntegrity?: boolean;
+    enableStorage?: boolean;
+}): ChaosChainSDK;
+
+export { A2AX402Extension, AgentMetadata, AgentRegistration, AgentRegistrationError, AgentRole, AutoStorageManager, CHAOS_CORE_ABI, ChaosAgent, ChaosChainSDK, ChaosChainSDKConfig, ChaosChainSDKError, ConfigurationError, ContractAddresses, ContractError, ERC8004_VERSION, FeedbackParams, GatewayClient, GatewayClientConfig, GatewayConnectionError, GatewayError, GatewayTimeoutError, GoogleAP2Integration, IDENTITY_REGISTRY_ABI, PinataStorage as IPFSPinataStorage, IntegrityProof, IntegrityVerificationError, IrysStorage, IrysStorage as IrysStorageProvider, LocalIPFSStorage, MandateManager, NetworkConfig, PaymentError, type PaymentHeader, PaymentManager, PaymentMethod, PendingWorkResponse, PinataStorage, REPUTATION_REGISTRY_ABI, REWARDS_DISTRIBUTOR_ABI, ValidationError as SDKValidationError, SDK_VERSION, STUDIO_FACTORY_ABI, STUDIO_PROXY_ABI, type SettleRequest, type SettleResponse, type StorageBackend, StorageError, type StorageResult, StudioClient, type StudioClientConfig, StudioManager, type StudioManagerConfig, type Task, type TransferAuthorizationParams, UploadOptions, UploadResult, VALIDATION_REGISTRY_ABI, WalletConfig, WalletManager, WorkEvidenceResponse, type WorkerBid, WorkflowError, WorkflowFailedError, WorkflowStatus, type X402FacilitatorConfig, X402PaymentManager, type X402PaymentProof, type X402PaymentRequest$1 as X402PaymentRequest, type X402PaymentRequirements, X402Server, X402_VERSION, ZeroGStorage, ChaosChainSDK as default, getContractAddresses, getNetworkInfo, initChaosChainSDK };