┌─────────────────────────────────────────────────────────────────────────────┐
│                      UNIVERSAL LIQUIDITY ENGINE                              │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                              │
│  ┌───────────────────────────────────────────────────────────────────────┐  │
│  │                    UniversalLiquidityRouter                           │  │
│  │         getBestQuote() | swap() | supplyBest() | borrow()             │  │
│  └─────────────────────────────────┬─────────────────────────────────────┘  │
│                                    │                                         │
│  ┌─────────────────────────────────┴─────────────────────────────────────┐  │
│  │                          ADAPTER LAYER                                │  │
│  ├───────────────┬───────────────┬───────────────┬───────────────────────┤  │
│  │     EVM       │    SOLANA     │      TON      │      BRIDGES          │  │
│  ├───────────────┼───────────────┼───────────────┼───────────────────────┤  │
│  │ • Uniswap V3  │ • Jupiter     │ • STON.fi     │ • Warp (Lux)          │  │
│  │ • Aave V3     │ • Raydium     │ • DeDust      │ • Stargate            │  │
│  │ • Compound    │ • Meteora     │ • Evaa        │ • Across              │  │
│  │ • Curve       │ • Orca        │ • Omniston    │ • Hop                 │  │
│  │ • 1inch       │ • Solend      │               │                       │  │
│  │ • Balancer    │ • Marinade    │               │                       │  │
│  │ • PancakeSwap │ • Kamino      │               │                       │  │
│  │ • GMX/Aster   │               │               │                       │  │
│  └───────────────┴───────────────┴───────────────┴───────────────────────┘  │
│                                                                              │
└─────────────────────────────────────────────────────────────────────────────┘

import "@luxfi/standard/src/liquidity/UniversalLiquidityRouter.sol";

UniversalLiquidityRouter router = UniversalLiquidityRouter(ROUTER_ADDRESS);

// Get best swap quote
(ILiquidityEngine.SwapQuote memory quote, bytes32 protocol) =
    router.getBestQuote(WETH, USDC, 1 ether);

console.log("Best output:", quote.amountOut);
console.log("Via protocol:", protocol); // e.g., "UNISWAP_V3"

// Execute swap with best route
uint256 amountOut = router.swap(
    WETH,           // tokenIn
    USDC,           // tokenOut
    1 ether,        // amountIn
    990e6,          // minAmountOut (1% slippage)
    msg.sender,     // recipient
    block.timestamp + 300 // deadline
);

// Build custom route
UniversalLiquidityRouter.RouteStep[] memory steps = new RouteStep[](2);

// Step 1: WETH → USDC via Uniswap
steps[0] = RouteStep({
    adapter: uniswapAdapter,
    tokenIn: WETH,
    tokenOut: USDC,
    amountIn: 1 ether,
    extraData: ""
});

// Step 2: USDC → DAI via Curve
steps[1] = RouteStep({
    adapter: curveAdapter,
    tokenIn: USDC,
    tokenOut: DAI,
    amountIn: 0, // Use output from step 1
    extraData: ""
});

uint256 finalAmount = router.swapMultiHop(
    steps,
    990e18,         // minAmountOut
    msg.sender,
    block.timestamp + 300
);

// Get best supply rate
(ILiquidityEngine.LendingQuote memory quote, bytes32 protocol) =
    router.getBestLendingRate(USDC, 1000e6, true);

console.log("Best APY:", quote.apy);
console.log("Via:", protocol); // e.g., "AAVE_V3"

// Supply to best protocol
(uint256 shares, bytes32 usedProtocol) = router.supplyBest(USDC, 1000e6);

import { LuxLiquidityEngine } from '@luxfi/liquidity-sdk';

const engine = new LuxLiquidityEngine({
  // EVM chains
  ethereum: { rpc: 'https://eth.llamarpc.com', signer },
  bsc: { rpc: 'https://bsc-dataseed.binance.org', signer },
  arbitrum: { rpc: 'https://arb1.arbitrum.io/rpc', signer },
  lux: { rpc: 'https://api.lux.network/rpc', signer },

  // Solana
  solana: { connection, wallet },

  // TON
  ton: { endpoint: 'https://toncenter.com/api/v2/jsonRPC', wallet },
});

// Cross-chain swap: ETH (Ethereum) → SOL (Solana)
const quote = await engine.getCrossChainQuote({
  sourceChain: 'ethereum',
  destChain: 'solana',
  tokenIn: 'ETH',
  tokenOut: 'SOL',
  amount: parseEther('1'),
});

console.log({
  amountOut: quote.amountOut,
  route: quote.route, // [ETH → USDC via Uniswap] → [Bridge] → [USDC → SOL via Jupiter]
  estimatedTime: quote.estimatedTime,
  totalFees: quote.fees,
});

// Execute
const txs = await engine.executeCrossChainSwap(quote);
for (const tx of txs) {
  console.log(`${tx.chain}: ${tx.hash}`);
}

import { LuxSolanaRouter } from '@luxfi/solana-liquidity';

const router = new LuxSolanaRouter({ connection, wallet });

// Swap via Jupiter (aggregates all Solana DEXes)
const { txId } = await router.swap({
  inputMint: 'So11111111111111111111111111111111111111112', // SOL
  outputMint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v', // USDC
  amount: 1_000_000_000, // 1 SOL
  slippageBps: 50,
});

// Supply to Solend
const { txId } = await router.supply({
  protocol: 'SOLEND',
  token: 'USDC',
  amount: 100_000_000,
});

// Add liquidity to Meteora DLMM
const { txId } = await router.addLiquidity({
  protocol: 'METEORA',
  pool: 'SOL-USDC',
  amountA: 1_000_000_000,
  amountB: 100_000_000,
});

import { LuxTonRouter } from '@luxfi/ton-liquidity';

const router = new LuxTonRouter({ endpoint, wallet });

// Swap via STON.fi
const { txHash } = await router.swap({
  protocol: 'STONFI',
  tokenIn: 'TON',
  tokenOut: 'USDT',
  amount: toNano('10'),
  slippage: 0.01,
});

// Cross-chain via Omniston
const { txHash } = await router.crossChainSwap({
  srcChain: 'TON',
  dstChain: 'ETHEREUM',
  tokenIn: 'TON',
  tokenOut: 'ETH',
  amount: toNano('100'),
});

// SPDX-License-Identifier: BSD-3-Clause
// Copyright (c) 2025 Lux Industries Inc.
pragma solidity ^0.8.24;

import {ILiquidityEngine} from "../interfaces/ILiquidityEngine.sol";

contract MyProtocolAdapter is ILiquidityEngine {
    // Implement required functions
    function getSwapQuote(address tokenIn, address tokenOut, uint256 amountIn)
        external view returns (SwapQuote memory);

    function swap(address tokenIn, address tokenOut, uint256 amountIn,
        uint256 minAmountOut, address recipient, uint256 deadline)
        external payable returns (uint256);

    // ... other required functions
}

// Admin registers new adapter
router.registerAdapter(
    keccak256("MY_PROTOCOL"),  // protocolId
    myAdapterAddress,          // adapter
    10                         // priority (lower = higher)
);

// Enable/disable
router.setAdapterEnabled(keccak256("MY_PROTOCOL"), true);

src/liquidity/
├── interfaces/
│   └── ILiquidityEngine.sol      # Universal adapter interface
├── UniversalLiquidityRouter.sol  # Main aggregator router
├── ProtocolRegistry.sol          # All protocol addresses
├── evm/
│   ├── UniswapV3Adapter.sol      # Uniswap V3 integration
│   ├── AaveV3Adapter.sol         # Aave V3 lending
│   ├── OneInchAdapter.sol        # 1inch aggregator
│   └── ...
├── solana/
│   └── README.md                 # Solana SDK documentation
└── ton/
    └── README.md                 # TON SDK documentation