import { useWallet, useConnection } from '@solana/wallet-adapter-react';
import { useState } from 'react';

export function QuickSwapButton() {
  const { publicKey, sendTransaction } = useWallet();
  const { connection } = useConnection();
  const [loading, setLoading] = useState(false);

  async function handleSwap() {
    if (!publicKey) return;
    setLoading(true);

    try {
      // 1. Fetch quote
      const params = new URLSearchParams({
        inputMint: "So11111111111111111111111111111111111111112",
        outputMint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
        amount: "1000000000",
        slippageBps: "50"
      });
      const quoteRes = await fetch(
        `https://quote-api.jup.ag/v6/quote?${params}`
      );
      const quote = await quoteRes.json();

      // 2. Get swap transaction
      const swapRes = await fetch(
        "https://quote-api.jup.ag/v6/swap",
        {
          method: "POST",
          headers: { "Content-Type": "application/json" },
          body: JSON.stringify({
            quoteResponse: quote,
            userPublicKey: publicKey.toBase58(),
            wrapAndUnwrapSol: true,
            dynamicComputeUnitLimit: true,
            dynamicSlippage: true,
          })
        }
      );
      const { swapTransaction } = await swapRes.json();

      // 3. Send transaction
      const txBuf = Buffer.from(swapTransaction, "base64");
      const tx = VersionedTransaction.deserialize(txBuf);
      const sig = await sendTransaction(tx, connection);

      // 4. Confirm
      const blockhash = await connection.getLatestBlockhash();
      await connection.confirmTransaction({
        signature: sig,
        ...blockhash
      }, "confirmed");

      console.log("Swap complete:", sig);
    } catch (err) {
      console.error("Swap failed:", err);
    } finally {
      setLoading(false);
    }
  }

  return (
    <button onClick={handleSwap} disabled={!publicKey || loading}>
      {loading ? "Swapping..." : "Swap 1 SOL to USDC"}
    </button>
  );
}

// Minimal swap hook for wallet extensions
import { useCallback, useState } from 'react';
import { useWallet, useConnection } from '@solana/wallet-adapter-react';
import { VersionedTransaction } from '@solana/web3.js';

export function useJupiterSwap() {
  const { publicKey, sendTransaction } = useWallet();
  const { connection } = useConnection();
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState<string | null>(null);

  const swap = useCallback(async (
    inputMint: string,
    outputMint: string,
    amount: number,
    slippageBps: number = 50
  ) => {
    if (!publicKey) throw new Error("Wallet not connected");

    setLoading(true);
    setError(null);

    try {
      const params = new URLSearchParams({
        inputMint,
        outputMint,
        amount: amount.toString(),
        slippageBps: slippageBps.toString()
      });

      const quoteRes = await fetch(
        `https://quote-api.jup.ag/v6/quote?${params}`
      );
      if (!quoteRes.ok) throw new Error("Quote failed");
      const quote = await quoteRes.json();

      const swapRes = await fetch("https://quote-api.jup.ag/v6/swap", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          quoteResponse: quote,
          userPublicKey: publicKey.toBase58(),
          wrapAndUnwrapSol: true,
          dynamicComputeUnitLimit: true,
          dynamicSlippage: true,
        })
      });
      if (!swapRes.ok) throw new Error("Swap preparation failed");
      const { swapTransaction } = await swapRes.json();

      const txBuf = Buffer.from(swapTransaction, "base64");
      const tx = VersionedTransaction.deserialize(txBuf);
      const signature = await sendTransaction(tx, connection);

      const blockhash = await connection.getLatestBlockhash();
      await connection.confirmTransaction({
        signature,
        ...blockhash
      }, "confirmed");

      return signature;
    } catch (err) {
      const msg = err instanceof Error ? err.message : "Unknown error";
      setError(msg);
      throw err;
    } finally {
      setLoading(false);
    }
  }, [publicKey, connection, sendTransaction]);

  return { swap, loading, error };
}

// Usage in your wallet UI
function WalletSwapScreen() {
  const { swap, loading, error } = useJupiterSwap();

  async function handleSwap() {
    try {
      const sig = await swap(
        "So11111111111111111111111111111111111111112",
        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
        1_000_000_000
      );
      alert(`Swap complete: ${sig}`);
    } catch (err) {
      console.error(err);
    }
  }

  return (
    <div>
      <button onClick={handleSwap} disabled={loading}>
        {loading ? "Swapping..." : "Swap"}
      </button>
      {error && <p>Error: {error}</p>}
    </div>
  );
}

function analyzeRoute(quote: JupiterQuote) {
  const { routePlan } = quote;

  const steps = routePlan.map((step, index) => ({
    stepNumber: index + 1,
    dex: step.swapInfo.label || 'Unknown DEX',
    inputMint: step.swapInfo.inputMint,
    outputMint: step.swapInfo.outputMint,
    // Additional metadata from step
  }));

  return {
    isDirectRoute: steps.length === 1,
    hopCount: steps.length,
    steps,
    dexesUsed: [...new Set(steps.map(s => s.dex))],
  };
}

// Usage
const quote = await fetchQuote(/* params */);
const routeInfo = analyzeRoute(quote);

console.log(`Route uses ${routeInfo.hopCount} hops`);
console.log(`DEXs: ${routeInfo.dexesUsed.join(', ')}`);

async function getOptimalPriorityFee(connection: Connection) {
  const recentFees = await connection.getRecentPrioritizationFees();

  if (recentFees.length === 0) {
    return 1000; // Minimum fee
  }

  // Use 75th percentile for reliable execution
  const sorted = recentFees
    .map(f => f.prioritizationFee)
    .sort((a, b) => a - b);

  const p75Index = Math.floor(sorted.length * 0.75);
  return sorted[p75Index];
}

// Include in swap request
const priorityFee = await getOptimalPriorityFee(connection);

const swapResponse = await fetch('/v6/swap', {
  method: 'POST',
  body: JSON.stringify({
    quoteResponse: quote,
    userPublicKey: wallet.publicKey.toBase58(),
    prioritizationFeeLamports: priorityFee,
    dynamicComputeUnitLimit: true,
  })
});

import { TOKEN_PROGRAM_ID } from '@solana/spl-token';

async function checkTokenBalance(
  connection: Connection,
  wallet: PublicKey,
  mintAddress: string,
  requiredAmount: number
): Promise<{ sufficient: boolean; balance: number }> {
  if (mintAddress === 'So11111111111111111111111111111111111111112') {
    // Native SOL
    const balance = await connection.getBalance(wallet);
    return {
      sufficient: balance >= requiredAmount,
      balance,
    };
  }

  // SPL Token
  const tokenAccounts = await connection.getParsedTokenAccountsByOwner(
    wallet,
    { mint: new PublicKey(mintAddress) }
  );

  if (tokenAccounts.value.length === 0) {
    return { sufficient: false, balance: 0 };
  }

  const balance = tokenAccounts.value[0].account.data.parsed.info
    .tokenAmount.amount;

  return {
    sufficient: parseInt(balance) >= requiredAmount,
    balance: parseInt(balance),
  };
}

// Before swap
const { sufficient, balance } = await checkTokenBalance(
  connection,
  wallet.publicKey,
  inputMint,
  amountInBaseUnits
);

if (!sufficient) {
  throw new Error(`Insufficient balance: have ${balance}, need ${amountInBaseUnits}`);
}

function useQuoteRefresh(
  inputMint: string,
  outputMint: string,
  amount: number,
  enabled: boolean
) {
  const [quote, setQuote] = useState<JupiterQuote | null>(null);
  const [priceChange, setPriceChange] = useState<number>(0);

  useEffect(() => {
    if (!enabled) return;

    const fetchAndCompare = async () => {
      const newQuote = await fetchQuote(inputMint, outputMint, amount);

      if (quote) {
        const oldOutput = parseInt(quote.outAmount);
        const newOutput = parseInt(newQuote.outAmount);
        const change = ((newOutput - oldOutput) / oldOutput) * 100;

        setPriceChange(change);

        // Alert on significant change
        if (Math.abs(change) > 2) {
          console.warn(`Price changed by ${change.toFixed(2)}%`);
        }
      }

      setQuote(newQuote);
    };

    fetchAndCompare();
    const interval = setInterval(fetchAndCompare, 10000); // Every 10s

    return () => clearInterval(interval);
  }, [inputMint, outputMint, amount, enabled]);

  return { quote, priceChange };
}

class SwapError extends Error {
  constructor(
    message: string,
    public code: string,
    public userMessage: string,
    public retryable: boolean
  ) {
    super(message);
    this.name = 'SwapError';
  }
}

function handleSwapError(error: any): SwapError {
  // Network errors
  if (error.message?.includes('fetch')) {
    return new SwapError(
      error.message,
      'NETWORK_ERROR',
      'Network connection failed. Please check your internet.',
      true
    );
  }

  // Wallet errors
  if (error.message?.includes('User rejected')) {
    return new SwapError(
      error.message,
      'USER_REJECTED',
      'Transaction was cancelled.',
      false
    );
  }

  // Slippage errors
  if (error.message?.includes('slippage')) {
    return new SwapError(
      error.message,
      'SLIPPAGE_EXCEEDED',
      'Price moved too much. Try increasing slippage tolerance.',
      true
    );
  }

  // Insufficient balance
  if (error.message?.includes('insufficient')) {
    return new SwapError(
      error.message,
      'INSUFFICIENT_BALANCE',
      'Not enough tokens to complete this swap.',
      false
    );
  }

  // Rate limit
  if (error.status === 429) {
    return new SwapError(
      'Rate limit exceeded',
      'RATE_LIMIT',
      'Too many requests. Please wait a moment.',
      true
    );
  }

  // Transaction timeout
  if (error.message?.includes('timeout') || error.message?.includes('blockhash')) {
    return new SwapError(
      error.message,
      'TRANSACTION_TIMEOUT',
      'Transaction took too long. It may still complete.',
      true
    );
  }

  // Generic error
  return new SwapError(
    error.message || 'Unknown error',
    'UNKNOWN_ERROR',
    'Something went wrong. Please try again.',
    true
  );
}

// Usage
try {
  await executeSwap(/* params */);
} catch (error) {
  const swapError = handleSwapError(error);

  console.error(`[${swapError.code}] ${swapError.message}`);

  // Show user-friendly message
  showError(swapError.userMessage);

  // Log for debugging
  logError({
    code: swapError.code,
    message: swapError.message,
    retryable: swapError.retryable,
    timestamp: new Date().toISOString(),
  });

  // Retry if applicable
  if (swapError.retryable) {
    showRetryButton();
  }
}

class QuoteCache {
  private cache = new Map<string, { quote: JupiterQuote; timestamp: number }>();
  private readonly TTL = 5000; // 5 seconds

  private getCacheKey(inputMint: string, outputMint: string, amount: number): string {
    return `${inputMint}-${outputMint}-${amount}`;
  }

  get(inputMint: string, outputMint: string, amount: number): JupiterQuote | null {
    const key = this.getCacheKey(inputMint, outputMint, amount);
    const cached = this.cache.get(key);

    if (!cached) return null;

    const age = Date.now() - cached.timestamp;
    if (age > this.TTL) {
      this.cache.delete(key);
      return null;
    }

    return cached.quote;
  }

  set(inputMint: string, outputMint: string, amount: number, quote: JupiterQuote): void {
    const key = this.getCacheKey(inputMint, outputMint, amount);
    this.cache.set(key, {
      quote,
      timestamp: Date.now(),
    });
  }

  clear(): void {
    this.cache.clear();
  }
}

const quoteCache = new QuoteCache();

async function fetchQuoteWithCache(
  inputMint: string,
  outputMint: string,
  amount: number
): Promise<JupiterQuote> {
  // Check cache first
  const cached = quoteCache.get(inputMint, outputMint, amount);
  if (cached) {
    console.log('Using cached quote');
    return cached;
  }

  // Fetch fresh quote
  const quote = await fetchQuote(inputMint, outputMint, amount);
  quoteCache.set(inputMint, outputMint, amount, quote);

  return quote;
}

function useDebouncedValue<T>(value: T, delay: number): T {
  const [debouncedValue, setDebouncedValue] = useState<T>(value);

  useEffect(() => {
    const handler = setTimeout(() => {
      setDebouncedValue(value);
    }, delay);

    return () => {
      clearTimeout(handler);
    };
  }, [value, delay]);

  return debouncedValue;
}

// Usage in component
function SwapComponent() {
  const [inputAmount, setInputAmount] = useState('');
  const debouncedAmount = useDebouncedValue(inputAmount, 500);

  useEffect(() => {
    if (debouncedAmount) {
      fetchQuote(debouncedAmount);
    }
  }, [debouncedAmount]);

  return (
    <input
      value={inputAmount}
      onChange={(e) => setInputAmount(e.target.value)}
      placeholder="Amount"
    />
  );
}

async function fetchSwapData(connection: Connection, wallet: PublicKey) {
  const [balance, tokenAccounts, recentBlockhash, priorityFees] = await Promise.all([
    connection.getBalance(wallet),
    connection.getParsedTokenAccountsByOwner(wallet, {
      programId: TOKEN_PROGRAM_ID
    }),
    connection.getLatestBlockhash(),
    connection.getRecentPrioritizationFees(),
  ]);

  return {
    solBalance: balance,
    tokens: tokenAccounts.value,
    blockhash: recentBlockhash,
    suggestedFee: calculateMedianFee(priorityFees),
  };
}

import { describe, it, expect, vi } from 'vitest';

describe('Quote Fetching', () => {
  it('should fetch valid quote for SOL to USDC', async () => {
    const quote = await fetchQuote(
      'So11111111111111111111111111111111111111112',
      'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
      1_000_000_000 // 1 SOL
    );

    expect(quote).toBeDefined();
    expect(quote.inAmount).toBe('1000000000');
    expect(parseInt(quote.outAmount)).toBeGreaterThan(0);
    expect(quote.priceImpactPct).toBeLessThan(1); // Less than 1%
  });

  it('should handle invalid token pair', async () => {
    await expect(
      fetchQuote('invalid-mint', 'also-invalid', 1000)
    ).rejects.toThrow();
  });

  it('should respect slippage parameter', async () => {
    const quote = await fetchQuote(
      'So11111111111111111111111111111111111111112',
      'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
      1_000_000_000,
      100 // 1% slippage
    );

    expect(quote.slippageBps).toBe(100);
  });
});

# .env.production
NEXT_PUBLIC_SOLANA_RPC=https://your-dedicated-rpc.com
NEXT_PUBLIC_ENABLE_ANALYTICS=true
NEXT_PUBLIC_ENVIRONMENT=production

# Optional: Add your own API endpoint if proxying Jupiter
NEXT_PUBLIC_JUPITER_API_URL=https://quote-api.jup.ag/v6