Spread one limit buy over Base's pools

// Buys WETH on Base with up to `budget` of the Pot's USDC, spread over the pair's pools on
// Aerodrome Slipstream, Uniswap V3, PancakeSwap V3 and hookless Uniswap V4: a limit buy in which
// no WETH costs more than `priceLimit`, fees included. Each pool, in the loops' order and not in
// order of price, is offered the budget still unspent and stops at its own fee-adjusted limit;
// missing, empty and past-limit pools are skipped. The WETH and the unspent USDC go to
// `recipient`. The cook reverts, and nothing moves, when less than `minTokens` arrives or, with
// `maxAvgPrice` not 0, the average price paid is above it.
//
//   sauce simulate distributed-swap.sauce.ts --chain base --owner <address> \
//     --assume-balance USDC:<budget>n \
//     --args <budget> <priceLimit> <minTokens> <maxAvgPrice> <recipient>
//   sauce run distributed-swap.sauce.ts --chain base --wallet <name> \
//     --fund USDC:<budget>n --args <budget> <priceLimit> <minTokens> <maxAvgPrice> <recipient>
//
//   budget: Uint256       the most USDC to spend, in USDC base units (6 decimals): 10000000000
//                         is 10,000 USDC; the Pot must hold it
//   priceLimit: Uint256   the most one WETH may cost, fees included: USDC base units per WETH
//                         base unit, times 1e18, which is the price in USDC times 10^6:
//                         2333000000 is 2,333 USDC
//   minTokens: Uint256    the least WETH `recipient` may receive, in wei (18 decimals);
//                         budget * 1e18 / priceLimit, rounded up, is the least a full fill at
//                         the limit buys: 4286326618088298329 for 10,000 USDC at 2,333. It does
//                         not force a full fill: pools below the limit can reach it with part of
//                         the budget unspent
//   maxAvgPrice: Uint256  the most the average may cost, in priceLimit's units; 0 turns it off
//   recipient: Address    receives the WETH bought and the unspent USDC
//
// On Base, up to 10,000 USDC of WETH at no more than 2,333 USDC each and at least
// 4.286326618088298329 WETH, an average of at most 2,332.489272 (halfway from a simulated
// 2,331.978543 to priceLimit), for <recipient>:
//
//   sauce run distributed-swap.sauce.ts --chain base --wallet me --fund USDC:10000 \
//     --args 10000000000 2333000000 4286326618088298329 2332489272 \
//     <recipient>
import { uniswapV3, uniswapV4 } from "@sauce/router";

// One pool: skipped when missing, empty or already at or past its own limit; otherwise offered
// all of the budget still unspent, up to its own limit, with the output paid to `recipient`.
function trade(
  venue: Uint256, // 0 Uniswap V3, 1 Slipstream, 2 Uniswap V4, 3 PancakeSwap V3
  pool: Uint256, // the pool's address; a V4 pool has none, and this is its id, a 256-bit hash
  spacing: Uint256, // a V4 pool's tick spacing
  kept: Uint256,
  limit: Uint256,
  recipient: Address,
): void {
  const unspent = pot.USDC - kept;
  if (pool == 0 || unspent == 0) {
    return;
  }
  const paysToken0 = USDC < WETH;
  let liquidity = 0;
  let price = 0;
  let fee = 0;
  let lpFee = 0;
  if (venue == 0) {
    liquidity = UniswapV3.Pool(pool).liquidity();
    price = UniswapV3.Pool(pool).slot0().sqrtPriceX96;
    fee = UniswapV3.Pool(pool).fee();
  } else if (venue == 1) {
    // Slipstream's own binding: its slot0 has no feeProtocol, and its fee can change any block.
    liquidity = AerodromeSlipstream.Pool(pool).liquidity();
    price = AerodromeSlipstream.Pool(pool).slot0().sqrtPriceX96;
    fee = AerodromeSlipstream.Pool(pool).fee();
  } else if (venue == 3) {
    // PancakeSwap V3's own binding: its slot0 declares feeProtocol as a uint32, and a read
    // decodes and range-checks every declared output.
    liquidity = PancakeswapV3.Pool(pool).liquidity();
    price = PancakeswapV3.Pool(pool).slot0().sqrtPriceX96;
    fee = PancakeswapV3.Pool(pool).fee();
  } else {
    // A missing V4 pool reads as empty. Its fee is this direction's protocol fee (paying token0's
    // in the low 12 bits, token1's in the next 12), then the LP fee on the rest.
    liquidity = UniswapV4.StateView.getLiquidity(pool);
    const [sqrtPriceX96, , protocolFees, poolFee] = UniswapV4.StateView.getSlot0(pool);
    const protocolFee = (paysToken0 ? protocolFees : protocolFees >> 12) & 0xfff;
    price = sqrtPriceX96;
    lpFee = poolFee;
    fee = protocolFee + lpFee - (protocolFee * lpFee) / 1000000;
  }
  // The pool's own limit: the caller's moved by √(1 − fee), so that its last unit, fee paid,
  // costs exactly priceLimit. Paying token0 pushes the price down, token1 pushes it up.
  const root = Math.sqrt((1000000 - fee) * 10 ** 30); // √(1 − fee), times 1e18
  const own = paysToken0 ? Math.mulDiv(limit, 10 ** 18, root) : Math.mulDiv(limit, root, 10 ** 18);
  const better = paysToken0 ? price > own : price < own;
  if (liquidity == 0 || !better) {
    return;
  }
  if (venue == 2) {
    // A hookless pool's LP fee is its key's fee.
    uniswapV4(UniswapV4.PoolManager, USDC, WETH, unspent, lpFee, spacing, 0, own, 0, recipient);
    return;
  }
  // Slipstream pools call back uniswapV3SwapCallback and PancakeSwap V3 pools
  // pancakeV3SwapCallback. The Router answers both, so uniswapV3 swaps all three.
  uniswapV3(pool, USDC, WETH, unspent, own, 0, recipient);
}

function main(
  budget: Uint256,
  priceLimit: Uint256,
  minTokens: Uint256,
  maxAvgPrice: Uint256,
  recipient: Address,
): { spent: Uint256; bought: Uint256; unspent: Uint256 } {
  require(budget > 0, "budget is 0");
  require(priceLimit > 0, "priceLimit is 0");
  require(pot.USDC >= budget, "budget is not in the Pot");
  const kept = pot.USDC - budget; // the Pot's other USDC, never spent
  const boughtBefore = recipient.WETH;

  // priceLimit as a pool's sqrt price (token1 per token0, times 2^96): where a unit costs it.
  let limit = Math.sqrt(Math.mulDiv(priceLimit, 1 << 192, 10 ** 18));
  if (USDC < WETH) {
    limit = Math.sqrt(Math.mulDiv(1 << 192, 10 ** 18, priceLimit));
  }

  // The loops only find pools; trade() decides and swaps. Each walks the tick spacings, fee
  // tiers or keys `sauce pools --chain base USDC WETH` listed for the pair, CLFactory first.
  for (const spacing of [1, 10, 50, 100, 200, 2000]) {
    const pool = AerodromeSlipstream.CLFactory.getPool(USDC, WETH, spacing);
    trade(1, pool, 0, kept, limit, recipient);
  }
  for (const fee of [100, 200, 300, 400, 500, 3000, 10000]) {
    const pool = UniswapV3.Factory.getPool(USDC, WETH, fee);
    trade(0, pool, 0, kept, limit, recipient);
  }
  for (const fee of [100, 500, 2500, 10000]) {
    const pool = PancakeswapV3.Factory.getPool(USDC, WETH, fee);
    trade(3, pool, 0, kept, limit, recipient);
  }
  for (const spacing of [1, 10, 50]) {
    const pool = AerodromeSlipstream.CLFactoryGaugesV3.getPool(USDC, WETH, spacing);
    trade(1, pool, 0, kept, limit, recipient);
  }
  for (const spacing of [50, 500]) {
    const pool = AerodromeSlipstream.CLFactoryGaugeCaps.getPool(USDC, WETH, spacing);
    trade(1, pool, 0, kept, limit, recipient);
  }
  // Uniswap V4, hookless. A pool is its id, the hash of its key with the pair in address order:
  // 256 bits, so a Uint256, never an Address. The keys are the `Uniswap V4 key …` rows that
  // `sauce pools` listed with liquidity.
  const low = USDC < WETH ? USDC : WETH;
  const high = USDC < WETH ? WETH : USDC;
  for (const key of [
    { fee: 500, spacing: 10 },
    { fee: 3000, spacing: 60 },
  ]) {
    const id = crypto.keccak256(abi.encode(low, high, key.fee, key.spacing, 0));
    trade(2, id, key.spacing, kept, limit, recipient);
  }

  // Settle: what arrived at the recipient, the budget the limits left, and the two checks.
  const bought = recipient.WETH - boughtBefore;
  const unspent = pot.USDC - kept;
  const spent = budget - unspent;
  require(bought >= minTokens, "bought below minTokens");
  require(maxAvgPrice == 0 || spent * 10 ** 18 <= maxAvgPrice * bought, "average too high");
  if (unspent > 0) {
    USDC.transfer(recipient, unspent);
  }
  return { spent, bought, unspent };
}