Buy the dip: buy WETH when ETH falls below a reference

// Buys WETH with `tranche` of the Pot's USDC when ETH has fallen at least `dipBps` from
// `reference`. It reads Chainlink's ETH/USD feed and computes the signed change from `reference`
// in basis points. At or below `dipBps` it buys on Uniswap V3's 0.05% WETH/USDC pool, stopping at
// the pool price where one WETH, fee included, costs `priceLimit`. Otherwise it buys nothing and
// returns normally, as it does when the pool is above `priceLimit` or the Pot holds less than a
// tranche. The cook reverts on a feed answer older than `maxAge` seconds, a non-positive answer,
// a missing pool, or an average price paid above `priceLimit`. The WETH stays in the Pot.
//
//   sauce simulate buy-the-dip.sauce.ts --chain ethereum --owner <address> \
//     --assume-balance USDC:<tranche>n --args <reference> <dipBps> <maxAge> <tranche> <priceLimit>
//   sauce run buy-the-dip.sauce.ts --chain ethereum --wallet <name> \
//     --args <reference> <dipBps> <maxAge> <tranche> <priceLimit>
//
//   reference: Uint256   the ETH price to measure the dip from, in the feed's units (USD, 8
//                        decimals): 250000000000 is 2,500 USD
//   dipBps: Int256       the change that triggers a buy, in hundredths of a percent, negative:
//                        -300 buys once ETH is 3% or more below `reference`
//   maxAge: Uint256      the oldest feed answer to act on, in seconds: 3600 is one hour
//   tranche: Uint256     the USDC to spend, in USDC base units (6 decimals): 250000000 is 250 USDC
//   priceLimit: Uint256  the most one WETH may cost, fee included, in USDC base units:
//                        2500000000 is 2,500 USDC
//
// On Ethereum, spend 250 USDC once ETH is 3% below 2,500 USD, paying at most 2,500 USDC per WETH:
//
//   sauce run buy-the-dip.sauce.ts --chain ethereum --wallet me \
//     --args 250000000000 -300 3600 250000000 2500000000
import { uniswapV3 } from "@sauce/router";

function main(
  reference: Uint256,
  dipBps: Int256,
  maxAge: Uint256,
  tranche: Uint256,
  priceLimit: Uint256,
): { change: Int256; spent: Uint256; bought: Uint256 } {
  require(reference > 0 && tranche > 0 && priceLimit > 0, "set reference, tranche, priceLimit");
  require(dipBps < 0, "dipBps must be negative");
  const round = Chainlink.EthUsdFeed.latestRoundData();
  require(round.answer > 0, "no price");
  require(ctx.timestamp() - round.updatedAt <= maxAge, "the price is stale");

  // answer is Int256 and reference is Uint256: Int256(reference) is a checked conversion, and the
  // subtraction, multiplication and division are signed. Both prices have 8 decimals, so the
  // change is in basis points; division truncates toward zero.
  const ref = Int256(reference);
  const change = ((round.answer - ref) * 10000) / ref;
  if (change > dipBps) {
    return { change, spent: 0, bought: 0 };
  }

  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;
  if (Math.mulDiv(price, 1000000, 1000000 - fee) > priceLimit || usdcBefore < tranche) {
    return { change, spent: 0, bought: 0 };
  }

  // The pool price at which WETH, fee included, costs exactly priceLimit, as a sqrt price.
  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));
  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 { change, spent, bought };
}