@t402/streaming-payments 1.0.0-beta.1

package/dist/settlement/index.d.ts

@@ -0,0 +1,867 @@
+import { z } from 'zod';
+
+/**
+ * Settlement state
+ */
+declare const SettlementState: z.ZodEnum<["pending", "in_progress", "challenging", "disputed", "finalizing", "completed", "failed"]>;
+type SettlementState = z.infer<typeof SettlementState>;
+/**
+ * Checkpoint type
+ */
+declare const CheckpointType: z.ZodEnum<["periodic", "manual", "balance", "pre_close", "dispute"]>;
+type CheckpointType = z.infer<typeof CheckpointType>;
+/**
+ * Settlement checkpoint - extends channel checkpoint with settlement data
+ */
+declare const SettlementCheckpoint: z.ZodObject<{
+    id: z.ZodString;
+    channelId: z.ZodString;
+    sequence: z.ZodNumber;
+    type: z.ZodEnum<["periodic", "manual", "balance", "pre_close", "dispute"]>;
+    payerBalance: z.ZodString;
+    payeeBalance: z.ZodString;
+    totalStreamed: z.ZodString;
+    payerSignature: z.ZodString;
+    payeeSignature: z.ZodOptional<z.ZodString>;
+    stateHash: z.ZodString;
+    merkleRoot: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodNumber;
+    expiresAt: z.ZodOptional<z.ZodNumber>;
+    txHash: z.ZodOptional<z.ZodString>;
+    blockNumber: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: "balance" | "dispute" | "periodic" | "manual" | "pre_close";
+    channelId: string;
+    sequence: number;
+    payerSignature: string;
+    id: string;
+    createdAt: number;
+    totalStreamed: string;
+    payerBalance: string;
+    payeeBalance: string;
+    stateHash: string;
+    payeeSignature?: string | undefined;
+    txHash?: string | undefined;
+    blockNumber?: number | undefined;
+    expiresAt?: number | undefined;
+    merkleRoot?: string | undefined;
+}, {
+    type: "balance" | "dispute" | "periodic" | "manual" | "pre_close";
+    channelId: string;
+    sequence: number;
+    payerSignature: string;
+    id: string;
+    createdAt: number;
+    totalStreamed: string;
+    payerBalance: string;
+    payeeBalance: string;
+    stateHash: string;
+    payeeSignature?: string | undefined;
+    txHash?: string | undefined;
+    blockNumber?: number | undefined;
+    expiresAt?: number | undefined;
+    merkleRoot?: string | undefined;
+}>;
+type SettlementCheckpoint = z.infer<typeof SettlementCheckpoint>;
+/**
+ * Settlement request
+ */
+declare const SettlementRequest: z.ZodObject<{
+    channelId: z.ZodString;
+    initiator: z.ZodString;
+    finalCheckpoint: z.ZodObject<{
+        id: z.ZodString;
+        channelId: z.ZodString;
+        sequence: z.ZodNumber;
+        type: z.ZodEnum<["periodic", "manual", "balance", "pre_close", "dispute"]>;
+        payerBalance: z.ZodString;
+        payeeBalance: z.ZodString;
+        totalStreamed: z.ZodString;
+        payerSignature: z.ZodString;
+        payeeSignature: z.ZodOptional<z.ZodString>;
+        stateHash: z.ZodString;
+        merkleRoot: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodNumber;
+        expiresAt: z.ZodOptional<z.ZodNumber>;
+        txHash: z.ZodOptional<z.ZodString>;
+        blockNumber: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: "balance" | "dispute" | "periodic" | "manual" | "pre_close";
+        channelId: string;
+        sequence: number;
+        payerSignature: string;
+        id: string;
+        createdAt: number;
+        totalStreamed: string;
+        payerBalance: string;
+        payeeBalance: string;
+        stateHash: string;
+        payeeSignature?: string | undefined;
+        txHash?: string | undefined;
+        blockNumber?: number | undefined;
+        expiresAt?: number | undefined;
+        merkleRoot?: string | undefined;
+    }, {
+        type: "balance" | "dispute" | "periodic" | "manual" | "pre_close";
+        channelId: string;
+        sequence: number;
+        payerSignature: string;
+        id: string;
+        createdAt: number;
+        totalStreamed: string;
+        payerBalance: string;
+        payeeBalance: string;
+        stateHash: string;
+        payeeSignature?: string | undefined;
+        txHash?: string | undefined;
+        blockNumber?: number | undefined;
+        expiresAt?: number | undefined;
+        merkleRoot?: string | undefined;
+    }>;
+    reason: z.ZodEnum<["mutual", "unilateral", "timeout", "dispute_resolution"]>;
+    signature: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    channelId: string;
+    initiator: string;
+    reason: "mutual" | "unilateral" | "timeout" | "dispute_resolution";
+    finalCheckpoint: {
+        type: "balance" | "dispute" | "periodic" | "manual" | "pre_close";
+        channelId: string;
+        sequence: number;
+        payerSignature: string;
+        id: string;
+        createdAt: number;
+        totalStreamed: string;
+        payerBalance: string;
+        payeeBalance: string;
+        stateHash: string;
+        payeeSignature?: string | undefined;
+        txHash?: string | undefined;
+        blockNumber?: number | undefined;
+        expiresAt?: number | undefined;
+        merkleRoot?: string | undefined;
+    };
+    signature: string;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    channelId: string;
+    initiator: string;
+    reason: "mutual" | "unilateral" | "timeout" | "dispute_resolution";
+    finalCheckpoint: {
+        type: "balance" | "dispute" | "periodic" | "manual" | "pre_close";
+        channelId: string;
+        sequence: number;
+        payerSignature: string;
+        id: string;
+        createdAt: number;
+        totalStreamed: string;
+        payerBalance: string;
+        payeeBalance: string;
+        stateHash: string;
+        payeeSignature?: string | undefined;
+        txHash?: string | undefined;
+        blockNumber?: number | undefined;
+        expiresAt?: number | undefined;
+        merkleRoot?: string | undefined;
+    };
+    signature: string;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+type SettlementRequest = z.infer<typeof SettlementRequest>;
+/**
+ * Settlement result
+ */
+declare const SettlementResult: z.ZodObject<{
+    success: z.ZodBoolean;
+    settlementId: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+    finalBalances: z.ZodOptional<z.ZodObject<{
+        payer: z.ZodString;
+        payee: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        payer: string;
+        payee: string;
+    }, {
+        payer: string;
+        payee: string;
+    }>>;
+    txHash: z.ZodOptional<z.ZodString>;
+    timestamp: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    timestamp: number;
+    success: boolean;
+    txHash?: string | undefined;
+    error?: string | undefined;
+    settlementId?: string | undefined;
+    finalBalances?: {
+        payer: string;
+        payee: string;
+    } | undefined;
+}, {
+    timestamp: number;
+    success: boolean;
+    txHash?: string | undefined;
+    error?: string | undefined;
+    settlementId?: string | undefined;
+    finalBalances?: {
+        payer: string;
+        payee: string;
+    } | undefined;
+}>;
+type SettlementResult = z.infer<typeof SettlementResult>;
+/**
+ * Dispute reason
+ */
+declare const DisputeReason: z.ZodEnum<["invalid_checkpoint", "stale_state", "balance_mismatch", "unauthorized_close", "fraud", "other"]>;
+type DisputeReason = z.infer<typeof DisputeReason>;
+/**
+ * Dispute evidence
+ */
+declare const DisputeEvidence: z.ZodObject<{
+    type: z.ZodEnum<["checkpoint", "signature", "transaction", "state_proof"]>;
+    data: z.ZodString;
+    description: z.ZodString;
+    timestamp: z.ZodNumber;
+    verified: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: "signature" | "checkpoint" | "transaction" | "state_proof";
+    timestamp: number;
+    data: string;
+    description: string;
+    verified: boolean;
+}, {
+    type: "signature" | "checkpoint" | "transaction" | "state_proof";
+    timestamp: number;
+    data: string;
+    description: string;
+    verified?: boolean | undefined;
+}>;
+type DisputeEvidence = z.infer<typeof DisputeEvidence>;
+/**
+ * Dispute record
+ */
+declare const Dispute: z.ZodObject<{
+    id: z.ZodString;
+    channelId: z.ZodString;
+    initiator: z.ZodString;
+    respondent: z.ZodString;
+    reason: z.ZodEnum<["invalid_checkpoint", "stale_state", "balance_mismatch", "unauthorized_close", "fraud", "other"]>;
+    description: z.ZodString;
+    claimedPayerBalance: z.ZodString;
+    claimedPayeeBalance: z.ZodString;
+    claimedCheckpoint: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        channelId: z.ZodString;
+        sequence: z.ZodNumber;
+        type: z.ZodEnum<["periodic", "manual", "balance", "pre_close", "dispute"]>;
+        payerBalance: z.ZodString;
+        payeeBalance: z.ZodString;
+        totalStreamed: z.ZodString;
+        payerSignature: z.ZodString;
+        payeeSignature: z.ZodOptional<z.ZodString>;
+        stateHash: z.ZodString;
+        merkleRoot: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodNumber;
+        expiresAt: z.ZodOptional<z.ZodNumber>;
+        txHash: z.ZodOptional<z.ZodString>;
+        blockNumber: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: "balance" | "dispute" | "periodic" | "manual" | "pre_close";
+        channelId: string;
+        sequence: number;
+        payerSignature: string;
+        id: string;
+        createdAt: number;
+        totalStreamed: string;
+        payerBalance: string;
+        payeeBalance: string;
+        stateHash: string;
+        payeeSignature?: string | undefined;
+        txHash?: string | undefined;
+        blockNumber?: number | undefined;
+        expiresAt?: number | undefined;
+        merkleRoot?: string | undefined;
+    }, {
+        type: "balance" | "dispute" | "periodic" | "manual" | "pre_close";
+        channelId: string;
+        sequence: number;
+        payerSignature: string;
+        id: string;
+        createdAt: number;
+        totalStreamed: string;
+        payerBalance: string;
+        payeeBalance: string;
+        stateHash: string;
+        payeeSignature?: string | undefined;
+        txHash?: string | undefined;
+        blockNumber?: number | undefined;
+        expiresAt?: number | undefined;
+        merkleRoot?: string | undefined;
+    }>>;
+    evidence: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<["checkpoint", "signature", "transaction", "state_proof"]>;
+        data: z.ZodString;
+        description: z.ZodString;
+        timestamp: z.ZodNumber;
+        verified: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        type: "signature" | "checkpoint" | "transaction" | "state_proof";
+        timestamp: number;
+        data: string;
+        description: string;
+        verified: boolean;
+    }, {
+        type: "signature" | "checkpoint" | "transaction" | "state_proof";
+        timestamp: number;
+        data: string;
+        description: string;
+        verified?: boolean | undefined;
+    }>, "many">;
+    responseEvidence: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<["checkpoint", "signature", "transaction", "state_proof"]>;
+        data: z.ZodString;
+        description: z.ZodString;
+        timestamp: z.ZodNumber;
+        verified: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        type: "signature" | "checkpoint" | "transaction" | "state_proof";
+        timestamp: number;
+        data: string;
+        description: string;
+        verified: boolean;
+    }, {
+        type: "signature" | "checkpoint" | "transaction" | "state_proof";
+        timestamp: number;
+        data: string;
+        description: string;
+        verified?: boolean | undefined;
+    }>, "many">>;
+    status: z.ZodEnum<["pending", "under_review", "resolved", "rejected", "timeout"]>;
+    resolution: z.ZodOptional<z.ZodObject<{
+        winner: z.ZodOptional<z.ZodString>;
+        finalPayerBalance: z.ZodString;
+        finalPayeeBalance: z.ZodString;
+        reason: z.ZodString;
+        timestamp: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        timestamp: number;
+        reason: string;
+        finalPayerBalance: string;
+        finalPayeeBalance: string;
+        winner?: string | undefined;
+    }, {
+        timestamp: number;
+        reason: string;
+        finalPayerBalance: string;
+        finalPayeeBalance: string;
+        winner?: string | undefined;
+    }>>;
+    createdAt: z.ZodNumber;
+    responseDeadline: z.ZodNumber;
+    resolutionDeadline: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    status: "timeout" | "pending" | "resolved" | "rejected" | "under_review";
+    channelId: string;
+    id: string;
+    createdAt: number;
+    initiator: string;
+    reason: "invalid_checkpoint" | "stale_state" | "balance_mismatch" | "unauthorized_close" | "fraud" | "other";
+    evidence: {
+        type: "signature" | "checkpoint" | "transaction" | "state_proof";
+        timestamp: number;
+        data: string;
+        description: string;
+        verified: boolean;
+    }[];
+    description: string;
+    respondent: string;
+    claimedPayerBalance: string;
+    claimedPayeeBalance: string;
+    responseDeadline: number;
+    resolutionDeadline: number;
+    resolution?: {
+        timestamp: number;
+        reason: string;
+        finalPayerBalance: string;
+        finalPayeeBalance: string;
+        winner?: string | undefined;
+    } | undefined;
+    claimedCheckpoint?: {
+        type: "balance" | "dispute" | "periodic" | "manual" | "pre_close";
+        channelId: string;
+        sequence: number;
+        payerSignature: string;
+        id: string;
+        createdAt: number;
+        totalStreamed: string;
+        payerBalance: string;
+        payeeBalance: string;
+        stateHash: string;
+        payeeSignature?: string | undefined;
+        txHash?: string | undefined;
+        blockNumber?: number | undefined;
+        expiresAt?: number | undefined;
+        merkleRoot?: string | undefined;
+    } | undefined;
+    responseEvidence?: {
+        type: "signature" | "checkpoint" | "transaction" | "state_proof";
+        timestamp: number;
+        data: string;
+        description: string;
+        verified: boolean;
+    }[] | undefined;
+}, {
+    status: "timeout" | "pending" | "resolved" | "rejected" | "under_review";
+    channelId: string;
+    id: string;
+    createdAt: number;
+    initiator: string;
+    reason: "invalid_checkpoint" | "stale_state" | "balance_mismatch" | "unauthorized_close" | "fraud" | "other";
+    evidence: {
+        type: "signature" | "checkpoint" | "transaction" | "state_proof";
+        timestamp: number;
+        data: string;
+        description: string;
+        verified?: boolean | undefined;
+    }[];
+    description: string;
+    respondent: string;
+    claimedPayerBalance: string;
+    claimedPayeeBalance: string;
+    responseDeadline: number;
+    resolutionDeadline: number;
+    resolution?: {
+        timestamp: number;
+        reason: string;
+        finalPayerBalance: string;
+        finalPayeeBalance: string;
+        winner?: string | undefined;
+    } | undefined;
+    claimedCheckpoint?: {
+        type: "balance" | "dispute" | "periodic" | "manual" | "pre_close";
+        channelId: string;
+        sequence: number;
+        payerSignature: string;
+        id: string;
+        createdAt: number;
+        totalStreamed: string;
+        payerBalance: string;
+        payeeBalance: string;
+        stateHash: string;
+        payeeSignature?: string | undefined;
+        txHash?: string | undefined;
+        blockNumber?: number | undefined;
+        expiresAt?: number | undefined;
+        merkleRoot?: string | undefined;
+    } | undefined;
+    responseEvidence?: {
+        type: "signature" | "checkpoint" | "transaction" | "state_proof";
+        timestamp: number;
+        data: string;
+        description: string;
+        verified?: boolean | undefined;
+    }[] | undefined;
+}>;
+type Dispute = z.infer<typeof Dispute>;
+/**
+ * Settlement configuration
+ */
+declare const SettlementConfig: z.ZodObject<{
+    challengePeriod: z.ZodDefault<z.ZodNumber>;
+    disputeResponsePeriod: z.ZodDefault<z.ZodNumber>;
+    disputeResolutionPeriod: z.ZodDefault<z.ZodNumber>;
+    minCheckpointInterval: z.ZodDefault<z.ZodNumber>;
+    maxCheckpointsStored: z.ZodDefault<z.ZodNumber>;
+    settlementFee: z.ZodDefault<z.ZodString>;
+    disputeBond: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    challengePeriod: number;
+    settlementFee: string;
+    disputeResponsePeriod: number;
+    disputeResolutionPeriod: number;
+    minCheckpointInterval: number;
+    maxCheckpointsStored: number;
+    disputeBond: string;
+}, {
+    challengePeriod?: number | undefined;
+    settlementFee?: string | undefined;
+    disputeResponsePeriod?: number | undefined;
+    disputeResolutionPeriod?: number | undefined;
+    minCheckpointInterval?: number | undefined;
+    maxCheckpointsStored?: number | undefined;
+    disputeBond?: string | undefined;
+}>;
+type SettlementConfig = z.infer<typeof SettlementConfig>;
+/**
+ * On-chain settlement data
+ */
+declare const OnChainSettlement: z.ZodObject<{
+    channelId: z.ZodString;
+    settlementId: z.ZodString;
+    txHash: z.ZodString;
+    blockNumber: z.ZodNumber;
+    payerReceived: z.ZodString;
+    payeeReceived: z.ZodString;
+    fee: z.ZodString;
+    timestamp: z.ZodNumber;
+    finalized: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    channelId: string;
+    timestamp: number;
+    txHash: string;
+    blockNumber: number;
+    settlementId: string;
+    payerReceived: string;
+    payeeReceived: string;
+    fee: string;
+    finalized: boolean;
+}, {
+    channelId: string;
+    timestamp: number;
+    txHash: string;
+    blockNumber: number;
+    settlementId: string;
+    payerReceived: string;
+    payeeReceived: string;
+    fee: string;
+    finalized: boolean;
+}>;
+type OnChainSettlement = z.infer<typeof OnChainSettlement>;
+
+/**
+ * Checkpoint manager configuration
+ */
+interface CheckpointManagerConfig {
+    autoCheckpoint?: boolean;
+    intervalSeconds?: number;
+    balanceThreshold?: string;
+    onCheckpoint?: (checkpoint: SettlementCheckpoint) => void;
+}
+/**
+ * Checkpoint creation request
+ */
+interface CheckpointRequest {
+    channelId: string;
+    sequence: number;
+    payerBalance: string;
+    payeeBalance: string;
+    totalStreamed: string;
+    type?: CheckpointType;
+    payerSignature: string;
+    payeeSignature?: string;
+}
+/**
+ * Checkpoint manager for creating and validating checkpoints
+ */
+declare class CheckpointManager {
+    private checkpoints;
+    private config;
+    private settlementConfig;
+    private lastCheckpointTime;
+    constructor(settlementConfig: SettlementConfig, config?: CheckpointManagerConfig);
+    /**
+     * Create a new checkpoint
+     */
+    create(request: CheckpointRequest): SettlementCheckpoint;
+    /**
+     * Get latest checkpoint for channel
+     */
+    getLatest(channelId: string): SettlementCheckpoint | undefined;
+    /**
+     * Get checkpoint by sequence
+     */
+    getBySequence(channelId: string, sequence: number): SettlementCheckpoint | undefined;
+    /**
+     * Get all checkpoints for channel
+     */
+    getAll(channelId: string): SettlementCheckpoint[];
+    /**
+     * Validate checkpoint
+     */
+    validate(checkpoint: SettlementCheckpoint): {
+        valid: boolean;
+        errors: string[];
+    };
+    /**
+     * Compare two checkpoints
+     */
+    compare(a: SettlementCheckpoint, b: SettlementCheckpoint): {
+        isNewer: boolean;
+        balanceDifference: {
+            payer: string;
+            payee: string;
+        };
+    };
+    /**
+     * Check if checkpoint is needed
+     */
+    needsCheckpoint(channelId: string, currentPayeeBalance: string): {
+        needed: boolean;
+        reason: string;
+    };
+    /**
+     * Build merkle root from checkpoint history
+     */
+    buildMerkleRoot(channelId: string): string;
+    /**
+     * Verify checkpoint is in merkle tree
+     */
+    verifyMerkleProof(checkpoint: SettlementCheckpoint, merkleRoot: string, _proof: string[]): boolean;
+    /**
+     * Export checkpoints for backup
+     */
+    export(channelId: string): string;
+    /**
+     * Import checkpoints from backup
+     */
+    import(data: string): {
+        success: boolean;
+        imported: number;
+    };
+    /**
+     * Clear checkpoints for channel
+     */
+    clear(channelId: string): void;
+    private generateCheckpointId;
+    private generateStateHash;
+    private hashArray;
+    private pruneCheckpoints;
+}
+/**
+ * Sign checkpoint data
+ */
+declare function signCheckpoint(checkpoint: SettlementCheckpoint, _privateKey: string): string;
+/**
+ * Verify checkpoint signature
+ */
+declare function verifyCheckpointSignature(_checkpoint: SettlementCheckpoint, signature: string, _publicKey: string): boolean;
+
+/**
+ * Final settlement manager configuration
+ */
+interface FinalSettlementConfig {
+    autoFinalize?: boolean;
+    retryAttempts?: number;
+    retryDelayMs?: number;
+}
+/**
+ * Settlement status
+ */
+interface SettlementStatus {
+    state: SettlementState;
+    channelId: string;
+    initiator: string;
+    checkpoint: SettlementCheckpoint;
+    challengeDeadline: number;
+    finalizedAt?: number;
+    txHash?: string;
+    error?: string;
+}
+/**
+ * Final settlement manager
+ */
+declare class FinalSettlementManager {
+    private settlements;
+    private checkpointManager;
+    private settlementConfig;
+    private onChainSettlements;
+    constructor(checkpointManager: CheckpointManager, settlementConfig: SettlementConfig, _config?: FinalSettlementConfig);
+    /**
+     * Initiate settlement
+     */
+    initiate(request: SettlementRequest): SettlementResult;
+    /**
+     * Process mutual settlement (both parties agree)
+     */
+    processMutual(channelId: string, payerSignature: string, payeeSignature: string, finalCheckpoint: SettlementCheckpoint): SettlementResult;
+    /**
+     * Check if challenge period has elapsed
+     */
+    canFinalize(channelId: string): {
+        canFinalize: boolean;
+        timeRemaining: number;
+    };
+    /**
+     * Finalize settlement after challenge period
+     */
+    finalize(channelId: string): SettlementResult;
+    /**
+     * Get settlement status
+     */
+    getStatus(channelId: string): SettlementStatus | undefined;
+    /**
+     * Get on-chain settlement
+     */
+    getOnChainSettlement(channelId: string): OnChainSettlement | undefined;
+    /**
+     * Cancel pending settlement (before challenge period ends)
+     */
+    cancel(channelId: string, canceller: string, reason: string): {
+        success: boolean;
+        error?: string;
+    };
+    /**
+     * Calculate settlement amounts
+     */
+    calculateSettlementAmounts(checkpoint: SettlementCheckpoint): {
+        payerReceives: string;
+        payeeReceives: string;
+        fee: string;
+        total: string;
+    };
+    /**
+     * Build settlement transaction data
+     */
+    buildSettlementTransaction(channelId: string): {
+        to: string;
+        data: string;
+        value: string;
+    } | null;
+    private validateRequest;
+    private transitionState;
+    private generateSettlementId;
+    private generateMockTxHash;
+}
+/**
+ * Estimate settlement gas cost
+ */
+declare function estimateSettlementGas(hasDispute: boolean, checkpointCount: number): string;
+/**
+ * Verify settlement transaction on-chain
+ */
+declare function verifySettlementOnChain(settlement: OnChainSettlement): {
+    verified: boolean;
+    error?: string;
+};
+
+/**
+ * Dispute manager configuration
+ */
+interface DisputeManagerConfig {
+    requireBond?: boolean;
+    autoResolve?: boolean;
+    notifyParties?: (dispute: Dispute, event: string) => void;
+}
+/**
+ * Dispute creation request
+ */
+interface DisputeRequest {
+    channelId: string;
+    initiator: string;
+    respondent: string;
+    reason: DisputeReason;
+    description: string;
+    claimedPayerBalance: string;
+    claimedPayeeBalance: string;
+    claimedCheckpoint?: SettlementCheckpoint;
+    evidence: DisputeEvidence[];
+    bond?: string;
+}
+/**
+ * Dispute response
+ */
+interface DisputeResponse {
+    disputeId: string;
+    responder: string;
+    counterClaim?: {
+        payerBalance: string;
+        payeeBalance: string;
+    };
+    evidence: DisputeEvidence[];
+    signature: string;
+}
+/**
+ * Dispute manager for handling payment disputes
+ */
+declare class DisputeManager {
+    private disputes;
+    private config;
+    private settlementConfig;
+    private checkpointManager;
+    constructor(checkpointManager: CheckpointManager, settlementConfig: SettlementConfig, config?: DisputeManagerConfig);
+    /**
+     * Raise a dispute
+     */
+    raise(request: DisputeRequest): {
+        success: boolean;
+        dispute?: Dispute;
+        error?: string;
+    };
+    /**
+     * Respond to a dispute
+     */
+    respond(response: DisputeResponse): {
+        success: boolean;
+        error?: string;
+    };
+    /**
+     * Resolve a dispute
+     */
+    resolve(disputeId: string, winner: string, finalPayerBalance: string, finalPayeeBalance: string, reason: string): {
+        success: boolean;
+        error?: string;
+    };
+    /**
+     * Reject a dispute
+     */
+    reject(disputeId: string, reason: string): {
+        success: boolean;
+        error?: string;
+    };
+    /**
+     * Handle timeout (no response)
+     */
+    handleTimeout(disputeId: string): {
+        success: boolean;
+        resolution?: Dispute['resolution'];
+    };
+    /**
+     * Get dispute by ID
+     */
+    get(disputeId: string): Dispute | undefined;
+    /**
+     * Get dispute by channel ID
+     */
+    getByChannel(channelId: string): Dispute | undefined;
+    /**
+     * Get all disputes
+     */
+    getAll(): Dispute[];
+    /**
+     * Get disputes by status
+     */
+    getByStatus(status: Dispute['status']): Dispute[];
+    /**
+     * Add evidence to existing dispute
+     */
+    addEvidence(disputeId: string, party: string, evidence: DisputeEvidence): {
+        success: boolean;
+        error?: string;
+    };
+    /**
+     * Evaluate dispute based on evidence
+     */
+    evaluateEvidence(disputeId: string): {
+        initiatorScore: number;
+        respondentScore: number;
+        recommendation: string;
+    };
+    private validateRequest;
+    private getEvidenceWeight;
+    private generateDisputeId;
+}
+/**
+ * Create evidence from checkpoint
+ */
+declare function createCheckpointEvidence(checkpoint: SettlementCheckpoint, description: string): DisputeEvidence;
+/**
+ * Create evidence from signature
+ */
+declare function createSignatureEvidence(signature: string, signedData: string, description: string): DisputeEvidence;
+/**
+ * Create evidence from transaction
+ */
+declare function createTransactionEvidence(txHash: string, description: string): DisputeEvidence;
+
+export { CheckpointManager, type CheckpointManagerConfig, type CheckpointRequest, CheckpointType, Dispute, DisputeEvidence, DisputeManager, type DisputeManagerConfig, DisputeReason, type DisputeRequest, type DisputeResponse, type FinalSettlementConfig, FinalSettlementManager, OnChainSettlement, SettlementCheckpoint, SettlementConfig, SettlementRequest, SettlementResult, SettlementState, type SettlementStatus, createCheckpointEvidence, createSignatureEvidence, createTransactionEvidence, estimateSettlementGas, signCheckpoint, verifyCheckpointSignature, verifySettlementOnChain };