Errors and reverts

// Reverts unless `amount` is at least 10, then throws for every amount.
//
//   sauce simulate minimum.sauce.ts --chain base --owner <address> --args <amount>
//
//   amount: Uint256   any number
function main(amount: Uint256) {
  require(amount >= 10, "below the minimum");
  throw "unreachable for a >= 10";
}

function main(amount: Uint256) {
  if (amount == 0) {
    throw "zero amount";
  }
  if (amount > 1000000000) {
    revert(amount.toBytesBe(32));
  }
}

// Pays `to` 1 USDC, then tries to pay `amount` more while keeping `reserve` in the Pot.
// Returns 2 when both payments stand, or 1000 times `stage` plus the error's length when the
// second payment is rolled back.
//
//   sauce simulate try-catch.sauce.ts --chain base --owner <address> \
//     --args <to> <amount> <reserve>
//
//   to: Address        the recipient
//   amount: Uint256    the second payment, in USDC's smallest unit (6 decimals): 4000000 is 4 USDC
//   reserve: Uint256   the USDC the Pot must keep, in the smallest unit
function main(to: Address, amount: Uint256, reserve: Uint256): Uint256 {
  USDC.transfer(to, 1000000);
  let stage = 1;
  try {
    stage = 2;
    USDC.transfer(to, amount);
    require(pot.USDC >= reserve, "reserve too low");
  } catch (error) {
    return stage * 1000 + error.length;
  }
  return stage;
}

// The first four bytes of the revert data when `query`, sent to `target` as a static call,
// reverts; 0 when it succeeds or reverts with fewer than four bytes.
function main(target: Address, query: bytes): Uint256 {
  require(ctx.isContract(target), "no contract");
  let selector = 0;
  try {
    evm.static(target, query);
  } catch (error) {
    if (error.length >= 4) {
      selector = error.slice(0, 4).toBe();
    }
  }
  return selector;
}

function main(amount: Uint256) {
  try {
    require(amount > 0, "zero");
  } catch (e) {
    log("caught");
  }
  log("done");
}

// A Uniswap V3 pool's sqrt price, or 0 when the read fails.
//
//   sauce simulate try-read.sauce.ts --chain base --owner <address> --args <pool>
//
//   pool: Address   a Uniswap V3 pool
function main(pool: Address): Uint256 {
  let price = 0;
  try {
    price = UniswapV3.Pool(pool).slot0().sqrtPriceX96;
  } catch {
    price = 0;
  }
  return price;
}

// Supplies `amount` of the Pot's USDC to Aave V3; returns 1 when the supply runs, 0 when it fails.
//
//   sauce simulate catch-statement.sauce.ts --chain base --owner <address> --args <amount>
//
//   amount: Uint256   in USDC's smallest unit (6 decimals): 5000000 is 5 USDC
function main(amount: Uint256): Uint256 {
  let supplied = 1;
  USDC.approve(AaveV3.Pool, amount);
  AaveV3.Pool.supply(USDC, amount, pot, 0).catch(() => {
    supplied = 0;
  });
  return supplied;
}

function main(amount: Uint256): Uint256 {
  let size = 0;
  USDC.approve(AaveV3.Pool, amount);
  AaveV3.Pool.supply(USDC, amount, pot, 0).catch((error) => {
    size = error.length;
  });
  return size;
}

// Uniswap V3 `liquidity()` read on the chain's USDC contract, which has no such function, so the
// call reverts and the read gives 7.
//
//   sauce simulate catch-value.sauce.ts --chain base --owner <address>
function main(): Uint256 {
  const liquidity = UniswapV3.Pool(USDC).liquidity().catch(() => {
    return 7;
  });
  return liquidity;
}

function main(target: Address): Uint256 {
  const liquidity = UniswapV3.Pool(target).liquidity().catch(() => {
    return 7;
  });
  return liquidity;
}

function main(program: Account, target: Account) {
  require(target.owner == program.address, "target is not the program's account");
  require(target.dataLen > 0, "target holds no data");
  svm.call(program, [target], hex`00`);
}

import { tryUniswapV2 } from "@sauce/router";

// Swaps `amountIn` USDC for WETH at one Uniswap V2 pair, or returns 0 with nothing moved when
// `pair` has no code (such as the zero address a factory returns for a missing pair) or cannot
// give at least `minOut`.
//
//   sauce simulate try-swap.sauce.ts --chain base --owner <address> \
//     --assume-balance USDC:<amount> --args <pair> <amountIn> <minOut>
//
//   pair: Address        a Uniswap V2 pair for USDC and WETH
//   amountIn: Uint256    the USDC to sell, in its smallest unit (6 decimals): 1000000000 is 1,000
//   minOut: Uint256      the least WETH to accept, in its smallest unit (18 decimals)
function main(pair: Address, amountIn: Uint256, minOut: Uint256): Uint256 {
  return tryUniswapV2(pair, USDC, WETH, amountIn, 0, minOut, pot);
}

function half(x: Uint256): Uint256 {
  return x / 2;
}

function pick(flag: bool, amount: Uint256): Uint256 {
  if (flag) {
    return amount;
  }
  return 0;
}

function larger(a: Uint256, b: Uint256): Uint256 {
  if (a > b) {
    return a;
  }
  return b;
}

function main(pool: Address, useAmount: bool, amount: Uint256, delta: Int256): Uint256 {
  const order = { amount: amount, fee: 30 };
  const signed = Int256(amount) + delta;
  const liquidity = UniswapV3.Pool(pool).liquidity();
  return pick(useAmount, larger(half(order.amount), order.fee)) + Uint256(signed) + liquidity;
}