@t402/streaming-payments 1.0.0-beta.1

package/dist/channels/index.js

@@ -0,0 +1,1135 @@
+// src/channels/types.ts
+import { z } from "zod";
+var ChannelState = z.enum([
+  "created",
+  // Channel created but not funded
+  "funding",
+  // Waiting for funding transaction
+  "open",
+  // Channel is active and streaming
+  "paused",
+  // Channel temporarily paused
+  "closing",
+  // Channel close initiated
+  "disputing",
+  // Dispute in progress
+  "closed",
+  // Channel fully closed
+  "expired"
+  // Channel expired without proper close
+]);
+var ChannelConfig = z.object({
+  // Funding requirements
+  minDeposit: z.string().default("1000000"),
+  // Minimum deposit (in smallest units)
+  maxDeposit: z.string().optional(),
+  // Timing
+  challengePeriod: z.number().default(86400),
+  // Dispute window in seconds (24h default)
+  expirationTime: z.number().optional(),
+  // Optional expiration timestamp
+  // Checkpointing
+  checkpointInterval: z.number().default(3600),
+  // Checkpoint every hour
+  minCheckpointAmount: z.string().default("100000"),
+  // Min amount change to checkpoint
+  // Fees
+  channelFee: z.string().default("0"),
+  // One-time channel opening fee
+  settlementFee: z.string().default("0")
+  // Fee for final settlement
+});
+var ChannelParticipant = z.object({
+  address: z.string(),
+  role: z.enum(["payer", "payee"]),
+  publicKey: z.string().optional()
+  // For off-chain signature verification
+});
+var ChannelBalance = z.object({
+  payer: z.string(),
+  // Payer's remaining balance
+  payee: z.string(),
+  // Payee's accrued balance
+  total: z.string(),
+  // Total channel capacity
+  locked: z.string().default("0")
+  // Amount locked in disputes
+});
+var ChannelCheckpoint = z.object({
+  channelId: z.string(),
+  sequence: z.number(),
+  // Monotonically increasing sequence number
+  timestamp: z.number(),
+  balance: ChannelBalance,
+  amountStreamed: z.string(),
+  // Total amount streamed so far
+  payerSignature: z.string(),
+  payeeSignature: z.string().optional(),
+  // Payee signature for mutual checkpoints
+  stateRoot: z.string().optional()
+  // Merkle root of channel state
+});
+var StreamingChannel = z.object({
+  id: z.string(),
+  state: ChannelState,
+  chain: z.string(),
+  // CAIP-2 chain ID
+  asset: z.string(),
+  // Token contract address
+  // Participants
+  payer: ChannelParticipant,
+  payee: ChannelParticipant,
+  // Financial state
+  balance: ChannelBalance,
+  // Streaming parameters
+  ratePerSecond: z.string(),
+  // Amount per second
+  startTime: z.number().optional(),
+  // When streaming started
+  pausedAt: z.number().optional(),
+  // When paused (if paused)
+  // Configuration
+  config: ChannelConfig,
+  // On-chain references
+  contractAddress: z.string().optional(),
+  // Payment channel contract
+  fundingTxHash: z.string().optional(),
+  closingTxHash: z.string().optional(),
+  // Checkpointing
+  checkpoints: z.array(ChannelCheckpoint),
+  latestCheckpoint: ChannelCheckpoint.optional(),
+  // Timestamps
+  createdAt: z.number(),
+  updatedAt: z.number(),
+  closedAt: z.number().optional()
+});
+var ChannelCreateRequest = z.object({
+  chain: z.string(),
+  asset: z.string(),
+  payerAddress: z.string(),
+  payeeAddress: z.string(),
+  depositAmount: z.string(),
+  ratePerSecond: z.string(),
+  config: ChannelConfig.optional()
+});
+var FundingTransaction = z.object({
+  channelId: z.string(),
+  txHash: z.string(),
+  amount: z.string(),
+  sender: z.string(),
+  blockNumber: z.number().optional(),
+  timestamp: z.number(),
+  confirmed: z.boolean()
+});
+var ChannelCloseRequest = z.object({
+  channelId: z.string(),
+  initiator: z.string(),
+  // Address of closer
+  reason: z.enum(["mutual", "unilateral", "timeout", "dispute"]),
+  finalCheckpoint: ChannelCheckpoint.optional(),
+  signature: z.string()
+});
+var ChannelDispute = z.object({
+  channelId: z.string(),
+  disputeId: z.string(),
+  initiator: z.string(),
+  reason: z.string(),
+  claimedBalance: ChannelBalance,
+  evidence: z.array(z.object({
+    type: z.enum(["checkpoint", "signature", "transaction"]),
+    data: z.string(),
+    timestamp: z.number()
+  })),
+  status: z.enum(["pending", "resolved", "rejected"]),
+  resolution: z.object({
+    winner: z.string().optional(),
+    finalBalance: ChannelBalance.optional(),
+    timestamp: z.number().optional()
+  }).optional(),
+  createdAt: z.number(),
+  expiresAt: z.number()
+});
+var StateTransition = z.object({
+  from: ChannelState,
+  to: ChannelState,
+  trigger: z.string(),
+  timestamp: z.number(),
+  metadata: z.record(z.unknown()).optional()
+});
+var RecoveryData = z.object({
+  channelId: z.string(),
+  checkpoints: z.array(ChannelCheckpoint),
+  transactions: z.array(FundingTransaction),
+  disputes: z.array(ChannelDispute),
+  stateHistory: z.array(StateTransition),
+  recoveredAt: z.number()
+});
+
+// src/channels/state.ts
+var STATE_TRANSITIONS = {
+  created: ["funding", "closed"],
+  funding: ["open", "closed", "expired"],
+  open: ["paused", "closing", "disputing"],
+  paused: ["open", "closing", "disputing"],
+  closing: ["closed", "disputing"],
+  disputing: ["closing", "closed"],
+  closed: [],
+  expired: []
+};
+var ChannelStateMachine = class {
+  channel;
+  transitions = [];
+  listeners = /* @__PURE__ */ new Map();
+  constructor(channel) {
+    this.channel = { ...channel };
+  }
+  /**
+   * Get current channel state
+   */
+  getChannel() {
+    return { ...this.channel };
+  }
+  /**
+   * Get current state
+   */
+  getState() {
+    return this.channel.state;
+  }
+  /**
+   * Get state history
+   */
+  getTransitions() {
+    return [...this.transitions];
+  }
+  /**
+   * Check if a transition is valid
+   */
+  canTransition(to) {
+    const allowedTransitions = STATE_TRANSITIONS[this.channel.state];
+    return allowedTransitions.includes(to);
+  }
+  /**
+   * Get allowed transitions from current state
+   */
+  getAllowedTransitions() {
+    return STATE_TRANSITIONS[this.channel.state];
+  }
+  /**
+   * Process a state event
+   */
+  process(event) {
+    const currentState = this.channel.state;
+    let nextState = null;
+    let metadata = {};
+    switch (event.type) {
+      case "FUND":
+        if (currentState !== "created") {
+          return { success: false, error: "Channel must be in created state to fund" };
+        }
+        nextState = "funding";
+        metadata = { txHash: event.txHash, amount: event.amount };
+        this.channel.fundingTxHash = event.txHash;
+        break;
+      case "CONFIRM_FUNDING":
+        if (currentState !== "funding") {
+          return { success: false, error: "Channel must be in funding state" };
+        }
+        nextState = "open";
+        this.channel.startTime = Date.now();
+        break;
+      case "START_STREAMING":
+        if (currentState !== "open" && currentState !== "paused") {
+          return { success: false, error: "Channel must be open or paused to stream" };
+        }
+        if (currentState === "paused") {
+          nextState = "open";
+          this.channel.pausedAt = void 0;
+        }
+        break;
+      case "PAUSE":
+        if (currentState !== "open") {
+          return { success: false, error: "Channel must be open to pause" };
+        }
+        nextState = "paused";
+        this.channel.pausedAt = Date.now();
+        break;
+      case "RESUME":
+        if (currentState !== "paused") {
+          return { success: false, error: "Channel must be paused to resume" };
+        }
+        nextState = "open";
+        this.channel.pausedAt = void 0;
+        break;
+      case "INITIATE_CLOSE":
+        if (currentState !== "open" && currentState !== "paused") {
+          return { success: false, error: "Channel must be open or paused to close" };
+        }
+        nextState = "closing";
+        metadata = { initiator: event.initiator };
+        break;
+      case "MUTUAL_CLOSE":
+        if (currentState !== "closing") {
+          return { success: false, error: "Channel must be in closing state" };
+        }
+        nextState = "closed";
+        this.channel.closedAt = Date.now();
+        metadata = { signature: event.signature };
+        break;
+      case "DISPUTE":
+        if (!["open", "paused", "closing"].includes(currentState)) {
+          return { success: false, error: "Cannot dispute in current state" };
+        }
+        nextState = "disputing";
+        metadata = { reason: event.reason };
+        break;
+      case "RESOLVE_DISPUTE":
+        if (currentState !== "disputing") {
+          return { success: false, error: "No dispute to resolve" };
+        }
+        nextState = "closing";
+        metadata = { winner: event.winner };
+        break;
+      case "FINALIZE":
+        if (currentState !== "closing") {
+          return { success: false, error: "Channel must be in closing state" };
+        }
+        nextState = "closed";
+        this.channel.closedAt = Date.now();
+        break;
+      case "TIMEOUT":
+        if (currentState === "funding") {
+          nextState = "expired";
+        } else if (currentState === "disputing") {
+          nextState = "closed";
+          this.channel.closedAt = Date.now();
+        } else {
+          return { success: false, error: "Timeout not applicable in current state" };
+        }
+        break;
+      default:
+        return { success: false, error: "Unknown event type" };
+    }
+    if (nextState && nextState !== currentState) {
+      if (!this.canTransition(nextState)) {
+        return { success: false, error: `Invalid transition from ${currentState} to ${nextState}` };
+      }
+      const transition = {
+        from: currentState,
+        to: nextState,
+        trigger: event.type,
+        timestamp: Date.now(),
+        metadata
+      };
+      this.channel.state = nextState;
+      this.channel.updatedAt = Date.now();
+      this.transitions.push(transition);
+      this.notifyListeners(nextState);
+    }
+    return { success: true };
+  }
+  /**
+   * Update channel balance
+   */
+  updateBalance(payerBalance, payeeBalance) {
+    this.channel.balance = {
+      ...this.channel.balance,
+      payer: payerBalance,
+      payee: payeeBalance
+    };
+    this.channel.updatedAt = Date.now();
+  }
+  /**
+   * Add checkpoint
+   */
+  addCheckpoint(checkpoint) {
+    this.channel.checkpoints.push(checkpoint);
+    this.channel.latestCheckpoint = checkpoint;
+    this.channel.updatedAt = Date.now();
+  }
+  /**
+   * Get current streamed amount
+   */
+  getCurrentStreamedAmount() {
+    if (!this.channel.startTime) return "0";
+    if (this.channel.state !== "open" && this.channel.state !== "paused") {
+      return this.channel.balance.payee;
+    }
+    const now = this.channel.pausedAt ?? Date.now();
+    const elapsed = Math.floor((now - this.channel.startTime) / 1e3);
+    const streamed = BigInt(this.channel.ratePerSecond) * BigInt(elapsed);
+    const maxStreamed = BigInt(this.channel.balance.total);
+    return (streamed > maxStreamed ? maxStreamed : streamed).toString();
+  }
+  /**
+   * Calculate remaining balance
+   */
+  getRemainingBalance() {
+    const total = BigInt(this.channel.balance.total);
+    const streamed = BigInt(this.getCurrentStreamedAmount());
+    return (total - streamed).toString();
+  }
+  /**
+   * Check if channel needs checkpoint
+   */
+  needsCheckpoint() {
+    const config = this.channel.config;
+    const lastCheckpoint = this.channel.latestCheckpoint;
+    if (!lastCheckpoint) return true;
+    const timeSinceCheckpoint = Date.now() - lastCheckpoint.timestamp;
+    if (timeSinceCheckpoint >= config.checkpointInterval * 1e3) return true;
+    const currentStreamed = BigInt(this.getCurrentStreamedAmount());
+    const lastStreamed = BigInt(lastCheckpoint.amountStreamed);
+    const amountChange = currentStreamed - lastStreamed;
+    if (amountChange >= BigInt(config.minCheckpointAmount)) return true;
+    return false;
+  }
+  /**
+   * Subscribe to state changes
+   */
+  onStateChange(state, callback) {
+    const key = state;
+    if (!this.listeners.has(key)) {
+      this.listeners.set(key, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(key).add(callback);
+    return () => {
+      this.listeners.get(key)?.delete(callback);
+    };
+  }
+  notifyListeners(newState) {
+    this.listeners.get(newState)?.forEach((cb) => cb(this.channel));
+    this.listeners.get("*")?.forEach((cb) => cb(this.channel));
+  }
+};
+function isChannelActive(channel) {
+  return channel.state === "open";
+}
+function isChannelTerminal(channel) {
+  return channel.state === "closed" || channel.state === "expired";
+}
+function getChannelUtilization(channel) {
+  const total = parseFloat(channel.balance.total);
+  if (total === 0) return 0;
+  const payee = parseFloat(channel.balance.payee);
+  return payee / total * 100;
+}
+
+// src/channels/opening.ts
+var ChannelOpener = class {
+  config;
+  constructor(config = {}) {
+    this.config = {
+      fundingTimeout: config.fundingTimeout ?? 36e5,
+      // 1 hour
+      confirmations: config.confirmations ?? 1,
+      contractAddress: config.contractAddress ?? ""
+    };
+  }
+  /**
+   * Create a new channel
+   */
+  create(request) {
+    this.validateCreateRequest(request);
+    const channelConfig = request.config ?? ChannelConfig.parse({});
+    const now = Date.now();
+    const channelId = this.generateChannelId(request, now);
+    const payer = {
+      address: request.payerAddress,
+      role: "payer"
+    };
+    const payee = {
+      address: request.payeeAddress,
+      role: "payee"
+    };
+    const balance = {
+      payer: request.depositAmount,
+      payee: "0",
+      total: request.depositAmount,
+      locked: "0"
+    };
+    const channel = {
+      id: channelId,
+      state: "created",
+      chain: request.chain,
+      asset: request.asset,
+      payer,
+      payee,
+      balance,
+      ratePerSecond: request.ratePerSecond,
+      config: channelConfig,
+      contractAddress: this.config.contractAddress || void 0,
+      checkpoints: [],
+      createdAt: now,
+      updatedAt: now
+    };
+    const stateMachine = new ChannelStateMachine(channel);
+    const fundingRequired = this.calculateFundingRequirements(channel);
+    return {
+      channel: stateMachine.getChannel(),
+      stateMachine,
+      fundingRequired
+    };
+  }
+  /**
+   * Process funding transaction
+   */
+  processFunding(stateMachine, txHash, amount) {
+    const channel = stateMachine.getChannel();
+    if (BigInt(amount) < BigInt(channel.config.minDeposit)) {
+      return { success: false, error: "Funding amount below minimum deposit" };
+    }
+    if (channel.config.maxDeposit && BigInt(amount) > BigInt(channel.config.maxDeposit)) {
+      return { success: false, error: "Funding amount exceeds maximum deposit" };
+    }
+    const result = stateMachine.process({
+      type: "FUND",
+      txHash,
+      amount
+    });
+    if (!result.success) {
+      return result;
+    }
+    stateMachine.updateBalance(amount, "0");
+    return { success: true };
+  }
+  /**
+   * Confirm funding (after required confirmations)
+   */
+  confirmFunding(stateMachine, _confirmation) {
+    return stateMachine.process({ type: "CONFIRM_FUNDING" });
+  }
+  /**
+   * Handle funding timeout
+   */
+  handleTimeout(stateMachine) {
+    const channel = stateMachine.getChannel();
+    if (channel.state !== "funding") {
+      return { success: false, expired: false };
+    }
+    const elapsed = Date.now() - channel.createdAt;
+    if (elapsed < this.config.fundingTimeout) {
+      return { success: false, expired: false };
+    }
+    const result = stateMachine.process({ type: "TIMEOUT" });
+    return { success: result.success, expired: result.success };
+  }
+  /**
+   * Validate channel create request
+   */
+  validateCreateRequest(request) {
+    ChannelCreateRequest.parse(request);
+    if (request.payerAddress === request.payeeAddress) {
+      throw new Error("Payer and payee must be different addresses");
+    }
+    if (BigInt(request.depositAmount) <= 0n) {
+      throw new Error("Deposit amount must be positive");
+    }
+    if (BigInt(request.ratePerSecond) <= 0n) {
+      throw new Error("Rate per second must be positive");
+    }
+    const depositBigInt = BigInt(request.depositAmount);
+    const rateBigInt = BigInt(request.ratePerSecond);
+    const minDuration = depositBigInt / rateBigInt;
+    if (minDuration < 60n) {
+      throw new Error("Channel would be exhausted in less than 60 seconds");
+    }
+  }
+  /**
+   * Generate unique channel ID
+   */
+  generateChannelId(request, timestamp) {
+    const data = `${request.chain}:${request.asset}:${request.payerAddress}:${request.payeeAddress}:${timestamp}`;
+    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 `ch_${Math.abs(hash).toString(16).padStart(16, "0")}`;
+  }
+  /**
+   * Calculate funding requirements for channel
+   */
+  calculateFundingRequirements(channel) {
+    const totalRequired = BigInt(channel.balance.total) + BigInt(channel.config.channelFee);
+    return {
+      amount: totalRequired.toString(),
+      to: channel.contractAddress ?? channel.payee.address,
+      data: this.encodeFundingData(channel)
+    };
+  }
+  /**
+   * Encode funding transaction data
+   */
+  encodeFundingData(channel) {
+    const methodId = "0x" + "initChannel".split("").map((c) => c.charCodeAt(0).toString(16)).join("").slice(0, 8);
+    return `${methodId}${channel.id.replace("ch_", "").padStart(64, "0")}`;
+  }
+};
+function estimateChannelDuration(depositAmount, ratePerSecond) {
+  const deposit = BigInt(depositAmount);
+  const rate = BigInt(ratePerSecond);
+  if (rate === 0n) {
+    return { seconds: Infinity, formatted: "infinite" };
+  }
+  const seconds = Number(deposit / rate);
+  if (seconds < 60) {
+    return { seconds, formatted: `${seconds} seconds` };
+  } else if (seconds < 3600) {
+    const minutes = Math.floor(seconds / 60);
+    return { seconds, formatted: `${minutes} minutes` };
+  } else if (seconds < 86400) {
+    const hours = Math.floor(seconds / 3600);
+    return { seconds, formatted: `${hours} hours` };
+  } else {
+    const days = Math.floor(seconds / 86400);
+    return { seconds, formatted: `${days} days` };
+  }
+}
+function calculateRequiredDeposit(ratePerSecond, durationSeconds) {
+  const rate = BigInt(ratePerSecond);
+  const duration = BigInt(durationSeconds);
+  return (rate * duration).toString();
+}
+
+// src/channels/closing.ts
+var ChannelCloser = class {
+  config;
+  constructor(config = {}) {
+    this.config = {
+      challengePeriod: config.challengePeriod ?? 86400,
+      // 24 hours
+      gracePeriod: config.gracePeriod ?? 3600,
+      // 1 hour
+      autoFinalize: config.autoFinalize ?? true
+    };
+  }
+  /**
+   * Initiate channel close
+   */
+  initiateClose(stateMachine, initiator, signature) {
+    const channel = stateMachine.getChannel();
+    if (initiator !== channel.payer.address && initiator !== channel.payee.address) {
+      return { success: false, error: "Initiator must be a channel participant" };
+    }
+    const currentStreamed = stateMachine.getCurrentStreamedAmount();
+    const finalBalance = this.calculateFinalBalance(channel, currentStreamed);
+    const finalCheckpoint = this.createFinalCheckpoint(channel, finalBalance, signature);
+    const result = stateMachine.process({
+      type: "INITIATE_CLOSE",
+      initiator
+    });
+    if (!result.success) {
+      return { success: false, error: result.error };
+    }
+    stateMachine.addCheckpoint(finalCheckpoint);
+    const challengeDeadline = Date.now() + this.config.challengePeriod * 1e3;
+    return {
+      success: true,
+      challengeDeadline,
+      finalCheckpoint,
+      settlementAmount: {
+        payer: finalBalance.payer,
+        payee: finalBalance.payee
+      }
+    };
+  }
+  /**
+   * Complete mutual close (both parties agree)
+   */
+  mutualClose(stateMachine, payerSignature, payeeSignature) {
+    const channel = stateMachine.getChannel();
+    const currentStreamed = stateMachine.getCurrentStreamedAmount();
+    const finalBalance = this.calculateFinalBalance(channel, currentStreamed);
+    const finalCheckpoint = {
+      channelId: channel.id,
+      sequence: channel.checkpoints.length,
+      timestamp: Date.now(),
+      balance: finalBalance,
+      amountStreamed: currentStreamed,
+      payerSignature,
+      payeeSignature
+    };
+    let result = stateMachine.process({
+      type: "INITIATE_CLOSE",
+      initiator: channel.payer.address
+    });
+    if (!result.success) {
+      return { success: false, error: result.error };
+    }
+    result = stateMachine.process({
+      type: "MUTUAL_CLOSE",
+      signature: `${payerSignature}:${payeeSignature}`
+    });
+    if (!result.success) {
+      return { success: false, error: result.error };
+    }
+    stateMachine.addCheckpoint(finalCheckpoint);
+    return {
+      success: true,
+      finalCheckpoint,
+      settlementAmount: {
+        payer: finalBalance.payer,
+        payee: finalBalance.payee
+      }
+    };
+  }
+  /**
+   * Finalize channel after challenge period
+   */
+  finalize(stateMachine) {
+    const channel = stateMachine.getChannel();
+    if (channel.state !== "closing") {
+      return {
+        success: false,
+        error: "Channel must be in closing state",
+        finalBalance: channel.balance
+      };
+    }
+    const latestCheckpoint = channel.latestCheckpoint;
+    if (latestCheckpoint) {
+      const elapsed = Date.now() - latestCheckpoint.timestamp;
+      if (elapsed < this.config.challengePeriod * 1e3) {
+        return {
+          success: false,
+          error: "Challenge period not yet elapsed",
+          finalBalance: channel.balance
+        };
+      }
+    }
+    const result = stateMachine.process({ type: "FINALIZE" });
+    if (!result.success) {
+      return {
+        success: false,
+        error: result.error,
+        finalBalance: channel.balance
+      };
+    }
+    const finalChannel = stateMachine.getChannel();
+    return {
+      success: true,
+      finalBalance: finalChannel.balance
+    };
+  }
+  /**
+   * Validate close request
+   */
+  validateCloseRequest(channel, request) {
+    const errors = [];
+    if (request.channelId !== channel.id) {
+      errors.push("Channel ID mismatch");
+    }
+    if (request.initiator !== channel.payer.address && request.initiator !== channel.payee.address) {
+      errors.push("Initiator is not a channel participant");
+    }
+    if (channel.state !== "open" && channel.state !== "paused") {
+      errors.push(`Cannot close channel in ${channel.state} state`);
+    }
+    if (request.finalCheckpoint) {
+      const cpErrors = this.validateCheckpoint(channel, request.finalCheckpoint);
+      errors.push(...cpErrors);
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  /**
+   * Get settlement amounts for on-chain execution
+   */
+  getSettlementAmounts(channel) {
+    const finalBalance = channel.latestCheckpoint?.balance ?? channel.balance;
+    const fee = channel.config.settlementFee;
+    const payerAmount = BigInt(finalBalance.payer) - BigInt(fee);
+    return {
+      payer: payerAmount > 0n ? payerAmount.toString() : "0",
+      payee: finalBalance.payee,
+      fee
+    };
+  }
+  /**
+   * Calculate time until channel can be finalized
+   */
+  getTimeUntilFinalization(channel) {
+    if (channel.state !== "closing") {
+      return -1;
+    }
+    const latestCheckpoint = channel.latestCheckpoint;
+    if (!latestCheckpoint) {
+      return 0;
+    }
+    const elapsed = Date.now() - latestCheckpoint.timestamp;
+    const remaining = this.config.challengePeriod * 1e3 - elapsed;
+    return Math.max(0, remaining);
+  }
+  /**
+   * Check if channel close can be challenged
+   */
+  canChallenge(channel) {
+    if (channel.state !== "closing") {
+      return false;
+    }
+    return this.getTimeUntilFinalization(channel) > 0;
+  }
+  calculateFinalBalance(channel, amountStreamed) {
+    const total = BigInt(channel.balance.total);
+    const streamed = BigInt(amountStreamed);
+    const remaining = total - streamed;
+    return {
+      payer: remaining.toString(),
+      payee: streamed.toString(),
+      total: total.toString(),
+      locked: "0"
+    };
+  }
+  createFinalCheckpoint(channel, balance, signature) {
+    return {
+      channelId: channel.id,
+      sequence: channel.checkpoints.length,
+      timestamp: Date.now(),
+      balance,
+      amountStreamed: balance.payee,
+      payerSignature: signature
+    };
+  }
+  validateCheckpoint(channel, checkpoint) {
+    const errors = [];
+    const expectedSequence = channel.checkpoints.length;
+    if (checkpoint.sequence !== expectedSequence) {
+      errors.push(`Invalid sequence: expected ${expectedSequence}, got ${checkpoint.sequence}`);
+    }
+    const totalBalance = BigInt(checkpoint.balance.payer) + BigInt(checkpoint.balance.payee);
+    if (totalBalance !== BigInt(channel.balance.total)) {
+      errors.push("Balance inconsistency: payer + payee does not equal total");
+    }
+    if (checkpoint.timestamp > Date.now()) {
+      errors.push("Checkpoint timestamp is in the future");
+    }
+    return errors;
+  }
+};
+function buildCloseTransactionData(channel, checkpoint) {
+  const methodId = "0x" + "closeChannel".split("").map((c) => c.charCodeAt(0).toString(16)).join("").slice(0, 8);
+  const data = [
+    methodId,
+    channel.id.replace("ch_", "").padStart(64, "0"),
+    checkpoint.sequence.toString(16).padStart(64, "0"),
+    checkpoint.payerSignature.replace("0x", "").padStart(128, "0")
+  ].join("");
+  return {
+    to: channel.contractAddress ?? channel.payee.address,
+    data,
+    value: "0"
+  };
+}
+
+// src/channels/recovery.ts
+var ChannelRecovery = class {
+  config;
+  storage;
+  constructor(config = {}, storage) {
+    this.config = {
+      maxCheckpointsToKeep: config.maxCheckpointsToKeep ?? 100,
+      verifySignatures: config.verifySignatures ?? true,
+      onChainFallback: config.onChainFallback ?? true
+    };
+    this.storage = storage;
+  }
+  /**
+   * Recover channel from checkpoints
+   */
+  recoverFromCheckpoints(baseChannel, checkpoints) {
+    if (checkpoints.length === 0) {
+      return {
+        success: true,
+        channel: baseChannel,
+        stateMachine: new ChannelStateMachine(baseChannel),
+        dataLoss: false
+      };
+    }
+    const sortedCheckpoints = [...checkpoints].sort((a, b) => a.sequence - b.sequence);
+    let latestValid;
+    for (let i = sortedCheckpoints.length - 1; i >= 0; i--) {
+      const checkpoint = sortedCheckpoints[i];
+      if (this.isCheckpointValid(baseChannel, checkpoint)) {
+        latestValid = checkpoint;
+        break;
+      }
+    }
+    if (!latestValid) {
+      return {
+        success: false,
+        error: "No valid checkpoints found",
+        dataLoss: true
+      };
+    }
+    const recoveredChannel = this.reconstructFromCheckpoint(baseChannel, latestValid, sortedCheckpoints);
+    return {
+      success: true,
+      channel: recoveredChannel,
+      stateMachine: new ChannelStateMachine(recoveredChannel),
+      recoveredFromCheckpoint: latestValid,
+      dataLoss: sortedCheckpoints[sortedCheckpoints.length - 1].sequence > latestValid.sequence
+    };
+  }
+  /**
+   * Full recovery from storage
+   */
+  async recoverFromStorage(channelId) {
+    if (!this.storage) {
+      return {
+        success: false,
+        error: "No storage provider configured"
+      };
+    }
+    try {
+      const [channel, checkpoints, transactions, disputes] = await Promise.all([
+        this.storage.getChannel(channelId),
+        this.storage.getCheckpoints(channelId),
+        this.storage.getTransactions(channelId),
+        this.storage.getDisputes(channelId)
+      ]);
+      if (!channel) {
+        return {
+          success: false,
+          error: "Channel not found in storage"
+        };
+      }
+      const result = this.recoverFromCheckpoints(channel, checkpoints);
+      if (!result.success) {
+        if (this.config.onChainFallback) {
+          return this.recoverFromOnChain(channel, transactions, disputes);
+        }
+        return result;
+      }
+      return result;
+    } catch (error) {
+      return {
+        success: false,
+        error: `Storage recovery failed: ${error instanceof Error ? error.message : "Unknown error"}`
+      };
+    }
+  }
+  /**
+   * Export recovery data for backup
+   */
+  exportRecoveryData(channel, stateMachine) {
+    return {
+      channelId: channel.id,
+      checkpoints: channel.checkpoints,
+      transactions: [],
+      // Would be populated from transaction history
+      disputes: [],
+      // Would be populated from dispute history
+      stateHistory: stateMachine.getTransitions(),
+      recoveredAt: Date.now()
+    };
+  }
+  /**
+   * Import recovery data
+   */
+  importRecoveryData(data) {
+    if (!data.channelId || !data.checkpoints) {
+      return {
+        success: false,
+        error: "Invalid recovery data format"
+      };
+    }
+    if (data.checkpoints.length === 0) {
+      return {
+        success: false,
+        error: "No checkpoints in recovery data"
+      };
+    }
+    const baseChannel = this.createBaseChannelFromRecoveryData(data);
+    return this.recoverFromCheckpoints(baseChannel, data.checkpoints);
+  }
+  /**
+   * Verify checkpoint integrity
+   */
+  verifyCheckpointChain(checkpoints) {
+    const errors = [];
+    if (checkpoints.length === 0) {
+      return { valid: true, errors: [] };
+    }
+    const sorted = [...checkpoints].sort((a, b) => a.sequence - b.sequence);
+    for (let i = 0; i < sorted.length; i++) {
+      const current = sorted[i];
+      if (current.sequence !== i) {
+        errors.push(`Sequence gap: expected ${i}, got ${current.sequence}`);
+      }
+      if (i > 0 && current.timestamp < sorted[i - 1].timestamp) {
+        errors.push(`Timestamp ordering violation at sequence ${current.sequence}`);
+      }
+      if (i > 0) {
+        const prevStreamed = BigInt(sorted[i - 1].amountStreamed);
+        const currStreamed = BigInt(current.amountStreamed);
+        if (currStreamed < prevStreamed) {
+          errors.push(`Amount decreased at sequence ${current.sequence}`);
+        }
+      }
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  /**
+   * Prune old checkpoints keeping only recent ones
+   */
+  pruneCheckpoints(checkpoints) {
+    if (checkpoints.length <= this.config.maxCheckpointsToKeep) {
+      return checkpoints;
+    }
+    const sorted = [...checkpoints].sort((a, b) => a.sequence - b.sequence);
+    const genesis = sorted[0];
+    const recent = sorted.slice(-(this.config.maxCheckpointsToKeep - 1));
+    return [genesis, ...recent];
+  }
+  isCheckpointValid(channel, checkpoint) {
+    if (checkpoint.channelId !== channel.id) {
+      return false;
+    }
+    const total = BigInt(checkpoint.balance.payer) + BigInt(checkpoint.balance.payee);
+    if (total !== BigInt(channel.balance.total)) {
+      return false;
+    }
+    if (!checkpoint.payerSignature) {
+      return false;
+    }
+    if (this.config.verifySignatures) {
+    }
+    return true;
+  }
+  reconstructFromCheckpoint(baseChannel, checkpoint, allCheckpoints) {
+    const validCheckpoints = allCheckpoints.filter((cp) => cp.sequence <= checkpoint.sequence);
+    let state = "open";
+    if (checkpoint.payeeSignature) {
+      state = "open";
+    }
+    return {
+      ...baseChannel,
+      state,
+      balance: checkpoint.balance,
+      checkpoints: validCheckpoints,
+      latestCheckpoint: checkpoint,
+      updatedAt: checkpoint.timestamp
+    };
+  }
+  recoverFromOnChain(channel, transactions, disputes) {
+    const confirmedTxs = transactions.filter((tx) => tx.confirmed);
+    if (confirmedTxs.length === 0) {
+      return {
+        success: false,
+        error: "No confirmed transactions found",
+        dataLoss: true
+      };
+    }
+    const totalFunded = confirmedTxs.reduce(
+      (sum, tx) => sum + BigInt(tx.amount),
+      0n
+    );
+    const activeDispute = disputes.find((d) => d.status === "pending");
+    let state = "open";
+    if (activeDispute) {
+      state = "disputing";
+    }
+    const recoveredChannel = {
+      ...channel,
+      state,
+      balance: {
+        ...channel.balance,
+        total: totalFunded.toString(),
+        payer: totalFunded.toString(),
+        payee: "0"
+      },
+      fundingTxHash: confirmedTxs[0].txHash,
+      checkpoints: [],
+      updatedAt: Date.now()
+    };
+    return {
+      success: true,
+      channel: recoveredChannel,
+      stateMachine: new ChannelStateMachine(recoveredChannel),
+      dataLoss: true
+    };
+  }
+  createBaseChannelFromRecoveryData(data) {
+    const firstCheckpoint = data.checkpoints[0];
+    return {
+      id: data.channelId,
+      state: "open",
+      chain: "",
+      asset: "",
+      payer: { address: "", role: "payer" },
+      payee: { address: "", role: "payee" },
+      balance: firstCheckpoint.balance,
+      ratePerSecond: "0",
+      config: {
+        minDeposit: "0",
+        challengePeriod: 86400,
+        checkpointInterval: 3600,
+        minCheckpointAmount: "0",
+        channelFee: "0",
+        settlementFee: "0"
+      },
+      checkpoints: [],
+      createdAt: firstCheckpoint.timestamp,
+      updatedAt: firstCheckpoint.timestamp
+    };
+  }
+};
+function createStateSnapshot(_channel, stateMachine) {
+  const snapshot = {
+    version: 1,
+    channel: stateMachine.getChannel(),
+    transitions: stateMachine.getTransitions(),
+    timestamp: Date.now()
+  };
+  return JSON.stringify(snapshot);
+}
+function restoreFromSnapshot(snapshotJson) {
+  try {
+    const snapshot = JSON.parse(snapshotJson);
+    if (snapshot.version !== 1) {
+      return {
+        success: false,
+        error: "Unsupported snapshot version"
+      };
+    }
+    const channel = snapshot.channel;
+    const stateMachine = new ChannelStateMachine(channel);
+    return {
+      success: true,
+      channel,
+      stateMachine,
+      dataLoss: false
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to parse snapshot: ${error instanceof Error ? error.message : "Unknown error"}`
+    };
+  }
+}
+export {
+  ChannelBalance,
+  ChannelCheckpoint,
+  ChannelCloseRequest,
+  ChannelCloser,
+  ChannelConfig,
+  ChannelCreateRequest,
+  ChannelDispute,
+  ChannelOpener,
+  ChannelParticipant,
+  ChannelRecovery,
+  ChannelState,
+  ChannelStateMachine,
+  FundingTransaction,
+  RecoveryData,
+  StateTransition,
+  StreamingChannel,
+  buildCloseTransactionData,
+  calculateRequiredDeposit,
+  createStateSnapshot,
+  estimateChannelDuration,
+  getChannelUtilization,
+  isChannelActive,
+  isChannelTerminal,
+  restoreFromSnapshot
+};
+//# sourceMappingURL=index.js.map