@t402/streaming-payments 1.0.0-beta.1

package/dist/index.js

@@ -0,0 +1,3482 @@
+// 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"}`
+    };
+  }
+}
+
+// src/streaming/types.ts
+import { z as z2 } from "zod";
+var StreamState = z2.enum([
+  "idle",
+  // Stream not started
+  "active",
+  // Streaming in progress
+  "paused",
+  // Temporarily paused
+  "completed",
+  // Stream completed (exhausted)
+  "cancelled"
+  // Stream cancelled
+]);
+var RateType = z2.enum([
+  "fixed",
+  // Fixed rate per second
+  "variable",
+  // Rate can change
+  "tiered",
+  // Different rates based on usage
+  "dynamic"
+  // Demand-based pricing
+]);
+var StreamRate = z2.object({
+  type: RateType,
+  baseRate: z2.string(),
+  // Base rate per second
+  minRate: z2.string().optional(),
+  // Minimum rate
+  maxRate: z2.string().optional(),
+  // Maximum rate
+  // For tiered rates
+  tiers: z2.array(z2.object({
+    threshold: z2.string(),
+    // Usage threshold
+    rate: z2.string()
+    // Rate after threshold
+  })).optional(),
+  // For dynamic rates
+  adjustmentInterval: z2.number().optional(),
+  // How often to adjust (seconds)
+  adjustmentFactor: z2.number().optional()
+  // Max adjustment per interval
+});
+var UsageMetrics = z2.object({
+  totalSeconds: z2.number(),
+  totalAmount: z2.string(),
+  averageRate: z2.string(),
+  peakRate: z2.string(),
+  startTime: z2.number(),
+  endTime: z2.number().optional(),
+  // Breakdown by period
+  hourly: z2.array(z2.object({
+    hour: z2.number(),
+    amount: z2.string(),
+    seconds: z2.number()
+  })).optional()
+});
+var MeteringRecord = z2.object({
+  timestamp: z2.number(),
+  duration: z2.number(),
+  // Seconds since last record
+  amount: z2.string(),
+  // Amount for this period
+  rate: z2.string(),
+  // Rate applied
+  cumulative: z2.string(),
+  // Cumulative total
+  metadata: z2.record(z2.unknown()).optional()
+});
+var BillingPeriod = z2.enum([
+  "realtime",
+  // Continuous real-time billing
+  "second",
+  // Per-second
+  "minute",
+  // Per-minute
+  "hour",
+  // Per-hour
+  "day"
+  // Per-day
+]);
+var BillingConfig = z2.object({
+  period: BillingPeriod,
+  minimumCharge: z2.string().default("0"),
+  roundingMode: z2.enum(["floor", "ceil", "round"]).default("floor"),
+  gracePeriod: z2.number().default(0),
+  // Seconds of free usage
+  invoiceInterval: z2.number().optional()
+  // Generate invoice every N seconds
+});
+var InvoiceItem = z2.object({
+  description: z2.string(),
+  quantity: z2.number(),
+  // Duration in billing periods
+  rate: z2.string(),
+  amount: z2.string(),
+  startTime: z2.number(),
+  endTime: z2.number()
+});
+var Invoice = z2.object({
+  id: z2.string(),
+  channelId: z2.string(),
+  payer: z2.string(),
+  payee: z2.string(),
+  items: z2.array(InvoiceItem),
+  subtotal: z2.string(),
+  fees: z2.string(),
+  total: z2.string(),
+  currency: z2.string(),
+  status: z2.enum(["pending", "paid", "settled", "disputed"]),
+  createdAt: z2.number(),
+  dueAt: z2.number().optional(),
+  paidAt: z2.number().optional()
+});
+var StreamSession = z2.object({
+  id: z2.string(),
+  channelId: z2.string(),
+  state: StreamState,
+  rate: StreamRate,
+  startedAt: z2.number().optional(),
+  pausedAt: z2.number().optional(),
+  endedAt: z2.number().optional(),
+  totalDuration: z2.number(),
+  // Total streaming seconds
+  totalAmount: z2.string(),
+  // Total amount streamed
+  meteringRecords: z2.array(MeteringRecord),
+  billingConfig: BillingConfig,
+  invoices: z2.array(z2.string())
+  // Invoice IDs
+});
+var RateAdjustmentRequest = z2.object({
+  sessionId: z2.string(),
+  newRate: z2.string(),
+  reason: z2.string(),
+  effectiveFrom: z2.number().optional(),
+  // Timestamp, default now
+  signature: z2.string().optional()
+  // For mutual rate changes
+});
+var StreamEvent = z2.discriminatedUnion("type", [
+  z2.object({
+    type: z2.literal("started"),
+    sessionId: z2.string(),
+    timestamp: z2.number(),
+    rate: z2.string()
+  }),
+  z2.object({
+    type: z2.literal("paused"),
+    sessionId: z2.string(),
+    timestamp: z2.number(),
+    totalStreamed: z2.string()
+  }),
+  z2.object({
+    type: z2.literal("resumed"),
+    sessionId: z2.string(),
+    timestamp: z2.number()
+  }),
+  z2.object({
+    type: z2.literal("rate_changed"),
+    sessionId: z2.string(),
+    timestamp: z2.number(),
+    oldRate: z2.string(),
+    newRate: z2.string()
+  }),
+  z2.object({
+    type: z2.literal("checkpoint"),
+    sessionId: z2.string(),
+    timestamp: z2.number(),
+    amount: z2.string(),
+    checkpointId: z2.string()
+  }),
+  z2.object({
+    type: z2.literal("completed"),
+    sessionId: z2.string(),
+    timestamp: z2.number(),
+    totalAmount: z2.string(),
+    totalDuration: z2.number()
+  }),
+  z2.object({
+    type: z2.literal("cancelled"),
+    sessionId: z2.string(),
+    timestamp: z2.number(),
+    reason: z2.string()
+  })
+]);
+
+// src/streaming/flow.ts
+var FlowController = class {
+  session;
+  config;
+  updateTimer;
+  checkpointTimer;
+  eventListeners = /* @__PURE__ */ new Set();
+  lastUpdateTime = 0;
+  constructor(channelId, rate, billingConfig, config = {}) {
+    this.config = {
+      updateInterval: config.updateInterval ?? 1e3,
+      bufferTime: config.bufferTime ?? 60,
+      autoCheckpoint: config.autoCheckpoint ?? true,
+      checkpointInterval: config.checkpointInterval ?? 3600
+    };
+    this.session = {
+      id: this.generateSessionId(),
+      channelId,
+      state: "idle",
+      rate,
+      totalDuration: 0,
+      totalAmount: "0",
+      meteringRecords: [],
+      billingConfig,
+      invoices: []
+    };
+  }
+  /**
+   * Get current session state
+   */
+  getSession() {
+    return { ...this.session };
+  }
+  /**
+   * Get current state
+   */
+  getState() {
+    return this.session.state;
+  }
+  /**
+   * Start streaming
+   */
+  start() {
+    if (this.session.state !== "idle" && this.session.state !== "paused") {
+      return { success: false, error: "Stream must be idle or paused to start" };
+    }
+    const now = Date.now();
+    if (this.session.state === "idle") {
+      this.session.startedAt = now;
+    } else {
+      const pauseDuration = now - (this.session.pausedAt ?? now);
+      this.session.pausedAt = void 0;
+      this.addMeteringRecord({
+        timestamp: now,
+        duration: 0,
+        amount: "0",
+        rate: "0",
+        cumulative: this.session.totalAmount,
+        metadata: { event: "resume", pauseDuration }
+      });
+    }
+    this.session.state = "active";
+    this.lastUpdateTime = now;
+    this.startUpdateTimer();
+    if (this.config.autoCheckpoint) {
+      this.startCheckpointTimer();
+    }
+    this.emitEvent({
+      type: "started",
+      sessionId: this.session.id,
+      timestamp: now,
+      rate: this.session.rate.baseRate
+    });
+    return { success: true };
+  }
+  /**
+   * Pause streaming
+   */
+  pause() {
+    if (this.session.state !== "active") {
+      return { success: false, error: "Stream must be active to pause" };
+    }
+    const now = Date.now();
+    this.updateTotals(now);
+    this.session.state = "paused";
+    this.session.pausedAt = now;
+    this.stopTimers();
+    this.emitEvent({
+      type: "paused",
+      sessionId: this.session.id,
+      timestamp: now,
+      totalStreamed: this.session.totalAmount
+    });
+    return { success: true };
+  }
+  /**
+   * Resume streaming (alias for start when paused)
+   */
+  resume() {
+    if (this.session.state !== "paused") {
+      return { success: false, error: "Stream must be paused to resume" };
+    }
+    const result = this.start();
+    if (result.success) {
+      this.emitEvent({
+        type: "resumed",
+        sessionId: this.session.id,
+        timestamp: Date.now()
+      });
+    }
+    return result;
+  }
+  /**
+   * Stop streaming (complete)
+   */
+  stop() {
+    const now = Date.now();
+    if (this.session.state === "active") {
+      this.updateTotals(now);
+    }
+    this.stopTimers();
+    this.session.state = "completed";
+    this.session.endedAt = now;
+    this.emitEvent({
+      type: "completed",
+      sessionId: this.session.id,
+      timestamp: now,
+      totalAmount: this.session.totalAmount,
+      totalDuration: this.session.totalDuration
+    });
+    return {
+      success: true,
+      finalAmount: this.session.totalAmount
+    };
+  }
+  /**
+   * Cancel streaming
+   */
+  cancel(reason) {
+    const now = Date.now();
+    if (this.session.state === "active") {
+      this.updateTotals(now);
+    }
+    this.stopTimers();
+    this.session.state = "cancelled";
+    this.session.endedAt = now;
+    this.emitEvent({
+      type: "cancelled",
+      sessionId: this.session.id,
+      timestamp: now,
+      reason
+    });
+    return { success: true };
+  }
+  /**
+   * Get current streamed amount
+   */
+  getCurrentAmount() {
+    if (this.session.state !== "active") {
+      return this.session.totalAmount;
+    }
+    const now = Date.now();
+    const elapsed = Math.floor((now - this.lastUpdateTime) / 1e3);
+    const additionalAmount = this.calculateAmount(elapsed, this.session.rate);
+    return (BigInt(this.session.totalAmount) + BigInt(additionalAmount)).toString();
+  }
+  /**
+   * Get current rate
+   */
+  getCurrentRate() {
+    return this.getEffectiveRate(this.session.rate, this.session.totalAmount);
+  }
+  /**
+   * Get time until exhaustion (returns -1 if infinite)
+   */
+  getTimeUntilExhaustion(channelCapacity) {
+    if (this.session.state !== "active") {
+      return -1;
+    }
+    const remaining = BigInt(channelCapacity) - BigInt(this.getCurrentAmount());
+    if (remaining <= 0n) {
+      return 0;
+    }
+    const rate = BigInt(this.getCurrentRate());
+    if (rate <= 0n) {
+      return -1;
+    }
+    return Number(remaining / rate);
+  }
+  /**
+   * Check if stream is near exhaustion
+   */
+  isNearExhaustion(channelCapacity) {
+    const remaining = this.getTimeUntilExhaustion(channelCapacity);
+    return remaining >= 0 && remaining <= this.config.bufferTime;
+  }
+  /**
+   * Create manual checkpoint
+   */
+  createCheckpoint() {
+    const now = Date.now();
+    const amount = this.getCurrentAmount();
+    const checkpointId = `cp_${this.session.id}_${now}`;
+    this.emitEvent({
+      type: "checkpoint",
+      sessionId: this.session.id,
+      timestamp: now,
+      amount,
+      checkpointId
+    });
+    return { id: checkpointId, amount, timestamp: now };
+  }
+  /**
+   * Subscribe to stream events
+   */
+  onEvent(callback) {
+    this.eventListeners.add(callback);
+    return () => this.eventListeners.delete(callback);
+  }
+  /**
+   * Clean up resources
+   */
+  destroy() {
+    this.stopTimers();
+    this.eventListeners.clear();
+  }
+  startUpdateTimer() {
+    this.updateTimer = setInterval(() => {
+      if (this.session.state === "active") {
+        this.updateTotals(Date.now());
+      }
+    }, this.config.updateInterval);
+  }
+  startCheckpointTimer() {
+    this.checkpointTimer = setInterval(() => {
+      if (this.session.state === "active") {
+        this.createCheckpoint();
+      }
+    }, this.config.checkpointInterval * 1e3);
+  }
+  stopTimers() {
+    if (this.updateTimer) {
+      clearInterval(this.updateTimer);
+      this.updateTimer = void 0;
+    }
+    if (this.checkpointTimer) {
+      clearInterval(this.checkpointTimer);
+      this.checkpointTimer = void 0;
+    }
+  }
+  updateTotals(now) {
+    const elapsed = Math.floor((now - this.lastUpdateTime) / 1e3);
+    if (elapsed <= 0) return;
+    const amount = this.calculateAmount(elapsed, this.session.rate);
+    const newTotal = BigInt(this.session.totalAmount) + BigInt(amount);
+    this.session.totalDuration += elapsed;
+    this.session.totalAmount = newTotal.toString();
+    this.lastUpdateTime = now;
+    this.addMeteringRecord({
+      timestamp: now,
+      duration: elapsed,
+      amount,
+      rate: this.getCurrentRate(),
+      cumulative: this.session.totalAmount
+    });
+  }
+  calculateAmount(seconds, rate) {
+    const effectiveRate = this.getEffectiveRate(rate, this.session.totalAmount);
+    return (BigInt(effectiveRate) * BigInt(seconds)).toString();
+  }
+  getEffectiveRate(rate, totalAmount) {
+    if (rate.type === "fixed") {
+      return rate.baseRate;
+    }
+    if (rate.type === "tiered" && rate.tiers) {
+      const amount = BigInt(totalAmount);
+      let applicableRate = rate.baseRate;
+      for (const tier of rate.tiers) {
+        if (amount >= BigInt(tier.threshold)) {
+          applicableRate = tier.rate;
+        }
+      }
+      return applicableRate;
+    }
+    return rate.baseRate;
+  }
+  addMeteringRecord(record) {
+    this.session.meteringRecords.push(record);
+    if (this.session.meteringRecords.length > 1e3) {
+      this.session.meteringRecords = this.session.meteringRecords.slice(-1e3);
+    }
+  }
+  emitEvent(event) {
+    this.eventListeners.forEach((callback) => {
+      try {
+        callback(event);
+      } catch {
+      }
+    });
+  }
+  generateSessionId() {
+    return `ss_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+  }
+};
+function createFixedRateFlow(channelId, ratePerSecond, config) {
+  const rate = {
+    type: "fixed",
+    baseRate: ratePerSecond
+  };
+  const billingConfig = {
+    period: "realtime",
+    minimumCharge: "0",
+    roundingMode: "floor",
+    gracePeriod: 0
+  };
+  return new FlowController(channelId, rate, billingConfig, config);
+}
+function createTieredRateFlow(channelId, baseRate, tiers, config) {
+  const rate = {
+    type: "tiered",
+    baseRate,
+    tiers
+  };
+  const billingConfig = {
+    period: "realtime",
+    minimumCharge: "0",
+    roundingMode: "floor",
+    gracePeriod: 0
+  };
+  return new FlowController(channelId, rate, billingConfig, config);
+}
+
+// src/streaming/rate.ts
+var RateController = class {
+  currentRate;
+  config;
+  history = [];
+  lastChangeTime = 0;
+  constructor(initialRate, config = {}) {
+    this.currentRate = { ...initialRate };
+    this.config = {
+      maxChangePercent: config.maxChangePercent ?? 50,
+      minChangeInterval: config.minChangeInterval ?? 60,
+      smoothingFactor: config.smoothingFactor ?? 0.3
+    };
+  }
+  /**
+   * Get current rate configuration
+   */
+  getRate() {
+    return { ...this.currentRate };
+  }
+  /**
+   * Get current effective rate
+   */
+  getEffectiveRate(totalUsage) {
+    if (this.currentRate.type === "fixed") {
+      return this.currentRate.baseRate;
+    }
+    if (this.currentRate.type === "tiered" && this.currentRate.tiers && totalUsage) {
+      return this.calculateTieredRate(totalUsage);
+    }
+    return this.currentRate.baseRate;
+  }
+  /**
+   * Request rate adjustment
+   */
+  adjustRate(request) {
+    const now = Date.now();
+    const timeSinceLastChange = (now - this.lastChangeTime) / 1e3;
+    if (timeSinceLastChange < this.config.minChangeInterval) {
+      return {
+        success: false,
+        error: `Rate can only be changed every ${this.config.minChangeInterval} seconds`
+      };
+    }
+    const newRateBigInt = BigInt(request.newRate);
+    if (newRateBigInt <= 0n) {
+      return { success: false, error: "Rate must be positive" };
+    }
+    if (this.currentRate.minRate && newRateBigInt < BigInt(this.currentRate.minRate)) {
+      return {
+        success: false,
+        error: `Rate cannot be below minimum: ${this.currentRate.minRate}`
+      };
+    }
+    if (this.currentRate.maxRate && newRateBigInt > BigInt(this.currentRate.maxRate)) {
+      return {
+        success: false,
+        error: `Rate cannot exceed maximum: ${this.currentRate.maxRate}`
+      };
+    }
+    const currentRateBigInt = BigInt(this.currentRate.baseRate);
+    const changePercent = this.calculateChangePercent(currentRateBigInt, newRateBigInt);
+    let adjustedRate = request.newRate;
+    if (changePercent > this.config.maxChangePercent) {
+      adjustedRate = this.applyMaxChange(
+        currentRateBigInt,
+        newRateBigInt,
+        this.config.maxChangePercent
+      );
+    }
+    this.history.push({
+      timestamp: now,
+      rate: adjustedRate,
+      reason: request.reason,
+      previousRate: this.currentRate.baseRate
+    });
+    this.currentRate.baseRate = adjustedRate;
+    this.lastChangeTime = now;
+    return {
+      success: true,
+      newRate: adjustedRate,
+      adjustedAmount: adjustedRate !== request.newRate ? adjustedRate : void 0
+    };
+  }
+  /**
+   * Set rate bounds
+   */
+  setBounds(minRate, maxRate) {
+    if (minRate !== void 0) {
+      this.currentRate.minRate = minRate;
+    }
+    if (maxRate !== void 0) {
+      this.currentRate.maxRate = maxRate;
+    }
+  }
+  /**
+   * Add or update a tier
+   */
+  addTier(threshold, rate) {
+    if (this.currentRate.type !== "tiered") {
+      this.currentRate.type = "tiered";
+      this.currentRate.tiers = [];
+    }
+    const tiers = this.currentRate.tiers ?? [];
+    const existingIndex = tiers.findIndex((t) => t.threshold === threshold);
+    if (existingIndex >= 0) {
+      tiers[existingIndex].rate = rate;
+    } else {
+      tiers.push({ threshold, rate });
+      tiers.sort((a, b) => {
+        return BigInt(a.threshold) < BigInt(b.threshold) ? -1 : 1;
+      });
+    }
+    this.currentRate.tiers = tiers;
+  }
+  /**
+   * Remove a tier
+   */
+  removeTier(threshold) {
+    if (!this.currentRate.tiers) return false;
+    const initialLength = this.currentRate.tiers.length;
+    this.currentRate.tiers = this.currentRate.tiers.filter(
+      (t) => t.threshold !== threshold
+    );
+    return this.currentRate.tiers.length < initialLength;
+  }
+  /**
+   * Get rate history
+   */
+  getHistory() {
+    return [...this.history];
+  }
+  /**
+   * Calculate average rate over time period
+   */
+  getAverageRate(startTime, endTime) {
+    const relevantHistory = this.history.filter(
+      (h) => h.timestamp >= startTime && h.timestamp <= endTime
+    );
+    if (relevantHistory.length === 0) {
+      return this.currentRate.baseRate;
+    }
+    let totalWeight = 0n;
+    let weightedSum = 0n;
+    let prevTime = startTime;
+    for (const entry of relevantHistory) {
+      const duration = BigInt(entry.timestamp - prevTime);
+      weightedSum += BigInt(entry.previousRate) * duration;
+      totalWeight += duration;
+      prevTime = entry.timestamp;
+    }
+    const finalDuration = BigInt(endTime - prevTime);
+    weightedSum += BigInt(this.currentRate.baseRate) * finalDuration;
+    totalWeight += finalDuration;
+    if (totalWeight === 0n) {
+      return this.currentRate.baseRate;
+    }
+    return (weightedSum / totalWeight).toString();
+  }
+  /**
+   * Calculate rate for dynamic pricing based on demand
+   */
+  calculateDynamicRate(demand, _baseRate) {
+    const base = BigInt(this.currentRate.baseRate);
+    const min = this.currentRate.minRate ? BigInt(this.currentRate.minRate) : base / 2n;
+    const max = this.currentRate.maxRate ? BigInt(this.currentRate.maxRate) : base * 2n;
+    const range = max - min;
+    const adjustment = BigInt(Math.floor(Number(range) * demand));
+    return (min + adjustment).toString();
+  }
+  /**
+   * Apply exponential smoothing for rate changes
+   */
+  smoothRate(targetRate) {
+    const current = BigInt(this.currentRate.baseRate);
+    const target = BigInt(targetRate);
+    const alpha = this.config.smoothingFactor;
+    const smoothed = BigInt(Math.floor(
+      alpha * Number(target) + (1 - alpha) * Number(current)
+    ));
+    return smoothed.toString();
+  }
+  calculateTieredRate(totalUsage) {
+    const usage = BigInt(totalUsage);
+    const tiers = this.currentRate.tiers ?? [];
+    let applicableRate = this.currentRate.baseRate;
+    for (const tier of tiers) {
+      if (usage >= BigInt(tier.threshold)) {
+        applicableRate = tier.rate;
+      }
+    }
+    return applicableRate;
+  }
+  calculateChangePercent(from, to) {
+    if (from === 0n) return 100;
+    const diff = to > from ? to - from : from - to;
+    return Number(diff * 100n / from);
+  }
+  applyMaxChange(from, to, maxPercent) {
+    const maxChange = from * BigInt(maxPercent) / 100n;
+    if (to > from) {
+      return (from + maxChange).toString();
+    } else {
+      return (from - maxChange).toString();
+    }
+  }
+};
+var RateLimiter = class {
+  requests = /* @__PURE__ */ new Map();
+  maxRequests;
+  windowMs;
+  constructor(maxRequests = 10, windowMs = 6e4) {
+    this.maxRequests = maxRequests;
+    this.windowMs = windowMs;
+  }
+  /**
+   * Check if request is allowed
+   */
+  isAllowed(key) {
+    const now = Date.now();
+    const windowStart = now - this.windowMs;
+    let requests = this.requests.get(key) ?? [];
+    requests = requests.filter((t) => t > windowStart);
+    if (requests.length >= this.maxRequests) {
+      return false;
+    }
+    requests.push(now);
+    this.requests.set(key, requests);
+    return true;
+  }
+  /**
+   * Get remaining requests in window
+   */
+  getRemainingRequests(key) {
+    const now = Date.now();
+    const windowStart = now - this.windowMs;
+    const requests = (this.requests.get(key) ?? []).filter((t) => t > windowStart);
+    return Math.max(0, this.maxRequests - requests.length);
+  }
+  /**
+   * Reset limits for a key
+   */
+  reset(key) {
+    this.requests.delete(key);
+  }
+  /**
+   * Clear all limits
+   */
+  clear() {
+    this.requests.clear();
+  }
+};
+function calculateOptimalRate(channelCapacity, desiredDurationSeconds, bufferPercent = 10) {
+  const capacity = BigInt(channelCapacity);
+  const duration = BigInt(desiredDurationSeconds);
+  if (duration === 0n) {
+    return "0";
+  }
+  const effectiveCapacity = capacity * BigInt(100 - bufferPercent) / 100n;
+  return (effectiveCapacity / duration).toString();
+}
+function convertRate(rate, fromUnit, toUnit) {
+  const unitToSeconds = {
+    second: 1,
+    minute: 60,
+    hour: 3600,
+    day: 86400
+  };
+  const fromSeconds = unitToSeconds[fromUnit];
+  const toSeconds = unitToSeconds[toUnit];
+  const rateBigInt = BigInt(rate);
+  const perSecond = rateBigInt / BigInt(fromSeconds);
+  return (perSecond * BigInt(toSeconds)).toString();
+}
+
+// src/streaming/metering.ts
+var MeteringManager = class {
+  records = [];
+  config;
+  sessionId;
+  startTime;
+  constructor(sessionId, config = {}) {
+    this.sessionId = sessionId;
+    this.startTime = Date.now();
+    this.config = {
+      recordInterval: config.recordInterval ?? 1,
+      aggregationInterval: config.aggregationInterval ?? 3600,
+      maxRecords: config.maxRecords ?? 1e4,
+      precision: config.precision ?? 18
+    };
+  }
+  /**
+   * Record usage
+   */
+  record(duration, amount, rate, metadata) {
+    const cumulative = this.calculateCumulative(amount);
+    const record = {
+      timestamp: Date.now(),
+      duration,
+      amount,
+      rate,
+      cumulative,
+      metadata
+    };
+    this.records.push(record);
+    if (this.records.length > this.config.maxRecords) {
+      this.pruneRecords();
+    }
+    return record;
+  }
+  /**
+   * Get all records
+   */
+  getRecords() {
+    return [...this.records];
+  }
+  /**
+   * Get records in time range
+   */
+  getRecordsInRange(startTime, endTime) {
+    return this.records.filter(
+      (r) => r.timestamp >= startTime && r.timestamp <= endTime
+    );
+  }
+  /**
+   * Calculate usage metrics
+   */
+  getMetrics() {
+    if (this.records.length === 0) {
+      return {
+        totalSeconds: 0,
+        totalAmount: "0",
+        averageRate: "0",
+        peakRate: "0",
+        startTime: this.startTime
+      };
+    }
+    const totalSeconds = this.records.reduce((sum, r) => sum + r.duration, 0);
+    const totalAmount = this.records[this.records.length - 1].cumulative;
+    const rates = this.records.map((r) => BigInt(r.rate));
+    const peakRate = rates.length > 0 ? rates.reduce((max, r) => r > max ? r : max, 0n) : 0n;
+    const averageRate = totalSeconds > 0 ? (BigInt(totalAmount) / BigInt(totalSeconds)).toString() : "0";
+    return {
+      totalSeconds,
+      totalAmount,
+      averageRate,
+      peakRate: peakRate.toString(),
+      startTime: this.startTime,
+      endTime: this.records[this.records.length - 1].timestamp,
+      hourly: this.getHourlyBreakdown()
+    };
+  }
+  /**
+   * Get aggregated usage by period
+   */
+  aggregate(intervalSeconds = 3600) {
+    if (this.records.length === 0) return [];
+    const aggregated = [];
+    const intervalMs = intervalSeconds * 1e3;
+    const groups = /* @__PURE__ */ new Map();
+    for (const record of this.records) {
+      const periodStart = Math.floor(record.timestamp / intervalMs) * intervalMs;
+      const existing = groups.get(periodStart) ?? [];
+      existing.push(record);
+      groups.set(periodStart, existing);
+    }
+    for (const [periodStart, records] of groups) {
+      const totalAmount = records.reduce(
+        (sum, r) => sum + BigInt(r.amount),
+        0n
+      );
+      const totalDuration = records.reduce((sum, r) => sum + r.duration, 0);
+      const averageRate = totalDuration > 0 ? (totalAmount / BigInt(totalDuration)).toString() : "0";
+      aggregated.push({
+        period: new Date(periodStart).toISOString(),
+        totalAmount: totalAmount.toString(),
+        totalDuration,
+        averageRate,
+        recordCount: records.length
+      });
+    }
+    return aggregated.sort((a, b) => a.period.localeCompare(b.period));
+  }
+  /**
+   * Get cumulative amount at a point in time
+   */
+  getCumulativeAt(timestamp) {
+    for (let i = this.records.length - 1; i >= 0; i--) {
+      if (this.records[i].timestamp <= timestamp) {
+        return this.records[i].cumulative;
+      }
+    }
+    return "0";
+  }
+  /**
+   * Calculate usage for billing period
+   */
+  getUsageForBillingPeriod(startTime, endTime) {
+    const periodRecords = this.getRecordsInRange(startTime, endTime);
+    const amount = periodRecords.reduce(
+      (sum, r) => sum + BigInt(r.amount),
+      0n
+    );
+    const duration = periodRecords.reduce((sum, r) => sum + r.duration, 0);
+    return {
+      amount: amount.toString(),
+      duration,
+      records: periodRecords.length
+    };
+  }
+  /**
+   * Export records for backup/audit
+   */
+  export() {
+    return JSON.stringify({
+      sessionId: this.sessionId,
+      startTime: this.startTime,
+      records: this.records,
+      exportedAt: Date.now()
+    });
+  }
+  /**
+   * Import records from backup
+   */
+  import(data) {
+    try {
+      const parsed = JSON.parse(data);
+      if (parsed.sessionId !== this.sessionId) {
+        return { success: false, recordsImported: 0 };
+      }
+      const importedRecords = parsed.records;
+      let importedCount = 0;
+      for (const record of importedRecords) {
+        const exists = this.records.some((r) => r.timestamp === record.timestamp);
+        if (!exists) {
+          this.records.push(record);
+          importedCount++;
+        }
+      }
+      this.records.sort((a, b) => a.timestamp - b.timestamp);
+      return { success: true, recordsImported: importedCount };
+    } catch {
+      return { success: false, recordsImported: 0 };
+    }
+  }
+  /**
+   * Clear all records
+   */
+  clear() {
+    this.records = [];
+  }
+  calculateCumulative(newAmount) {
+    if (this.records.length === 0) {
+      return newAmount;
+    }
+    const lastCumulative = BigInt(this.records[this.records.length - 1].cumulative);
+    return (lastCumulative + BigInt(newAmount)).toString();
+  }
+  pruneRecords() {
+    const keepCount = this.config.maxRecords;
+    if (this.records.length <= keepCount) return;
+    const first = this.records[0];
+    const recent = this.records.slice(-(keepCount - 1));
+    this.records = [first, ...recent];
+  }
+  getHourlyBreakdown() {
+    const hourlyMap = /* @__PURE__ */ new Map();
+    for (const record of this.records) {
+      const hour = new Date(record.timestamp).getUTCHours();
+      const existing = hourlyMap.get(hour) ?? { amount: 0n, seconds: 0 };
+      existing.amount += BigInt(record.amount);
+      existing.seconds += record.duration;
+      hourlyMap.set(hour, existing);
+    }
+    return Array.from(hourlyMap.entries()).map(([hour, data]) => ({
+      hour,
+      amount: data.amount.toString(),
+      seconds: data.seconds
+    }));
+  }
+};
+function calculateProRatedUsage(fullPeriodAmount, fullPeriodSeconds, actualSeconds) {
+  if (fullPeriodSeconds === 0) return "0";
+  const amount = BigInt(fullPeriodAmount);
+  return (amount * BigInt(actualSeconds) / BigInt(fullPeriodSeconds)).toString();
+}
+function estimateUsage(metrics, futureSeconds) {
+  if (metrics.totalSeconds === 0) return "0";
+  const avgRate = BigInt(metrics.averageRate);
+  return (avgRate * BigInt(futureSeconds)).toString();
+}
+function compareUsage(current, previous) {
+  const currentAmount = BigInt(current.totalAmount);
+  const previousAmount = BigInt(previous.totalAmount);
+  const amountChange = currentAmount - previousAmount;
+  const amountChangePercent = previousAmount > 0n ? Number(amountChange * 100n / previousAmount) : 0;
+  const currentRate = BigInt(current.averageRate);
+  const previousRate = BigInt(previous.averageRate);
+  const rateChange = currentRate - previousRate;
+  const rateChangePercent = previousRate > 0n ? Number(rateChange * 100n / previousRate) : 0;
+  return {
+    amountChange: amountChange.toString(),
+    amountChangePercent,
+    rateChange: rateChange.toString(),
+    rateChangePercent
+  };
+}
+
+// src/streaming/billing.ts
+var BillingManager = class {
+  config;
+  billingConfig;
+  invoices = [];
+  channelId;
+  payer;
+  payee;
+  lastInvoiceTime;
+  constructor(channelId, payer, payee, billingConfig, config = {}) {
+    this.channelId = channelId;
+    this.payer = payer;
+    this.payee = payee;
+    this.billingConfig = billingConfig;
+    this.lastInvoiceTime = Date.now();
+    this.config = {
+      autoInvoice: config.autoInvoice ?? false,
+      invoiceInterval: config.invoiceInterval ?? 86400,
+      currency: config.currency ?? "USDT",
+      taxRate: config.taxRate ?? 0
+    };
+  }
+  /**
+   * Generate invoice from metering records
+   */
+  generateInvoice(records, startTime, endTime) {
+    const items = this.createInvoiceItems(records, startTime, endTime);
+    const subtotal = this.calculateSubtotal(items);
+    const fees = this.calculateFees(subtotal);
+    const total = (BigInt(subtotal) + BigInt(fees)).toString();
+    const invoice = {
+      id: this.generateInvoiceId(),
+      channelId: this.channelId,
+      payer: this.payer,
+      payee: this.payee,
+      items,
+      subtotal,
+      fees,
+      total,
+      currency: this.config.currency,
+      status: "pending",
+      createdAt: Date.now(),
+      dueAt: Date.now() + 864e5
+      // Due in 24 hours
+    };
+    this.invoices.push(invoice);
+    this.lastInvoiceTime = endTime;
+    return invoice;
+  }
+  /**
+   * Get all invoices
+   */
+  getInvoices() {
+    return [...this.invoices];
+  }
+  /**
+   * Get invoice by ID
+   */
+  getInvoice(id) {
+    return this.invoices.find((inv) => inv.id === id);
+  }
+  /**
+   * Mark invoice as paid
+   */
+  markPaid(invoiceId) {
+    const invoice = this.invoices.find((inv) => inv.id === invoiceId);
+    if (!invoice || invoice.status !== "pending") {
+      return false;
+    }
+    invoice.status = "paid";
+    invoice.paidAt = Date.now();
+    return true;
+  }
+  /**
+   * Mark invoice as settled
+   */
+  markSettled(invoiceId) {
+    const invoice = this.invoices.find((inv) => inv.id === invoiceId);
+    if (!invoice) return false;
+    invoice.status = "settled";
+    return true;
+  }
+  /**
+   * Get pending amount
+   */
+  getPendingAmount() {
+    return this.invoices.filter((inv) => inv.status === "pending").reduce((sum, inv) => sum + BigInt(inv.total), 0n).toString();
+  }
+  /**
+   * Get total billed amount
+   */
+  getTotalBilled() {
+    return this.invoices.reduce((sum, inv) => sum + BigInt(inv.total), 0n).toString();
+  }
+  /**
+   * Check if new invoice is due
+   */
+  isInvoiceDue(currentTime) {
+    const elapsed = currentTime - this.lastInvoiceTime;
+    return elapsed >= this.config.invoiceInterval * 1e3;
+  }
+  /**
+   * Calculate amount for billing period
+   */
+  calculatePeriodAmount(rate, durationSeconds) {
+    const periodSeconds = this.getPeriodSeconds(this.billingConfig.period);
+    const periods = durationSeconds / periodSeconds;
+    const amount = BigInt(rate) * BigInt(Math.floor(periods * periodSeconds));
+    return this.applyRounding(amount.toString());
+  }
+  /**
+   * Apply minimum charge
+   */
+  applyMinimumCharge(amount) {
+    const minCharge = BigInt(this.billingConfig.minimumCharge);
+    const actualAmount = BigInt(amount);
+    return (actualAmount < minCharge ? minCharge : actualAmount).toString();
+  }
+  /**
+   * Calculate grace period savings
+   */
+  calculateGracePeriodSavings(rate, totalDuration) {
+    const gracePeriod = this.billingConfig.gracePeriod;
+    if (gracePeriod <= 0 || totalDuration <= gracePeriod) {
+      return "0";
+    }
+    return (BigInt(rate) * BigInt(Math.min(gracePeriod, totalDuration))).toString();
+  }
+  /**
+   * Get billing summary
+   */
+  getSummary() {
+    const totalBilled = this.getTotalBilled();
+    const totalPaid = this.invoices.filter((inv) => inv.status === "paid" || inv.status === "settled").reduce((sum, inv) => sum + BigInt(inv.total), 0n).toString();
+    const totalPending = this.getPendingAmount();
+    const averageInvoice = this.invoices.length > 0 ? (BigInt(totalBilled) / BigInt(this.invoices.length)).toString() : "0";
+    return {
+      totalInvoices: this.invoices.length,
+      totalBilled,
+      totalPaid,
+      totalPending,
+      averageInvoice
+    };
+  }
+  /**
+   * Export billing data
+   */
+  export() {
+    return JSON.stringify({
+      channelId: this.channelId,
+      invoices: this.invoices,
+      exportedAt: Date.now()
+    });
+  }
+  createInvoiceItems(records, startTime, endTime) {
+    if (records.length === 0) {
+      return [];
+    }
+    const rateGroups = /* @__PURE__ */ new Map();
+    for (const record of records) {
+      const existing = rateGroups.get(record.rate) ?? [];
+      existing.push(record);
+      rateGroups.set(record.rate, existing);
+    }
+    const items = [];
+    for (const [rate, groupRecords] of rateGroups) {
+      const totalDuration = groupRecords.reduce((sum, r) => sum + r.duration, 0);
+      const totalAmount = groupRecords.reduce(
+        (sum, r) => sum + BigInt(r.amount),
+        0n
+      );
+      const periodName = this.getPeriodName(this.billingConfig.period);
+      const quantity = this.calculateQuantity(totalDuration);
+      items.push({
+        description: `Streaming usage at ${rate} per ${periodName}`,
+        quantity,
+        rate,
+        amount: totalAmount.toString(),
+        startTime,
+        endTime
+      });
+    }
+    return items;
+  }
+  calculateSubtotal(items) {
+    return items.reduce((sum, item) => sum + BigInt(item.amount), 0n).toString();
+  }
+  calculateFees(subtotal) {
+    const amount = BigInt(subtotal);
+    const taxRate = this.config.taxRate;
+    if (taxRate <= 0) return "0";
+    return BigInt(Math.floor(Number(amount) * taxRate)).toString();
+  }
+  applyRounding(amount) {
+    const value = BigInt(amount);
+    const mode = this.billingConfig.roundingMode;
+    switch (mode) {
+      case "floor":
+        return value.toString();
+      case "ceil":
+        return value.toString();
+      case "round":
+        return value.toString();
+      default:
+        return value.toString();
+    }
+  }
+  getPeriodSeconds(period) {
+    switch (period) {
+      case "realtime":
+      case "second":
+        return 1;
+      case "minute":
+        return 60;
+      case "hour":
+        return 3600;
+      case "day":
+        return 86400;
+    }
+  }
+  getPeriodName(period) {
+    switch (period) {
+      case "realtime":
+      case "second":
+        return "second";
+      case "minute":
+        return "minute";
+      case "hour":
+        return "hour";
+      case "day":
+        return "day";
+    }
+  }
+  calculateQuantity(totalSeconds) {
+    const periodSeconds = this.getPeriodSeconds(this.billingConfig.period);
+    return totalSeconds / periodSeconds;
+  }
+  generateInvoiceId() {
+    return `inv_${this.channelId.slice(-8)}_${Date.now().toString(36)}`;
+  }
+};
+function formatCurrencyAmount(amount, decimals = 6, symbol = "USDT") {
+  const value = BigInt(amount);
+  const divisor = BigInt(10 ** decimals);
+  const wholePart = value / divisor;
+  const fractionalPart = value % divisor;
+  const fractionalStr = fractionalPart.toString().padStart(decimals, "0");
+  const trimmedFractional = fractionalStr.replace(/0+$/, "") || "0";
+  return `${wholePart}.${trimmedFractional} ${symbol}`;
+}
+function parseCurrencyAmount(display, decimals = 6) {
+  const cleaned = display.replace(/[^\d.]/g, "");
+  const [whole, fractional = ""] = cleaned.split(".");
+  const paddedFractional = fractional.slice(0, decimals).padEnd(decimals, "0");
+  const combined = whole + paddedFractional;
+  return BigInt(combined).toString();
+}
+function estimateFutureBill(currentRate, durationSeconds, minimumCharge = "0") {
+  const estimated = BigInt(currentRate) * BigInt(durationSeconds);
+  const minimum = BigInt(minimumCharge);
+  return (estimated < minimum ? minimum : estimated).toString();
+}
+
+// src/settlement/types.ts
+import { z as z3 } from "zod";
+var SettlementState = z3.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 = z3.enum([
+  "periodic",
+  // Regular interval checkpoint
+  "manual",
+  // Manually triggered
+  "balance",
+  // Triggered by balance threshold
+  "pre_close",
+  // Before channel close
+  "dispute"
+  // Checkpoint for dispute
+]);
+var SettlementCheckpoint = z3.object({
+  id: z3.string(),
+  channelId: z3.string(),
+  sequence: z3.number(),
+  type: CheckpointType,
+  // Balances
+  payerBalance: z3.string(),
+  payeeBalance: z3.string(),
+  totalStreamed: z3.string(),
+  // Signatures
+  payerSignature: z3.string(),
+  payeeSignature: z3.string().optional(),
+  // Verification
+  stateHash: z3.string(),
+  merkleRoot: z3.string().optional(),
+  // Timing
+  createdAt: z3.number(),
+  expiresAt: z3.number().optional(),
+  // On-chain reference
+  txHash: z3.string().optional(),
+  blockNumber: z3.number().optional()
+});
+var SettlementRequest = z3.object({
+  channelId: z3.string(),
+  initiator: z3.string(),
+  finalCheckpoint: SettlementCheckpoint,
+  reason: z3.enum(["mutual", "unilateral", "timeout", "dispute_resolution"]),
+  signature: z3.string(),
+  metadata: z3.record(z3.unknown()).optional()
+});
+var SettlementResult = z3.object({
+  success: z3.boolean(),
+  settlementId: z3.string().optional(),
+  error: z3.string().optional(),
+  finalBalances: z3.object({
+    payer: z3.string(),
+    payee: z3.string()
+  }).optional(),
+  txHash: z3.string().optional(),
+  timestamp: z3.number()
+});
+var DisputeReason = z3.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 = z3.object({
+  type: z3.enum(["checkpoint", "signature", "transaction", "state_proof"]),
+  data: z3.string(),
+  description: z3.string(),
+  timestamp: z3.number(),
+  verified: z3.boolean().default(false)
+});
+var Dispute = z3.object({
+  id: z3.string(),
+  channelId: z3.string(),
+  initiator: z3.string(),
+  respondent: z3.string(),
+  reason: DisputeReason,
+  description: z3.string(),
+  // Claimed state
+  claimedPayerBalance: z3.string(),
+  claimedPayeeBalance: z3.string(),
+  claimedCheckpoint: SettlementCheckpoint.optional(),
+  // Evidence
+  evidence: z3.array(DisputeEvidence),
+  responseEvidence: z3.array(DisputeEvidence).optional(),
+  // Resolution
+  status: z3.enum(["pending", "under_review", "resolved", "rejected", "timeout"]),
+  resolution: z3.object({
+    winner: z3.string().optional(),
+    finalPayerBalance: z3.string(),
+    finalPayeeBalance: z3.string(),
+    reason: z3.string(),
+    timestamp: z3.number()
+  }).optional(),
+  // Timing
+  createdAt: z3.number(),
+  responseDeadline: z3.number(),
+  resolutionDeadline: z3.number()
+});
+var SettlementConfig = z3.object({
+  challengePeriod: z3.number().default(86400),
+  // 24 hours
+  disputeResponsePeriod: z3.number().default(43200),
+  // 12 hours
+  disputeResolutionPeriod: z3.number().default(172800),
+  // 48 hours
+  minCheckpointInterval: z3.number().default(60),
+  // 60 seconds
+  maxCheckpointsStored: z3.number().default(100),
+  settlementFee: z3.string().default("0"),
+  disputeBond: z3.string().default("0")
+  // Bond required to raise dispute
+});
+var OnChainSettlement = z3.object({
+  channelId: z3.string(),
+  settlementId: z3.string(),
+  txHash: z3.string(),
+  blockNumber: z3.number(),
+  payerReceived: z3.string(),
+  payeeReceived: z3.string(),
+  fee: z3.string(),
+  timestamp: z3.number(),
+  finalized: z3.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 {
+  BillingConfig,
+  BillingManager,
+  BillingPeriod,
+  ChannelBalance,
+  ChannelCheckpoint,
+  ChannelCloseRequest,
+  ChannelCloser,
+  ChannelConfig,
+  ChannelCreateRequest,
+  ChannelDispute,
+  ChannelOpener,
+  ChannelParticipant,
+  ChannelRecovery,
+  ChannelState,
+  ChannelStateMachine,
+  CheckpointManager,
+  CheckpointType,
+  Dispute,
+  DisputeEvidence,
+  DisputeManager,
+  DisputeReason,
+  FinalSettlementManager,
+  FlowController,
+  FundingTransaction,
+  Invoice,
+  InvoiceItem,
+  MeteringManager,
+  MeteringRecord,
+  OnChainSettlement,
+  RateAdjustmentRequest,
+  RateController,
+  RateLimiter,
+  RateType,
+  RecoveryData,
+  SettlementCheckpoint,
+  SettlementConfig,
+  SettlementRequest,
+  SettlementResult,
+  SettlementState,
+  StateTransition,
+  StreamEvent,
+  StreamRate,
+  StreamSession,
+  StreamState,
+  StreamingChannel,
+  UsageMetrics,
+  buildCloseTransactionData,
+  calculateOptimalRate,
+  calculateProRatedUsage,
+  calculateRequiredDeposit,
+  compareUsage,
+  convertRate,
+  createCheckpointEvidence,
+  createFixedRateFlow,
+  createSignatureEvidence,
+  createStateSnapshot,
+  createTieredRateFlow,
+  createTransactionEvidence,
+  estimateChannelDuration,
+  estimateFutureBill,
+  estimateSettlementGas,
+  estimateUsage,
+  formatCurrencyAmount,
+  getChannelUtilization,
+  isChannelActive,
+  isChannelTerminal,
+  parseCurrencyAmount,
+  restoreFromSnapshot,
+  signCheckpoint,
+  verifyCheckpointSignature,
+  verifySettlementOnChain
+};
+//# sourceMappingURL=index.js.map