@invariance/sdk 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,4735 @@
+import * as _invariance_common from '@invariance/common';
+import { LedgerQueryFilters, LedgerEntry, ExportData, RegisterIdentityOptions, CreatePolicyOptions, Identity, SpecPolicy, HireOptions, IntentRequestOptions, LedgerEventInput, IntentResult, ActorType, ActorReference, SubmitReviewOptions, HireResult, CompletionResult, ReputationScore, PolicyRule, InvarianceConfig, ChainConfig, ContractAddresses, PauseResult, TxReceipt as TxReceipt$2, Attestation, PreparedIntent, ApprovalResult, IntentStatus, PolicyStatus, EvaluationResult, Unsubscribe, CreateEscrowOptions, EscrowContract, ResolveOptions, ApprovalStatus, EscrowStatus, VerificationResult, IdentityVerification, EscrowVerification, ReputationProfile, Review, ComparisonResult, Badge, ScoreHistory, GasEstimate, GasBalance, RegisterListingOptions, Listing, SearchQuery, SearchResults, AuditConfig, AuditLogMode, AuditVisibility, AuditLogInput, AuditLogRecord, AuditQueryFilters, CreateProposalOptions, VoteInput, Vote, SettlementData, MerkleProofBundle, Proposal, ErrorCode } from '@invariance/common';
+export { ActorReference, ActorType, ApprovalMethod, ApprovalResult, ApprovalStatus, Attestation, AuditConfig, AuditLogInput, AuditLogMode, AuditLogRecord, AuditQueryFilters, AuditVisibility, Badge, ChainConfig, ComparisonResult, CompletionResult, ContractAddresses, CreateEscrowOptions, CreatePolicyOptions, EIP1193Provider, ErrorCode, EscrowConditions, EscrowContract, EscrowState, EscrowStatus, EscrowVerification, EvaluationResult, ExportData, GasBalance, GasEstimate, HireOptions, HireResult, Identity, IdentityVerification, IntentLifecycle, IntentRequestOptions, IntentResult, IntentStatus, InvarianceConfig, InvarianceSigner, LedgerEntry, LedgerEventInput, LedgerQueryFilters, Listing, ListingCategory, OnChainMetrics, PauseResult, PaymentGatedAuthorization, PaymentOptions, PolicyRule, PolicyRuleType, PolicyStatus, PreparedIntent, PricingModel, ProofBundle, RegisterIdentityOptions, RegisterListingOptions, ReputationProfile, ReputationScore, RequirePaymentConfig, ResolveOptions, Review, ReviewSummary, ScoreHistory, ScoreHistoryEntry, SearchQuery, SearchResults, SpecPolicy, SubmitReviewOptions, TxReceipt, Unsubscribe, VerificationResult } from '@invariance/common';
+import { PublicClient, WalletClient, Chain } from 'viem';
+export { generatePrivateKey, mnemonicToAccount, privateKeyToAccount } from 'viem/accounts';
+
+/**
+ * SDK-level event types that modules can emit.
+ */
+interface InvarianceEvents {
+    'identity.registered': {
+        identityId: string;
+        address: string;
+    };
+    'identity.paused': {
+        identityId: string;
+    };
+    'identity.resumed': {
+        identityId: string;
+    };
+    'intent.requested': {
+        intentId: string;
+        action: string;
+        requester?: string;
+        requesterIdentityId?: string;
+        target?: string;
+        value?: string;
+        mode?: string;
+    };
+    'intent.approved': {
+        intentId: string;
+        approver: string;
+        approverIdentityId: string;
+    };
+    'intent.completed': {
+        intentId: string;
+        txHash: string;
+        requester?: string;
+        requesterIdentityId?: string;
+        action?: string;
+        value?: string;
+    };
+    'intent.rejected': {
+        intentId: string;
+        reason: string;
+        rejector?: string;
+        rejectorIdentityId?: string;
+    };
+    'policy.created': {
+        policyId: string;
+        name: string;
+    };
+    'policy.attached': {
+        policyId: string;
+        identityId: string;
+    };
+    'policy.detached': {
+        policyId: string;
+        identityId: string;
+    };
+    'policy.revoked': {
+        policyId: string;
+    };
+    'policy.composed': {
+        policyId: string;
+        name: string;
+    };
+    'policy.violation': {
+        policyId: string;
+        action: string;
+        detail: string;
+    };
+    'escrow.created': {
+        escrowId: string;
+        amount: string;
+        depositor?: string;
+        depositorIdentityId?: string;
+        beneficiary?: string;
+        beneficiaryIdentityId?: string;
+        conditionType?: string;
+    };
+    'escrow.funded': {
+        escrowId: string;
+        funder?: string;
+        depositor?: string;
+        depositorIdentityId?: string;
+        beneficiary?: string;
+        beneficiaryIdentityId?: string;
+        amount?: string;
+    };
+    'escrow.released': {
+        escrowId: string;
+        depositor?: string;
+        depositorIdentityId?: string;
+        beneficiary?: string;
+        beneficiaryIdentityId?: string;
+        amount?: string;
+    };
+    'escrow.refunded': {
+        escrowId: string;
+        depositor?: string;
+        depositorIdentityId?: string;
+        beneficiary?: string;
+        beneficiaryIdentityId?: string;
+        amount?: string;
+    };
+    'escrow.disputed': {
+        escrowId: string;
+        reason: string;
+        disputant?: string;
+        depositor?: string;
+        depositorIdentityId?: string;
+        beneficiary?: string;
+        beneficiaryIdentityId?: string;
+        amount?: string;
+    };
+    'escrow.resolved': {
+        escrowId: string;
+        depositor?: string;
+        depositorIdentityId?: string;
+        beneficiary?: string;
+        beneficiaryIdentityId?: string;
+        transferAmount?: string;
+        releasedToBeneficiary?: boolean;
+    };
+    'ledger.logged': {
+        entryId: string;
+        action: string;
+    };
+    'reputation.reviewed': {
+        reviewId: string;
+        target: string;
+        rating: number;
+        reviewer?: string;
+        reviewerIdentityId?: string;
+        targetIdentityId?: string;
+        escrowId?: string;
+        commentHash?: string;
+        categories?: Record<string, number>;
+    };
+    'marketplace.listed': {
+        listingId: string;
+    };
+    'marketplace.hired': {
+        hireId: string;
+        listingId: string;
+        hirer?: string;
+        provider?: string;
+        escrowId?: string;
+        policyId?: string;
+    };
+    'marketplace.hire.completed': {
+        hireId: string;
+        hirer: string;
+        provider: string;
+        listingId: string;
+        escrowId: string;
+        completedAt: number;
+    };
+    'marketplace.hire.cancelled': {
+        hireId: string;
+        hirer: string;
+        provider: string;
+        listingId: string;
+        escrowId: string;
+    };
+    'marketplace.hire.disputed': {
+        hireId: string;
+        disputant: string;
+        hirer: string;
+        provider: string;
+        listingId: string;
+        escrowId: string;
+    };
+    'webhook.delivered': {
+        webhookId: string;
+        event: string;
+    };
+    'payment.completed': {
+        paymentId: string;
+        action: string;
+        amount: string;
+    };
+    'payment.failed': {
+        action: string;
+        reason: string;
+    };
+    'erc8004.identity.linked': {
+        invarianceIdentityId: string;
+        erc8004AgentId: string;
+    };
+    'erc8004.identity.unlinked': {
+        invarianceIdentityId: string;
+        erc8004AgentId: string;
+    };
+    'erc8004.feedback.pushed': {
+        erc8004AgentId: string;
+        value: number;
+    };
+    'erc8004.validation.responded': {
+        requestHash: string;
+        response: number;
+    };
+    'action.before': {
+        action: string;
+        actor: {
+            type: string;
+            address: string;
+        };
+        timestamp: number;
+    };
+    'action.after': {
+        action: string;
+        actor: {
+            type: string;
+            address: string;
+        };
+        durationMs: number;
+        success: boolean;
+        timestamp: number;
+    };
+    'action.violation': {
+        action: string;
+        detail: string;
+        policyId?: string;
+        timestamp: number;
+    };
+    'action.error': {
+        action: string;
+        message: string;
+        code?: string;
+        timestamp: number;
+    };
+    'error': {
+        code: string;
+        message: string;
+    };
+}
+/** Listener callback type */
+type Listener<T> = (data: T) => void;
+/**
+ * Typed event emitter for SDK-level events.
+ *
+ * Provides a simple pub/sub mechanism for all Invariance modules
+ * to emit events and for consumers to subscribe to them.
+ *
+ * @example
+ * ```typescript
+ * const emitter = new InvarianceEventEmitter();
+ * emitter.on('intent.completed', (data) => {
+ *   console.log(`Intent ${data.intentId} completed: ${data.txHash}`);
+ * });
+ * ```
+ */
+declare class InvarianceEventEmitter {
+    private listeners;
+    /**
+     * Subscribe to an event.
+     *
+     * @param event - The event name to listen for
+     * @param listener - Callback invoked when the event is emitted
+     * @returns A function to unsubscribe
+     */
+    on<K extends keyof InvarianceEvents>(event: K, listener: Listener<InvarianceEvents[K]>): () => void;
+    /**
+     * Unsubscribe from an event.
+     *
+     * @param event - The event name
+     * @param listener - The callback to remove
+     */
+    off<K extends keyof InvarianceEvents>(event: K, listener: Listener<InvarianceEvents[K]>): void;
+    /**
+     * Emit an event to all subscribers.
+     *
+     * @param event - The event name
+     * @param data - The event payload
+     */
+    emit<K extends keyof InvarianceEvents>(event: K, data: InvarianceEvents[K]): void;
+}
+
+/**
+ * Type definitions for Invariance SDK convenience methods.
+ *
+ * These types support higher-level workflow methods on the {@link Invariance} class
+ * that compose multiple module calls into single operations.
+ */
+
+/** Options for {@link Invariance.quickSetup} */
+interface QuickSetupOptions {
+    /** Identity registration options */
+    identity: RegisterIdentityOptions;
+    /** Policy to create and attach to the new identity (required unless policyTemplate is set) */
+    policy?: CreatePolicyOptions;
+    /** Use a built-in policy template instead of manual policy config */
+    policyTemplate?: string;
+    /** Auto-fund the wallet after setup */
+    fund?: {
+        amount: string;
+        token?: 'USDC';
+    };
+}
+/** Result of {@link Invariance.quickSetup} */
+interface QuickSetupResult {
+    identity: Identity;
+    policy: SpecPolicy;
+    /** Whether the wallet was funded during setup */
+    funded?: boolean;
+}
+/** Options for {@link Invariance.hireAndFund} */
+interface HireAndFundOptions extends HireOptions {
+    /** Amount to fund the escrow with (defaults to hire payment amount) */
+    fundAmount?: string;
+}
+/** Options for a single agent in a batch registration */
+interface BatchAgentOptions {
+    /** Identity registration options */
+    identity: RegisterIdentityOptions;
+    /** Optional per-agent policy override (otherwise shared policy is used) */
+    policyOverride?: CreatePolicyOptions;
+}
+/** Result of a single agent in a batch registration */
+interface BatchRegisterEntry {
+    identity: Identity;
+    policy: SpecPolicy;
+}
+/** Options for {@link Invariance.batchRegister} */
+interface BatchRegisterOptions {
+    /** Agents to register */
+    agents: BatchAgentOptions[];
+    /** Shared policy applied to all agents (unless overridden) */
+    sharedPolicy: CreatePolicyOptions;
+}
+/** Options for {@link Invariance.executeAndLog} */
+interface ExecuteAndLogOptions {
+    /** Intent request options */
+    intent: IntentRequestOptions;
+    /** Additional ledger event to log alongside the intent */
+    log: LedgerEventInput;
+}
+/** Result of {@link Invariance.executeAndLog} */
+interface ExecuteAndLogResult {
+    intent: IntentResult;
+    log: LedgerEntry;
+}
+/** Options for {@link Invariance.recurringPayment} */
+interface RecurringPaymentOptions {
+    /** Human-readable name for the payment policy */
+    name: string;
+    /** Payment amount per interval */
+    amount: string;
+    /** Payment recipient address */
+    recipient: string;
+    /** Interval between payments (ISO 8601 duration, e.g. "P1M" for monthly) */
+    interval: string;
+    /** Maximum number of payments (optional, unlimited if omitted) */
+    maxPayments?: number;
+    /** Actor types this policy applies to */
+    actor?: ActorType | ActorType[];
+    /** Allowed actions during the payment window */
+    allowedActions?: string[];
+    /** Policy expiry (ISO 8601 datetime) */
+    expiry?: string;
+}
+/** Options for {@link Invariance.createMultiSig} */
+interface CreateMultiSigOptions {
+    /** Escrow amount in USDC */
+    amount: string;
+    /** Recipient identity or address */
+    recipient: ActorReference;
+    /** Signer addresses for multi-sig approval */
+    signers: string[];
+    /** Number of signatures required to release */
+    threshold: number;
+    /** Timeout per signer (ISO 8601 duration) */
+    timeoutPerSigner?: string;
+    /** Overall escrow timeout (ISO 8601 duration) */
+    timeout?: string;
+    /** Whether to auto-fund on creation */
+    autoFund?: boolean;
+}
+/** Options for {@link Invariance.setupRateLimitedAgent} */
+interface SetupRateLimitedAgentOptions {
+    /** Identity registration options */
+    identity: RegisterIdentityOptions;
+    /** Maximum actions per window */
+    maxActions: number;
+    /** Rate limit window (ISO 8601 duration, e.g. "PT1H" for 1 hour) */
+    window: string;
+    /** Cooldown between actions (ISO 8601 duration) */
+    cooldown?: string;
+    /** Allowed actions (whitelist) */
+    allowedActions?: string[];
+    /** Maximum spend per window */
+    maxSpend?: string;
+}
+/** Options for {@link Invariance.hireAndReview} */
+interface HireAndReviewOptions {
+    /** Hire options */
+    hire: HireOptions;
+    /** Review to submit after completion */
+    review: Omit<SubmitReviewOptions, 'target' | 'escrowId'>;
+    /** Amount to fund escrow (defaults to hire payment amount) */
+    fundAmount?: string;
+}
+/** Result of {@link Invariance.hireAndReview} */
+interface HireAndReviewResult {
+    hire: HireResult;
+    completion: CompletionResult;
+    review: {
+        reviewId: string;
+        updatedReputation: ReputationScore;
+    };
+}
+/** Options for {@link Invariance.audit} */
+interface AuditOptions extends LedgerQueryFilters {
+    /** Whether to verify each ledger entry */
+    verify?: boolean;
+    /** Export format */
+    exportFormat?: 'json' | 'csv';
+}
+/** Result of {@link Invariance.audit} */
+interface AuditReport {
+    entries: LedgerEntry[];
+    totalEntries: number;
+    verifiedCount: number;
+    failedVerifications: Array<{
+        entryId: string;
+        error: string;
+    }>;
+    exported?: ExportData;
+    generatedAt: number;
+}
+/** Options for {@link Invariance.delegate} */
+interface DelegateOptions {
+    /** Identity ID of the delegating agent */
+    from: string;
+    /** Identity ID of the agent receiving delegation */
+    to: string;
+    /** Scope of allowed actions for the delegate */
+    scope: {
+        /** Allowed actions */
+        actions: string[];
+        /** Maximum spend limit */
+        maxSpend?: string;
+        /** Delegation expiry (ISO 8601 datetime) */
+        expiry?: string;
+        /** Additional policy rules */
+        additionalRules?: PolicyRule[];
+    };
+}
+/** Result of {@link Invariance.delegate} */
+interface DelegateResult {
+    policy: SpecPolicy;
+    intent: IntentResult;
+}
+/** A deferred operation for batch execution */
+interface DeferredOperation<T = unknown> {
+    /** The async function to execute */
+    execute: () => Promise<T>;
+    /** Human-readable description of the operation */
+    description: string;
+}
+/** Options for batch execution */
+interface BatchOptions {
+    /** Continue executing remaining operations after a failure (default: false) */
+    continueOnError?: boolean;
+    /** Maximum number of concurrent operations (default: 5) */
+    maxConcurrency?: number;
+}
+/** Result of a batch execution */
+interface BatchResult<T = unknown> {
+    results: Array<{
+        index: number;
+        description: string;
+        result: T;
+    }>;
+    failures: Array<{
+        index: number;
+        description: string;
+        error: string;
+    }>;
+    successCount: number;
+    failureCount: number;
+    totalCount: number;
+}
+/** Options for creating a session context */
+interface SessionOptions {
+    /** The actor to bind to all session operations */
+    actor: ActorReference;
+}
+/** A single step result in a pipeline execution */
+interface PipelineStep {
+    name: string;
+    success: boolean;
+    result?: unknown;
+    error?: string;
+    durationMs: number;
+}
+/** Result of a pipeline execution */
+interface PipelineResult {
+    success: boolean;
+    steps: PipelineStep[];
+    context: Record<string, unknown>;
+}
+
+/** Filters for querying intent history */
+interface IntentHistoryFilters {
+    actor?: string;
+    action?: string | string[];
+    status?: 'completed' | 'rejected' | 'expired';
+    from?: string | number;
+    to?: string | number;
+    limit?: number;
+    offset?: number;
+}
+/** Configuration for intent retry behavior */
+interface RetryConfig {
+    /** Maximum number of attempts (default: 3) */
+    maxAttempts?: number;
+    /** Initial delay in milliseconds (default: 1000) */
+    initialDelayMs?: number;
+    /** Backoff multiplier (default: 2) */
+    backoffMultiplier?: number;
+    /** Error codes that trigger a retry (default: NETWORK_ERROR, RPC_ERROR, TIMEOUT) */
+    retryableErrors?: string[];
+}
+/** Result of a retried intent request */
+interface RetryResult {
+    /** The successful intent result (if any) */
+    result: _invariance_common.IntentResult | null;
+    /** Total number of attempts made */
+    attempts: number;
+    /** Errors from each failed attempt */
+    errors: Array<{
+        attempt: number;
+        error: string;
+        code?: string;
+    }>;
+    /** Whether the request ultimately succeeded */
+    success: boolean;
+}
+
+/** Callback for streamed ledger entries */
+type LedgerStreamCallback = (entry: _invariance_common.LedgerEntry) => void;
+/** Configuration for auto-batching compact ledger entries */
+interface AutoBatchConfig {
+    /** Maximum entries per batch (default: 10) */
+    maxBatchSize?: number;
+    /** Maximum wait time in ms before flushing (default: 5000) */
+    maxWaitMs?: number;
+    /** Whether batching is enabled (default: true) */
+    enabled?: boolean;
+}
+/** Time range filter for analytics queries */
+interface AnalyticsTimeframe {
+    from?: string | number;
+    to?: string | number;
+}
+/** Result of a success rate query */
+interface SuccessRateResult {
+    total: number;
+    successful: number;
+    failed: number;
+    /** Success rate as a decimal (0-1) */
+    rate: number;
+    /** Success rate as a percentage (0-100) */
+    percentage: number;
+}
+/** Result of an action count query */
+interface ActionCountResult {
+    action: string;
+    count: number;
+    byCategory: Record<string, number>;
+}
+/** Result of a cost summary query */
+interface CostSummaryResult {
+    totalCost: string;
+    transactionCount: number;
+    byAction: Record<string, number>;
+}
+/** Result of a violations query */
+interface ViolationResult {
+    total: number;
+    byAction: Record<string, number>;
+    details: Array<{
+        action: string;
+        timestamp: number;
+        detail: string;
+        policyId: string;
+    }>;
+}
+
+/** Options for evaluating an action against a policy */
+interface EvaluateOptions {
+    policyId: string;
+    actor: _invariance_common.ActorReference;
+    action: string;
+    amount?: string;
+    params?: Record<string, unknown>;
+    /** x402 payment receipt ID for require-payment rule verification */
+    paymentReceiptId?: string;
+}
+/** Filters for listing policies */
+interface PolicyListFilters {
+    identityId?: string;
+    actor?: string;
+    state?: 'active' | 'revoked' | 'expired';
+    limit?: number;
+    offset?: number;
+}
+/** Callback for policy violation events */
+type PolicyViolationCallback = (violation: {
+    policyId: string;
+    action: string;
+    detail: string;
+    timestamp: number;
+}) => void;
+/** Built-in template names */
+type BuiltInTemplate = 'conservative-spending' | 'defi-trading' | 'content-agent' | 'research-agent' | 'full-autonomy' | 'mev-bot' | 'social-agent' | 'cross-chain-bridge' | 'payment-delegation' | 'iot-device' | 'government-benefits' | 'identity-verifier';
+/** A policy template definition */
+interface PolicyTemplate {
+    /** Template name */
+    name: string;
+    /** Human-readable description */
+    description: string;
+    /** Whether this is a built-in template */
+    builtin: boolean;
+    /** Policy rules included in the template */
+    rules: _invariance_common.PolicyRule[];
+}
+
+/**
+ * Session context that binds an actor to all operations,
+ * eliminating repetitive actor passing.
+ *
+ * @example
+ * ```typescript
+ * const session = inv.session({ actor: { type: 'agent', address: '0xBot' } });
+ * await session.requestIntent({ action: 'swap', params: {...} });
+ * await session.myActions({ limit: 50 });
+ * ```
+ */
+
+/**
+ * A session scoped to a specific actor.
+ *
+ * All operations automatically use the bound actor, removing the need
+ * to pass actor references repeatedly.
+ */
+declare class SessionContext {
+    private readonly inv;
+    /** The actor bound to this session */
+    readonly actor: ActorReference;
+    constructor(inv: Invariance, options: SessionOptions);
+    /**
+     * Request an intent with the session actor pre-filled.
+     *
+     * @param opts - Intent options (actor is auto-filled)
+     * @returns Intent result
+     */
+    requestIntent(opts: Omit<IntentRequestOptions, 'actor'>): Promise<IntentResult>;
+    /**
+     * Query the session actor's action history.
+     *
+     * @param filters - Optional additional filters
+     * @returns Array of intent results
+     */
+    myActions(filters?: Omit<IntentHistoryFilters, 'actor'>): Promise<IntentResult[]>;
+    /**
+     * Query ledger entries for the session actor.
+     *
+     * @param filters - Optional additional filters
+     * @returns Array of ledger entries
+     */
+    myLedgerEntries(filters?: Omit<LedgerQueryFilters, 'actor'>): Promise<LedgerEntry[]>;
+    /**
+     * List policies attached to the session actor's identity.
+     *
+     * @param filters - Optional additional filters
+     * @returns Array of policies
+     */
+    myPolicies(filters?: Omit<PolicyListFilters, 'identityId'>): Promise<SpecPolicy[]>;
+}
+
+/**
+ * Fluent pipeline builder for multi-step workflows with auto-linked context.
+ *
+ * @example
+ * ```typescript
+ * const result = await inv.pipeline()
+ *   .register({ type: 'agent', label: 'Bot', owner: '0x...' })
+ *   .createPolicy({ template: 'defi-trading' })
+ *   .attachPolicy()
+ *   .fundWallet({ amount: '100' })
+ *   .execute();
+ * ```
+ */
+
+/** Shared context passed between pipeline steps */
+type PipelineContext = Map<string, unknown>;
+/**
+ * Fluent builder for multi-step agent workflows.
+ *
+ * Steps store results in a shared context map. Later steps auto-read
+ * values (like identityId, policyId) from context.
+ */
+declare class PipelineBuilder {
+    private readonly inv;
+    private readonly steps;
+    constructor(inv: Invariance);
+    /**
+     * Register an identity. Stores `identityId` and `identity` in context.
+     */
+    register(opts: RegisterIdentityOptions): this;
+    /**
+     * Create a policy. Accepts either a template name or full options.
+     * Stores `policyId` and `policy` in context.
+     */
+    createPolicy(opts: {
+        template: string;
+        expiry?: string;
+    } | CreatePolicyOptions): this;
+    /**
+     * Attach the policy from context to the identity from context.
+     * Auto-reads `policyId` and `identityId` from previous steps.
+     */
+    attachPolicy(policyId?: string, identityId?: string): this;
+    /**
+     * Fund the wallet with a specified amount.
+     */
+    fundWallet(opts: {
+        amount: string;
+        token?: 'USDC';
+    }): this;
+    /**
+     * Add a custom step with access to the pipeline context.
+     */
+    custom(name: string, fn: (ctx: PipelineContext) => Promise<unknown>): this;
+    /**
+     * Execute all pipeline steps sequentially.
+     * Stops on first error with full step-by-step reporting.
+     *
+     * @returns Pipeline result with success status, step results, and context
+     */
+    execute(): Promise<PipelineResult>;
+}
+
+type ContractName = 'identity' | 'policy' | 'ledger' | 'intent' | 'escrow' | 'review' | 'registry' | 'hire' | 'mockUsdc' | 'compactLedger' | 'atomicVerifier' | 'voting';
+/**
+ * Manages contract instances and blockchain connectivity.
+ *
+ * ContractFactory is the central point for creating and caching
+ * viem PublicClient and WalletClient instances, as well as providing
+ * typed contract addresses for each Invariance module.
+ *
+ * @example
+ * ```typescript
+ * const factory = new ContractFactory(config);
+ * const identityAddr = factory.getAddress('identity');
+ * ```
+ */
+declare class ContractFactory {
+    private readonly config;
+    private readonly chainConfig;
+    private readonly addresses;
+    private publicClient;
+    private wsPublicClient;
+    private walletClient;
+    constructor(config: InvarianceConfig);
+    /**
+     * Get the RPC URL for the current chain.
+     * Uses config override if provided, otherwise falls back to chain default.
+     */
+    getRpcUrl(): string;
+    /**
+     * Get the chain configuration.
+     */
+    getChainConfig(): ChainConfig;
+    /**
+     * Get the chain ID.
+     */
+    getChainId(): number;
+    /**
+     * Get all contract addresses for the current chain.
+     */
+    getAddresses(): ContractAddresses;
+    /**
+     * Get a specific contract address by module name.
+     *
+     * @param name - The contract module name
+     * @returns The contract address as a hex string
+     */
+    getAddress(name: keyof ContractAddresses): string;
+    /**
+     * Get the signer/wallet from config.
+     * Returns undefined if no signer is configured.
+     */
+    getSigner(): unknown;
+    /**
+     * Get the API key from config (for managed hosting).
+     */
+    getApiKey(): string | undefined;
+    /**
+     * Get the gas strategy.
+     */
+    getGasStrategy(): 'standard' | 'fast' | 'abstracted' | 'sponsored';
+    /**
+     * Get the explorer base URL.
+     */
+    getExplorerBaseUrl(): string;
+    /**
+     * Check whether managed mode is active (API key provided).
+     */
+    isManaged(): boolean;
+    /** Set the viem clients after wallet initialization */
+    setClients(publicClient: PublicClient, walletClient: WalletClient): void;
+    /**
+     * Get the best available client for receipt watching.
+     * Prefers WebSocket (instant block notifications) over HTTP polling.
+     */
+    getReceiptClient(): PublicClient;
+    /** Get the confirmation strategy. */
+    getConfirmation(): 'optimistic' | 'receipt';
+    /** Get the public client for read operations */
+    getPublicClient(): PublicClient;
+    /** Get the wallet client for write operations */
+    getWalletClient(): WalletClient;
+    /** Check if clients are initialized */
+    hasClients(): boolean;
+    /**
+     * Get a viem contract instance for the given contract name.
+     *
+     * @param name - The contract name
+     * @returns A viem contract instance with read/write methods
+     */
+    getContract(name: ContractName): {
+        address: `0x${string}`;
+        abi: readonly unknown[];
+        read: Record<string, (...args: unknown[]) => Promise<unknown>>;
+        write: Record<string, (...args: unknown[]) => Promise<`0x${string}`>>;
+    };
+    /** Get the API base URL for indexer calls */
+    getApiBaseUrl(): string;
+    /** Get the wallet address from the wallet client */
+    getWalletAddress(): string;
+    /**
+     * Get the EIP-712 domain for CompactLedger signatures.
+     *
+     * @returns EIP-712 domain with the CompactLedger contract address
+     */
+    getCompactLedgerDomain(): {
+        name: string;
+        version: string;
+        chainId: number;
+        verifyingContract: `0x${string}`;
+    };
+}
+
+/**
+ * Anonymized telemetry collector for SDK usage metrics.
+ *
+ * When enabled, collects non-identifying usage data such as method call counts,
+ * error rates, and latency distributions. All data is anonymized and contains
+ * no wallet addresses, transaction hashes, or personally identifiable information.
+ *
+ * Telemetry is opt-out: enabled by default but can be disabled via config.
+ */
+declare class Telemetry {
+    private readonly enabled;
+    private buffer;
+    private static readonly MAX_BUFFER_SIZE;
+    constructor(enabled: boolean);
+    /**
+     * Track an anonymized telemetry event.
+     *
+     * @param event - Event name (e.g., 'identity.register', 'intent.request')
+     * @param data - Anonymized event data (no PII, no addresses, no hashes)
+     */
+    track(event: string, data?: Record<string, unknown>): void;
+    /**
+     * Flush buffered telemetry events.
+     *
+     * In V1 this is a no-op stub. Future versions will send to
+     * the Invariance telemetry endpoint.
+     */
+    flush(): Promise<void>;
+}
+
+/**
+ * Re-exports and module-specific types for the Identity module.
+ */
+
+/** Filters for listing identities */
+interface IdentityListFilters {
+    type?: 'agent' | 'human' | 'device' | 'service';
+    owner?: string;
+    status?: 'active' | 'suspended' | 'deactivated';
+    limit?: number;
+    offset?: number;
+}
+/** Attestation input (without auto-generated fields) */
+interface AttestationInput {
+    claim: string;
+    attester: string;
+    evidence?: string;
+    expiresAt?: number;
+}
+/** Options for updating an identity */
+interface UpdateIdentityOptions {
+    label?: string;
+    metadata?: Record<string, string>;
+    capabilities?: string[];
+}
+
+/**
+ * Manages identity registration, resolution, and lifecycle.
+ *
+ * Everything in Invariance is an Identity. An identity is an on-chain entity
+ * that can perform actions, hold reputation, and be verified. The identity
+ * module replaces the concept of "wallet management" with a universal actor registry.
+ *
+ * @example
+ * ```typescript
+ * const agent = await inv.identity.register({
+ *   type: 'agent',
+ *   owner: '0xDeveloperWallet',
+ *   label: 'AlphaTrader v2',
+ *   capabilities: ['swap', 'rebalance'],
+ *   wallet: { create: true },
+ * });
+ * ```
+ */
+declare class IdentityManager {
+    private readonly contracts;
+    private readonly events;
+    private readonly telemetry;
+    private indexer;
+    constructor(contracts: ContractFactory, events: InvarianceEventEmitter, telemetry: Telemetry);
+    /** Lazily initialize the indexer client */
+    private getIndexer;
+    /** Map an on-chain identity tuple to the SDK Identity type */
+    private mapOnChainIdentity;
+    /** Map an on-chain attestation tuple to the SDK Attestation type */
+    private mapOnChainAttestation;
+    /**
+     * Register a new identity (agent, human, device, or service).
+     *
+     * Creates an on-chain identity record and optionally provisions
+     * an embedded wallet via Privy.
+     *
+     * @param opts - Registration options including type, owner, and label
+     * @returns The newly created identity
+     */
+    register(opts: RegisterIdentityOptions): Promise<Identity>;
+    /**
+     * Get identity details by address.
+     *
+     * @param address - The 0x wallet address of the identity
+     * @returns The identity record
+     * @throws {InvarianceError} If identity is not found
+     */
+    get(address: string): Promise<Identity>;
+    /**
+     * Resolve an identity by ID, address, or ENS name.
+     *
+     * @param idOrAddress - Identity ID (bytes32 hex), 0x address, or string ID
+     * @returns The resolved identity
+     * @throws {InvarianceError} If identity cannot be resolved
+     */
+    resolve(idOrAddress: string): Promise<Identity>;
+    /**
+     * Update identity metadata.
+     *
+     * @param id - The identity ID to update
+     * @param opts - Fields to update (label, metadata, capabilities)
+     * @returns The updated identity
+     */
+    update(id: string, opts: UpdateIdentityOptions): Promise<Identity>;
+    /**
+     * EMERGENCY STOP: Freeze an identity.
+     *
+     * Pausing an identity is the kill switch. One call revokes all active
+     * policies, freezes all escrowed funds, and cancels all pending intents.
+     * Only the identity owner can call this.
+     *
+     * @param id - The identity ID to pause
+     * @returns Pause result with counts of affected resources
+     */
+    pause(id: string): Promise<PauseResult>;
+    /**
+     * Resume a paused identity.
+     *
+     * Reactivates the identity. Policies must be re-attached manually
+     * as a safety measure. Escrows unfreeze but require fresh approval.
+     *
+     * @param id - The identity ID to resume
+     * @returns Transaction receipt
+     */
+    resume(id: string): Promise<TxReceipt$2>;
+    /**
+     * Permanently deactivate an identity.
+     *
+     * This is irreversible. All policies are revoked and escrows are refunded.
+     *
+     * @param id - The identity ID to deactivate
+     * @returns Transaction receipt
+     */
+    deactivate(id: string): Promise<TxReceipt$2>;
+    /**
+     * List identities by type, owner, or status.
+     *
+     * Attempts the indexer API first, falls back to on-chain reads.
+     *
+     * @param filters - Optional filters to narrow results
+     * @returns Array of matching identities
+     */
+    list(filters?: IdentityListFilters): Promise<Identity[]>;
+    /**
+     * Add an attestation to an identity.
+     *
+     * Attestations are claims made by third parties about an identity,
+     * stored on-chain with optional evidence hashes.
+     *
+     * @param id - The identity ID to attest
+     * @param attestation - The attestation details
+     * @returns The created attestation record
+     */
+    attest(id: string, attestation: AttestationInput): Promise<Attestation>;
+    /**
+     * Get all attestations for an identity.
+     *
+     * @param id - The identity ID
+     * @returns Array of attestation records
+     */
+    attestations(id: string): Promise<Attestation[]>;
+}
+
+type WalletProvider = 'coinbase-wallet' | 'coinbase-smart-wallet' | 'metamask' | 'walletconnect' | 'privy' | 'dynamic' | 'turnkey' | 'safe' | 'ledger' | 'raw' | 'custom';
+interface WalletInfo {
+    address: string;
+    provider: WalletProvider;
+    chainId: number;
+    connected: boolean;
+    isSmartAccount: boolean;
+    identityId?: string | undefined;
+}
+interface BalanceInfo {
+    usdc: string;
+    eth: string;
+    address: string;
+}
+interface FundOptions {
+    amount: string;
+    token?: 'USDC' | undefined;
+}
+interface CreateWalletOptions {
+    provider?: WalletProvider | undefined;
+    label?: string | undefined;
+    chainType?: string | undefined;
+}
+interface ConnectOptions {
+    provider?: WalletProvider | undefined;
+    chainId?: number | undefined;
+}
+
+/**
+ * Handles wallet management for all identity types.
+ *
+ * Accepts any wallet type: viem Account, WalletClient, EIP-1193 provider,
+ * or custom InvarianceSigner. Normalizes to viem WalletClient internally.
+ *
+ * @example
+ * ```typescript
+ * const inv = new Invariance({
+ *   chain: 'base',
+ *   signer: privateKeyToAccount('0x...'),
+ * });
+ * const balance = await inv.wallet.balance();
+ * ```
+ */
+declare class WalletManager {
+    private readonly contracts;
+    private readonly telemetry;
+    private readonly config;
+    private walletClient;
+    private publicClient;
+    private address;
+    private detectedProvider;
+    constructor(contracts: ContractFactory, telemetry: Telemetry, config: InvarianceConfig);
+    /**
+     * Initialize from a signer provided in config.
+     * Detects type and normalizes to viem WalletClient.
+     */
+    initFromSigner(signer: unknown, rpcUrl: string, chain: Chain): Promise<void>;
+    private isViemAccount;
+    private isWalletClient;
+    private isEIP1193Provider;
+    private isInvarianceSigner;
+    private isPrivyWallet;
+    private requireWallet;
+    private requirePublicClient;
+    /** Get the wallet address */
+    getAddress(): `0x${string}`;
+    /** Get the underlying viem WalletClient */
+    getWalletClient(): WalletClient;
+    /** Get the public client for read operations */
+    getPublicClient(): PublicClient;
+    /** Check if a wallet is connected */
+    isConnected(): boolean;
+    /**
+     * Create an embedded wallet using Privy.
+     * Requires Privy configuration in InvarianceConfig: { privy: { appId, appSecret } }
+     * @param _opts - Optional wallet creation options
+     */
+    create(_opts?: CreateWalletOptions): Promise<WalletInfo>;
+    /** Get the current wallet info */
+    get(): Promise<WalletInfo>;
+    /**
+     * Send USDC or ETH to a wallet address.
+     * WARNING: This method executes transfers immediately without confirmation prompts.
+     * The caller is responsible for implementing any necessary security checks.
+     * @param address - The recipient address
+     * @param opts - Fund options including amount and token type (defaults to USDC)
+     */
+    fund(address: string, opts: FundOptions): Promise<TxReceipt$2>;
+    /**
+     * Get USDC and ETH balances for an address.
+     * @param address - The address to check (defaults to current wallet)
+     */
+    balance(address?: string | undefined): Promise<BalanceInfo>;
+}
+
+/**
+ * The Intent Protocol is the heart of Invariance.
+ *
+ * Every verified action follows the same four-step handshake:
+ * **Request -> Approve -> Execute -> Verify**.
+ *
+ * The proof generated at the end looks identical regardless of who
+ * performed the action (agent, human, or device).
+ *
+ * @example
+ * ```typescript
+ * const trade = await inv.intent.request({
+ *   actor: { type: 'agent', address: '0xTradingBot' },
+ *   action: 'swap',
+ *   params: { from: 'USDC', to: 'ETH', amount: '100' },
+ *   approval: 'auto',
+ * });
+ * console.log(trade.explorerUrl);
+ * ```
+ */
+declare class IntentProtocol {
+    private readonly contracts;
+    private readonly events;
+    private readonly telemetry;
+    private indexer;
+    private x402;
+    constructor(contracts: ContractFactory, events: InvarianceEventEmitter, telemetry: Telemetry);
+    /** Lazily initialize the X402 manager */
+    private getX402Manager;
+    /** Lazily initialize the indexer client */
+    private getIndexer;
+    /**
+     * Full intent handshake: request, approve, execute, verify.
+     *
+     * This is the primary method for performing verified actions.
+     * The approval method determines how the intent is approved:
+     * - 'auto': Policy engine auto-approves (for agents)
+     * - 'wallet-signature': Requires wallet signature (for humans)
+     * - 'multi-sig': M-of-N approval required
+     *
+     * @param opts - Intent request options
+     * @returns The completed intent result with proof bundle
+     */
+    request(opts: IntentRequestOptions): Promise<IntentResult>;
+    /**
+     * Single-transaction atomic verification using CompactLedger + AtomicVerifier.
+     *
+     * Collapses identity check + policy evaluation + ledger log into one tx.
+     * ~86% gas reduction compared to the full intent handshake.
+     *
+     * @param opts - Intent request options
+     * @returns The completed intent result with proof bundle
+     */
+    requestAtomic(opts: IntentRequestOptions): Promise<IntentResult>;
+    /**
+     * Prepare an intent without executing (dry-run).
+     *
+     * Useful for checking if an intent would succeed, estimating gas,
+     * and previewing policy evaluations before committing.
+     *
+     * @param opts - Intent request options
+     * @returns Prepared intent with policy checks and gas estimate
+     */
+    prepare(opts: IntentRequestOptions): Promise<PreparedIntent>;
+    /**
+     * Manually approve a pending intent.
+     *
+     * Used when an intent requires wallet signature or multi-sig approval
+     * and the signer wants to approve it explicitly.
+     *
+     * @param intentId - The intent to approve
+     * @returns Approval result with threshold status
+     */
+    approve(intentId: string): Promise<ApprovalResult>;
+    /**
+     * Reject a pending intent.
+     *
+     * @param intentId - The intent to reject
+     * @param reason - Optional reason for rejection
+     * @returns Transaction receipt
+     */
+    reject(intentId: string, reason?: string): Promise<TxReceipt$2>;
+    /**
+     * Check the lifecycle status of an intent.
+     *
+     * @param intentId - The intent to check
+     * @returns Current intent status with approval details
+     */
+    status(intentId: string): Promise<IntentStatus>;
+    /**
+     * Request an intent with automatic retry on transient failures.
+     *
+     * Retries on NETWORK_ERROR, RPC_ERROR, and TIMEOUT by default.
+     * Uses exponential backoff between attempts.
+     *
+     * @param opts - Intent request options
+     * @param retryConfig - Retry behavior configuration
+     * @returns Result with attempt history
+     *
+     * @example
+     * ```typescript
+     * const result = await inv.intent.requestWithRetry(
+     *   { actor, action: 'swap', params, approval: 'auto' },
+     *   { maxAttempts: 3, initialDelayMs: 1000, backoffMultiplier: 2 }
+     * );
+     * ```
+     */
+    requestWithRetry(opts: IntentRequestOptions, retryConfig?: RetryConfig): Promise<RetryResult>;
+    /**
+     * Query intent history with filters.
+     *
+     * @param filters - Optional filters for actor, action, status, time range
+     * @returns Array of completed intent results
+     */
+    history(filters?: IntentHistoryFilters): Promise<IntentResult[]>;
+}
+
+/**
+ * Composable, verifiable condition sets for action control.
+ *
+ * The Policy Engine replaces simple permissions with composable, verifiable
+ * condition sets. A policy is a set of rules: can I do this, under these
+ * conditions, with these constraints, verified by these parties?
+ *
+ * @example
+ * ```typescript
+ * const policy = await inv.policy.create({
+ *   name: 'Daily Trading Limits',
+ *   actor: 'agent',
+ *   rules: [
+ *     { type: 'max-spend', config: { limit: '1000', period: '24h' } },
+ *     { type: 'action-whitelist', config: { actions: ['swap'] } },
+ *   ],
+ * });
+ * await inv.policy.attach(policy.policyId, agent.identityId);
+ * ```
+ */
+declare class PolicyEngine {
+    private readonly contracts;
+    private readonly events;
+    private readonly telemetry;
+    private indexer;
+    private x402;
+    constructor(contracts: ContractFactory, events: InvarianceEventEmitter, telemetry: Telemetry);
+    /** Lazily initialize the X402 manager */
+    private getX402Manager;
+    /** Lazily initialize the indexer client */
+    private getIndexer;
+    /** Map an on-chain policy tuple to the SDK SpecPolicy type */
+    private mapOnChainPolicy;
+    /** Get the contract address for the policy module */
+    getContractAddress(): string;
+    /**
+     * Create a new policy.
+     *
+     * Policies are registered on-chain and can be attached to one or more
+     * identities. They support composable rules including spending limits,
+     * time windows, action whitelists, and custom evaluators.
+     *
+     * @param opts - Policy creation options
+     * @returns The created policy
+     */
+    create(opts: CreatePolicyOptions): Promise<SpecPolicy>;
+    /**
+     * Attach a policy to an identity.
+     *
+     * Once attached, all actions by this identity will be evaluated
+     * against the policy rules.
+     *
+     * @param policyId - The policy to attach
+     * @param identityId - The identity to attach it to
+     * @returns Transaction receipt
+     */
+    attach(policyId: string, identityId: string): Promise<TxReceipt$2>;
+    /**
+     * Remove a policy from an identity.
+     *
+     * @param policyId - The policy to detach
+     * @param identityId - The identity to detach it from
+     * @returns Transaction receipt
+     */
+    detach(policyId: string, identityId: string): Promise<TxReceipt$2>;
+    /**
+     * Check policy state and usage statistics.
+     *
+     * @param policyId - The policy to check
+     * @returns Extended policy status with usage metrics
+     */
+    status(policyId: string): Promise<PolicyStatus>;
+    /**
+     * List policies by identity, type, or status.
+     *
+     * @param filters - Optional filters
+     * @returns Array of matching policies
+     */
+    list(filters?: PolicyListFilters): Promise<SpecPolicy[]>;
+    /**
+     * Evaluate an action against a policy without executing.
+     *
+     * Returns detailed rule-by-rule evaluation results, remaining
+     * budgets, and compliance proof if all rules pass.
+     *
+     * @param opts - Evaluation options (policy, actor, action)
+     * @returns Detailed evaluation result per rule
+     */
+    evaluate(opts: EvaluateOptions): Promise<EvaluationResult>;
+    /**
+     * Revoke a policy entirely.
+     *
+     * Once revoked, the policy cannot be re-activated. All identities
+     * with this policy attached will have it automatically detached.
+     *
+     * @param policyId - The policy to revoke
+     * @returns Transaction receipt
+     */
+    revoke(policyId: string): Promise<TxReceipt$2>;
+    /**
+     * Combine multiple policies into one composite policy.
+     *
+     * The composed policy evaluates all constituent rules. An action
+     * must pass ALL rules from ALL composed policies to be allowed.
+     *
+     * @param policyIds - Array of policy IDs to compose
+     * @returns The new composite policy
+     */
+    compose(policyIds: string[]): Promise<SpecPolicy>;
+    /**
+     * Create a policy from a pre-built template.
+     *
+     * @param templateName - Name of the template (e.g. 'defi-trading')
+     * @param overrides - Optional overrides for expiry, actor, or additional rules
+     * @returns The created policy
+     *
+     * @example
+     * ```typescript
+     * const policy = await inv.policy.fromTemplate('defi-trading', { expiry: '2025-12-31' });
+     * ```
+     */
+    fromTemplate(templateName: string, overrides?: {
+        expiry?: string;
+        actor?: _invariance_common.ActorType | _invariance_common.ActorType[];
+        additionalRules?: _invariance_common.PolicyRule[];
+    }): Promise<SpecPolicy>;
+    /**
+     * Register a custom policy template.
+     *
+     * @param name - Template name
+     * @param template - Template definition with description and rules
+     *
+     * @example
+     * ```typescript
+     * inv.policy.defineTemplate('my-custom', {
+     *   description: 'Custom policy for my use case',
+     *   rules: [{ type: 'max-spend', config: { amount: '500' } }],
+     * });
+     * ```
+     */
+    defineTemplate(name: string, template: Omit<PolicyTemplate, 'name' | 'builtin'>): void;
+    /**
+     * List all available policy templates (built-in + custom).
+     *
+     * @returns Array of template metadata
+     */
+    listTemplates(): Array<{
+        name: string;
+        description: string;
+        builtin: boolean;
+    }>;
+    /**
+     * Subscribe to policy violations in real-time.
+     *
+     * @param policyId - The policy to monitor
+     * @param callback - Called when a violation occurs
+     * @returns Unsubscribe function
+     */
+    onViolation(policyId: string, callback: PolicyViolationCallback): Unsubscribe;
+}
+
+/** Filters for listing escrows */
+interface EscrowListFilters {
+    depositor?: string;
+    recipient?: string;
+    state?: _invariance_common.EscrowState;
+    limit?: number;
+    offset?: number;
+}
+/** Callback for escrow state change events */
+type EscrowStateChangeCallback = (change: {
+    escrowId: string;
+    previousState: _invariance_common.EscrowState;
+    newState: _invariance_common.EscrowState;
+    txHash: string;
+    timestamp: number;
+}) => void;
+/** Options for releasing escrow funds */
+interface ReleaseOptions {
+    /** Optional linked intent ID for automatic release verification */
+    intentId?: string;
+}
+
+/**
+ * USDC escrow with multi-sig, conditional release.
+ *
+ * Escrow is the payment primitive for any verified interaction.
+ * Lock USDC, define release conditions, and funds only move when
+ * conditions are cryptographically confirmed.
+ *
+ * @example
+ * ```typescript
+ * const escrow = await inv.escrow.create({
+ *   amount: '250.00',
+ *   recipient: { type: 'agent', address: '0xContentBot' },
+ *   conditions: { type: 'task-completion', timeout: '48h', arbiter: '0xPlatform' },
+ *   autoFund: true,
+ * });
+ * ```
+ */
+declare class EscrowManager {
+    private readonly contracts;
+    private readonly events;
+    private readonly telemetry;
+    private indexer;
+    constructor(contracts: ContractFactory, events: InvarianceEventEmitter, telemetry: Telemetry);
+    /** Lazily initialize the indexer client */
+    private getIndexer;
+    /** Get the contract address for the escrow module */
+    getContractAddress(): string;
+    /**
+     * Parse timeout string (e.g., '48h', '7d') to seconds.
+     *
+     * @param timeout - The timeout string
+     * @returns Timeout in seconds
+     */
+    private parseTimeout;
+    /**
+     * Resolve an identity ID to its actor type by querying the identity contract.
+     *
+     * @param identityId - The on-chain identity ID (bytes32)
+     * @returns The actor type string
+     */
+    private resolveActorType;
+    /** Map an on-chain escrow tuple to the SDK EscrowContract type */
+    private mapOnChainEscrow;
+    /**
+     * Deploy a new escrow contract on Base.
+     *
+     * Creates an escrow with specified conditions: single-arbiter,
+     * multi-sig, intent-linked, or milestone-based release.
+     *
+     * @param opts - Escrow creation options
+     * @returns The deployed escrow contract details
+     */
+    create(opts: CreateEscrowOptions): Promise<EscrowContract>;
+    /**
+     * Fund an escrow with USDC.
+     *
+     * This uses a two-step ERC20 approval flow:
+     * 1. Approve the escrow contract to spend USDC
+     * 2. Call fund() to transfer USDC to the escrow
+     *
+     * @param escrowId - The escrow to fund
+     * @returns Transaction receipt
+     */
+    fund(escrowId: string): Promise<TxReceipt$2>;
+    /**
+     * Release escrow funds to recipient.
+     *
+     * @param escrowId - The escrow to release
+     * @param opts - Optional release options
+     * @returns Transaction receipt
+     */
+    release(escrowId: string, _opts?: ReleaseOptions): Promise<TxReceipt$2>;
+    /**
+     * Refund escrow to depositor.
+     *
+     * @param escrowId - The escrow to refund
+     * @returns Transaction receipt
+     */
+    refund(escrowId: string): Promise<TxReceipt$2>;
+    /**
+     * Open a dispute on an escrow.
+     *
+     * @param escrowId - The escrow to dispute
+     * @param reason - Reason for the dispute
+     * @returns Transaction receipt
+     */
+    dispute(escrowId: string, reason: string): Promise<TxReceipt$2>;
+    /**
+     * Resolve a dispute (arbiter only).
+     *
+     * Transfers funds to either beneficiary or depositor based on resolution.
+     *
+     * @param escrowId - The disputed escrow
+     * @param opts - Resolution options
+     * @returns Transaction receipt
+     */
+    resolve(escrowId: string, opts: ResolveOptions): Promise<TxReceipt$2>;
+    /**
+     * Approve escrow release (multi-sig signer).
+     *
+     * Each signer calls this independently. When the threshold is met,
+     * funds can be released.
+     *
+     * @param escrowId - The escrow to approve
+     * @returns Approval result with threshold status
+     */
+    approve(escrowId: string): Promise<ApprovalResult>;
+    /**
+     * Check multi-sig approval status.
+     *
+     * @param escrowId - The escrow to check
+     * @returns Approval status with signer details
+     */
+    approvals(escrowId: string): Promise<ApprovalStatus>;
+    /**
+     * Get the current state of an escrow.
+     *
+     * @param escrowId - The escrow to check
+     * @returns Extended escrow status with time remaining and approvals
+     */
+    status(escrowId: string): Promise<EscrowStatus>;
+    /**
+     * List escrows by identity, state, or role.
+     *
+     * Attempts the indexer API first, falls back to on-chain reads.
+     *
+     * @param filters - Optional filters
+     * @returns Array of matching escrow contracts
+     */
+    list(filters?: EscrowListFilters): Promise<EscrowContract[]>;
+    /**
+     * Subscribe to escrow state changes in real-time.
+     *
+     * @param escrowId - The escrow to monitor
+     * @param callback - Called when the escrow state changes
+     * @returns Unsubscribe function
+     */
+    onStateChange(escrowId: string, callback: EscrowStateChangeCallback): Unsubscribe;
+}
+
+/**
+ * Semantic analytics helpers for common ledger query patterns.
+ *
+ * @example
+ * ```typescript
+ * const rate = await inv.ledger.analytics.successRate('0xBot', { from: '2025-01-01' });
+ * const costs = await inv.ledger.analytics.costSummary('0xBot', { from: '2025-01-01' });
+ * ```
+ */
+
+/**
+ * Analytics layer on top of the Event Ledger.
+ */
+declare class LedgerAnalytics {
+    private readonly ledger;
+    constructor(ledger: EventLedger);
+    /**
+     * Calculate the success rate for an actor's actions.
+     *
+     * @param actor - Actor address
+     * @param timeframe - Optional time range filter
+     * @returns Success rate as a ratio and percentage
+     */
+    successRate(actor: string, timeframe?: AnalyticsTimeframe): Promise<SuccessRateResult>;
+    /**
+     * Count occurrences of a specific action for an actor.
+     *
+     * @param actor - Actor address
+     * @param action - Action name to count
+     * @param timeframe - Optional time range filter
+     * @returns Count and breakdown by category
+     */
+    actionCount(actor: string, action: string, timeframe?: AnalyticsTimeframe): Promise<ActionCountResult>;
+    /**
+     * Summarize costs/spending for an actor.
+     *
+     * @param actor - Actor address
+     * @param timeframe - Optional time range filter
+     * @returns Cost breakdown by action
+     */
+    costSummary(actor: string, timeframe?: AnalyticsTimeframe): Promise<CostSummaryResult>;
+    /**
+     * Query policy violations for an actor.
+     *
+     * @param actor - Actor address
+     * @param timeframe - Optional time range filter
+     * @returns List of violations with details
+     */
+    violations(actor: string, timeframe?: AnalyticsTimeframe): Promise<ViolationResult>;
+}
+
+/**
+ * Immutable on-chain logging with dual signatures.
+ *
+ * The Event Ledger is the single source of truth for all Invariance actions.
+ * Every intent, every escrow state change, every policy evaluation is logged
+ * here with dual signatures. This is a Truth Ledger that produces identical
+ * proof records regardless of actor type.
+ *
+ * @example
+ * ```typescript
+ * const entry = await inv.ledger.log({
+ *   action: 'model-inference',
+ *   actor: { type: 'agent', address: '0xMyAgent' },
+ *   metadata: { model: 'claude-sonnet', latencyMs: 230 },
+ * });
+ * console.log(entry.explorerUrl);
+ * ```
+ */
+declare class EventLedger {
+    private readonly contracts;
+    private readonly events;
+    private readonly telemetry;
+    private indexer;
+    private _analytics?;
+    constructor(contracts: ContractFactory, events: InvarianceEventEmitter, telemetry: Telemetry);
+    /**
+     * Analytics helpers for common ledger query patterns.
+     *
+     * @example
+     * ```typescript
+     * const rate = await inv.ledger.analytics.successRate('0xBot');
+     * ```
+     */
+    get analytics(): LedgerAnalytics;
+    /** Lazily initialize the indexer client */
+    private getIndexer;
+    /** Get the contract address for the ledger module */
+    getContractAddress(): string;
+    /**
+     * Log a custom event on-chain.
+     *
+     * Creates an immutable ledger entry with dual signatures (actor + platform),
+     * metadata hash, and a public explorer URL.
+     *
+     * @param event - The event to log
+     * @returns The created ledger entry with proof bundle
+     */
+    log(event: LedgerEventInput): Promise<LedgerEntry>;
+    /**
+     * Log multiple events in a single transaction.
+     *
+     * More gas-efficient than individual log() calls when
+     * logging multiple related events.
+     *
+     * @param events - Array of events to log
+     * @returns Array of created ledger entries
+     */
+    batch(events: LedgerEventInput[]): Promise<LedgerEntry[]>;
+    /**
+     * Query ledger entries by identity, action, or time range.
+     *
+     * @param filters - Query filters (actor, action, category, time range)
+     * @returns Array of matching ledger entries
+     */
+    query(filters: LedgerQueryFilters): Promise<LedgerEntry[]>;
+    /**
+     * Stream ledger entries in real-time.
+     *
+     * Subscribes to new ledger entries matching the given filters
+     * and invokes the callback for each new entry.
+     *
+     * @param filters - Optional filters for the stream
+     * @param callback - Called for each new matching entry
+     * @returns Unsubscribe function
+     */
+    stream(filters: LedgerQueryFilters, callback: LedgerStreamCallback): Unsubscribe;
+    /**
+     * Export ledger entries as JSON or CSV.
+     *
+     * @param filters - Query filters to select entries for export
+     * @returns Exported data in the requested format
+     */
+    export(filters: LedgerQueryFilters): Promise<ExportData>;
+}
+
+/**
+ * Fraud-proof on-chain logging via CompactLedger with EIP-712 dual signatures.
+ *
+ * Unlike the legacy {@link EventLedger}, this module calls `CompactLedger.log(input, actorSig, platformSig)`
+ * where both signatures are verified on-chain via `ECDSA.recover`. This means:
+ * - Actor signature uses EIP-712 `signTypedData` (not `signMessage`)
+ * - Platform signature comes from `/v1/attest` API (API key required)
+ * - The keccak256 fallback is NOT valid — it will revert on-chain
+ *
+ * @example
+ * ```typescript
+ * // Requires API key for platform attestation
+ * const inv = new Invariance({
+ *   chain: 'base-sepolia',
+ *   signer: wallet,
+ *   apiKey: 'inv_live_xxx',
+ * });
+ *
+ * const entry = await inv.ledgerCompact.log({
+ *   action: 'model-inference',
+ *   actor: { type: 'agent', address: '0xMyAgent' },
+ *   metadata: { model: 'claude-sonnet', latencyMs: 230 },
+ * });
+ * ```
+ */
+declare class EventLedgerCompact {
+    private readonly contracts;
+    private readonly events;
+    private readonly telemetry;
+    constructor(contracts: ContractFactory, events: InvarianceEventEmitter, telemetry: Telemetry);
+    /** Get the contract address for the compact ledger module */
+    getContractAddress(): string;
+    /**
+     * Log a fraud-proof event on-chain via CompactLedger.
+     *
+     * Creates an immutable ledger entry with EIP-712 dual signatures (actor + platform)
+     * that are verified on-chain. Requires an API key for platform attestation.
+     *
+     * @param event - The event to log
+     * @returns The created ledger entry with proof bundle
+     * @throws {InvarianceError} If no API key is configured
+     */
+    log(event: LedgerEventInput): Promise<LedgerEntry>;
+}
+
+/**
+ * Auto-batching wrapper around CompactLedger that buffers `log()` calls
+ * and flushes them as a single `logBatch()` transaction.
+ *
+ * @example
+ * ```typescript
+ * const batched = inv.ledgerCompactBatched({ maxBatchSize: 10, maxWaitMs: 5000 });
+ * // These 10 calls produce 1 on-chain transaction:
+ * await Promise.all(Array.from({ length: 10 }, (_, i) =>
+ *   batched.log({ action: `action-${i}`, actor: { type: 'agent', address: '0x...' } })
+ * ));
+ * ```
+ */
+declare class AutoBatchedEventLedgerCompact {
+    private readonly contracts;
+    private readonly events;
+    private readonly telemetry;
+    private readonly maxBatchSize;
+    private readonly maxWaitMs;
+    private readonly enabled;
+    private buffer;
+    private timer;
+    private destroyed;
+    private flushing;
+    constructor(contracts: ContractFactory, events: InvarianceEventEmitter, telemetry: Telemetry, config?: AutoBatchConfig);
+    /**
+     * Log an event. If batching is enabled, the call is buffered and resolved
+     * when the batch is flushed. If disabled, delegates directly to the single-entry path.
+     */
+    log(event: LedgerEventInput): Promise<LedgerEntry>;
+    /** Manually flush all buffered entries immediately */
+    flush(): Promise<void>;
+    /** Flush remaining buffer and prevent future calls */
+    destroy(): Promise<void>;
+    /** Get the current number of buffered entries */
+    getBufferSize(): number;
+    private _prepare;
+    private _scheduleFlush;
+    private _clearTimer;
+    private _flush;
+    /** Bypass batching — direct single-entry log */
+    private _logSingle;
+}
+
+/** Decoded proof data */
+interface ProofData {
+    proofHash: string;
+    actor: _invariance_common.ActorReference;
+    action: string;
+    timestamp: number;
+    blockNumber: number;
+    signatures: {
+        actor: string;
+        platform?: string;
+        valid: boolean;
+    };
+    metadataHash: string;
+    raw: string;
+    verified: boolean;
+}
+/** Options for verifying by actor and action */
+interface VerifyActionOptions {
+    actor: string;
+    action?: string;
+    from?: string | number;
+    to?: string | number;
+}
+
+/**
+ * Cryptographic verification and public explorer URLs.
+ *
+ * Verification is the public-facing proof layer. Any person, any system,
+ * anywhere in the world can verify any Invariance action using a transaction
+ * hash, an identity address, or a public explorer URL.
+ *
+ * The Verifier is special: it is both callable directly as `inv.verify(txHash)`
+ * and has sub-methods like `inv.verify.action()`, `inv.verify.identity()`, etc.
+ *
+ * @example
+ * ```typescript
+ * // Direct call
+ * const result = await inv.verify('0xtxhash...');
+ *
+ * // Sub-methods
+ * const audit = await inv.verify.identity('0xTradingBot');
+ * const url = inv.verify.url('inv_int_abc123');
+ * ```
+ */
+declare class Verifier {
+    private readonly contracts;
+    private readonly telemetry;
+    private indexer;
+    constructor(contracts: ContractFactory, _events: InvarianceEventEmitter, telemetry: Telemetry);
+    /** Lazily initialize the indexer client */
+    private getIndexer;
+    /**
+     * Verify a single transaction by hash.
+     *
+     * Retrieves the on-chain proof, validates signatures, and returns
+     * the full verification result with an explorer URL.
+     *
+     * @param txHash - The transaction hash to verify
+     * @returns Verification result with proof and explorer URL
+     */
+    verify(txHash: string): Promise<VerificationResult>;
+    /**
+     * Verify by actor address and optionally action type and timeframe.
+     *
+     * @param opts - Verification options (actor, action, time range)
+     * @returns Verification result for the matching action
+     */
+    action(opts: VerifyActionOptions): Promise<VerificationResult>;
+    /**
+     * Full audit of an identity.
+     *
+     * Returns comprehensive verification data including total actions,
+     * verified count, policy history, attestations, and volume.
+     *
+     * @param address - The identity address to audit
+     * @returns Full identity verification audit
+     */
+    identity(address: string): Promise<IdentityVerification>;
+    /**
+     * Escrow audit trail.
+     *
+     * Returns the complete timeline of an escrow from creation to
+     * final state, with proof bundles for each state transition.
+     *
+     * @param escrowId - The escrow to audit
+     * @returns Escrow verification with full timeline
+     */
+    escrow(escrowId: string): Promise<EscrowVerification>;
+    /**
+     * Decode and validate a proof by its hash.
+     *
+     * @param proofHash - The proof hash to decode
+     * @returns Decoded proof data with validation status
+     */
+    proof(proofHash: string): Promise<ProofData>;
+    /**
+     * Batch verify multiple transactions.
+     *
+     * More efficient than calling verify() in a loop when verifying
+     * multiple transactions simultaneously.
+     *
+     * @param txHashes - Array of transaction hashes to verify
+     * @returns Array of verification results (one per hash)
+     */
+    bulk(txHashes: string[]): Promise<VerificationResult[]>;
+    /**
+     * Verify a CompactLedger commitment hash on-chain.
+     *
+     * Reads the stored commitment from the CompactLedger contract and
+     * optionally reconstructs the expected commitment to compare.
+     *
+     * @param entryId - The entry ID to verify
+     * @param expected - Optional expected values to reconstruct and compare commitment
+     * @returns Whether the commitment exists and matches
+     */
+    verifyCommitment(entryId: string, expected?: {
+        actorAddress: string;
+        action: string;
+        metadataHash: string;
+        proofHash: string;
+        timestamp: number;
+    }): Promise<{
+        exists: boolean;
+        matches: boolean;
+        commitmentHash: string;
+    }>;
+    /**
+     * Generate a public explorer URL for an intent.
+     *
+     * This URL can be shared publicly. Anyone can open it to
+     * independently verify the action without needing the SDK.
+     *
+     * @param intentId - The intent ID to generate a URL for
+     * @returns The public explorer URL
+     */
+    url(intentId: string): string;
+    /**
+     * Verify a vote's merkle inclusion in a settled proposal.
+     *
+     * @param proposalId - The proposal ID
+     * @param voter - Voter address
+     * @param support - Vote direction (true = for)
+     * @param weight - Vote weight
+     * @param proof - Merkle proof
+     * @returns Whether the vote is included in the settled merkle root
+     */
+    verifyVote(proposalId: string, voter: string, support: boolean, weight: bigint, proof: string[]): Promise<boolean>;
+}
+
+/**
+ * Single-transaction atomic verifier: identity check + policy eval + compact ledger log.
+ *
+ * Wraps `AtomicVerifier.verifyAndLog()` with the same EIP-712 signing flow
+ * as {@link EventLedgerCompact}. Requires an API key for platform attestation.
+ *
+ * @example
+ * ```typescript
+ * const entry = await inv.atomic.verifyAndLog({
+ *   action: 'swap',
+ *   actor: { type: 'agent', address: '0xBot' },
+ *   metadata: { from: 'USDC', to: 'ETH', amount: '100' },
+ * });
+ * ```
+ */
+declare class AtomicVerifier {
+    private readonly contracts;
+    private readonly events;
+    private readonly telemetry;
+    constructor(contracts: ContractFactory, events: InvarianceEventEmitter, telemetry: Telemetry);
+    /** Get the contract address for the atomic verifier */
+    getContractAddress(): string;
+    /**
+     * Verify identity + evaluate policy + log to CompactLedger in a single transaction.
+     *
+     * @param event - The event to verify and log
+     * @returns The created ledger entry with proof bundle
+     * @throws {InvarianceError} If no API key is configured
+     */
+    verifyAndLog(event: LedgerEventInput): Promise<LedgerEntry>;
+}
+
+/** Options for querying reviews */
+interface ReviewQueryOptions {
+    limit?: number;
+    offset?: number;
+    sortBy?: 'newest' | 'highest' | 'lowest';
+}
+/** Paginated review list */
+interface ReviewList {
+    reviews: _invariance_common.Review[];
+    total: number;
+    page: number;
+}
+/** Options for querying score history */
+interface ScoreHistoryOptions {
+    from?: string | number;
+    to?: string | number;
+    limit?: number;
+}
+
+/**
+ * Auto-calculated reputation scores and 1-5 star reviews.
+ *
+ * Reputation applies to all identity types. The scoring model is identical.
+ * Reviews are 1-5 stars, cryptographically linked to completed escrows.
+ * No escrow = no review. Fake reviews are mathematically impossible.
+ *
+ * @example
+ * ```typescript
+ * const rep = await inv.reputation.get('0xTradingBot');
+ * console.log(rep.scores.overall, rep.scores.tier);
+ *
+ * const review = await inv.reputation.review({
+ *   target: '0xTradingBot',
+ *   escrowId: 'esc_abc',
+ *   rating: 5,
+ *   comment: 'Excellent execution',
+ * });
+ * ```
+ */
+declare class ReputationEngine {
+    private readonly contracts;
+    private readonly events;
+    private readonly telemetry;
+    private indexer;
+    constructor(contracts: ContractFactory, events: InvarianceEventEmitter, telemetry: Telemetry);
+    /** Lazily initialize the indexer client */
+    private getIndexer;
+    /** Calculate on-chain metrics for an identity */
+    private calculateOnChainMetrics;
+    /** Calculate overall reputation score */
+    private calculateOverallScore;
+    /** Determine tier from overall score */
+    private determineTier;
+    /** Get the contract address for the review module */
+    getContractAddress(): string;
+    /**
+     * Get full reputation profile for any identity.
+     *
+     * Includes scores, reviews, on-chain metrics, badges, and explorer URL.
+     *
+     * @param address - The identity address
+     * @returns Full reputation profile
+     */
+    get(address: string): Promise<ReputationProfile>;
+    /**
+     * Submit a 1-5 star review.
+     *
+     * Reviews MUST reference a completed escrow between the reviewer
+     * and the target. This is enforced on-chain. No escrow = no review.
+     *
+     * @param opts - Review options (target, escrowId, rating)
+     * @returns The submitted review
+     * @throws {InvarianceError} With NO_ESCROW_FOR_REVIEW if no qualifying escrow
+     * @throws {InvarianceError} With ALREADY_REVIEWED if already reviewed
+     */
+    review(opts: SubmitReviewOptions): Promise<Review>;
+    /**
+     * Get all reviews for an identity.
+     *
+     * @param address - The identity address
+     * @param opts - Optional query options (pagination, sorting)
+     * @returns Paginated review list
+     */
+    getReviews(address: string, opts?: ReviewQueryOptions): Promise<ReviewList>;
+    /**
+     * Get numeric reputation scores only (lighter than full profile).
+     *
+     * @param address - The identity address
+     * @returns Reputation scores
+     */
+    score(address: string): Promise<ReputationScore>;
+    /**
+     * Compare multiple identities side-by-side.
+     *
+     * Returns ranked comparison with key metrics for each identity.
+     *
+     * @param addresses - Array of identity addresses to compare
+     * @returns Comparison result with rankings
+     */
+    compare(addresses: string[]): Promise<ComparisonResult>;
+    /**
+     * Get earned badge for an identity.
+     *
+     * Badges are auto-calculated based on on-chain metrics:
+     * - Verified: Has attestations
+     * - Trusted: 50+ verified actions
+     * - Elite: 95%+ policy compliance with 100+ actions
+     *
+     * @param address - The identity address
+     * @returns Badge or null if none earned
+     */
+    badge(address: string): Promise<Badge | null>;
+    /**
+     * Get score changes over time.
+     *
+     * @param address - The identity address
+     * @param opts - Optional query options (time range, limit)
+     * @returns Score history with entries
+     */
+    history(address: string, opts?: ScoreHistoryOptions): Promise<ScoreHistory>;
+}
+
+/**
+ * Re-exports and module-specific types for the Gas module.
+ */
+
+/** Options for gas estimation */
+interface EstimateGasOptions {
+    action: string;
+    params?: Record<string, unknown>;
+    target?: string;
+}
+
+/**
+ * Gas abstraction for Invariance operations.
+ *
+ * Provides gas estimation and balance checking with support for
+ * USDC-based gas abstraction (where users pay gas fees in USDC
+ * instead of ETH).
+ *
+ * @example
+ * ```typescript
+ * const estimate = await inv.gas.estimate({ action: 'swap' });
+ * console.log(estimate.usdcCost);
+ *
+ * const balance = await inv.gas.balance();
+ * console.log(balance.canAbstract);
+ * ```
+ */
+declare class GasManager {
+    private readonly contracts;
+    private readonly telemetry;
+    constructor(contracts: ContractFactory, _events: InvarianceEventEmitter, telemetry: Telemetry);
+    /**
+     * Estimate gas cost for an action.
+     *
+     * Returns both ETH and USDC costs based on the current gas strategy.
+     *
+     * @param opts - Action details for gas estimation
+     * @returns Gas estimate with ETH and USDC costs
+     */
+    estimate(opts: EstimateGasOptions): Promise<GasEstimate>;
+    /**
+     * Sponsor a user operation via Coinbase Paymaster on Base.
+     *
+     * Sends the user operation to the paymaster endpoint for gas sponsorship.
+     * Requires `PAYMASTER_URL` and `PAYMASTER_API_KEY` environment variables.
+     *
+     * @param userOp - The user operation to sponsor
+     * @returns The sponsored user operation with paymaster fields filled in
+     */
+    sponsorUserOperation(userOp: {
+        sender: string;
+        nonce: string;
+        callData: string;
+        callGasLimit: string;
+        verificationGasLimit: string;
+        preVerificationGas: string;
+        maxFeePerGas: string;
+        maxPriorityFeePerGas: string;
+    }): Promise<{
+        paymasterAndData: string;
+        callGasLimit: string;
+        verificationGasLimit: string;
+        preVerificationGas: string;
+    }>;
+    /**
+     * Get gas-related balances for the current wallet.
+     *
+     * Returns ETH and USDC balances and whether gas abstraction
+     * is available (requires sufficient USDC and abstracted strategy).
+     *
+     * @returns Gas balance information
+     */
+    balance(): Promise<GasBalance>;
+}
+
+/**
+ * Types for the x402 payment protocol module.
+ */
+/** Options for paying for an action via x402 */
+interface PayForActionOptions {
+    /** The action being paid for */
+    action: string;
+    /** Payment amount in USDC (decimal string, e.g. '1.50') */
+    amount: string;
+    /** Payment recipient address */
+    recipient: string;
+    /** Identity ID of the payer */
+    identityId?: string;
+    /** x402 facilitator URL */
+    facilitatorUrl?: string;
+    /** Additional metadata to attach to the payment */
+    metadata?: Record<string, unknown>;
+}
+/** Receipt returned after a successful payment */
+interface PaymentReceipt {
+    /** Unique payment identifier */
+    paymentId: string;
+    /** Backwards-compatible alias for payloadHash (not an on-chain tx hash) */
+    txHash?: string;
+    /** Hash of the payment payload (not an on-chain tx hash) */
+    payloadHash: string;
+    /** Payment amount in USDC */
+    amount: string;
+    /** Recipient address */
+    recipient: string;
+    /** Payer address */
+    payer: string;
+    /** The action this payment is for */
+    action: string;
+    /** Unix timestamp of payment */
+    timestamp: number;
+    /** Cryptographic proof of payment */
+    proof: string;
+}
+/** Result of verifying a payment */
+interface PaymentVerification {
+    /** Whether the payment is valid */
+    valid: boolean;
+    /** The verified receipt */
+    receipt?: PaymentReceipt;
+    /** Reason for failure, if invalid */
+    reason?: string;
+}
+/** Filters for querying payment history */
+interface PaymentHistoryFilters {
+    /** Filter by action type */
+    action?: string;
+    /** Start of time range (unix timestamp or ISO string) */
+    from?: string | number;
+    /** End of time range (unix timestamp or ISO string) */
+    to?: string | number;
+    /** Maximum number of results */
+    limit?: number;
+    /** Offset for pagination */
+    offset?: number;
+}
+/** Estimated cost for an action */
+interface PaymentEstimate {
+    /** Estimated USDC cost */
+    amount: string;
+    /** The action being estimated */
+    action: string;
+    /** Whether a payment is required for this action */
+    required: boolean;
+    /** Breakdown of cost components */
+    breakdown?: {
+        baseCost: string;
+        gasCost: string;
+        facilitatorFee: string;
+    };
+}
+/** x402 module configuration */
+interface X402Settings {
+    /** Default facilitator URL for x402 payments */
+    facilitatorUrl?: string;
+    /** Default payment recipient address */
+    defaultRecipient?: string;
+    /** Maximum auto-approve amount in USDC (payments above this require explicit approval) */
+    maxAutoApprove?: string;
+    /** USDC token address override (defaults to chain-specific address) */
+    usdcAddress?: string;
+    /** Whether to use Permit2 transfer method (default: false, uses EIP-3009) */
+    usePermit2?: boolean;
+}
+
+/**
+ * Manages x402 payment protocol operations.
+ *
+ * Provides pay-per-action execution, payment verification, and
+ * agent-to-agent payments using the x402 HTTP payment standard.
+ * Payments are made in USDC on Base.
+ *
+ * @example
+ * ```typescript
+ * // Pay for an action
+ * const receipt = await inv.x402.payForAction({
+ *   action: 'swap',
+ *   amount: '1.00',
+ *   recipient: '0xServiceProvider',
+ * });
+ *
+ * // Verify a payment
+ * const verification = await inv.x402.verifyPayment(receipt.paymentId);
+ *
+ * // Query payment history
+ * const history = await inv.x402.history('agent-identity-id');
+ * ```
+ */
+declare class X402Manager {
+    private readonly contracts;
+    private readonly events;
+    private readonly telemetry;
+    private paymentClient;
+    private indexer;
+    private receipts;
+    private static readonly MAX_RECEIPTS;
+    constructor(contracts: ContractFactory, events: InvarianceEventEmitter, telemetry: Telemetry);
+    /** Lazily initialize the payment client */
+    private getPaymentClient;
+    /** Lazily initialize the indexer client */
+    private getIndexer;
+    /**
+     * Pay for an action via the x402 protocol.
+     *
+     * Creates a USDC payment authorization and returns a receipt
+     * that can be attached to intent requests for policy verification.
+     *
+     * @param opts - Payment options including action, amount, and recipient
+     * @returns Payment receipt with proof
+     */
+    payForAction(opts: PayForActionOptions): Promise<PaymentReceipt>;
+    /**
+     * Verify a payment by receipt ID.
+     *
+     * Checks that the payment proof is valid and the amount
+     * meets requirements.
+     *
+     * @param receiptId - The payment receipt ID to verify
+     * @returns Verification result
+     */
+    verifyPayment(receiptId: string): Promise<PaymentVerification>;
+    /**
+     * Query payment history for an identity.
+     *
+     * @param identityId - The identity to query payments for
+     * @param filters - Optional filters for action, time range, pagination
+     * @returns Array of payment receipts
+     */
+    history(identityId: string, filters?: PaymentHistoryFilters): Promise<PaymentReceipt[]>;
+    /**
+     * Estimate the cost for an action.
+     *
+     * @param opts - Estimation options
+     * @returns Cost estimate
+     */
+    estimateCost(opts: {
+        action: string;
+        recipient?: string;
+    }): Promise<PaymentEstimate>;
+    /**
+     * Configure x402 module settings.
+     *
+     * @param settings - Configuration options
+     */
+    configure(settings: X402Settings): Promise<void>;
+}
+
+/**
+ * ERC-8004 (Trustless Agents) types.
+ *
+ * Self-contained type definitions for the ERC-8004 module.
+ * Standalone types have NO imports from Invariance common types.
+ * Bridge types (at the bottom) import from Invariance where needed.
+ */
+/** Registry contract addresses for an ERC-8004 deployment */
+interface ERC8004RegistryAddresses {
+    identity: `0x${string}`;
+    reputation: `0x${string}`;
+    validation: `0x${string}`;
+}
+/** Configuration for an ERC8004Manager instance */
+interface ERC8004Config {
+    /** Chain ID of the target network */
+    chainId: number;
+    /** viem PublicClient for read operations */
+    publicClient: unknown;
+    /** Optional viem WalletClient for write operations */
+    walletClient?: unknown;
+    /** Override default registry addresses (for custom deployments) */
+    registryAddresses?: ERC8004RegistryAddresses;
+}
+/** A single metadata key-value pair stored on an agent identity */
+interface ERC8004Metadata {
+    key: string;
+    value: string;
+}
+/** An agent identity registered in the ERC-8004 Identity Registry */
+interface ERC8004AgentIdentity {
+    /** On-chain agent ID (token ID) */
+    agentId: bigint;
+    /** Agent URI (off-chain metadata pointer) */
+    agentURI: string;
+    /** Wallet address authorized to act on behalf of the agent */
+    wallet: `0x${string}`;
+    /** Cross-chain global identifier: eip155:{chainId}:{registryAddress} */
+    globalId: string;
+    /** Metadata entries associated with the agent */
+    metadata: ERC8004Metadata[];
+}
+/** Options for the giveFeedback() call */
+interface GiveFeedbackOptions {
+    /** Agent ID to give feedback on */
+    agentId: bigint;
+    /** Feedback value (contract-specific scale) */
+    value: number;
+    /** First feedback tag */
+    tag1: string;
+    /** Optional second feedback tag */
+    tag2?: string;
+    /** Optional feedback URI (off-chain details) */
+    feedbackURI?: string;
+}
+/** A single feedback entry from the ERC-8004 Reputation Registry */
+interface ERC8004Feedback {
+    /** Address of the client who gave the feedback */
+    client: `0x${string}`;
+    /** Feedback value */
+    value: number;
+    /** First feedback tag */
+    tag1: string;
+    /** Second feedback tag */
+    tag2: string;
+    /** Feedback URI */
+    feedbackURI: string;
+    /** Block timestamp */
+    timestamp: number;
+}
+/** Aggregated reputation summary for an agent */
+interface ERC8004ReputationSummary {
+    /** Total number of feedback entries */
+    count: number;
+    /** Summary value from the contract */
+    summaryValue: number;
+    /** Decimal precision of the summary value */
+    decimals: number;
+}
+/** Filter options for reputation summary queries */
+interface ReputationSummaryFilterOptions {
+    /** Filter by tag */
+    tag?: string;
+    /** Lookback period in milliseconds from now */
+    lookbackMs?: number;
+}
+/** Options for requesting a validation */
+interface ValidationRequestOptions {
+    /** Agent ID to validate */
+    agentId: bigint;
+    /** Validator address */
+    validator: `0x${string}`;
+    /** Validation request URI (details about what to validate) */
+    requestURI: string;
+}
+/** Options for responding to a validation request */
+interface ValidationResponseOptions {
+    /** Hash of the validation request */
+    requestHash: `0x${string}`;
+    /** Response value (0 = invalid, 1 = valid, etc.) */
+    response: number;
+    /** Optional response URI (off-chain proof) */
+    responseURI?: string;
+}
+/** Full validation status for a request */
+interface ERC8004ValidationStatus {
+    /** The request hash */
+    requestHash: `0x${string}`;
+    /** Agent ID being validated */
+    agentId: bigint;
+    /** Validator address */
+    validator: `0x${string}`;
+    /** Request URI */
+    requestURI: string;
+    /** Response value (0 if not yet responded) */
+    response: number;
+    /** Response URI */
+    responseURI: string;
+    /** Whether the validation is complete */
+    completed: boolean;
+}
+/** Aggregated validation summary for an agent */
+interface ERC8004ValidationSummary {
+    /** Total number of validation requests */
+    count: number;
+    /** Average response value */
+    avgResponse: number;
+}
+/** Filter options for validation summary queries */
+interface ValidationSummaryFilterOptions {
+    /** Filter by validator address */
+    validator?: `0x${string}`;
+    /** Lookback period in milliseconds from now */
+    lookbackMs?: number;
+}
+/** A linked identity pairing between Invariance and ERC-8004 */
+interface LinkedIdentity {
+    /** Invariance identity ID */
+    invarianceIdentityId: string;
+    /** ERC-8004 agent ID */
+    erc8004AgentId: string;
+    /** ERC-8004 global ID */
+    erc8004GlobalId: string;
+    /** Timestamp when linked */
+    linkedAt: number;
+    /** Transaction hash of the linking operation */
+    txHash: string;
+}
+/** External reputation signal pulled from ERC-8004 */
+interface ExternalReputationSignal {
+    /** Source protocol */
+    source: 'erc8004';
+    /** Total feedback count */
+    feedbackCount: number;
+    /** Average feedback value */
+    averageValue: number;
+    /** Normalized score (0-100) */
+    normalizedScore: number;
+}
+/** Options for pushing Invariance ledger data as ERC-8004 feedback */
+interface PushFeedbackOptions {
+    /** First feedback tag */
+    tag1: string;
+    /** Optional second feedback tag */
+    tag2?: string;
+    /** Lookback period in milliseconds to query ledger entries */
+    lookbackMs?: number;
+    /** Optional feedback URI */
+    feedbackURI?: string;
+}
+
+/**
+ * Standalone ERC-8004 (Trustless Agents) manager.
+ *
+ * NO dependency on ContractFactory, EventEmitter, or Telemetry.
+ * Takes raw viem PublicClient + optional WalletClient directly.
+ * Can be used without any Invariance infrastructure.
+ *
+ * @example
+ * ```typescript
+ * import { createPublicClient, http } from 'viem';
+ * import { base } from 'viem/chains';
+ * import { ERC8004Manager } from '@invariance/sdk';
+ *
+ * const publicClient = createPublicClient({ chain: base, transport: http() });
+ * const manager = new ERC8004Manager({ chainId: 8453, publicClient });
+ *
+ * const agent = await manager.getAgent(1n);
+ * const summary = await manager.getSummary(1n);
+ * ```
+ */
+
+/** Transaction receipt returned by write methods */
+interface TxReceipt$1 {
+    txHash: string;
+    blockNumber: number;
+    status: 'success' | 'reverted';
+}
+declare class ERC8004Manager {
+    private readonly chainId;
+    private readonly publicClient;
+    private readonly walletClient;
+    private readonly registryAddresses;
+    private readonly identityContract;
+    private readonly reputationContract;
+    private readonly validationContract;
+    constructor(config: ERC8004Config);
+    /**
+     * Register a new agent identity in the ERC-8004 Identity Registry.
+     *
+     * @param agentURI - Off-chain metadata URI for the agent
+     * @param metadata - Optional initial metadata key-value pairs
+     * @returns The registered agent identity
+     */
+    register(agentURI: string, metadata?: ERC8004Metadata[]): Promise<ERC8004AgentIdentity>;
+    /**
+     * Get an agent identity by ID.
+     *
+     * @param agentId - The on-chain agent ID
+     * @returns The agent identity
+     */
+    getAgent(agentId: bigint): Promise<ERC8004AgentIdentity>;
+    /**
+     * Set a metadata value on an agent identity.
+     *
+     * @param agentId - The agent ID
+     * @param key - Metadata key
+     * @param value - Metadata value
+     * @returns Transaction receipt
+     */
+    setMetadata(agentId: bigint, key: string, value: string): Promise<TxReceipt$1>;
+    /**
+     * Get a metadata value from an agent identity.
+     *
+     * @param agentId - The agent ID
+     * @param key - Metadata key
+     * @returns The metadata value
+     */
+    getMetadata(agentId: bigint, key: string): Promise<string>;
+    /**
+     * Set the wallet address for an agent (with signature authorization).
+     *
+     * @param agentId - The agent ID
+     * @param newWallet - New wallet address
+     * @param deadline - Signature deadline timestamp
+     * @param signature - Authorization signature
+     * @returns Transaction receipt
+     */
+    setAgentWallet(agentId: bigint, newWallet: `0x${string}`, deadline: bigint, signature: `0x${string}`): Promise<TxReceipt$1>;
+    /**
+     * Set the agent URI.
+     *
+     * @param agentId - The agent ID
+     * @param newURI - New agent URI
+     * @returns Transaction receipt
+     */
+    setAgentURI(agentId: bigint, newURI: string): Promise<TxReceipt$1>;
+    /**
+     * Compute the cross-chain global ID for an agent.
+     *
+     * @param agentId - The on-chain agent ID
+     * @returns The global ID string: eip155:{chainId}:{registryAddress}:{agentId}
+     */
+    getGlobalId(agentId: bigint): string;
+    /**
+     * Give feedback on an agent.
+     *
+     * @param opts - Feedback options
+     * @returns Transaction receipt
+     */
+    giveFeedback(opts: GiveFeedbackOptions): Promise<TxReceipt$1>;
+    /**
+     * Revoke previously given feedback.
+     *
+     * @param agentId - The agent ID
+     * @param feedbackIndex - Index of the feedback to revoke
+     * @returns Transaction receipt
+     */
+    revokeFeedback(agentId: bigint, feedbackIndex: bigint): Promise<TxReceipt$1>;
+    /**
+     * Get reputation summary for an agent.
+     *
+     * @param agentId - The agent ID
+     * @param _opts - Optional filter options (reserved for future use)
+     * @returns Reputation summary
+     */
+    getSummary(agentId: bigint, _opts?: ReputationSummaryFilterOptions): Promise<ERC8004ReputationSummary>;
+    /**
+     * Read a single feedback entry.
+     *
+     * @param agentId - The agent ID
+     * @param client - The client address who gave the feedback
+     * @param index - Feedback index for this client
+     * @returns The feedback entry
+     */
+    readFeedback(agentId: bigint, client: `0x${string}`, index: bigint): Promise<ERC8004Feedback>;
+    /**
+     * Read all feedback entries for an agent.
+     *
+     * @param agentId - The agent ID
+     * @returns All feedback entries
+     */
+    readAllFeedback(agentId: bigint): Promise<ERC8004Feedback[]>;
+    /**
+     * Submit a validation request for an agent.
+     *
+     * @param opts - Validation request options
+     * @returns Transaction receipt
+     */
+    requestValidation(opts: ValidationRequestOptions): Promise<TxReceipt$1>;
+    /**
+     * Respond to a validation request.
+     *
+     * @param opts - Validation response options
+     * @returns Transaction receipt
+     */
+    respondToValidation(opts: ValidationResponseOptions): Promise<TxReceipt$1>;
+    /**
+     * Get the status of a validation request.
+     *
+     * @param requestHash - The validation request hash
+     * @returns Validation status
+     */
+    getValidationStatus(requestHash: `0x${string}`): Promise<ERC8004ValidationStatus>;
+    /**
+     * Get validation summary for an agent.
+     *
+     * @param agentId - The agent ID
+     * @param _opts - Optional filter options (reserved for future use)
+     * @returns Validation summary
+     */
+    getValidationSummary(agentId: bigint, _opts?: ValidationSummaryFilterOptions): Promise<ERC8004ValidationSummary>;
+    /** Get a read function from a contract, throwing if not found */
+    private getReadFn;
+    /** Get a write function from a contract, throwing if not found */
+    private getWriteFn;
+    /** Ensure walletClient is available for write operations */
+    private requireWalletClient;
+    /** Compute the global ID for an agent */
+    private computeGlobalId;
+    /** Wait for a transaction receipt and return a simplified result */
+    private waitForTxReceipt;
+    /** Parse agent ID from registration event logs */
+    private parseAgentIdFromLogs;
+}
+/**
+ * Error class for ERC-8004 operations.
+ * Standalone — does not extend InvarianceError.
+ */
+declare class ERC8004Error extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+
+/**
+ * Optional bridge between ERC-8004 and Invariance modules.
+ *
+ * Takes an ERC8004Manager instance + Invariance module references.
+ * Explicitly constructed — never automatic.
+ *
+ * @example
+ * ```typescript
+ * const inv = new Invariance({ chain: 'base', signer: wallet });
+ * const bridge = inv.erc8004Bridge;
+ *
+ * // Link identities
+ * const linked = await bridge.linkIdentity('inv-id-123', 42n);
+ *
+ * // Pull external reputation
+ * const signal = await bridge.pullERC8004Reputation(42n);
+ * ```
+ */
+
+/** Transaction receipt returned by bridge write methods */
+interface TxReceipt {
+    txHash: string;
+    blockNumber: number;
+    status: 'success' | 'reverted';
+}
+declare class InvarianceBridge {
+    private readonly erc8004;
+    private readonly identity;
+    private readonly ledger;
+    private readonly contracts;
+    private readonly events;
+    private readonly telemetry;
+    /** In-memory cache of linked identities */
+    private linkedIdentities;
+    private static readonly MAX_LINKED_IDENTITIES;
+    constructor(erc8004: ERC8004Manager, identity: IdentityManager, ledger: EventLedger, contracts: ContractFactory, events: InvarianceEventEmitter, telemetry: Telemetry);
+    /**
+     * Link an Invariance identity to an ERC-8004 agent identity.
+     *
+     * Sets `invariance-identity-id` as ERC-8004 metadata AND creates
+     * an Invariance attestation with `erc8004-agent-id` claim.
+     *
+     * @param invarianceIdentityId - Invariance identity ID
+     * @param erc8004AgentId - ERC-8004 agent ID
+     * @returns The linked identity pairing
+     */
+    linkIdentity(invarianceIdentityId: string, erc8004AgentId: bigint): Promise<LinkedIdentity>;
+    /**
+     * Get a linked identity pairing.
+     *
+     * Checks local cache first, then queries ERC-8004 metadata.
+     *
+     * @param invarianceIdentityId - Invariance identity ID
+     * @returns The linked identity or null if not linked
+     */
+    getLinkedIdentity(invarianceIdentityId: string): Promise<LinkedIdentity | null>;
+    /**
+     * Unlink an Invariance identity from its ERC-8004 agent.
+     *
+     * Removes the ERC-8004 metadata and clears the local cache.
+     *
+     * @param invarianceIdentityId - Invariance identity ID
+     */
+    unlinkIdentity(invarianceIdentityId: string): Promise<void>;
+    /**
+     * Pull ERC-8004 reputation data and normalize to a 0-100 score.
+     *
+     * Does NOT modify Invariance scoring — caller decides how to use the signal.
+     *
+     * @param erc8004AgentId - ERC-8004 agent ID
+     * @returns External reputation signal with normalized score
+     */
+    pullERC8004Reputation(erc8004AgentId: bigint): Promise<ExternalReputationSignal>;
+    /**
+     * Push Invariance ledger data as ERC-8004 feedback.
+     *
+     * Queries Invariance ledger entries for the identity, derives a
+     * feedback value (based on success rate), and calls giveFeedback()
+     * on the ERC-8004 Reputation Registry.
+     *
+     * @param invarianceIdentityId - Invariance identity ID
+     * @param erc8004AgentId - ERC-8004 agent ID to give feedback on
+     * @param opts - Feedback options (tags, lookback, URI)
+     * @returns Transaction receipt
+     */
+    pushFeedbackFromLedger(invarianceIdentityId: string, erc8004AgentId: bigint, opts: PushFeedbackOptions): Promise<TxReceipt>;
+    /**
+     * Act as a validator for an ERC-8004 agent.
+     *
+     * Reads Invariance execution logs, evaluates integrity,
+     * and submits a validation response.
+     *
+     * @param erc8004AgentId - ERC-8004 agent ID being validated
+     * @param requestHash - Hash of the validation request to respond to
+     * @returns Transaction receipt
+     */
+    actAsValidator(erc8004AgentId: bigint, requestHash: `0x${string}`): Promise<TxReceipt>;
+    /**
+     * Submit a validation request targeting Invariance as validator.
+     *
+     * @param erc8004AgentId - ERC-8004 agent ID to validate
+     * @param requestURI - URI describing what to validate
+     * @returns Transaction receipt
+     */
+    requestInvarianceValidation(erc8004AgentId: bigint, requestURI: string): Promise<TxReceipt>;
+}
+
+/** Options for updating a marketplace listing */
+interface UpdateListingOptions {
+    name?: string;
+    description?: string;
+    category?: _invariance_common.ListingCategory;
+    pricing?: _invariance_common.PricingModel;
+    capabilities?: string[];
+    tags?: string[];
+    avatar?: string;
+    apiEndpoint?: string;
+    sla?: {
+        maxResponseTime: string;
+        uptime: number;
+        refundPolicy: string;
+    };
+}
+/** Options for querying featured listings */
+interface FeaturedOptions {
+    category?: _invariance_common.ListingCategory;
+    limit?: number;
+}
+/** Options for completing a hire */
+interface CompleteHireOptions {
+    review?: Omit<_invariance_common.SubmitReviewOptions, 'target' | 'escrowId'>;
+    deliverables?: string[];
+    notes?: string;
+}
+
+/**
+ * Pre-built primitives for building verified marketplaces.
+ *
+ * The Marketplace Kit provides everything needed to build a marketplace
+ * where any identity type can list services, be discovered, hired, and
+ * reviewed. V1 focuses on AI agent marketplaces.
+ *
+ * The full flow: Register -> Search -> Hire -> Complete
+ * Hiring automatically creates an escrow + policy in one call.
+ *
+ * @example
+ * ```typescript
+ * const listing = await inv.marketplace.register({
+ *   identity: agent.identityId,
+ *   name: 'ContentGenius Pro',
+ *   description: 'AI content writer',
+ *   category: 'content',
+ *   pricing: { type: 'per-task', amount: '25.00', currency: 'USDC' },
+ *   capabilities: ['blog-posts', 'seo-optimization'],
+ * });
+ * ```
+ */
+declare class MarketplaceKit {
+    private readonly contracts;
+    private readonly events;
+    private readonly telemetry;
+    private indexer;
+    constructor(contracts: ContractFactory, events: InvarianceEventEmitter, telemetry: Telemetry);
+    /** Get the contract address for the registry module */
+    getContractAddress(): string;
+    /** Lazily initialize the indexer client */
+    private getIndexer;
+    /**
+     * Map an on-chain listing tuple to the SDK Listing type.
+     * Uses sensible defaults for reputation/reviews since the indexer provides enriched data.
+     */
+    private mapOnChainListing;
+    /**
+     * Build a metadata URI JSON string from registration/update options.
+     */
+    private buildMetadataUri;
+    /**
+     * Register an identity on the marketplace.
+     *
+     * Creates a public listing with pricing, capabilities, and SLA details.
+     * The listing is linked to the identity's on-chain reputation.
+     *
+     * @param opts - Listing registration options
+     * @returns The created listing
+     */
+    register(opts: RegisterListingOptions): Promise<Listing>;
+    /**
+     * Update listing details.
+     *
+     * @param listingId - The listing to update
+     * @param opts - Fields to update
+     * @returns The updated listing
+     */
+    update(listingId: string, opts: UpdateListingOptions): Promise<Listing>;
+    /**
+     * Deactivate a listing.
+     *
+     * The listing will no longer appear in search results but
+     * existing hires remain active until completed.
+     *
+     * @param listingId - The listing to deactivate
+     * @returns Transaction receipt
+     */
+    deactivate(listingId: string): Promise<TxReceipt$2>;
+    /**
+     * Search and filter marketplace listings.
+     *
+     * Supports text search, category filtering, rating thresholds,
+     * price ranges, and capability matching.
+     *
+     * @param query - Search query with filters
+     * @returns Paginated search results with facets
+     */
+    search(query: SearchQuery): Promise<SearchResults>;
+    /**
+     * Get a single listing with full details.
+     *
+     * @param listingId - The listing ID
+     * @returns The listing with reputation and reviews
+     */
+    get(listingId: string): Promise<Listing>;
+    /**
+     * Get top-rated listings by category.
+     *
+     * @param opts - Optional category and limit
+     * @returns Array of featured listings
+     */
+    featured(opts?: FeaturedOptions): Promise<Listing[]>;
+    /**
+     * Hire from a listing.
+     *
+     * This is a compound operation that creates an escrow, policy, and
+     * on-chain hire record in a single call. The escrow holds the payment,
+     * the policy constrains what the hired identity can do, and the hire
+     * contract records the agreement on-chain.
+     *
+     * @param opts - Hire options (listing, task, payment, policy)
+     * @returns Hire result with escrow and policy IDs
+     */
+    hire(opts: HireOptions): Promise<HireResult>;
+    /**
+     * Complete a job and optionally leave a review.
+     *
+     * Marks the hire as completed on-chain, releases the escrow,
+     * submits a review (if provided), and updates the identity's reputation.
+     *
+     * @param hireId - The hire to complete
+     * @param opts - Completion options (optional review)
+     * @returns Completion result with escrow and reputation updates
+     */
+    complete(hireId: string, opts?: CompleteHireOptions): Promise<CompletionResult>;
+    /**
+     * Get a hire agreement from the on-chain contract.
+     *
+     * @param hireId - The hire ID
+     * @returns The on-chain hire data
+     */
+    getHire(hireId: string): Promise<{
+        hireId: string;
+        listingId: string;
+        escrowId: string;
+        policyId: string;
+        hirer: string;
+        provider: string;
+        taskDescription: string;
+        status: number;
+        createdAt: number;
+        completedAt: number;
+    }>;
+}
+
+/** Options for a gated action execution. */
+interface GateActionOptions {
+    action: string;
+    actor: ActorReference;
+    category?: string;
+    metadata?: Record<string, unknown>;
+    mode?: AuditLogMode;
+    visibility?: AuditVisibility;
+    requestId?: string;
+}
+/** Result envelope for a gated action. */
+interface GateActionResult<T> {
+    result: T;
+    mode: AuditLogMode;
+    offchain?: {
+        attemptId?: string;
+        successId?: string;
+    };
+    onchainEntryId?: string;
+}
+/** Fully-resolved audit settings. */
+interface ResolvedAuditConfig extends Required<Pick<AuditConfig, 'enabled' | 'mode' | 'visibility' | 'failOpen'>> {
+    route: string;
+}
+
+declare class AuditTrail {
+    private readonly contracts;
+    private readonly events;
+    private readonly telemetry;
+    private readonly ledger;
+    private readonly config;
+    private indexer;
+    constructor(contracts: ContractFactory, events: InvarianceEventEmitter, telemetry: Telemetry, ledger: EventLedger, config?: InvarianceConfig['audit']);
+    /** Resolved audit configuration currently used by this module. */
+    getSettings(): ResolvedAuditConfig;
+    /** Log a single off-chain audit record. */
+    log(input: AuditLogInput): Promise<AuditLogRecord>;
+    /** Query off-chain audit logs. */
+    query(filters: AuditQueryFilters): Promise<{
+        data: AuditLogRecord[];
+        total: number;
+    }>;
+    /**
+     * Execute any action through a consistent SDK gate:
+     * - emits action lifecycle events
+     * - writes off-chain audit logs (default)
+     * - optionally anchors to on-chain ledger
+     */
+    gate<T>(opts: GateActionOptions, executor: () => Promise<T>): Promise<GateActionResult<T>>;
+    private getIndexer;
+    private tryOffchainLog;
+}
+
+/**
+ * Off-chain batch voting with merkle root settlement.
+ *
+ * Proposals are created on-chain for immutability. Votes are collected
+ * off-chain as EIP-712 signed messages. A single merkle root posted
+ * on-chain proves all votes (95%+ gas savings vs individual storage).
+ *
+ * @example
+ * ```typescript
+ * // Create a proposal
+ * await inv.voting.createProposal({
+ *   proposalId: 'prop-1',
+ *   identityId: 'id-1',
+ *   title: 'Upgrade to v2',
+ *   descriptionHash: '0x...',
+ *   votingPeriod: 7 * 24 * 3600,
+ *   quorum: 100n,
+ *   threshold: 5000,
+ * });
+ *
+ * // Cast votes off-chain
+ * const vote = await inv.voting.castVote({ proposalId: 'prop-1', support: true, weight: 50n });
+ *
+ * // Settle with merkle root
+ * await inv.voting.settleVotes('prop-1');
+ *
+ * // Verify any vote
+ * const proof = inv.voting.generateProof('prop-1', vote.voter);
+ * const valid = await inv.voting.verifyVote('prop-1', proof);
+ * ```
+ */
+declare class VotingManager {
+    private readonly contracts;
+    private readonly telemetry;
+    /** In-memory vote storage per proposal */
+    private readonly voteStore;
+    /** Cached merkle trees per proposal */
+    private readonly treeCache;
+    constructor(contracts: ContractFactory, _events: InvarianceEventEmitter, telemetry: Telemetry);
+    /**
+     * Create a proposal on-chain.
+     *
+     * @param opts - Proposal creation options
+     * @returns Transaction hash
+     */
+    createProposal(opts: CreateProposalOptions): Promise<string>;
+    /**
+     * Cast a vote off-chain with EIP-712 signature.
+     *
+     * The vote is signed and stored in memory. No on-chain transaction
+     * occurs until settleVotes() is called.
+     *
+     * @param input - Vote input (proposalId, support, weight)
+     * @returns The signed vote
+     */
+    castVote(input: VoteInput): Promise<Vote>;
+    /**
+     * Build the merkle tree for a proposal's votes.
+     *
+     * @param proposalId - The proposal ID
+     * @returns The merkle root
+     */
+    buildMerkleTree(proposalId: string): string;
+    /**
+     * Settle votes on-chain by posting the merkle root.
+     *
+     * Builds the merkle tree, computes totals, and submits a single
+     * transaction to the contract.
+     *
+     * @param proposalId - The proposal to settle
+     * @returns Settlement data including tx hash
+     */
+    settleVotes(proposalId: string): Promise<SettlementData & {
+        txHash: string;
+    }>;
+    /**
+     * Generate a merkle proof for a specific voter.
+     *
+     * @param proposalId - The proposal ID
+     * @param voter - Voter address
+     * @returns Merkle proof bundle
+     */
+    generateProof(proposalId: string, voter: string): MerkleProofBundle;
+    /**
+     * Verify a vote on-chain using a merkle proof.
+     *
+     * @param proposalId - The proposal ID
+     * @param bundle - Merkle proof bundle
+     * @returns Whether the vote is valid
+     */
+    verifyVote(proposalId: string, bundle: MerkleProofBundle): Promise<boolean>;
+    /**
+     * Verify a vote off-chain using the merkle proof.
+     *
+     * @param root - Expected merkle root
+     * @param vote - The vote to verify
+     * @param proof - Merkle proof
+     * @returns Whether the proof is valid
+     */
+    verifyVoteOffChain(root: string, vote: Vote, proof: string[]): boolean;
+    /**
+     * Get a proposal from the contract.
+     *
+     * @param proposalId - The proposal ID
+     * @returns Proposal data
+     */
+    getProposal(proposalId: string): Promise<Proposal>;
+    /**
+     * Get all in-memory votes for a proposal.
+     *
+     * @param proposalId - The proposal ID
+     * @returns Array of votes
+     */
+    getVotes(proposalId: string): Vote[];
+    /**
+     * Check if a settled proposal passed (on-chain).
+     *
+     * @param proposalId - The proposal ID
+     * @returns Whether the proposal passed
+     */
+    didPass(proposalId: string): Promise<boolean>;
+}
+
+/**
+ * Current SDK version, injected at build time via tsup define.
+ */
+declare const SDK_VERSION: string;
+/**
+ * The callable verify interface.
+ *
+ * Supports both `inv.verify(txHash)` direct call syntax
+ * and sub-methods like `inv.verify.action()`.
+ */
+interface VerifyProxy extends Verifier {
+    (txHash: string): Promise<VerificationResult>;
+}
+/**
+ * The main entry point for the Invariance SDK.
+ *
+ * Lazily initializes all 12 module managers and exposes them as properties.
+ * The constructor validates chain configuration and contract availability.
+ *
+ * @example
+ * ```typescript
+ * import { Invariance } from '@invariance/sdk';
+ *
+ * // Self-hosted
+ * const inv = new Invariance({
+ *   chain: 'base',
+ *   rpcUrl: 'https://mainnet.base.org',
+ *   signer: wallet,
+ * });
+ *
+ * // Managed hosting
+ * const inv = new Invariance({
+ *   apiKey: 'inv_live_xxx',
+ *   chain: 'base',
+ * });
+ *
+ * // Register an identity
+ * const agent = await inv.identity.register({
+ *   type: 'agent',
+ *   owner: '0xDev',
+ *   label: 'TraderBot',
+ * });
+ *
+ * // Execute a verified intent
+ * const result = await inv.intent.request({
+ *   actor: { type: 'agent', address: agent.address },
+ *   action: 'swap',
+ *   params: { from: 'USDC', to: 'ETH', amount: '100' },
+ *   approval: 'auto',
+ * });
+ *
+ * // Verify any transaction
+ * const verification = await inv.verify('0xtxhash...');
+ * ```
+ */
+declare class Invariance {
+    private readonly config;
+    private readonly contracts;
+    private readonly events;
+    private readonly telemetry;
+    private _identity?;
+    private _wallet?;
+    private _walletInitPromise?;
+    private _intent?;
+    private _policy?;
+    private _escrow?;
+    private _ledger?;
+    private _ledgerCompact?;
+    private _verify?;
+    private _atomic?;
+    private _reputation?;
+    private _gas?;
+    private _x402?;
+    private _erc8004?;
+    private _erc8004Bridge?;
+    private _marketplace?;
+    private _auditTrail?;
+    private _voting?;
+    /**
+     * Generate a fresh random wallet and return an Invariance client.
+     *
+     * @example
+     * ```typescript
+     * const inv = Invariance.createRandom({ chain: 'base-sepolia' });
+     * console.log(inv.wallet.getAddress());
+     * ```
+     */
+    static createRandom(config?: Partial<InvarianceConfig>): Invariance;
+    /**
+     * Create a client from a hex private key string.
+     *
+     * @param key - Hex private key (with or without 0x prefix)
+     * @param config - Optional SDK configuration overrides
+     *
+     * @example
+     * ```typescript
+     * const inv = Invariance.fromPrivateKey('0xabc...', { chain: 'base-sepolia' });
+     * ```
+     */
+    static fromPrivateKey(key: string, config?: Partial<InvarianceConfig>): Invariance;
+    /**
+     * Create a client from a BIP-39 mnemonic phrase.
+     *
+     * @param phrase - 12 or 24 word mnemonic
+     * @param config - Optional SDK configuration overrides
+     *
+     * @example
+     * ```typescript
+     * const inv = Invariance.fromMnemonic('abandon abandon ... about', { chain: 'base' });
+     * ```
+     */
+    static fromMnemonic(phrase: string, config?: Partial<InvarianceConfig>): Invariance;
+    constructor(config?: Partial<InvarianceConfig>);
+    /**
+     * Ensure wallet initialization is complete.
+     * Call this before using any contract methods.
+     *
+     * @remarks
+     * This is called automatically when accessing module getters,
+     * so manual calls are rarely needed.
+     */
+    ensureWalletInit(): Promise<void>;
+    /**
+     * Internal: ensure wallet init is complete.
+     * Called automatically by module getters.
+     * @internal
+     */
+    private _autoInit;
+    /**
+     * Identity management module.
+     *
+     * Register agents, humans, devices as verified identities.
+     * 10 methods: register, get, resolve, update, pause, resume, deactivate, list, attest, attestations
+     */
+    get identity(): IdentityManager;
+    /**
+     * Ensure wallet is initialized before performing contract operations.
+     * Automatically called internally; rarely needed by consumers.
+     * @internal
+     */
+    ready(): Promise<this>;
+    /**
+     * Wallet management module.
+     *
+     * Key management, embedded wallets via Privy.
+     * 9 methods: create, connect, get, fund, balance, export, exportPrivateKey, signMessage, disconnect
+     */
+    get wallet(): WalletManager;
+    /**
+     * Intent Protocol module.
+     *
+     * Request -> Approve -> Execute -> Verify handshake.
+     * 6 methods: request, prepare, approve, reject, status, history
+     */
+    get intent(): IntentProtocol;
+    /**
+     * Policy Engine module.
+     *
+     * Composable, verifiable condition sets.
+     * 9 methods: create, attach, detach, evaluate, revoke, status, list, compose, onViolation
+     */
+    get policy(): PolicyEngine;
+    /**
+     * Escrow module.
+     *
+     * USDC escrow with multi-sig, conditional release.
+     * 11 methods: create, fund, release, refund, dispute, resolve, approve, approvals, status, list, onStateChange
+     */
+    get escrow(): EscrowManager;
+    /**
+     * Event Ledger module.
+     *
+     * Immutable on-chain logging with dual signatures.
+     * 5 methods: log, batch, query, stream, export
+     */
+    get ledger(): EventLedger;
+    /**
+     * Compact Event Ledger module (fraud-proof).
+     *
+     * Uses CompactLedger with EIP-712 dual signatures verified on-chain.
+     * Requires an API key for platform attestation.
+     *
+     * @example
+     * ```typescript
+     * const entry = await inv.ledgerCompact.log({
+     *   action: 'model-inference',
+     *   actor: { type: 'agent', address: '0xBot' },
+     * });
+     * ```
+     */
+    get ledgerCompact(): EventLedgerCompact;
+    /**
+     * Atomic Verifier module.
+     *
+     * Identity check + policy eval + CompactLedger log in a single transaction.
+     * Requires an API key for platform attestation.
+     *
+     * @example
+     * ```typescript
+     * const entry = await inv.atomic.verifyAndLog({
+     *   action: 'swap',
+     *   actor: { type: 'agent', address: '0xBot' },
+     * });
+     * ```
+     */
+    get atomic(): AtomicVerifier;
+    /**
+     * Verify module.
+     *
+     * Cryptographic verification + public explorer URLs.
+     * Supports both direct call `inv.verify(txHash)` and sub-methods.
+     * 7 methods: verify (callable), action, identity, escrow, proof, bulk, url
+     */
+    get verify(): VerifyProxy;
+    /**
+     * Reputation Engine module.
+     *
+     * Auto-calculated scores + 1-5 star reviews.
+     * 7 methods: get, review, getReviews, score, compare, badge, history
+     */
+    get reputation(): ReputationEngine;
+    /**
+     * Gas management module.
+     *
+     * Gas abstraction (USDC-based).
+     * 2 methods: estimate, balance
+     */
+    get gas(): GasManager;
+    /**
+     * X402 Payment Protocol module.
+     *
+     * Pay-per-action execution and agent-to-agent payments via x402.
+     * 5 methods: payForAction, verifyPayment, history, estimateCost, configure
+     */
+    get x402(): X402Manager;
+    /**
+     * ERC-8004 (Trustless Agents) module.
+     *
+     * Standalone manager for on-chain agent identity, reputation, and validation.
+     * Works without any Invariance contracts — just ERC-8004 registries.
+     * 14 methods: register, getAgent, setMetadata, getMetadata, setAgentWallet,
+     * setAgentURI, getGlobalId, giveFeedback, revokeFeedback, getSummary,
+     * readFeedback, readAllFeedback, requestValidation, respondToValidation,
+     * getValidationStatus, getValidationSummary
+     */
+    get erc8004(): ERC8004Manager;
+    /**
+     * ERC-8004 Bridge module.
+     *
+     * Optional bridge between ERC-8004 and Invariance modules.
+     * Links identities, bridges reputation, enables cross-protocol validation.
+     * 6 methods: linkIdentity, getLinkedIdentity, unlinkIdentity,
+     * pullERC8004Reputation, pushFeedbackFromLedger, actAsValidator,
+     * requestInvarianceValidation
+     */
+    get erc8004Bridge(): InvarianceBridge;
+    /**
+     * Marketplace Kit module.
+     *
+     * Pre-built primitives for verified marketplaces: list, search, hire, complete.
+     * 8 methods: register, update, deactivate, search, get, featured, hire, complete
+     */
+    get marketplace(): MarketplaceKit;
+    /**
+     * Off-chain-first audit module with optional on-chain anchoring.
+     *
+     * Wallet account integrations remain unchanged: actor identity and signer
+     * flow still use the configured wallet/account providers.
+     */
+    get auditTrail(): AuditTrail;
+    /**
+     * Off-chain batch voting with merkle root settlement.
+     *
+     * Create proposals on-chain, collect EIP-712 signed votes off-chain,
+     * then settle with a single merkle root transaction.
+     * 10 methods: createProposal, castVote, buildMerkleTree, settleVotes,
+     * generateProof, verifyVote, verifyVoteOffChain, getProposal, getVotes, didPass
+     */
+    get voting(): VotingManager;
+    /**
+     * Create an auto-batching compact ledger that buffers `log()` calls
+     * and flushes them as a single `logBatch()` transaction for ~85% gas savings.
+     *
+     * @param config - Batch configuration (maxBatchSize, maxWaitMs, enabled)
+     * @returns Auto-batching compact ledger wrapper
+     *
+     * @example
+     * ```typescript
+     * const batched = inv.ledgerCompactBatched({ maxBatchSize: 10, maxWaitMs: 5000 });
+     * await Promise.all(events.map(e => batched.log(e))); // 1 tx instead of N
+     * await batched.destroy(); // flush remaining + cleanup
+     * ```
+     */
+    ledgerCompactBatched(config?: AutoBatchConfig): AutoBatchedEventLedgerCompact;
+    /**
+     * Register an identity, create a policy, and attach it in one call.
+     *
+     * @param opts - Identity and policy options
+     * @returns The created identity and attached policy
+     *
+     * @example
+     * ```typescript
+     * const { identity, policy } = await inv.quickSetup({
+     *   identity: { type: 'agent', owner: '0xDev', label: 'TraderBot' },
+     *   policy: { name: 'trading-limits', rules: [{ type: 'max-spend', config: { amount: '1000' } }] },
+     * });
+     * ```
+     */
+    quickSetup(opts: QuickSetupOptions): Promise<QuickSetupResult>;
+    /**
+     * Hire from a marketplace listing and auto-fund the escrow.
+     *
+     * @param opts - Hire options with optional fund amount override
+     * @returns Hire result with funded escrow
+     *
+     * @example
+     * ```typescript
+     * const result = await inv.hireAndFund({
+     *   listingId: 'listing-123',
+     *   task: { description: 'Label 1000 images', deadline: '2025-06-01' },
+     *   payment: { amount: '500', type: 'escrow' },
+     * });
+     * ```
+     */
+    hireAndFund(opts: HireAndFundOptions): Promise<_invariance_common.HireResult>;
+    /**
+     * Register multiple agents with a shared policy in one call.
+     *
+     * @param opts - Batch of agents and a shared policy
+     * @returns Array of registered identities with attached policies
+     *
+     * @example
+     * ```typescript
+     * const agents = await inv.batchRegister({
+     *   agents: [
+     *     { identity: { type: 'agent', owner: '0xDev', label: 'Worker-1' } },
+     *     { identity: { type: 'agent', owner: '0xDev', label: 'Worker-2' } },
+     *   ],
+     *   sharedPolicy: { name: 'worker-policy', rules: [{ type: 'rate-limit', config: { max: 100, window: 'PT1H' } }] },
+     * });
+     * ```
+     */
+    batchRegister(opts: BatchRegisterOptions): Promise<BatchRegisterEntry[]>;
+    /**
+     * Execute an intent and log a custom ledger event in one call.
+     *
+     * @param opts - Intent request options and ledger event input
+     * @returns The intent result and logged ledger entry
+     *
+     * @example
+     * ```typescript
+     * const { intent, log } = await inv.executeAndLog({
+     *   intent: {
+     *     actor: { type: 'agent', address: '0xAgent' },
+     *     action: 'moderate',
+     *     params: { contentId: 'post-456' },
+     *     approval: 'auto',
+     *   },
+     *   log: {
+     *     action: 'content-moderated',
+     *     actor: { type: 'agent', address: '0xAgent' },
+     *     category: 'custom',
+     *     metadata: { contentId: 'post-456', verdict: 'approved' },
+     *   },
+     * });
+     * ```
+     */
+    executeAndLog(opts: ExecuteAndLogOptions): Promise<ExecuteAndLogResult>;
+    /**
+     * Gate any async action through SDK lifecycle + audit logging.
+     *
+     * Defaults to off-chain logging via infrastructure APIs. Per-action mode can
+     * be overridden with `opts.mode` (`offchain`, `onchain`, or `dual`).
+     */
+    gateAction<T>(opts: GateActionOptions, executor: () => Promise<T>): Promise<GateActionResult<T>>;
+    /**
+     * Create a policy configured for recurring payments with time-window rules.
+     *
+     * @param opts - Recurring payment configuration
+     * @returns The created policy
+     *
+     * @example
+     * ```typescript
+     * const policy = await inv.recurringPayment({
+     *   name: 'monthly-subscription',
+     *   amount: '50',
+     *   recipient: '0xService',
+     *   interval: 'P1M',
+     *   maxPayments: 12,
+     * });
+     * ```
+     */
+    recurringPayment(opts: RecurringPaymentOptions): Promise<SpecPolicy>;
+    /**
+     * Create a multi-sig escrow with simplified options.
+     *
+     * @param opts - Multi-sig escrow configuration
+     * @returns The created escrow contract
+     *
+     * @example
+     * ```typescript
+     * const escrow = await inv.createMultiSig({
+     *   amount: '10000',
+     *   recipient: { type: 'agent', address: '0xAgent' },
+     *   signers: ['0xSigner1', '0xSigner2', '0xSigner3'],
+     *   threshold: 2,
+     * });
+     * ```
+     */
+    createMultiSig(opts: CreateMultiSigOptions): Promise<EscrowContract>;
+    /**
+     * Register an agent with rate-limit and cooldown policies pre-configured.
+     *
+     * @param opts - Agent identity and rate limit configuration
+     * @returns The created identity and rate-limit policy
+     *
+     * @example
+     * ```typescript
+     * const { identity, policy } = await inv.setupRateLimitedAgent({
+     *   identity: { type: 'agent', owner: '0xDev', label: 'SupportBot' },
+     *   maxActions: 100,
+     *   window: 'PT1H',
+     *   cooldown: 'PT5S',
+     *   allowedActions: ['reply', 'escalate', 'close'],
+     * });
+     * ```
+     */
+    setupRateLimitedAgent(opts: SetupRateLimitedAgentOptions): Promise<QuickSetupResult>;
+    /**
+     * Complete the full hire → complete → review flow in one call.
+     *
+     * @param opts - Hire, completion, and review options
+     * @returns Combined result with hire, completion, and review data
+     *
+     * @example
+     * ```typescript
+     * const result = await inv.hireAndReview({
+     *   hire: {
+     *     listingId: 'listing-123',
+     *     task: { description: 'Analyze dataset', deadline: '2025-06-01' },
+     *     payment: { amount: '200', type: 'escrow' },
+     *   },
+     *   review: { rating: 5, comment: 'Excellent work' },
+     * });
+     * ```
+     */
+    hireAndReview(opts: HireAndReviewOptions): Promise<HireAndReviewResult>;
+    /**
+     * Query ledger entries, optionally verify each one, and export a report.
+     *
+     * @param opts - Audit query filters and options
+     * @returns Audit report with entries, verification results, and optional export
+     *
+     * @example
+     * ```typescript
+     * const report = await inv.audit({
+     *   actor: '0xAgent',
+     *   from: '2025-01-01',
+     *   to: '2025-06-01',
+     *   verify: true,
+     *   exportFormat: 'json',
+     * });
+     * console.log(`${report.verifiedCount}/${report.totalEntries} entries verified`);
+     * ```
+     */
+    audit(opts: AuditOptions): Promise<AuditReport>;
+    /**
+     * Create a scoped child policy for agent-to-agent delegation.
+     *
+     * @param opts - Delegation scope and agent identifiers
+     * @returns The delegation policy and intent recording the delegation
+     *
+     * @example
+     * ```typescript
+     * const { policy, intent } = await inv.delegate({
+     *   from: 'identity-orchestrator',
+     *   to: 'identity-worker',
+     *   scope: {
+     *     actions: ['fetch-data', 'transform'],
+     *     maxSpend: '50',
+     *     expiry: '2025-06-01T00:00:00Z',
+     *   },
+     * });
+     * ```
+     */
+    delegate(opts: DelegateOptions): Promise<DelegateResult>;
+    /**
+     * Execute multiple operations with concurrency control and error handling.
+     *
+     * @param operations - Operations to execute
+     * @param options - Batch execution options
+     * @returns Aggregated results with success/failure counts
+     *
+     * @example
+     * ```typescript
+     * const results = await inv.batch([
+     *   { execute: () => inv.identity.register({...}), description: 'Register Bot1' },
+     *   { execute: () => inv.identity.register({...}), description: 'Register Bot2' },
+     * ], { continueOnError: true, maxConcurrency: 3 });
+     * ```
+     */
+    batch<T = unknown>(operations: DeferredOperation<T>[], options?: BatchOptions): Promise<BatchResult<T>>;
+    /**
+     * Create a session context bound to a specific actor.
+     *
+     * All operations on the returned session automatically use the bound actor.
+     *
+     * @param options - Session options with actor reference
+     * @returns Session context with actor-scoped methods
+     *
+     * @example
+     * ```typescript
+     * const session = inv.session({ actor: { type: 'agent', address: '0xBot' } });
+     * await session.requestIntent({ action: 'swap', params: {...} });
+     * ```
+     */
+    session(options: SessionOptions): SessionContext;
+    /**
+     * Create a fluent pipeline builder for multi-step workflows.
+     *
+     * @returns Pipeline builder with chainable methods
+     *
+     * @example
+     * ```typescript
+     * const result = await inv.pipeline()
+     *   .register({ type: 'agent', label: 'Bot', owner: '0x...' })
+     *   .createPolicy({ template: 'defi-trading' })
+     *   .attachPolicy()
+     *   .execute();
+     * ```
+     */
+    pipeline(): PipelineBuilder;
+    /**
+     * Register a callback to run before every intent action.
+     *
+     * @param callback - Called before each action with action details
+     * @returns Unsubscribe function
+     */
+    beforeAction(callback: (data: InvarianceEvents['action.before']) => void): () => void;
+    /**
+     * Register a callback to run after every intent action.
+     *
+     * @param callback - Called after each action with result details
+     * @returns Unsubscribe function
+     */
+    afterAction(callback: (data: InvarianceEvents['action.after']) => void): () => void;
+    /**
+     * Register a callback for policy violation events.
+     *
+     * @param callback - Called when a violation occurs
+     * @returns Unsubscribe function
+     */
+    onViolation(callback: (data: InvarianceEvents['action.violation']) => void): () => void;
+    /**
+     * Register a callback for error events.
+     *
+     * @param callback - Called when an error occurs
+     * @returns Unsubscribe function
+     */
+    onError(callback: (data: InvarianceEvents['action.error']) => void): () => void;
+    /**
+     * Get the raw configuration object.
+     */
+    getConfig(): InvarianceConfig;
+    /**
+     * Get the current SDK version.
+     */
+    get version(): string;
+    /**
+     * Get the chain configuration.
+     */
+    getChainConfig(): _invariance_common.ChainConfig;
+    /**
+     * Get all contract addresses for the current chain.
+     */
+    getContractAddresses(): _invariance_common.ContractAddresses;
+    /**
+     * Get the explorer base URL.
+     */
+    getExplorerBaseUrl(): string;
+    /**
+     * Subscribe to SDK-level events.
+     *
+     * @param event - Event name
+     * @param listener - Callback
+     * @returns Unsubscribe function
+     */
+    on<K extends keyof InvarianceEvents>(event: K, listener: (data: InvarianceEvents[K]) => void): () => void;
+}
+
+/**
+ * Batch executor for running multiple operations with concurrency control.
+ *
+ * @example
+ * ```typescript
+ * const results = await inv.batch([
+ *   { execute: () => inv.identity.register({...}), description: 'Register Bot1' },
+ *   { execute: () => inv.identity.register({...}), description: 'Register Bot2' },
+ * ], { continueOnError: true, maxConcurrency: 3 });
+ * ```
+ */
+
+/**
+ * Execute a batch of operations with concurrency control and error handling.
+ */
+declare class BatchExecutor {
+    /**
+     * Execute operations with configurable concurrency and error handling.
+     *
+     * @param operations - Operations to execute
+     * @param options - Batch execution options
+     * @returns Aggregated results with success/failure counts
+     */
+    execute<T = unknown>(operations: DeferredOperation<T>[], options?: BatchOptions): Promise<BatchResult<T>>;
+}
+
+/**
+ * Base error class for all Invariance SDK errors.
+ *
+ * Every SDK error carries a structured {@link ErrorCode} for programmatic handling,
+ * along with optional explorer URL and transaction hash for on-chain debugging.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await inv.intent.request(opts);
+ * } catch (err) {
+ *   if (err instanceof InvarianceError) {
+ *     console.error(err.code, err.message, err.explorerUrl);
+ *   }
+ * }
+ * ```
+ */
+declare class InvarianceError extends Error {
+    /** Structured error code for programmatic handling */
+    readonly code: ErrorCode;
+    /** Public explorer URL relevant to the error context */
+    readonly explorerUrl?: string | undefined;
+    /** On-chain transaction hash related to the error */
+    readonly txHash?: string | undefined;
+    constructor(code: ErrorCode, message: string, opts?: {
+        explorerUrl?: string;
+        txHash?: string;
+    });
+}
+
+/**
+ * Canonical ERC-8004 registry addresses per chain.
+ *
+ * **IMPORTANT — Testnet placeholders only.**
+ * The addresses below are synthetic pre-deployment values (sequential hex pattern).
+ * They do NOT correspond to deployed contracts. Before using ERC-8004 features in
+ * production, you **must** override these with real deployed addresses via
+ * `Invariance({ erc8004: { addresses: { identity, reputation, validation } } })`.
+ *
+ * @todo Replace with actual deployed contract addresses after ERC-8004 registry deployment.
+ */
+
+/**
+ * Get ERC-8004 registry addresses for a given chain.
+ *
+ * @param chainId - The chain ID
+ * @returns Registry addresses or undefined if not supported
+ */
+declare function getERC8004Addresses(chainId: number): ERC8004RegistryAddresses | undefined;
+/**
+ * Check if ERC-8004 is supported on a given chain.
+ *
+ * @param chainId - The chain ID
+ * @returns Whether ERC-8004 registries are deployed on this chain
+ */
+declare function isERC8004Supported(chainId: number): boolean;
+
+/**
+ * Verify an Invariance webhook HMAC-SHA256 signature.
+ *
+ * Use this in your webhook endpoint to verify that incoming
+ * payloads are genuinely from Invariance and have not been tampered with.
+ *
+ * @param body - The raw request body (string or object)
+ * @param signature - The signature from the `X-Invariance-Signature` header
+ * @param secret - Your webhook secret (from webhook registration)
+ * @returns True if the signature is valid
+ *
+ * @example
+ * ```typescript
+ * import { verifyWebhookSignature } from '@invariance/sdk';
+ *
+ * app.post('/webhooks/invariance', (req, res) => {
+ *   const sig = req.headers['x-invariance-signature'];
+ *   if (!verifyWebhookSignature(req.body, sig, WEBHOOK_SECRET)) {
+ *     return res.status(401).send('Invalid signature');
+ *   }
+ *   // Process webhook...
+ * });
+ * ```
+ */
+declare function verifyWebhookSignature(body: unknown, signature: string, secret: string): boolean;
+
+/**
+ * Generic pre/post action hooks for ANY agent runtime.
+ * 3-line integration for any framework.
+ *
+ * @example
+ * ```typescript
+ * const hooks = new RuntimeHookAdapter(inv);
+ * const { allowed } = await hooks.beforeAction({ action: 'swap', actor, params: {} });
+ * await hooks.afterAction(ctx, { success: true, txHash: '0x...' });
+ * ```
+ */
+
+/** Action context passed through hooks */
+interface ActionContext {
+    /** Action identifier (e.g., 'swap', 'transfer') */
+    action: string;
+    /** Actor performing the action */
+    actor: ActorReference;
+    /** Action parameters */
+    params: Record<string, unknown>;
+    /** Optional policy to evaluate against */
+    policyId?: string;
+    /** Timestamp of action initiation */
+    timestamp: number;
+}
+/** Result from beforeAction hook */
+interface BeforeActionResult {
+    /** Whether the action is permitted */
+    allowed: boolean;
+    /** Reason if denied */
+    reason?: string;
+    /** Policy evaluation details */
+    policyId?: string;
+}
+/** Result from afterAction hook */
+interface AfterActionResult {
+    /** Ledger entry ID */
+    entryId: string;
+    /** Transaction hash */
+    txHash: string;
+    /** Duration in milliseconds */
+    durationMs: number;
+}
+/** Hook callbacks for custom logic */
+interface RuntimeHooks {
+    /** Called before policy evaluation */
+    onBeforeEvaluate?: (ctx: ActionContext) => Promise<void> | void;
+    /** Called after policy evaluation, before execution */
+    onAfterEvaluate?: (ctx: ActionContext, result: BeforeActionResult) => Promise<void> | void;
+    /** Called after logging */
+    onAfterLog?: (ctx: ActionContext, result: AfterActionResult) => Promise<void> | void;
+    /** Called on any error */
+    onError?: (ctx: ActionContext, error: Error) => Promise<void> | void;
+}
+/**
+ * RuntimeHookAdapter — drop-in verification for any agent runtime.
+ *
+ * @example
+ * ```typescript
+ * const hooks = new RuntimeHookAdapter(inv);
+ * // Wrap any agent action:
+ * const { result, log } = await hooks.wrap(
+ *   { action: 'swap', actor: { type: 'agent', address: '0x...' }, params: {} },
+ *   () => executeSwap(),
+ * );
+ * ```
+ */
+declare class RuntimeHookAdapter {
+    private readonly client;
+    private readonly hooks;
+    constructor(client: Invariance, hooks?: RuntimeHooks);
+    /**
+     * Evaluate policy and request intent before action execution.
+     */
+    beforeAction(ctx: Omit<ActionContext, 'timestamp'>): Promise<BeforeActionResult>;
+    /**
+     * Log action result to immutable ledger after execution.
+     */
+    afterAction(ctx: Omit<ActionContext, 'timestamp'>, outcome: {
+        success: boolean;
+        txHash?: string;
+        error?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<AfterActionResult>;
+    /**
+     * Wrap an async function with before/after hooks.
+     */
+    wrap<T>(ctx: Omit<ActionContext, 'timestamp'>, fn: () => Promise<T>): Promise<{
+        result: T;
+        log: AfterActionResult;
+    }>;
+}
+
+/**
+ * Setup crews with shared budgets and per-role policies.
+ *
+ * @example
+ * ```typescript
+ * const composer = new MultiAgentComposer(inv);
+ * const crew = await composer.setupCrew({
+ *   name: 'research-crew',
+ *   budget: '5000',
+ *   roles: [
+ *     { name: 'researcher', rules: [], allowedActions: ['query', 'analyze'] },
+ *     { name: 'executor', rules: [], allowedActions: ['swap', 'transfer'], maxSpend: '1000' },
+ *   ],
+ *   members: [
+ *     { identity: { type: 'agent', owner: '0xDev', label: 'R-1' }, role: 'researcher' },
+ *   ],
+ *   signers: ['0xSigner1', '0xSigner2'],
+ *   threshold: 2,
+ * });
+ * ```
+ */
+
+/** Role definition for a crew member */
+interface CrewRole {
+    /** Role identifier (e.g., 'researcher', 'executor', 'reviewer') */
+    name: string;
+    /** Policy rules specific to this role */
+    rules: PolicyRule[];
+    /** Optional spending limit override for this role */
+    maxSpend?: string;
+    /** Allowed actions for this role */
+    allowedActions?: string[];
+}
+/** Agent to register as part of a crew */
+interface CrewMember {
+    /** Identity registration options */
+    identity: {
+        type: 'agent' | 'human' | 'device' | 'service';
+        owner: string;
+        label: string;
+        metadata?: Record<string, unknown>;
+    };
+    /** Role name from the crew's role definitions */
+    role: string;
+}
+/** Options for setting up a crew */
+interface SetupCrewOptions {
+    /** Crew name */
+    name: string;
+    /** Shared budget amount in USDC */
+    budget: string;
+    /** Role definitions */
+    roles: CrewRole[];
+    /** Members to register */
+    members: CrewMember[];
+    /** Multi-sig signers for budget release */
+    signers: string[];
+    /** Required signatures for budget release */
+    threshold: number;
+    /** Budget escrow timeout (ISO 8601 duration, default: P30D) */
+    timeout?: string;
+    /** Shared policy rules that apply to ALL members */
+    sharedRules?: PolicyRule[];
+}
+/** Result of crew setup */
+interface CrewSetupResult {
+    /** Crew identifier */
+    crewId: string;
+    /** Registered member identities */
+    members: Array<{
+        identity: Identity;
+        role: string;
+        policy: SpecPolicy;
+    }>;
+    /** Shared budget escrow */
+    escrow: EscrowContract;
+    /** Shared policy (applied to all members) */
+    sharedPolicy: SpecPolicy;
+}
+/**
+ * MultiAgentComposer — orchestrate agent crews with shared budgets and role-based policies.
+ */
+declare class MultiAgentComposer {
+    private readonly client;
+    constructor(client: Invariance);
+    /**
+     * Register a crew of agents with shared budget and role-based policies.
+     */
+    setupCrew(opts: SetupCrewOptions): Promise<CrewSetupResult>;
+    /**
+     * Add a new member to an existing crew.
+     */
+    addMember(crewSharedPolicyId: string, member: CrewMember, role: CrewRole, crewName: string): Promise<{
+        identity: Identity;
+        policy: SpecPolicy;
+    }>;
+}
+
+/**
+ * Publish agents to external stores with verified badges.
+ *
+ * @example
+ * ```typescript
+ * const plugin = new MarketplacePlugin(inv);
+ * const { listing, badge } = await plugin.publishAgent({
+ *   identity: 'identity-123',
+ *   name: 'DataAnalyzer',
+ *   description: 'Analyzes datasets with ML',
+ *   category: 'analytics',
+ *   pricing: { model: 'per-task', amount: '50' },
+ *   generateBadge: true,
+ * });
+ * ```
+ */
+
+/** Options for publishing an agent */
+interface PublishAgentOptions extends RegisterListingOptions {
+    /** Auto-generate a reputation badge on publish */
+    generateBadge?: boolean;
+    /** Minimum reputation score required for badge */
+    badgeThreshold?: number;
+}
+/** Result of publishing an agent */
+interface PublishResult {
+    /** Created marketplace listing */
+    listing: Listing;
+    /** Generated badge (if requested) */
+    badge?: Badge;
+}
+/** Options for hiring with escrow */
+interface HireWithEscrowOptions {
+    /** Listing ID to hire from */
+    listingId: string;
+    /** Task description */
+    task: {
+        description: string;
+        deadline?: string;
+    };
+    /** Payment configuration */
+    payment: {
+        amount: string;
+        type: 'escrow';
+    };
+    /** Optional fund amount override */
+    fundAmount?: string;
+}
+/**
+ * MarketplacePlugin — simplified publish + hire flows with verified badges.
+ */
+declare class MarketplacePlugin {
+    private readonly client;
+    constructor(client: Invariance);
+    /**
+     * Publish an agent listing with optional reputation badge.
+     */
+    publishAgent(opts: PublishAgentOptions): Promise<PublishResult>;
+    /**
+     * Hire an agent with automatic escrow funding.
+     */
+    hireWithEscrow(opts: HireWithEscrowOptions): Promise<HireResult>;
+    /**
+     * Get verified listing with reputation data.
+     */
+    getVerifiedListing(listingId: string): Promise<{
+        listing: Listing;
+        badge?: Badge;
+    }>;
+}
+
+/**
+ * Import/aggregate scores from external platforms.
+ *
+ * @example
+ * ```typescript
+ * const bridge = new ReputationBridge(inv);
+ * bridge.importExternalScore('identity-123', {
+ *   platform: 'gitcoin',
+ *   score: 85,
+ *   proofUrl: 'https://passport.gitcoin.co/...',
+ *   fetchedAt: Date.now(),
+ * });
+ * const agg = await bridge.getAggregatedScore('identity-123');
+ * ```
+ */
+
+/** External score source */
+interface ExternalScore {
+    /** Platform name (e.g., 'gitcoin', 'lens', 'olas') */
+    platform: string;
+    /** Score value (0-100 normalized) */
+    score: number;
+    /** Source URL or proof */
+    proofUrl?: string;
+    /** When the score was fetched */
+    fetchedAt: number;
+    /** Raw score data from the platform */
+    rawData?: Record<string, unknown>;
+}
+/** Aggregation weights configuration */
+interface AggregationWeights {
+    /** Weight for Invariance on-chain score (default: 0.7) */
+    invariance: number;
+    /** Weight for external scores (default: 0.3) */
+    external: number;
+}
+/** Aggregated reputation result */
+interface AggregatedReputation {
+    /** Final weighted score (0-100) */
+    score: number;
+    /** Invariance on-chain score component */
+    invarianceScore: number;
+    /** Average external score component */
+    externalAverage: number;
+    /** Individual external scores */
+    externalScores: ExternalScore[];
+    /** Weights used */
+    weights: AggregationWeights;
+    /** Number of sources */
+    sourceCount: number;
+}
+/**
+ * ReputationBridge — import and aggregate reputation from external platforms.
+ */
+declare class ReputationBridge {
+    private readonly client;
+    private readonly externalScores;
+    private weights;
+    constructor(client: Invariance, weights?: Partial<AggregationWeights>);
+    /**
+     * Import an external reputation score for an identity.
+     */
+    importExternalScore(identityId: string, score: ExternalScore): void;
+    /**
+     * Get external scores for an identity.
+     */
+    getExternalScores(identityId: string): ExternalScore[];
+    /**
+     * Get aggregated reputation score combining Invariance + external sources.
+     */
+    getAggregatedScore(identityId: string): Promise<AggregatedReputation>;
+    /**
+     * Update aggregation weights.
+     */
+    setWeights(weights: Partial<AggregationWeights>): void;
+    /**
+     * Record external score as on-chain attestation.
+     */
+    attestExternalScore(identityId: string, score: ExternalScore): Promise<string>;
+}
+
+/**
+ * Escrow with cross-chain policy enforcement.
+ *
+ * @example
+ * ```typescript
+ * const xEscrow = new CrossChainEscrow(inv);
+ * const result = await xEscrow.create({
+ *   sourceChain: 'base',
+ *   destinationChain: 'optimism',
+ *   amount: '5000',
+ *   recipient: { type: 'agent', address: '0xAgent' },
+ *   perChainCap: '2500',
+ * });
+ * ```
+ */
+
+/** Supported chain identifiers */
+type ChainId = 'base' | 'base-sepolia' | 'ethereum' | 'optimism' | 'arbitrum';
+/** Cross-chain escrow configuration */
+interface CrossChainEscrowOptions {
+    /** Source chain where escrow is created */
+    sourceChain: ChainId;
+    /** Destination chain for the bridged action */
+    destinationChain: ChainId;
+    /** Escrow amount in USDC */
+    amount: string;
+    /** Recipient actor reference */
+    recipient: {
+        type: string;
+        address: string;
+    };
+    /** Per-chain spending cap */
+    perChainCap?: string;
+    /** Allowed bridge actions */
+    allowedActions?: string[];
+    /** Additional policy rules */
+    additionalRules?: PolicyRule[];
+    /** Escrow timeout (ISO 8601 duration) */
+    timeout?: string;
+}
+/** Result of cross-chain escrow creation */
+interface CrossChainEscrowResult {
+    /** Created escrow on source chain */
+    escrow: EscrowContract;
+    /** Attached bridge policy */
+    policy: SpecPolicy;
+    /** Source chain */
+    sourceChain: ChainId;
+    /** Destination chain */
+    destinationChain: ChainId;
+}
+/**
+ * CrossChainEscrow — escrow with cross-chain policy enforcement.
+ */
+declare class CrossChainEscrow {
+    private readonly client;
+    constructor(client: Invariance);
+    /**
+     * Create an escrow on the source chain with bridge-specific policy enforcement.
+     */
+    create(opts: CrossChainEscrowOptions): Promise<CrossChainEscrowResult>;
+    /**
+     * Verify that a cross-chain action complies with the attached policy.
+     */
+    verifyAction(policyId: string, action: string, actor: {
+        type: string;
+        address: string;
+    }, params?: Record<string, unknown>): Promise<{
+        allowed: boolean;
+        reason?: string;
+    }>;
+}
+
+/**
+ * Time-expiring verification with sybil resistance.
+ * Serves: Tinder+World ID, Hicky, Luna, Gitcoin Passport, Polygon ID, government ID programs.
+ *
+ * @example
+ * ```typescript
+ * const gatekeeper = new IdentityGatekeeper(inv);
+ * const credential = await gatekeeper.verifyAndGate({
+ *   identityId: 'identity-123',
+ *   platform: 'world-id',
+ *   validityMs: 365 * 24 * 60 * 60 * 1000,
+ *   sybilResistant: true,
+ * });
+ * ```
+ */
+
+/** Verification credential */
+interface VerificationCredential {
+    /** Identity ID of the verified entity */
+    identityId: string;
+    /** Platform that issued the verification */
+    platform: string;
+    /** When the verification was issued (ms since epoch) */
+    issuedAt: number;
+    /** When the verification expires (ms since epoch) */
+    expiresAt: number;
+    /** Transaction hash of the attestation */
+    txHash: string;
+    /** Whether still valid */
+    active: boolean;
+}
+/** Options for verifying and gating */
+interface VerifyAndGateOptions {
+    /** Identity to verify */
+    identityId: string;
+    /** Platform name (e.g., 'world-id', 'polygon-id', 'civic') */
+    platform: string;
+    /** Verification validity duration in milliseconds (default: 365 days) */
+    validityMs?: number;
+    /** External proof (e.g., World ID proof, Polygon ID credential) */
+    proof?: string;
+    /** Enforce 1-identity-per-platform (default: true) */
+    sybilResistant?: boolean;
+}
+/** Access log entry */
+interface AccessLogEntry {
+    /** Who queried the identity data */
+    queriedBy: string;
+    /** Identity that was queried */
+    identityId: string;
+    /** What data was accessed */
+    dataAccessed: string;
+    /** Timestamp */
+    timestamp: number;
+    /** Ledger entry ID */
+    entryId: string;
+}
+/**
+ * IdentityGatekeeper — time-expiring verification with sybil resistance.
+ */
+declare class IdentityGatekeeper {
+    private readonly client;
+    private readonly platformRegistry;
+    private readonly credentials;
+    constructor(client: Invariance);
+    /**
+     * Verify an identity and issue a time-bounded credential.
+     * Enforces 1-identity-per-platform when sybilResistant is true.
+     */
+    verifyAndGate(opts: VerifyAndGateOptions): Promise<VerificationCredential>;
+    /**
+     * Check if an identity has valid (non-expired) verification.
+     */
+    isVerified(identityId: string, platform: string): boolean;
+    /**
+     * Revoke expired verifications. Returns count of revoked credentials.
+     */
+    revokeExpired(platform?: string): number;
+    /**
+     * Log an access event for GDPR compliance.
+     */
+    accessLog(queriedBy: string, identityId: string, dataAccessed: string): Promise<AccessLogEntry>;
+    /**
+     * Get all active credentials for an identity.
+     */
+    getCredentials(identityId: string): VerificationCredential[];
+}
+
+/**
+ * Dual-identity verification (device + human) with confidence thresholds.
+ * Serves: Neuralink, Merge Labs, and future BCI platforms.
+ *
+ * @example
+ * ```typescript
+ * const bci = new BCIIntentVerifier(inv, { autoApprove: 0.95, humanReview: 0.7, deny: 0.3 });
+ * const result = await bci.verifyIntent({
+ *   deviceId: 'device-neuralink-001',
+ *   humanId: 'identity-user-123',
+ *   confidence: 0.92,
+ *   action: 'transfer',
+ *   params: { to: '0xRecipient', amount: '100' },
+ * });
+ * ```
+ */
+
+/** BCI signal with confidence score */
+interface BCISignal {
+    /** Device identity ID */
+    deviceId: string;
+    /** Human identity ID */
+    humanId: string;
+    /** Neural confidence score (0.0 - 1.0) */
+    confidence: number;
+    /** Intended action */
+    action: string;
+    /** Action parameters */
+    params: Record<string, unknown>;
+    /** Raw signal metadata */
+    signalMetadata?: Record<string, unknown>;
+}
+/** Confidence threshold configuration */
+interface ConfidenceThresholds {
+    /** Minimum confidence for auto-approval (default: 0.95) */
+    autoApprove: number;
+    /** Minimum confidence for human-in-the-loop approval (default: 0.7) */
+    humanReview: number;
+    /** Below this, action is denied (default: 0.3) */
+    deny: number;
+}
+/** BCI verification result */
+interface BCIVerificationResult {
+    /** Whether the action is approved */
+    approved: boolean;
+    /** Approval method used */
+    method: 'auto' | 'human-review' | 'denied';
+    /** Confidence score */
+    confidence: number;
+    /** Reason for decision */
+    reason: string;
+    /** Ledger entry for audit trail */
+    auditEntryId?: string;
+    /** Transaction hash */
+    txHash?: string;
+}
+/**
+ * BCIIntentVerifier — dual-identity verification for brain-computer interfaces.
+ */
+declare class BCIIntentVerifier {
+    private readonly client;
+    private readonly thresholds;
+    private readonly highStakesActions;
+    constructor(client: Invariance, thresholds?: Partial<ConfidenceThresholds>, highStakesActions?: string[]);
+    /**
+     * Verify a BCI intent signal with dual-identity check and confidence gating.
+     */
+    verifyIntent(signal: BCISignal): Promise<BCIVerificationResult>;
+    /**
+     * Update confidence thresholds.
+     */
+    setThresholds(thresholds: Partial<ConfidenceThresholds>): void;
+    /**
+     * Add actions to the high-stakes list.
+     */
+    addHighStakesActions(actions: string[]): void;
+    /**
+     * Get current threshold configuration.
+     */
+    getThresholds(): ConfidenceThresholds;
+}
+
+/**
+ * Beneficiary-gated bot registration + extraction logging.
+ * Serves: MEV bots, DeFi arbitrage, liquidation systems.
+ *
+ * @example
+ * ```typescript
+ * const mev = new MEVComplianceKit(inv);
+ * const bot = await mev.registerBot({
+ *   identity: { type: 'agent', owner: '0xDev', label: 'ArbBot-1' },
+ *   beneficiaries: ['0xTreasury', '0xDAO'],
+ *   maxExtractionPerTx: '1000',
+ *   maxDailyExtraction: '50000',
+ *   allowedStrategies: ['arbitrage', 'liquidation'],
+ * });
+ * ```
+ */
+
+/** MEV bot registration options */
+interface RegisterBotOptions {
+    /** Bot identity details */
+    identity: {
+        type: 'agent';
+        owner: string;
+        label: string;
+        metadata?: Record<string, unknown>;
+    };
+    /** Allowed beneficiary addresses */
+    beneficiaries: string[];
+    /** Maximum extraction per transaction */
+    maxExtractionPerTx?: string;
+    /** Maximum daily extraction */
+    maxDailyExtraction?: string;
+    /** Allowed MEV strategies */
+    allowedStrategies?: string[];
+}
+/** Registered bot result */
+interface RegisteredBot {
+    /** Bot identity */
+    identity: Identity;
+    /** Attached compliance policy */
+    policy: SpecPolicy;
+    /** Registered beneficiaries */
+    beneficiaries: string[];
+}
+/** MEV extraction log entry */
+interface ExtractionLog {
+    /** Ledger entry ID */
+    entryId: string;
+    /** Transaction hash */
+    txHash: string;
+    /** Strategy used */
+    strategy: string;
+    /** Amount extracted (USDC) */
+    amount: string;
+    /** Beneficiary address */
+    beneficiary: string;
+    /** Timestamp */
+    timestamp: number;
+}
+/**
+ * MEVComplianceKit — beneficiary-gated bot registration + extraction logging.
+ */
+declare class MEVComplianceKit {
+    private readonly client;
+    private readonly beneficiaryRegistry;
+    constructor(client: Invariance);
+    /**
+     * Register a MEV bot with beneficiary gates and extraction limits.
+     */
+    registerBot(opts: RegisterBotOptions): Promise<RegisteredBot>;
+    /**
+     * Verify that an extraction targets an approved beneficiary.
+     */
+    isBeneficiaryApproved(botIdentityId: string, beneficiary: string): boolean;
+    /**
+     * Log an MEV extraction event to the immutable ledger.
+     */
+    logExtraction(botIdentityId: string, extraction: {
+        strategy: string;
+        amount: string;
+        beneficiary: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<ExtractionLog>;
+    /**
+     * Add a beneficiary to an existing bot.
+     */
+    addBeneficiary(botIdentityId: string, beneficiary: string): void;
+    /**
+     * Remove a beneficiary from an existing bot.
+     */
+    removeBeneficiary(botIdentityId: string, beneficiary: string): boolean;
+    /**
+     * Get all approved beneficiaries for a bot.
+     */
+    getBeneficiaries(botIdentityId: string): string[];
+}
+
+/**
+ * Role-based procurement + benefits distribution.
+ * Serves: DOGE, government procurement, benefits distribution programs.
+ *
+ * @example
+ * ```typescript
+ * const gov = new GovernmentComplianceKit(inv);
+ * const agency = await gov.setupAgency({
+ *   name: 'DOT',
+ *   identity: { type: 'service', owner: '0xGov', label: 'Dept-of-Transportation' },
+ *   roles: [
+ *     { name: 'officer', maxSpend: '100000', allowedActions: ['approve', 'procure', 'audit'] },
+ *     { name: 'vendor', maxSpend: '0', allowedActions: ['bid', 'deliver', 'invoice'] },
+ *   ],
+ *   agencyCap: '10000000',
+ * });
+ * ```
+ */
+
+/** Agency role with permission matrix */
+interface AgencyRole {
+    /** Role name (e.g., 'procurement-officer', 'auditor', 'vendor') */
+    name: string;
+    /** Maximum spending authority */
+    maxSpend: string;
+    /** Allowed actions */
+    allowedActions: string[];
+    /** Approval required above this amount */
+    approvalThreshold?: string;
+}
+/** Options for setting up an agency */
+interface SetupAgencyOptions {
+    /** Agency name */
+    name: string;
+    /** Agency identity details */
+    identity: {
+        type: 'service';
+        owner: string;
+        label: string;
+        metadata?: Record<string, unknown>;
+    };
+    /** Role definitions */
+    roles: AgencyRole[];
+    /** Agency-wide spending cap */
+    agencyCap: string;
+}
+/** Agency setup result */
+interface AgencySetupResult {
+    /** Agency identity */
+    identity: Identity;
+    /** Agency-wide policy */
+    policy: SpecPolicy;
+    /** Role policies */
+    rolePolicies: Map<string, SpecPolicy>;
+}
+/** Milestone for escrow release */
+interface Milestone {
+    /** Milestone description */
+    description: string;
+    /** Amount to release on completion */
+    amount: string;
+    /** Verifier identity ID */
+    verifier: string;
+}
+/** Milestone escrow result */
+interface MilestoneEscrowResult {
+    /** Created escrow */
+    escrow: EscrowContract;
+    /** Policy for milestone verification */
+    policy: SpecPolicy;
+    /** Milestones registered */
+    milestones: Milestone[];
+}
+/** Benefits distribution options */
+interface DistributeBenefitsOptions {
+    /** Program name */
+    program: string;
+    /** Recipient identity IDs */
+    recipients: string[];
+    /** Amount per recipient */
+    amountPerRecipient: string;
+    /** Maximum total distribution */
+    maxTotal: string;
+    /** Require eligibility verification */
+    requireEligibility?: boolean;
+}
+/** Distribution result */
+interface DistributionResult {
+    /** Number of successful distributions */
+    successCount: number;
+    /** Total amount distributed */
+    totalDistributed: string;
+    /** Ledger entries for audit trail */
+    auditEntries: string[];
+    /** Failed distributions */
+    failures: Array<{
+        recipientId: string;
+        reason: string;
+    }>;
+}
+/**
+ * GovernmentComplianceKit — role-based procurement + benefits distribution.
+ */
+declare class GovernmentComplianceKit {
+    private readonly client;
+    constructor(client: Invariance);
+    /**
+     * Register an agency identity with role-based permission matrix.
+     */
+    setupAgency(opts: SetupAgencyOptions): Promise<AgencySetupResult>;
+    /**
+     * Create milestone-based escrow for procurement contracts.
+     */
+    milestoneEscrow(contractName: string, totalAmount: string, milestones: Milestone[], signers: string[], threshold: number): Promise<MilestoneEscrowResult>;
+    /**
+     * Distribute benefits with eligibility gates and per-citizen caps.
+     */
+    distributeBenefits(opts: DistributeBenefitsOptions): Promise<DistributionResult>;
+    /**
+     * Create immutable compliance attestation.
+     */
+    complianceAttestation(agencyIdentityId: string, regulation: string, details: Record<string, unknown>): Promise<{
+        txHash: string;
+    }>;
+}
+
+/**
+ * Agent/user relationship tracking via attestations.
+ * BFS traversal of social connections for trust graphs.
+ *
+ * @example
+ * ```typescript
+ * const graph = new SocialGraphAdapter(inv);
+ * await graph.linkAgents('identity-a', 'identity-b', 'trusts', 0.9);
+ * const trust = graph.getTrustGraph('identity-a', 3);
+ * ```
+ */
+
+/** A link between two identities */
+interface SocialLink {
+    /** Source identity ID */
+    from: string;
+    /** Target identity ID */
+    to: string;
+    /** Relationship type (e.g., 'trusts', 'delegates-to', 'collaborates-with') */
+    relationship: string;
+    /** Link strength (0.0 - 1.0) */
+    strength: number;
+    /** When the link was created */
+    createdAt: number;
+    /** Transaction hash of the attestation */
+    txHash: string;
+}
+/** Trust graph node */
+interface TrustNode {
+    /** Identity ID */
+    identityId: string;
+    /** Distance from the origin (in hops) */
+    depth: number;
+    /** Aggregated trust score at this depth */
+    trustScore: number;
+    /** Incoming links */
+    incomingLinks: SocialLink[];
+}
+/** Trust graph result */
+interface TrustGraph {
+    /** Origin identity */
+    origin: string;
+    /** All reachable nodes */
+    nodes: TrustNode[];
+    /** Total edges traversed */
+    edgeCount: number;
+    /** Maximum depth reached */
+    maxDepth: number;
+}
+/**
+ * SocialGraphAdapter — agent/user relationship tracking and trust graph traversal.
+ */
+declare class SocialGraphAdapter {
+    private readonly client;
+    private readonly adjacency;
+    constructor(client: Invariance);
+    /**
+     * Create a link between two identities with on-chain attestation.
+     */
+    linkAgents(fromId: string, toId: string, relationship: string, strength: number): Promise<SocialLink>;
+    /**
+     * Remove a link between two identities.
+     */
+    unlinkAgents(fromId: string, toId: string, relationship: string): boolean;
+    /**
+     * Get direct links from an identity.
+     */
+    getLinks(identityId: string): SocialLink[];
+    /**
+     * BFS traversal to build a trust graph from an origin identity.
+     */
+    getTrustGraph(origin: string, maxDepth?: number, minStrength?: number): TrustGraph;
+    /**
+     * Get mutual connections between two identities.
+     */
+    getMutualConnections(idA: string, idB: string): string[];
+}
+
+export { type AccessLogEntry, type ActionContext, type ActionCountResult, type AfterActionResult, type AgencyRole, type AgencySetupResult, type AggregatedReputation, type AggregationWeights, type AnalyticsTimeframe, AtomicVerifier, type AttestationInput, type AuditOptions, type AuditReport, AuditTrail, type AutoBatchConfig, AutoBatchedEventLedgerCompact, BCIIntentVerifier, type BCISignal, type BCIVerificationResult, type BalanceInfo, type BatchAgentOptions, BatchExecutor, type BatchOptions, type BatchRegisterEntry, type BatchRegisterOptions, type BatchResult, type BeforeActionResult, type BuiltInTemplate, type ChainId, type CompleteHireOptions, type ConfidenceThresholds, type ConnectOptions, ContractFactory, type CostSummaryResult, type CreateMultiSigOptions, type CreateWalletOptions, type CrewMember, type CrewRole, type CrewSetupResult, CrossChainEscrow, type CrossChainEscrowOptions, type CrossChainEscrowResult, type DeferredOperation, type DelegateOptions, type DelegateResult, type DistributeBenefitsOptions, type DistributionResult, type ERC8004AgentIdentity, InvarianceBridge as ERC8004Bridge, type ERC8004Config, ERC8004Error, type ERC8004Feedback, ERC8004Manager, type ERC8004Metadata, type ERC8004RegistryAddresses, type ERC8004ReputationSummary, type ERC8004ValidationStatus, type ERC8004ValidationSummary, type EscrowListFilters, EscrowManager, type EscrowStateChangeCallback, type EstimateGasOptions, type EvaluateOptions, EventLedger, EventLedgerCompact, type ExecuteAndLogOptions, type ExecuteAndLogResult, type ExternalReputationSignal, type ExternalScore, type ExtractionLog, type FeaturedOptions, type FundOptions, GasManager, type GateActionOptions, type GateActionResult, type GiveFeedbackOptions, GovernmentComplianceKit, type HireAndFundOptions, type HireAndReviewOptions, type HireAndReviewResult, type HireWithEscrowOptions, IdentityGatekeeper, type IdentityListFilters, IdentityManager, type IntentHistoryFilters, IntentProtocol, Invariance, InvarianceError, InvarianceEventEmitter, type InvarianceEvents, LedgerAnalytics, type LedgerStreamCallback, type LinkedIdentity, MEVComplianceKit, MarketplaceKit, MarketplacePlugin, type Milestone, type MilestoneEscrowResult, MultiAgentComposer, type PayForActionOptions, type PaymentEstimate, type PaymentHistoryFilters, type PaymentReceipt, type PaymentVerification, PipelineBuilder, type PipelineResult, type PipelineStep, PolicyEngine, type PolicyListFilters, type PolicyTemplate, type PolicyViolationCallback, type ProofData, type PublishAgentOptions, type PublishResult, type PushFeedbackOptions, type QuickSetupOptions, type QuickSetupResult, type RecurringPaymentOptions, type RegisterBotOptions, type RegisteredBot, type ReleaseOptions, ReputationBridge, ReputationEngine, type ReputationSummaryFilterOptions, type RetryConfig, type RetryResult, type ReviewList, type ReviewQueryOptions, RuntimeHookAdapter, type RuntimeHooks, SDK_VERSION, type ScoreHistoryOptions, SessionContext, type SessionOptions, type SetupAgencyOptions, type SetupCrewOptions, type SetupRateLimitedAgentOptions, SocialGraphAdapter, type SocialLink, type SuccessRateResult, Telemetry, type TrustGraph, type TrustNode, type UpdateIdentityOptions, type UpdateListingOptions, type ValidationRequestOptions, type ValidationResponseOptions, type ValidationSummaryFilterOptions, type VerificationCredential, Verifier, type VerifyActionOptions, type VerifyAndGateOptions, type VerifyProxy, type ViolationResult, type WalletInfo, WalletManager, type WalletProvider, X402Manager, type X402Settings, getERC8004Addresses, isERC8004Supported, verifyWebhookSignature };