Buy tokenized SpaceX stock under a price cap

// Buys SpaceX stock on Ethereum (SPCXon, Ondo's tokenized SpaceX, 18 decimals) with up to
// `budget` of the Pot's USDC, on the Uniswap V3 USDC/SPCXon pool, of the four fee tiers, whose
// share costs least with its fee paid. The swap stops where a share, fee included, costs
// `priceLimit`; the shares go to `recipient` and the USDC the pool did not take to `refundTo`.
// The cook reverts, and nothing moves, when no pool has liquidity, every pool is at or above
// `priceLimit`, or `recipient` receives fewer than `minShares`.
//
//   sauce simulate buy-tokenized-stock.sauce.ts --chain ethereum --owner <address> \
//     --assume-balance USDC:<budget>n \
//     --args <budget> <priceLimit> <minShares> <recipient> <refundTo>
//   sauce run buy-tokenized-stock.sauce.ts --chain ethereum --wallet <name> \
//     --fund USDC:<budget>n --args <budget> <priceLimit> <minShares> <recipient> <refundTo>
//
//   budget: Uint256      the most USDC to spend, in USDC base units (6 decimals): 5000000000 is
//                        5,000 USDC; the Pot must hold it
//   priceLimit: Uint256  the most one share may cost, fee included, in USDC base units:
//                        149400000 is 149.40 USDC
//   minShares: Uint256   the fewest shares `recipient` may receive, in SPCXon base units
//                        (18 decimals): 10000000000000000000 is 10 shares
//   recipient: Address   receives the shares
//   refundTo: Address    receives the USDC the pool did not take
//
// On Ethereum, up to 5,000 USDC of SPCXon at no more than 149.40 USDC a share, at least 10
// shares, the shares to <recipient> and the rest of the budget to <refundTo>:
//
//   sauce run buy-tokenized-stock.sauce.ts --chain ethereum --wallet me --fund USDC:5000 \
//     --args 5000000000 149400000 10000000000000000000 \
//     <recipient> <refundTo>
import { uniswapV3 } from "@sauce/router";

function main(
  budget: Uint256,
  priceLimit: Uint256,
  minShares: Uint256,
  recipient: Address,
  refundTo: Address,
): { fee: Uint256; spent: Uint256; shares: Uint256 } {
  require(budget > 0, "budget is 0");
  require(priceLimit > 0, "priceLimit is 0");
  const before = pot.USDC;
  require(before >= budget, "budget is not in the Pot");

  // Every fee tier: keep the pool with liquidity whose share, fee included, costs least.
  let pool: Address = 0;
  let fee: Uint256 = 0;
  let cheapest: Uint256 = 0;
  for (const tier of [100, 500, 3000, 10000]) {
    const candidate = UniswapV3.Factory.getPool(USDC, SPCXon, tier);
    if (candidate == 0 || UniswapV3.Pool(candidate).liquidity() == 0) {
      continue;
    }
    // A share's price in USDC base units, from the sqrt price (token1 per token0, times 2^96;
    // the lower address is token0), then with the pool's fee on top.
    const sqrtPriceX96 = UniswapV3.Pool(candidate).slot0().sqrtPriceX96;
    const ratio = Math.mulDiv(sqrtPriceX96, sqrtPriceX96, 1 << 96);
    const price =
      USDC < SPCXon
        ? Math.mulDiv(10 ** 18, 1 << 96, ratio)
        : Math.mulDiv(ratio, 10 ** 18, 1 << 96);
    const paid = Math.mulDiv(price, 1000000, 1000000 - tier);
    if (pool == 0 || paid < cheapest) {
      pool = candidate;
      fee = tier;
      cheapest = paid;
    }
  }
  require(pool != 0, "no USDC/SPCXon pool with liquidity");
  require(cheapest < priceLimit, "every pool is at or above priceLimit");

  // The pool price at which a share with the fee on top costs priceLimit, as a sqrt price: the
  // swap stops there. Paying token0 pushes the price down, paying token1 pushes it up.
  const atLimit = Math.mulDiv(priceLimit, 1000000 - fee, 1000000);
  const limit =
    USDC < SPCXon
      ? Math.sqrt(Math.mulDiv(1 << 192, 10 ** 18, atLimit))
      : Math.sqrt(Math.mulDiv(atLimit, 1 << 192, 10 ** 18));
  const sharesBefore = recipient.SPCXon;
  uniswapV3(pool, USDC, SPCXon, budget, limit, 0, recipient);
  const shares = recipient.SPCXon - sharesBefore;
  require(shares >= minShares, "fewer shares than minShares");

  // What the pool took; the rest of the budget goes back. The Pot's other USDC stays.
  const spent = before - pot.USDC;
  if (budget > spent) {
    USDC.transfer(refundTo, budget - spent);
  }
  return { fee, spent, shares };
}