@hivemind-os/collective-core 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,1675 @@
+import { DID, NetworkConfig, Capability, AgentCard, ReputationScore, Task, Bid, BidRecommendation, Dispute, MeshEvent, PaymentRail, RelayListFilters, RelayNode, SpendingPolicy, ReputationEvent, ReputationAnchor, ReputationEventType, StakePosition, HashChainProof, MeteringReport, StreamingPaymentState, ProviderScore, MultiProviderRequest, MultiProviderResult, ProviderSelectionStrategy } from '@hivemind-os/collective-types';
+export * from '@hivemind-os/collective-types';
+import { Signer } from '@mysten/sui/cryptography';
+import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
+import { SuiClient, SuiTransactionBlockResponseOptions, SuiTransactionBlockResponse, EventId, SuiEvent } from '@mysten/sui/client';
+import pino from 'pino';
+import { Transaction } from '@mysten/sui/transactions';
+import { Chain, WalletClient, PublicClient } from 'viem';
+
+interface KeytarModule {
+    getPassword(service: string, account: string): Promise<string | null>;
+    setPassword(service: string, account: string, password: string): Promise<void>;
+}
+interface SimpleKeypair {
+    publicKey: Uint8Array;
+    secretKey: Uint8Array;
+}
+interface KeyStore {
+    load(): Promise<Uint8Array>;
+    save(secretKey: Uint8Array): Promise<void>;
+    exists(): Promise<boolean>;
+}
+declare class FileKeyStore implements KeyStore {
+    private readonly keyPath;
+    constructor(keyPath: string);
+    load(): Promise<Uint8Array>;
+    save(secretKey: Uint8Array): Promise<void>;
+    exists(): Promise<boolean>;
+    delete(): void;
+}
+declare class KeychainStore implements KeyStore {
+    private readonly keytar;
+    private readonly service;
+    private readonly account;
+    constructor(keytar: KeytarModule, service?: string, account?: string);
+    load(): Promise<Uint8Array>;
+    save(secretKey: Uint8Array): Promise<void>;
+    exists(): Promise<boolean>;
+}
+declare function generateKeypair(): SimpleKeypair;
+declare function keypairFromSecretKey(secretKey: Uint8Array): SimpleKeypair;
+declare function createKeyStore(dataDir: string): Promise<KeyStore>;
+declare function identityKeyExists(dataDir: string): Promise<boolean>;
+declare function loadOrCreateKeypair(dataDir: string): Promise<SimpleKeypair>;
+
+declare function createDID(publicKey: Uint8Array): DID;
+declare function parseDID(did: string): {
+    publicKey: Uint8Array;
+};
+declare function isValidDID(did: string): boolean;
+
+declare function sign(message: Uint8Array, secretKey: Uint8Array): Uint8Array;
+declare function verify(message: Uint8Array, signature: Uint8Array, publicKey: Uint8Array): boolean;
+declare function signString(message: string, secretKey: Uint8Array): string;
+
+interface X25519KeyPair {
+    publicKey: Uint8Array;
+    privateKey: Uint8Array;
+}
+declare function generateX25519KeyPair(): X25519KeyPair;
+declare function ed25519ToX25519(ed25519PrivateKey: Uint8Array): X25519KeyPair;
+declare function computeSharedSecret(myPrivateKey: Uint8Array, theirPublicKey: Uint8Array): Uint8Array;
+
+interface EncryptedPayload {
+    version: 1;
+    senderPublicKey: string;
+    nonce: string;
+    ciphertext: string;
+    tag: string;
+}
+declare function encryptForRecipient(plaintext: Uint8Array, senderPrivateKey: Uint8Array, recipientPublicKey: Uint8Array): Promise<EncryptedPayload>;
+declare function decryptFromSender(payload: EncryptedPayload, recipientPrivateKey: Uint8Array): Promise<Uint8Array>;
+declare function serializeEncryptedPayload(payload: EncryptedPayload): Uint8Array;
+declare function parseEncryptedPayload(data: Uint8Array): EncryptedPayload | null;
+declare function isEncryptedPayload(value: unknown): value is EncryptedPayload;
+
+declare enum SessionState {
+    VALID = "valid",
+    REFRESHING = "refreshing",
+    NEEDS_REAUTH = "needs_reauth",
+    EXPIRED = "expired"
+}
+interface SessionRefreshPolicy {
+    maxAttempts?: number;
+    backoffMs?: readonly number[];
+    maxConsecutiveFailures?: number;
+}
+interface SessionStateChangeEvent {
+    previousState: SessionState;
+    currentState: SessionState;
+    session: StoredZkLoginSession | null;
+    reason?: string;
+    refreshFailureCount: number;
+    error?: unknown;
+}
+type SessionStateChangeCallback = (event: SessionStateChangeEvent) => void;
+
+type AuthMode = 'ed25519' | 'zklogin';
+type OAuthProvider = 'google' | 'apple';
+interface AuthProvider {
+    mode: AuthMode;
+    getAddress(): Promise<string>;
+    getDID(): string;
+    signTransaction(tx: Uint8Array): Promise<Uint8Array>;
+    signPersonalMessage(message: Uint8Array): Promise<{
+        signature: Uint8Array;
+    }>;
+    isAuthenticated(): boolean;
+    getPublicKey(): Uint8Array;
+    toSuiSigner(): Signer;
+    getSessionState?(): SessionState;
+    isSessionValid?(): boolean | Promise<boolean>;
+    onSessionStateChange?(callback: SessionStateChangeCallback): () => void;
+}
+interface ZkLoginSession {
+    provider: OAuthProvider;
+    jwt: string;
+    salt: string;
+    epoch: number;
+    ephemeralKeypair: Ed25519Keypair;
+    proof: ZkLoginProof;
+    maxEpoch: number;
+    address: string;
+    sub: string;
+    iss: string;
+    aud: string;
+}
+interface StoredZkLoginSession extends ZkLoginSession {
+    randomness: string;
+    refreshToken?: string;
+    createdAt: number;
+    updatedAt: number;
+    sessionState?: SessionState;
+    refreshFailureCount?: number;
+}
+interface ZkLoginProof {
+    proofPoints: {
+        a: string[];
+        b: string[][];
+        c: string[];
+    };
+    issBase64Details: {
+        value: string;
+        indexMod4: number;
+    };
+    headerBase64: string;
+    addressSeed: string;
+}
+interface OAuthConfig {
+    provider: OAuthProvider;
+    clientId: string;
+    redirectUri: string;
+    authorizationEndpoint?: string;
+    tokenEndpoint?: string;
+    deviceCodeEndpoint?: string;
+    saltEndpoint?: string;
+    proverEndpoint?: string;
+    issuer?: string;
+    scopes?: string[];
+}
+interface OAuthTokenResponse {
+    jwt: string;
+    refreshToken?: string;
+    accessToken?: string;
+    expiresIn?: number;
+    tokenType?: string;
+    scope?: string;
+}
+interface DeviceFlowStatus {
+    userCode: string;
+    verificationUri: string;
+    deviceCode: string;
+    pollInterval: number;
+    expiresIn: number;
+}
+
+interface SessionContext {
+    address: string;
+    iss: string;
+    maxEpoch: number;
+    updatedAt: number;
+}
+interface SessionRefreshErrorOptions {
+    attempts: number;
+    maxAttempts: number;
+    retryDelaysMs: readonly number[];
+    consecutiveFailures: number;
+    sessionState: SessionState;
+    session?: StoredZkLoginSession | null;
+    cause?: unknown;
+}
+declare class SessionRefreshError extends Error {
+    readonly attempts: number;
+    readonly maxAttempts: number;
+    readonly retryDelaysMs: readonly number[];
+    readonly consecutiveFailures: number;
+    readonly sessionState: SessionState;
+    readonly session?: SessionContext;
+    constructor(message: string, options: SessionRefreshErrorOptions);
+}
+interface SessionExpiredErrorOptions {
+    attempts?: number;
+    maxAttempts?: number;
+    retryDelaysMs?: readonly number[];
+    consecutiveFailures?: number;
+    sessionState?: SessionState;
+    session?: StoredZkLoginSession | null;
+    cause?: unknown;
+}
+declare class SessionExpiredError extends Error {
+    readonly attempts?: number;
+    readonly maxAttempts?: number;
+    readonly retryDelaysMs?: readonly number[];
+    readonly consecutiveFailures?: number;
+    readonly sessionState: SessionState;
+    readonly session?: SessionContext;
+    constructor(message: string, options?: SessionExpiredErrorOptions);
+}
+
+declare class Ed25519AuthProvider implements AuthProvider {
+    private readonly keypair;
+    readonly mode: "ed25519";
+    constructor(keypair: Ed25519Keypair);
+    getAddress(): Promise<string>;
+    getDID(): string;
+    signTransaction(tx: Uint8Array): Promise<Uint8Array>;
+    signPersonalMessage(message: Uint8Array): Promise<{
+        signature: Uint8Array;
+    }>;
+    isAuthenticated(): boolean;
+    getPublicKey(): Uint8Array;
+    toSuiSigner(): Ed25519Keypair;
+}
+
+type SessionStoreLogger = Pick<ReturnType<typeof pino>, 'info' | 'warn' | 'error'>;
+interface ZkLoginSessionStoreOptions {
+    refresh?: SessionRefreshPolicy;
+    logger?: SessionStoreLogger;
+    onSessionStateChange?: SessionStateChangeCallback;
+    sleep?: (ms: number) => Promise<void>;
+}
+declare class ZkLoginSessionStore {
+    private readonly baseDir;
+    private readonly encryptionKey;
+    private readonly legacyEncryptionKey;
+    private readonly refreshPolicy;
+    private readonly logger;
+    private readonly sleep;
+    private readonly stateChangeListeners;
+    private sessionState;
+    private refreshFailureCount;
+    constructor(baseDir: string, encryptionKey: Uint8Array, options?: ZkLoginSessionStoreOptions);
+    getSessionState(): SessionState;
+    getRefreshFailureCount(): number;
+    onSessionStateChange(callback: SessionStateChangeCallback): () => void;
+    save(session: StoredZkLoginSession): Promise<void>;
+    loadLatest(): Promise<StoredZkLoginSession | null>;
+    loadAll(): Promise<StoredZkLoginSession[]>;
+    loadLatestValid(currentEpoch: number): Promise<StoredZkLoginSession | null>;
+    hasValidSession(currentEpoch: number): Promise<boolean>;
+    isExpired(session: Pick<StoredZkLoginSession, 'maxEpoch'>, currentEpoch: number): boolean;
+    isNearExpiry(session: Pick<StoredZkLoginSession, 'maxEpoch'>, currentEpoch: number, remainingEpochs?: number): boolean;
+    refreshIfNeeded(currentEpoch: number, refresher: (session: StoredZkLoginSession) => Promise<StoredZkLoginSession | null>, options?: {
+        force?: boolean;
+    }): Promise<StoredZkLoginSession | null>;
+    delete(session: Pick<StoredZkLoginSession, 'iss' | 'sub'>): Promise<void>;
+    deleteExpired(currentEpoch: number): Promise<void>;
+    private serializeSession;
+    private deserializeSession;
+    private normalizeSession;
+    private resolveSessionState;
+    private updateSessionState;
+    private encrypt;
+    private decrypt;
+    private decryptEnvelope;
+    private ensureBaseDir;
+}
+
+interface ZkLoginPendingSession {
+    epoch: number;
+    maxEpoch: number;
+    randomness: string;
+    nonce: string;
+    ephemeralKeypair: Ed25519Keypair;
+}
+interface ZkLoginAuthorizationRequest {
+    authorizationUrl: string;
+    pendingSession: ZkLoginPendingSession;
+}
+interface ZkLoginProviderOptions {
+    client: Pick<SuiClient, 'getCurrentEpoch'>;
+    oauth: OAuthConfig;
+    sessionStore?: ZkLoginSessionStore;
+    fetchFn?: typeof fetch;
+}
+interface RefreshSessionOptions {
+    force?: boolean;
+    invalidateOnFailure?: boolean;
+    throwOnFailure?: boolean;
+    now?: number;
+}
+declare class ZkLoginProvider implements AuthProvider {
+    private readonly options;
+    readonly mode: "zklogin";
+    private session;
+    private sessionState;
+    private readonly signer;
+    private readonly fetchFn;
+    private readonly sessionStateListeners;
+    private oauth;
+    constructor(options: ZkLoginProviderOptions);
+    getOAuthConfig(): OAuthConfig;
+    setOAuthConfig(oauth: OAuthConfig): void;
+    restoreSession(): Promise<boolean>;
+    createAuthorizationRequest(params: {
+        redirectUri: string;
+        state: string;
+        codeChallenge: string;
+        scopes?: string[];
+    }): Promise<ZkLoginAuthorizationRequest>;
+    exchangeAuthorizationCode(code: string, codeVerifier: string, redirectUri: string): Promise<OAuthTokenResponse>;
+    refreshSessionIfNeeded(currentEpoch?: number, options?: RefreshSessionOptions): Promise<StoredZkLoginSession | null>;
+    authenticateWithJwt(jwt: string, params: {
+        pendingSession: ZkLoginPendingSession;
+        refreshToken?: string;
+        validateNonce?: boolean;
+    }): Promise<StoredZkLoginSession>;
+    getAddress(): Promise<string>;
+    getDID(): string;
+    signTransaction(tx: Uint8Array): Promise<Uint8Array>;
+    signPersonalMessage(message: Uint8Array): Promise<{
+        signature: Uint8Array;
+    }>;
+    isAuthenticated(): boolean;
+    getPublicKey(): Uint8Array;
+    toSuiSigner(): Signer;
+    getSession(): StoredZkLoginSession | null;
+    getSessionState(): SessionState;
+    onSessionStateChange(callback: SessionStateChangeCallback): () => void;
+    isSessionValid(currentEpoch?: number): Promise<boolean>;
+    getSessionExpiryMs(session?: StoredZkLoginSession | null): number | null;
+    clearSession(session?: StoredZkLoginSession | null): Promise<void>;
+    private refreshTokens;
+    private createPendingSession;
+    private buildAuthorizationUrl;
+    private fetchSalt;
+    private fetchProof;
+    private fetchJson;
+    private getPublicIdentifier;
+    private requireSession;
+    private loadCurrentSession;
+    private handleRefreshFailure;
+    private dropSession;
+    private updateSessionState;
+    private getCurrentEpoch;
+    private getAuthorizationEndpoint;
+    private getTokenEndpoint;
+    private getSaltEndpoint;
+    private getProverEndpoint;
+    private getIssuer;
+}
+declare function createPkcePair(): {
+    verifier: string;
+    challenge: string;
+};
+
+declare function startDeviceFlow(config: OAuthConfig): Promise<DeviceFlowStatus>;
+declare function pollDeviceFlow(deviceCode: string, config: OAuthConfig): Promise<{
+    jwt: string;
+    refreshToken?: string;
+} | null>;
+
+declare function deriveEvmKey(identityPrivateKey: Uint8Array, userSalt: string, oauthSub: string): Uint8Array;
+
+interface ExecuteTransactionOptions {
+    requestType?: 'WaitForEffectsCert' | 'WaitForLocalExecution';
+    responseOptions?: SuiTransactionBlockResponseOptions;
+    timeout?: number;
+    pollInterval?: number;
+}
+declare class SuiTransactionExecutionError extends Error {
+    readonly digest?: string;
+    readonly retryable: boolean;
+    constructor(message: string, options?: {
+        cause?: unknown;
+        digest?: string;
+        retryable?: boolean;
+    });
+}
+declare function createSuiClient(config: NetworkConfig): SuiClient;
+declare class MeshSuiClient {
+    private readonly networkConfig;
+    private readonly suiClient;
+    constructor(networkConfig: NetworkConfig);
+    executeTransaction(tx: Transaction, keypair: Signer, options?: ExecuteTransactionOptions): Promise<SuiTransactionBlockResponse>;
+    getBalance(address: string): Promise<bigint>;
+    queryEvents(eventType: string, cursor?: EventId | null, limit?: number): Promise<{
+        events: SuiEvent[];
+        nextCursor: EventId | null;
+        hasMore: boolean;
+    }>;
+    getObject<T>(objectId: string): Promise<T>;
+    get client(): SuiClient;
+    get config(): NetworkConfig;
+}
+
+declare const CLOCK_OBJECT_ID = "0x6";
+interface RegisterAgentParams {
+    packageId: string;
+    registryId: string;
+    name: string;
+    did: string;
+    description: string;
+    capabilities: Capability[];
+    endpoint: string;
+}
+interface UpdateAgentParams {
+    packageId: string;
+    registryId: string;
+    cardId: string;
+    name: string;
+    description: string;
+    endpoint: string;
+}
+interface SetEncryptionKeyParams {
+    packageId: string;
+    cardId: string;
+    encryptionPublicKey: Uint8Array;
+}
+interface UpdateCapabilitiesParams {
+    packageId: string;
+    registryId: string;
+    cardId: string;
+    capabilities: Capability[];
+}
+interface DeactivateAgentParams {
+    packageId: string;
+    registryId: string;
+    cardId: string;
+}
+interface ReactivateAgentParams {
+    packageId: string;
+    registryId: string;
+    cardId: string;
+}
+interface PostTaskParams {
+    packageId: string;
+    capability: string;
+    category: string;
+    inputBlobId: string;
+    agreementHash?: string;
+    priceMist: bigint;
+    disputeWindowMs: number;
+    expiryHours: number;
+}
+interface PostMeteredTaskParams {
+    packageId: string;
+    capability: string;
+    category: string;
+    inputBlobId: string;
+    agreementHash?: string;
+    maxPriceMist: bigint;
+    unitPriceMist: bigint;
+    disputeWindowMs: number;
+    expiryHours: number;
+}
+interface AcceptTaskParams {
+    packageId: string;
+    taskId: string;
+}
+interface CompleteTaskParams {
+    packageId: string;
+    taskId: string;
+    resultBlobId: string;
+    providerCardId?: string;
+}
+interface CompleteMeteredTaskParams {
+    packageId: string;
+    taskId: string;
+    resultBlobId: string;
+    meteredUnits: number;
+    verificationHash: string;
+    providerCardId?: string;
+}
+interface ReleasePaymentParams {
+    packageId: string;
+    taskId: string;
+}
+interface ReleaseMeteredPaymentParams {
+    packageId: string;
+    taskId: string;
+}
+interface ClaimPaymentParams {
+    packageId: string;
+    taskId: string;
+    providerCardId?: string;
+}
+interface CancelTaskParams {
+    packageId: string;
+    taskId: string;
+}
+interface RefundExpiredTaskParams {
+    packageId: string;
+    taskId: string;
+}
+interface PlaceBidParams {
+    packageId: string;
+    taskId: string;
+    bidPriceMist: bigint;
+    reputationScore: bigint;
+    evidenceBlob?: string;
+}
+interface AcceptBidParams {
+    packageId: string;
+    taskId: string;
+    bidId: string;
+    otherBidIds?: string[];
+}
+interface WithdrawBidParams {
+    packageId: string;
+    bidId: string;
+}
+interface RejectBidParams {
+    packageId: string;
+    taskId: string;
+    bidId: string;
+}
+interface OpenDisputeParams {
+    packageId: string;
+    taskId: string;
+    evidenceBlobId: string;
+    proposedSplitMist: bigint;
+    arbitratorAddress?: string;
+}
+interface RespondToDisputeParams {
+    packageId: string;
+    disputeId: string;
+    evidenceBlobId: string;
+    proposedSplitMist: bigint;
+}
+interface AcceptResolutionParams {
+    packageId: string;
+    disputeId: string;
+    taskId: string;
+}
+interface ArbitrateDisputeParams {
+    packageId: string;
+    disputeId: string;
+    taskId: string;
+    rulingSplitMist: bigint;
+}
+interface PublishReputationAnchorParams {
+    packageId: string;
+    merkleRoot: number[];
+    eventCount: number;
+    blobId: string;
+    fromTimestamp: number;
+    toTimestamp: number;
+}
+interface DepositStakeParams {
+    packageId: string;
+    amountMist: bigint;
+    stakeType: 'agent' | 'relay';
+}
+interface AddStakeParams {
+    packageId: string;
+    stakeId: string;
+    amountMist: bigint;
+}
+interface StartDeactivationParams {
+    packageId: string;
+    stakeId: string;
+}
+interface WithdrawStakeParams {
+    packageId: string;
+    stakeId: string;
+}
+interface SlashStakeParams {
+    packageId: string;
+    stakeId: string;
+    taskId: string;
+}
+interface RegisterRelayParams {
+    packageId: string;
+    endpoint: string;
+    stakeId: string;
+    capabilities: string[];
+    region: string;
+    routingFeeBps: number;
+}
+interface RelayMutationParams {
+    packageId: string;
+    relayId: string;
+}
+interface RecordRelayRoutingParams extends RelayMutationParams {
+    feeAmountMist: bigint;
+}
+declare function buildRegisterAgentTx(params: RegisterAgentParams): Transaction;
+declare function buildUpdateAgentTx(params: UpdateAgentParams): Transaction;
+declare function buildUpdateCapabilitiesTx(params: UpdateCapabilitiesParams): Transaction;
+declare function buildSetEncryptionKeyTx(params: SetEncryptionKeyParams): Transaction;
+declare function buildDeactivateAgentTx(params: DeactivateAgentParams): Transaction;
+declare function buildReactivateAgentTx(params: ReactivateAgentParams): Transaction;
+declare function buildPostTaskTx(params: PostTaskParams): Transaction;
+declare function buildPostMeteredTaskTx(params: PostMeteredTaskParams): Transaction;
+declare function buildAcceptTaskTx(params: AcceptTaskParams): Transaction;
+declare function buildCompleteTaskTx(params: CompleteTaskParams): Transaction;
+declare function buildCompleteMeteredTaskTx(params: CompleteMeteredTaskParams): Transaction;
+declare function buildReleasePaymentTx(params: ReleasePaymentParams): Transaction;
+declare function buildReleaseMeteredPaymentTx(params: ReleaseMeteredPaymentParams): Transaction;
+declare function buildClaimPaymentTx(params: ClaimPaymentParams): Transaction;
+declare function buildCancelTaskTx(params: CancelTaskParams): Transaction;
+declare function buildRefundExpiredTaskTx(params: RefundExpiredTaskParams): Transaction;
+declare function buildPlaceBidTx(params: PlaceBidParams): Transaction;
+declare function buildAcceptBidTx(params: AcceptBidParams): Transaction;
+declare function buildWithdrawBidTx(params: WithdrawBidParams): Transaction;
+declare function buildRejectBidTx(params: RejectBidParams): Transaction;
+declare function buildOpenDisputeTx(params: OpenDisputeParams): Transaction;
+declare function buildRespondToDisputeTx(params: RespondToDisputeParams): Transaction;
+declare function buildAcceptResolutionTx(params: AcceptResolutionParams): Transaction;
+declare function buildArbitrateDisputeTx(params: ArbitrateDisputeParams): Transaction;
+declare function buildPublishReputationAnchorTx(params: PublishReputationAnchorParams): Transaction;
+declare function buildDepositStakeTx(params: DepositStakeParams): Transaction;
+declare function buildAddStakeTx(params: AddStakeParams): Transaction;
+declare function buildStartDeactivationTx(params: StartDeactivationParams): Transaction;
+declare function buildWithdrawStakeTx(params: WithdrawStakeParams): Transaction;
+declare function buildSlashExpiredEscrowTx(params: SlashStakeParams): Transaction;
+declare function buildSlashNonDeliveryTx(params: SlashStakeParams): Transaction;
+declare function buildRegisterRelayTx(params: RegisterRelayParams): Transaction;
+declare function buildHeartbeatRelayTx(params: RelayMutationParams): Transaction;
+declare function buildDeactivateRelayTx(params: RelayMutationParams): Transaction;
+declare function buildRecordRelayRoutingTx(params: RecordRelayRoutingParams): Transaction;
+
+declare class RegistryClient {
+    private readonly suiClient;
+    private readonly config;
+    private readonly scoreCalculator;
+    private readonly stakingClient;
+    constructor(suiClient: MeshSuiClient, config: NetworkConfig);
+    registerAgent(params: {
+        name: string;
+        did: string;
+        description: string;
+        capabilities: Capability[];
+        endpoint: string;
+        encryptionPublicKey?: Uint8Array;
+        keypair: Signer;
+    }): Promise<{
+        txDigest: string;
+        agentCardId: string;
+    }>;
+    updateAgent(params: {
+        cardId: string;
+        name: string;
+        description: string;
+        endpoint: string;
+        encryptionPublicKey?: Uint8Array;
+        keypair: Signer;
+    }): Promise<{
+        txDigest: string;
+    }>;
+    setEncryptionKey(params: {
+        cardId: string;
+        encryptionPublicKey: Uint8Array;
+        keypair: Signer;
+    }): Promise<{
+        txDigest: string;
+    }>;
+    updateCapabilities(params: {
+        cardId: string;
+        capabilities: Capability[];
+        keypair: Signer;
+    }): Promise<{
+        txDigest: string;
+    }>;
+    deactivateAgent(params: {
+        cardId: string;
+        keypair: Signer;
+    }): Promise<{
+        txDigest: string;
+    }>;
+    reactivateAgent(params: {
+        cardId: string;
+        keypair: Signer;
+    }): Promise<{
+        txDigest: string;
+    }>;
+    getAgentCard(cardId: string): Promise<AgentCard | null>;
+    getAgentCardByOwner(owner: string): Promise<AgentCard | null>;
+    findAgentByDid(did: string): Promise<AgentCard | null>;
+    discoverByCapability(capability: string, limit?: number, options?: {
+        sortByReputation?: boolean;
+        scores?: Map<string, ReputationScore>;
+    }): Promise<AgentCard[]>;
+    private enrichAgentStake;
+}
+
+declare class TaskClient {
+    private readonly suiClient;
+    private readonly config;
+    constructor(suiClient: MeshSuiClient, config: NetworkConfig);
+    postTask(params: {
+        capability: string;
+        category: string;
+        inputBlobId: string;
+        agreementHash?: string;
+        priceMist: bigint;
+        disputeWindowMs: number;
+        expiryHours: number;
+        keypair: Signer;
+    }): Promise<{
+        txDigest: string;
+        taskId: string;
+    }>;
+    postMeteredTask(params: {
+        capability: string;
+        category: string;
+        inputBlobId: string;
+        agreementHash?: string;
+        maxPriceMist: bigint;
+        unitPriceMist: bigint;
+        disputeWindowMs: number;
+        expiryHours: number;
+        keypair: Signer;
+    }): Promise<{
+        txDigest: string;
+        taskId: string;
+    }>;
+    acceptTask(params: {
+        taskId: string;
+        keypair: Signer;
+    }): Promise<{
+        txDigest: string;
+    }>;
+    completeTask(params: {
+        taskId: string;
+        resultBlobId: string;
+        keypair: Signer;
+        providerCardId?: string;
+    }): Promise<{
+        txDigest: string;
+    }>;
+    completeMeteredTask(params: {
+        taskId: string;
+        resultBlobId: string;
+        meteredUnits: number;
+        verificationHash: string;
+        keypair: Signer;
+        providerCardId?: string;
+    }): Promise<{
+        txDigest: string;
+    }>;
+    releasePayment(params: {
+        taskId: string;
+        keypair: Signer;
+    }): Promise<{
+        txDigest: string;
+    }>;
+    releaseMeteredPayment(params: {
+        taskId: string;
+        keypair: Signer;
+    }): Promise<{
+        txDigest: string;
+    }>;
+    claimPayment(params: {
+        taskId: string;
+        keypair: Signer;
+        providerCardId?: string;
+    }): Promise<{
+        txDigest: string;
+    }>;
+    cancelTask(params: {
+        taskId: string;
+        keypair: Signer;
+    }): Promise<{
+        txDigest: string;
+    }>;
+    refundExpiredTask(params: {
+        taskId: string;
+        keypair: Signer;
+    }): Promise<{
+        txDigest: string;
+    }>;
+    getTask(taskId: string): Promise<Task | null>;
+    private submitTaskCreation;
+}
+
+interface BrowseOpenTasksFilters {
+    category?: string;
+    minPriceMist?: bigint;
+    maxPriceMist?: bigint;
+    limit?: number;
+}
+declare class MarketplaceClient {
+    private readonly suiClient;
+    private readonly config;
+    private readonly taskClient;
+    private readonly registryClient;
+    private readonly scoreCalculator;
+    constructor(suiClient: MeshSuiClient, config: NetworkConfig);
+    postOpenTask(params: {
+        capability: string;
+        category: string;
+        inputBlobId: string;
+        agreementHash?: string;
+        priceMist: bigint;
+        disputeWindowMs: number;
+        expiryHours: number;
+        signer: Signer;
+    }): Promise<{
+        txDigest: string;
+        taskId: string;
+    }>;
+    placeBid(params: {
+        taskId: string;
+        bidPriceMist: bigint;
+        signer: Signer;
+        reputationScore?: bigint | number;
+        evidenceBlob?: string;
+    }): Promise<{
+        bidId: string;
+        txDigest: string;
+        reputationScore: bigint;
+    }>;
+    acceptBid(params: {
+        taskId: string;
+        bidId: string;
+        signer: Signer;
+        rejectCompeting?: boolean;
+    }): Promise<{
+        txDigest: string;
+        rejectedBidIds: string[];
+    }>;
+    withdrawBid(params: {
+        bidId: string;
+        signer: Signer;
+    }): Promise<{
+        txDigest: string;
+    }>;
+    rejectBid(params: {
+        taskId: string;
+        bidId: string;
+        signer: Signer;
+    }): Promise<{
+        txDigest: string;
+    }>;
+    getBid(bidId: string): Promise<Bid | null>;
+    getBidsForTask(taskId: string): Promise<Bid[]>;
+    browseOpenTasks(filters?: BrowseOpenTasksFilters): Promise<Task[]>;
+    getRecommendedBid(taskId: string, options?: {
+        reputationWeight?: bigint | number;
+        priceWeight?: bigint | number;
+    }): Promise<BidRecommendation | null>;
+    private deriveReputationScore;
+}
+
+declare class DisputeClient {
+    private readonly suiClient;
+    private readonly config;
+    constructor(suiClient: MeshSuiClient, config: Pick<NetworkConfig, 'packageId'>);
+    openDispute(params: {
+        taskId: string;
+        evidenceBlobId: string;
+        proposedSplitMist: bigint;
+        arbitratorAddress?: string;
+        signer: Ed25519Keypair;
+    }): Promise<{
+        disputeId: string;
+        txDigest: string;
+    }>;
+    respondToDispute(params: {
+        disputeId: string;
+        evidenceBlobId: string;
+        proposedSplitMist: bigint;
+        signer: Ed25519Keypair;
+    }): Promise<{
+        txDigest: string;
+    }>;
+    acceptResolution(params: {
+        disputeId: string;
+        taskId: string;
+        signer: Ed25519Keypair;
+    }): Promise<{
+        requesterAmount: bigint;
+        providerAmount: bigint;
+        txDigest: string;
+    }>;
+    arbitrate(params: {
+        disputeId: string;
+        taskId: string;
+        rulingSplitMist: bigint;
+        signer: Ed25519Keypair;
+    }): Promise<{
+        txDigest: string;
+    }>;
+    getDispute(disputeId: string): Promise<Dispute | null>;
+    getDisputeByTask(taskId: string): Promise<Dispute | null>;
+}
+
+interface CursorStore {
+    getCursor(eventType: string): Promise<EventId | null>;
+    setCursor(eventType: string, cursor: EventId): Promise<void>;
+}
+declare class EventSubscription {
+    private readonly params;
+    private running;
+    private timer?;
+    private cursor;
+    private polling;
+    constructor(params: {
+        suiClient: MeshSuiClient;
+        eventType: string;
+        pollIntervalMs?: number;
+        onEvent: (event: SuiEvent) => Promise<void>;
+        onError?: (error: unknown) => void;
+        cursorStore: CursorStore;
+    });
+    start(): void;
+    stop(): void;
+    isRunning(): boolean;
+    private poll;
+}
+declare class SqliteCursorStore implements CursorStore {
+    private readonly db;
+    constructor(dbPath: string);
+    getCursor(eventType: string): Promise<EventId | null>;
+    setCursor(eventType: string, cursor: EventId): Promise<void>;
+    close(): void;
+}
+
+declare function parseRawEvent(rawEvent: SuiEvent, packageId: string): MeshEvent | null;
+
+interface AdvancedAgentQueryFilters {
+    capability?: string;
+    minReputation?: number;
+    category?: string;
+    search?: string;
+    limit?: number;
+    offset?: number;
+    sortBy?: 'stake' | 'reputation';
+}
+type AdvancedAgentQueryDelegate = (filters: AdvancedAgentQueryFilters) => Promise<AgentCard[]>;
+declare class AgentCache {
+    private readonly db;
+    private readonly scoreCalculator;
+    private readonly queryDelegate?;
+    constructor(dbPath: string, options?: {
+        queryDelegate?: AdvancedAgentQueryDelegate;
+    });
+    upsertAgent(agent: AgentCard): void;
+    removeAgent(agentId: string): void;
+    getAgent(agentId: string): AgentCard | null;
+    getAgentByDID(did: string): AgentCard | null;
+    searchByCapability(query: string, limit?: number, options?: {
+        sortByReputation?: boolean;
+        scores?: Map<string, ReputationScore>;
+    }): AgentCard[];
+    getAllActive(limit?: number): AgentCard[];
+    queryAgentsAdvanced(filters?: AdvancedAgentQueryFilters): Promise<AgentCard[]>;
+    close(): void;
+}
+
+interface ContentAddressedBlob {
+    blobId: string;
+    contentHash: string;
+    size: number;
+    storedAt: number;
+}
+interface StoredBlob extends ContentAddressedBlob {
+    hash: string;
+    checksum: string;
+}
+type BlobMetadata = ContentAddressedBlob;
+declare class BlobIntegrityError extends Error {
+    readonly blobId: string;
+    readonly expectedHash: string;
+    readonly actualHash: string;
+    constructor(message: string, blobId: string, expectedHash: string, actualHash: string);
+}
+interface BlobStore {
+    store(data: Uint8Array): Promise<StoredBlob>;
+    fetch(blobId: string): Promise<Uint8Array | null>;
+    exists(blobId: string): Promise<boolean>;
+    delete(blobId: string): Promise<void>;
+    getMetadata?(blobId: string): Promise<BlobMetadata | null>;
+}
+
+declare class FilesystemBlobStore implements BlobStore {
+    private readonly baseDir;
+    constructor(baseDir: string);
+    store(data: Uint8Array): Promise<StoredBlob>;
+    fetch(blobId: string): Promise<Uint8Array | null>;
+    exists(blobId: string): Promise<boolean>;
+    getMetadata(blobId: string): Promise<BlobMetadata | null>;
+    delete(blobId: string): Promise<void>;
+}
+
+declare const DEFAULT_WALRUS_PUBLISHER_URL = "https://publisher.walrus-testnet.walrus.space";
+declare const DEFAULT_WALRUS_AGGREGATOR_URL = "https://aggregator.walrus-testnet.walrus.space";
+declare const DEFAULT_WALRUS_EPOCHS = 5;
+declare const DEFAULT_WALRUS_MAX_BLOB_SIZE: number;
+declare const DEFAULT_WALRUS_RETRY_ATTEMPTS = 3;
+declare const DEFAULT_WALRUS_RETRY_DELAY_MS = 1000;
+declare const DEFAULT_WALRUS_TIMEOUT_MS = 30000;
+interface WalrusLogger {
+    debug(bindings: Record<string, unknown>, message?: string): void;
+    info(bindings: Record<string, unknown>, message?: string): void;
+    warn(bindings: Record<string, unknown>, message?: string): void;
+    error(bindings: Record<string, unknown>, message?: string): void;
+}
+interface WalrusBlobStoreConfig {
+    publisherUrl: string;
+    aggregatorUrl: string;
+    epochs?: number;
+    maxBlobSize?: number;
+    retryAttempts?: number;
+    retryDelayMs?: number;
+    timeoutMs?: number;
+    fetchImpl?: typeof fetch;
+    logger?: WalrusLogger;
+}
+interface WalrusBlobMetadata extends BlobMetadata {
+    storageBlobId: string;
+    objectId?: string;
+    deletable?: boolean;
+    endEpoch?: number;
+}
+interface WalrusBlobReference {
+    blobId: string;
+    storageBlobId: string;
+    contentHash?: string;
+}
+declare class WalrusRequestError extends Error {
+    readonly url: string;
+    readonly transient: boolean;
+    readonly status?: number | undefined;
+    readonly body?: string | undefined;
+    constructor(message: string, url: string, transient: boolean, status?: number | undefined, body?: string | undefined, options?: ErrorOptions);
+}
+declare class WalrusNetworkError extends WalrusRequestError {
+    constructor(message: string, url: string, options?: ErrorOptions);
+}
+declare class WalrusTimeoutError extends WalrusRequestError {
+    readonly timeoutMs: number;
+    constructor(message: string, url: string, timeoutMs: number, options?: ErrorOptions);
+}
+declare class WalrusHttpError extends WalrusRequestError {
+    constructor(message: string, url: string, status: number, body: string);
+}
+declare class WalrusResponseError extends WalrusRequestError {
+    constructor(message: string, url: string, body: string, options?: ErrorOptions);
+}
+declare class WalrusBlobTooLargeError extends Error {
+    readonly size: number;
+    readonly maxBlobSize: number;
+    constructor(size: number, maxBlobSize: number);
+}
+declare class WalrusBlobStore implements BlobStore {
+    private readonly config;
+    private readonly metadata;
+    constructor(config: WalrusBlobStoreConfig);
+    store(data: Uint8Array): Promise<StoredBlob>;
+    fetch(blobId: string): Promise<Uint8Array | null>;
+    exists(blobId: string): Promise<boolean>;
+    getMetadata(blobId: string): Promise<BlobMetadata | null>;
+    delete(blobId: string): Promise<void>;
+    private executeWithRetry;
+    private fetchWithTimeout;
+    private rememberMetadata;
+    private log;
+}
+declare function createWalrusBlobReference(storageBlobId: string, contentHash: string): string;
+declare function parseWalrusBlobReference(blobId: string): WalrusBlobReference;
+
+interface HybridBlobStoreOptions {
+    preferWalrus?: boolean;
+    cacheLocally?: boolean;
+}
+declare class HybridBlobStore implements BlobStore {
+    private readonly walrus;
+    private readonly local;
+    private readonly options;
+    constructor(walrus: WalrusBlobStore, local: FilesystemBlobStore, options?: HybridBlobStoreOptions);
+    store(data: Uint8Array): Promise<StoredBlob>;
+    fetch(blobId: string): Promise<Uint8Array | null>;
+    exists(blobId: string): Promise<boolean>;
+    getMetadata(blobId: string): Promise<BlobMetadata | null>;
+    delete(blobId: string): Promise<void>;
+    private get preferWalrus();
+    private get cacheLocally();
+}
+
+declare class EncryptedBlobStore implements BlobStore {
+    private readonly inner;
+    private readonly myKeyPair;
+    constructor(inner: BlobStore, myKeyPair: X25519KeyPair);
+    storeEncrypted(data: Uint8Array, recipientPublicKey: Uint8Array): Promise<{
+        blobId: string;
+        hash: string;
+    }>;
+    fetchDecrypted(blobId: string): Promise<Uint8Array | null>;
+    store(data: Uint8Array): Promise<StoredBlob>;
+    fetch(blobId: string): Promise<Uint8Array | null>;
+    exists(blobId: string): Promise<boolean>;
+    delete(blobId: string): Promise<void>;
+    getMetadata(blobId: string): Promise<BlobMetadata | null>;
+}
+
+declare const USDC_ADDRESS: {
+    readonly base: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+    readonly 'base-sepolia': "0x036CbD53842c5426634e7929541eC2318f3dCF7e";
+};
+declare const PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+
+interface EvmWalletConfig {
+    network: 'base' | 'base-sepolia' | 'localhost';
+    rpcUrl?: string;
+}
+declare class EvmWallet {
+    private readonly config;
+    private readonly account;
+    private readonly chainConfig;
+    private readonly walletClient;
+    private readonly publicClient;
+    constructor(privateKey: Uint8Array, config: EvmWalletConfig);
+    get address(): string;
+    get chain(): Chain;
+    getBalance(): Promise<bigint>;
+    getTokenBalance(tokenAddress: string): Promise<bigint>;
+    signMessage(message: string | Uint8Array): Promise<string>;
+    signTypedData(typedData: Omit<Parameters<WalletClient['signTypedData']>[0], 'account'>): Promise<string>;
+    sendTransaction(to: string, value: bigint): Promise<string>;
+    getWalletClient(): WalletClient;
+    getPublicClient(): PublicClient;
+}
+
+type SelectedPaymentRail = 'sui-escrow' | 'sui-transfer' | 'x402-base';
+interface RailSelectionContext {
+    executionMode: 'sync' | 'async';
+    consumerHasSuiWallet: boolean;
+    consumerHasEvmWallet: boolean;
+    providerAcceptsSui: boolean;
+    providerAcceptsX402: boolean;
+    amount: bigint;
+    currency: string;
+}
+declare class PaymentRailSelector {
+    selectRail(context: RailSelectionContext): SelectedPaymentRail;
+    getAvailableRails(context: RailSelectionContext): SelectedPaymentRail[];
+}
+
+interface X402PaymentRequest {
+    paymentAddress: string;
+    amount: string;
+    currency: string;
+    network: string;
+    nonce: string;
+    expiresAt: number;
+}
+interface X402PaymentSignature {
+    signature: string;
+    payerAddress: string;
+    network: string;
+    nonce: string;
+}
+declare class X402Client {
+    private readonly wallet;
+    constructor(wallet: EvmWallet);
+    parse402Response(headers: Record<string, string>, body?: unknown): X402PaymentRequest;
+    signPayment(request: X402PaymentRequest): Promise<X402PaymentSignature>;
+    createPaymentHeader(request: X402PaymentRequest): Promise<string>;
+    verifyPayment(signature: X402PaymentSignature, request: X402PaymentRequest): Promise<boolean>;
+}
+
+interface RelaySuiPaymentProof {
+    rail: PaymentRail.SUI_TRANSFER;
+    payerDid: DID;
+    payerAddress: string;
+    paymentAddress: string;
+    amount: string;
+    currency: string;
+    network: string;
+    nonce: string;
+    expiresAt: number;
+    signature: string;
+}
+declare class RelayConsumerClient {
+    private readonly x402Client;
+    private readonly identity;
+    private readonly config;
+    private readonly sessionId;
+    private sequence;
+    constructor(x402Client: X402Client | null, identity: AuthProvider, config: {
+        relayUrl: string;
+    });
+    executeSync(request: {
+        providerDid: string;
+        capability: string;
+        input: unknown;
+        paymentRail: PaymentRail;
+        timeoutMs?: number;
+    }): Promise<{
+        result: unknown;
+        paymentReceipt?: string;
+        latencyMs: number;
+        taskId?: string;
+        providerDid?: string;
+    }>;
+    executeSyncStreaming(request: {
+        providerDid: string;
+        capability: string;
+        input: unknown;
+        paymentRail: PaymentRail;
+        onChunk: (chunk: string) => void;
+        onProgress: (progress: number, message?: string) => void;
+        timeoutMs?: number;
+    }): Promise<{
+        result: unknown;
+        paymentReceipt?: string;
+    }>;
+    private executeWithPayment;
+    private sendExecuteRequest;
+    private requirePaymentChallenge;
+    private createPaymentHeader;
+    private nextSequence;
+}
+declare function createRelaySuiPaymentProof(identity: AuthProvider, request: {
+    paymentAddress: string;
+    amount: string;
+    currency: string;
+    network: string;
+    nonce: string;
+    expiresAt: number;
+}): Promise<RelaySuiPaymentProof>;
+declare function encodeRelaySuiPaymentProof(proof: RelaySuiPaymentProof): string;
+declare function decodeRelaySuiPaymentProof(header: string): RelaySuiPaymentProof;
+declare function verifyRelaySuiPaymentProof(proof: RelaySuiPaymentProof): boolean;
+
+interface RelayRegistryContractConfig {
+    packageId: string;
+    heartbeatFreshnessMs?: number;
+}
+declare const DEFAULT_RELAY_HEARTBEAT_FRESHNESS_MS: number;
+declare class RelayRegistryClient {
+    private readonly suiClient;
+    private readonly config;
+    private readonly stakingClient;
+    private readonly heartbeatFreshnessMs;
+    constructor(suiClient: MeshSuiClient, config: RelayRegistryContractConfig);
+    registerRelay(params: {
+        endpoint: string;
+        stakeId: string;
+        capabilities: string[];
+        region: string;
+        routingFeeBps: number;
+        signer: Signer;
+    }): Promise<{
+        relayId: string;
+        txDigest: string;
+    }>;
+    heartbeat(params: {
+        relayId: string;
+        signer: Signer;
+    }): Promise<{
+        lastHeartbeat: number;
+        txDigest: string;
+    }>;
+    recordRouting(params: {
+        relayId: string;
+        feeAmountMist: bigint;
+        signer: Signer;
+    }): Promise<{
+        txDigest: string;
+    }>;
+    deactivateRelay(params: {
+        relayId: string;
+        signer: Signer;
+    }): Promise<{
+        txDigest: string;
+    }>;
+    listRelays(filters?: RelayListFilters): Promise<RelayNode[]>;
+    getRelay(relayId: string): Promise<RelayNode | null>;
+    getRelaysByRegion(region: string): Promise<RelayNode[]>;
+    private collectRelayIds;
+    private enrichRelay;
+}
+
+interface RelayDiscoveryOptions {
+    cacheTtlMs?: number;
+    heartbeatFreshnessMs?: number;
+    now?: () => number;
+}
+declare class RelayDiscovery {
+    private readonly registryClient;
+    private readonly cacheTtlMs;
+    private readonly heartbeatFreshnessMs;
+    private readonly now;
+    private cache?;
+    constructor(registryClient: Pick<RelayRegistryClient, 'listRelays'>, options?: RelayDiscoveryOptions);
+    findBestRelay(capability: string, region?: string): Promise<RelayNode | null>;
+    invalidateCache(): void;
+    private getRelayList;
+}
+
+interface SpendingPolicyDecision {
+    approved: boolean;
+    reason?: string;
+}
+interface SpendingPolicyConfig extends SpendingPolicy {
+    perApp?: Record<string, {
+        limits: SpendingPolicy['limits'];
+    }>;
+}
+interface SpendingAmount {
+    amount?: bigint;
+    amountMist?: bigint;
+    currency?: string;
+}
+interface SpendingLogEntry {
+    id: number;
+    amountBaseUnits: bigint;
+    rail: PaymentRail;
+    currency?: string;
+    taskId?: string;
+    appId?: string;
+    timestamp: number;
+}
+declare class SpendingPolicyEngine {
+    private readonly db;
+    private policy;
+    constructor(params: {
+        policy: SpendingPolicyConfig;
+        dbPath: string;
+    });
+    evaluate(request: SpendingAmount & {
+        rail: PaymentRail;
+        appId?: string;
+        originAppName?: string;
+    }): SpendingPolicyDecision;
+    record(entry: SpendingAmount & {
+        rail: PaymentRail;
+        taskId: string;
+        appId?: string;
+        originAppName?: string;
+    }): void;
+    getSpent(interval: 'hour' | 'day' | 'month', rail?: PaymentRail, appId?: string, currency?: string): bigint;
+    /** Return the most recent spending log entries, newest first. */
+    getRecentEntries(limit?: number): SpendingLogEntry[];
+    updatePolicy(policy: SpendingPolicyConfig): void;
+    close(): void;
+    private evaluateLimits;
+    private getSpentForLimit;
+    private migrateSpendingLogSchema;
+}
+
+interface ContractConfig {
+    packageId: string;
+}
+declare class ReputationAnchorClient {
+    private readonly suiClient;
+    private readonly config;
+    constructor(suiClient: MeshSuiClient, config: ContractConfig);
+    publishAnchor(events: ReputationEvent[], blobStore: BlobStore, signer: Signer): Promise<{
+        anchorId: string;
+        merkleRoot: string;
+        txDigest: string;
+    }>;
+    getAnchors(author?: string, limit?: number): Promise<ReputationAnchor[]>;
+    private fetchAnchor;
+}
+
+declare class ReputationEventPublisher {
+    private readonly blobStore;
+    private readonly identity;
+    constructor(blobStore: BlobStore, identity: AuthProvider);
+    createEvent(params: {
+        type: ReputationEventType;
+        subject: string;
+        taskId: string;
+        outcome: string;
+        capability: string;
+        rating?: number;
+        latencyMs?: number;
+        paymentAmount?: {
+            amount: string;
+            currency: string;
+        };
+    }): Promise<ReputationEvent>;
+    publishEvent(event: ReputationEvent): Promise<void>;
+}
+
+declare function buildMerkleTree(events: ReputationEvent[]): {
+    root: Uint8Array;
+    proof: (index: number) => Uint8Array[];
+};
+declare function verifyMerkleProof(event: ReputationEvent, proof: Uint8Array[], root: Uint8Array, index: number): boolean;
+
+declare class ReputationScoreCalculator {
+    computeScore(agentCard: AgentCard, events: ReputationEvent[]): ReputationScore;
+    rankByReputation(agents: AgentCard[], scores: Map<string, ReputationScore>): AgentCard[];
+}
+
+declare class ReputationStore {
+    private readonly db;
+    constructor(dbPath: string);
+    addEvent(event: ReputationEvent): Promise<void>;
+    getEvents(options: {
+        subject?: string;
+        author?: string;
+        since?: number;
+        limit?: number;
+    }): Promise<ReputationEvent[]>;
+    getUnanchoredEvents(limit?: number): Promise<ReputationEvent[]>;
+    markAnchored(eventIds: string[], anchorId: string): Promise<void>;
+    getStats(subject: string): Promise<{
+        completed: number;
+        failed: number;
+        disputed: number;
+    }>;
+    close(): void;
+}
+
+interface StakingContractConfig {
+    packageId: string;
+}
+declare const STAKING_COOLDOWN_MS = 604800000;
+declare class StakingClient {
+    private readonly suiClient;
+    private readonly config;
+    constructor(suiClient: MeshSuiClient, config: StakingContractConfig);
+    depositStake(params: {
+        amountMist: bigint;
+        stakeType: 'agent' | 'relay';
+        signer: Ed25519Keypair;
+    }): Promise<{
+        stakeId: string;
+        txDigest: string;
+    }>;
+    addStake(params: {
+        stakeId: string;
+        amountMist: bigint;
+        signer: Ed25519Keypair;
+    }): Promise<{
+        txDigest: string;
+    }>;
+    startDeactivation(params: {
+        stakeId: string;
+        signer: Ed25519Keypair;
+    }): Promise<{
+        cooldownEndsAt: number;
+        txDigest: string;
+    }>;
+    withdrawStake(params: {
+        stakeId: string;
+        signer: Ed25519Keypair;
+    }): Promise<{
+        amountReturned: bigint;
+        txDigest: string;
+    }>;
+    slashExpiredEscrow(params: {
+        stakeId: string;
+        taskId: string;
+        signer: Ed25519Keypair;
+    }): Promise<{
+        slashedAmount: bigint;
+        txDigest: string;
+    }>;
+    slashNonDelivery(params: {
+        stakeId: string;
+        taskId: string;
+        signer: Ed25519Keypair;
+    }): Promise<{
+        slashedAmount: bigint;
+        txDigest: string;
+    }>;
+    getStakePosition(stakeId: string): Promise<StakePosition | null>;
+    getStakeByOwner(owner: string): Promise<StakePosition | null>;
+    getStakeByOwners(owners: string[]): Promise<Map<string, StakePosition>>;
+}
+
+declare const DEFAULT_METERING_CHUNK_SIZE = 1024;
+declare class HashChain {
+    private readonly seed;
+    private currentHash;
+    private readonly intermediateHashes;
+    constructor(seed?: Uint8Array);
+    addUnit(data: Uint8Array): string;
+    getRoot(): string;
+    getProof(): HashChainProof;
+    static verifyChain(proof: HashChainProof, unitData: Uint8Array[], seed?: Uint8Array): boolean;
+}
+declare function createMeteringSeed(taskId: string): Uint8Array;
+declare function splitIntoMeteringUnits(data: Uint8Array, chunkSize?: number): Uint8Array[];
+
+interface UsageMeterOptions {
+    taskId: string;
+    maxPrice: bigint;
+    unitPrice?: bigint;
+    seed?: Uint8Array;
+}
+declare class UsageMeter {
+    private readonly hashChain;
+    private actualUnits;
+    private readonly taskId;
+    private readonly maxPrice;
+    private readonly unitPrice;
+    constructor(options: UsageMeterOptions);
+    recordUnit(data: Uint8Array): number;
+    getActualUnits(): number;
+    getVerificationHash(): string;
+    getProof(): HashChainProof;
+    getCost(unitPrice?: bigint): bigint;
+    getReport(): MeteringReport;
+}
+
+interface StreamingPaymentManagerOptions {
+    dbPath: string;
+    now?: () => number;
+    paymentProcessor?: (entry: {
+        taskId: string;
+        amount: bigint;
+        unitIndex: number;
+        totalPaid: bigint;
+        timestamp: number;
+    }) => Promise<void> | void;
+}
+declare class StreamingPaymentManager {
+    private readonly options;
+    private readonly db;
+    private readonly now;
+    constructor(options: StreamingPaymentManagerOptions);
+    startStream(taskId: string, maxBudget: bigint, unitPrice: bigint): StreamingPaymentState;
+    getState(taskId: string): StreamingPaymentState | null;
+    payUnit(taskId: string): Promise<StreamingPaymentState>;
+    finalizeStream(taskId: string): {
+        state: StreamingPaymentState;
+        refundAmount: bigint;
+    };
+    getAuditTrail(taskId: string): Array<{
+        taskId: string;
+        unitIndex: number;
+        amount: bigint;
+        timestamp: number;
+    }>;
+    close(): void;
+    private requireStreamRow;
+}
+
+declare const METERED_RESULT_SCHEMA = "agentic-mesh-metered-result/v1";
+interface MeteredResultEnvelope {
+    schema: typeof METERED_RESULT_SCHEMA;
+    resultEncoding: 'base64';
+    result: string;
+    proof: HashChainProof;
+    unitChunkSize: number;
+}
+declare class ResultVerifier {
+    verify(task: Pick<Task, 'id' | 'verificationHash'>, proof: HashChainProof, expectedData: Uint8Array[]): boolean;
+}
+declare function createMeteredResultEnvelope(resultData: Uint8Array, proof: HashChainProof, unitChunkSize?: number): MeteredResultEnvelope;
+declare function serializeMeteredResultEnvelope(envelope: MeteredResultEnvelope): Uint8Array;
+declare function parseMeteredResultEnvelope(data: Uint8Array): MeteredResultEnvelope | null;
+declare function decodeMeteredResult(envelope: MeteredResultEnvelope): Uint8Array;
+declare function getMeteredResultUnits(envelope: MeteredResultEnvelope): Uint8Array[];
+
+declare enum CircuitBreakerState {
+    CLOSED = "closed",
+    OPEN = "open",
+    HALF_OPEN = "half_open"
+}
+interface CircuitBreakerOptions {
+    failureThreshold?: number;
+    recoveryTimeoutMs?: number;
+    now?: () => number;
+}
+declare class CircuitBreaker {
+    private readonly failureThreshold;
+    private readonly recoveryTimeoutMs;
+    private readonly now;
+    private readonly states;
+    constructor(options?: CircuitBreakerOptions);
+    recordSuccess(providerId: string): void;
+    recordFailure(providerId: string): void;
+    allowRequest(providerId: string): boolean;
+    isOpen(providerId: string): boolean;
+    getState(providerId: string): CircuitBreakerState;
+    private getStateRecord;
+}
+
+interface PerformanceTrackerOptions {
+    dbPath?: string;
+    now?: () => number;
+    maxSamplesPerCapability?: number;
+}
+interface ProviderCapabilityPerformance {
+    capability: string;
+    avgDurationMs: number;
+    p50: number;
+    p95: number;
+    successCount: number;
+    failureCount: number;
+    lastUpdated: number;
+}
+interface ProviderPerformanceStats {
+    providerDid: string;
+    avgDurationMs: number;
+    p50: number;
+    p95: number;
+    successCount: number;
+    failureCount: number;
+    lastUpdated?: number;
+    capabilities: ProviderCapabilityPerformance[];
+}
+declare class PerformanceTracker {
+    private readonly db;
+    private readonly now;
+    private readonly maxSamplesPerCapability;
+    constructor(options?: PerformanceTrackerOptions);
+    recordCompletion(provider: string, capability: string, durationMs: number, success: boolean): void;
+    getEstimatedLatency(provider: string, capability: string): number | undefined;
+    getProviderStats(provider: string): ProviderPerformanceStats;
+    close(): void;
+}
+
+interface ProviderExecutionOutput {
+    value: unknown;
+    aggregateValue?: unknown;
+    cost?: bigint;
+}
+interface FanOutExecutorOptions {
+    executeProvider: (provider: ProviderScore, request: MultiProviderRequest, context: {
+        signal: AbortSignal;
+    }) => Promise<ProviderExecutionOutput>;
+    circuitBreaker?: Pick<CircuitBreaker, 'allowRequest' | 'recordSuccess' | 'recordFailure'>;
+    performanceTracker?: Pick<PerformanceTracker, 'recordCompletion'>;
+    now?: () => number;
+}
+declare class FanOutExecutor {
+    private readonly options;
+    private readonly now;
+    constructor(options: FanOutExecutorOptions);
+    execute(request: MultiProviderRequest, providers: ProviderScore[]): Promise<MultiProviderResult>;
+    private runProvider;
+    private waitForFirstSuccess;
+    private waitForMajority;
+}
+
+interface ProviderSelectionWeights {
+    reputation: number;
+    price: number;
+    speed: number;
+}
+interface ProviderSelectorOptions {
+    circuitBreaker?: Pick<CircuitBreaker, 'isOpen'>;
+    performanceTracker?: Pick<PerformanceTracker, 'getEstimatedLatency'>;
+    reputationCalculator?: ReputationScoreCalculator;
+}
+declare class ProviderSelector {
+    private readonly circuitBreaker?;
+    private readonly performanceTracker?;
+    private readonly reputationCalculator;
+    private roundRobinOffset;
+    constructor(options?: ProviderSelectorOptions);
+    rankProviders(agents: AgentCard[], capability: string, weights?: Partial<ProviderSelectionWeights>): ProviderScore[];
+    selectProviders(agents: AgentCard[], capability: string, strategy: ProviderSelectionStrategy, count: number, weights?: Partial<ProviderSelectionWeights>): ProviderScore[];
+    selectCheapest(providers: ProviderScore[], count: number): ProviderScore[];
+    selectFastest(providers: ProviderScore[], count: number): ProviderScore[];
+    selectHighestReputation(providers: ProviderScore[], count: number): ProviderScore[];
+    selectRoundRobin(providers: ProviderScore[], count: number): ProviderScore[];
+    selectWeighted(providers: ProviderScore[], count: number, weights?: Partial<ProviderSelectionWeights>): ProviderScore[];
+    private toProviderScore;
+    private applyCompositeScores;
+}
+
+export { type AcceptBidParams, type AcceptResolutionParams, type AcceptTaskParams, type AddStakeParams, type AdvancedAgentQueryDelegate, type AdvancedAgentQueryFilters, AgentCache, type ArbitrateDisputeParams, type AuthMode, type AuthProvider, BlobIntegrityError, type BlobMetadata, type BlobStore, type BrowseOpenTasksFilters, CLOCK_OBJECT_ID, type CancelTaskParams, CircuitBreaker, type CircuitBreakerOptions, CircuitBreakerState, type ClaimPaymentParams, type CompleteMeteredTaskParams, type CompleteTaskParams, type ContentAddressedBlob, type ContractConfig, type CursorStore, DEFAULT_METERING_CHUNK_SIZE, DEFAULT_RELAY_HEARTBEAT_FRESHNESS_MS, DEFAULT_WALRUS_AGGREGATOR_URL, DEFAULT_WALRUS_EPOCHS, DEFAULT_WALRUS_MAX_BLOB_SIZE, DEFAULT_WALRUS_PUBLISHER_URL, DEFAULT_WALRUS_RETRY_ATTEMPTS, DEFAULT_WALRUS_RETRY_DELAY_MS, DEFAULT_WALRUS_TIMEOUT_MS, type DeactivateAgentParams, type DepositStakeParams, type DeviceFlowStatus, DisputeClient, Ed25519AuthProvider, EncryptedBlobStore, type EncryptedPayload, EventSubscription, EvmWallet, type EvmWalletConfig, type ExecuteTransactionOptions, FanOutExecutor, type FanOutExecutorOptions, FileKeyStore, FilesystemBlobStore, HashChain, HybridBlobStore, type HybridBlobStoreOptions, type KeyStore, KeychainStore, MarketplaceClient, MeshSuiClient, type MeteredResultEnvelope, type OAuthConfig, type OAuthProvider, type OAuthTokenResponse, type OpenDisputeParams, PERMIT2_ADDRESS, PaymentRailSelector, PerformanceTracker, type PerformanceTrackerOptions, type PlaceBidParams, type PostMeteredTaskParams, type PostTaskParams, type ProviderCapabilityPerformance, type ProviderExecutionOutput, type ProviderPerformanceStats, type ProviderSelectionWeights, ProviderSelector, type ProviderSelectorOptions, type PublishReputationAnchorParams, type RailSelectionContext, type ReactivateAgentParams, type RecordRelayRoutingParams, type RefreshSessionOptions, type RefundExpiredTaskParams, type RegisterAgentParams, type RegisterRelayParams, RegistryClient, type RejectBidParams, RelayConsumerClient, RelayDiscovery, type RelayDiscoveryOptions, type RelayMutationParams, RelayRegistryClient, type RelayRegistryContractConfig, type ReleaseMeteredPaymentParams, type ReleasePaymentParams, ReputationAnchorClient, ReputationEventPublisher, ReputationScoreCalculator, ReputationStore, type RespondToDisputeParams, ResultVerifier, STAKING_COOLDOWN_MS, type SelectedPaymentRail, SessionExpiredError, type SessionExpiredErrorOptions, SessionRefreshError, type SessionRefreshErrorOptions, type SessionRefreshPolicy, SessionState, type SessionStateChangeCallback, type SessionStateChangeEvent, type SetEncryptionKeyParams, type SimpleKeypair, type SlashStakeParams, type SpendingLogEntry, type SpendingPolicyConfig, type SpendingPolicyDecision, SpendingPolicyEngine, SqliteCursorStore, StakingClient, type StakingContractConfig, type StartDeactivationParams, type StoredBlob, type StoredZkLoginSession, StreamingPaymentManager, type StreamingPaymentManagerOptions, SuiTransactionExecutionError, TaskClient, USDC_ADDRESS, type UpdateAgentParams, type UpdateCapabilitiesParams, UsageMeter, type UsageMeterOptions, type WalrusBlobMetadata, type WalrusBlobReference, WalrusBlobStore, type WalrusBlobStoreConfig, WalrusBlobTooLargeError, WalrusHttpError, type WalrusLogger, WalrusNetworkError, WalrusRequestError, WalrusResponseError, WalrusTimeoutError, type WithdrawBidParams, type WithdrawStakeParams, type X25519KeyPair, X402Client, type X402PaymentRequest, type X402PaymentSignature, type ZkLoginAuthorizationRequest, type ZkLoginPendingSession, type ZkLoginProof, ZkLoginProvider, type ZkLoginProviderOptions, type ZkLoginSession, ZkLoginSessionStore, type ZkLoginSessionStoreOptions, buildAcceptBidTx, buildAcceptResolutionTx, buildAcceptTaskTx, buildAddStakeTx, buildArbitrateDisputeTx, buildCancelTaskTx, buildClaimPaymentTx, buildCompleteMeteredTaskTx, buildCompleteTaskTx, buildDeactivateAgentTx, buildDeactivateRelayTx, buildDepositStakeTx, buildHeartbeatRelayTx, buildMerkleTree, buildOpenDisputeTx, buildPlaceBidTx, buildPostMeteredTaskTx, buildPostTaskTx, buildPublishReputationAnchorTx, buildReactivateAgentTx, buildRecordRelayRoutingTx, buildRefundExpiredTaskTx, buildRegisterAgentTx, buildRegisterRelayTx, buildRejectBidTx, buildReleaseMeteredPaymentTx, buildReleasePaymentTx, buildRespondToDisputeTx, buildSetEncryptionKeyTx, buildSlashExpiredEscrowTx, buildSlashNonDeliveryTx, buildStartDeactivationTx, buildUpdateAgentTx, buildUpdateCapabilitiesTx, buildWithdrawBidTx, buildWithdrawStakeTx, computeSharedSecret, createDID, createKeyStore, createMeteredResultEnvelope, createMeteringSeed, createPkcePair, createRelaySuiPaymentProof, createSuiClient, createWalrusBlobReference, decodeMeteredResult, decodeRelaySuiPaymentProof, decryptFromSender, deriveEvmKey, ed25519ToX25519, encodeRelaySuiPaymentProof, encryptForRecipient, generateKeypair, generateX25519KeyPair, getMeteredResultUnits, identityKeyExists, isEncryptedPayload, isValidDID, keypairFromSecretKey, loadOrCreateKeypair, parseDID, parseEncryptedPayload, parseMeteredResultEnvelope, parseRawEvent, parseWalrusBlobReference, pollDeviceFlow, serializeEncryptedPayload, serializeMeteredResultEnvelope, sign, signString, splitIntoMeteringUnits, startDeviceFlow, verify, verifyMerkleProof, verifyRelaySuiPaymentProof };