Builtins

// Runs on every chain.
function main(out: Uint256, minOut: Uint256, code: Uint256) {
  require(out >= minOut, "slippage");
  if (code == 1) {
    throw "below floor";
  }
  if (code == 2) {
    revert(code.toBytesBe(32));
  }
  log(out.toBytesLe(8));
}

// Runs the compiled program `inner` with one argument and returns its result.
function main(inner: bytes, amount: Uint256): bytes {
  return eval(inner, amount);
}

function main(to: Address, amount: Uint256) {
  const paid = crypto.keccak256("Paid(address,uint256)");
  log(amount.toBytesBe(32), paid, to);
}

// Moves `amount` USDC to `to` and checks it against `limit` in one atomic block.
function main(to: Address, amount: Uint256, limit: Uint256): Uint256 {
  let stage = 1;
  try {
    stage = 2;
    USDC.transfer(to, amount);
    require(amount <= limit, "over limit");
  } catch (error) {
    return stage * 1000 + error.length;
  }
  return stage;
}

// Divides `delta` by 2 in a separate program and returns that program's result.
function main(delta: Int256): bytes {
  const nested = program((divisor: Int256): Int256 => delta / divisor, 2);
  return eval(nested.code.concat(nested.args));
}

// Pays nothing; reads the context on every chain.
function main(deadline: Uint256, vault: Account): Uint256 {
  require(ctx.timestamp() <= deadline, "expired");
  log(ctx.self().toBytesBe(32));
  return ctx.balance(vault.address) + ctx.selfBalance() + ctx.blockNumber() + ctx.chainId();
}

// Guards a program on the chain's base fee, the target's code and the value sent.
function main(token: Address, maxBaseFee: Uint256): Uint256 {
  require(ctx.codeSize(token) > 0, "no code at token");
  require(ctx.isContract(token), "not a contract");
  require(ctx.baseFee() <= maxBaseFee, "base fee too high");
  require(ctx.msgValue() == 0, "no value expected");
  require(ctx.msgSender() == ctx.txOrigin(), "called through a contract");
  return ctx.blockHash(ctx.blockNumber() - 1) + ctx.gasLeft();
}

function main(programId: Address, user: Address, digest: Uint256, sig: bytes): Uint256 {
  require(crypto.ecdsaVerify(digest, sig, user), "bad signature");
  const [vault, bump] = crypto.findPDA(programId, [hex`01`, "vault", user.toBytesBe(32)]);
  return vault + bump + crypto.keccak256("Transfer(address,address,uint256)");
}

// A fee in basis points, a square root, and a pool tick read from a raw 24-bit word.
function main(amount: Uint256, bps: Uint256, rawTick: Uint256): Int256 {
  const fee = Math.mulDiv(amount, bps, 10000);
  const root = Math.sqrt(amount);
  const tick = Math.signExtend(rawTick, 2);
  if (tick < 0) {
    return tick / 2 + Int256(Math.addMod(fee, root, 7));
  }
  return tick + Int256(Math.mulMod(fee, root, 7));
}

// Adds a signed `delta` to `amount`; reverts when `amount` is above 2²⁵⁵ − 1.
function main(amount: Uint256, delta: Int256): Int256 {
  return Int256(amount) + delta;
}

function main(total: Uint256, recipient: Address, data: bytes): bytes {
  const [amount, to] = abi.decode(data, ["Uint256", "Address"]);
  require(amount <= total, "over total");
  return abi.encode(amount, to, total);
}

// Wraps native coin into a wrapped-native contract, then reads that contract's total supply.
function main(wrapped: Address, amount: Uint256): Uint256 {
  evm.call(wrapped, amount, hex`d0e30db0`);
  const supply = evm.static(wrapped, hex`18160ddd`);
  return abi.decode(supply, ["Uint256"])[0];
}

// Returns 1 if USDC's totalSupply() answers within `cap` gas, and 0 if that call fails.
function main(cap: Uint256): Uint256 {
  let ok = 1;
  evm.static(USDC, hex`18160ddd`, cap).catch(() => {
    ok = 0;
  });
  return ok;
}

// Counts runs in the Pot's storage, and flags re-entry in transient storage.
function main(slot: Uint256, key: Uint256): Uint256 {
  require(evm.tload(key) == 0, "re-entered");
  evm.tstore(key, 1);
  const count = evm.sload(slot) + 1;
  evm.sstore(slot, count);
  evm.tstore(key, 0);
  return count;
}

function main(initcode: bytes, salt: Uint256, nonce: Uint256): Address {
  const expected = evm.create2Address(pot, salt, crypto.keccak256(initcode));
  const deployed = evm.create2(initcode, salt);
  require(deployed == expected, "create2");
  require(evm.create3Address(salt + 1) != expected, "create3");
  require(evm.createAddress(pot, nonce) != expected, "create");
  return deployed;
}

// Reads a counter from the first 8 bytes of `state` and writes it back increased by `step`.
function main(state: Account<Writable, Signer>, step: Uint256) {
  require(state.dataLen >= 8, "state too small");
  const count = svm.sload(state, 0, 8).toLe();
  const next = count + step;
  svm.sstore(state, 0, next.toBytesLe(8));
}

// Invokes a program with three accounts and the instruction data given as an argument.
function main(
  tokenProgram: Account,
  source: Account<Writable>,
  destination: Account<Writable>,
  owner: Account<Signer>,
  instruction: bytes,
): bytes {
  return svm.call(tokenProgram, [source, destination, owner], instruction);
}

// Forwards every account attached after `router` to the router program.
function main(router: Account, data: bytes): bytes {
  const first = svm.remainingAccount(0);
  require(first != router, "first extra account is the router");
  const rest = svm.remainingAccounts();
  return svm.call(router, rest, data);
}

// Rebuilds a transfer call's data from a call's input.
function main(input: bytes, to: Uint256, amount: Uint256): bytes {
  const selector = input.slice(0, 4);
  const first = input.slice(4, 36).toBe();
  const second = input.slice(36, 44).toLe();
  require(first + second + input.length > 0, "empty");
  return selector.concat(to.toBytesBe(32), amount.toBytesBe(32), amount.toBytesLe(8));
}

function main(amounts: Uint256[]): Uint256 {
  let total = 0;
  for (let i = 0; i < amounts.length; i++) {
    total += amounts[i];
  }
  return total;
}

function main(a: Account, b: Account, expected: Uint256) {
  require(a != b, "same account");
  require(a.address == expected, "wrong account");
}

// Checks that `mint` is owned by the token program and is 82 bytes, an SPL Token mint with no extensions.
function main(mint: Account, tokenProgram: Account) {
  require(mint.owner == tokenProgram.address, "not owned by the token program");
  require(mint.dataLen == 82, "not a mint");
}

function main(n: Uint256, x: Uint256): Int256 {
  const xs = new Array(n);
  xs[0] = x;
  const tag = hex`0xdeadbeef`;
  const negative = -Int256(x);
  return negative + Int256(xs[0] + tag.length);
}

[
  {
    "type": "function",
    "name": "count",
    "stateMutability": "view",
    "inputs": [],
    "outputs": [{ "name": "", "type": "uint256" }]
  },
  {
    "type": "function",
    "name": "add",
    "stateMutability": "nonpayable",
    "inputs": [{ "name": "n", "type": "uint256" }],
    "outputs": []
  }
]

import Counter from "./Counter.json";

function main(counter: Address, impl: Address, n: Uint256): Uint256 {
  const c = Counter.at(counter);
  c.add(n);
  const before = Counter.view(counter).count();
  Counter.lib(impl).add(n);
  return before + c.count();
}

// Reads the Pot's USDC balance with at most `cap` gas forwarded; 0 if that read fails.
function main(cap: Uint256): Uint256 {
  return USDC.balanceOf(pot).gas(cap).catch(() => {
    return 0;
  });
}

import Counter from "./Counter.json";

function main(counter: Address, n: Uint256): Uint256 {
  let errorLength = 0;
  Counter.at(counter).add(n).catch((error) => {
    errorLength = error.length;
  });
  const current = Counter.at(counter).count().catch(() => {
    return 0;
  });
  return errorLength + current;
}

// Pays `amount` of USDC from the Pot to `to`, after checking the Pot holds it.
function main(to: Address, amount: Uint256): Uint256 {
  require(balanceOf(USDC, pot) >= amount, "not enough USDC");
  transfer(USDC, to, amount);
  return decimals(USDC);
}

// Returns a token account's USDC balance and the account's owner.
function main(account: Account): { balance: Uint256; owner: Address } {
  return { balance: balanceOf(USDC, account), owner: ownerOf(USDC, account) };
}

function main(token: Address, tokenA: Address, tokenB: Address, to: Address, amount: Uint256) {
  if (UniswapV3.Factory) {
    const pool = UniswapV3.Factory.getPool(tokenA, tokenB, 500);
    require(pool != 0, "no 0.05% pool");
  }
  require(pot.USDC >= amount, "not enough USDC");
  const t = Token(token);
  t.transfer(to, amount);
}