@t402/smart-router 1.0.0-beta.1

package/dist/chunk-KJJ2L6TF.js

@@ -0,0 +1,742 @@
+// src/routing/engine.ts
+var OPTIMIZATION_WEIGHTS = {
+  cost: { cost: 0.6, speed: 0.1, confidence: 0.2, slippage: 0.1 },
+  speed: { cost: 0.1, speed: 0.6, confidence: 0.2, slippage: 0.1 },
+  privacy: { cost: 0.2, speed: 0.1, confidence: 0.3, slippage: 0.4 },
+  balanced: { cost: 0.3, speed: 0.3, confidence: 0.2, slippage: 0.2 },
+  slippage: { cost: 0.1, speed: 0.1, confidence: 0.2, slippage: 0.6 }
+};
+var RoutingEngine = class {
+  graph;
+  config;
+  routeCache = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    this.config = {
+      maxRoutes: config.maxRoutes ?? 5,
+      cacheTtl: config.cacheTtl ?? 3e4,
+      minConfidence: config.minConfidence ?? 50,
+      defaultSlippage: config.defaultSlippage ?? "0.5"
+    };
+    this.graph = {
+      nodes: /* @__PURE__ */ new Map(),
+      edges: [],
+      lastUpdated: Date.now()
+    };
+  }
+  /**
+   * Find optimal routes for a payment
+   */
+  async findRoutes(request) {
+    const cacheKey = this.getCacheKey(request);
+    const cached = this.routeCache.get(cacheKey);
+    if (cached && cached.expiresAt > Date.now()) {
+      return cached.routes;
+    }
+    const validation = this.validateRequest(request);
+    if (!validation.valid) {
+      throw new RoutingError(
+        `Invalid route request: ${validation.errors[0]?.message}`,
+        "INVALID_REQUEST"
+      );
+    }
+    const paths = this.findAllPaths(
+      request.sourceChain,
+      request.sourceAsset,
+      request.destinationChain,
+      request.destinationAsset ?? request.sourceAsset,
+      request.maxHops
+    );
+    if (paths.length === 0) {
+      throw new RoutingError(
+        "No route found between source and destination",
+        "NO_ROUTE"
+      );
+    }
+    const routes = [];
+    for (const path of paths) {
+      try {
+        const route = await this.buildRoute(request, path);
+        if (route.confidence >= this.config.minConfidence) {
+          routes.push(route);
+        }
+      } catch {
+        continue;
+      }
+    }
+    if (routes.length === 0) {
+      throw new RoutingError(
+        "No valid routes found",
+        "NO_VALID_ROUTE"
+      );
+    }
+    const scoredRoutes = routes.map((route) => ({
+      route,
+      score: this.scoreRoute(route, request.optimization)
+    })).sort((a, b) => b.score - a.score).slice(0, this.config.maxRoutes).map(({ route }) => route);
+    this.routeCache.set(cacheKey, {
+      routes: scoredRoutes,
+      expiresAt: Date.now() + this.config.cacheTtl
+    });
+    return scoredRoutes;
+  }
+  /**
+   * Get the best route for a payment
+   */
+  async getBestRoute(request) {
+    const routes = await this.findRoutes(request);
+    return routes[0] ?? null;
+  }
+  /**
+   * Validate a route is still executable
+   */
+  async validateRoute(route) {
+    const errors = [];
+    const warnings = [];
+    if (route.expiresAt < Date.now()) {
+      errors.push({
+        code: "EXPIRED",
+        message: "Route has expired"
+      });
+    }
+    for (let i = 0; i < route.steps.length; i++) {
+      const step = route.steps[i];
+      const edge = this.findEdge(
+        step.chain,
+        step.inputAsset,
+        step.chain,
+        step.outputAsset,
+        step.protocol
+      );
+      if (!edge) {
+        errors.push({
+          step: i,
+          code: "PROTOCOL_UNAVAILABLE",
+          message: `Protocol ${step.protocol} not available for step ${i}`
+        });
+        continue;
+      }
+      if (BigInt(step.inputAmount) > BigInt(edge.maxAmount)) {
+        errors.push({
+          step: i,
+          code: "INSUFFICIENT_LIQUIDITY",
+          message: `Insufficient liquidity for step ${i}`
+        });
+      }
+      if (BigInt(step.inputAmount) < BigInt(edge.minAmount)) {
+        errors.push({
+          step: i,
+          code: "BELOW_MINIMUM",
+          message: `Amount below minimum for step ${i}`
+        });
+      }
+    }
+    if (parseFloat(route.priceImpact) > 1) {
+      warnings.push({
+        code: "HIGH_PRICE_IMPACT",
+        message: `Price impact is ${route.priceImpact}%`
+      });
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  /**
+   * Update the routing graph with new data
+   */
+  updateGraph(edges) {
+    this.graph.edges = [];
+    this.graph.nodes.clear();
+    for (const edge of edges) {
+      this.addEdge(edge);
+    }
+    this.graph.lastUpdated = Date.now();
+    this.routeCache.clear();
+  }
+  /**
+   * Add an edge to the routing graph
+   */
+  addEdge(edge) {
+    this.graph.edges.push(edge);
+    const fromKey = `${edge.from}:${edge.fromAsset}`;
+    const toKey = `${edge.to}:${edge.toAsset}`;
+    if (!this.graph.nodes.has(fromKey)) {
+      this.graph.nodes.set(fromKey, {
+        chain: edge.from,
+        asset: edge.fromAsset,
+        edges: []
+      });
+    }
+    this.graph.nodes.get(fromKey).edges.push(edge);
+    if (!this.graph.nodes.has(toKey)) {
+      this.graph.nodes.set(toKey, {
+        chain: edge.to,
+        asset: edge.toAsset,
+        edges: []
+      });
+    }
+  }
+  /**
+   * Get the current routing graph
+   */
+  getGraph() {
+    return this.graph;
+  }
+  validateRequest(request) {
+    const errors = [];
+    if (!request.sourceChain) {
+      errors.push({ code: "MISSING_SOURCE_CHAIN", message: "Source chain is required" });
+    }
+    if (!request.sourceAsset) {
+      errors.push({ code: "MISSING_SOURCE_ASSET", message: "Source asset is required" });
+    }
+    if (!request.sourceAmount || BigInt(request.sourceAmount) <= 0n) {
+      errors.push({ code: "INVALID_AMOUNT", message: "Source amount must be positive" });
+    }
+    if (!request.destinationChain) {
+      errors.push({ code: "MISSING_DEST_CHAIN", message: "Destination chain is required" });
+    }
+    if (!request.sender) {
+      errors.push({ code: "MISSING_SENDER", message: "Sender address is required" });
+    }
+    if (!request.recipient) {
+      errors.push({ code: "MISSING_RECIPIENT", message: "Recipient address is required" });
+    }
+    return { valid: errors.length === 0, errors, warnings: [] };
+  }
+  findAllPaths(fromChain, fromAsset, toChain, toAsset, maxHops) {
+    const paths = [];
+    const startKey = `${fromChain}:${fromAsset}`;
+    const endKey = `${toChain}:${toAsset}`;
+    const queue = [{ key: startKey, path: [] }];
+    const visited = /* @__PURE__ */ new Set();
+    while (queue.length > 0) {
+      const { key, path } = queue.shift();
+      if (path.length > maxHops) continue;
+      if (key === endKey && path.length > 0) {
+        paths.push([...path]);
+        continue;
+      }
+      const node = this.graph.nodes.get(key);
+      if (!node) continue;
+      for (const edge of node.edges) {
+        const nextKey = `${edge.to}:${edge.toAsset}`;
+        const pathKey = `${key}->${nextKey}`;
+        if (visited.has(pathKey)) continue;
+        visited.add(pathKey);
+        queue.push({
+          key: nextKey,
+          path: [...path, edge]
+        });
+      }
+    }
+    return paths;
+  }
+  async buildRoute(request, path) {
+    const steps = [];
+    let currentAmount = request.sourceAmount;
+    let totalGasCost = 0n;
+    let totalProtocolFees = 0n;
+    let totalBridgeFees = 0n;
+    let totalTime = 0;
+    let cumulativePriceImpact = 0;
+    for (let i = 0; i < path.length; i++) {
+      const edge = path[i];
+      const slippage2 = parseFloat(request.maxSlippage) / 100;
+      const outputAmount = this.calculateOutput(currentAmount, edge);
+      const minOutput = BigInt(Math.floor(Number(outputAmount) * (1 - slippage2))).toString();
+      const gasEstimate = this.estimateGas(edge.type);
+      const protocolFee = this.calculateProtocolFee(currentAmount, edge);
+      const bridgeFee = edge.type === "bridge" ? this.calculateBridgeFee(currentAmount, edge) : "0";
+      const step = {
+        id: `step-${i}`,
+        type: edge.type,
+        chain: edge.from,
+        protocol: edge.protocol,
+        inputAsset: edge.fromAsset,
+        outputAsset: edge.toAsset,
+        inputAmount: currentAmount,
+        outputAmount,
+        minOutputAmount: minOutput,
+        contract: this.getProtocolContract(edge),
+        estimatedGas: gasEstimate,
+        estimatedTime: edge.estimatedTime,
+        protocolFee,
+        bridgeFee: edge.type === "bridge" ? bridgeFee : void 0,
+        priceImpact: this.calculatePriceImpact(currentAmount, edge),
+        exchangeRate: this.calculateExchangeRate(edge)
+      };
+      steps.push(step);
+      currentAmount = outputAmount;
+      totalGasCost += BigInt(gasEstimate);
+      totalProtocolFees += BigInt(protocolFee);
+      totalBridgeFees += BigInt(bridgeFee);
+      totalTime += edge.estimatedTime;
+      cumulativePriceImpact += parseFloat(step.priceImpact ?? "0");
+    }
+    const totalCost = totalGasCost + totalProtocolFees + totalBridgeFees;
+    const slippage = parseFloat(request.maxSlippage) / 100;
+    const minDestination = BigInt(Math.floor(Number(currentAmount) * (1 - slippage))).toString();
+    return {
+      id: crypto.randomUUID(),
+      steps,
+      sourceChain: request.sourceChain,
+      destinationChain: request.destinationChain,
+      sourceAsset: request.sourceAsset,
+      destinationAsset: request.destinationAsset ?? request.sourceAsset,
+      sourceAmount: request.sourceAmount,
+      destinationAmount: currentAmount,
+      minDestinationAmount: minDestination,
+      totalGasCost: totalGasCost.toString(),
+      totalProtocolFees: totalProtocolFees.toString(),
+      totalBridgeFees: totalBridgeFees.toString(),
+      totalCost: totalCost.toString(),
+      estimatedTime: totalTime,
+      priceImpact: cumulativePriceImpact.toFixed(4),
+      confidence: this.calculateConfidence(path),
+      optimization: request.optimization,
+      warnings: this.generateWarnings(steps, request),
+      createdAt: Date.now(),
+      expiresAt: Date.now() + 6e4
+      // 1 minute
+    };
+  }
+  scoreRoute(route, strategy) {
+    const weights = OPTIMIZATION_WEIGHTS[strategy];
+    const costScore = 100 - Math.min(100, Number(route.totalCost) / 1e6);
+    const speedScore = 100 - Math.min(100, route.estimatedTime / 600);
+    const confidenceScore = route.confidence;
+    const slippageScore = 100 - Math.min(100, parseFloat(route.priceImpact) * 10);
+    return costScore * weights.cost + speedScore * weights.speed + confidenceScore * weights.confidence + slippageScore * weights.slippage;
+  }
+  calculateOutput(input, _edge) {
+    const inputBigInt = BigInt(input);
+    const fee = inputBigInt * 3n / 1000n;
+    return (inputBigInt - fee).toString();
+  }
+  calculateProtocolFee(amount, edge) {
+    const feeRate = edge.type === "swap" ? 30n : 10n;
+    return (BigInt(amount) * feeRate / 10000n).toString();
+  }
+  calculateBridgeFee(amount, _edge) {
+    const variableFee = BigInt(amount) * 10n / 10000n;
+    const fixedFee = 100000n;
+    return (variableFee + fixedFee).toString();
+  }
+  calculatePriceImpact(amount, edge) {
+    const liquidity = BigInt(edge.liquidity);
+    if (liquidity === 0n) return "100";
+    const amountBigInt = BigInt(amount);
+    const impact = Number(amountBigInt * 10000n / liquidity) / 100;
+    return impact.toFixed(4);
+  }
+  calculateExchangeRate(edge) {
+    if (edge.fromAsset === edge.toAsset) {
+      return "1.0";
+    }
+    return "0.997";
+  }
+  estimateGas(type) {
+    const gasEstimates = {
+      transfer: "65000",
+      swap: "150000",
+      bridge: "200000",
+      wrap: "45000",
+      unwrap: "45000",
+      approve: "46000",
+      deposit: "100000",
+      withdraw: "100000"
+    };
+    return gasEstimates[type] ?? "100000";
+  }
+  getProtocolContract(edge) {
+    return `0x${edge.protocol?.slice(0, 40).padEnd(40, "0") ?? "0".repeat(40)}`;
+  }
+  calculateConfidence(path) {
+    let confidence = 100;
+    for (const edge of path) {
+      const reduction = edge.type === "bridge" ? 10 : 3;
+      confidence -= reduction;
+      if (BigInt(edge.liquidity) < 1000000n) {
+        confidence -= 5;
+      }
+    }
+    return Math.max(0, Math.min(100, confidence));
+  }
+  generateWarnings(steps, request) {
+    const warnings = [];
+    if (steps.length > 3) {
+      warnings.push(`Route has ${steps.length} steps which may increase risk`);
+    }
+    const bridgeSteps = steps.filter((s) => s.type === "bridge");
+    if (bridgeSteps.length > 0) {
+      warnings.push("Route includes cross-chain bridge which may take longer");
+    }
+    if (request.deadline) {
+      const totalTime = steps.reduce((sum, s) => sum + s.estimatedTime, 0);
+      const timeRemaining = request.deadline - Date.now() / 1e3;
+      if (totalTime > timeRemaining * 0.8) {
+        warnings.push("Route may not complete before deadline");
+      }
+    }
+    return warnings;
+  }
+  findEdge(fromChain, fromAsset, toChain, toAsset, protocol) {
+    return this.graph.edges.find(
+      (e) => e.from === fromChain && e.fromAsset === fromAsset && e.to === toChain && e.toAsset === toAsset && (!protocol || e.protocol === protocol)
+    );
+  }
+  getCacheKey(request) {
+    return JSON.stringify({
+      sourceChain: request.sourceChain,
+      sourceAsset: request.sourceAsset,
+      sourceAmount: request.sourceAmount,
+      destinationChain: request.destinationChain,
+      destinationAsset: request.destinationAsset,
+      optimization: request.optimization
+    });
+  }
+};
+var RoutingError = class extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "RoutingError";
+    this.code = code;
+  }
+};
+
+// src/routing/algorithms.ts
+var PriorityQueue = class {
+  items = [];
+  enqueue(item, priority) {
+    this.items.push({ item, priority });
+    this.items.sort((a, b) => a.priority - b.priority);
+  }
+  dequeue() {
+    return this.items.shift()?.item;
+  }
+  isEmpty() {
+    return this.items.length === 0;
+  }
+};
+function nodeKey(chain, asset) {
+  return `${chain}:${asset}`;
+}
+var COST_CONFIGS = {
+  cost: {
+    gasCostWeight: 0.4,
+    feeWeight: 0.4,
+    timeWeight: 0.1,
+    slippageWeight: 0.1,
+    hopPenalty: 0.05,
+    bridgePenalty: 0.1
+  },
+  speed: {
+    gasCostWeight: 0.1,
+    feeWeight: 0.1,
+    timeWeight: 0.6,
+    slippageWeight: 0.2,
+    hopPenalty: 0.1,
+    bridgePenalty: 0.2
+  },
+  privacy: {
+    gasCostWeight: 0.2,
+    feeWeight: 0.2,
+    timeWeight: 0.1,
+    slippageWeight: 0.5,
+    hopPenalty: 0.15,
+    bridgePenalty: 0.05
+  },
+  balanced: {
+    gasCostWeight: 0.25,
+    feeWeight: 0.25,
+    timeWeight: 0.25,
+    slippageWeight: 0.25,
+    hopPenalty: 0.08,
+    bridgePenalty: 0.12
+  },
+  slippage: {
+    gasCostWeight: 0.1,
+    feeWeight: 0.1,
+    timeWeight: 0.1,
+    slippageWeight: 0.7,
+    hopPenalty: 0.12,
+    bridgePenalty: 0.15
+  }
+};
+function calculateEdgeCost(edge, config) {
+  const normalizedGas = edge.cost / 1e6;
+  const normalizedTime = edge.estimatedTime / 3600;
+  let cost = normalizedGas * config.gasCostWeight + normalizedTime * config.timeWeight;
+  cost += config.hopPenalty;
+  if (edge.type === "bridge") {
+    cost += config.bridgePenalty;
+  }
+  return Math.max(1e-3, cost);
+}
+function dijkstra(edges, startChain, startAsset, endChain, endAsset, costConfig, maxHops = 5) {
+  const startKey = nodeKey(startChain, startAsset);
+  const endKey = nodeKey(endChain, endAsset);
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    const key = nodeKey(edge.from, edge.fromAsset);
+    if (!adjacency.has(key)) {
+      adjacency.set(key, []);
+    }
+    adjacency.get(key).push(edge);
+  }
+  const distances = /* @__PURE__ */ new Map();
+  const previous = /* @__PURE__ */ new Map();
+  const hops = /* @__PURE__ */ new Map();
+  const pq = new PriorityQueue();
+  distances.set(startKey, 0);
+  hops.set(startKey, 0);
+  previous.set(startKey, null);
+  pq.enqueue(startKey, 0);
+  while (!pq.isEmpty()) {
+    const currentKey = pq.dequeue();
+    const currentDistance = distances.get(currentKey) ?? Infinity;
+    const currentHops = hops.get(currentKey) ?? 0;
+    if (currentKey === endKey) {
+      break;
+    }
+    if (currentHops >= maxHops) {
+      continue;
+    }
+    const neighbors = adjacency.get(currentKey) ?? [];
+    for (const edge of neighbors) {
+      const neighborKey = nodeKey(edge.to, edge.toAsset);
+      const edgeCost = calculateEdgeCost(edge, costConfig);
+      const newDistance = currentDistance + edgeCost;
+      if (newDistance < (distances.get(neighborKey) ?? Infinity)) {
+        distances.set(neighborKey, newDistance);
+        hops.set(neighborKey, currentHops + 1);
+        previous.set(neighborKey, { edge, node: currentKey });
+        pq.enqueue(neighborKey, newDistance);
+      }
+    }
+  }
+  if (!previous.has(endKey)) {
+    return null;
+  }
+  const path = [];
+  let current = endKey;
+  while (previous.get(current) !== null) {
+    const prev = previous.get(current);
+    path.unshift(prev.edge);
+    current = prev.node;
+  }
+  return path;
+}
+function astar(edges, startChain, startAsset, endChain, endAsset, costConfig, maxHops = 5) {
+  const startKey = nodeKey(startChain, startAsset);
+  const endKey = nodeKey(endChain, endAsset);
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    const key = nodeKey(edge.from, edge.fromAsset);
+    if (!adjacency.has(key)) {
+      adjacency.set(key, []);
+    }
+    adjacency.get(key).push(edge);
+  }
+  const heuristic = (key) => {
+    if (key === endKey) return 0;
+    const [chain] = key.split(":");
+    if (chain === endChain) {
+      return 0.1;
+    }
+    return 0.5;
+  };
+  const gScore = /* @__PURE__ */ new Map();
+  const fScore = /* @__PURE__ */ new Map();
+  const previous = /* @__PURE__ */ new Map();
+  const hops = /* @__PURE__ */ new Map();
+  const pq = new PriorityQueue();
+  gScore.set(startKey, 0);
+  fScore.set(startKey, heuristic(startKey));
+  hops.set(startKey, 0);
+  previous.set(startKey, null);
+  pq.enqueue(startKey, fScore.get(startKey));
+  const visited = /* @__PURE__ */ new Set();
+  while (!pq.isEmpty()) {
+    const currentKey = pq.dequeue();
+    if (currentKey === endKey) {
+      break;
+    }
+    if (visited.has(currentKey)) {
+      continue;
+    }
+    visited.add(currentKey);
+    const currentHops = hops.get(currentKey) ?? 0;
+    if (currentHops >= maxHops) {
+      continue;
+    }
+    const neighbors = adjacency.get(currentKey) ?? [];
+    for (const edge of neighbors) {
+      const neighborKey = nodeKey(edge.to, edge.toAsset);
+      const edgeCost = calculateEdgeCost(edge, costConfig);
+      const tentativeGScore = (gScore.get(currentKey) ?? Infinity) + edgeCost;
+      if (tentativeGScore < (gScore.get(neighborKey) ?? Infinity)) {
+        gScore.set(neighborKey, tentativeGScore);
+        fScore.set(neighborKey, tentativeGScore + heuristic(neighborKey));
+        hops.set(neighborKey, currentHops + 1);
+        previous.set(neighborKey, { edge, node: currentKey });
+        pq.enqueue(neighborKey, fScore.get(neighborKey));
+      }
+    }
+  }
+  if (!previous.has(endKey)) {
+    return null;
+  }
+  const path = [];
+  let current = endKey;
+  while (previous.get(current) !== null) {
+    const prev = previous.get(current);
+    path.unshift(prev.edge);
+    current = prev.node;
+  }
+  return path;
+}
+function kShortestPaths(edges, startChain, startAsset, endChain, endAsset, costConfig, k = 5, maxHops = 5) {
+  const paths = [];
+  const firstPath = dijkstra(
+    edges,
+    startChain,
+    startAsset,
+    endChain,
+    endAsset,
+    costConfig,
+    maxHops
+  );
+  if (!firstPath) {
+    return [];
+  }
+  paths.push(firstPath);
+  const candidates = [];
+  for (let i = 1; i < k; i++) {
+    const prevPath = paths[i - 1];
+    for (let j = 0; j < prevPath.length; j++) {
+      const excludedEdges = /* @__PURE__ */ new Set();
+      for (const existingPath of paths) {
+        if (existingPath.length > j) {
+          let match = true;
+          for (let m = 0; m < j; m++) {
+            if (existingPath[m] !== prevPath[m]) {
+              match = false;
+              break;
+            }
+          }
+          if (match && existingPath[j]) {
+            const edgeKey = `${existingPath[j].from}:${existingPath[j].fromAsset}->${existingPath[j].to}:${existingPath[j].toAsset}`;
+            excludedEdges.add(edgeKey);
+          }
+        }
+      }
+      const filteredEdges = edges.filter((e) => {
+        const edgeKey = `${e.from}:${e.fromAsset}->${e.to}:${e.toAsset}`;
+        return !excludedEdges.has(edgeKey);
+      });
+      const spurNode = j === 0 ? { chain: startChain, asset: startAsset } : { chain: prevPath[j - 1].to, asset: prevPath[j - 1].toAsset };
+      const spurPath = dijkstra(
+        filteredEdges,
+        spurNode.chain,
+        spurNode.asset,
+        endChain,
+        endAsset,
+        costConfig,
+        maxHops - j
+      );
+      if (spurPath) {
+        const rootPath = prevPath.slice(0, j);
+        const candidatePath = [...rootPath, ...spurPath];
+        const cost = candidatePath.reduce(
+          (sum, edge) => sum + calculateEdgeCost(edge, costConfig),
+          0
+        );
+        const pathKey = candidatePath.map(
+          (e) => `${e.from}:${e.fromAsset}->${e.to}:${e.toAsset}`
+        ).join("|");
+        const isDuplicate = paths.some(
+          (p) => p.map((e) => `${e.from}:${e.fromAsset}->${e.to}:${e.toAsset}`).join("|") === pathKey
+        ) || candidates.some(
+          (c) => c.path.map((e) => `${e.from}:${e.fromAsset}->${e.to}:${e.toAsset}`).join("|") === pathKey
+        );
+        if (!isDuplicate) {
+          candidates.push({ path: candidatePath, cost });
+        }
+      }
+    }
+    if (candidates.length === 0) {
+      break;
+    }
+    candidates.sort((a, b) => a.cost - b.cost);
+    const best = candidates.shift();
+    paths.push(best.path);
+  }
+  return paths;
+}
+function paretoOptimalPaths(edges, startChain, startAsset, endChain, endAsset, maxHops = 5) {
+  const costPaths = kShortestPaths(
+    edges,
+    startChain,
+    startAsset,
+    endChain,
+    endAsset,
+    COST_CONFIGS.cost,
+    3,
+    maxHops
+  );
+  const speedPaths = kShortestPaths(
+    edges,
+    startChain,
+    startAsset,
+    endChain,
+    endAsset,
+    COST_CONFIGS.speed,
+    3,
+    maxHops
+  );
+  const allPaths = [...costPaths, ...speedPaths];
+  const uniquePaths = /* @__PURE__ */ new Map();
+  for (const path of allPaths) {
+    const key = path.map(
+      (e) => `${e.from}:${e.fromAsset}->${e.to}:${e.toAsset}:${e.protocol}`
+    ).join("|");
+    if (!uniquePaths.has(key)) {
+      uniquePaths.set(key, path);
+    }
+  }
+  const results = Array.from(uniquePaths.values()).map((path) => {
+    const cost = path.reduce((sum, e) => sum + e.cost, 0);
+    const time = path.reduce((sum, e) => sum + e.estimatedTime, 0);
+    return {
+      path,
+      metrics: { cost, time, hops: path.length }
+    };
+  });
+  return results.filter((r, i) => {
+    for (let j = 0; j < results.length; j++) {
+      if (i === j) continue;
+      const other = results[j];
+      const otherDominates = other.metrics.cost <= r.metrics.cost && other.metrics.time <= r.metrics.time && other.metrics.hops <= r.metrics.hops && (other.metrics.cost < r.metrics.cost || other.metrics.time < r.metrics.time || other.metrics.hops < r.metrics.hops);
+      if (otherDominates) {
+        return false;
+      }
+    }
+    return true;
+  });
+}
+
+export {
+  RoutingEngine,
+  RoutingError,
+  COST_CONFIGS,
+  calculateEdgeCost,
+  dijkstra,
+  astar,
+  kShortestPaths,
+  paretoOptimalPaths
+};
+//# sourceMappingURL=chunk-KJJ2L6TF.js.map