@luxfi/exchange 0.1.0

package/src/contracts/abis/uniswap-v3-pool.ts

@@ -0,0 +1,81 @@
+/**
+ * UniswapV3Pool ABI (essential functions)
+ */
+export const UNISWAP_V3_POOL_ABI = [
+  {
+    type: 'function',
+    name: 'token0',
+    inputs: [],
+    outputs: [{ type: 'address' }],
+    stateMutability: 'view',
+  },
+  {
+    type: 'function',
+    name: 'token1',
+    inputs: [],
+    outputs: [{ type: 'address' }],
+    stateMutability: 'view',
+  },
+  {
+    type: 'function',
+    name: 'fee',
+    inputs: [],
+    outputs: [{ type: 'uint24' }],
+    stateMutability: 'view',
+  },
+  {
+    type: 'function',
+    name: 'tickSpacing',
+    inputs: [],
+    outputs: [{ type: 'int24' }],
+    stateMutability: 'view',
+  },
+  {
+    type: 'function',
+    name: 'liquidity',
+    inputs: [],
+    outputs: [{ type: 'uint128' }],
+    stateMutability: 'view',
+  },
+  {
+    type: 'function',
+    name: 'slot0',
+    inputs: [],
+    outputs: [
+      { name: 'sqrtPriceX96', type: 'uint160' },
+      { name: 'tick', type: 'int24' },
+      { name: 'observationIndex', type: 'uint16' },
+      { name: 'observationCardinality', type: 'uint16' },
+      { name: 'observationCardinalityNext', type: 'uint16' },
+      { name: 'feeProtocol', type: 'uint8' },
+      { name: 'unlocked', type: 'bool' },
+    ],
+    stateMutability: 'view',
+  },
+  {
+    type: 'function',
+    name: 'positions',
+    inputs: [{ name: 'key', type: 'bytes32' }],
+    outputs: [
+      { name: 'liquidity', type: 'uint128' },
+      { name: 'feeGrowthInside0LastX128', type: 'uint256' },
+      { name: 'feeGrowthInside1LastX128', type: 'uint256' },
+      { name: 'tokensOwed0', type: 'uint128' },
+      { name: 'tokensOwed1', type: 'uint128' },
+    ],
+    stateMutability: 'view',
+  },
+  {
+    type: 'event',
+    name: 'Swap',
+    inputs: [
+      { name: 'sender', type: 'address', indexed: true },
+      { name: 'recipient', type: 'address', indexed: true },
+      { name: 'amount0', type: 'int256', indexed: false },
+      { name: 'amount1', type: 'int256', indexed: false },
+      { name: 'sqrtPriceX96', type: 'uint160', indexed: false },
+      { name: 'liquidity', type: 'uint128', indexed: false },
+      { name: 'tick', type: 'int24', indexed: false },
+    ],
+  },
+] as const

package/src/contracts/addresses.ts

@@ -0,0 +1,128 @@
+/**
+ * Contract Addresses for Lux Exchange
+ */
+import type { Address } from 'viem'
+
+/**
+ * Contract addresses for Lux Mainnet (96369)
+ */
+export const LUX_MAINNET_CONTRACTS = {
+  // Core
+  WLUX: '0x55750d6CA62a041c06a8E28626b10Be6c688f471' as Address,
+  MULTICALL: '0xd25F88CBdAe3c2CCA3Bb75FC4E723b44C0Ea362F' as Address,
+
+  // Bridge tokens
+  LETH: '0xAA3AE95816a4A6FbC6b8Ed5a6C06f22A96A80C8C' as Address,
+  LBTC: '0x526903E35E7106D62ED3B5d77E14e51d024Aa1D3' as Address,
+  LUSD: '0x4B1BfA76eD63F1A0aD2E4f40b3F46C45E8F7A4E2' as Address,
+
+  // AMM V2 (QuantumSwap)
+  V2_FACTORY: '0xd9a95609DbB228A13568Bd9f9A285105E7596970' as Address,
+  V2_ROUTER: '0x1F6cbC7d3bc7D803ee76D80F0eEE25767431e674' as Address,
+
+  // AMM V3 (Concentrated Liquidity)
+  V3_FACTORY: '0xb732BD88F25EdD9C3456638671fB37685D4B4e3f' as Address,
+  V3_SWAP_ROUTER: '0xE8fb25086C8652c92f5AF90D730Bac7C63Fc9A58' as Address,
+  V3_SWAP_ROUTER_02: '0x939bC0Bca6F9B9c52E6e3AD8A3C590b5d9B9D10E' as Address,
+  V3_QUOTER: '0x12e2B76FaF4dDA5a173a4532916bb6Bfa3645275' as Address,
+  V3_QUOTER_V2: '0x15C729fdd833Ba675edd466Dfc63E1B737925A4c' as Address,
+  V3_TICK_LENS: '0x57A22965AdA0e52D785A9Aa155beF423D573b879' as Address,
+  V3_NFT_POSITION_MANAGER: '0x7a4C48B9dae0b7c396569b34042fcA604150Ee28' as Address,
+  V3_NFT_DESCRIPTOR: '0x53B1aAA5b6DDFD4eD00D0A7b5Ef333dc74B605b5' as Address,
+} as const
+
+/**
+ * Contract addresses for Lux Testnet (96368)
+ */
+export const LUX_TESTNET_CONTRACTS = {
+  // Core
+  WLUX: '0x732740c5c895C9FCF619930ed4293fc858eb44c7' as Address,
+  WETH: '0xd9956542B51032d940ef076d70B69410667277A3' as Address,
+  MULTICALL: '0xd25F88CBdAe3c2CCA3Bb75FC4E723b44C0Ea362F' as Address,
+
+  // AMM V2
+  V2_FACTORY: '0x81C3669B139D92909AA67DbF74a241b10540d919' as Address,
+  V2_ROUTER: '0xDB6c703c80BFaE5F9a56482d3c8535f27E1136EB' as Address,
+
+  // AMM V3
+  V3_FACTORY: '0x80bBc7C4C7a59C899D1B37BC14539A22D5830a84' as Address,
+  V3_SWAP_ROUTER: '0xE8fb25086C8652c92f5AF90D730Bac7C63Fc9A58' as Address,
+  V3_SWAP_ROUTER_02: '0x939bC0Bca6F9B9c52E6e3AD8A3C590b5d9B9D10E' as Address,
+  V3_QUOTER: '0x12e2B76FaF4dDA5a173a4532916bb6Bfa3645275' as Address,
+  V3_QUOTER_V2: '0x15C729fdd833Ba675edd466Dfc63E1B737925A4c' as Address,
+  V3_TICK_LENS: '0x57A22965AdA0e52D785A9Aa155beF423D573b879' as Address,
+  V3_NFT_POSITION_MANAGER: '0x7a4C48B9dae0b7c396569b34042fcA604150Ee28' as Address,
+  V3_NFT_DESCRIPTOR: '0x53B1aAA5b6DDFD4eD00D0A7b5Ef333dc74B605b5' as Address,
+} as const
+
+/**
+ * DEX Precompile addresses (native AMM)
+ * These provide sub-microsecond execution
+ * 
+ * Lux Precompile Address Standard:
+ * - Prefix format: 0xNNNN000000000000000000000000000000000000
+ * - Range 0x0400-0x04FF is reserved for DEX precompiles
+ * 
+ * @see ~/work/lux/precompile/dex/module.go for implementation
+ */
+export const DEX_PRECOMPILES = {
+  POOL_MANAGER: '0x0400000000000000000000000000000000000000' as Address,
+  SWAP_ROUTER: '0x0401000000000000000000000000000000000000' as Address,
+  HOOKS_REGISTRY: '0x0402000000000000000000000000000000000000' as Address,
+  FLASH_LOAN: '0x0403000000000000000000000000000000000000' as Address,
+  LENDING: '0x0410000000000000000000000000000000000000' as Address,
+  LIQUID: '0x0430000000000000000000000000000000000000' as Address,
+  TELEPORT: '0x0440000000000000000000000000000000000000' as Address,
+} as const
+
+/**
+ * Contract addresses for Lux Dev (1337)
+ */
+export const LUX_DEV_CONTRACTS = {
+  // Core
+  WLUX: '0x610178dA211FEF7D417bC0e6FeD39F05609AD788' as Address,
+  MULTICALL: '0xd25F88CBdAe3c2CCA3Bb75FC4E723b44C0Ea362F' as Address,
+
+  // Bridged tokens (local dev)
+  ETH: '0x5FbDB2315678afecb367f032d93F642f64180aa3' as Address,
+  BTC: '0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512' as Address,
+  USDC: '0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0' as Address,
+  USDT: '0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9' as Address,
+  DAI: '0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9' as Address,
+  AI: '0x0B306BF915C4d645ff596e518fAf3F9669b97016' as Address,
+
+  // AMM V2
+  V2_FACTORY: '0x959922bE3CAee4b8Cd9a407cc3ac1C251C2007B1' as Address,
+  V2_ROUTER: '0x9A9f2CCfdE556A7E9Ff0848998Aa4a0CFD8863AE' as Address,
+
+  // AMM V3 (uses testnet addresses for dev)
+  V3_FACTORY: '0x80bBc7C4C7a59C899D1B37BC14539A22D5830a84' as Address,
+  V3_SWAP_ROUTER: '0xE8fb25086C8652c92f5AF90D730Bac7C63Fc9A58' as Address,
+  V3_SWAP_ROUTER_02: '0x939bC0Bca6F9B9c52E6e3AD8A3C590b5d9B9D10E' as Address,
+  V3_QUOTER: '0x12e2B76FaF4dDA5a173a4532916bb6Bfa3645275' as Address,
+  V3_QUOTER_V2: '0x15C729fdd833Ba675edd466Dfc63E1B737925A4c' as Address,
+  V3_TICK_LENS: '0x57A22965AdA0e52D785A9Aa155beF423D573b879' as Address,
+  V3_NFT_POSITION_MANAGER: '0x7a4C48B9dae0b7c396569b34042fcA604150Ee28' as Address,
+  V3_NFT_DESCRIPTOR: '0x53B1aAA5b6DDFD4eD00D0A7b5Ef333dc74B605b5' as Address,
+
+  // Staking
+  STAKED_LUX: '0xA51c1fc2f0D1a1b8494Ed1FE312d7C3a78Ed91C0' as Address,
+} as const
+
+/**
+ * Get contracts for a specific chain
+ */
+export function getContracts(chainId: number) {
+  switch (chainId) {
+    case 96369:
+      return LUX_MAINNET_CONTRACTS
+    case 96368:
+      return LUX_TESTNET_CONTRACTS
+    case 1337:
+      return LUX_DEV_CONTRACTS
+    default:
+      return LUX_TESTNET_CONTRACTS
+  }
+}
+
+export type ContractAddresses = typeof LUX_MAINNET_CONTRACTS

package/src/contracts/index.ts

@@ -0,0 +1,14 @@
+/**
+ * Contract exports
+ */
+
+export {
+  LUX_MAINNET_CONTRACTS,
+  LUX_TESTNET_CONTRACTS,
+  LUX_DEV_CONTRACTS,
+  DEX_PRECOMPILES,
+  getContracts,
+  type ContractAddresses,
+} from './addresses'
+
+export * from './abis'

package/src/dex/balance-delta.ts

@@ -0,0 +1,52 @@
+import type { BalanceDelta } from './types'
+
+/**
+ * Create balance delta from packed int256 (Solidity representation)
+ * Upper 128 bits = amount0, Lower 128 bits = amount1
+ */
+export function unpackBalanceDelta(packed: bigint): BalanceDelta {
+  const amount0 = packed >> 128n
+  const amount1 = BigInt.asIntN(128, packed)
+  return { amount0, amount1 }
+}
+
+/**
+ * Pack balance delta into int256
+ */
+export function packBalanceDelta(delta: BalanceDelta): bigint {
+  return (delta.amount0 << 128n) | (delta.amount1 & ((1n << 128n) - 1n))
+}
+
+/**
+ * Add two balance deltas
+ */
+export function addBalanceDeltas(a: BalanceDelta, b: BalanceDelta): BalanceDelta {
+  return {
+    amount0: a.amount0 + b.amount0,
+    amount1: a.amount1 + b.amount1,
+  }
+}
+
+/**
+ * Negate balance delta
+ */
+export function negateBalanceDelta(delta: BalanceDelta): BalanceDelta {
+  return {
+    amount0: -delta.amount0,
+    amount1: -delta.amount1,
+  }
+}
+
+/**
+ * Check if balance delta is zero
+ */
+export function isZeroDelta(delta: BalanceDelta): boolean {
+  return delta.amount0 === 0n && delta.amount1 === 0n
+}
+
+/**
+ * Get the amount for a specific currency (0 or 1)
+ */
+export function getDeltaAmount(delta: BalanceDelta, currency: 0 | 1): bigint {
+  return currency === 0 ? delta.amount0 : delta.amount1
+}

package/src/dex/index.ts

@@ -0,0 +1,7 @@
+/**
+ * DEX Types and Utilities
+ */
+
+export * from './types'
+export * from './pool-key'
+export * from './balance-delta'

package/src/dex/pool-key.ts

@@ -0,0 +1,62 @@
+import { keccak256, encodeAbiParameters, type Address } from 'viem'
+import type { PoolKey, Currency } from './types'
+
+/**
+ * Sort currencies to ensure currency0 < currency1
+ */
+export function sortCurrencies(currencyA: Currency, currencyB: Currency): [Currency, Currency] {
+  const a = BigInt(currencyA)
+  const b = BigInt(currencyB)
+  return a < b ? [currencyA, currencyB] : [currencyB, currencyA]
+}
+
+/**
+ * Create a pool key from parameters
+ */
+export function createPoolKey(
+  currencyA: Currency,
+  currencyB: Currency,
+  fee: number,
+  tickSpacing: number,
+  hooks: Address = '0x0000000000000000000000000000000000000000'
+): PoolKey {
+  const [currency0, currency1] = sortCurrencies(currencyA, currencyB)
+  return {
+    currency0,
+    currency1,
+    fee,
+    tickSpacing,
+    hooks,
+  }
+}
+
+/**
+ * Compute pool ID from pool key
+ */
+export function computePoolId(key: PoolKey): `0x${string}` {
+  return keccak256(
+    encodeAbiParameters(
+      [
+        { type: 'address', name: 'currency0' },
+        { type: 'address', name: 'currency1' },
+        { type: 'uint24', name: 'fee' },
+        { type: 'int24', name: 'tickSpacing' },
+        { type: 'address', name: 'hooks' },
+      ],
+      [key.currency0, key.currency1, key.fee, key.tickSpacing, key.hooks]
+    )
+  )
+}
+
+/**
+ * Check if two pool keys are equal
+ */
+export function poolKeysEqual(a: PoolKey, b: PoolKey): boolean {
+  return (
+    a.currency0.toLowerCase() === b.currency0.toLowerCase() &&
+    a.currency1.toLowerCase() === b.currency1.toLowerCase() &&
+    a.fee === b.fee &&
+    a.tickSpacing === b.tickSpacing &&
+    a.hooks.toLowerCase() === b.hooks.toLowerCase()
+  )
+}

package/src/dex/types.ts

@@ -0,0 +1,87 @@
+import type { Address } from 'viem'
+
+/**
+ * Currency type - address(0) represents native token
+ */
+export type Currency = Address
+
+/**
+ * Pool key uniquely identifies a pool
+ */
+export interface PoolKey {
+  currency0: Currency
+  currency1: Currency
+  fee: number       // uint24 - fee in hundredths of a bip (e.g., 3000 = 0.30%)
+  tickSpacing: number // int24
+  hooks: Address    // Hook contract address (address(0) = no hooks)
+}
+
+/**
+ * Balance delta represents changes in token balances
+ * Positive = user owes pool, Negative = pool owes user
+ */
+export interface BalanceDelta {
+  amount0: bigint
+  amount1: bigint
+}
+
+/**
+ * Swap parameters
+ */
+export interface SwapParams {
+  zeroForOne: boolean       // Direction: true = token0 -> token1
+  amountSpecified: bigint   // Positive = exact input, Negative = exact output
+  sqrtPriceLimitX96: bigint // Price limit (0 for no limit)
+}
+
+/**
+ * Modify liquidity parameters
+ */
+export interface ModifyLiquidityParams {
+  tickLower: number
+  tickUpper: number
+  liquidityDelta: bigint
+  salt: `0x${string}`
+}
+
+/**
+ * Pool slot0 state
+ */
+export interface Slot0 {
+  sqrtPriceX96: bigint
+  tick: number
+  protocolFee: number
+  lpFee: number
+}
+
+/**
+ * Fee tiers (in hundredths of a bip)
+ */
+export const FEE_TIERS = {
+  LOWEST: 100,    // 0.01%
+  LOW: 500,       // 0.05%
+  MEDIUM: 3000,   // 0.30%
+  HIGH: 10000,    // 1.00%
+} as const
+
+/**
+ * Tick spacing for fee tiers
+ */
+export const TICK_SPACINGS: Record<number, number> = {
+  100: 1,
+  500: 10,
+  3000: 60,
+  10000: 200,
+}
+
+/**
+ * Native currency constant
+ */
+export const NATIVE_CURRENCY: Currency = '0x0000000000000000000000000000000000000000'
+
+/**
+ * Check if currency is native
+ */
+export function isNativeCurrency(currency: Currency): boolean {
+  return currency === NATIVE_CURRENCY
+}

package/src/hooks/index.ts

@@ -0,0 +1,10 @@
+/**
+ * React hooks for DEX interactions
+ */
+
+export * from './use-swap-quote'
+export * from './use-swap'
+export * from './use-pools'
+export * from './use-positions'
+export * from './use-token-balance'
+export * from './use-token-allowance'

package/src/hooks/use-pools.ts

@@ -0,0 +1,116 @@
+'use client'
+
+import { useQuery } from '@tanstack/react-query'
+import { usePublicClient } from 'wagmi'
+import { getContracts } from '../contracts'
+import { UNISWAP_V3_FACTORY_ABI, UNISWAP_V3_POOL_ABI } from '../contracts/abis'
+import type { Address } from 'viem'
+
+export interface Pool {
+  address: Address
+  token0: Address
+  token1: Address
+  fee: number
+  tickSpacing: number
+  liquidity: bigint
+  sqrtPriceX96: bigint
+  tick: number
+}
+
+/**
+ * Hook to get pool information
+ */
+export function usePool(
+  token0: Address | undefined,
+  token1: Address | undefined,
+  fee: number,
+  chainId: number
+) {
+  const publicClient = usePublicClient({ chainId })
+  const contracts = getContracts(chainId)
+
+  return useQuery({
+    queryKey: ['pool', token0, token1, fee, chainId],
+    queryFn: async (): Promise<Pool | null> => {
+      if (!token0 || !token1 || !publicClient) return null
+
+      try {
+        // Get pool address from factory
+        const poolAddress = await publicClient.readContract({
+          address: contracts.V3_FACTORY,
+          abi: UNISWAP_V3_FACTORY_ABI,
+          functionName: 'getPool',
+          args: [token0, token1, fee],
+        })
+
+        if (poolAddress === '0x0000000000000000000000000000000000000000') {
+          return null
+        }
+
+        // Get pool state
+        const [slot0, liquidity, tickSpacing] = await Promise.all([
+          publicClient.readContract({
+            address: poolAddress,
+            abi: UNISWAP_V3_POOL_ABI,
+            functionName: 'slot0',
+          }),
+          publicClient.readContract({
+            address: poolAddress,
+            abi: UNISWAP_V3_POOL_ABI,
+            functionName: 'liquidity',
+          }),
+          publicClient.readContract({
+            address: poolAddress,
+            abi: UNISWAP_V3_POOL_ABI,
+            functionName: 'tickSpacing',
+          }),
+        ])
+
+        return {
+          address: poolAddress,
+          token0,
+          token1,
+          fee,
+          tickSpacing,
+          liquidity,
+          sqrtPriceX96: slot0[0],
+          tick: slot0[1],
+        }
+      } catch (error) {
+        console.error('Failed to fetch pool:', error)
+        return null
+      }
+    },
+    enabled: !!token0 && !!token1 && !!publicClient,
+    staleTime: 30_000,
+  })
+}
+
+/**
+ * Hook to get all pools for a token pair
+ */
+export function usePools(
+  token0: Address | undefined,
+  token1: Address | undefined,
+  chainId: number
+) {
+  const pool100 = usePool(token0, token1, 100, chainId)
+  const pool500 = usePool(token0, token1, 500, chainId)
+  const pool3000 = usePool(token0, token1, 3000, chainId)
+  const pool10000 = usePool(token0, token1, 10000, chainId)
+
+  const pools = [
+    pool100.data,
+    pool500.data,
+    pool3000.data,
+    pool10000.data,
+  ].filter((p): p is Pool => p !== null)
+
+  return {
+    pools,
+    isLoading: pool100.isLoading || pool500.isLoading || pool3000.isLoading || pool10000.isLoading,
+    bestPool: pools.length > 0 ? pools.reduce((best, pool) =>
+      pool.liquidity > best.liquidity ? pool : best
+    ) : null,
+  }
+}

package/src/hooks/use-positions.ts

@@ -0,0 +1,90 @@
+'use client'
+
+import { useQuery } from '@tanstack/react-query'
+import { usePublicClient } from 'wagmi'
+import { getContracts } from '../contracts'
+import { NFT_POSITION_MANAGER_ABI } from '../contracts/abis'
+import type { Address } from 'viem'
+
+export interface Position {
+  tokenId: bigint
+  token0: Address
+  token1: Address
+  fee: number
+  tickLower: number
+  tickUpper: number
+  liquidity: bigint
+  tokensOwed0: bigint
+  tokensOwed1: bigint
+}
+
+/**
+ * Hook to get user's liquidity positions
+ */
+export function usePositions(owner: Address | undefined, chainId: number) {
+  const publicClient = usePublicClient({ chainId })
+  const contracts = getContracts(chainId)
+
+  return useQuery({
+    queryKey: ['positions', owner, chainId],
+    queryFn: async (): Promise<Position[]> => {
+      if (!owner || !publicClient) return []
+
+      try {
+        // Get number of positions
+        const balance = await publicClient.readContract({
+          address: contracts.V3_NFT_POSITION_MANAGER,
+          abi: NFT_POSITION_MANAGER_ABI,
+          functionName: 'balanceOf',
+          args: [owner],
+        })
+
+        if (balance === 0n) return []
+
+        // Get all token IDs
+        const tokenIds = await Promise.all(
+          Array.from({ length: Number(balance) }, (_, i) =>
+            publicClient.readContract({
+              address: contracts.V3_NFT_POSITION_MANAGER,
+              abi: NFT_POSITION_MANAGER_ABI,
+              functionName: 'tokenOfOwnerByIndex',
+              args: [owner, BigInt(i)],
+            })
+          )
+        )
+
+        // Get position details for each token ID
+        const positions = await Promise.all(
+          tokenIds.map(async (tokenId) => {
+            const position = await publicClient.readContract({
+              address: contracts.V3_NFT_POSITION_MANAGER,
+              abi: NFT_POSITION_MANAGER_ABI,
+              functionName: 'positions',
+              args: [tokenId],
+            })
+
+            return {
+              tokenId,
+              token0: position[2],
+              token1: position[3],
+              fee: position[4],
+              tickLower: position[5],
+              tickUpper: position[6],
+              liquidity: position[7],
+              tokensOwed0: position[10],
+              tokensOwed1: position[11],
+            }
+          })
+        )
+
+        // Filter out closed positions (zero liquidity)
+        return positions.filter((p) => p.liquidity > 0n)
+      } catch (error) {
+        console.error('Failed to fetch positions:', error)
+        return []
+      }
+    },
+    enabled: !!owner && !!publicClient,
+    staleTime: 60_000,
+  })
+}