burn swap and page menu updates

src/hooks/usePartyPlanner.ts

@@ -522,4 +522,137 @@ export function useSwapMintAmounts(
     error,
     isReady: mounted,
   };
+}
+
+export function useBurnSwapAmounts(
+  poolAddress: `0x${string}` | undefined,
+  lpAmount: bigint | undefined,
+  inputTokenIndex: number | undefined
+) {
+  const publicClient = usePublicClient();
+  const [mounted, setMounted] = useState(false);
+  const [burnSwapAmounts, setBurnSwapAmounts] = useState<bigint | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  // Handle hydration for Next.js static export
+  useEffect(() => {
+    setMounted(true);
+  }, []);
+
+  useEffect(() => {
+    if (!mounted || !poolAddress || !lpAmount || lpAmount === BigInt(0) || inputTokenIndex === undefined) {
+      setLoading(false);
+      setBurnSwapAmounts(null);
+      return;
+    }
+
+    const fetchBurnSwapAmounts = async () => {
+      if (!publicClient) {
+        setLoading(false);
+        return;
+      }
+
+      try {
+        setLoading(true);
+        setError(null);
+
+        // Get chain ID and contract address
+        const chainId = await publicClient.getChainId();
+        const viewerAddress = (chainInfo as Record<string, { v1: { PartyPlanner: string; PartyPoolViewer: string } }>)[chainId.toString()]?.v1?.PartyPoolViewer;
+
+        if (!viewerAddress) {
+          setError('IPartyPoolViewer contract not found for current chain');
+          setBurnSwapAmounts(null);
+          return;
+        }
+
+        // Call burnSwapAmounts function
+        const result = await publicClient.readContract({
+          address: viewerAddress as `0x${string}`,
+          abi: IPartyPoolViewerABI,
+          functionName: 'burnSwapAmounts',
+          args: [poolAddress, lpAmount, BigInt(inputTokenIndex)],
+        }) as bigint;
+
+        setBurnSwapAmounts(result);
+      } catch (err) {
+        console.error('Error calling burnSwapAmounts:', err);
+        setError(err instanceof Error ? err.message : 'Failed to fetch burn swap amounts');
+        setBurnSwapAmounts(null);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    fetchBurnSwapAmounts();
+  }, [publicClient, mounted, poolAddress, lpAmount, inputTokenIndex]);
+
+  return {
+    burnSwapAmounts,
+    loading,
+    error,
+    isReady: mounted,
+  };
+}
+
+export function useLPTokenBalance(
+  poolAddress: `0x${string}` | undefined,
+  userAddress: `0x${string}` | undefined
+) {
+  const publicClient = usePublicClient();
+  const [mounted, setMounted] = useState(false);
+  const [lpBalance, setLpBalance] = useState<bigint | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  // Handle hydration for Next.js static export
+  useEffect(() => {
+    setMounted(true);
+  }, []);
+
+  useEffect(() => {
+    if (!mounted || !poolAddress || !userAddress) {
+      setLoading(false);
+      setLpBalance(null);
+      return;
+    }
+
+    const fetchLPBalance = async () => {
+      if (!publicClient) {
+        setLoading(false);
+        return;
+      }
+
+      try {
+        setLoading(true);
+        setError(null);
+
+        // Call balanceOf on the pool (which is an ERC20 LP token)
+        const balance = await publicClient.readContract({
+          address: poolAddress,
+          abi: ERC20ABI,
+          functionName: 'balanceOf',
+          args: [userAddress],
+        }) as bigint;
+
+        setLpBalance(balance);
+      } catch (err) {
+        console.error('Error fetching LP token balance:', err);
+        setError(err instanceof Error ? err.message : 'Failed to fetch LP balance');
+        setLpBalance(null);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    fetchLPBalance();
+  }, [publicClient, mounted, poolAddress, userAddress]);
+
+  return {
+    lpBalance,
+    loading,
+    error,
+    isReady: mounted,
+  };
 }

src/hooks/usePartyPool.ts

@@ -462,4 +462,111 @@ export function useSwapMint() {
         swapMintHash,
         swapMintError,
     };
+}
+
+export function useBurnSwap() {
+    const publicClient = usePublicClient();
+    const { data: walletClient } = useWalletClient();
+    const [isBurnSwapping, setIsBurnSwapping] = useState(false);
+    const [burnSwapHash, setBurnSwapHash] = useState<`0x${string}` | null>(null);
+    const [burnSwapError, setBurnSwapError] = useState<string | null>(null);
+
+    const executeBurnSwap = async (
+        poolAddress: `0x${string}`,
+        lpAmount: bigint,
+        inputTokenIndex: number,
+        unwrap: boolean = false
+    ) => {
+        if (!walletClient || !publicClient) {
+            setBurnSwapError('Wallet not connected');
+            return;
+        }
+
+        try {
+            setIsBurnSwapping(true);
+            setBurnSwapError(null);
+            setBurnSwapHash(null);
+
+            const userAddress = walletClient.account.address;
+
+            // STEP 1: Approve the pool to spend the LP tokens
+            console.log('🔐 Approving LP token spend for burn swap...');
+            console.log('LP token (pool) to approve:', poolAddress);
+            console.log('Spender (pool):', poolAddress);
+            console.log('Amount:', lpAmount.toString());
+
+            const approvalHash = await walletClient.writeContract({
+                address: poolAddress,
+                abi: [
+                    {
+                        name: 'approve',
+                        type: 'function',
+                        stateMutability: 'nonpayable',
+                        inputs: [
+                            { name: 'spender', type: 'address' },
+                            { name: 'amount', type: 'uint256' }
+                        ],
+                        outputs: [{ name: '', type: 'bool' }]
+                    }
+                ],
+                functionName: 'approve',
+                args: [poolAddress, lpAmount],
+            });
+
+            console.log('✅ Approval transaction submitted:', approvalHash);
+            await publicClient.waitForTransactionReceipt({ hash: approvalHash });
+            console.log('✅ Approval confirmed');
+
+            // STEP 2: Calculate deadline (5 minutes from now)
+            const deadline = BigInt(Math.floor(Date.now() / 1000) + 300); // 5 minutes = 300 seconds
+
+            console.log('🚀 Executing burnSwap with params:', {
+                pool: poolAddress,
+                payer: userAddress,
+                receiver: userAddress,
+                lpAmount: lpAmount.toString(),
+                inputTokenIndex,
+                deadline: deadline.toString(),
+                unwrap,
+            });
+
+            // STEP 3: Execute the burnSwap transaction
+            const hash = await walletClient.writeContract({
+                address: poolAddress,
+                abi: IPartyPoolABI,
+                functionName: 'burnSwap',
+                args: [
+                    userAddress, // payer
+                    userAddress, // receiver
+                    lpAmount,
+                    BigInt(inputTokenIndex),
+                    deadline,
+                    unwrap,
+                ],
+            });
+
+            setBurnSwapHash(hash);
+            console.log('✅ BurnSwap transaction submitted:', hash);
+
+            // Wait for transaction confirmation
+            const receipt = await publicClient.waitForTransactionReceipt({ hash });
+            console.log('✅ BurnSwap transaction confirmed:', receipt);
+
+            return receipt;
+        } catch (err) {
+            const errorMessage = err instanceof Error ? err.message : 'BurnSwap failed';
+            setBurnSwapError(errorMessage);
+            console.error('❌ BurnSwap error:', err);
+            throw err;
+        } finally {
+            setIsBurnSwapping(false);
+        }
+    };
+
+    return {
+        executeBurnSwap,
+        isBurnSwapping,
+        burnSwapHash,
+        burnSwapError,
+    };
 }