Dollar-cost averaging: one step of a buy plan

// One tick of a dollar-cost-averaging plan, meant to run on a schedule. It spends up to `tranche`
// of the Pot's USDC on WETH through Uniswap V3's 0.05% WETH/USDC pool, and only while one WETH
// costs at most `priceLimit` USDC, pool fee included. The swap stops at the pool price that
// corresponds to `priceLimit`, so a thin pool can fill part of the tranche; the rest stays in the
// Pot. Above the limit, or with less than `tranche` USDC in the Pot, the tick buys nothing and
// returns normally. It reverts when the pool does not exist or the average price paid exceeds
// `priceLimit`. The WETH stays in the Pot.
//
//   sauce simulate dca.sauce.ts --chain <chain> --owner <address> \
//     --assume-balance USDC:<tranche>n --args <tranche> <priceLimit>
//   sauce run dca.sauce.ts --chain <chain> --wallet <name> --args <tranche> <priceLimit>
//
//   tranche: Uint256     the USDC to spend in one tick, in USDC base units (6 decimals):
//                        250000000 is 250 USDC
//   priceLimit: Uint256  the most one WETH may cost, fee included, in USDC base units:
//                        2800000000 is 2,800 USDC
//
// On Base, spend 250 USDC while WETH costs at most 2,800 USDC:
//
//   sauce run dca.sauce.ts --chain base --wallet me --args 250000000 2800000000
import { uniswapV3 } from "@sauce/router";

function main(
  tranche: Uint256,
  priceLimit: Uint256,
): { price: Uint256; spent: Uint256; bought: Uint256 } {
  require(tranche > 0 && priceLimit > 0, "set tranche and priceLimit");
  const pool = UniswapV3.Factory.getPool(WETH, USDC, 500);
  require(pool != 0, "no WETH/USDC pool at 0.05%");
  const fee = UniswapV3.Pool(pool).fee();

  // The pool's price in USDC base units per WETH, from its sqrt price (token1 per token0, x 2^96).
  const sqrtPriceX96 = UniswapV3.Pool(pool).slot0().sqrtPriceX96;
  const ratio = Math.mulDiv(sqrtPriceX96, sqrtPriceX96, 1 << 96);
  const price =
    WETH < USDC ? Math.mulDiv(ratio, 10 ** 18, 1 << 96) : Math.mulDiv(10 ** 18, 1 << 96, ratio);
  const usdcBefore = pot.USDC;
  const wethBefore = pot.WETH;

  // Skip the tick: the price with the fee on top is above the limit, or the Pot holds too little.
  if (Math.mulDiv(price, 1000000, 1000000 - fee) > priceLimit || usdcBefore < tranche) {
    return { price, spent: 0, bought: 0 };
  }

  // The pool price at which WETH, fee included, costs exactly priceLimit, as a sqrt price. The
  // swap stops there. Paying token1 pushes the price up, paying token0 pushes it down.
  const atLimit = Math.mulDiv(priceLimit, 1000000 - fee, 1000000);
  const limit =
    WETH < USDC
      ? Math.sqrt(Math.mulDiv(atLimit, 1 << 192, 10 ** 18))
      : Math.sqrt(Math.mulDiv(1 << 192, 10 ** 18, atLimit));

  // The limit decides how much is bought, so no minimum output is known before the swap. The
  // average price is checked after it, from what the Pot's balances show moved.
  uniswapV3(pool, USDC, WETH, tranche, limit, 0, pot);
  const spent = usdcBefore - pot.USDC;
  const bought = pot.WETH - wethBefore;
  require(Math.mulDiv(bought, priceLimit, 10 ** 18) >= spent, "paid more than priceLimit");
  return { price, spent, bought };
}