@luxfi/dex 1.2.1 → 1.3.0

package/dist/precompile/addresses.d.ts

@@ -0,0 +1,65 @@
+/**
+ * DEX Precompile Addresses
+ * Native Go implementation at EVM level
+ *
+ * Lux Precompile Address Standard:
+ * - Prefix format: 0xNNNN000000000000000000000000000000000000
+ * - Range 0x0400-0x04FF is reserved for DEX precompiles
+ *
+ * @see ~/work/lux/precompile/dex/module.go for implementation
+ */
+import type { Address } from 'viem';
+/**
+ * DEX Precompile contract addresses
+ * These are native precompiles, not deployed contracts
+ */
+export declare const DEX_PRECOMPILES: {
+    /**
+     * PoolManager (0x0400)
+     * Singleton managing all liquidity pools
+     * - Initialize pools
+     * - Execute swaps
+     * - Modify liquidity
+     * - Flash accounting settlement
+     */
+    readonly POOL_MANAGER: Address;
+    /**
+     * SwapRouter (0x0401)
+     * Optimized swap routing
+     * - exactInputSingle / exactOutputSingle
+     * - Multi-hop swaps
+     * - Native LUX support
+     */
+    readonly SWAP_ROUTER: Address;
+    /**
+     * HooksRegistry (0x0402)
+     * Hook contract registry
+     * - Register hook contracts
+     * - Query hook permissions
+     */
+    readonly HOOKS_REGISTRY: Address;
+    /**
+     * FlashLoan (0x0403)
+     * Flash loan facility
+     * - Borrow any token
+     * - Repay in same transaction
+     */
+    readonly FLASH_LOAN: Address;
+    /**
+     * Lending (0x0410)
+     * Lending protocol
+     */
+    readonly LENDING: Address;
+    /**
+     * Liquid (0x0430)
+     * Liquid staking vaults
+     */
+    readonly LIQUID: Address;
+    /**
+     * Teleport (0x0440)
+     * Cross-chain bridge
+     */
+    readonly TELEPORT: Address;
+};
+export type DexPrecompile = keyof typeof DEX_PRECOMPILES;
+//# sourceMappingURL=addresses.d.ts.map

package/dist/precompile/addresses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addresses.d.ts","sourceRoot":"","sources":["../../src/precompile/addresses.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAEnC;;;GAGG;AACH,eAAO,MAAM,eAAe;IAC1B;;;;;;;OAOG;2BAC2D,OAAO;IAErE;;;;;;OAMG;0BAC0D,OAAO;IAEpE;;;;;OAKG;6BAC6D,OAAO;IAEvE;;;;;OAKG;yBACyD,OAAO;IAEnE;;;OAGG;sBACsD,OAAO;IAEhE;;;OAGG;qBACqD,OAAO;IAE/D;;;OAGG;uBACuD,OAAO;CACzD,CAAA;AAEV,MAAM,MAAM,aAAa,GAAG,MAAM,OAAO,eAAe,CAAA"}

package/dist/precompile/addresses.js

@@ -0,0 +1,52 @@
+/**
+ * DEX Precompile contract addresses
+ * These are native precompiles, not deployed contracts
+ */
+export const DEX_PRECOMPILES = {
+    /**
+     * PoolManager (0x0400)
+     * Singleton managing all liquidity pools
+     * - Initialize pools
+     * - Execute swaps
+     * - Modify liquidity
+     * - Flash accounting settlement
+     */
+    POOL_MANAGER: '0x0400000000000000000000000000000000000000',
+    /**
+     * SwapRouter (0x0401)
+     * Optimized swap routing
+     * - exactInputSingle / exactOutputSingle
+     * - Multi-hop swaps
+     * - Native LUX support
+     */
+    SWAP_ROUTER: '0x0401000000000000000000000000000000000000',
+    /**
+     * HooksRegistry (0x0402)
+     * Hook contract registry
+     * - Register hook contracts
+     * - Query hook permissions
+     */
+    HOOKS_REGISTRY: '0x0402000000000000000000000000000000000000',
+    /**
+     * FlashLoan (0x0403)
+     * Flash loan facility
+     * - Borrow any token
+     * - Repay in same transaction
+     */
+    FLASH_LOAN: '0x0403000000000000000000000000000000000000',
+    /**
+     * Lending (0x0410)
+     * Lending protocol
+     */
+    LENDING: '0x0410000000000000000000000000000000000000',
+    /**
+     * Liquid (0x0430)
+     * Liquid staking vaults
+     */
+    LIQUID: '0x0430000000000000000000000000000000000000',
+    /**
+     * Teleport (0x0440)
+     * Cross-chain bridge
+     */
+    TELEPORT: '0x0440000000000000000000000000000000000000',
+};

package/dist/precompile/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * DEX Precompile Exports
+ * Native Uniswap v4-style AMM at 0x0400-0x0403
+ */
+export * from './types';
+export * from './abis';
+export * from './addresses';
+//# sourceMappingURL=index.d.ts.map

package/dist/precompile/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/precompile/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,cAAc,SAAS,CAAA;AACvB,cAAc,QAAQ,CAAA;AACtB,cAAc,aAAa,CAAA"}

package/dist/precompile/index.js

@@ -0,0 +1,7 @@
+/**
+ * DEX Precompile Exports
+ * Native Uniswap v4-style AMM at 0x0400-0x0403
+ */
+export * from './types';
+export * from './abis';
+export * from './addresses';

package/dist/precompile/types.d.ts

@@ -0,0 +1,76 @@
+/**
+ * DEX Precompile Types
+ * Native Uniswap v4-style AMM implementation
+ */
+import type { Address } from 'viem';
+/**
+ * Currency type - address(0) = native LUX
+ */
+export interface Currency {
+    address: Address;
+}
+/**
+ * Pool key uniquely identifies a pool
+ */
+export interface PoolKey {
+    currency0: Address;
+    currency1: Address;
+    fee: number;
+    tickSpacing: number;
+    hooks: Address;
+}
+/**
+ * Balance delta from swap/liquidity operations
+ * Positive = user owes pool, Negative = pool owes user
+ */
+export interface BalanceDelta {
+    amount0: bigint;
+    amount1: bigint;
+}
+/**
+ * Swap parameters
+ */
+export interface SwapParams {
+    zeroForOne: boolean;
+    amountSpecified: bigint;
+    sqrtPriceLimitX96: bigint;
+}
+/**
+ * Modify liquidity parameters
+ */
+export interface ModifyLiquidityParams {
+    tickLower: number;
+    tickUpper: number;
+    liquidityDelta: bigint;
+    salt: `0x${string}`;
+}
+/**
+ * Pool state
+ */
+export interface PoolState {
+    sqrtPriceX96: bigint;
+    tick: number;
+    protocolFee: number;
+    lpFee: number;
+}
+/**
+ * Position info
+ */
+export interface Position {
+    liquidity: bigint;
+    feeGrowthInside0LastX128: bigint;
+    feeGrowthInside1LastX128: bigint;
+}
+/**
+ * Native LUX currency constant
+ */
+export declare const NATIVE_LUX: Address;
+/**
+ * Sort currencies for pool key creation
+ */
+export declare function sortCurrencies(a: Address, b: Address): [Address, Address];
+/**
+ * Create a pool key from two currencies
+ */
+export declare function createPoolKey(tokenA: Address, tokenB: Address, fee?: number, tickSpacing?: number, hooks?: Address): PoolKey;
+//# sourceMappingURL=types.d.ts.map

package/dist/precompile/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/precompile/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAEnC;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,OAAO,EAAE,OAAO,CAAA;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,OAAO;IACtB,SAAS,EAAE,OAAO,CAAA;IAClB,SAAS,EAAE,OAAO,CAAA;IAClB,GAAG,EAAE,MAAM,CAAA;IACX,WAAW,EAAE,MAAM,CAAA;IACnB,KAAK,EAAE,OAAO,CAAA;CACf;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,UAAU,EAAE,OAAO,CAAA;IACnB,eAAe,EAAE,MAAM,CAAA;IACvB,iBAAiB,EAAE,MAAM,CAAA;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,cAAc,EAAE,MAAM,CAAA;IACtB,IAAI,EAAE,KAAK,MAAM,EAAE,CAAA;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,YAAY,EAAE,MAAM,CAAA;IACpB,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,KAAK,EAAE,MAAM,CAAA;CACd;AAED;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,SAAS,EAAE,MAAM,CAAA;IACjB,wBAAwB,EAAE,MAAM,CAAA;IAChC,wBAAwB,EAAE,MAAM,CAAA;CACjC;AAED;;GAEG;AACH,eAAO,MAAM,UAAU,EAAE,OAAsD,CAAA;AAE/E;;GAEG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,CAEzE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,OAAO,EACf,GAAG,GAAE,MAAa,EAClB,WAAW,GAAE,MAAW,EACxB,KAAK,GAAE,OAAsD,GAC5D,OAAO,CAGT"}

package/dist/precompile/types.js

@@ -0,0 +1,17 @@
+/**
+ * Native LUX currency constant
+ */
+export const NATIVE_LUX = '0x0000000000000000000000000000000000000000';
+/**
+ * Sort currencies for pool key creation
+ */
+export function sortCurrencies(a, b) {
+    return a.toLowerCase() < b.toLowerCase() ? [a, b] : [b, a];
+}
+/**
+ * Create a pool key from two currencies
+ */
+export function createPoolKey(tokenA, tokenB, fee = 3000, tickSpacing = 60, hooks = '0x0000000000000000000000000000000000000000') {
+    const [currency0, currency1] = sortCurrencies(tokenA, tokenB);
+    return { currency0, currency1, fee, tickSpacing, hooks };
+}

package/dist/router/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Router Exports
+ * Omnichain routing between CLOB and AMM
+ */
+export * from './types';
+export * from './router';
+//# sourceMappingURL=index.d.ts.map

package/dist/router/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/router/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,cAAc,SAAS,CAAA;AACvB,cAAc,UAAU,CAAA"}

package/dist/router/index.js

@@ -0,0 +1,6 @@
+/**
+ * Router Exports
+ * Omnichain routing between CLOB and AMM
+ */
+export * from './types';
+export * from './router';

package/dist/router/router.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Omnichain Router
+ * Routes orders between CLOB and AMM for best execution
+ */
+import type { PublicClient } from 'viem';
+import type { ICLOBClient } from '../client/types';
+import type { RouterConfig, QuoteRequest, Quote, SwapRequest, SwapResult } from './types';
+/**
+ * Omnichain Router
+ * Best execution routing between CLOB and AMM
+ */
+export declare class OmnichainRouter {
+    private config;
+    private publicClient;
+    private clobClient;
+    constructor(config?: Partial<RouterConfig>);
+    /**
+     * Set the public client for AMM interactions
+     */
+    setPublicClient(client: PublicClient): void;
+    /**
+     * Set the CLOB client
+     */
+    setCLOBClient(client: ICLOBClient): void;
+    /**
+     * Get a quote for a swap
+     */
+    getQuote(request: QuoteRequest): Promise<Quote>;
+    /**
+     * Get AMM quote using precompiles
+     */
+    private getAMMQuote;
+    /**
+     * Get CLOB quote
+     */
+    private getCLOBQuote;
+    /**
+     * Convert token addresses to trading symbol
+     */
+    private getSymbol;
+    /**
+     * Execute a swap
+     */
+    executeSwap(request: SwapRequest): Promise<SwapResult>;
+    /**
+     * Execute AMM swap via precompile
+     */
+    private executeAMMSwap;
+    /**
+     * Execute CLOB swap
+     */
+    private executeCLOBSwap;
+}
+/**
+ * Create an omnichain router instance
+ */
+export declare function createRouter(config?: Partial<RouterConfig>): OmnichainRouter;
+//# sourceMappingURL=router.d.ts.map

package/dist/router/router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../src/router/router.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAW,YAAY,EAAE,MAAM,MAAM,CAAA;AAIjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAClD,OAAO,KAAK,EACV,YAAY,EACZ,YAAY,EACZ,KAAK,EAEL,WAAW,EACX,UAAU,EACX,MAAM,SAAS,CAAA;AAUhB;;;GAGG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,YAAY,CAA4B;IAChD,OAAO,CAAC,UAAU,CAA2B;gBAEjC,MAAM,GAAE,OAAO,CAAC,YAAY,CAAM;IAI9C;;OAEG;IACH,eAAe,CAAC,MAAM,EAAE,YAAY;IAIpC;;OAEG;IACH,aAAa,CAAC,MAAM,EAAE,WAAW;IAIjC;;OAEG;IACG,QAAQ,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,KAAK,CAAC;IAkDrD;;OAEG;YACW,WAAW;IAgEzB;;OAEG;YACW,YAAY;IAwE1B;;OAEG;IACH,OAAO,CAAC,SAAS;IAgBjB;;OAEG;IACG,WAAW,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;IAmB5D;;OAEG;YACW,cAAc;IAU5B;;OAEG;YACW,eAAe;CAyB9B;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,eAAe,CAE5E"}

package/dist/router/router.js

@@ -0,0 +1,272 @@
+import { DEX_PRECOMPILES } from '../precompile/addresses';
+import { POOL_MANAGER_ABI } from '../precompile/abis';
+import { createPoolKey } from '../precompile/types';
+const DEFAULT_CONFIG = {
+    clobEnabled: true,
+    ammEnabled: true,
+    maxHops: 3,
+    preferCLOB: false,
+    hybridEnabled: true,
+};
+/**
+ * Omnichain Router
+ * Best execution routing between CLOB and AMM
+ */
+export class OmnichainRouter {
+    config;
+    publicClient = null;
+    clobClient = null;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Set the public client for AMM interactions
+     */
+    setPublicClient(client) {
+        this.publicClient = client;
+    }
+    /**
+     * Set the CLOB client
+     */
+    setCLOBClient(client) {
+        this.clobClient = client;
+    }
+    /**
+     * Get a quote for a swap
+     */
+    async getQuote(request) {
+        const { tokenIn, tokenOut, amountIn, slippageTolerance = 50, // 0.5%
+        preferredSource, } = request;
+        const quotes = [];
+        // Get AMM quote if enabled
+        if (this.config.ammEnabled && (!preferredSource || preferredSource !== 'clob')) {
+            try {
+                const ammQuote = await this.getAMMQuote(tokenIn, tokenOut, amountIn);
+                if (ammQuote)
+                    quotes.push(ammQuote);
+            }
+            catch (error) {
+                console.warn('AMM quote failed:', error);
+            }
+        }
+        // Get CLOB quote if enabled
+        if (this.config.clobEnabled && this.clobClient && (!preferredSource || preferredSource !== 'amm')) {
+            try {
+                const clobQuote = await this.getCLOBQuote(tokenIn, tokenOut, amountIn);
+                if (clobQuote)
+                    quotes.push(clobQuote);
+            }
+            catch (error) {
+                console.warn('CLOB quote failed:', error);
+            }
+        }
+        if (quotes.length === 0) {
+            throw new Error('No quotes available');
+        }
+        // Select best quote (highest output)
+        const bestQuote = quotes.reduce((best, quote) => quote.amountOut > best.amountOut ? quote : best);
+        // Apply slippage tolerance
+        const minimumAmountOut = bestQuote.amountOut - (bestQuote.amountOut * BigInt(slippageTolerance)) / 10000n;
+        return {
+            ...bestQuote,
+            minimumAmountOut,
+            validUntil: Date.now() + 30000, // 30 seconds
+        };
+    }
+    /**
+     * Get AMM quote using precompiles
+     */
+    async getAMMQuote(tokenIn, tokenOut, amountIn) {
+        if (!this.publicClient)
+            return null;
+        try {
+            // Create pool key
+            const poolKey = createPoolKey(tokenIn, tokenOut);
+            const zeroForOne = tokenIn.toLowerCase() < tokenOut.toLowerCase();
+            // Get pool state
+            const slot0 = await this.publicClient.readContract({
+                address: DEX_PRECOMPILES.POOL_MANAGER,
+                abi: POOL_MANAGER_ABI,
+                functionName: 'getSlot0',
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                args: [poolKey],
+            });
+            if (slot0[0] === 0n) {
+                return null; // Pool doesn't exist
+            }
+            // Calculate expected output (simplified - real implementation would use tick math)
+            // For now, use a simple estimate based on sqrt price
+            const sqrtPriceX96 = slot0[0];
+            const price = (sqrtPriceX96 * sqrtPriceX96) / (2n ** 192n);
+            const amountOut = zeroForOne
+                ? (amountIn * price) / (10n ** 18n)
+                : (amountIn * (10n ** 18n)) / price;
+            // Estimate price impact (simplified)
+            const priceImpact = Number((amountIn * 10n) / (amountIn + amountOut));
+            const step = {
+                source: 'amm',
+                tokenIn,
+                tokenOut,
+                amountIn,
+                amountOut,
+                pool: DEX_PRECOMPILES.POOL_MANAGER,
+                fee: (amountIn * BigInt(poolKey.fee)) / 1000000n,
+                priceImpact,
+            };
+            return {
+                tokenIn,
+                tokenOut,
+                amountIn,
+                amountOut,
+                minimumAmountOut: amountOut,
+                route: [step],
+                priceImpact,
+                estimatedGas: 150000n,
+                validUntil: Date.now() + 30000,
+            };
+        }
+        catch (error) {
+            console.error('AMM quote error:', error);
+            return null;
+        }
+    }
+    /**
+     * Get CLOB quote
+     */
+    async getCLOBQuote(tokenIn, tokenOut, amountIn) {
+        if (!this.clobClient || !this.clobClient.isConnected())
+            return null;
+        try {
+            // Convert addresses to symbol (e.g., "LUX-USDT")
+            const symbol = this.getSymbol(tokenIn, tokenOut);
+            if (!symbol)
+                return null;
+            const orderBook = await this.clobClient.getOrderBook(symbol, 50);
+            // Calculate output by walking the order book
+            let remainingIn = amountIn;
+            let totalOut = 0n;
+            const side = tokenIn.toLowerCase() < tokenOut.toLowerCase() ? 'asks' : 'bids';
+            const levels = side === 'asks' ? orderBook.asks : orderBook.bids;
+            for (const level of levels) {
+                if (remainingIn <= 0n)
+                    break;
+                const levelSize = BigInt(Math.floor(level.size * 1e18));
+                const levelPrice = BigInt(Math.floor(level.price * 1e18));
+                const fillSize = remainingIn < levelSize ? remainingIn : levelSize;
+                const fillOut = side === 'asks'
+                    ? (fillSize * (10n ** 18n)) / levelPrice
+                    : (fillSize * levelPrice) / (10n ** 18n);
+                totalOut += fillOut;
+                remainingIn -= fillSize;
+            }
+            if (totalOut === 0n)
+                return null;
+            // Calculate price impact
+            const avgPrice = (amountIn * (10n ** 18n)) / totalOut;
+            const bestPrice = BigInt(Math.floor(levels[0]?.price * 1e18 || 0));
+            const priceImpact = bestPrice > 0n
+                ? Number(((avgPrice - bestPrice) * 10000n) / bestPrice)
+                : 0;
+            const step = {
+                source: 'clob',
+                tokenIn,
+                tokenOut,
+                amountIn,
+                amountOut: totalOut,
+                symbol,
+                fee: (amountIn * 30n) / 10000n, // 0.3% maker fee estimate
+                priceImpact,
+            };
+            return {
+                tokenIn,
+                tokenOut,
+                amountIn,
+                amountOut: totalOut,
+                minimumAmountOut: totalOut,
+                route: [step],
+                priceImpact,
+                estimatedGas: 50000n, // CLOB is off-chain
+                validUntil: Date.now() + 10000, // 10 seconds (faster expiry for CLOB)
+            };
+        }
+        catch (error) {
+            console.error('CLOB quote error:', error);
+            return null;
+        }
+    }
+    /**
+     * Convert token addresses to trading symbol
+     */
+    getSymbol(tokenIn, tokenOut) {
+        // TODO: Implement proper token-to-symbol mapping
+        // This should look up the token registry
+        const tokenMap = {
+            '0x0000000000000000000000000000000000000000': 'LUX',
+            // Add more tokens as needed
+        };
+        const symbolIn = tokenMap[tokenIn.toLowerCase()];
+        const symbolOut = tokenMap[tokenOut.toLowerCase()];
+        if (!symbolIn || !symbolOut)
+            return null;
+        return `${symbolIn}-${symbolOut}`;
+    }
+    /**
+     * Execute a swap
+     */
+    async executeSwap(request) {
+        const { quote, recipient, deadline = Math.floor(Date.now() / 1000) + 1200 } = request;
+        if (Date.now() > quote.validUntil) {
+            throw new Error('Quote expired');
+        }
+        // Determine execution path
+        const source = quote.route[0]?.source;
+        if (source === 'amm') {
+            return this.executeAMMSwap(quote, recipient, deadline);
+        }
+        else if (source === 'clob') {
+            return this.executeCLOBSwap(quote, recipient);
+        }
+        else {
+            throw new Error(`Unknown route source: ${source}`);
+        }
+    }
+    /**
+     * Execute AMM swap via precompile
+     */
+    async executeAMMSwap(quote, recipient, deadline) {
+        // This would be called by the wallet/wagmi on the frontend
+        // Just return the transaction parameters
+        throw new Error('AMM swap execution should be handled by wagmi writeContract');
+    }
+    /**
+     * Execute CLOB swap
+     */
+    async executeCLOBSwap(quote, recipient) {
+        if (!this.clobClient) {
+            throw new Error('CLOB client not configured');
+        }
+        const step = quote.route[0];
+        if (!step?.symbol) {
+            throw new Error('Invalid CLOB route');
+        }
+        // Place market order on CLOB
+        const order = await this.clobClient.placeOrder({
+            symbol: step.symbol,
+            side: step.tokenIn.toLowerCase() < step.tokenOut.toLowerCase() ? 'buy' : 'sell',
+            type: 'market',
+            size: Number(quote.amountIn) / 1e18,
+        });
+        return {
+            txHash: `0x${order.orderId}`,
+            amountIn: quote.amountIn,
+            amountOut: quote.amountOut,
+            route: quote.route,
+        };
+    }
+}
+/**
+ * Create an omnichain router instance
+ */
+export function createRouter(config) {
+    return new OmnichainRouter(config);
+}

package/dist/router/types.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Router Types
+ * Types for hybrid CLOB + AMM routing
+ */
+import type { Address } from 'viem';
+/**
+ * Route source - where liquidity comes from
+ */
+export type RouteSource = 'clob' | 'amm' | 'hybrid';
+/**
+ * Quote request
+ */
+export interface QuoteRequest {
+    tokenIn: Address;
+    tokenOut: Address;
+    amountIn: bigint;
+    slippageTolerance?: number;
+    preferredSource?: RouteSource;
+}
+/**
+ * Route step
+ */
+export interface RouteStep {
+    source: RouteSource;
+    tokenIn: Address;
+    tokenOut: Address;
+    amountIn: bigint;
+    amountOut: bigint;
+    pool?: Address;
+    symbol?: string;
+    fee: bigint;
+    priceImpact: number;
+}
+/**
+ * Quote response
+ */
+export interface Quote {
+    tokenIn: Address;
+    tokenOut: Address;
+    amountIn: bigint;
+    amountOut: bigint;
+    minimumAmountOut: bigint;
+    route: RouteStep[];
+    priceImpact: number;
+    estimatedGas: bigint;
+    validUntil: number;
+}
+/**
+ * Swap request
+ */
+export interface SwapRequest {
+    quote: Quote;
+    recipient: Address;
+    deadline?: number;
+}
+/**
+ * Swap result
+ */
+export interface SwapResult {
+    txHash: `0x${string}`;
+    amountIn: bigint;
+    amountOut: bigint;
+    route: RouteStep[];
+}
+/**
+ * Router configuration
+ */
+export interface RouterConfig {
+    clobUrl?: string;
+    clobEnabled?: boolean;
+    ammEnabled?: boolean;
+    maxHops?: number;
+    preferCLOB?: boolean;
+    hybridEnabled?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/router/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/router/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAEnC;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,CAAA;AAEnD;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,OAAO,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,eAAe,CAAC,EAAE,WAAW,CAAA;CAC9B;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,WAAW,CAAA;IACnB,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,OAAO,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,GAAG,EAAE,MAAM,CAAA;IACX,WAAW,EAAE,MAAM,CAAA;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,KAAK;IACpB,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,OAAO,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB,gBAAgB,EAAE,MAAM,CAAA;IACxB,KAAK,EAAE,SAAS,EAAE,CAAA;IAClB,WAAW,EAAE,MAAM,CAAA;IACnB,YAAY,EAAE,MAAM,CAAA;IACpB,UAAU,EAAE,MAAM,CAAA;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,KAAK,CAAA;IACZ,SAAS,EAAE,OAAO,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,KAAK,MAAM,EAAE,CAAA;IACrB,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,SAAS,EAAE,CAAA;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAE3B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,WAAW,CAAC,EAAE,OAAO,CAAA;IAGrB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,OAAO,CAAC,EAAE,MAAM,CAAA;IAGhB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB"}

package/dist/router/types.js

@@ -0,0 +1 @@
+export {};