@t402/smart-router 1.0.0-beta.1

package/dist/chunk-BUGQ6VOQ.js

@@ -0,0 +1,662 @@
+import {
+  AssetId,
+  ChainId,
+  ProtocolId
+} from "./chunk-QIZPPHGB.js";
+
+// src/pricing/types.ts
+import { z } from "zod";
+var GasPrice = z.object({
+  chain: ChainId,
+  // Price in native token (wei for EVM)
+  slow: z.string(),
+  standard: z.string(),
+  fast: z.string(),
+  instant: z.string(),
+  // EIP-1559 fields (for supported chains)
+  baseFee: z.string().optional(),
+  priorityFee: z.object({
+    slow: z.string(),
+    standard: z.string(),
+    fast: z.string(),
+    instant: z.string()
+  }).optional(),
+  // Native token price in USD
+  nativeTokenPriceUsd: z.string(),
+  // Block info
+  lastBlock: z.number(),
+  timestamp: z.number()
+});
+var TokenPrice = z.object({
+  chain: ChainId,
+  asset: AssetId,
+  priceUsd: z.string(),
+  price24hChange: z.string().optional(),
+  volume24h: z.string().optional(),
+  source: z.string(),
+  // Price oracle source
+  timestamp: z.number(),
+  confidence: z.number().min(0).max(100)
+});
+var ProtocolFees = z.object({
+  protocol: ProtocolId,
+  chain: ChainId,
+  // Fee types
+  swapFee: z.string().optional(),
+  // Percentage (e.g., "0.3" for 0.3%)
+  bridgeFee: z.object({
+    percentage: z.string(),
+    minimum: z.string(),
+    maximum: z.string().optional()
+  }).optional(),
+  // Gas estimates for different operations
+  gasEstimates: z.record(z.string(), z.string()),
+  // Operation -> gas units
+  timestamp: z.number()
+});
+var BridgeQuote = z.object({
+  bridge: ProtocolId,
+  sourceChain: ChainId,
+  destinationChain: ChainId,
+  sourceAsset: AssetId,
+  destinationAsset: AssetId,
+  inputAmount: z.string(),
+  outputAmount: z.string(),
+  fee: z.string(),
+  feeUsd: z.string(),
+  estimatedTime: z.number(),
+  // Seconds
+  confidence: z.number().min(0).max(100),
+  expiresAt: z.number()
+});
+var SwapQuote = z.object({
+  dex: ProtocolId,
+  chain: ChainId,
+  inputAsset: AssetId,
+  outputAsset: AssetId,
+  inputAmount: z.string(),
+  outputAmount: z.string(),
+  minOutputAmount: z.string(),
+  priceImpact: z.string(),
+  fee: z.string(),
+  feeUsd: z.string(),
+  route: z.array(AssetId),
+  // Token path
+  estimatedGas: z.string(),
+  expiresAt: z.number()
+});
+var FeeEstimateRequest = z.object({
+  chain: ChainId,
+  operation: z.enum(["transfer", "swap", "bridge", "approve", "wrap", "unwrap"]),
+  protocol: ProtocolId.optional(),
+  inputAsset: AssetId,
+  outputAsset: AssetId.optional(),
+  amount: z.string(),
+  gasSpeed: z.enum(["slow", "standard", "fast", "instant"]).default("standard")
+});
+var FeeEstimate = z.object({
+  // Gas
+  gasUnits: z.string(),
+  gasPriceWei: z.string(),
+  gasCostNative: z.string(),
+  gasCostUsd: z.string(),
+  // Protocol fees
+  protocolFee: z.string(),
+  protocolFeeUsd: z.string(),
+  // Total
+  totalFeeUsd: z.string(),
+  // Metadata
+  confidence: z.number().min(0).max(100),
+  breakdown: z.array(z.object({
+    type: z.string(),
+    amount: z.string(),
+    amountUsd: z.string()
+  }))
+});
+var PricePrediction = z.object({
+  chain: ChainId,
+  asset: AssetId.optional(),
+  // If not provided, predicts gas price
+  currentPrice: z.string(),
+  predictions: z.array(z.object({
+    timestamp: z.number(),
+    predictedPrice: z.string(),
+    confidence: z.number(),
+    lowerBound: z.string(),
+    upperBound: z.string()
+  })),
+  model: z.string(),
+  lastUpdated: z.number()
+});
+
+// src/pricing/gas.ts
+var GasOracle = class {
+  providers = /* @__PURE__ */ new Map();
+  cache = /* @__PURE__ */ new Map();
+  config;
+  history = /* @__PURE__ */ new Map();
+  maxHistorySize = 100;
+  constructor(config = {}) {
+    this.config = {
+      cacheTtl: config.cacheTtl ?? 15e3,
+      // 15 seconds
+      refreshInterval: config.refreshInterval ?? 12e3,
+      // 12 seconds (block time)
+      enablePrediction: config.enablePrediction ?? true
+    };
+  }
+  /**
+   * Register a gas provider for a chain
+   */
+  registerProvider(chain, provider) {
+    this.providers.set(chain, provider);
+  }
+  /**
+   * Get current gas price for a chain
+   */
+  async getGasPrice(chain) {
+    const cached = this.cache.get(chain);
+    if (cached && cached.expiresAt > Date.now()) {
+      return cached.data;
+    }
+    const provider = this.providers.get(chain);
+    let gasPrice;
+    if (provider) {
+      gasPrice = await provider.getGasPrice(chain);
+    } else {
+      gasPrice = this.getMockGasPrice(chain);
+    }
+    this.cache.set(chain, {
+      data: gasPrice,
+      expiresAt: Date.now() + this.config.cacheTtl
+    });
+    this.addToHistory(chain, gasPrice);
+    return gasPrice;
+  }
+  /**
+   * Get gas prices for multiple chains
+   */
+  async getMultiChainGasPrices(chains) {
+    const results = /* @__PURE__ */ new Map();
+    await Promise.all(
+      chains.map(async (chain) => {
+        try {
+          const price = await this.getGasPrice(chain);
+          results.set(chain, price);
+        } catch {
+        }
+      })
+    );
+    return results;
+  }
+  /**
+   * Calculate gas cost in USD
+   */
+  async calculateGasCostUsd(chain, gasUnits, speed = "standard") {
+    const gasPrice = await this.getGasPrice(chain);
+    const priceWei = BigInt(gasPrice[speed]);
+    const units = BigInt(gasUnits);
+    const costNative = (priceWei * units).toString();
+    const nativePrice = parseFloat(gasPrice.nativeTokenPriceUsd);
+    const costUsd = (Number(costNative) * nativePrice / 1e18).toFixed(6);
+    return { costNative, costUsd };
+  }
+  /**
+   * Predict future gas prices (simple moving average)
+   */
+  predictGasPrice(chain, horizonMinutes = 5) {
+    if (!this.config.enablePrediction) {
+      return null;
+    }
+    const history = this.history.get(chain);
+    if (!history || history.length < 5) {
+      return null;
+    }
+    const currentPrice = history[history.length - 1];
+    const recentPrices = history.slice(-20).map((h) => BigInt(h.standard));
+    const sum = recentPrices.reduce((a, b) => a + b, 0n);
+    const avg = sum / BigInt(recentPrices.length);
+    const variance = recentPrices.reduce(
+      (acc, p) => acc + (p - avg) * (p - avg),
+      0n
+    ) / BigInt(recentPrices.length);
+    const stdDev = BigInt(Math.floor(Math.sqrt(Number(variance))));
+    const predictions = [];
+    const intervals = [1, 2, 5, 10, 15];
+    for (const mins of intervals) {
+      if (mins > horizonMinutes) break;
+      const decay = 0.9 ** mins;
+      const predicted = avg + BigInt(Math.floor(Number(BigInt(currentPrice.standard) - avg) * decay));
+      predictions.push({
+        timestamp: Date.now() + mins * 60 * 1e3,
+        predictedPrice: predicted.toString(),
+        confidence: Math.max(50, 95 - mins * 5),
+        lowerBound: (predicted - stdDev * 2n).toString(),
+        upperBound: (predicted + stdDev * 2n).toString()
+      });
+    }
+    return {
+      chain,
+      currentPrice: currentPrice.standard,
+      predictions,
+      model: "simple_moving_average",
+      lastUpdated: Date.now()
+    };
+  }
+  /**
+   * Get recommended gas price based on urgency
+   */
+  async getRecommendedGasPrice(chain, urgency) {
+    const gasPrice = await this.getGasPrice(chain);
+    const mapping = {
+      low: { speed: "slow", time: 300 },
+      medium: { speed: "standard", time: 60 },
+      high: { speed: "fast", time: 15 },
+      critical: { speed: "instant", time: 5 }
+    };
+    const { speed, time } = mapping[urgency];
+    return {
+      price: gasPrice[speed],
+      estimatedTime: time
+    };
+  }
+  /**
+   * Get gas history for a chain
+   */
+  getHistory(chain) {
+    return this.history.get(chain) ?? [];
+  }
+  /**
+   * Clear cache
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+  addToHistory(chain, price) {
+    if (!this.history.has(chain)) {
+      this.history.set(chain, []);
+    }
+    const history = this.history.get(chain);
+    history.push(price);
+    if (history.length > this.maxHistorySize) {
+      history.shift();
+    }
+  }
+  getMockGasPrice(chain) {
+    const defaults = {
+      "eip155:1": {
+        // Ethereum
+        slow: "15000000000",
+        // 15 gwei
+        standard: "25000000000",
+        // 25 gwei
+        fast: "40000000000",
+        // 40 gwei
+        instant: "60000000000",
+        // 60 gwei
+        nativeTokenPriceUsd: "2500",
+        baseFee: "20000000000",
+        priorityFee: {
+          slow: "1000000000",
+          standard: "2000000000",
+          fast: "5000000000",
+          instant: "10000000000"
+        }
+      },
+      "eip155:8453": {
+        // Base
+        slow: "100000000",
+        // 0.1 gwei
+        standard: "150000000",
+        // 0.15 gwei
+        fast: "250000000",
+        // 0.25 gwei
+        instant: "500000000",
+        // 0.5 gwei
+        nativeTokenPriceUsd: "2500"
+      },
+      "eip155:42161": {
+        // Arbitrum
+        slow: "10000000",
+        // 0.01 gwei
+        standard: "100000000",
+        // 0.1 gwei
+        fast: "200000000",
+        // 0.2 gwei
+        instant: "500000000",
+        // 0.5 gwei
+        nativeTokenPriceUsd: "2500"
+      },
+      "eip155:137": {
+        // Polygon
+        slow: "30000000000",
+        // 30 gwei
+        standard: "50000000000",
+        // 50 gwei
+        fast: "80000000000",
+        // 80 gwei
+        instant: "150000000000",
+        // 150 gwei
+        nativeTokenPriceUsd: "0.5"
+      },
+      "solana:mainnet": {
+        slow: "5000",
+        // 5000 lamports
+        standard: "10000",
+        // 10000 lamports
+        fast: "25000",
+        // 25000 lamports
+        instant: "50000",
+        // 50000 lamports
+        nativeTokenPriceUsd: "150"
+      }
+    };
+    const chainDefault = defaults[chain] ?? {
+      slow: "1000000000",
+      standard: "2000000000",
+      fast: "5000000000",
+      instant: "10000000000",
+      nativeTokenPriceUsd: "1"
+    };
+    return {
+      chain,
+      slow: chainDefault.slow,
+      standard: chainDefault.standard,
+      fast: chainDefault.fast,
+      instant: chainDefault.instant,
+      nativeTokenPriceUsd: chainDefault.nativeTokenPriceUsd,
+      baseFee: chainDefault.baseFee,
+      priorityFee: chainDefault.priorityFee,
+      lastBlock: 0,
+      timestamp: Date.now()
+    };
+  }
+};
+var MockGasProvider = class {
+  chains;
+  volatility;
+  constructor(chains, volatility = 0.1) {
+    this.chains = chains;
+    this.volatility = volatility;
+  }
+  async getGasPrice(chain) {
+    const variance = 1 + (Math.random() - 0.5) * this.volatility;
+    const basePrice = 1000000000n;
+    const adjusted = BigInt(Math.floor(Number(basePrice) * variance));
+    return {
+      chain,
+      slow: adjusted.toString(),
+      standard: (adjusted * 2n).toString(),
+      fast: (adjusted * 4n).toString(),
+      instant: (adjusted * 8n).toString(),
+      nativeTokenPriceUsd: "2500",
+      lastBlock: Math.floor(Math.random() * 1e6),
+      timestamp: Date.now()
+    };
+  }
+  supportedChains() {
+    return this.chains;
+  }
+};
+
+// src/pricing/fees.ts
+var FeeEstimator = class {
+  gasOracle;
+  protocolFees = /* @__PURE__ */ new Map();
+  tokenPrices = /* @__PURE__ */ new Map();
+  config;
+  // Default gas estimates for different operations
+  GAS_ESTIMATES = {
+    transfer: "65000",
+    approve: "46000",
+    swap_simple: "150000",
+    swap_complex: "300000",
+    bridge: "200000",
+    wrap: "45000",
+    unwrap: "45000",
+    deposit: "100000",
+    withdraw: "100000"
+  };
+  constructor(gasOracle, config = {}) {
+    this.gasOracle = gasOracle;
+    this.config = {
+      defaultSlippage: config.defaultSlippage ?? "0.5",
+      cacheTtl: config.cacheTtl ?? 6e4
+    };
+  }
+  /**
+   * Estimate fees for an operation
+   */
+  async estimateFees(request) {
+    const parsedRequest = FeeEstimateRequest.parse(request);
+    const gasUnits = this.getGasEstimate(
+      parsedRequest.operation,
+      parsedRequest.protocol
+    );
+    const { costNative, costUsd: gasCostUsd } = await this.gasOracle.calculateGasCostUsd(
+      parsedRequest.chain,
+      gasUnits,
+      parsedRequest.gasSpeed
+    );
+    const { fee: protocolFee, feeUsd: protocolFeeUsd } = await this.calculateProtocolFee(
+      parsedRequest.chain,
+      parsedRequest.protocol,
+      parsedRequest.operation,
+      parsedRequest.amount
+    );
+    const totalFeeUsd = (parseFloat(gasCostUsd) + parseFloat(protocolFeeUsd)).toFixed(6);
+    const breakdown = [
+      { type: "gas", amount: costNative, amountUsd: gasCostUsd }
+    ];
+    if (parseFloat(protocolFee) > 0) {
+      breakdown.push({ type: "protocol", amount: protocolFee, amountUsd: protocolFeeUsd });
+    }
+    return {
+      gasUnits,
+      gasPriceWei: (await this.gasOracle.getGasPrice(parsedRequest.chain))[parsedRequest.gasSpeed],
+      gasCostNative: costNative,
+      gasCostUsd,
+      protocolFee,
+      protocolFeeUsd,
+      totalFeeUsd,
+      confidence: 85,
+      // Base confidence
+      breakdown
+    };
+  }
+  /**
+   * Estimate total route fees
+   */
+  async estimateRouteFees(steps, gasSpeed = "standard") {
+    const stepEstimates = [];
+    let totalGasUsd = 0;
+    let totalProtocolFeesUsd = 0;
+    for (const step of steps) {
+      const estimate = await this.estimateFees({
+        chain: step.chain,
+        operation: step.operation,
+        protocol: step.protocol,
+        inputAsset: step.inputAsset,
+        outputAsset: step.outputAsset,
+        amount: step.amount,
+        gasSpeed
+      });
+      stepEstimates.push(estimate);
+      totalGasUsd += parseFloat(estimate.gasCostUsd);
+      totalProtocolFeesUsd += parseFloat(estimate.protocolFeeUsd);
+    }
+    return {
+      totalGasUsd: totalGasUsd.toFixed(6),
+      totalProtocolFeesUsd: totalProtocolFeesUsd.toFixed(6),
+      totalFeesUsd: (totalGasUsd + totalProtocolFeesUsd).toFixed(6),
+      stepEstimates
+    };
+  }
+  /**
+   * Get a swap quote
+   */
+  async getSwapQuote(chain, dex, inputAsset, outputAsset, inputAmount, slippage) {
+    const slippagePercent = parseFloat(slippage ?? this.config.defaultSlippage) / 100;
+    const inputPrice = await this.getTokenPrice(chain, inputAsset);
+    const outputPrice = await this.getTokenPrice(chain, outputAsset);
+    const inputValueUsd = parseFloat(inputAmount) * parseFloat(inputPrice.priceUsd);
+    const feePercent = this.getProtocolFeePercent(dex);
+    const outputValueUsd = inputValueUsd * (1 - feePercent);
+    const outputAmount = (outputValueUsd / parseFloat(outputPrice.priceUsd)).toString();
+    const minOutput = (parseFloat(outputAmount) * (1 - slippagePercent)).toFixed(0);
+    const priceImpact = (feePercent * 100).toFixed(4);
+    const gasEstimate = this.GAS_ESTIMATES.swap_simple;
+    await this.gasOracle.calculateGasCostUsd(chain, gasEstimate);
+    return {
+      dex,
+      chain,
+      inputAsset,
+      outputAsset,
+      inputAmount,
+      outputAmount,
+      minOutputAmount: minOutput,
+      priceImpact,
+      fee: (parseFloat(inputAmount) * feePercent).toFixed(0),
+      feeUsd: (inputValueUsd * feePercent).toFixed(6),
+      route: [inputAsset, outputAsset],
+      estimatedGas: gasEstimate,
+      expiresAt: Date.now() + 6e4
+    };
+  }
+  /**
+   * Get a bridge quote
+   */
+  async getBridgeQuote(bridge, sourceChain, destinationChain, sourceAsset, destinationAsset, inputAmount) {
+    const feePercent = 1e-3;
+    const minFee = 1e5;
+    const fee = Math.max(
+      minFee,
+      Math.floor(parseFloat(inputAmount) * feePercent)
+    );
+    const outputAmount = (parseFloat(inputAmount) - fee).toFixed(0);
+    const tokenPrice = await this.getTokenPrice(sourceChain, sourceAsset);
+    const feeUsd = (fee * parseFloat(tokenPrice.priceUsd) / 1e6).toFixed(6);
+    const estimatedTime = this.getBridgeEstimatedTime(bridge, sourceChain, destinationChain);
+    return {
+      bridge,
+      sourceChain,
+      destinationChain,
+      sourceAsset,
+      destinationAsset,
+      inputAmount,
+      outputAmount,
+      fee: fee.toString(),
+      feeUsd,
+      estimatedTime,
+      confidence: 90,
+      expiresAt: Date.now() + 12e4
+    };
+  }
+  /**
+   * Register protocol fee structure
+   */
+  registerProtocolFees(fees) {
+    const key = `${fees.protocol}:${fees.chain}`;
+    this.protocolFees.set(key, fees);
+  }
+  /**
+   * Update token price
+   */
+  updateTokenPrice(price) {
+    const key = `${price.chain}:${price.asset}`;
+    this.tokenPrices.set(key, price);
+  }
+  getGasEstimate(operation, _protocol) {
+    const key = operation.toLowerCase();
+    return this.GAS_ESTIMATES[key] ?? this.GAS_ESTIMATES.transfer;
+  }
+  async calculateProtocolFee(_chain, protocol, operation, amount) {
+    if (!protocol) {
+      return { fee: "0", feeUsd: "0" };
+    }
+    const feePercent = this.getProtocolFeePercent(protocol);
+    if (operation === "transfer" || operation === "approve") {
+      return { fee: "0", feeUsd: "0" };
+    }
+    const fee = Math.floor(parseFloat(amount) * feePercent);
+    const feeUsd = (fee / 1e6).toFixed(6);
+    return { fee: fee.toString(), feeUsd };
+  }
+  getProtocolFeePercent(protocol) {
+    const fees = {
+      uniswap: 3e-3,
+      sushiswap: 3e-3,
+      curve: 4e-4,
+      balancer: 2e-3,
+      "1inch": 0,
+      paraswap: 0,
+      layerzero: 1e-3,
+      wormhole: 1e-3,
+      stargate: 6e-4
+    };
+    return fees[protocol.toLowerCase()] ?? 3e-3;
+  }
+  async getTokenPrice(chain, asset) {
+    const key = `${chain}:${asset}`;
+    const cached = this.tokenPrices.get(key);
+    if (cached && cached.timestamp > Date.now() - this.config.cacheTtl) {
+      return cached;
+    }
+    const isStablecoin = asset.toLowerCase().includes("usdt") || asset.toLowerCase().includes("usdc") || asset.toLowerCase().includes("dai");
+    const price = {
+      chain,
+      asset,
+      priceUsd: isStablecoin ? "1.0" : "1.0",
+      source: "mock",
+      timestamp: Date.now(),
+      confidence: 95
+    };
+    this.tokenPrices.set(key, price);
+    return price;
+  }
+  getBridgeEstimatedTime(bridge, sourceChain, destinationChain) {
+    const bridgeTimes = {
+      layerzero: 60,
+      wormhole: 120,
+      stargate: 30,
+      hop: 300,
+      across: 60,
+      celer: 600,
+      multichain: 600
+    };
+    let baseTime = bridgeTimes[bridge.toLowerCase()] ?? 300;
+    if (sourceChain.includes("eip155:1") || destinationChain.includes("eip155:1")) {
+      baseTime += 120;
+    }
+    return baseTime;
+  }
+};
+function calculateMinOutput(amount, slippagePercent) {
+  const slippage = parseFloat(slippagePercent) / 100;
+  const minOutput = BigInt(amount) * BigInt(Math.floor((1 - slippage) * 1e4)) / 10000n;
+  return minOutput.toString();
+}
+function calculatePriceImpact(amount, liquidity) {
+  if (BigInt(liquidity) === 0n) {
+    return "100";
+  }
+  const impact = Number(BigInt(amount) * 10000n / BigInt(liquidity)) / 100;
+  return impact.toFixed(4);
+}
+
+export {
+  GasPrice,
+  TokenPrice,
+  ProtocolFees,
+  BridgeQuote,
+  SwapQuote,
+  FeeEstimateRequest,
+  FeeEstimate,
+  PricePrediction,
+  GasOracle,
+  MockGasProvider,
+  FeeEstimator,
+  calculateMinOutput,
+  calculatePriceImpact
+};
+//# sourceMappingURL=chunk-BUGQ6VOQ.js.map