@luxfi/exchange 0.1.0

package/dist/hooks/use-token-balance.js

@@ -0,0 +1,58 @@
+'use client';
+import { useBalance, useReadContract } from 'wagmi';
+import { ERC20_ABI } from '../contracts/abis';
+import { isNativeToken } from '../tokens';
+/**
+ * Hook to get token balance for an address
+ */
+export function useTokenBalance(token, address, chainId) {
+    // For native token
+    const nativeBalance = useBalance({
+        address,
+        chainId,
+        query: {
+            enabled: !!token && isNativeToken(token) && !!address,
+        },
+    });
+    // For ERC20 token
+    const erc20Balance = useReadContract({
+        address: token?.address,
+        abi: ERC20_ABI,
+        functionName: 'balanceOf',
+        args: address ? [address] : undefined,
+        chainId,
+        query: {
+            enabled: !!token && !isNativeToken(token) && !!address,
+        },
+    });
+    if (!token || !address) {
+        return {
+            balance: 0n,
+            formatted: '0',
+            isLoading: false,
+            error: null,
+        };
+    }
+    if (isNativeToken(token)) {
+        const value = nativeBalance.data?.value ?? 0n;
+        return {
+            balance: value,
+            formatted: formatBalance(value, token.decimals),
+            isLoading: nativeBalance.isLoading,
+            error: nativeBalance.error,
+        };
+    }
+    return {
+        balance: erc20Balance.data ?? 0n,
+        formatted: formatBalance(erc20Balance.data ?? 0n, token.decimals),
+        isLoading: erc20Balance.isLoading,
+        error: erc20Balance.error,
+    };
+}
+function formatBalance(value, decimals) {
+    const divisor = 10n ** BigInt(decimals);
+    const whole = value / divisor;
+    const fraction = value % divisor;
+    const fractionStr = fraction.toString().padStart(decimals, '0').slice(0, 6);
+    return `${whole}.${fractionStr}`.replace(/\.?0+$/, '');
+}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @luxfi/exchange - Core DEX logic for Lux Exchange
+ *
+ * Provides:
+ * - Chain and token definitions
+ * - AMM V2/V3 contract interfaces
+ * - DEX precompile integration
+ * - Swap/liquidity hooks
+ * - Zustand stores for state management
+ */
+export * from './chains';
+export * from './tokens';
+export * from './contracts';
+export * from './dex';
+export * from './hooks';
+export * from './stores';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,cAAc,UAAU,CAAA;AAGxB,cAAc,UAAU,CAAA;AAGxB,cAAc,aAAa,CAAA;AAG3B,cAAc,OAAO,CAAA;AAGrB,cAAc,SAAS,CAAA;AAGvB,cAAc,UAAU,CAAA"}

package/dist/index.js

@@ -0,0 +1,24 @@
+/**
+ * @luxfi/exchange - Core DEX logic for Lux Exchange
+ *
+ * Provides:
+ * - Chain and token definitions
+ * - AMM V2/V3 contract interfaces
+ * - DEX precompile integration
+ * - Swap/liquidity hooks
+ * - Zustand stores for state management
+ */
+// Chains
+export * from './chains';
+// Tokens
+export * from './tokens';
+// Contracts & ABIs
+export * from './contracts';
+// DEX types
+export * from './dex';
+// Hooks
+export * from './hooks';
+// Stores
+export * from './stores';
+// Note: Bridge module is experimental and will be added in a future release
+// See bridge-wip/ for the work-in-progress implementation

package/dist/stores/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Zustand stores for state management
+ */
+export * from './swap-store';
+export * from './token-store';
+export * from './settings-store';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/stores/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,cAAc,CAAA;AAC5B,cAAc,eAAe,CAAA;AAC7B,cAAc,kBAAkB,CAAA"}

package/dist/stores/index.js

@@ -0,0 +1,6 @@
+/**
+ * Zustand stores for state management
+ */
+export * from './swap-store';
+export * from './token-store';
+export * from './settings-store';

package/dist/stores/settings-store.d.ts

@@ -0,0 +1,25 @@
+export type RouterPreference = 'auto' | 'v2' | 'v3' | 'precompile';
+export interface SettingsStore {
+    routerPreference: RouterPreference;
+    expertMode: boolean;
+    autoSlippage: boolean;
+    hideSmallBalances: boolean;
+    smallBalanceThreshold: number;
+    setRouterPreference: (preference: RouterPreference) => void;
+    toggleExpertMode: () => void;
+    toggleAutoSlippage: () => void;
+    toggleHideSmallBalances: () => void;
+    setSmallBalanceThreshold: (threshold: number) => void;
+}
+export declare const useSettingsStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<SettingsStore>, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<SettingsStore, SettingsStore>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: SettingsStore) => void) => () => void;
+        onFinishHydration: (fn: (state: SettingsStore) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<SettingsStore, SettingsStore>>;
+    };
+}>;
+//# sourceMappingURL=settings-store.d.ts.map

package/dist/stores/settings-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings-store.d.ts","sourceRoot":"","sources":["../../src/stores/settings-store.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,IAAI,GAAG,IAAI,GAAG,YAAY,CAAA;AAElE,MAAM,WAAW,aAAa;IAE5B,gBAAgB,EAAE,gBAAgB,CAAA;IAGlC,UAAU,EAAE,OAAO,CAAA;IAGnB,YAAY,EAAE,OAAO,CAAA;IAGrB,iBAAiB,EAAE,OAAO,CAAA;IAG1B,qBAAqB,EAAE,MAAM,CAAA;IAG7B,mBAAmB,EAAE,CAAC,UAAU,EAAE,gBAAgB,KAAK,IAAI,CAAA;IAC3D,gBAAgB,EAAE,MAAM,IAAI,CAAA;IAC5B,kBAAkB,EAAE,MAAM,IAAI,CAAA;IAC9B,uBAAuB,EAAE,MAAM,IAAI,CAAA;IACnC,wBAAwB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAA;CACtD;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;;EAwB5B,CAAA"}

package/dist/stores/settings-store.js

@@ -0,0 +1,16 @@
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+export const useSettingsStore = create()(persist((set) => ({
+    routerPreference: 'auto',
+    expertMode: false,
+    autoSlippage: true,
+    hideSmallBalances: false,
+    smallBalanceThreshold: 1,
+    setRouterPreference: (preference) => set({ routerPreference: preference }),
+    toggleExpertMode: () => set((state) => ({ expertMode: !state.expertMode })),
+    toggleAutoSlippage: () => set((state) => ({ autoSlippage: !state.autoSlippage })),
+    toggleHideSmallBalances: () => set((state) => ({ hideSmallBalances: !state.hideSmallBalances })),
+    setSmallBalanceThreshold: (threshold) => set({ smallBalanceThreshold: threshold }),
+}), {
+    name: 'settings-storage',
+}));

package/dist/stores/swap-store.d.ts

@@ -0,0 +1,38 @@
+import type { Token } from '../tokens';
+export type SwapField = 'input' | 'output';
+export interface SwapState {
+    tokenIn: Token | null;
+    tokenOut: Token | null;
+    amountIn: string;
+    amountOut: string;
+    independentField: SwapField;
+    slippageTolerance: number;
+    deadline: number;
+    setTokenIn: (token: Token | null) => void;
+    setTokenOut: (token: Token | null) => void;
+    setAmountIn: (amount: string) => void;
+    setAmountOut: (amount: string) => void;
+    setIndependentField: (field: SwapField) => void;
+    setSlippageTolerance: (tolerance: number) => void;
+    setDeadline: (deadline: number) => void;
+    switchTokens: () => void;
+    reset: () => void;
+}
+export declare const useSwapStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<SwapState>, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<SwapState, {
+            slippageTolerance: number;
+            deadline: number;
+        }>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: SwapState) => void) => () => void;
+        onFinishHydration: (fn: (state: SwapState) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<SwapState, {
+            slippageTolerance: number;
+            deadline: number;
+        }>>;
+    };
+}>;
+//# sourceMappingURL=swap-store.d.ts.map

package/dist/stores/swap-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swap-store.d.ts","sourceRoot":"","sources":["../../src/stores/swap-store.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,WAAW,CAAA;AAEtC,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,QAAQ,CAAA;AAE1C,MAAM,WAAW,SAAS;IAExB,OAAO,EAAE,KAAK,GAAG,IAAI,CAAA;IACrB,QAAQ,EAAE,KAAK,GAAG,IAAI,CAAA;IAGtB,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;IAGjB,gBAAgB,EAAE,SAAS,CAAA;IAG3B,iBAAiB,EAAE,MAAM,CAAA;IAGzB,QAAQ,EAAE,MAAM,CAAA;IAGhB,UAAU,EAAE,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,KAAK,IAAI,CAAA;IACzC,WAAW,EAAE,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,KAAK,IAAI,CAAA;IAC1C,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IACrC,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IACtC,mBAAmB,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAA;IAC/C,oBAAoB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAA;IACjD,WAAW,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;IACvC,YAAY,EAAE,MAAM,IAAI,CAAA;IACxB,KAAK,EAAE,MAAM,IAAI,CAAA;CAClB;AAYD,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;EAiExB,CAAA"}

package/dist/stores/swap-store.js

@@ -0,0 +1,58 @@
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+const initialState = {
+    tokenIn: null,
+    tokenOut: null,
+    amountIn: '',
+    amountOut: '',
+    independentField: 'input',
+    slippageTolerance: 50, // 0.5%
+    deadline: 30, // 30 minutes
+};
+export const useSwapStore = create()(persist((set) => ({
+    ...initialState,
+    setTokenIn: (token) => set((state) => {
+        // If selecting same token as output, switch them
+        if (token && state.tokenOut && token.address === state.tokenOut.address) {
+            return {
+                tokenIn: token,
+                tokenOut: state.tokenIn,
+            };
+        }
+        return { tokenIn: token };
+    }),
+    setTokenOut: (token) => set((state) => {
+        // If selecting same token as input, switch them
+        if (token && state.tokenIn && token.address === state.tokenIn.address) {
+            return {
+                tokenOut: token,
+                tokenIn: state.tokenOut,
+            };
+        }
+        return { tokenOut: token };
+    }),
+    setAmountIn: (amount) => set({
+        amountIn: amount,
+        independentField: 'input',
+    }),
+    setAmountOut: (amount) => set({
+        amountOut: amount,
+        independentField: 'output',
+    }),
+    setIndependentField: (field) => set({ independentField: field }),
+    setSlippageTolerance: (tolerance) => set({ slippageTolerance: tolerance }),
+    setDeadline: (deadline) => set({ deadline: deadline }),
+    switchTokens: () => set((state) => ({
+        tokenIn: state.tokenOut,
+        tokenOut: state.tokenIn,
+        amountIn: state.amountOut,
+        amountOut: state.amountIn,
+    })),
+    reset: () => set(initialState),
+}), {
+    name: 'swap-storage',
+    partialize: (state) => ({
+        slippageTolerance: state.slippageTolerance,
+        deadline: state.deadline,
+    }),
+}));

package/dist/stores/token-store.d.ts

@@ -0,0 +1,21 @@
+import type { Token } from '../tokens';
+export interface TokenStore {
+    customTokens: Token[];
+    favoriteTokens: string[];
+    addCustomToken: (token: Token) => void;
+    removeCustomToken: (address: string) => void;
+    toggleFavorite: (address: string) => void;
+    isFavorite: (address: string) => boolean;
+}
+export declare const useTokenStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<TokenStore>, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<TokenStore, TokenStore>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: TokenStore) => void) => () => void;
+        onFinishHydration: (fn: (state: TokenStore) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<TokenStore, TokenStore>>;
+    };
+}>;
+//# sourceMappingURL=token-store.d.ts.map

package/dist/stores/token-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-store.d.ts","sourceRoot":"","sources":["../../src/stores/token-store.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,WAAW,CAAA;AAEtC,MAAM,WAAW,UAAU;IAEzB,YAAY,EAAE,KAAK,EAAE,CAAA;IAGrB,cAAc,EAAE,MAAM,EAAE,CAAA;IAGxB,cAAc,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;IACtC,iBAAiB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;IAC5C,cAAc,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;IACzC,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAA;CACzC;AAED,eAAO,MAAM,aAAa;;;;;;;;;;EA2CzB,CAAA"}

package/dist/stores/token-store.js

@@ -0,0 +1,32 @@
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+export const useTokenStore = create()(persist((set, get) => ({
+    customTokens: [],
+    favoriteTokens: [],
+    addCustomToken: (token) => set((state) => {
+        // Check if token already exists
+        if (state.customTokens.some((t) => t.address.toLowerCase() === token.address.toLowerCase())) {
+            return state;
+        }
+        return { customTokens: [...state.customTokens, token] };
+    }),
+    removeCustomToken: (address) => set((state) => ({
+        customTokens: state.customTokens.filter((t) => t.address.toLowerCase() !== address.toLowerCase()),
+    })),
+    toggleFavorite: (address) => set((state) => {
+        const normalized = address.toLowerCase();
+        if (state.favoriteTokens.includes(normalized)) {
+            return {
+                favoriteTokens: state.favoriteTokens.filter((a) => a !== normalized),
+            };
+        }
+        return {
+            favoriteTokens: [...state.favoriteTokens, normalized],
+        };
+    }),
+    isFavorite: (address) => {
+        return get().favoriteTokens.includes(address.toLowerCase());
+    },
+}), {
+    name: 'token-storage',
+}));

package/dist/tokens/index.d.ts

@@ -0,0 +1,65 @@
+import type { Address } from 'viem';
+/**
+ * Token type definition
+ */
+export interface Token {
+    address: Address;
+    chainId: number;
+    decimals: number;
+    symbol: string;
+    name: string;
+    logoURI?: string;
+    isNative?: boolean;
+}
+/**
+ * Native tokens
+ */
+export declare const NATIVE_LUX: Token;
+export declare const NATIVE_ZOO: Token;
+/**
+ * Wrapped native tokens
+ */
+export declare const WLUX_MAINNET: Token;
+export declare const WLUX_TESTNET: Token;
+export declare const WLUX_DEV: Token;
+/**
+ * Stablecoins
+ */
+export declare const LUSD: Token;
+/**
+ * Bridge tokens (L-prefix for assets bridged to Lux)
+ */
+export declare const LETH: Token;
+export declare const LBTC: Token;
+/**
+ * Major tokens on Lux Mainnet
+ */
+export declare const USDC_LUX: Token;
+export declare const USDT_LUX: Token;
+export declare const WETH_LUX: Token;
+export declare const WBTC_LUX: Token;
+export declare const DAI_LUX: Token;
+/**
+ * Zoo chain tokens
+ */
+export declare const WZOO: Token;
+export declare const USDC_ZOO: Token;
+export declare const USDT_ZOO: Token;
+export declare const WETH_ZOO: Token;
+/**
+ * Default token list for Lux Mainnet
+ */
+export declare const LUX_MAINNET_TOKENS: Token[];
+/**
+ * Default token list for Zoo Mainnet
+ */
+export declare const ZOO_MAINNET_TOKENS: Token[];
+/**
+ * Get wrapped native token for chain
+ */
+export declare function getWrappedNative(chainId: number): Token | undefined;
+/**
+ * Check if token is native
+ */
+export declare function isNativeToken(token: Token): boolean;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tokens/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAEnC;;GAEG;AACH,MAAM,WAAW,KAAK;IACpB,OAAO,EAAE,OAAO,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB;AAED;;GAEG;AACH,eAAO,MAAM,UAAU,EAAE,KAOxB,CAAA;AAED,eAAO,MAAM,UAAU,EAAE,KAOxB,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,KAM1B,CAAA;AAED,eAAO,MAAM,YAAY,EAAE,KAM1B,CAAA;AAED,eAAO,MAAM,QAAQ,EAAE,KAMtB,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,IAAI,EAAE,KAMlB,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,IAAI,EAAE,KAMlB,CAAA;AAED,eAAO,MAAM,IAAI,EAAE,KAMlB,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,KAMtB,CAAA;AAED,eAAO,MAAM,QAAQ,EAAE,KAMtB,CAAA;AAED,eAAO,MAAM,QAAQ,EAAE,KAMtB,CAAA;AAED,eAAO,MAAM,QAAQ,EAAE,KAMtB,CAAA;AAED,eAAO,MAAM,OAAO,EAAE,KAMrB,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,IAAI,EAAE,KAMlB,CAAA;AAED,eAAO,MAAM,QAAQ,EAAE,KAMtB,CAAA;AAED,eAAO,MAAM,QAAQ,EAAE,KAMtB,CAAA;AAED,eAAO,MAAM,QAAQ,EAAE,KAMtB,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,KAAK,EAWrC,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,KAAK,EAMrC,CAAA;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,CAWnE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAEnD"}

package/dist/tokens/index.js

@@ -0,0 +1,185 @@
+/**
+ * Native tokens
+ */
+export const NATIVE_LUX = {
+    address: '0x0000000000000000000000000000000000000000',
+    chainId: 96369,
+    decimals: 18,
+    symbol: 'LUX',
+    name: 'LUX',
+    isNative: true,
+};
+export const NATIVE_ZOO = {
+    address: '0x0000000000000000000000000000000000000000',
+    chainId: 200200,
+    decimals: 18,
+    symbol: 'ZOO',
+    name: 'ZOO',
+    isNative: true,
+};
+/**
+ * Wrapped native tokens
+ */
+export const WLUX_MAINNET = {
+    address: '0x55750d6CA62a041c06a8E28626b10Be6c688f471',
+    chainId: 96369,
+    decimals: 18,
+    symbol: 'WLUX',
+    name: 'Wrapped LUX',
+};
+export const WLUX_TESTNET = {
+    address: '0x732740c5c895C9FCF619930ed4293fc858eb44c7',
+    chainId: 96368,
+    decimals: 18,
+    symbol: 'WLUX',
+    name: 'Wrapped LUX',
+};
+export const WLUX_DEV = {
+    address: '0x610178dA211FEF7D417bC0e6FeD39F05609AD788',
+    chainId: 1337,
+    decimals: 18,
+    symbol: 'WLUX',
+    name: 'Wrapped LUX',
+};
+/**
+ * Stablecoins
+ */
+export const LUSD = {
+    address: '0x0000000000000000000000000000000000000000', // TODO: Deploy
+    chainId: 96369,
+    decimals: 18,
+    symbol: 'LUSD',
+    name: 'Lux Dollar',
+};
+/**
+ * Bridge tokens (L-prefix for assets bridged to Lux)
+ */
+export const LETH = {
+    address: '0xAA3AE951A7925F25aE8Ad65b052a76Bd8f052598',
+    chainId: 96369,
+    decimals: 18,
+    symbol: 'LETH',
+    name: 'Lux ETH',
+};
+export const LBTC = {
+    address: '0x526903Ee6118de6737D11b37f82fC7f69B13685D',
+    chainId: 96369,
+    decimals: 8,
+    symbol: 'LBTC',
+    name: 'Lux BTC',
+};
+/**
+ * Major tokens on Lux Mainnet
+ */
+export const USDC_LUX = {
+    address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+    chainId: 96369,
+    decimals: 6,
+    symbol: 'USDC',
+    name: 'USD Coin',
+};
+export const USDT_LUX = {
+    address: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
+    chainId: 96369,
+    decimals: 6,
+    symbol: 'USDT',
+    name: 'Tether USD',
+};
+export const WETH_LUX = {
+    address: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+    chainId: 96369,
+    decimals: 18,
+    symbol: 'WETH',
+    name: 'Wrapped Ether',
+};
+export const WBTC_LUX = {
+    address: '0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599',
+    chainId: 96369,
+    decimals: 8,
+    symbol: 'WBTC',
+    name: 'Wrapped Bitcoin',
+};
+export const DAI_LUX = {
+    address: '0x6B175474E89094C44Da98b954EesdscdKD34eL55',
+    chainId: 96369,
+    decimals: 18,
+    symbol: 'DAI',
+    name: 'Dai Stablecoin',
+};
+/**
+ * Zoo chain tokens
+ */
+export const WZOO = {
+    address: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
+    chainId: 200200,
+    decimals: 18,
+    symbol: 'WZOO',
+    name: 'Wrapped ZOO',
+};
+export const USDC_ZOO = {
+    address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+    chainId: 200200,
+    decimals: 6,
+    symbol: 'USDC',
+    name: 'USD Coin',
+};
+export const USDT_ZOO = {
+    address: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
+    chainId: 200200,
+    decimals: 6,
+    symbol: 'USDT',
+    name: 'Tether USD',
+};
+export const WETH_ZOO = {
+    address: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+    chainId: 200200,
+    decimals: 18,
+    symbol: 'WETH',
+    name: 'Wrapped Ether',
+};
+/**
+ * Default token list for Lux Mainnet
+ */
+export const LUX_MAINNET_TOKENS = [
+    NATIVE_LUX,
+    WLUX_MAINNET,
+    USDC_LUX,
+    USDT_LUX,
+    WETH_LUX,
+    WBTC_LUX,
+    DAI_LUX,
+    LETH,
+    LBTC,
+    LUSD,
+];
+/**
+ * Default token list for Zoo Mainnet
+ */
+export const ZOO_MAINNET_TOKENS = [
+    NATIVE_ZOO,
+    WZOO,
+    USDC_ZOO,
+    USDT_ZOO,
+    WETH_ZOO,
+];
+/**
+ * Get wrapped native token for chain
+ */
+export function getWrappedNative(chainId) {
+    switch (chainId) {
+        case 96369:
+            return WLUX_MAINNET;
+        case 96368:
+            return WLUX_TESTNET;
+        case 1337:
+            return WLUX_DEV;
+        default:
+            return undefined;
+    }
+}
+/**
+ * Check if token is native
+ */
+export function isNativeToken(token) {
+    return token.isNative === true || token.address === '0x0000000000000000000000000000000000000000';
+}

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@luxfi/exchange",
+  "version": "0.1.0",
+  "description": "Lux Exchange SDK - React hooks and utilities for Lux DEX",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    },
+    "./chains": {
+      "types": "./dist/chains/index.d.ts",
+      "import": "./dist/chains/index.js"
+    },
+    "./tokens": {
+      "types": "./dist/tokens/index.d.ts",
+      "import": "./dist/tokens/index.js"
+    },
+    "./contracts": {
+      "types": "./dist/contracts/index.d.ts",
+      "import": "./dist/contracts/index.js"
+    },
+    "./hooks": {
+      "types": "./dist/hooks/index.d.ts",
+      "import": "./dist/hooks/index.js"
+    },
+    "./stores": {
+      "types": "./dist/stores/index.d.ts",
+      "import": "./dist/stores/index.js"
+    },
+    "./dex": {
+      "types": "./dist/dex/index.d.ts",
+      "import": "./dist/dex/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "build": "tsc",
+    "test": "vitest run",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "viem": "^2.43.3",
+    "wagmi": "^3.1.3",
+    "@tanstack/react-query": "^5.90.12",
+    "zustand": "^5.0.5"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.3",
+    "@types/react": "^19.2.3",
+    "typescript": "^5.8.3",
+    "vitest": "^4.0.16"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/luxfi/exchange.git",
+    "directory": "packages/exchange"
+  },
+  "keywords": [
+    "lux",
+    "dex",
+    "exchange",
+    "defi",
+    "blockchain",
+    "react",
+    "hooks"
+  ]
+}