Swap WETH, then pay a USDC invoice

// Settles an invoice priced in USDC from the Pot's WETH: sells `amountIn` WETH on Uniswap V3's
// 0.05% WETH/USDC pool, down to the price floor `sqrtPriceLimitX96`, pays exactly `due` USDC to
// `payee`, and sends the USDC above `due` and any WETH the pool did not take to `refundTo`. The
// cook reverts, and nothing moves, when `amountIn` or `due` is zero, `payee` or `refundTo` is the
// zero address, the Pot holds less than `amountIn` WETH, the swap returns less than `due` USDC,
// or the payee receives a different amount.
//
//   sauce simulate swap-then-pay.sauce.ts --chain base --owner <address> \
//     --assume-balance WETH:<amountIn>n \
//     --args <amountIn> <sqrtPriceLimitX96> <due> <payee> <refundTo>
//   sauce run swap-then-pay.sauce.ts --chain base --wallet <name> --fund WETH:<amountIn>n \
//     --args <amountIn> <sqrtPriceLimitX96> <due> <payee> <refundTo>
//
//   amountIn: Uint256           the WETH to sell, in wei (18 decimals): 500000000000000000 is
//                               0.5 WETH
//   sqrtPriceLimitX96: Uint256  the lowest pool price the swap may reach, as a sqrtPriceX96; WETH
//                               sorts before USDC on Base, so it is a floor. `sauce price --chain
//                               base 2200 USDC per WETH` prints it (Selling WETH). 0 sets no floor
//   due: Uint256                the invoice, in USDC's base units (6 decimals): 1000000000 is
//                               1,000 USDC
//   payee: Address              who the invoice is paid to
//   refundTo: Address           who receives the USDC above `due` and the unsold WETH
//
// On Base, sell 0.5 WETH with a floor of 2,200 USDC per WETH and pay a 1,000 USDC invoice to <payee>:
//
//   sauce run swap-then-pay.sauce.ts --chain base --wallet me --fund WETH:0.5 \
//     --args 500000000000000000 3716130220787573219086287 1000000000 \
//     <payee> <refundTo>
import { uniswapV3 } from "@sauce/router";

function main(
  amountIn: Uint256,
  sqrtPriceLimitX96: Uint256,
  due: Uint256,
  payee: Address,
  refundTo: Address,
): { received: Uint256; paid: Uint256; changeUsdc: Uint256; changeWeth: Uint256 } {
  require(amountIn > 0 && due > 0, "amountIn or due is zero");
  require(payee != 0 && refundTo != 0, "no payee or no refund address");
  require(WETH.balanceOf(pot) >= amountIn, "not enough WETH in the Pot");

  // Swap into the Pot and measure both sides: with a floor, the pool may take less than amountIn.
  const pool = UniswapV3.Factory.getPool(WETH, USDC, 500);
  const wethBefore = WETH.balanceOf(pot);
  const usdcBefore = USDC.balanceOf(pot);
  uniswapV3(pool, WETH, USDC, amountIn, sqrtPriceLimitX96, 0, pot);
  const sold = wethBefore - WETH.balanceOf(pot);
  const received = USDC.balanceOf(pot) - usdcBefore;
  require(received >= due, "the swap returned less USDC than due");

  // Pay the invoice exactly, measured at the payee.
  const payeeBefore = USDC.balanceOf(payee);
  USDC.transfer(payee, due);
  const paid = USDC.balanceOf(payee) - payeeBefore;
  require(paid == due, "the payee received a different amount");

  // Return the change: USDC above the invoice, and WETH the pool did not take.
  const changeUsdc = received - due;
  const changeWeth = amountIn - sold;
  if (changeUsdc > 0) {
    USDC.transfer(refundTo, changeUsdc);
  }
  if (changeWeth > 0) {
    WETH.transfer(refundTo, changeWeth);
  }

  return { received, paid, changeUsdc, changeWeth };
}