Contracts and ABIs

// Finds the chain's 0.05% WETH/USDC Uniswap V3 pool and returns its current sqrt price.
function main(): Uint256 {
  const pool = UniswapV3.Factory.getPool(WETH, USDC, 500);
  require(pool != 0, "no WETH/USDC 0.05% pool");
  const [sqrtPriceX96] = pool.slot0();
  require(pool.token0().decimals() > 0, "token0 has no decimals");
  return sqrtPriceX96;
}

// Calls `liquidity()` on `target` and discards the result.
function main(target: Address): Uint256 {
  UniswapV3.Pool(target).liquidity();
  return 1;
}

// Calls `liquidity()` on `target` and returns the result.
function main(target: Address): Uint256 {
  return UniswapV3.Pool(target).liquidity();
}

// Quotes selling `amountIn` WETH for USDC in the 0.05% Uniswap V3 pool, and returns the
// output and the number of initialized ticks the swap would cross.
function main(amountIn: Uint256): Uint256 {
  const [amountOut, sqrtPriceX96After, ticksCrossed] = UniswapV3.QuoterV2.quoteExactInputSingle({
    tokenIn: WETH,
    tokenOut: USDC,
    amountIn: amountIn,
    fee: 500,
    sqrtPriceLimitX96: 0,
  });
  require(sqrtPriceX96After > 0, "no price after the swap");
  return amountOut * 1000 + ticksCrossed;
}

// The USDC out of selling `amountIn` WETH in the 0.05% pool.
function main(amountIn: Uint256): Uint256 {
  return UniswapV3.QuoterV2.quoteExactInputSingle({
    tokenIn: WETH,
    tokenOut: USDC,
    amountIn: amountIn,
    fee: 500,
    sqrtPriceLimitX96: 0,
  }).amountOut;
}

// Reads `pool`'s liquidity, giving the call at most `gasCap` gas, and returns 0 when the call fails.
function main(pool: Address, gasCap: Uint256): Uint256 {
  return UniswapV3.Pool(pool).liquidity().gas(gasCap).catch(() => {
    return 0;
  });
}

// Supplies `amount` of the Pot's USDC to Aave V3 for `onBehalfOf`, who receives the aTokens:
// a wallet, or the Pot itself (`pot`).
function main(onBehalfOf: Address, amount: Uint256) {
  USDC.approve(AaveV3.Pool, amount);
  AaveV3.Pool.supply(USDC, amount, onBehalfOf, 0);
}

// Deposits `assets` of an ERC-4626 vault's asset from the Pot; `receiver` gets the shares.
function main(vault: Address, assets: Uint256, receiver: Address): Uint256 {
  const asset = Erc4626.Vault(vault).asset();
  asset.approve(vault, assets);
  return Erc4626.Vault(vault).deposit(assets, receiver);
}

// Reads a Chainlink price feed passed as an argument, and reverts when its answer is not positive
// or older than `maxAge` seconds.
import AggregatorV3ABI from "./protocols/chainlink/AggregatorV3ABI.json";

function main(feed: Address, maxAge: Uint256): Uint256 {
  const round = AggregatorV3ABI.at(feed).latestRoundData();
  require(round.answer > 0, "negative or zero answer");
  require(ctx.timestamp() - round.updatedAt <= maxAge, "stale answer");
  return Uint256(round.answer);
}

[
  {
    "type": "function",
    "name": "observe",
    "stateMutability": "view",
    "inputs": [{ "name": "secondsAgos", "type": "uint32[]" }],
    "outputs": [
      { "name": "tickCumulatives", "type": "int56[]" },
      { "name": "secondsPerLiquidityCumulativeX128s", "type": "uint160[]" }
    ]
  }
]

// Returns the average tick of a Uniswap V3 pool over the last `window` seconds.
import IOracle from "./IOracle.json";

function main(pool: Address, window: Uint256): Int256 {
  require(UniswapV3.Pool(pool).liquidity() > 0, "the pool has no liquidity");
  const [ticks] = IOracle.at(pool).observe([window, 0]);
  return (ticks[1] - ticks[0]) / Int256(window);
}

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

// Reads `who`'s balance of `token` through the raw ERC-20 ABI.
import { IERC20 as Erc20 } from "./artifacts/IERC20.json";

function main(token: Address, who: Address): Uint256 {
  return Erc20.at(token).balanceOf(who);
}

// Wraps `amount` wei of the Pot's ETH into WETH by calling WETH's payable deposit() with value,
// and returns the Pot's WETH balance.
function main(amount: Uint256): Uint256 {
  evm.call(WETH, amount, hex`d0e30db0`);
  return pot.WETH;
}