@luxfi/exchange 0.1.0

package/dist/dex/pool-key.js

@@ -0,0 +1,44 @@
+import { keccak256, encodeAbiParameters } from 'viem';
+/**
+ * Sort currencies to ensure currency0 < currency1
+ */
+export function sortCurrencies(currencyA, currencyB) {
+    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, currencyB, fee, tickSpacing, hooks = '0x0000000000000000000000000000000000000000') {
+    const [currency0, currency1] = sortCurrencies(currencyA, currencyB);
+    return {
+        currency0,
+        currency1,
+        fee,
+        tickSpacing,
+        hooks,
+    };
+}
+/**
+ * Compute pool ID from pool key
+ */
+export function computePoolId(key) {
+    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, b) {
+    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/dist/dex/types.d.ts

@@ -0,0 +1,71 @@
+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;
+    tickSpacing: number;
+    hooks: Address;
+}
+/**
+ * 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;
+    amountSpecified: bigint;
+    sqrtPriceLimitX96: bigint;
+}
+/**
+ * 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 declare const FEE_TIERS: {
+    readonly LOWEST: 100;
+    readonly LOW: 500;
+    readonly MEDIUM: 3000;
+    readonly HIGH: 10000;
+};
+/**
+ * Tick spacing for fee tiers
+ */
+export declare const TICK_SPACINGS: Record<number, number>;
+/**
+ * Native currency constant
+ */
+export declare const NATIVE_CURRENCY: Currency;
+/**
+ * Check if currency is native
+ */
+export declare function isNativeCurrency(currency: Currency): boolean;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/dex/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAEnC;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,CAAA;AAE9B;;GAEG;AACH,MAAM,WAAW,OAAO;IACtB,SAAS,EAAE,QAAQ,CAAA;IACnB,SAAS,EAAE,QAAQ,CAAA;IACnB,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,KAAK;IACpB,YAAY,EAAE,MAAM,CAAA;IACpB,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,KAAK,EAAE,MAAM,CAAA;CACd;AAED;;GAEG;AACH,eAAO,MAAM,SAAS;;;;;CAKZ,CAAA;AAEV;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAKhD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,QAAuD,CAAA;AAErF;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAE5D"}

package/dist/dex/types.js

@@ -0,0 +1,28 @@
+/**
+ * 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%
+};
+/**
+ * Tick spacing for fee tiers
+ */
+export const TICK_SPACINGS = {
+    100: 1,
+    500: 10,
+    3000: 60,
+    10000: 200,
+};
+/**
+ * Native currency constant
+ */
+export const NATIVE_CURRENCY = '0x0000000000000000000000000000000000000000';
+/**
+ * Check if currency is native
+ */
+export function isNativeCurrency(currency) {
+    return currency === NATIVE_CURRENCY;
+}

package/dist/hooks/index.d.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';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,kBAAkB,CAAA;AAChC,cAAc,YAAY,CAAA;AAC1B,cAAc,aAAa,CAAA;AAC3B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,qBAAqB,CAAA;AACnC,cAAc,uBAAuB,CAAA"}

package/dist/hooks/index.js

@@ -0,0 +1,9 @@
+/**
+ * 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/dist/hooks/use-pools.d.ts

@@ -0,0 +1,24 @@
+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 declare function usePool(token0: Address | undefined, token1: Address | undefined, fee: number, chainId: number): import("@tanstack/react-query").UseQueryResult<Pool | null, Error>;
+/**
+ * Hook to get all pools for a token pair
+ */
+export declare function usePools(token0: Address | undefined, token1: Address | undefined, chainId: number): {
+    pools: Pool[];
+    isLoading: boolean;
+    bestPool: Pool | null;
+};
+//# sourceMappingURL=use-pools.d.ts.map

package/dist/hooks/use-pools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-pools.d.ts","sourceRoot":"","sources":["../../src/hooks/use-pools.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAEnC,MAAM,WAAW,IAAI;IACnB,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE,OAAO,CAAA;IACf,MAAM,EAAE,OAAO,CAAA;IACf,GAAG,EAAE,MAAM,CAAA;IACX,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;IACjB,YAAY,EAAE,MAAM,CAAA;IACpB,IAAI,EAAE,MAAM,CAAA;CACb;AAED;;GAEG;AACH,wBAAgB,OAAO,CACrB,MAAM,EAAE,OAAO,GAAG,SAAS,EAC3B,MAAM,EAAE,OAAO,GAAG,SAAS,EAC3B,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,sEA4DhB;AAED;;GAEG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,OAAO,GAAG,SAAS,EAC3B,MAAM,EAAE,OAAO,GAAG,SAAS,EAC3B,OAAO,EAAE,MAAM;;;;EAqBhB"}

package/dist/hooks/use-pools.js

@@ -0,0 +1,85 @@
+'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';
+/**
+ * Hook to get pool information
+ */
+export function usePool(token0, token1, fee, chainId) {
+    const publicClient = usePublicClient({ chainId });
+    const contracts = getContracts(chainId);
+    return useQuery({
+        queryKey: ['pool', token0, token1, fee, chainId],
+        queryFn: async () => {
+            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, token1, chainId) {
+    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 !== 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/dist/hooks/use-positions.d.ts

@@ -0,0 +1,17 @@
+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 declare function usePositions(owner: Address | undefined, chainId: number): import("@tanstack/react-query").UseQueryResult<Position[], Error>;
+//# sourceMappingURL=use-positions.d.ts.map

package/dist/hooks/use-positions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-positions.d.ts","sourceRoot":"","sources":["../../src/hooks/use-positions.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAEnC,MAAM,WAAW,QAAQ;IACvB,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,OAAO,CAAA;IACf,MAAM,EAAE,OAAO,CAAA;IACf,GAAG,EAAE,MAAM,CAAA;IACX,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,CAAA;IACnB,WAAW,EAAE,MAAM,CAAA;CACpB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,EAAE,OAAO,EAAE,MAAM,qEAkEvE"}

package/dist/hooks/use-positions.js

@@ -0,0 +1,65 @@
+'use client';
+import { useQuery } from '@tanstack/react-query';
+import { usePublicClient } from 'wagmi';
+import { getContracts } from '../contracts';
+import { NFT_POSITION_MANAGER_ABI } from '../contracts/abis';
+/**
+ * Hook to get user's liquidity positions
+ */
+export function usePositions(owner, chainId) {
+    const publicClient = usePublicClient({ chainId });
+    const contracts = getContracts(chainId);
+    return useQuery({
+        queryKey: ['positions', owner, chainId],
+        queryFn: async () => {
+            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,
+    });
+}

package/dist/hooks/use-swap-quote.d.ts

@@ -0,0 +1,19 @@
+import type { Token } from '../tokens';
+export interface SwapQuote {
+    amountIn: bigint;
+    amountOut: bigint;
+    priceImpact: number;
+    route: Token[];
+    gasEstimate: bigint;
+}
+export interface UseSwapQuoteParams {
+    tokenIn: Token | null;
+    tokenOut: Token | null;
+    amountIn: bigint;
+    chainId: number;
+}
+/**
+ * Hook to get swap quote from V3 Quoter
+ */
+export declare function useSwapQuote({ tokenIn, tokenOut, amountIn, chainId, }: UseSwapQuoteParams): import("@tanstack/react-query").UseQueryResult<SwapQuote | null, Error>;
+//# sourceMappingURL=use-swap-quote.d.ts.map

package/dist/hooks/use-swap-quote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-swap-quote.d.ts","sourceRoot":"","sources":["../../src/hooks/use-swap-quote.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,WAAW,CAAA;AAEtC,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,CAAA;IACnB,KAAK,EAAE,KAAK,EAAE,CAAA;IACd,WAAW,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,KAAK,GAAG,IAAI,CAAA;IACrB,QAAQ,EAAE,KAAK,GAAG,IAAI,CAAA;IACtB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,EAC3B,OAAO,EACP,QAAQ,EACR,QAAQ,EACR,OAAO,GACR,EAAE,kBAAkB,2EAiDpB"}

package/dist/hooks/use-swap-quote.js

@@ -0,0 +1,54 @@
+'use client';
+import { useQuery } from '@tanstack/react-query';
+import { usePublicClient } from 'wagmi';
+import { getContracts } from '../contracts';
+import { QUOTER_V2_ABI } from '../contracts/abis';
+/**
+ * Hook to get swap quote from V3 Quoter
+ */
+export function useSwapQuote({ tokenIn, tokenOut, amountIn, chainId, }) {
+    const publicClient = usePublicClient({ chainId });
+    const contracts = getContracts(chainId);
+    return useQuery({
+        queryKey: ['swapQuote', tokenIn?.address, tokenOut?.address, amountIn.toString(), chainId],
+        queryFn: async () => {
+            if (!tokenIn || !tokenOut || amountIn === 0n || !publicClient) {
+                return null;
+            }
+            try {
+                // Call QuoterV2 for quote
+                const result = await publicClient.simulateContract({
+                    address: contracts.V3_QUOTER_V2,
+                    abi: QUOTER_V2_ABI,
+                    functionName: 'quoteExactInputSingle',
+                    args: [
+                        {
+                            tokenIn: tokenIn.address,
+                            tokenOut: tokenOut.address,
+                            amountIn,
+                            fee: 3000, // 0.30% fee tier
+                            sqrtPriceLimitX96: 0n,
+                        },
+                    ],
+                });
+                const [amountOut, , , gasEstimate] = result.result;
+                // Calculate price impact (simplified)
+                const priceImpact = 0.003; // 0.3% placeholder
+                return {
+                    amountIn,
+                    amountOut,
+                    priceImpact,
+                    route: [tokenIn, tokenOut],
+                    gasEstimate,
+                };
+            }
+            catch (error) {
+                console.error('Failed to get swap quote:', error);
+                return null;
+            }
+        },
+        enabled: !!tokenIn && !!tokenOut && amountIn > 0n && !!publicClient,
+        staleTime: 10_000, // 10 seconds
+        refetchInterval: 15_000, // Refetch every 15 seconds
+    });
+}

package/dist/hooks/use-swap.d.ts

@@ -0,0 +1,22 @@
+import type { Token } from '../tokens';
+export interface SwapRequest {
+    tokenIn: Token;
+    tokenOut: Token;
+    amountIn: bigint;
+    amountOutMinimum: bigint;
+    recipient: `0x${string}`;
+    deadline: bigint;
+    chainId: number;
+}
+/**
+ * Hook to execute a swap transaction
+ */
+export declare function useSwap(): {
+    swap: import("@tanstack/react-query").UseMutateAsyncFunction<`0x${string}`, Error, SwapRequest, unknown>;
+    hash: `0x${string}` | undefined;
+    isPending: boolean;
+    isConfirming: boolean;
+    isSuccess: boolean;
+    error: Error | null;
+};
+//# sourceMappingURL=use-swap.d.ts.map

package/dist/hooks/use-swap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-swap.d.ts","sourceRoot":"","sources":["../../src/hooks/use-swap.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,WAAW,CAAA;AAGtC,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,KAAK,CAAA;IACd,QAAQ,EAAE,KAAK,CAAA;IACf,QAAQ,EAAE,MAAM,CAAA;IAChB,gBAAgB,EAAE,MAAM,CAAA;IACxB,SAAS,EAAE,KAAK,MAAM,EAAE,CAAA;IACxB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;GAEG;AACH,wBAAgB,OAAO;;;;;;;EAwCtB"}

package/dist/hooks/use-swap.js

@@ -0,0 +1,46 @@
+'use client';
+import { useMutation } from '@tanstack/react-query';
+import { useWriteContract, useWaitForTransactionReceipt } from 'wagmi';
+import { getContracts } from '../contracts';
+import { SWAP_ROUTER_ABI } from '../contracts/abis';
+import { isNativeToken } from '../tokens';
+/**
+ * Hook to execute a swap transaction
+ */
+export function useSwap() {
+    const { writeContractAsync, data: hash, isPending } = useWriteContract();
+    const { isLoading: isConfirming, isSuccess } = useWaitForTransactionReceipt({ hash });
+    const swap = useMutation({
+        mutationFn: async (params) => {
+            const contracts = getContracts(params.chainId);
+            const isNativeIn = isNativeToken(params.tokenIn);
+            const txHash = await writeContractAsync({
+                address: contracts.V3_SWAP_ROUTER_02,
+                abi: SWAP_ROUTER_ABI,
+                functionName: 'exactInputSingle',
+                args: [
+                    {
+                        tokenIn: isNativeIn ? contracts.WLUX : params.tokenIn.address,
+                        tokenOut: params.tokenOut.address,
+                        fee: 3000, // 0.30% fee tier
+                        recipient: params.recipient,
+                        deadline: params.deadline,
+                        amountIn: params.amountIn,
+                        amountOutMinimum: params.amountOutMinimum,
+                        sqrtPriceLimitX96: 0n,
+                    },
+                ],
+                value: isNativeIn ? params.amountIn : 0n,
+            });
+            return txHash;
+        },
+    });
+    return {
+        swap: swap.mutateAsync,
+        hash,
+        isPending: isPending || swap.isPending,
+        isConfirming,
+        isSuccess,
+        error: swap.error,
+    };
+}

package/dist/hooks/use-token-allowance.d.ts

@@ -0,0 +1,27 @@
+import type { Token } from '../tokens';
+import type { Address } from 'viem';
+/**
+ * Hook to check and manage token allowance
+ */
+export declare function useTokenAllowance(token: Token | null, owner: Address | undefined, spender: Address | undefined, chainId: number): {
+    allowance: bigint;
+    isApproved: boolean;
+    approve: (amount?: bigint) => Promise<`0x${string}` | undefined>;
+    isPending: boolean;
+    isConfirming: boolean;
+    isSuccess: boolean;
+    refetch?: undefined;
+} | {
+    allowance: bigint;
+    isApproved: boolean;
+    approve: (amount?: bigint) => Promise<`0x${string}` | undefined>;
+    isPending: boolean;
+    isConfirming: boolean;
+    isSuccess: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<bigint, import("viem").ReadContractErrorType>>;
+};
+/**
+ * Check if approval is needed for a specific amount
+ */
+export declare function needsApproval(allowance: bigint, amount: bigint): boolean;
+//# sourceMappingURL=use-token-allowance.d.ts.map

package/dist/hooks/use-token-allowance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-token-allowance.d.ts","sourceRoot":"","sources":["../../src/hooks/use-token-allowance.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,WAAW,CAAA;AAEtC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAEnC;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,KAAK,GAAG,IAAI,EACnB,KAAK,EAAE,OAAO,GAAG,SAAS,EAC1B,OAAO,EAAE,OAAO,GAAG,SAAS,EAC5B,OAAO,EAAE,MAAM;;;uBAgBgB,MAAM;;;;;;;;uBAAN,MAAM;;;;;EAkCtC;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAExE"}

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

@@ -0,0 +1,59 @@
+'use client';
+import { useReadContract, useWriteContract, useWaitForTransactionReceipt } from 'wagmi';
+import { maxUint256 } from 'viem';
+import { ERC20_ABI } from '../contracts/abis';
+import { isNativeToken } from '../tokens';
+/**
+ * Hook to check and manage token allowance
+ */
+export function useTokenAllowance(token, owner, spender, chainId) {
+    const allowance = useReadContract({
+        address: token?.address,
+        abi: ERC20_ABI,
+        functionName: 'allowance',
+        args: owner && spender ? [owner, spender] : undefined,
+        chainId,
+        query: {
+            enabled: !!token && !isNativeToken(token) && !!owner && !!spender,
+        },
+    });
+    const { writeContractAsync, data: hash, isPending } = useWriteContract();
+    const { isLoading: isConfirming, isSuccess } = useWaitForTransactionReceipt({ hash });
+    const approve = async (amount = maxUint256) => {
+        if (!token || !spender || isNativeToken(token))
+            return;
+        return writeContractAsync({
+            address: token.address,
+            abi: ERC20_ABI,
+            functionName: 'approve',
+            args: [spender, amount],
+        });
+    };
+    // Native tokens don't need approval
+    if (token && isNativeToken(token)) {
+        return {
+            allowance: maxUint256,
+            isApproved: true,
+            approve,
+            isPending: false,
+            isConfirming: false,
+            isSuccess: true,
+        };
+    }
+    const currentAllowance = allowance.data ?? 0n;
+    return {
+        allowance: currentAllowance,
+        isApproved: currentAllowance > 0n,
+        approve,
+        isPending,
+        isConfirming,
+        isSuccess,
+        refetch: allowance.refetch,
+    };
+}
+/**
+ * Check if approval is needed for a specific amount
+ */
+export function needsApproval(allowance, amount) {
+    return allowance < amount;
+}

package/dist/hooks/use-token-balance.d.ts

@@ -0,0 +1,17 @@
+import type { Token } from '../tokens';
+import type { Address } from 'viem';
+/**
+ * Hook to get token balance for an address
+ */
+export declare function useTokenBalance(token: Token | null, address: Address | undefined, chainId: number): {
+    balance: bigint;
+    formatted: string;
+    isLoading: boolean;
+    error: import("viem").GetBalanceErrorType | null;
+} | {
+    balance: bigint;
+    formatted: string;
+    isLoading: boolean;
+    error: import("viem").ReadContractErrorType | null;
+};
+//# sourceMappingURL=use-token-balance.d.ts.map

package/dist/hooks/use-token-balance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-token-balance.d.ts","sourceRoot":"","sources":["../../src/hooks/use-token-balance.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,WAAW,CAAA;AAEtC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAEnC;;GAEG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,KAAK,GAAG,IAAI,EACnB,OAAO,EAAE,OAAO,GAAG,SAAS,EAC5B,OAAO,EAAE,MAAM;;;;;;;;;;EAgDhB"}