@t402/smart-router 1.0.0-beta.1

package/dist/liquidity/index.d.ts

@@ -0,0 +1,418 @@
+import { z } from 'zod';
+import { C as ChainId, P as ProtocolId, A as AssetId } from '../types-C0ey6WqI.js';
+
+/**
+ * Liquidity pool type
+ */
+declare const PoolType: z.ZodEnum<["constant_product", "concentrated", "stable", "weighted", "hybrid"]>;
+type PoolType = z.infer<typeof PoolType>;
+/**
+ * Liquidity pool
+ */
+declare const LiquidityPool: z.ZodObject<{
+    id: z.ZodString;
+    protocol: z.ZodString;
+    chain: z.ZodString;
+    type: z.ZodEnum<["constant_product", "concentrated", "stable", "weighted", "hybrid"]>;
+    tokens: z.ZodArray<z.ZodObject<{
+        asset: z.ZodString;
+        reserve: z.ZodString;
+        weight: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        asset: string;
+        reserve: string;
+        weight?: string | undefined;
+    }, {
+        asset: string;
+        reserve: string;
+        weight?: string | undefined;
+    }>, "many">;
+    fee: z.ZodString;
+    tvl: z.ZodString;
+    tickSpacing: z.ZodOptional<z.ZodNumber>;
+    currentTick: z.ZodOptional<z.ZodNumber>;
+    sqrtPriceX96: z.ZodOptional<z.ZodString>;
+    address: z.ZodString;
+    createdAt: z.ZodNumber;
+    lastUpdated: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "constant_product" | "concentrated" | "stable" | "weighted" | "hybrid";
+    id: string;
+    chain: string;
+    protocol: string;
+    createdAt: number;
+    fee: string;
+    lastUpdated: number;
+    tokens: {
+        asset: string;
+        reserve: string;
+        weight?: string | undefined;
+    }[];
+    tvl: string;
+    address: string;
+    tickSpacing?: number | undefined;
+    currentTick?: number | undefined;
+    sqrtPriceX96?: string | undefined;
+}, {
+    type: "constant_product" | "concentrated" | "stable" | "weighted" | "hybrid";
+    id: string;
+    chain: string;
+    protocol: string;
+    createdAt: number;
+    fee: string;
+    lastUpdated: number;
+    tokens: {
+        asset: string;
+        reserve: string;
+        weight?: string | undefined;
+    }[];
+    tvl: string;
+    address: string;
+    tickSpacing?: number | undefined;
+    currentTick?: number | undefined;
+    sqrtPriceX96?: string | undefined;
+}>;
+type LiquidityPool = z.infer<typeof LiquidityPool>;
+/**
+ * Liquidity source (aggregated from multiple pools)
+ */
+declare const LiquiditySource: z.ZodObject<{
+    chain: z.ZodString;
+    inputAsset: z.ZodString;
+    outputAsset: z.ZodString;
+    totalLiquidity: z.ZodString;
+    bestPrice: z.ZodString;
+    averagePrice: z.ZodString;
+    pools: z.ZodArray<z.ZodObject<{
+        poolId: z.ZodString;
+        protocol: z.ZodString;
+        liquidity: z.ZodString;
+        price: z.ZodString;
+        maxAmountIn: z.ZodString;
+        maxAmountOut: z.ZodString;
+        priceImpact1Percent: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        protocol: string;
+        price: string;
+        poolId: string;
+        liquidity: string;
+        maxAmountIn: string;
+        maxAmountOut: string;
+        priceImpact1Percent: string;
+    }, {
+        protocol: string;
+        price: string;
+        poolId: string;
+        liquidity: string;
+        maxAmountIn: string;
+        maxAmountOut: string;
+        priceImpact1Percent: string;
+    }>, "many">;
+    lastUpdated: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    chain: string;
+    inputAsset: string;
+    outputAsset: string;
+    lastUpdated: number;
+    totalLiquidity: string;
+    bestPrice: string;
+    averagePrice: string;
+    pools: {
+        protocol: string;
+        price: string;
+        poolId: string;
+        liquidity: string;
+        maxAmountIn: string;
+        maxAmountOut: string;
+        priceImpact1Percent: string;
+    }[];
+}, {
+    chain: string;
+    inputAsset: string;
+    outputAsset: string;
+    lastUpdated: number;
+    totalLiquidity: string;
+    bestPrice: string;
+    averagePrice: string;
+    pools: {
+        protocol: string;
+        price: string;
+        poolId: string;
+        liquidity: string;
+        maxAmountIn: string;
+        maxAmountOut: string;
+        priceImpact1Percent: string;
+    }[];
+}>;
+type LiquiditySource = z.infer<typeof LiquiditySource>;
+/**
+ * Cross-chain liquidity
+ */
+declare const CrossChainLiquidity: z.ZodObject<{
+    sourceChain: z.ZodString;
+    destinationChain: z.ZodString;
+    asset: z.ZodString;
+    bridges: z.ZodArray<z.ZodObject<{
+        bridge: z.ZodString;
+        liquidity: z.ZodString;
+        maxTransfer: z.ZodString;
+        minTransfer: z.ZodString;
+        fee: z.ZodString;
+        estimatedTime: z.ZodNumber;
+        available: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        bridge: string;
+        estimatedTime: number;
+        fee: string;
+        liquidity: string;
+        maxTransfer: string;
+        minTransfer: string;
+        available: boolean;
+    }, {
+        bridge: string;
+        estimatedTime: number;
+        fee: string;
+        liquidity: string;
+        maxTransfer: string;
+        minTransfer: string;
+        available: boolean;
+    }>, "many">;
+    totalLiquidity: z.ZodString;
+    bestBridge: z.ZodString;
+    lastUpdated: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    sourceChain: string;
+    destinationChain: string;
+    asset: string;
+    lastUpdated: number;
+    totalLiquidity: string;
+    bridges: {
+        bridge: string;
+        estimatedTime: number;
+        fee: string;
+        liquidity: string;
+        maxTransfer: string;
+        minTransfer: string;
+        available: boolean;
+    }[];
+    bestBridge: string;
+}, {
+    sourceChain: string;
+    destinationChain: string;
+    asset: string;
+    lastUpdated: number;
+    totalLiquidity: string;
+    bridges: {
+        bridge: string;
+        estimatedTime: number;
+        fee: string;
+        liquidity: string;
+        maxTransfer: string;
+        minTransfer: string;
+        available: boolean;
+    }[];
+    bestBridge: string;
+}>;
+type CrossChainLiquidity = z.infer<typeof CrossChainLiquidity>;
+/**
+ * Slippage calculation result
+ */
+declare const SlippageResult: z.ZodObject<{
+    inputAmount: z.ZodString;
+    outputAmount: z.ZodString;
+    priceImpact: z.ZodString;
+    effectivePrice: z.ZodString;
+    slippageTolerance: z.ZodString;
+    minOutputAmount: z.ZodString;
+    executionPath: z.ZodArray<z.ZodObject<{
+        poolId: z.ZodString;
+        amountIn: z.ZodString;
+        amountOut: z.ZodString;
+        priceImpact: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        priceImpact: string;
+        poolId: string;
+        amountIn: string;
+        amountOut: string;
+    }, {
+        priceImpact: string;
+        poolId: string;
+        amountIn: string;
+        amountOut: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    inputAmount: string;
+    outputAmount: string;
+    minOutputAmount: string;
+    priceImpact: string;
+    effectivePrice: string;
+    slippageTolerance: string;
+    executionPath: {
+        priceImpact: string;
+        poolId: string;
+        amountIn: string;
+        amountOut: string;
+    }[];
+}, {
+    inputAmount: string;
+    outputAmount: string;
+    minOutputAmount: string;
+    priceImpact: string;
+    effectivePrice: string;
+    slippageTolerance: string;
+    executionPath: {
+        priceImpact: string;
+        poolId: string;
+        amountIn: string;
+        amountOut: string;
+    }[];
+}>;
+type SlippageResult = z.infer<typeof SlippageResult>;
+/**
+ * Liquidity depth at different price levels
+ */
+declare const LiquidityDepth: z.ZodObject<{
+    chain: z.ZodString;
+    inputAsset: z.ZodString;
+    outputAsset: z.ZodString;
+    currentPrice: z.ZodString;
+    depth: z.ZodArray<z.ZodObject<{
+        priceLevel: z.ZodString;
+        bidLiquidity: z.ZodString;
+        askLiquidity: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        priceLevel: string;
+        bidLiquidity: string;
+        askLiquidity: string;
+    }, {
+        priceLevel: string;
+        bidLiquidity: string;
+        askLiquidity: string;
+    }>, "many">;
+    spread: z.ZodString;
+    lastUpdated: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    chain: string;
+    inputAsset: string;
+    outputAsset: string;
+    currentPrice: string;
+    lastUpdated: number;
+    depth: {
+        priceLevel: string;
+        bidLiquidity: string;
+        askLiquidity: string;
+    }[];
+    spread: string;
+}, {
+    chain: string;
+    inputAsset: string;
+    outputAsset: string;
+    currentPrice: string;
+    lastUpdated: number;
+    depth: {
+        priceLevel: string;
+        bidLiquidity: string;
+        askLiquidity: string;
+    }[];
+    spread: string;
+}>;
+type LiquidityDepth = z.infer<typeof LiquidityDepth>;
+
+/**
+ * Liquidity provider interface
+ */
+interface ILiquidityProvider {
+    chain: ChainId;
+    protocol: ProtocolId;
+    getPools(inputAsset: AssetId, outputAsset?: AssetId): Promise<LiquidityPool[]>;
+    getPool(poolId: string): Promise<LiquidityPool | null>;
+}
+/**
+ * Bridge liquidity provider interface
+ */
+interface IBridgeProvider {
+    bridge: ProtocolId;
+    getLiquidity(sourceChain: ChainId, destinationChain: ChainId, asset: AssetId): Promise<CrossChainLiquidity['bridges'][0] | null>;
+}
+/**
+ * Aggregator configuration
+ */
+interface AggregatorConfig {
+    cacheTtl?: number;
+    maxPoolsPerSource?: number;
+    minLiquidity?: string;
+}
+/**
+ * Liquidity aggregator - combines liquidity from multiple sources
+ */
+declare class LiquidityAggregator {
+    private providers;
+    private bridgeProviders;
+    private poolCache;
+    private config;
+    constructor(config?: AggregatorConfig);
+    /**
+     * Register a liquidity provider
+     */
+    registerProvider(provider: ILiquidityProvider): void;
+    /**
+     * Register a bridge provider
+     */
+    registerBridgeProvider(provider: IBridgeProvider): void;
+    /**
+     * Get aggregated liquidity for a trading pair
+     */
+    getLiquidity(chain: ChainId, inputAsset: AssetId, outputAsset: AssetId): Promise<LiquiditySource>;
+    /**
+     * Get cross-chain liquidity
+     */
+    getCrossChainLiquidity(sourceChain: ChainId, destinationChain: ChainId, asset: AssetId): Promise<CrossChainLiquidity>;
+    /**
+     * Calculate slippage for a trade
+     */
+    calculateSlippage(source: LiquiditySource, inputAmount: string, slippageTolerance: string): SlippageResult;
+    /**
+     * Get liquidity depth at different price levels
+     */
+    getLiquidityDepth(chain: ChainId, inputAsset: AssetId, outputAsset: AssetId, levels?: number[]): Promise<LiquidityDepth>;
+    /**
+     * Find best route across multiple pools
+     */
+    findBestRoute(source: LiquiditySource, inputAmount: string, maxPools?: number): {
+        pools: string[];
+        expectedOutput: string;
+        priceImpact: string;
+    };
+    /**
+     * Clear cache
+     */
+    clearCache(): void;
+    private aggregatePools;
+    private calculatePoolPriceImpact;
+    private calculateTotalPriceImpact;
+    private calculateLiquidityAtLevel;
+}
+/**
+ * Mock liquidity provider for testing
+ */
+declare class MockLiquidityProvider implements ILiquidityProvider {
+    chain: ChainId;
+    protocol: ProtocolId;
+    private pools;
+    constructor(chain: ChainId, protocol: ProtocolId);
+    addPool(pool: LiquidityPool): void;
+    getPools(inputAsset: AssetId, outputAsset?: AssetId): Promise<LiquidityPool[]>;
+    getPool(poolId: string): Promise<LiquidityPool | null>;
+}
+/**
+ * Mock bridge provider for testing
+ */
+declare class MockBridgeProvider implements IBridgeProvider {
+    bridge: ProtocolId;
+    private liquidity;
+    constructor(bridge: ProtocolId);
+    setLiquidity(sourceChain: ChainId, destinationChain: ChainId, asset: AssetId, data: CrossChainLiquidity['bridges'][0]): void;
+    getLiquidity(sourceChain: ChainId, destinationChain: ChainId, asset: AssetId): Promise<CrossChainLiquidity['bridges'][0] | null>;
+}
+
+export { type AggregatorConfig, CrossChainLiquidity, type IBridgeProvider, type ILiquidityProvider, LiquidityAggregator, LiquidityDepth, LiquidityPool, LiquiditySource, MockBridgeProvider, MockLiquidityProvider, PoolType, SlippageResult };

package/dist/liquidity/index.js

@@ -0,0 +1,24 @@
+import {
+  CrossChainLiquidity,
+  LiquidityAggregator,
+  LiquidityDepth,
+  LiquidityPool,
+  LiquiditySource,
+  MockBridgeProvider,
+  MockLiquidityProvider,
+  PoolType,
+  SlippageResult
+} from "../chunk-PCDWVENA.js";
+import "../chunk-QIZPPHGB.js";
+export {
+  CrossChainLiquidity,
+  LiquidityAggregator,
+  LiquidityDepth,
+  LiquidityPool,
+  LiquiditySource,
+  MockBridgeProvider,
+  MockLiquidityProvider,
+  PoolType,
+  SlippageResult
+};
+//# sourceMappingURL=index.js.map

package/dist/liquidity/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/pricing/index.d.ts

@@ -0,0 +1,74 @@
+import { c as GasOracle, F as FeeEstimateRequest, a as FeeEstimate, S as SwapQuote, B as BridgeQuote, P as ProtocolFees, T as TokenPrice } from '../gas-CNpJzuy5.js';
+export { d as GasOracleConfig, G as GasPrice, I as IGasProvider, M as MockGasProvider, b as PricePrediction } from '../gas-CNpJzuy5.js';
+import { C as ChainId, P as ProtocolId, A as AssetId } from '../types-C0ey6WqI.js';
+import 'zod';
+
+/**
+ * Fee estimator configuration
+ */
+interface FeeEstimatorConfig {
+    defaultSlippage?: string;
+    cacheTtl?: number;
+}
+/**
+ * Fee estimator for calculating total transaction costs
+ */
+declare class FeeEstimator {
+    private gasOracle;
+    private protocolFees;
+    private tokenPrices;
+    private config;
+    private readonly GAS_ESTIMATES;
+    constructor(gasOracle: GasOracle, config?: FeeEstimatorConfig);
+    /**
+     * Estimate fees for an operation
+     */
+    estimateFees(request: FeeEstimateRequest): Promise<FeeEstimate>;
+    /**
+     * Estimate total route fees
+     */
+    estimateRouteFees(steps: Array<{
+        chain: ChainId;
+        operation: string;
+        protocol?: ProtocolId;
+        amount: string;
+        inputAsset: AssetId;
+        outputAsset?: AssetId;
+    }>, gasSpeed?: 'slow' | 'standard' | 'fast' | 'instant'): Promise<{
+        totalGasUsd: string;
+        totalProtocolFeesUsd: string;
+        totalFeesUsd: string;
+        stepEstimates: FeeEstimate[];
+    }>;
+    /**
+     * Get a swap quote
+     */
+    getSwapQuote(chain: ChainId, dex: ProtocolId, inputAsset: AssetId, outputAsset: AssetId, inputAmount: string, slippage?: string): Promise<SwapQuote>;
+    /**
+     * Get a bridge quote
+     */
+    getBridgeQuote(bridge: ProtocolId, sourceChain: ChainId, destinationChain: ChainId, sourceAsset: AssetId, destinationAsset: AssetId, inputAmount: string): Promise<BridgeQuote>;
+    /**
+     * Register protocol fee structure
+     */
+    registerProtocolFees(fees: ProtocolFees): void;
+    /**
+     * Update token price
+     */
+    updateTokenPrice(price: TokenPrice): void;
+    private getGasEstimate;
+    private calculateProtocolFee;
+    private getProtocolFeePercent;
+    private getTokenPrice;
+    private getBridgeEstimatedTime;
+}
+/**
+ * Calculate slippage-adjusted output
+ */
+declare function calculateMinOutput(amount: string, slippagePercent: string): string;
+/**
+ * Calculate price impact from liquidity
+ */
+declare function calculatePriceImpact(amount: string, liquidity: string): string;
+
+export { BridgeQuote, FeeEstimate, FeeEstimateRequest, FeeEstimator, type FeeEstimatorConfig, GasOracle, ProtocolFees, SwapQuote, TokenPrice, calculateMinOutput, calculatePriceImpact };

package/dist/pricing/index.js

@@ -0,0 +1,32 @@
+import {
+  BridgeQuote,
+  FeeEstimate,
+  FeeEstimateRequest,
+  FeeEstimator,
+  GasOracle,
+  GasPrice,
+  MockGasProvider,
+  PricePrediction,
+  ProtocolFees,
+  SwapQuote,
+  TokenPrice,
+  calculateMinOutput,
+  calculatePriceImpact
+} from "../chunk-BUGQ6VOQ.js";
+import "../chunk-QIZPPHGB.js";
+export {
+  BridgeQuote,
+  FeeEstimate,
+  FeeEstimateRequest,
+  FeeEstimator,
+  GasOracle,
+  GasPrice,
+  MockGasProvider,
+  PricePrediction,
+  ProtocolFees,
+  SwapQuote,
+  TokenPrice,
+  calculateMinOutput,
+  calculatePriceImpact
+};
+//# sourceMappingURL=index.js.map

package/dist/pricing/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/routing/index.d.ts

@@ -0,0 +1,117 @@
+import { a as RouteRequest, c as Route, e as RouteValidation, G as GraphEdge, g as RoutingGraph, C as ChainId, A as AssetId, O as OptimizationStrategy } from '../types-C0ey6WqI.js';
+export { f as GraphNode, P as ProtocolId, d as RouteComparison, b as RouteStep, R as RouteStepType } from '../types-C0ey6WqI.js';
+import 'zod';
+
+/**
+ * Router configuration
+ */
+interface RouterConfig {
+    maxRoutes?: number;
+    cacheTtl?: number;
+    minConfidence?: number;
+    defaultSlippage?: string;
+}
+/**
+ * Smart routing engine
+ */
+declare class RoutingEngine {
+    private graph;
+    private config;
+    private routeCache;
+    constructor(config?: RouterConfig);
+    /**
+     * Find optimal routes for a payment
+     */
+    findRoutes(request: RouteRequest): Promise<Route[]>;
+    /**
+     * Get the best route for a payment
+     */
+    getBestRoute(request: RouteRequest): Promise<Route | null>;
+    /**
+     * Validate a route is still executable
+     */
+    validateRoute(route: Route): Promise<RouteValidation>;
+    /**
+     * Update the routing graph with new data
+     */
+    updateGraph(edges: GraphEdge[]): void;
+    /**
+     * Add an edge to the routing graph
+     */
+    addEdge(edge: GraphEdge): void;
+    /**
+     * Get the current routing graph
+     */
+    getGraph(): RoutingGraph;
+    private validateRequest;
+    private findAllPaths;
+    private buildRoute;
+    private scoreRoute;
+    private calculateOutput;
+    private calculateProtocolFee;
+    private calculateBridgeFee;
+    private calculatePriceImpact;
+    private calculateExchangeRate;
+    private estimateGas;
+    private getProtocolContract;
+    private calculateConfidence;
+    private generateWarnings;
+    private findEdge;
+    private getCacheKey;
+}
+/**
+ * Routing error codes
+ */
+type RoutingErrorCode = 'INVALID_REQUEST' | 'NO_ROUTE' | 'NO_VALID_ROUTE' | 'INSUFFICIENT_LIQUIDITY' | 'ROUTE_EXPIRED';
+/**
+ * Custom error for routing operations
+ */
+declare class RoutingError extends Error {
+    code: RoutingErrorCode;
+    constructor(message: string, code: RoutingErrorCode);
+}
+
+/**
+ * Cost function configuration
+ */
+interface CostConfig {
+    gasCostWeight: number;
+    feeWeight: number;
+    timeWeight: number;
+    slippageWeight: number;
+    hopPenalty: number;
+    bridgePenalty: number;
+}
+/**
+ * Default cost configurations for different strategies
+ */
+declare const COST_CONFIGS: Record<OptimizationStrategy, CostConfig>;
+/**
+ * Calculate edge cost based on optimization strategy
+ */
+declare function calculateEdgeCost(edge: GraphEdge, config: CostConfig): number;
+/**
+ * Dijkstra's algorithm for finding shortest path
+ */
+declare function dijkstra(edges: GraphEdge[], startChain: ChainId, startAsset: AssetId, endChain: ChainId, endAsset: AssetId, costConfig: CostConfig, maxHops?: number): GraphEdge[] | null;
+/**
+ * A* algorithm with heuristic for faster path finding
+ */
+declare function astar(edges: GraphEdge[], startChain: ChainId, startAsset: AssetId, endChain: ChainId, endAsset: AssetId, costConfig: CostConfig, maxHops?: number): GraphEdge[] | null;
+/**
+ * Find k-shortest paths using Yen's algorithm
+ */
+declare function kShortestPaths(edges: GraphEdge[], startChain: ChainId, startAsset: AssetId, endChain: ChainId, endAsset: AssetId, costConfig: CostConfig, k?: number, maxHops?: number): GraphEdge[][];
+/**
+ * Multi-objective path finding (Pareto-optimal paths)
+ */
+declare function paretoOptimalPaths(edges: GraphEdge[], startChain: ChainId, startAsset: AssetId, endChain: ChainId, endAsset: AssetId, maxHops?: number): {
+    path: GraphEdge[];
+    metrics: {
+        cost: number;
+        time: number;
+        hops: number;
+    };
+}[];
+
+export { AssetId, COST_CONFIGS, ChainId, type CostConfig, GraphEdge, OptimizationStrategy, Route, RouteRequest, RouteValidation, type RouterConfig, RoutingEngine, RoutingError, type RoutingErrorCode, RoutingGraph, astar, calculateEdgeCost, dijkstra, kShortestPaths, paretoOptimalPaths };