> ## Documentation Index
> Fetch the complete documentation index at: https://docs.eco.com/llms.txt
> Use this file to discover all available pages before exploring further.

# actions: Action types

> Action types: 52 exports of the actions module of @eco-incorp/sauce, including ActionChainInput, ActionChainOptions, UniswapV3ExactInputAction, UniswapV3ExactInputMultiHopAction, UniswapV4ExactInputAction, UniswapV4ExactInputMultiHopAction.

`@eco-incorp/sauce/actions` lowers routing intents into Sauce programs and carries the AMM and bridge action primitives.

```typescript theme={null}
import { actionsToSauce } from "@eco-incorp/sauce/actions";
```

This page covers `actions/dist/types.d.ts`.

<Note>
  Generated from the type declarations shipped in `@eco-incorp/sauce` 0.99.4. Each entry shows the package authors' JSDoc and declaration for this SDK version. For runtime compatibility and deployed addresses, see [architecture and deployments](/programmable-transactions/sauce/architecture-and-deployments).
</Note>

### `ActionChainInput`

*Interface* · `actions/dist/types.d.ts`

Chaining options shared by all actions.

```typescript theme={null}
export interface ActionChainInput {
    amountRef?: string;
    saveOutputAs?: string;
}
```

### `ActionChainOptions`

*Type* · `actions/dist/types.d.ts`

Alias for actions that produce a capturable output (e.g. swaps).

```typescript theme={null}
export type ActionChainOptions = ActionChainInput;
```

### `UniswapV3ExactInputAction`

*Type* · `actions/dist/types.d.ts`

```typescript theme={null}
export type UniswapV3ExactInputAction = (UniswapV3ExactInputBase & {
    amountOutMin: string;
    sqrtPriceLimitX96?: never;
}) | (UniswapV3ExactInputBase & {
    sqrtPriceLimitX96: string;
    amountOutMin?: never;
});
```

### `UniswapV3ExactInputMultiHopAction`

*Interface* · `actions/dist/types.d.ts`

UniswapV3 multi-hop exact-input swap (encoded path)

```typescript theme={null}
export interface UniswapV3ExactInputMultiHopAction extends ActionChainOptions {
    type: "uniswapV3ExactInputMultiHop";
    chainId: number;
    router: Address;
    path: Hex;
    amountIn?: string;
    amountOutMin: string;
    recipient: Address;
    deadline: number;
}
```

### `UniswapV4ExactInputAction`

*Interface* · `actions/dist/types.d.ts`

UniswapV4 single-pool exact-input swap via Universal Router

```typescript theme={null}
export interface UniswapV4ExactInputAction extends ActionChainOptions {
    type: "uniswapV4ExactInput";
    chainId: number;
    router: Address;
    poolKey: {
        currency0: Address;
        currency1: Address;
        fee: number;
        tickSpacing: number;
        hooks: Address;
    };
    zeroForOne: boolean;
    amountIn?: string;
    amountOutMin: string;
    recipient: Address;
}
```

### `UniswapV4ExactInputMultiHopAction`

*Interface* · `actions/dist/types.d.ts`

UniswapV4 multi-hop exact-input swap via Universal Router (PathKey path)

```typescript theme={null}
export interface UniswapV4ExactInputMultiHopAction extends ActionChainOptions {
    type: "uniswapV4ExactInputMultiHop";
    chainId: number;
    router: Address;
    currencyIn: Address;
    path: Array<{
        intermediateCurrency: Address;
        fee: number;
        tickSpacing: number;
        hooks: Address;
    }>;
    amountIn?: string;
    amountOutMin: string;
    recipient: Address;
}
```

### `CurveSwapAction`

*Interface* · `actions/dist/types.d.ts`

Curve stable/crypto pool swap (uses exchange with receiver overload)

```typescript theme={null}
export interface CurveSwapAction extends ActionChainOptions {
    type: "curveSwap";
    chainId: number;
    pool: Address;
    tokenIn: Address;
    tokenOut: Address;
    i: number;
    j: number;
    amountIn?: string;
    amountOutMin: string;
    recipient: Address;
}
```

### `BalancerV2SwapAction`

*Interface* · `actions/dist/types.d.ts`

BalancerV2 single swap

```typescript theme={null}
export interface BalancerV2SwapAction extends ActionChainOptions {
    type: "balancerV2Swap";
    chainId: number;
    vault: Address;
    poolId: Hex;
    tokenIn: Address;
    tokenOut: Address;
    amountIn?: string;
    amountOutMin: string;
    recipient: Address;
    deadline: number;
}
```

### `BalancerV2BatchSwapAction`

*Interface* · `actions/dist/types.d.ts`

BalancerV2 batch swap (multi-hop through multiple pools)

```typescript theme={null}
export interface BalancerV2BatchSwapAction extends ActionChainInput {
    type: "balancerV2BatchSwap";
    chainId: number;
    vault: Address;
    steps: Array<{
        poolId: Hex;
        assetInIndex: number;
        assetOutIndex: number;
        amount: string;
    }>;
    assets: Address[];
    amountOutMin: string;
    recipient: Address;
    deadline: number;
}
```

### `UniswapV2SwapAction`

*Interface* · `actions/dist/types.d.ts`

UniswapV2 exact-input swap via V2 Router

```typescript theme={null}
export interface UniswapV2SwapAction extends ActionChainOptions {
    type: "uniswapV2Swap";
    chainId: number;
    router: Address;
    amountIn?: string;
    amountOutMin: string;
    path: Address[];
    recipient: Address;
    deadline: number;
}
```

### `CurveRouterNGSwapAction`

*Interface* · `actions/dist/types.d.ts`

Curve RouterNG multi-hop swap (up to 5 hops)

```typescript theme={null}
export interface CurveRouterNGSwapAction extends ActionChainOptions {
    type: "curveRouterNGSwap";
    chainId: number;
    router: Address;
    route: Address[];
    swapParams: [
        number,
        number,
        number,
        number,
        number
    ][];
    amountIn?: string;
    amountOutMin: string;
    pools: Address[];
    recipient: Address;
}
```

### `BalancerV3SwapAction`

*Interface* · `actions/dist/types.d.ts`

BalancerV3 single-token exact-input swap via Router

```typescript theme={null}
export interface BalancerV3SwapAction extends ActionChainOptions {
    type: "balancerV3Swap";
    chainId: number;
    router: Address;
    pool: Address;
    tokenIn: Address;
    tokenOut: Address;
    amountIn?: string;
    amountOutMin: string;
    deadline: number;
    wethIsEth: boolean;
}
```

### `AmbientSwapAction`

*Interface* · `actions/dist/types.d.ts`

Ambient (CrocSwap) swap via userCmd

```typescript theme={null}
export interface AmbientSwapAction extends ActionChainOptions {
    type: "ambientSwap";
    chainId: number;
    dex: Address;
    base: Address;
    quote: Address;
    poolIdx: number;
    isBuy: boolean;
    inBaseQty: boolean;
    amountIn?: string;
    tip: number;
    limitPrice: string;
    minOut: string;
    reserveFlags: number;
}
```

### `DODOSwapAction`

*Interface* · `actions/dist/types.d.ts`

DODO token-to-token swap via DODOProxy (supports V1 Classical and V2 pools)

```typescript theme={null}
export interface DODOSwapAction extends ActionChainOptions {
    type: "dodoSwap";
    chainId: number;
    proxy: Address;
    fromToken: Address;
    toToken: Address;
    amountIn?: string;
    amountOutMin: string;
    dodoPairs: Address[];
    directions: number;
    deadline: number;
    version?: "v1" | "v2";
}
```

### `MaverickSwapAction`

*Interface* · `actions/dist/types.d.ts`

Maverick V2 exact-input single swap

```typescript theme={null}
export interface MaverickSwapAction extends ActionChainOptions {
    type: "maverickSwap";
    chainId: number;
    router: Address;
    pool: Address;
    tokenAIn: boolean;
    amountIn?: string;
    amountOutMin: string;
    recipient: Address;
}
```

### `MaverickMultiHopSwapAction`

*Interface* · `actions/dist/types.d.ts`

Maverick V2 exact-input multi-hop swap

```typescript theme={null}
export interface MaverickMultiHopSwapAction extends ActionChainOptions {
    type: "maverickMultiHopSwap";
    chainId: number;
    router: Address;
    path: Hex;
    amountIn?: string;
    amountOutMin: string;
    recipient: Address;
}
```

### `CarbonSwapAction`

*Interface* · `actions/dist/types.d.ts`

Carbon (Bancor) trade by source amount

```typescript theme={null}
export interface CarbonSwapAction extends ActionChainOptions {
    type: "carbonSwap";
    chainId: number;
    controller: Address;
    sourceToken: Address;
    targetToken: Address;
    tradeActions: Array<{
        strategyId: string;
        amount: string;
    }>;
    amountIn?: string;
    amountOutMin: string;
    deadline: number;
}
```

### `FraxswapSwapAction`

*Interface* · `actions/dist/types.d.ts`

Fraxswap exact-input swap (UniV2-compatible router)

```typescript theme={null}
export interface FraxswapSwapAction extends ActionChainOptions {
    type: "fraxswapSwap";
    chainId: number;
    router: Address;
    amountIn?: string;
    amountOutMin: string;
    path: Address[];
    recipient: Address;
    deadline: number;
}
```

### `ClipperSwapAction`

*Interface* · `actions/dist/types.d.ts`

Clipper sellTokenForToken swap

```typescript theme={null}
export interface ClipperSwapAction extends ActionChainOptions {
    type: "clipperSwap";
    chainId: number;
    exchange: Address;
    inputToken: Address;
    outputToken: Address;
    amountIn?: string;
    amountOutMin: string;
    recipient: Address;
    auxiliaryData: Hex;
}
```

### `IntegralSwapAction`

*Interface* · `actions/dist/types.d.ts`

Integral SIZE delayed sell order

```typescript theme={null}
export interface IntegralSwapAction extends ActionChainOptions {
    type: "integralSwap";
    chainId: number;
    delay: Address;
    tokenIn: Address;
    tokenOut: Address;
    amountIn?: string;
    amountOutMin: string;
    wrapUnwrap: boolean;
    recipient: Address;
    gasLimit: string;
    submitDeadline: number;
}
```

### `FluidDexT1SwapAction`

*Interface* · `actions/dist/types.d.ts`

Fluid DEX T1 pool swap (swapIn)

```typescript theme={null}
export interface FluidDexT1SwapAction extends ActionChainOptions {
    type: "fluidDexT1Swap";
    chainId: number;
    pool: Address;
    swap0to1: boolean;
    amountIn?: string;
    amountOutMin: string;
    recipient: Address;
}
```

### `FluidDexLiteSwapAction`

*Interface* · `actions/dist/types.d.ts`

Fluid DEX Lite singleton swap (swapSingle)

```typescript theme={null}
export interface FluidDexLiteSwapAction extends ActionChainOptions {
    type: "fluidDexLiteSwap";
    chainId: number;
    dex: Address;
    token0: Address;
    token1: Address;
    salt: Hex;
    swap0To1: boolean;
    amountIn?: string;
    amountOutMin: string;
    recipient: Address;
}
```

### `SwapAction`

*Type* · `actions/dist/types.d.ts`

```typescript theme={null}
export type SwapAction = UniswapV3ExactInputAction | UniswapV3ExactInputMultiHopAction | UniswapV4ExactInputAction | UniswapV4ExactInputMultiHopAction | CurveSwapAction | CurveRouterNGSwapAction | BalancerV2SwapAction | BalancerV2BatchSwapAction | BalancerV3SwapAction | UniswapV2SwapAction | AmbientSwapAction | DODOSwapAction | MaverickSwapAction | MaverickMultiHopSwapAction | CarbonSwapAction | FraxswapSwapAction | ClipperSwapAction | IntegralSwapAction | FluidDexT1SwapAction | FluidDexLiteSwapAction;
```

### `AcrossBridgeAction`

*Interface* · `actions/dist/types.d.ts`

Across V3 bridge

```typescript theme={null}
export interface AcrossBridgeAction extends ActionChainInput {
    type: "acrossBridge";
    srcChainId: number;
    destChainId: number;
    spokePool: Address;
    token: Address;
    amount?: string;
    relayerFeePct: string;
    quoteTimestamp: number;
    fillDeadline: number;
    exclusivityDeadline: number;
    message: Hex;
}
```

### `StargateBridgeAction`

*Interface* · `actions/dist/types.d.ts`

Stargate / LayerZero bridge

```typescript theme={null}
export interface StargateBridgeAction extends ActionChainInput {
    type: "stargateBridge";
    srcChainId: number;
    destChainId: number;
    router: Address;
    token: Address;
    srcPoolId: number;
    dstPoolId: number;
    amount?: string;
    amountOutMin: string;
    lzFee: string;
}
```

### `CCTPBridgeAction`

*Interface* · `actions/dist/types.d.ts`

Circle CCTP native USDC bridge

```typescript theme={null}
export interface CCTPBridgeAction extends ActionChainInput {
    type: "cctpBridge";
    srcChainId: number;
    destChainId: number;
    tokenMessenger: Address;
    token: Address;
    srcDomain: number;
    destDomain: number;
    amount?: string;
    mintRecipient: Hex;
}
```

### `HyperlaneBridgeAction`

*Interface* · `actions/dist/types.d.ts`

Hyperlane token bridge

```typescript theme={null}
export interface HyperlaneBridgeAction extends ActionChainInput {
    type: "hyperlaneBridge";
    srcChainId: number;
    destChainId: number;
    router: Address;
    token: Address;
    amount?: string;
    destinationDomain: number;
    gasPayment: string;
}
```

### `BridgeAction`

*Type* · `actions/dist/types.d.ts`

```typescript theme={null}
export type BridgeAction = AcrossBridgeAction | StargateBridgeAction | CCTPBridgeAction | HyperlaneBridgeAction;
```

### `WrapETHAction`

*Interface* · `actions/dist/types.d.ts`

Wrap ETH → WETH via deposit()

```typescript theme={null}
export interface WrapETHAction extends ActionChainInput {
    type: "wrapETH";
    chainId: number;
    weth: Address;
    amount?: string;
}
```

### `UnwrapETHAction`

*Interface* · `actions/dist/types.d.ts`

Unwrap WETH → ETH via withdraw()

```typescript theme={null}
export interface UnwrapETHAction extends ActionChainInput {
    type: "unwrapETH";
    chainId: number;
    weth: Address;
    amount?: string;
}
```

### `WrapStETHAction`

*Interface* · `actions/dist/types.d.ts`

Wrap stETH → wstETH

```typescript theme={null}
export interface WrapStETHAction extends ActionChainInput {
    type: "wrapStETH";
    chainId: number;
    wstETH: Address;
    stETHAmount?: string;
}
```

### `UnwrapStETHAction`

*Interface* · `actions/dist/types.d.ts`

Unwrap wstETH → stETH

```typescript theme={null}
export interface UnwrapStETHAction extends ActionChainInput {
    type: "unwrapStETH";
    chainId: number;
    wstETH: Address;
    wstETHAmount?: string;
}
```

### `WrapAction`

*Type* · `actions/dist/types.d.ts`

```typescript theme={null}
export type WrapAction = WrapETHAction | UnwrapETHAction | WrapStETHAction | UnwrapStETHAction;
```

### `LidoStakeAction`

*Interface* · `actions/dist/types.d.ts`

Lido: stake ETH → stETH via submit()

```typescript theme={null}
export interface LidoStakeAction extends ActionChainInput {
    type: "lidoStake";
    chainId: number;
    stETH: Address;
    amount?: string;
    referral: Address;
}
```

### `LidoUnstakeAction`

*Interface* · `actions/dist/types.d.ts`

Lido: request withdrawal stETH → ETH (async, not instant)

```typescript theme={null}
export interface LidoUnstakeAction extends ActionChainInput {
    type: "lidoUnstake";
    chainId: number;
    withdrawalQueue: Address;
    stETHAmount?: string;
}
```

### `RocketPoolStakeAction`

*Interface* · `actions/dist/types.d.ts`

Rocket Pool: stake ETH → rETH

```typescript theme={null}
export interface RocketPoolStakeAction extends ActionChainInput {
    type: "rocketPoolStake";
    chainId: number;
    rETH: Address;
    depositPool: Address;
    amount?: string;
}
```

### `RocketPoolUnstakeAction`

*Interface* · `actions/dist/types.d.ts`

Rocket Pool: burn rETH → ETH

```typescript theme={null}
export interface RocketPoolUnstakeAction extends ActionChainInput {
    type: "rocketPoolUnstake";
    chainId: number;
    rETH: Address;
    amount?: string;
}
```

### `CoinbaseStakeAction`

*Interface* · `actions/dist/types.d.ts`

Coinbase: stake ETH → cbETH

```typescript theme={null}
export interface CoinbaseStakeAction extends ActionChainInput {
    type: "coinbaseStake";
    chainId: number;
    cbETH: Address;
    amount?: string;
}
```

### `EtherFiStakeAction`

*Interface* · `actions/dist/types.d.ts`

EtherFi: stake ETH → eETH

```typescript theme={null}
export interface EtherFiStakeAction extends ActionChainInput {
    type: "etherFiStake";
    chainId: number;
    liquidityPool: Address;
    amount?: string;
}
```

### `StakeAction`

*Type* · `actions/dist/types.d.ts`

```typescript theme={null}
export type StakeAction = LidoStakeAction | LidoUnstakeAction | RocketPoolStakeAction | RocketPoolUnstakeAction | CoinbaseStakeAction | EtherFiStakeAction;
```

### `AaveV3SupplyAction`

*Interface* · `actions/dist/types.d.ts`

Aave V3: supply token into lending pool

```typescript theme={null}
export interface AaveV3SupplyAction extends ActionChainInput {
    type: "aaveV3Supply";
    chainId: number;
    pool: Address;
    token: Address;
    amount?: string;
    onBehalfOf: Address;
    referralCode: number;
}
```

### `AaveV3WithdrawAction`

*Interface* · `actions/dist/types.d.ts`

Aave V3: withdraw token from lending pool

```typescript theme={null}
export interface AaveV3WithdrawAction extends ActionChainOptions {
    type: "aaveV3Withdraw";
    chainId: number;
    pool: Address;
    token: Address;
    amount?: string;
    to: Address;
}
```

### `AaveV3BorrowAction`

*Interface* · `actions/dist/types.d.ts`

Aave V3: borrow token against collateral

```typescript theme={null}
export interface AaveV3BorrowAction extends ActionChainInput {
    type: "aaveV3Borrow";
    chainId: number;
    pool: Address;
    token: Address;
    amount?: string;
    interestRateMode: 2;
    onBehalfOf: Address;
    referralCode: number;
}
```

### `AaveV3RepayAction`

*Interface* · `actions/dist/types.d.ts`

Aave V3: repay borrowed token

```typescript theme={null}
export interface AaveV3RepayAction extends ActionChainInput {
    type: "aaveV3Repay";
    chainId: number;
    pool: Address;
    token: Address;
    amount?: string;
    interestRateMode: 2;
    onBehalfOf: Address;
}
```

### `CompoundV3SupplyAction`

*Interface* · `actions/dist/types.d.ts`

Compound V3: supply token to Comet market

```typescript theme={null}
export interface CompoundV3SupplyAction extends ActionChainInput {
    type: "compoundV3Supply";
    chainId: number;
    comet: Address;
    token: Address;
    amount?: string;
}
```

### `CompoundV3WithdrawAction`

*Interface* · `actions/dist/types.d.ts`

Compound V3: withdraw token from Comet market

```typescript theme={null}
export interface CompoundV3WithdrawAction extends ActionChainInput {
    type: "compoundV3Withdraw";
    chainId: number;
    comet: Address;
    token: Address;
    amount?: string;
}
```

### `LendingAction`

*Type* · `actions/dist/types.d.ts`

```typescript theme={null}
export type LendingAction = AaveV3SupplyAction | AaveV3WithdrawAction | AaveV3BorrowAction | AaveV3RepayAction | CompoundV3SupplyAction | CompoundV3WithdrawAction;
```

### `TransferAction`

*Interface* · `actions/dist/types.d.ts`

Plain ERC-20 or native token transfer

```typescript theme={null}
export interface TransferAction extends ActionChainInput {
    type: "transfer";
    chainId: number;
    token: Address;
    to: Address;
    amount?: string;
}
```

### `ApproveAction`

*Interface* · `actions/dist/types.d.ts`

Approve ERC-20 spending

```typescript theme={null}
export interface ApproveAction extends ActionChainInput {
    type: "approve";
    chainId: number;
    token: Address;
    spender: Address;
    amount?: string;
}
```

### `RoutingAction`

*Type* · `actions/dist/types.d.ts`

```typescript theme={null}
export type RoutingAction = SwapAction | BridgeAction | WrapAction | StakeAction | LendingAction | TransferAction | ApproveAction;
```

### `RoutingStep`

*Interface* · `actions/dist/types.d.ts`

A single step in a routing plan, with execution metadata

```typescript theme={null}
export interface RoutingStep {
    stepIndex: number;
    action: RoutingAction;
    dependsOn?: number;
    estimatedGas?: string;
}
```

### `RoutingPlan`

*Interface* · `actions/dist/types.d.ts`

A full routing plan that fulfills one or more SauceIntents

```typescript theme={null}
export interface RoutingPlan {
    id: string;
    steps: RoutingStep[];
    totalEstimatedGas: string;
    expiresAt: number;
    expectedAmountOut: string;
    minAmountOut: string;
}
```