@t402/streaming-payments 1.0.0-beta.1

package/dist/streaming/index.js

@@ -0,0 +1,1321 @@
+// src/streaming/types.ts
+import { z } from "zod";
+var StreamState = z.enum([
+  "idle",
+  // Stream not started
+  "active",
+  // Streaming in progress
+  "paused",
+  // Temporarily paused
+  "completed",
+  // Stream completed (exhausted)
+  "cancelled"
+  // Stream cancelled
+]);
+var RateType = z.enum([
+  "fixed",
+  // Fixed rate per second
+  "variable",
+  // Rate can change
+  "tiered",
+  // Different rates based on usage
+  "dynamic"
+  // Demand-based pricing
+]);
+var StreamRate = z.object({
+  type: RateType,
+  baseRate: z.string(),
+  // Base rate per second
+  minRate: z.string().optional(),
+  // Minimum rate
+  maxRate: z.string().optional(),
+  // Maximum rate
+  // For tiered rates
+  tiers: z.array(z.object({
+    threshold: z.string(),
+    // Usage threshold
+    rate: z.string()
+    // Rate after threshold
+  })).optional(),
+  // For dynamic rates
+  adjustmentInterval: z.number().optional(),
+  // How often to adjust (seconds)
+  adjustmentFactor: z.number().optional()
+  // Max adjustment per interval
+});
+var UsageMetrics = z.object({
+  totalSeconds: z.number(),
+  totalAmount: z.string(),
+  averageRate: z.string(),
+  peakRate: z.string(),
+  startTime: z.number(),
+  endTime: z.number().optional(),
+  // Breakdown by period
+  hourly: z.array(z.object({
+    hour: z.number(),
+    amount: z.string(),
+    seconds: z.number()
+  })).optional()
+});
+var MeteringRecord = z.object({
+  timestamp: z.number(),
+  duration: z.number(),
+  // Seconds since last record
+  amount: z.string(),
+  // Amount for this period
+  rate: z.string(),
+  // Rate applied
+  cumulative: z.string(),
+  // Cumulative total
+  metadata: z.record(z.unknown()).optional()
+});
+var BillingPeriod = z.enum([
+  "realtime",
+  // Continuous real-time billing
+  "second",
+  // Per-second
+  "minute",
+  // Per-minute
+  "hour",
+  // Per-hour
+  "day"
+  // Per-day
+]);
+var BillingConfig = z.object({
+  period: BillingPeriod,
+  minimumCharge: z.string().default("0"),
+  roundingMode: z.enum(["floor", "ceil", "round"]).default("floor"),
+  gracePeriod: z.number().default(0),
+  // Seconds of free usage
+  invoiceInterval: z.number().optional()
+  // Generate invoice every N seconds
+});
+var InvoiceItem = z.object({
+  description: z.string(),
+  quantity: z.number(),
+  // Duration in billing periods
+  rate: z.string(),
+  amount: z.string(),
+  startTime: z.number(),
+  endTime: z.number()
+});
+var Invoice = z.object({
+  id: z.string(),
+  channelId: z.string(),
+  payer: z.string(),
+  payee: z.string(),
+  items: z.array(InvoiceItem),
+  subtotal: z.string(),
+  fees: z.string(),
+  total: z.string(),
+  currency: z.string(),
+  status: z.enum(["pending", "paid", "settled", "disputed"]),
+  createdAt: z.number(),
+  dueAt: z.number().optional(),
+  paidAt: z.number().optional()
+});
+var StreamSession = z.object({
+  id: z.string(),
+  channelId: z.string(),
+  state: StreamState,
+  rate: StreamRate,
+  startedAt: z.number().optional(),
+  pausedAt: z.number().optional(),
+  endedAt: z.number().optional(),
+  totalDuration: z.number(),
+  // Total streaming seconds
+  totalAmount: z.string(),
+  // Total amount streamed
+  meteringRecords: z.array(MeteringRecord),
+  billingConfig: BillingConfig,
+  invoices: z.array(z.string())
+  // Invoice IDs
+});
+var RateAdjustmentRequest = z.object({
+  sessionId: z.string(),
+  newRate: z.string(),
+  reason: z.string(),
+  effectiveFrom: z.number().optional(),
+  // Timestamp, default now
+  signature: z.string().optional()
+  // For mutual rate changes
+});
+var StreamEvent = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("started"),
+    sessionId: z.string(),
+    timestamp: z.number(),
+    rate: z.string()
+  }),
+  z.object({
+    type: z.literal("paused"),
+    sessionId: z.string(),
+    timestamp: z.number(),
+    totalStreamed: z.string()
+  }),
+  z.object({
+    type: z.literal("resumed"),
+    sessionId: z.string(),
+    timestamp: z.number()
+  }),
+  z.object({
+    type: z.literal("rate_changed"),
+    sessionId: z.string(),
+    timestamp: z.number(),
+    oldRate: z.string(),
+    newRate: z.string()
+  }),
+  z.object({
+    type: z.literal("checkpoint"),
+    sessionId: z.string(),
+    timestamp: z.number(),
+    amount: z.string(),
+    checkpointId: z.string()
+  }),
+  z.object({
+    type: z.literal("completed"),
+    sessionId: z.string(),
+    timestamp: z.number(),
+    totalAmount: z.string(),
+    totalDuration: z.number()
+  }),
+  z.object({
+    type: z.literal("cancelled"),
+    sessionId: z.string(),
+    timestamp: z.number(),
+    reason: z.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();
+}
+export {
+  BillingConfig,
+  BillingManager,
+  BillingPeriod,
+  FlowController,
+  Invoice,
+  InvoiceItem,
+  MeteringManager,
+  MeteringRecord,
+  RateAdjustmentRequest,
+  RateController,
+  RateLimiter,
+  RateType,
+  StreamEvent,
+  StreamRate,
+  StreamSession,
+  StreamState,
+  UsageMetrics,
+  calculateOptimalRate,
+  calculateProRatedUsage,
+  compareUsage,
+  convertRate,
+  createFixedRateFlow,
+  createTieredRateFlow,
+  estimateFutureBill,
+  estimateUsage,
+  formatCurrencyAmount,
+  parseCurrencyAmount
+};
+//# sourceMappingURL=index.js.map