// LuxLend market definition - just 5 parameters
struct MarketParams {
    address loanToken;
    address collateralToken;
    address oracle;
    address irm;
    uint256 lltv;
}

// Market ID is simply the hash
function id(MarketParams memory params) internal pure returns (Id) {
    return Id.wrap(keccak256(abi.encode(params)));
}

// Oracle interface - implement however you want
interface IOracle {
    function price() external view returns (uint256);
}

// Interest Rate Model - implement however you want
interface IIrm {
    function borrowRate(MarketParams memory, Market memory)
        external returns (uint256);
}

// ONE contract holds ALL markets
contract LuxLend {
    mapping(Id => Market) public market;
    mapping(Id => mapping(address => Position)) public position;
}

function flashLoan(address token, uint256 assets, bytes calldata data) external {
    IERC20(token).safeTransfer(msg.sender, assets);
    IFlashLoanCallback(msg.sender).onFlashLoan(assets, data);
    IERC20(token).safeTransferFrom(msg.sender, address(this), assets);
    // No fee! Just repay what you borrowed
}

// Supply with callback
function supply(..., bytes calldata data) external {
    // ... accounting
    if (data.length > 0) {
        ISupplyCallback(msg.sender).onSupply(assets, data);
    }
    IERC20(token).safeTransferFrom(msg.sender, address(this), assets);
}

┌─────────────────────────────────────────────────────────────┐
│                      LUXBUNDLER                              │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│   User signs ONE transaction containing:                     │
│                                                              │
│   1. Approve USDC to Bundler                                │
│   2. Swap USDC → WETH via DEX                               │
│   3. Supply WETH as collateral to LuxLend                   │
│   4. Borrow LUXD against collateral                         │
│   5. Repay competitor loan with LUXD                        │
│   6. Withdraw competitor collateral                         │
│   7. Supply competitor collateral to LuxLend                │
│                                                              │
│   = Complete migration in ONE tx                            │
│                                                              │
└─────────────────────────────────────────────────────────────┘

// One-click migration from competitors
contract MigrationAdapter {
    function migratePosition(
        address sourcePool,
        address[] calldata collaterals,
        address[] calldata debts,
        Id[] calldata luxMarkets
    ) external {
        // 1. Flash loan to repay source debt
        // 2. Withdraw source collateral
        // 3. Supply collateral to LuxLend
        // 4. Borrow from LuxLend to repay flash loan
    }
}

contract LuxLend {
    // Core lending logic

    // + Warp integration for cross-chain markets
    IWarpMessenger constant WARP = IWarpMessenger(0x0200...0005);

    function supplyFromRemoteChain(
        MarketParams memory params,
        uint256 assets,
        uint32 warpIndex
    ) external {
        WarpMessage memory msg = WARP.getVerifiedWarpMessage(warpIndex);
        // Verify and credit cross-chain supply
    }

    // + Native LUX collateral
    function supplyCollateralLUX(MarketParams memory params)
        external payable
    {
        IWLUX(WLUX).deposit{value: msg.value}();
        _supplyCollateral(params, msg.value, msg.sender);
    }
}

contract LuxBundler {
    // Core bundler logic

    // Adapters:
    // - GeneralAdapter (ERC20, WLUX, ERC4626)
    // - LendingAdapter (LuxLend interactions)
    // - AMMAdapter (Uniswap V2/V3 swaps)
    // - PerpsAdapter (position management)
    // - OmnichainAdapter (cross-chain operations)
    // - MigrationAdapter (competitor migration)
}

Call[] memory bundle = new Call[](4);

// 1. Supply ETH as collateral
bundle[0] = Call({
    to: lendingAdapter,
    data: abi.encodeCall(supplyCollateral, (market, ethAmount)),
    value: ethAmount
});

// 2. Borrow LUXD
bundle[1] = Call({
    to: lendingAdapter,
    data: abi.encodeCall(borrow, (market, luxdAmount))
});

// 3. Swap LUXD for more ETH
bundle[2] = Call({
    to: ammAdapter,
    data: abi.encodeCall(swapExactIn, (LUXD, WETH, luxdAmount, minEth))
});

// 4. Supply swapped ETH as more collateral
bundle[3] = Call({
    to: lendingAdapter,
    data: abi.encodeCall(supplyCollateral, (market, 0)) // Uses balance
});

bundler.multicall(bundle);
// Result: 3x leveraged ETH long in one tx

@luxfi/sdk/
├── packages/
│   ├── core/              # Entity classes (Market, Position, Vault)
│   ├── viem/              # Viem-based fetch and actions
│   ├── wagmi/             # React hooks
│   ├── bundler/           # Build bundler transactions
│   ├── simulation/        # Preview outcomes before tx
│   ├── liquidation/       # MEV-protected liquidation bots
│   ├── omnichain/         # Cross-chain operations
│   └── migration/         # Competitor migration helpers

import { LuxLend, Market, simulate } from '@luxfi/sdk';

// Fetch market data
const market = await LuxLend.getMarket(marketId);

// Simulate borrow
const result = await simulate.borrow({
  market,
  assets: parseEther('1000'),
  account: userAddress,
});

console.log({
  newHealthFactor: result.healthFactor,
  liquidationPrice: result.liquidationPrice,
  interestRate: result.borrowRate,
});

// Build bundler tx for leverage
const bundle = await bundler.leverageLong({
  market,
  collateralAmount: parseEther('1'),
  leverage: 3,
  slippage: 0.5,
});

// Execute
await walletClient.sendTransaction(bundle);

src/
├── lending/
│   ├── LuxLend.sol           # Core lending
│   ├── interfaces/
│   │   ├── ILuxLend.sol
│   │   ├── IOracle.sol
│   │   └── IIrm.sol
│   └── libraries/
│       ├── MathLib.sol
│       ├── SharesMathLib.sol
│       └── MarketParamsLib.sol
├── bundler/
│   ├── LuxBundler.sol        # Core bundler
│   └── adapters/
│       ├── GeneralAdapter.sol
│       ├── LendingAdapter.sol
│       ├── AMMAdapter.sol
│       ├── PerpsAdapter.sol
│       └── MigrationAdapter.sol
└── resolver/
    ├── LuxResolver.sol       # Intent resolution
    └── SolverRegistry.sol