Layout of a program

// Pays each of `recipients` `amount` of the chain's USDC, from the Pot.
//
//   sauce run payout.sauce.ts --chain <chain> --wallet <name> \
//     --args <recipients> <amount>
//
//   recipients: Address[]  who is paid, as a JSON array: '["<address>","<address>"]'
//   amount: Uint256        what each is paid, in USDC's smallest unit (6 decimals):
//                          5000000 is 5 USDC
//
// On Base, 5 USDC to each of two recipients:
//
//   sauce run payout.sauce.ts --chain base --wallet <name> \
//     --args '["<address>","<address>"]' 5000000
function main(recipients: Address[], amount: Uint256) {
  for (const to of recipients) {
    USDC.transfer(to, amount);
  }
}

// The Uniswap V3 WETH/USDC pool at the 0.05% fee tier (500 millionths), or 0 where there is none.
//
//   sauce simulate pool-address.sauce.ts --chain base --owner <address>
function main(): Address {
  return UniswapV3.Factory.getPool(WETH, USDC, 500);
}

// Supplies the Pot's whole USDC balance to Aave V3 for the Pot, so the aTokens stay in the
// Pot until another cook moves them.
//
//   sauce run supply-all.sauce.ts --chain base --wallet <name>
const held = pot.USDC;
require(held >= 1000000, "below 1 USDC");
USDC.approve(AaveV3.Pool, held);
AaveV3.Pool.supply(USDC, held, pot, 0);

// Reverts unless 6 is over the limit the script passes to its helper.
function over(x: Uint256, limit: Uint256): bool {
  return x > limit;
}

const limit = 5;
require(over(6, limit), "no");

// The amount left after a 0.30% fee, in the token's smallest unit.
const FEE_BPS = 30;
const DENOMINATOR = 10000;
const KEEP = DENOMINATOR - FEE_BPS;

function main(amount: Uint256): Uint256 {
  return (amount * KEEP) / DENOMINATOR;
}

const FEES = [100, 500, 3000, 10000];

function main(): Uint256 {
  return FEES[2];
}

// Returns the fee tier at index `i` (0 to 3); an index past the end reverts.
function main(i: Uint256): Uint256 {
  const fees = [100, 500, 3000, 10000];
  return fees[i];
}

let calls = 0;

function bump(): void {
  calls = calls + 1;
}

function main(): Uint256 {
  bump();
  bump();
  return calls;
}

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

// Swaps `amountIn` USDC for WETH at one Uniswap V3 pool, with no price limit (the 0) and at
// least `minOut` WETH sent to the Pot.
function main(pool: Address, amountIn: Uint256, minOut: Uint256) {
  uniswapV3(pool, USDC, WETH, amountIn, 0, minOut, pot);
}

{ "fee": 30 }

import cfg from "./config.json" with { type: "json" };

function main(amount: Uint256): Uint256 {
  return (amount * cfg.fee) / 10000;
}

// The fee on an EVM chain: 30 basis points.
export function fee(amount: Uint256): Uint256 {
  return (amount * 30) / 10000;
}

// The fee on Solana: 25 basis points.
export function fee(amount: Uint256): Uint256 {
  return (amount * 25) / 10000;
}

import { fee } from "./fee.ts";

function main(amount: Uint256): Uint256 {
  return fee(amount);
}

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

function main(amount: Uint256, flag: bool): Uint256 {
  let total = 0;
  const limit: Uint256 = 100;
  if (flag) {
    total = half(amount);
  }
  return total < limit ? total : limit;
}

interface Order {
  amount: Uint256;
  to: Address;
}

function pay(order: Order): void {
  USDC.transfer(order.to, order.amount);
}

function main(orders: Order[], extra: { amount: Uint256, to: Address }) {
  for (const order of orders) {
    pay(order);
  }
  pay(extra);
}