Stop-loss and take-profit on an oracle price

// A stop-loss and take-profit on the Pot's WETH, meant to run on a schedule. It reads Chainlink's
// ETH/USD feed and, when the price is at or below `stop` or at or above `takeProfit`, sells the
// Pot's WETH for USDC on Uniswap V3's 0.05% WETH/USDC pool. The swap stops at the pool price where
// a unit, after the pool fee, fetches the oracle price less `maxSlippageBps`; WETH the pool cannot
// take at that price stays in the Pot. Between the two thresholds it sells nothing and returns
// normally. The cook reverts on a feed answer older than `maxAge` seconds, a non-positive answer,
// or an average sale price below that floor. The USDC stays in the Pot.
//
//   sauce simulate stop-loss.sauce.ts --chain ethereum --owner <address> \
//     --assume-balance WETH:<whole-tokens> --args <stop> <takeProfit> <maxSlippageBps> <maxAge>
//   sauce run stop-loss.sauce.ts --chain ethereum --wallet <name> \
//     --args <stop> <takeProfit> <maxSlippageBps> <maxAge>
//
//   stop: Uint256            sell at or below this ETH price, in the feed's units (USD, 8
//                            decimals): 240000000000 is 2,400 USD; 0 sets no stop
//   takeProfit: Uint256      sell at or above this ETH price, same units: 320000000000 is
//                            3,200 USD; 0 sets no take-profit
//   maxSlippageBps: Uint256  how far below the oracle price a unit may sell, fee included, in
//                            hundredths of a percent: 100 is 1%
//   maxAge: Uint256          the oldest feed answer to act on, in seconds: 3600 is one hour
//
// On Ethereum, sell below 2,400 USD or above 3,200 USD, within 1% of the oracle:
//
//   sauce run stop-loss.sauce.ts --chain ethereum --wallet me \
//     --args 240000000000 320000000000 100 3600
import { uniswapV3 } from "@sauce/router";

function main(
  stop: Uint256,
  takeProfit: Uint256,
  maxSlippageBps: Uint256,
  maxAge: Uint256,
): { price: Uint256; triggered: bool; sold: Uint256; received: Uint256 } {
  require(maxSlippageBps < 10000, "maxSlippageBps is 100% or more");
  const round = Chainlink.EthUsdFeed.latestRoundData();
  // The feed's answer is a signed Int256. Reject zero and negative answers, then convert once:
  // Uint256() is checked, and the unsigned math below (mulDiv) refuses a negative Int256.
  require(round.answer > 0, "no price");
  const price = Uint256(round.answer); // USD per ETH, 8 decimals
  require(ctx.timestamp() - round.updatedAt <= maxAge, "the price is stale");

  const triggered = (stop > 0 && price <= stop) || (takeProfit > 0 && price >= takeProfit);
  const held = pot.WETH;
  if (!triggered || held == 0) {
    return { price, triggered, sold: 0, received: 0 };
  }

  // The least one WETH may fetch, in USDC base units: the feed's 8 decimals become USDC's 6.
  const floor = Math.mulDiv(price, 10000 - maxSlippageBps, 10000 * 100);
  const pool = UniswapV3.Factory.getPool(WETH, USDC, 500);
  require(pool != 0, "no WETH/USDC pool at 0.05%");
  // `floor` as the pool's sqrt price (token1 per token0, x 2^96), moved by sqrt(1 - fee) so the
  // last unit sold fetches `floor` after the fee. Selling token0 pushes the price down, selling
  // token1 pushes it up: the swap stops at the limit either way. `root` is sqrt(1 - fee) x 1e18.
  const root = Math.sqrt((1000000 - UniswapV3.Pool(pool).fee()) * 10 ** 30);
  const wethIs0 = WETH < USDC;
  const limit = wethIs0
    ? Math.mulDiv(Math.sqrt(Math.mulDiv(floor, 1 << 192, 10 ** 18)), 10 ** 18, root)
    : Math.mulDiv(Math.sqrt(Math.mulDiv(1 << 192, 10 ** 18, floor)), root, 10 ** 18);
  // A pool already past the limit has no unit to sell at the floor: nothing sells this run.
  const now = UniswapV3.Pool(pool).slot0().sqrtPriceX96;
  if (wethIs0 ? now <= limit : now >= limit) {
    return { price, triggered, sold: 0, received: 0 };
  }

  // The limit decides how much sells, so no minimum output is known before the swap. The
  // average is checked after it, from what the Pot's balances show moved.
  const usdcBefore = pot.USDC;
  uniswapV3(pool, WETH, USDC, held, limit, 0, pot);
  const sold = held - pot.WETH;
  const received = pot.USDC - usdcBefore;
  require(received >= Math.mulDiv(sold, floor, 10 ** 18), "sold below the floor");
  return { price, triggered, sold, received };
}