@t402/streaming-payments 1.0.0-beta.1

package/dist/settlement/index.js

@@ -0,0 +1,1030 @@
+// src/settlement/types.ts
+import { z } from "zod";
+var SettlementState = z.enum([
+  "pending",
+  // Settlement not yet initiated
+  "in_progress",
+  // Settlement process started
+  "challenging",
+  // In challenge period
+  "disputed",
+  // Dispute raised
+  "finalizing",
+  // Finalizing on-chain
+  "completed",
+  // Successfully settled
+  "failed"
+  // Settlement failed
+]);
+var CheckpointType = z.enum([
+  "periodic",
+  // Regular interval checkpoint
+  "manual",
+  // Manually triggered
+  "balance",
+  // Triggered by balance threshold
+  "pre_close",
+  // Before channel close
+  "dispute"
+  // Checkpoint for dispute
+]);
+var SettlementCheckpoint = z.object({
+  id: z.string(),
+  channelId: z.string(),
+  sequence: z.number(),
+  type: CheckpointType,
+  // Balances
+  payerBalance: z.string(),
+  payeeBalance: z.string(),
+  totalStreamed: z.string(),
+  // Signatures
+  payerSignature: z.string(),
+  payeeSignature: z.string().optional(),
+  // Verification
+  stateHash: z.string(),
+  merkleRoot: z.string().optional(),
+  // Timing
+  createdAt: z.number(),
+  expiresAt: z.number().optional(),
+  // On-chain reference
+  txHash: z.string().optional(),
+  blockNumber: z.number().optional()
+});
+var SettlementRequest = z.object({
+  channelId: z.string(),
+  initiator: z.string(),
+  finalCheckpoint: SettlementCheckpoint,
+  reason: z.enum(["mutual", "unilateral", "timeout", "dispute_resolution"]),
+  signature: z.string(),
+  metadata: z.record(z.unknown()).optional()
+});
+var SettlementResult = z.object({
+  success: z.boolean(),
+  settlementId: z.string().optional(),
+  error: z.string().optional(),
+  finalBalances: z.object({
+    payer: z.string(),
+    payee: z.string()
+  }).optional(),
+  txHash: z.string().optional(),
+  timestamp: z.number()
+});
+var DisputeReason = z.enum([
+  "invalid_checkpoint",
+  // Checkpoint signature or data invalid
+  "stale_state",
+  // Challenger has newer valid state
+  "balance_mismatch",
+  // Balance doesn't match expected
+  "unauthorized_close",
+  // Unauthorized party initiated close
+  "fraud",
+  // Fraudulent activity detected
+  "other"
+  // Other reason
+]);
+var DisputeEvidence = z.object({
+  type: z.enum(["checkpoint", "signature", "transaction", "state_proof"]),
+  data: z.string(),
+  description: z.string(),
+  timestamp: z.number(),
+  verified: z.boolean().default(false)
+});
+var Dispute = z.object({
+  id: z.string(),
+  channelId: z.string(),
+  initiator: z.string(),
+  respondent: z.string(),
+  reason: DisputeReason,
+  description: z.string(),
+  // Claimed state
+  claimedPayerBalance: z.string(),
+  claimedPayeeBalance: z.string(),
+  claimedCheckpoint: SettlementCheckpoint.optional(),
+  // Evidence
+  evidence: z.array(DisputeEvidence),
+  responseEvidence: z.array(DisputeEvidence).optional(),
+  // Resolution
+  status: z.enum(["pending", "under_review", "resolved", "rejected", "timeout"]),
+  resolution: z.object({
+    winner: z.string().optional(),
+    finalPayerBalance: z.string(),
+    finalPayeeBalance: z.string(),
+    reason: z.string(),
+    timestamp: z.number()
+  }).optional(),
+  // Timing
+  createdAt: z.number(),
+  responseDeadline: z.number(),
+  resolutionDeadline: z.number()
+});
+var SettlementConfig = z.object({
+  challengePeriod: z.number().default(86400),
+  // 24 hours
+  disputeResponsePeriod: z.number().default(43200),
+  // 12 hours
+  disputeResolutionPeriod: z.number().default(172800),
+  // 48 hours
+  minCheckpointInterval: z.number().default(60),
+  // 60 seconds
+  maxCheckpointsStored: z.number().default(100),
+  settlementFee: z.string().default("0"),
+  disputeBond: z.string().default("0")
+  // Bond required to raise dispute
+});
+var OnChainSettlement = z.object({
+  channelId: z.string(),
+  settlementId: z.string(),
+  txHash: z.string(),
+  blockNumber: z.number(),
+  payerReceived: z.string(),
+  payeeReceived: z.string(),
+  fee: z.string(),
+  timestamp: z.number(),
+  finalized: z.boolean()
+});
+
+// src/settlement/checkpoint.ts
+var CheckpointManager = class {
+  checkpoints = /* @__PURE__ */ new Map();
+  config;
+  settlementConfig;
+  lastCheckpointTime = /* @__PURE__ */ new Map();
+  constructor(settlementConfig, config = {}) {
+    this.settlementConfig = settlementConfig;
+    this.config = {
+      autoCheckpoint: config.autoCheckpoint ?? false,
+      intervalSeconds: config.intervalSeconds ?? 3600,
+      balanceThreshold: config.balanceThreshold ?? "1000000",
+      onCheckpoint: config.onCheckpoint ?? (() => {
+      })
+    };
+  }
+  /**
+   * Create a new checkpoint
+   */
+  create(request) {
+    const now = Date.now();
+    const channelCheckpoints = this.checkpoints.get(request.channelId) ?? [];
+    const expectedSequence = channelCheckpoints.length;
+    if (request.sequence !== expectedSequence) {
+      throw new Error(`Invalid sequence: expected ${expectedSequence}, got ${request.sequence}`);
+    }
+    const lastTime = this.lastCheckpointTime.get(request.channelId) ?? 0;
+    const elapsed = (now - lastTime) / 1e3;
+    if (elapsed < this.settlementConfig.minCheckpointInterval && channelCheckpoints.length > 0) {
+      throw new Error(`Checkpoint interval too short: ${elapsed}s < ${this.settlementConfig.minCheckpointInterval}s`);
+    }
+    const stateHash = this.generateStateHash(request);
+    const checkpoint = {
+      id: this.generateCheckpointId(request.channelId, request.sequence),
+      channelId: request.channelId,
+      sequence: request.sequence,
+      type: request.type ?? "manual",
+      payerBalance: request.payerBalance,
+      payeeBalance: request.payeeBalance,
+      totalStreamed: request.totalStreamed,
+      payerSignature: request.payerSignature,
+      payeeSignature: request.payeeSignature,
+      stateHash,
+      createdAt: now
+    };
+    channelCheckpoints.push(checkpoint);
+    this.checkpoints.set(request.channelId, channelCheckpoints);
+    this.lastCheckpointTime.set(request.channelId, now);
+    this.pruneCheckpoints(request.channelId);
+    this.config.onCheckpoint(checkpoint);
+    return checkpoint;
+  }
+  /**
+   * Get latest checkpoint for channel
+   */
+  getLatest(channelId) {
+    const checkpoints = this.checkpoints.get(channelId);
+    if (!checkpoints || checkpoints.length === 0) return void 0;
+    return checkpoints[checkpoints.length - 1];
+  }
+  /**
+   * Get checkpoint by sequence
+   */
+  getBySequence(channelId, sequence) {
+    const checkpoints = this.checkpoints.get(channelId);
+    if (!checkpoints) return void 0;
+    return checkpoints.find((cp) => cp.sequence === sequence);
+  }
+  /**
+   * Get all checkpoints for channel
+   */
+  getAll(channelId) {
+    return [...this.checkpoints.get(channelId) ?? []];
+  }
+  /**
+   * Validate checkpoint
+   */
+  validate(checkpoint) {
+    const errors = [];
+    const payerBalance = BigInt(checkpoint.payerBalance);
+    const payeeBalance = BigInt(checkpoint.payeeBalance);
+    const totalStreamed = BigInt(checkpoint.totalStreamed);
+    if (payerBalance < 0n) {
+      errors.push("Payer balance cannot be negative");
+    }
+    if (payeeBalance < 0n) {
+      errors.push("Payee balance cannot be negative");
+    }
+    if (totalStreamed < 0n) {
+      errors.push("Total streamed cannot be negative");
+    }
+    if (payeeBalance !== totalStreamed) {
+      errors.push("Total streamed should equal payee balance");
+    }
+    if (!checkpoint.payerSignature) {
+      errors.push("Payer signature is required");
+    }
+    const expectedHash = this.generateStateHash({
+      channelId: checkpoint.channelId,
+      sequence: checkpoint.sequence,
+      payerBalance: checkpoint.payerBalance,
+      payeeBalance: checkpoint.payeeBalance,
+      totalStreamed: checkpoint.totalStreamed,
+      payerSignature: checkpoint.payerSignature
+    });
+    if (checkpoint.stateHash !== expectedHash) {
+      errors.push("State hash mismatch");
+    }
+    if (checkpoint.createdAt > Date.now()) {
+      errors.push("Checkpoint timestamp is in the future");
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  /**
+   * Compare two checkpoints
+   */
+  compare(a, b) {
+    const isNewer = a.sequence > b.sequence || a.sequence === b.sequence && a.createdAt > b.createdAt;
+    const payerDiff = BigInt(a.payerBalance) - BigInt(b.payerBalance);
+    const payeeDiff = BigInt(a.payeeBalance) - BigInt(b.payeeBalance);
+    return {
+      isNewer,
+      balanceDifference: {
+        payer: payerDiff.toString(),
+        payee: payeeDiff.toString()
+      }
+    };
+  }
+  /**
+   * Check if checkpoint is needed
+   */
+  needsCheckpoint(channelId, currentPayeeBalance) {
+    const lastCheckpoint = this.getLatest(channelId);
+    const now = Date.now();
+    if (!lastCheckpoint) {
+      return { needed: true, reason: "No existing checkpoint" };
+    }
+    const elapsed = (now - lastCheckpoint.createdAt) / 1e3;
+    if (elapsed >= this.config.intervalSeconds) {
+      return { needed: true, reason: "Interval elapsed" };
+    }
+    const balanceChange = BigInt(currentPayeeBalance) - BigInt(lastCheckpoint.payeeBalance);
+    if (balanceChange >= BigInt(this.config.balanceThreshold)) {
+      return { needed: true, reason: "Balance threshold exceeded" };
+    }
+    return { needed: false, reason: "" };
+  }
+  /**
+   * Build merkle root from checkpoint history
+   */
+  buildMerkleRoot(channelId) {
+    const checkpoints = this.checkpoints.get(channelId);
+    if (!checkpoints || checkpoints.length === 0) {
+      return "0x" + "0".repeat(64);
+    }
+    const hashes = checkpoints.map((cp) => cp.stateHash);
+    return this.hashArray(hashes);
+  }
+  /**
+   * Verify checkpoint is in merkle tree
+   */
+  verifyMerkleProof(checkpoint, merkleRoot, _proof) {
+    const channelRoot = this.buildMerkleRoot(checkpoint.channelId);
+    return channelRoot === merkleRoot;
+  }
+  /**
+   * Export checkpoints for backup
+   */
+  export(channelId) {
+    const checkpoints = this.checkpoints.get(channelId) ?? [];
+    return JSON.stringify({
+      channelId,
+      checkpoints,
+      exportedAt: Date.now()
+    });
+  }
+  /**
+   * Import checkpoints from backup
+   */
+  import(data) {
+    try {
+      const parsed = JSON.parse(data);
+      const { channelId, checkpoints } = parsed;
+      let imported = 0;
+      const existing = this.checkpoints.get(channelId) ?? [];
+      for (const cp of checkpoints) {
+        const validation = this.validate(cp);
+        if (validation.valid) {
+          const exists = existing.some((e) => e.sequence === cp.sequence);
+          if (!exists) {
+            existing.push(cp);
+            imported++;
+          }
+        }
+      }
+      existing.sort((a, b) => a.sequence - b.sequence);
+      this.checkpoints.set(channelId, existing);
+      return { success: true, imported };
+    } catch {
+      return { success: false, imported: 0 };
+    }
+  }
+  /**
+   * Clear checkpoints for channel
+   */
+  clear(channelId) {
+    this.checkpoints.delete(channelId);
+    this.lastCheckpointTime.delete(channelId);
+  }
+  generateCheckpointId(channelId, sequence) {
+    return `cp_${channelId.slice(-8)}_${sequence}_${Date.now().toString(36)}`;
+  }
+  generateStateHash(request) {
+    const data = [
+      request.channelId,
+      request.sequence.toString(),
+      request.payerBalance,
+      request.payeeBalance,
+      request.totalStreamed
+    ].join(":");
+    let hash = 0;
+    for (let i = 0; i < data.length; i++) {
+      const char = data.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return "0x" + Math.abs(hash).toString(16).padStart(64, "0");
+  }
+  hashArray(hashes) {
+    const combined = hashes.join("");
+    let hash = 0;
+    for (let i = 0; i < combined.length; i++) {
+      const char = combined.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return "0x" + Math.abs(hash).toString(16).padStart(64, "0");
+  }
+  pruneCheckpoints(channelId) {
+    const checkpoints = this.checkpoints.get(channelId);
+    if (!checkpoints) return;
+    const maxStored = this.settlementConfig.maxCheckpointsStored;
+    if (checkpoints.length <= maxStored) return;
+    const first = checkpoints[0];
+    const recent = checkpoints.slice(-(maxStored - 1));
+    this.checkpoints.set(channelId, [first, ...recent]);
+  }
+};
+function signCheckpoint(checkpoint, _privateKey) {
+  const dataToSign = [
+    checkpoint.channelId,
+    checkpoint.sequence.toString(),
+    checkpoint.payerBalance,
+    checkpoint.payeeBalance,
+    checkpoint.totalStreamed,
+    checkpoint.createdAt.toString()
+  ].join(":");
+  let hash = 0;
+  for (let i = 0; i < dataToSign.length; i++) {
+    const char = dataToSign.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return "0x" + Math.abs(hash).toString(16).padStart(128, "0");
+}
+function verifyCheckpointSignature(_checkpoint, signature, _publicKey) {
+  return signature.startsWith("0x") && signature.length === 130;
+}
+
+// src/settlement/final.ts
+var FinalSettlementManager = class {
+  settlements = /* @__PURE__ */ new Map();
+  checkpointManager;
+  settlementConfig;
+  onChainSettlements = /* @__PURE__ */ new Map();
+  constructor(checkpointManager, settlementConfig, _config = {}) {
+    this.checkpointManager = checkpointManager;
+    this.settlementConfig = settlementConfig;
+  }
+  /**
+   * Initiate settlement
+   */
+  initiate(request) {
+    const now = Date.now();
+    const validation = this.validateRequest(request);
+    if (!validation.valid) {
+      return {
+        success: false,
+        error: validation.errors.join(", "),
+        timestamp: now
+      };
+    }
+    const existing = this.settlements.get(request.channelId);
+    if (existing && existing.state !== "completed" && existing.state !== "failed") {
+      return {
+        success: false,
+        error: "Settlement already in progress",
+        timestamp: now
+      };
+    }
+    const settlementId = this.generateSettlementId(request.channelId);
+    const challengeDeadline = now + this.settlementConfig.challengePeriod * 1e3;
+    const status = {
+      state: "pending",
+      channelId: request.channelId,
+      initiator: request.initiator,
+      checkpoint: request.finalCheckpoint,
+      challengeDeadline
+    };
+    this.settlements.set(request.channelId, status);
+    this.transitionState(request.channelId, "in_progress");
+    return {
+      success: true,
+      settlementId,
+      finalBalances: {
+        payer: request.finalCheckpoint.payerBalance,
+        payee: request.finalCheckpoint.payeeBalance
+      },
+      timestamp: now
+    };
+  }
+  /**
+   * Process mutual settlement (both parties agree)
+   */
+  processMutual(channelId, payerSignature, payeeSignature, finalCheckpoint) {
+    const now = Date.now();
+    if (!payerSignature || !payeeSignature) {
+      return {
+        success: false,
+        error: "Both signatures required for mutual settlement",
+        timestamp: now
+      };
+    }
+    const mutualCheckpoint = {
+      ...finalCheckpoint,
+      payerSignature,
+      payeeSignature
+    };
+    const status = {
+      state: "finalizing",
+      channelId,
+      initiator: "mutual",
+      checkpoint: mutualCheckpoint,
+      challengeDeadline: now
+      // No challenge period for mutual
+    };
+    this.settlements.set(channelId, status);
+    return this.finalize(channelId);
+  }
+  /**
+   * Check if challenge period has elapsed
+   */
+  canFinalize(channelId) {
+    const status = this.settlements.get(channelId);
+    if (!status) {
+      return { canFinalize: false, timeRemaining: -1 };
+    }
+    if (status.state === "completed" || status.state === "failed") {
+      return { canFinalize: false, timeRemaining: 0 };
+    }
+    if (status.state === "disputed") {
+      return { canFinalize: false, timeRemaining: -1 };
+    }
+    const now = Date.now();
+    const timeRemaining = Math.max(0, status.challengeDeadline - now);
+    return {
+      canFinalize: timeRemaining === 0,
+      timeRemaining
+    };
+  }
+  /**
+   * Finalize settlement after challenge period
+   */
+  finalize(channelId) {
+    const now = Date.now();
+    const status = this.settlements.get(channelId);
+    if (!status) {
+      return {
+        success: false,
+        error: "No settlement found",
+        timestamp: now
+      };
+    }
+    const { canFinalize: canFinalizeNow, timeRemaining } = this.canFinalize(channelId);
+    if (!canFinalizeNow && status.state !== "finalizing") {
+      return {
+        success: false,
+        error: `Cannot finalize: ${timeRemaining}ms remaining in challenge period`,
+        timestamp: now
+      };
+    }
+    this.transitionState(channelId, "finalizing");
+    const settlementId = this.generateSettlementId(channelId);
+    const mockTxHash = this.generateMockTxHash(channelId);
+    const onChainSettlement = {
+      channelId,
+      settlementId,
+      txHash: mockTxHash,
+      blockNumber: Math.floor(Date.now() / 1e3),
+      payerReceived: status.checkpoint.payerBalance,
+      payeeReceived: status.checkpoint.payeeBalance,
+      fee: this.settlementConfig.settlementFee,
+      timestamp: now,
+      finalized: true
+    };
+    this.onChainSettlements.set(channelId, onChainSettlement);
+    this.transitionState(channelId, "completed");
+    status.finalizedAt = now;
+    status.txHash = mockTxHash;
+    return {
+      success: true,
+      settlementId,
+      finalBalances: {
+        payer: status.checkpoint.payerBalance,
+        payee: status.checkpoint.payeeBalance
+      },
+      txHash: mockTxHash,
+      timestamp: now
+    };
+  }
+  /**
+   * Get settlement status
+   */
+  getStatus(channelId) {
+    return this.settlements.get(channelId);
+  }
+  /**
+   * Get on-chain settlement
+   */
+  getOnChainSettlement(channelId) {
+    return this.onChainSettlements.get(channelId);
+  }
+  /**
+   * Cancel pending settlement (before challenge period ends)
+   */
+  cancel(channelId, canceller, reason) {
+    const status = this.settlements.get(channelId);
+    if (!status) {
+      return { success: false, error: "No settlement found" };
+    }
+    if (status.state !== "pending" && status.state !== "in_progress" && status.state !== "challenging") {
+      return { success: false, error: "Cannot cancel settlement in current state" };
+    }
+    if (status.initiator !== canceller && status.initiator !== "mutual") {
+      return { success: false, error: "Only initiator can cancel" };
+    }
+    this.transitionState(channelId, "failed");
+    status.error = `Cancelled: ${reason}`;
+    return { success: true };
+  }
+  /**
+   * Calculate settlement amounts
+   */
+  calculateSettlementAmounts(checkpoint) {
+    const payerBalance = BigInt(checkpoint.payerBalance);
+    const payeeBalance = BigInt(checkpoint.payeeBalance);
+    const fee = BigInt(this.settlementConfig.settlementFee);
+    const payerReceives = payerBalance > fee ? payerBalance - fee : 0n;
+    const payeeReceives = payeeBalance;
+    const total = payerReceives + payeeReceives + fee;
+    return {
+      payerReceives: payerReceives.toString(),
+      payeeReceives: payeeReceives.toString(),
+      fee: fee.toString(),
+      total: total.toString()
+    };
+  }
+  /**
+   * Build settlement transaction data
+   */
+  buildSettlementTransaction(channelId) {
+    const status = this.settlements.get(channelId);
+    if (!status) return null;
+    const amounts = this.calculateSettlementAmounts(status.checkpoint);
+    const methodId = "0x" + "settle".split("").map((c) => c.charCodeAt(0).toString(16)).join("").slice(0, 8);
+    const data = [
+      methodId,
+      channelId.replace(/^ch_/, "").padStart(64, "0"),
+      amounts.payerReceives.padStart(64, "0"),
+      amounts.payeeReceives.padStart(64, "0"),
+      status.checkpoint.payerSignature.replace("0x", "").padStart(128, "0")
+    ].join("");
+    return {
+      to: "0x" + "0".repeat(40),
+      // Contract address placeholder
+      data,
+      value: "0"
+    };
+  }
+  validateRequest(request) {
+    const errors = [];
+    const cpValidation = this.checkpointManager.validate(request.finalCheckpoint);
+    if (!cpValidation.valid) {
+      errors.push(...cpValidation.errors);
+    }
+    if (!request.signature) {
+      errors.push("Settlement signature is required");
+    }
+    const validReasons = ["mutual", "unilateral", "timeout", "dispute_resolution"];
+    if (!validReasons.includes(request.reason)) {
+      errors.push("Invalid settlement reason");
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  transitionState(channelId, newState) {
+    const status = this.settlements.get(channelId);
+    if (status) {
+      status.state = newState;
+    }
+  }
+  generateSettlementId(channelId) {
+    return `stl_${channelId.slice(-8)}_${Date.now().toString(36)}`;
+  }
+  generateMockTxHash(channelId) {
+    const data = channelId + Date.now().toString();
+    let hash = 0;
+    for (let i = 0; i < data.length; i++) {
+      const char = data.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return "0x" + Math.abs(hash).toString(16).padStart(64, "0");
+  }
+};
+function estimateSettlementGas(hasDispute, checkpointCount) {
+  const baseGas = 100000n;
+  const disputeGas = hasDispute ? 50000n : 0n;
+  const checkpointGas = BigInt(checkpointCount) * 5000n;
+  return (baseGas + disputeGas + checkpointGas).toString();
+}
+function verifySettlementOnChain(settlement) {
+  if (!settlement.txHash || !settlement.txHash.startsWith("0x")) {
+    return { verified: false, error: "Invalid transaction hash" };
+  }
+  if (!settlement.finalized) {
+    return { verified: false, error: "Settlement not finalized" };
+  }
+  return { verified: true };
+}
+
+// src/settlement/dispute.ts
+var DisputeManager = class {
+  disputes = /* @__PURE__ */ new Map();
+  config;
+  settlementConfig;
+  checkpointManager;
+  constructor(checkpointManager, settlementConfig, config = {}) {
+    this.checkpointManager = checkpointManager;
+    this.settlementConfig = settlementConfig;
+    this.config = {
+      requireBond: config.requireBond ?? true,
+      autoResolve: config.autoResolve ?? false,
+      notifyParties: config.notifyParties ?? (() => {
+      })
+    };
+  }
+  /**
+   * Raise a dispute
+   */
+  raise(request) {
+    const now = Date.now();
+    const validation = this.validateRequest(request);
+    if (!validation.valid) {
+      return { success: false, error: validation.errors.join(", ") };
+    }
+    const existingDispute = this.getByChannel(request.channelId);
+    if (existingDispute && existingDispute.status === "pending") {
+      return { success: false, error: "Dispute already pending for this channel" };
+    }
+    if (this.config.requireBond && this.settlementConfig.disputeBond !== "0") {
+      if (!request.bond || BigInt(request.bond) < BigInt(this.settlementConfig.disputeBond)) {
+        return {
+          success: false,
+          error: `Dispute bond of ${this.settlementConfig.disputeBond} required`
+        };
+      }
+    }
+    const disputeId = this.generateDisputeId(request.channelId);
+    const responseDeadline = now + this.settlementConfig.disputeResponsePeriod * 1e3;
+    const resolutionDeadline = now + this.settlementConfig.disputeResolutionPeriod * 1e3;
+    const dispute = {
+      id: disputeId,
+      channelId: request.channelId,
+      initiator: request.initiator,
+      respondent: request.respondent,
+      reason: request.reason,
+      description: request.description,
+      claimedPayerBalance: request.claimedPayerBalance,
+      claimedPayeeBalance: request.claimedPayeeBalance,
+      claimedCheckpoint: request.claimedCheckpoint,
+      evidence: request.evidence,
+      status: "pending",
+      createdAt: now,
+      responseDeadline,
+      resolutionDeadline
+    };
+    this.disputes.set(disputeId, dispute);
+    this.config.notifyParties(dispute, "raised");
+    return { success: true, dispute };
+  }
+  /**
+   * Respond to a dispute
+   */
+  respond(response) {
+    const dispute = this.disputes.get(response.disputeId);
+    if (!dispute) {
+      return { success: false, error: "Dispute not found" };
+    }
+    if (dispute.status !== "pending") {
+      return { success: false, error: "Dispute is not pending" };
+    }
+    if (response.responder !== dispute.respondent) {
+      return { success: false, error: "Only the respondent can respond" };
+    }
+    const now = Date.now();
+    if (now > dispute.responseDeadline) {
+      return { success: false, error: "Response deadline has passed" };
+    }
+    dispute.responseEvidence = response.evidence;
+    dispute.status = "under_review";
+    this.config.notifyParties(dispute, "responded");
+    return { success: true };
+  }
+  /**
+   * Resolve a dispute
+   */
+  resolve(disputeId, winner, finalPayerBalance, finalPayeeBalance, reason) {
+    const dispute = this.disputes.get(disputeId);
+    if (!dispute) {
+      return { success: false, error: "Dispute not found" };
+    }
+    if (dispute.status === "resolved" || dispute.status === "rejected") {
+      return { success: false, error: "Dispute already resolved" };
+    }
+    const now = Date.now();
+    dispute.resolution = {
+      winner,
+      finalPayerBalance,
+      finalPayeeBalance,
+      reason,
+      timestamp: now
+    };
+    dispute.status = "resolved";
+    this.config.notifyParties(dispute, "resolved");
+    return { success: true };
+  }
+  /**
+   * Reject a dispute
+   */
+  reject(disputeId, reason) {
+    const dispute = this.disputes.get(disputeId);
+    if (!dispute) {
+      return { success: false, error: "Dispute not found" };
+    }
+    if (dispute.status === "resolved" || dispute.status === "rejected") {
+      return { success: false, error: "Dispute already resolved" };
+    }
+    dispute.status = "rejected";
+    dispute.resolution = {
+      finalPayerBalance: dispute.claimedPayerBalance,
+      finalPayeeBalance: dispute.claimedPayeeBalance,
+      reason: `Rejected: ${reason}`,
+      timestamp: Date.now()
+    };
+    this.config.notifyParties(dispute, "rejected");
+    return { success: true };
+  }
+  /**
+   * Handle timeout (no response)
+   */
+  handleTimeout(disputeId) {
+    const dispute = this.disputes.get(disputeId);
+    if (!dispute) {
+      return { success: false };
+    }
+    const now = Date.now();
+    if (dispute.status === "pending" && now > dispute.responseDeadline) {
+      return this.resolve(
+        disputeId,
+        dispute.initiator,
+        dispute.claimedPayerBalance,
+        dispute.claimedPayeeBalance,
+        "Timeout: No response from respondent"
+      ).success ? { success: true, resolution: dispute.resolution } : { success: false };
+    }
+    if (dispute.status === "under_review" && now > dispute.resolutionDeadline) {
+      dispute.status = "timeout";
+      return { success: true };
+    }
+    return { success: false };
+  }
+  /**
+   * Get dispute by ID
+   */
+  get(disputeId) {
+    return this.disputes.get(disputeId);
+  }
+  /**
+   * Get dispute by channel ID
+   */
+  getByChannel(channelId) {
+    for (const dispute of this.disputes.values()) {
+      if (dispute.channelId === channelId && dispute.status !== "resolved" && dispute.status !== "rejected") {
+        return dispute;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Get all disputes
+   */
+  getAll() {
+    return Array.from(this.disputes.values());
+  }
+  /**
+   * Get disputes by status
+   */
+  getByStatus(status) {
+    return Array.from(this.disputes.values()).filter((d) => d.status === status);
+  }
+  /**
+   * Add evidence to existing dispute
+   */
+  addEvidence(disputeId, party, evidence) {
+    const dispute = this.disputes.get(disputeId);
+    if (!dispute) {
+      return { success: false, error: "Dispute not found" };
+    }
+    if (dispute.status !== "pending" && dispute.status !== "under_review") {
+      return { success: false, error: "Cannot add evidence to resolved dispute" };
+    }
+    if (party !== dispute.initiator && party !== dispute.respondent) {
+      return { success: false, error: "Only parties can add evidence" };
+    }
+    if (party === dispute.initiator) {
+      dispute.evidence.push(evidence);
+    } else {
+      dispute.responseEvidence = dispute.responseEvidence ?? [];
+      dispute.responseEvidence.push(evidence);
+    }
+    return { success: true };
+  }
+  /**
+   * Evaluate dispute based on evidence
+   */
+  evaluateEvidence(disputeId) {
+    const dispute = this.disputes.get(disputeId);
+    if (!dispute) {
+      return { initiatorScore: 0, respondentScore: 0, recommendation: "Dispute not found" };
+    }
+    let initiatorScore = 0;
+    let respondentScore = 0;
+    for (const evidence of dispute.evidence) {
+      if (evidence.verified) {
+        initiatorScore += this.getEvidenceWeight(evidence.type);
+      } else {
+        initiatorScore += this.getEvidenceWeight(evidence.type) * 0.5;
+      }
+    }
+    for (const evidence of dispute.responseEvidence ?? []) {
+      if (evidence.verified) {
+        respondentScore += this.getEvidenceWeight(evidence.type);
+      } else {
+        respondentScore += this.getEvidenceWeight(evidence.type) * 0.5;
+      }
+    }
+    if (dispute.claimedCheckpoint) {
+      const latestCheckpoint = this.checkpointManager.getLatest(dispute.channelId);
+      if (latestCheckpoint) {
+        const comparison = this.checkpointManager.compare(
+          dispute.claimedCheckpoint,
+          latestCheckpoint
+        );
+        if (comparison.isNewer) {
+          initiatorScore += 10;
+        } else {
+          respondentScore += 10;
+        }
+      }
+    }
+    let recommendation;
+    if (initiatorScore > respondentScore * 1.5) {
+      recommendation = "Initiator has stronger evidence";
+    } else if (respondentScore > initiatorScore * 1.5) {
+      recommendation = "Respondent has stronger evidence";
+    } else {
+      recommendation = "Evidence is inconclusive - may need arbitration";
+    }
+    return { initiatorScore, respondentScore, recommendation };
+  }
+  validateRequest(request) {
+    const errors = [];
+    if (!request.channelId) {
+      errors.push("Channel ID is required");
+    }
+    if (!request.initiator) {
+      errors.push("Initiator address is required");
+    }
+    if (!request.respondent) {
+      errors.push("Respondent address is required");
+    }
+    if (request.initiator === request.respondent) {
+      errors.push("Initiator and respondent must be different");
+    }
+    if (!request.reason) {
+      errors.push("Dispute reason is required");
+    }
+    if (!request.description || request.description.length < 10) {
+      errors.push("Description must be at least 10 characters");
+    }
+    if (request.evidence.length === 0) {
+      errors.push("At least one piece of evidence is required");
+    }
+    if (BigInt(request.claimedPayerBalance) < 0n) {
+      errors.push("Claimed payer balance cannot be negative");
+    }
+    if (BigInt(request.claimedPayeeBalance) < 0n) {
+      errors.push("Claimed payee balance cannot be negative");
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  getEvidenceWeight(type) {
+    const weights = {
+      checkpoint: 10,
+      signature: 8,
+      transaction: 9,
+      state_proof: 10
+    };
+    return weights[type] ?? 5;
+  }
+  generateDisputeId(channelId) {
+    return `dsp_${channelId.slice(-8)}_${Date.now().toString(36)}`;
+  }
+};
+function createCheckpointEvidence(checkpoint, description) {
+  return {
+    type: "checkpoint",
+    data: JSON.stringify(checkpoint),
+    description,
+    timestamp: Date.now(),
+    verified: false
+  };
+}
+function createSignatureEvidence(signature, signedData, description) {
+  return {
+    type: "signature",
+    data: JSON.stringify({ signature, signedData }),
+    description,
+    timestamp: Date.now(),
+    verified: false
+  };
+}
+function createTransactionEvidence(txHash, description) {
+  return {
+    type: "transaction",
+    data: txHash,
+    description,
+    timestamp: Date.now(),
+    verified: false
+  };
+}
+export {
+  CheckpointManager,
+  CheckpointType,
+  Dispute,
+  DisputeEvidence,
+  DisputeManager,
+  DisputeReason,
+  FinalSettlementManager,
+  OnChainSettlement,
+  SettlementCheckpoint,
+  SettlementConfig,
+  SettlementRequest,
+  SettlementResult,
+  SettlementState,
+  createCheckpointEvidence,
+  createSignatureEvidence,
+  createTransactionEvidence,
+  estimateSettlementGas,
+  signCheckpoint,
+  verifyCheckpointSignature,
+  verifySettlementOnChain
+};
+//# sourceMappingURL=index.js.map