Actions - Eco Docs

An actions document is an ordered list of protocol operations written as JSON: swap on a Uniswap V3 pool, approve a token, supply to Aave. @eco-incorp/sauce/actions validates a document and compiles it, for one chain, into one Sauce program that runs in a Pot in one transaction. Any language that writes JSON can produce one, and the package publishes the JSON Schema it is checked against. The same documents run from the command line with sauce actions, and sauce compile, simulate, tx and run take one wherever they take a program file.

The document

swap-supply.json

{
  "version": 1,
  "actions": [
    { "type": "argument", "name": "amount" },
    {
      "type": "uniswapV3Swap",
      "tokenIn": "USDC",
      "tokenOut": "WETH",
      "factory": "UniswapV3.Factory",
      "fee": 500,
      "amountOutMin": "1",
      "recipient": "pot",
      "saveOutputAs": "weth"
    },
    { "type": "approve", "token": "WETH", "spender": "AaveV3.Pool" },
    {
      "type": "aaveV3Supply",
      "pool": "AaveV3.Pool",
      "token": "WETH",
      "onBehalfOf": "pot",
      "amountRef": "weth"
    }
  ]
}

This takes an amount of USDC as a run-time argument, swaps it for WETH in the pool Uniswap V3’s factory keys at 0.05%, approves Aave’s pool for the WETH received, and supplies it with the Pot as the beneficiary.

Field	Type	Meaning
`version`	`1`	The format version.
`chainId`	integer, optional	The one chain the document is written for. Compiling it for another chain is refused. Leave it out and the document compiles for any chain where its names exist.
`actions`	array, at least one	The actions, in execution order. Each is an object whose `type` selects its fields.

A $schema key is allowed and ignored. Every action runs in one transaction on the chain the document is compiled for; a bridge’s destination is one of the bridge action’s own fields.

Values

Value	Encoding
Amounts, prices, fees, strategy ids	A base-10 string with no sign, exponent or leading zeros: `"1000000"`. A JSON number is refused.
Tokens (`tokenIn`, `token`, `path`, …)	A registry symbol (`"USDC"`) or an address; `"native"` where the venue trades the native coin itself.
Protocol contracts (`pool`, `vault`, `factory`, `spender`, …)	A namespace reference (`"UniswapV3.Factory"`, `"AaveV3.Pool"`) or an address.
Recipients on this chain (`recipient`, `onBehalfOf`, `owner`)	An address, or `"pot"` for the executing Pot.
Addresses	`0x` and 40 hex digits. Mixed case must be a valid EIP-55 checksum.
Fee tiers, indices, domains, Unix times	JSON integers.

Each amount must also fit the field it becomes; a value too wide for it is an error.

Names and addresses

A name lowers to the program global of that name, and the compile for a chain resolves it there, as it resolves USDC in a hand-written program. A document with only names and no chainId therefore compiles for every chain that has those names, each time to that chain’s addresses. An address means the same address on every chain, which suits a contract deployed at one address everywhere, such as Permit2. A document may mix names and addresses. A swap may name its pool by its factory’s key instead of its address: uniswapV2Swap by factory, uniswapV3Swap by factory with fee (or tickSpacing for Aerodrome Slipstream), traderJoeLBSwap by factory with binStep. The program reads the pool from the factory when it runs and reverts before anything moves if there is none.

Chaining outputs

An action that spends an amount takes it from, in order:

its own amount;
amountRef, the name of an output an earlier action saved with saveOutputAs;
otherwise, the previous action’s output.

Setting both amount and amountRef, naming an output no earlier action saved, or a first action with no amount is an error. Saving a second output under one name reassigns it. An action’s output is what it delivered to the Pot (received), the amount it spent (its amount), or, for balanceOf, nativeBalance and argument, the value read. When a later action spends an output, the action delivers it to the Pot whatever its recipient says; an output nothing spends goes to the action’s recipient. An argument action declares a run-time parameter: it becomes a Uint256 parameter of main, so one compiled program serves every amount, and the value travels as an ABI-v1 word after the bytecode.

parseProgram

Validates a document and returns a canonical copy.

Import

import { parseProgram } from "@eco-incorp/sauce/actions";

Usage

parse-errors.mts

import { ProgramError, compileProgram, parseProgram } from "@eco-incorp/sauce/actions";

// Two mistakes: a lower-case symbol, and an amount written as a JSON number.
try {
  parseProgram({
    version: 1,
    actions: [{ type: "transfer", token: "usdc", amount: 1000000, recipient: "pot" }],
  });
} catch (error) {
  if (!(error instanceof ProgramError)) throw error;
  for (const issue of error.issues) console.log(`${issue.path}: ${issue.message}`);
}

// A valid document whose name the chain lacks: refused for that chain, which `chain` names.
try {
  compileProgram(
    { version: 1, actions: [{ type: "approve", token: "USDC", spender: "AaveV3.Pool", amount: "1" }] },
    { chain: "kava" },
  );
} catch (error) {
  if (!(error instanceof ProgramError)) throw error;
  console.log(error.chain?.slug, error.issues.map((issue) => issue.path));
  console.log(error.message);
}

actions[0].token: expected a registry token symbol ("USDC") or an address (0x + 40 hex digits), got "usdc" — symbols are upper case: did you mean "USDC"?
actions[0].amount: expected a base-10 string, got the JSON number 1000000 — JSON numbers lose precision above 2^53, so amounts are strings: write "1000000"
kava [ 'actions[0].token', 'actions[0].spender' ]
the action program does not compile for Kava (kava, chain 2222) (2 issues):
  actions[0].token: no token "USDC" on Kava (chain 2222), which registers no token symbols — give its address there instead
  actions[0].spender: no "AaveV3.Pool" on Kava (chain 2222): AaveV3 is not deployed there (it is on ethereum, optimism, bsc, polygon, base, arbitrum, gnosis, fantom, metis, avalanche, scroll, monad) — give the contract's address there instead

Signature

export declare function parseProgram(input: unknown): ActionProgram;

Parameters

input: the document as JSON text, or an already-parsed value.

Returns

ActionProgram: a fresh copy with its keys in canonical order. It fills in nothing: an optional field left out stays out. Parsing checks how each name is spelled; whether a name exists is decided by the chain the document is compiled for.

Throws

ProgramError, listing every problem at once, each with its path.

serializeProgram

Writes a document as canonical JSON.

Import

import { serializeProgram } from "@eco-incorp/sauce/actions";

Usage

serialize.mts

import { parseProgram, serializeProgram, type ActionProgram } from "@eco-incorp/sauce/actions";

const program: ActionProgram = {
  actions: [{ recipient: "pot", token: "USDC", type: "transfer", amount: "1000000" }],
  version: 1,
};

const text = serializeProgram(program, 2); // validated, keys in schema order
console.log(text);
console.log(serializeProgram(parseProgram(text)) === serializeProgram(program));

{
  "version": 1,
  "actions": [
    {
      "type": "transfer",
      "amount": "1000000",
      "token": "USDC",
      "recipient": "pot"
    }
  ]
}
true

Signature

export declare function serializeProgram(program: ActionProgram, space?: number | string): string;

Parameters

program: the document.
space: indentation, as JSON.stringify takes it. Default none.

Returns

The canonical JSON text: two equal programs serialize to the same text, and parseProgram(serializeProgram(p)) equals p.

Throws

ProgramError when program is invalid; it is validated first.

programSchema

Returns the JSON Schema (draft 2020-12) every document satisfies.

Import

import { programSchema } from "@eco-incorp/sauce/actions";

The same schema ships as a file: @eco-incorp/sauce/actions/action-program.schema.json.

Usage

schema.mts

import { readFileSync } from "node:fs";
import { programSchema } from "@eco-incorp/sauce/actions";

const schema = programSchema();
console.log(schema.$schema, schema.$id, schema.required);

// The same document, as a file in the package, for a validator outside TypeScript.
const file = import.meta.resolve("@eco-incorp/sauce/actions/action-program.schema.json");
const onDisk = JSON.parse(readFileSync(new URL(file), "utf8"));
console.log(JSON.stringify(onDisk) === JSON.stringify(schema));

https://json-schema.org/draft/2020-12/schema urn:eco-incorp:sauce:action-program:1 [ 'version', 'actions' ]
true

Signature

export type JsonSchema = {
    readonly [key: string]: unknown;
};
export declare function programSchema(): JsonSchema;

Returns

The schema object. It is generated from the table the parser reads, so a document the schema rejects is always rejected by parseProgram. It marks which fields take a token ($defs/token, $defs/tokenOrNative), a protocol contract ($defs/contract) or either ($defs/tokenContract), and states each swap’s pool alternatives as a oneOf. The schema cannot express four rules that the parser and the compile enforce: EIP-55 checksums, exact numeric ranges (it bounds digit counts), the chaining rules, and whether a name exists on the chain being compiled for. Validate with the schema at the edge of your system, and parse before compiling.

compileProgram

Compiles a document for one chain into a program and its cook payload.

Import

import { compileProgram } from "@eco-incorp/sauce/actions";

Usage

compile-actions.mts

import { readFileSync } from "node:fs";
import { compileProgram, parseProgram } from "@eco-incorp/sauce/actions";

const program = parseProgram(readFileSync("swap-supply.json", "utf8"));
const compiled = compileProgram(program, { chain: "base" });

console.log(compiled.source);
console.log("parameters:", compiled.parameters);
console.log("bytecode:", compiled.bytecode.length, "bytes");

// The `program` argument of Pot.cook, for 1,000 USDC: bytecode, then the encoded `amount`.
const payload = compiled.payload({ amount: 1_000_000_000n });
console.log("payload:", payload.length, "bytes; amount at offset", compiled.argumentOffset("amount"));

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

function main(a_amount: Uint256): void {
  let t_out0 = a_amount;
  const pool0 = UniswapV3.Factory.getPool(USDC, WETH, 500);
  require(pool0 != 0, "actions[1]: no pool under that key");
  const amt1 = uniswapV3(pool0, USDC, WETH, t_out0, 0, 1, pot);
  let v_weth = amt1;
  // … 17 lines: WETH's allowance for AaveV3.Pool read, reset to zero if set, then set to v_weth,
  // each write checked as SafeERC20 checks it …
  IAaveV3Pool.at(AaveV3.Pool).supply(WETH, v_weth, pot, 0);
}

parameters: [ 'amount' ]
bytecode: 895 bytes
payload: 927 bytes; amount at offset 895

The swap is a call into @sauce/router, the same library a hand-written program calls. The lowered program names the Pot pot and its native balance pot.balance, as a hand-written one does; a split swap compiled with no chain writes ctx.self(). Every other action is an ABI-bound call, IBinding.at(address).method(...), with the registry’s ABI wherever the registry declares the exact function. Reading any part of a bound call’s result decodes all its declared outputs; a result the program discards is neither decoded nor checked. ERC-20 transfer and approve are checked writes with OpenZeppelin SafeERC20 semantics. A call that carries native value (wrapETH, the staking deposits, the bridge fees) is a raw evm.call.

Signature

export declare function compileProgram(program: ActionProgram, options?: CompileOptions): CompiledProgram;

export interface CompileOptions {
    readonly chain?: ChainRef;
}

export interface CompiledProgram {
    readonly bytecode: Uint8Array;
    readonly source: string;
    readonly contracts: ActionContracts;
    readonly parameters: readonly string[];
    readonly entryEncoding: "abi-v1";
    payload(values?: ArgumentValues): Uint8Array;
    argumentOffset(name: string): number;
}

export type ArgumentValues = Readonly<Record<string, bigint | number | string>>;

Parameters

program: the document. It is validated again, so a typed document that skipped parseProgram is held to the same rules.
options.chain: the chain to compile for, a slug ("base"), a chain id (8453) or a CanonicalChain. Defaults to the document’s chainId; a document without one needs it.

Returns

CompiledProgram:

bytecode: the compiled program.
source: the SauceScript the document lowered to, with every name as written.
contracts: the ABI bindings source calls through.
parameters: the argument names, in the order main takes them.
entryEncoding: always "abi-v1", the only argument encoding.
payload(values?): the bytecode followed by the encoded arguments, by name: the program a Pot’s cook(engine, program) takes (Cook transactions).
argumentOffset(name): where argument name’s 32-byte big-endian word starts in the payload. The offset is fixed whatever the values, so a number measured later can be spliced into a payload built earlier.

Throws

ProgramError when the document is invalid, when chainId names another chain, or when a name does not exist on the chain, listing every such name with its path. The SDK refuses on Arc (chain 5042) what Arc cannot do: wrapETH, unwrapETH, lidoStake, rocketPoolStake, etherFiStake, balancerV3Swap with wethIsEth: true, and a nativeBalance spent as a token amount. Arc’s native coin is USDC, the same balance as its USDC ERC-20 (Arc).

ProgramError

The error every function on this page throws for a document that breaks a rule.

Import

import { ProgramError } from "@eco-incorp/sauce/actions";

Usage

The parseProgram example catches it twice.

Signature

export interface ProgramIssue {
    readonly path: string;
    readonly message: string;
}
export declare class ProgramError extends Error {
    readonly issues: readonly ProgramIssue[];
    readonly chain?: CanonicalChain;
    constructor(issues: readonly ProgramIssue[], chain?: CanonicalChain);
}

Properties

issues: every problem found, in order, each located by a path into the document (actions[2].amountRef).
chain: set when the issues are the compiled chain’s, such as a name it lacks, rather than the document’s own.
message: a summary line, then one line per issue.

quoteAction

Builds the eth_call that prices a swap action at its own amount. It reads nothing; you send the call. @sauce/router has no quote function, so this is how TypeScript prices a swap before it builds a program. A program can also read a quote itself before it swaps, as Quote, swap and supply does.

Import

import { quoteAction } from "@eco-incorp/sauce/actions";

Usage

quote.mts

import { quoteAction, type UniswapV3SwapAction } from "@eco-incorp/sauce/actions";
import { v12QuoteRouterAddress } from "@eco-incorp/sauce/deployments";
import { createPublicClient, getAddress, http } from "viem";
import { base } from "viem/chains";

const rpcUrl = process.argv[2]; // your Base JSON-RPC URL: the SDK ships none
const client = createPublicClient({ chain: base, transport: http(rpcUrl) });

const swap: UniswapV3SwapAction = {
  type: "uniswapV3Swap",
  pool: "0xd0b53D9277642d899DF5C87A3966A349A798F224", // Uniswap V3 WETH/USDC 0.05% on Base
  tokenIn: "USDC",
  tokenOut: "WETH",
  amount: "1000000000", // 1,000 USDC
  amountOutMin: "1",
  recipient: "pot",
};

const quote = quoteAction(swap, { chain: "base", router: getAddress(v12QuoteRouterAddress()) });
const blockNumber = await client.getBlockNumber();
const { data } = await client.call({ to: quote.to, data: quote.data, blockNumber });
if (data === undefined) throw new Error("the quote returned nothing");

console.log("block", blockNumber, "WETH out:", quote.decode(data));

node quote.mts <your Base RPC URL>

On Base at block 53157152, through a public endpoint:

block 53157152n WETH out: 431160687887827317n

Signature

export declare function quoteAction(action: SwapAction, options?: QuoteOptions): Quote;

export interface Quote {
    readonly to: Address;
    readonly data: Hex;
    decode(result: Hex): bigint;
}

export interface QuoteOptions {
    readonly chain?: ChainRef;
    readonly router?: Address;
    readonly maverickQuoter?: Address;
    readonly ambientImpact?: Address;
    readonly fluidDexResolver?: Address;
}

Parameters

action: a swap action with its amount (a Carbon trade or a Balancer batch prices at the amounts it carries). Its pool must be given by address.
options.chain: the chain whose names the action’s tokens and contracts resolve to; required when the action uses a name.
options.router: for uniswapV3Swap and uniswapV4Swap, the quote Router at v12QuoteRouterAddress() from @eco-incorp/sauce/deployments (Deployments). The content-addressed execution Router at v12RouterAddress(), which a Pot swaps through, has no quote method.
options.maverickQuoter, options.ambientImpact, options.fluidDexResolver: the quoter for maverickV2Swap, ambientSwap and fluidDexT1Swap.

The other venues price on the contract the action names: a Uniswap V2 pair’s reserves, a Curve pool’s get_dy, a DODO pool’s querySellBase or querySellQuote, a Trader Joe pair’s getSwapOut (zero when the pair cannot take the whole input), WooPPV2’s query. Send a Balancer V3 quote from the zero address. No quote needs a balance or an allowance.

Returns

Quote: send data to to as an eth_call, and pass the result to decode for the output amount in tokenOut’s smallest unit.

Throws

For a pool given by key: read the pool from the factory first, then give pool. For an action that names a token or contract when options.chain is missing.

compileSplitSwap

Compiles one program that divides an amount into equal slices and gives each, in turn, to the candidate pool whose onchain quote pays the most for it, then executes every candidate’s share.

Import

import { compileSplitSwap } from "@eco-incorp/sauce/actions";

Usage

split-swap.mts

import { compileSplitSwap } from "@eco-incorp/sauce/actions";
import { v12QuoteRouterAddress } from "@eco-incorp/sauce/deployments";
import { getAddress } from "viem";

// 1,000 USDC for WETH, in 10 slices, each to whichever Base pool quotes the most for it.
const split = compileSplitSwap({
  chain: "base",
  amount: "1000000000",
  buckets: 10,
  amountOutMin: "400000000000000000", // 0.4 WETH across every leg
  candidates: [
    {
      type: "uniswapV3Swap",
      pool: "0xd0b53D9277642d899DF5C87A3966A349A798F224", // Uniswap V3 0.05%
      tokenIn: "USDC",
      tokenOut: "WETH",
      amountOutMin: "0",
      recipient: "pot",
    },
    {
      type: "uniswapV3Swap",
      pool: "0x6c561B446416E1A00E8E93E221854d6eA4171372", // Uniswap V3 0.3%
      tokenIn: "USDC",
      tokenOut: "WETH",
      amountOutMin: "0",
      recipient: "pot",
    },
  ],
  quoters: { router: getAddress(v12QuoteRouterAddress()) },
  sweep: { token: "WETH", recipient: "0x1111111111111111111111111111111111111111" },
});

console.log("bytecode:", split.bytecode.length, "bytes; parameters:", split.parameters);

bytecode: 1638 bytes; parameters: []

Signature

export declare function compileSplitSwap(swap: SplitSwap): CompiledProgram;

export interface SplitSwap {
    readonly candidates: readonly SwapAction[];
    readonly amount: string;
    readonly buckets: number;
    readonly amountOutMin: string;
    readonly approvals?: readonly ApproveAction[];
    readonly sweep?: {
        readonly token: Token;
        readonly recipient: Recipient;
    };
    readonly quoters?: QuoteOptions;
    readonly chain?: ChainRef;
}

Parameters

candidates: ordinary swap actions with no amount, amountRef or saveOutputAs, each with its pool by address (a uniswapV4Swap by its poolManager and key) and each delivering to the Pot. Each must have an onchain quote with a fixed amount offset: every venue but Balancer (V2, its batch swap and V3) and Carbon, which the split refuses (candidates[i] (balancerV2Swap) has no on-chain quote with a runtime amount, which a split needs). Uniswap V3 and V4 candidates quote through quoters.router, the quote Router at v12QuoteRouterAddress().
amount: the total input, a base-10 string divisible by buckets.
buckets: how many equal slices the allocation hands out; at least 1.
amountOutMin: the least total output, checked once after every leg. Required; "0" waives it.
approvals: approvals to run first, each with an explicit amount, for a candidate that pulls through a periphery contract. A @sauce/router swap needs none.
sweep: sends the total output of token to recipient at the end; omit it to keep the output in the Pot. recipient is an address or "pot".
quoters: the quoter contracts the candidates price through, as in quoteAction.
chain: the chain the names in the candidates, approvals and sweep resolve on; needed only when they use a name.

Returns

A CompiledProgram with no run-time arguments: its payload() is the bytecode.

Throws

ProgramError for an invalid candidate or a name the chain lacks; an error for a pool given by key.

Action reference

Every action type, generated from @eco-incorp/sauce/actions/action-program.schema.json. Every action that takes amount also takes amountRef, and every action takes saveOutputAs. Output is what a later action spends.

Action	Required	Optional	Takes `amount`	Output
`uniswapV2Swap`	`tokenIn`, `tokenOut`, `amountOutMin`, `recipient`; `pool` or `factory`	`feePpm`	yes	received
`uniswapV3Swap`	`tokenIn`, `tokenOut`, `amountOutMin`, `recipient`; `pool` or `factory` + `fee` or `factory` + `tickSpacing`	`sqrtPriceLimitX96`	yes	received
`uniswapV4Swap`	`poolManager`, `tokenIn`, `tokenOut`, `fee`, `tickSpacing`, `amountOutMin`, `recipient`	`hooks`, `sqrtPriceLimitX96`	yes	received
`curveSwap`	`pool`, `tokenIn`, `tokenOut`, `i`, `j`, `indexType`, `amountOutMin`, `recipient`		yes	received
`balancerV2Swap`	`vault`, `poolId`, `tokenIn`, `tokenOut`, `amountOutMin`, `recipient`		yes	received
`dodoV2Swap`	`pool`, `tokenIn`, `tokenOut`, `baseToken`, `quoteToken`, `amountOutMin`, `recipient`		yes	received
`traderJoeLBSwap`	`tokenIn`, `tokenOut`, `amountOutMin`, `recipient`; `pool` or `factory` + `binStep`	`tokenX`, `tokenY`	yes	received
`woofiSwap`	`pool`, `tokenIn`, `tokenOut`, `amountOutMin`, `recipient`		yes	received
`maverickV2Swap`	`pool`, `tokenIn`, `tokenOut`, `amountOutMin`, `recipient`		yes	received
`curveRouterNGSwap`	`router`, `route`, `swapParams`, `pools`, `amountOutMin`, `recipient`		yes	received
`balancerV2BatchSwap`	`vault`, `steps`, `assets`, `amountOutMin`, `recipient`, `deadline`		no	received
`balancerV3Swap`	`router`, `pool`, `tokenIn`, `tokenOut`, `amountOutMin`, `deadline`, `wethIsEth`		yes	received
`ambientSwap`	`dex`, `base`, `quote`, `poolIdx`, `isBuy`, `inBaseQty`, `tip`, `limitPrice`, `amountOutMin`, `reserveFlags`		yes	received
`dodoV1Swap`	`proxy`, `tokenIn`, `tokenOut`, `pairs`, `directions`, `amountOutMin`, `deadline`		yes	received
`carbonSwap`	`controller`, `sourceToken`, `targetToken`, `tradeActions`, `amountOutMin`, `deadline`		no	received
`fraxswapSwap`	`router`, `path`, `amountOutMin`, `recipient`, `deadline`		yes	received
`fluidDexT1Swap`	`pool`, `swap0to1`, `amountOutMin`, `recipient`		yes	received
`acrossBridge`	`spokePool`, `token`, `destChainId`, `recipient`, `relayerFee`, `quoteTimestamp`, `fillDeadline`, `exclusivityDeadline`, `message`		yes	its amount
`stargateBridge`	`pool`, `dstEid`, `recipient`, `amountOutMin`		yes	its amount
`cctpBridge`	`tokenMessenger`, `token`, `destinationDomain`, `recipient`	`maxFee`, `minFinalityThreshold`	yes	its amount
`hyperlaneBridge`	`router`, `destinationDomain`, `recipient`		yes	its amount
`wrapETH`	`weth`		yes	its amount
`unwrapETH`	`weth`		yes	its amount
`wrapStETH`	`wstETH`		yes	received
`unwrapStETH`	`wstETH`		yes	received
`lidoStake`	`stETH`	`referral`	yes	received
`lidoUnstake`	`withdrawalQueue`, `owner`		yes	its amount
`rocketPoolStake`	`depositPool`, `rETH`		yes	received
`rocketPoolUnstake`	`rETH`		yes	received
`etherFiStake`	`liquidityPool`, `eETH`		yes	received
`aaveV3Supply`	`pool`, `token`, `onBehalfOf`	`referralCode`	yes	its amount
`aaveV3Withdraw`	`pool`, `token`, `recipient`		yes	received
`aaveV3Borrow`	`pool`, `token`, `onBehalfOf`	`referralCode`	yes	its amount
`aaveV3Repay`	`pool`, `token`, `onBehalfOf`		yes	its amount
`compoundV3Supply`	`comet`, `token`		yes	its amount
`compoundV3Withdraw`	`comet`, `token`		yes	its amount
`transfer`	`token`, `recipient`		yes	its amount
`approve`	`token`, `spender`		yes	its amount
`permit2Approve`	`permit2`, `token`, `spender`, `expiration`		yes	its amount
`balanceOf`	`token`		no	the value read
`nativeBalance`			no	the value read
`argument`	`name`		no	the value read

Each field’s documentation is its description in the schema. A @sauce/router swap (the first nine rows) needs no approval: it pushes its input to the pool, approves exactly its input itself, or the Pot’s Router pays the pool. Any other venue that pulls from the Pot needs an approve first.

TypeScript types

Every type is the JSON it describes, with amounts as strings and no class instances.

ActionProgram is the document, Action the union of every action, and ActionType its type.
Each action has its own type (UniswapV3SwapAction, AaveV3SupplyAction, …), grouped as SwapAction (with RouterSwapAction, the nine @sauce/router swaps), BridgeAction, WrapAction, StakeAction, LendingAction, TokenAction and SourceAction.
A field’s type says what it takes: Token (a TokenSymbol or an address), TokenOrNative, Contract (a ContractName, "Namespace.Contract", or an address), TokenContract and Recipient (`0x${string}` | "pot").
A swap that names its pool by key is a union, so TypeScript refuses the mixes the parser refuses: UniswapV3SwapAction is a pool, or a factory with a fee, or a factory with a tick spacing.

Next steps

sauce actions: print what a document lowers to from the command line.
@sauce/router: the swap library the swap actions call.
Cook transactions: wrap a payload in Pot.cook.
Actions: swap and supply: a worked document.

​The document

​Values

​Names and addresses

​Chaining outputs

​parseProgram

​Import

​Usage

​Signature

​Parameters

​Returns

​Throws

​serializeProgram

​Import

​Usage

​Signature

​Parameters

​Returns

​Throws

​programSchema

​Import

​Usage

​Signature

​Returns

​compileProgram

​Import

​Usage

​Signature

​Parameters

​Returns

​Throws

​ProgramError

​Import

​Usage

​Signature

​Properties

​quoteAction

​Import

​Usage

​Signature

​Parameters

​Returns

​Throws

​compileSplitSwap

​Import

​Usage

​Signature

​Parameters

​Returns

​Throws

​Action reference

​TypeScript types

​Next steps

The document

Values

Names and addresses

Chaining outputs

parseProgram

Import

Usage

Signature

Parameters

Returns

Throws

serializeProgram

Import

Usage

Signature

Parameters

Returns

Throws

programSchema

Import

Usage

Signature

Returns

compileProgram

Import

Usage

Signature

Parameters

Returns

Throws

ProgramError

Import

Usage

Signature

Properties

quoteAction

Import

Usage

Signature

Parameters

Returns

Throws

compileSplitSwap

Import

Usage

Signature

Parameters

Returns

Throws

Action reference

TypeScript types

Next steps