const quote = await hypertrade.getQuote({
  tokenIn: 'USDC',
  tokenOut: 'ETH',
  amountIn: ethers.parseUnits('1000', 6), // 1000 USDC (6 decimals)
  slippage: 1.0, // 1%
});

console.log('You will receive:', ethers.formatUnits(quote.amountOut, 18), 'ETH');
console.log('Price impact:', quote.priceImpact, '%');
console.log('Route:', quote.route.map(r => `${r.percentage}% via ${r.dex}`));

try {
  const tx = await hypertrade.executeSwap({
    tokenIn: 'USDC',
    tokenOut: 'ETH',
    amountIn: ethers.parseUnits('1000', 6),
    slippage: 1.0,
    deadline: Math.floor(Date.now() / 1000) + 600, // 10 minutes
  });

  console.log('Transaction sent:', tx.hash);

  const receipt = await tx.wait();
  console.log('Swap completed!');
  console.log('Gas used:', receipt.gasUsed.toString());

} catch (error) {
  console.error('Swap failed:', error);
}

Check if approval is required
const allowance = await hypertrade.checkAllowance('USDC');
const amountIn = ethers.parseUnits('1000', 6);

if (allowance < amountIn) {
  console.log('Approval needed...');

  const approveTx = await hypertrade.approveToken('USDC', amountIn);
  await approveTx.wait();

  console.log('Approval successful!');
}

Now you can swap
const swapTx = await hypertrade.executeSwap({ ... });
Recommendation: Use limited approval (exact amount or amount + 10%) rather than unlimited.

const tokens = await hypertrade.getTokens();

console.log('Available tokens:');
tokens.forEach(token => {
  console.log(`${token.symbol} (${token.name}): ${token.address}`);
});

const ethPrice = await hypertrade.getPrice('ETH');
console.log('ETH price:', ethPrice.priceUSD, 'USD');
console.log('24h change:', ethPrice.change24h, '%');

const simulation = await hypertrade.simulateSwap({
  tokenIn: 'USDC',
  tokenOut: 'ETH',
  amountIn: ethers.parseUnits('10000', 6), // large order
  slippage: 1.0,
});

console.log('Simulated result:');
console.log('Amount out:', ethers.formatUnits(simulation.amountOut, 18), 'ETH');
console.log('Price impact:', simulation.priceImpact, '%');
console.log('Gas cost:', simulation.gasCostUSD, 'USD');

Check if the swap will execute
if (simulation.success) {
  console.log('✅ Swap will succeed');
} else {
  console.error('❌ Swap will fail:', simulation.error);
}

try {
  const quote = await hypertrade.getQuote({ ... });
} catch (error) {
  if (error.code === 'INSUFFICIENT_LIQUIDITY') {
    alert('Not enough liquidity for this swap');
  } else if (error.code === 'HIGH_PRICE_IMPACT') {
    alert(`Price impact ${error.impact}% is too high. Consider splitting the order.`);
  } else if (error.code === 'USER_REJECTED') {
    console.log('User cancelled transaction');
  } else {
    console.error('Unexpected error:', error);
    alert('Swap failed. Please try again.');
  }
}

function PortfolioRebalance() {
  const [portfolio, setPortfolio] = useState({
    ETH: 10.5,
    USDC: 5000,
    HYPE: 2000,
  });

  const handleRebalance = async () => {
    Sell 30% ETH
    const ethToSell = portfolio. ETH * 0.3; // 3.15 ETH

    const quote = await hypertrade.getQuote({
      tokenIn: 'ETH',
      tokenOut: 'USDC',
      amountIn: ethers.parseUnits(ethToSell.toString(), 18),
      slippage: 1.0,
    });

    console.log('Will receive:', quote.amountOutHuman, 'USDC');

    const tx = await hypertrade.executeSwap({
      tokenIn: 'ETH',
      tokenOut: 'USDC',
      amountIn: ethers.parseUnits(ethToSell.toString(), 18),
      slippage: 1.0,
    });

    await tx.wait();

    Update portfolio
    setPortfolio({
      ETH: portfolio. ETH - ethToSell,
      USDC: portfolio. USDC + parseFloat(quote.amountOutHuman),
      HYPE: portfolio. HYPE,
    });

    alert('Rebalance complete!');
  };

  return (
    <div>
      <h2>Portfolio Rebalance</h2>
      <p>ETH: {portfolio. ETH}</p>
      <p>USDC: {portfolio. USDC}</p>
      <button onClick={handleRebalance}>Rebalance (Sell 30% ETH)</button>
    </div>
  );
}

function NFTPurchase({ nftPrice }) {
  const [userBalance, setUserBalance] = useState({ USDC: 5000, ETH: 0.5 });

  const handleBuyNFT = async () => {
    const ethNeeded = nftPrice; e.g. 2.5 ETH

    if (userBalance.ETH >= ethNeeded) {
      Enough ETH, you can buy it right away
      await purchaseNFT(ethNeeded);
    } else {
      Not enough ETH → swap USDC → ETH
      const ethShortage = ethNeeded - userBalance.ETH; 2.0 ETH needs to be purchased

      const quote = await hypertrade.getQuote({
        tokenIn: 'USDC',
        tokenOut: 'ETH',
        amountOut: ethers.parseUnits(ethShortage.toString(), 18), // reversed quote
        slippage: 1.0,
      });

      console.log('Need to swap:', quote.amountInHuman, 'USDC');

      User Confirmation
      const confirm = window.confirm(
        `You need ${ethShortage} ETH. Swap ${quote.amountInHuman} USDC?`
      );
      if (!confirm) return;

      Execute swap
      const tx = await hypertrade.executeSwap({
        tokenIn: 'USDC',
        tokenOut: 'ETH',
        amountIn: quote.amountIn,
        slippage: 1.0,
      });

      await tx.wait();

      Update Balance
      setUserBalance({
        USDC: userBalance.USDC - parseFloat(quote.amountInHuman),
        ETH: userBalance.ETH + ethShortage,
      });

      Buy NFTs Now
      await purchaseNFT(ethNeeded);
    }
  };

  return (
    <div>
      <h2>Buy NFT</h2>
      <p>Price: {nftPrice} ETH</p>
      <p>Your balance: {userBalance.ETH} ETH, {userBalance.USDC} USDC</p>
      <button onClick={handleBuyNFT}>Buy NFT</button>
    </div>
  );
}

import cron from 'node-cron';

Every Monday at 10:00 UTC
cron.schedule('0 10 * * 1', async () => {
  console.log('Running weekly DCA...');

  try {
    const amountUSDC = 1000;

    const quote = await hypertrade.getQuote({
      tokenIn: 'USDC',
      tokenOut: 'ETH',
      amountIn: ethers.parseUnits(amountUSDC.toString(), 6),
      slippage: 1.0,
    });

    console.log('Will buy:', quote.amountOutHuman, 'ETH for', amountUSDC, 'USDC');
    console.log('Price:', amountUSDC / parseFloat(quote.amountOutHuman), 'USDC/ETH');

    const tx = await hypertrade.executeSwap({
      tokenIn: 'USDC',
      tokenOut: 'ETH',
      amountIn: ethers.parseUnits(amountUSDC.toString(), 6),
      slippage: 1.0,
    });

    await tx.wait();
    console.log('DCA successful! Tx:', tx.hash);

    Send a notification
    await sendNotification(`DCA executed: Bought ${quote.amountOutHuman} ETH`);

  } catch (error) {
    console.error('DCA failed:', error);
    await sendErrorAlert('DCA failed', error);
  }
});