Bundle Actions Reference - Enso Developer Documentation

The Bundle API accepts an ordered array of public actions. This page documents stable Enso composition actions and common protocol action families.

Start with the Bundle API guide for request shape, execution, approvals, and response handling. Use the standalone Route API when Enso should choose the complete path. The enso:route section below documents the route action used inside a Bundle request.

Protocol support and inputs change over time. Use Supported Actions for the current action list and Standard per Protocol for actions available on a specific protocol. Generic protocol tables below describe common fields, not a universal schema for every integration.

Action index

Routing and composition: route, split, merge, call
Safety and fees: slippage, minamountout, fee, ensofee
Protocol actions: swap, deposit, redeem, bridge, borrow, repay, harvest
Token actions: approve, transfer, transferfrom, permittransferfrom, balance
Liquidity actions: depositclmm, redeemclmm
Logic: Math Actions, Helpers Actions

Chaining actions

Use a previous output as a later input with a zero-based reference:

{ useOutputOfCallAt: 0 }

Array outputs require an explicit item index:

{ useOutputOfCallAt: 0, index: 1 }

The following source-backed example splits USDT into two routed outputs and passes both into a CLMM deposit:

const bundle = await client.getBundleData(
  {
    chainId: 42161,
    fromAddress: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
    routingStrategy: "router",
  },
  [
    {
      protocol: "enso",
      action: "split",
      args: {
        tokenIn: "0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9",
        tokenOut: [
          "0xaf88d065e77c8cc2239327c5edb3a432268e5831",
          "0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9",
        ],
        amountIn: "100000000",
      },
    },
    {
      protocol: "sushiswap-v3",
      action: "depositclmm",
      args: {
        tokenOut: "0xf0cbce1942a68beb3d1b73f0dd86c8dcc363ef49",
        ticks: [-887271, 887271],
        tokenIn: [
          "0xaf88d065e77c8cc2239327c5edb3a432268e5831",
          "0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9",
        ],
        poolFee: "100",
        amountIn: [
          { useOutputOfCallAt: 0, index: 0 },
          { useOutputOfCallAt: 0, index: 1 },
        ],
      },
    },
  ],
);

References must point to an earlier available output. Checks such as check and minamountout do not produce a normal token amount for downstream consumption.

Action outputs

Action	Output	Shape	Reference notes
`route`	Routed token amount or amounts	Scalar or array	Use `index` for a multi-output route.
`balance`	Execution-account or requested account balance	Scalar	Advanced `account` and `estimate` behavior is documented separately.
`split`	One routed amount per `tokenOut`	Array	`index` is required.
`merge`	Merged output amount	Scalar	—
`call`	Contract return value	ABI-dependent	Shape follows the supplied ABI.
`slippage`	Calculated minimum amount	Scalar	The referenced producer must already exist.
`minamountout`	Assertion only	None	Do not reference it as a token producer.
`fee`, `ensofee`	Amount after fee	Scalar	Feed the net amount into the next action.
Math actions	Calculated number	Scalar	—
Comparison, `not`	Boolean result	Scalar	—
`toggle`	Selected amount	Scalar	—
`check`	Assertion only	None	Reverts when the condition is false.
Protocol actions	Protocol-specific	Varies	Use current per-protocol action metadata.

Ondo quote estimates

GET /api/v1/shortcuts/quote supports routes containing the synthetic ondosplit and ondomerge actions. It returns a soft estimate based on current Folio view data and Ondo soft attestations; it does not build an executable Ondo transaction or obtain a hard attestation. Use the Route API when execution-ready Ondo actions are required. Generic split and merge actions remain unavailable in the Quote API.

Core actions

`route`

enso:route finds a path between tokenIn and tokenOut inside a Bundle request. It can expand into swaps, deposits, or redeems, and the Bundle response includes the selected hops in route. This is different from the standalone Route API, which is usually simpler when the entire request has one final destination.

{
  protocol: "enso",
  action: "route",
  args: {
    tokenIn: "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
    tokenOut: "0xae7ab96520de3a18e5e111b5eaab095312d7fe84",
    amountIn: "1000000000000000000",
    slippage: "300",
    fee: ["100"],
    feeReceiver: "0x220866B1A2219f40e72f5c628B65D54268cA3A9D",
  },
}

The fee array aligns with amountIn; "100" is 1%. Values must be between 1 and 100 basis points. Omit fee when no fee should be collected. By default, route fees are deducted from the input assets on the source chain and sent to feeReceiver. For a cross-chain route with destination execution, set destinationFeeReceiver to collect the fee from the delivered bridge asset on the destination chain instead. feeReceiver remains required as the fallback for direct bridges without destination execution or routes where destination collection does not apply. For cross-chain routing, add destinationChainId. ignoreBridges and refundReceiver apply only to cross-chain route actions. Source completion and destination execution are asynchronous.

{
  protocol: "enso",
  action: "route",
  args: {
    tokenIn: "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
    tokenOut: "0x94b008aa00579c1307b0ef2c499ad98a8ce58e58",
    amountIn: "1000000000000000000",
    destinationChainId: 10,
    receiver: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
    refundReceiver: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
    fee: ["50"],
    feeReceiver: "0x220866B1A2219f40e72f5c628B65D54268cA3A9D",
    destinationFeeReceiver: "0x5fe5C43f1c4B2A1BA49cC6fE4A6a62f2f1619B82",
    ignoreBridges: ["ccip"],
  },
}

Parameter	Description	Required
`tokenIn`	Input token address. Use `0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee` for the native asset.	Yes
`tokenOut`	Output token address.	Yes
`amountIn`	Base-unit amount or previous output reference.	Yes
`slippage`	Slippage tolerance in basis points.	No
`minAmountOut`	Explicit minimum output amount or amounts.	No
`receiver`	Output recipient override.	No
`fee`	Fee BPS values aligned with the input amounts. Each value must be from 1 to 100.	No
`feeReceiver`	Source-chain fee receiver and fallback receiver. Required when `fee` is set.	No
`destinationFeeReceiver`	Destination-chain fee receiver for cross-chain routes with destination execution. Requires `fee` and `feeReceiver`.	No
`ignoreAggregators`	Aggregators to exclude from route selection.	No
`ignoreStandards`	Protocol standards to exclude from route selection.	No
`destinationChainId`	Destination chain for a cross-chain route.	No
`refundReceiver`	Cross-chain dust/refund recipient.	No
`ignoreBridges`	Bridges to exclude from cross-chain route selection.	No

`swap`

Swaps one token for another using a specific pool or exchange protocol.

const bundle = await client.getBundleData(
  {
    chainId: 1,
    fromAddress: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
    routingStrategy: "delegate",
  },
  [
    {
      protocol: "uniswap-v2",
      action: "swap",
      args: {
        tokenIn: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
        tokenOut: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
        amountIn: "1000000000000000000", // 1 WETH (18 decimals)
        primaryAddress: "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D", // Uniswap V2 Router
        receiver: "0x742d35Cc6634C0532925a3b844Bc454e4438f44e", // Receiver
        slippage: "100", // Optional: 1% slippage (100 basis points)
        poolFee: "3000", // Optional: Pool fee in basis points (e.g., 3000 for 0.3%)
      },
    },
  ],
);

Parameter	Description	Required
`tokenIn`	Address of token to swap from	Yes
`tokenOut`	Address of token to swap to	Yes
`amountIn`	Amount of `tokenIn` to swap in wei (with full decimals)	Yes
`primaryAddress`	Address of the router or pool contract	No
`receiver`	Address to receive the output tokens	Yes
`slippage`	Slippage tolerance in basis points (100 = 1%)	No
`poolFee`	Optional pool fee in basis points when using specific pools	No
`poolId`	The ID to identify the liquidity pool	No

`deposit`

Deposits tokens into a protocol to receive a position token or add liquidity.

Morpho
Aave

Use the optional positionId to deposit into.

{
  protocol: "morpho-markets-v1",
  action: "deposit",
  args: {
    amountIn: { useOutputOfCallAt: 0 },
    tokenIn: TOKEN_IN_ADDRESS,
    receiver: WALLET_ADDRESS,
    primaryAddress: MORPHO,
    positionId: MORPHO_POSITION_ID,
  },
}

const bundle = await client.getBundleData(
  {
    chainId: 1,
    fromAddress: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
    routingStrategy: "delegate",
  },
  [
    {
      protocol: "aave-v3",
      action: "deposit",
      args: {
        tokenIn: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", // WETH address
        tokenOut: "0x4d5F47FA6A74757f35C14fD3a6Ef8E3C9BC514E8", // aWETH address (optional)
        amountIn: "1000000000000000000", // Amount in wei (1 WETH)
        primaryAddress: "0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2", // Aave V3 pool
        receiver: "0x742d35Cc6634C0532925a3b844Bc454e4438f44e", // Optional: Receiver address
      },
    },
  ],
);

Parameter	Description	Required
`tokenIn`	Address of token to deposit. Can be a single address or an array for multiple tokens	Yes
`tokenOut`	Address of token to receive. Can be a single address or an array for multiple tokens. Omit if position is not represented by a token.	No
`amountIn`	Amount of `tokenIn` to deposit in wei (with full decimals). Can be a single value or an array for multiple tokens	Yes
`primaryAddress`	Address of the protocol contract to interact with	Yes
`receiver`	Address to receive the output tokens if not the caller	No
`positionId`	Position ID to deposit into (e.g. Morpho Markets’ positions)	No

`redeem`

Redeems underlying assets from a protocol by exchanging shares or tokens. Use it to exit a position and retrieve the desired tokens.

const bundle = await client.getBundleData(
  {
    chainId: 1,
    fromAddress: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
    routingStrategy: "delegate",
  },
  [
    // Step 1: First deposit into the ERC4626 vault to get shares
    {
      protocol: "erc4626",
      action: "deposit",
      args: {
        tokenIn: "0x6B175474E89094C44Da98b954EedeAC495271d0F", // DAI (underlying asset)
        tokenOut: "0xdA816459F1AB5631232FE5e97a05BBBb94970c95", // yvDAI (vault shares)
        amountIn: "1000000000000000000", // 1 DAI
        primaryAddress: "0xdA816459F1AB5631232FE5e97a05BBBb94970c95", // Vault address
      },
    },
    // Step 2: Now redeem the shares we just received
    {
      protocol: "erc4626",
      action: "redeem",
      args: {
        tokenIn: "0xdA816459F1AB5631232FE5e97a05BBBb94970c95", // yvDAI shares
        tokenOut: "0x6B175474E89094C44Da98b954EedeAC495271d0F", // DAI (underlying asset)
        amountIn: { useOutputOfCallAt: 0 }, // Use the shares from the deposit
        primaryAddress: "0xdA816459F1AB5631232FE5e97a05BBBb94970c95", // Vault address
        receiver: "0x742d35Cc6634C0532925a3b844Bc454e4438f44e", // Optional: Receiver
      },
    },
  ],
);

Parameter	Description	Required
`tokenIn`	Address of shares/tokens to redeem	No
`tokenOut`	Address of token(s) to receive upon redemption. Can be a single address or an array	Yes
`amountIn`	Amount of shares/tokens to redeem in wei (with full decimals)	Yes
`primaryAddress`	Address of the contract to interact with	Yes
`receiver`	Address to receive the output tokens if not the caller	No

Bridging

The bridge action lets you perform transactions spanning multiple chains. It relies on Stargate and LayerZero to coordinate interactions.

`bridge`

Facilitates cross-chain token transfers using various bridge protocols with optional callback actions on the destination chain. When used with callback actions (callback array), it can execute a destination-chain sequence after tokens arrive. Source bridging and destination execution are asynchronous; callback failure cannot revert a finalized source-chain bridge. Monitor the transfer through Bridge Status.

Important: When using callbacks, the callback bundle MUST start with a balance action to check the bridged token balance on the destination chain.

const bundle = await client.getBundleData(
  {
    chainId: 1,
    fromAddress: "0x93621DCA56fE26Cdee86e4F6B18E116e9758Ff11",
    spender: "0x93621DCA56fE26Cdee86e4F6B18E116e9758Ff11",
    routingStrategy: "router",
  },
  [
    {
      protocol: "enso",
      action: "route",
      args: {
        tokenIn: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48", // USDC on mainnet
        amountIn: "1000000000", // 1000 USDC
        tokenOut: "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", // ETH
      },
    },
    {
      protocol: "enso",
      action: "fee",
      args: {
        token: "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
        amount: { useOutputOfCallAt: 0 },
        bps: 25,
        receiver: "0x93621DCA56fE26Cdee86e4F6B18E116e9758Ff11", // Fee receiver
      },
    },
    {
      protocol: "stargate",
      action: "bridge",
      args: {
        primaryAddress: "0x77b2043768d28e9c9ab44e1abfc95944bce57931",
        destinationChainId: 8453,
        tokenIn: "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
        amountIn: { useOutputOfCallAt: 1 },
        receiver: "0x93621DCA56fE26Cdee86e4F6B18E116e9758Ff11",
        callback: [
          {
            protocol: "enso",
            action: "balance",
            args: {
              token: "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
            },
          },
          {
            protocol: "enso",
            action: "split",
            args: {
              tokenIn: "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
              tokenOut: [
                "0x50c5725949a6f0c72e6c4a641f24049a917db0cb",
                "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
              ],
              amountIn: { useOutputOfCallAt: 0 },
            },
          },
          {
            protocol: "enso",
            action: "slippage",
            args: {
              amountOut: { useOutputOfCallAt: 1, index: 0 },
              bps: 50,
            },
          },
          {
            protocol: "enso",
            action: "slippage",
            args: {
              amountOut: { useOutputOfCallAt: 1, index: 1 },
              bps: 50,
            },
          },
          {
            protocol: "uniswap-v4",
            action: "depositclmm",
            args: {
              tokenOut: "0x7c5f5a4bbd8fd63184577525326123b519429bdc",
              ticks: [-276842, -275842],
              tokenIn: [
                "0x50c5725949a6f0c72e6c4a641f24049a917db0cb",
                "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
              ],
              poolFee: "100",
              amountIn: [
                { useOutputOfCallAt: 1, index: 0 },
                { useOutputOfCallAt: 1, index: 1 },
              ],
            },
          },
        ],
      },
    },
  ],
);

Parameter	Description	Required
`primaryAddress`	Source bridge pool address	Yes
`destinationChainId`	Target blockchain network ID	Yes
`tokenIn`	Token address to bridge from source chain	Yes
`amountIn`	Amount to bridge (with full decimals) or a reference to a previous action’s output	Yes
`receiver`	Address to receive bridged tokens on destination chain	Yes
`callback`	Array of actions to execute on the destination chain after bridging (must start with balance action)	No
`callbackValue`	Additional value passed to the callback (in addition to bridge token)	No
`protocolArgs`	Provider-specific options such as CCTP transfer type and forward-fee level	No

Bridge providers do not all support the same callback shapes. Use Crosschain Routing for provider-specific constraints.

Slippage protection

The route action accepts its own slippage or explicit minimum settings. For direct protocol actions and internal routes used by composition actions, add slippage or minamountout checks where the flow requires explicit protection.

`slippage`

Derives a quote-backed minimum for a previously produced output and adds an on-chain check. The transaction reverts when the received amount is below that minimum. The referenced output must already exist. In split -> slippage -> depositclmm flows, the slippage checks intentionally sit before depositclmm because they protect the internal routes that prepare its inputs.

const bundle = await client.getBundleData(
  {
    chainId: 1,
    fromAddress: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
    routingStrategy: "delegate",
  },
  [
    {
      protocol: "uniswap-v2",
      action: "swap",
      args: {
        tokenIn: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
        tokenOut: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
        amountIn: "1000000000000000000",
        primaryAddress: "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D",
      },
    },
    {
      protocol: "enso",
      action: "slippage",
      args: {
        bps: "100",
        amountOut: { useOutputOfCallAt: 0 },
      },
    },
  ],
);

Parameter	Description	Required
`amountOut`	Expected output amount - must be output of one of previous actions `useOutputOfCallAt`	Yes
`bps`	Maximum acceptable slippage in basis points (1 bps = 0.01%, 100 bps = 1%)	Yes

`minAmountOut`

Applies slippage protection specified in absolute amount (minAmountOut) to ensure the received amount is within the acceptable range of the expected output.

const bundle = await client.getBundleData(
  {
    chainId: 1,
    fromAddress: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
    routingStrategy: "delegate",
  },
  [
    // First action to get an output
    {
      protocol: "uniswap-v2",
      action: "swap",
      args: {
        tokenIn: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
        tokenOut: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
        amountIn: "1000000000000000000", // 1 WETH
        primaryAddress: "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D", // Uniswap V2 Router
        receiver: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
      },
    },
    // Now apply minAmountOut check
    {
      protocol: "enso",
      action: "minamountout",
      args: {
        amountOut: { useOutputOfCallAt: 0 }, // Reference to first action's output
        minAmountOut: "1940000", // Minimum amount (1.94 USDC)
      },
    },
  ],
);

Parameter	Description	Required
`amountOut`	Expected output amount - must be output of one of previous actions `useOutputOfCallAt`	Yes
`minAmountOut`	Minimum acceptable amount of out token	Yes

minamountout is an assertion-only action. Do not use its position as a downstream token-amount reference.

Deposit & Redeem Actions

`depositCLMM`

Deposits tokens into a Concentrated Liquidity Market Maker pool (like Uniswap V3).

const bundle = await client.getBundleData(
  {
    chainId: 1,
    fromAddress: "0x93621DCA56fE26Cdee86e4F6B18E116e9758Ff11",
    spender: "0x93621DCA56fE26Cdee86e4F6B18E116e9758Ff11",
    routingStrategy: "router",
  },
  [
    {
      protocol: "uniswap-v4",
      action: "depositclmm",
      args: {
        tokenOut: "0xbd216513d74c8cf14cf4747e6aaa6420ff64ee9e",
        ticks: [-887270, 887270],
        tokenIn: [
          "0xdac17f958d2ee523a2206206994597c13d831ec7", // USDT
          "0x2260fac5e5542a773aa44fbcfedf7c193bc2c599", // WBTC
        ],
        poolFee: "500",
        amountIn: ["1000000000", "100000000"], // 1000 USDT (6 decimals), 1 WBTC (8 decimals)
      },
    },
  ],
);

Parameter	Description	Required
`tokenIn`	Array of addresses of tokens to deposit (usually 2 tokens)	Yes
`tokenOut`	Address of the position NFT to receive	Yes
`amountIn`	Array of amounts to deposit in wei (with full decimals). Must match the length of `tokenIn` array	Yes
`ticks`	Array containing lower and upper tick bounds defining the price range	Yes
`poolFee`	Pool fee tier in basis points (e.g., 3000 for 0.3%)	Yes
`receiver`	Address to receive the position NFT if not the caller	No
`tickSpacing`	The minimum gap between valid price points for adding liquidity	No
`hook`	The hook address for Uniswap V4 pools	No

`redeemCLMM`

Redeems tokens from a Concentrated Liquidity Market Maker position (like Uniswap V3).

const bundle = await client.getBundleData(
  {
    chainId: 1,
    fromAddress: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
    routingStrategy: "delegate",
  },
  [
    {
      protocol: "uniswap-v3",
      action: "redeemclmm",
      args: {
        tokenIn: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88", // UNI-V3-POS NFT
        tokenOut: [
          "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
          "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
        ],
        liquidity: "1000000000000", // Liquidity amount to withdraw
        tokenId: "123456", // The NFT token ID
        receiver: "0x742d35Cc6634C0532925a3b844Bc454e4438f44e", // Optional: Receiver
      },
    },
  ],
);

Parameter	Description	Required
`tokenIn`	Address of the position NFT token	Yes
`tokenOut`	Array of addresses of tokens to receive	Yes
`liquidity`	Amount of liquidity to withdraw	Yes
`tokenId`	ID of the position NFT	Yes
`receiver`	Address to receive the underlying tokens if not the caller	No

`singleDeposit`

Deposits a single token into a protocol. This is a specialized version of the deposit action for single token deposits.

const bundle = await client.getBundleData(
  {
    chainId: 1,
    fromAddress: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
    routingStrategy: "delegate",
  },
  [
    {
      protocol: "yearn",
      action: "singledeposit",
      args: {
        tokenIn: "0x6B175474E89094C44Da98b954EedeAC495271d0F", // DAI address
        tokenOut: "0xdA816459F1AB5631232FE5e97a05BBBb94970c95", // yvDAI address
        amountIn: "10000000000000000000", // 10 DAI (18 decimals)
        primaryAddress: "0xdA816459F1AB5631232FE5e97a05BBBb94970c95", // Yearn vault
        receiver: "0x742d35Cc6634C0532925a3b844Bc454e4438f44e", // Optional: Receiver
      },
    },
  ],
);

Parameter	Description	Required
`tokenIn`	Address of the single token to deposit	Yes
`tokenOut`	Address of the token to receive (usually a receipt or share token)	No
`amountIn`	Amount of `tokenIn` to deposit in wei (with full decimals)	Yes
`primaryAddress`	Address of the protocol contract to interact with	Yes
`receiver`	Address to receive the output tokens if not the caller	No

`multiDeposit`

Deposits multiple tokens into a protocol (like Curve or Balancer) in a single operation.

const bundle = await client.getBundleData(
  {
    chainId: 1,
    fromAddress: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
    routingStrategy: "delegate",
  },
  [
    {
      protocol: "curve",
      action: "multideposit",
      args: {
        tokenIn: [
          "0x6B175474E89094C44Da98b954EedeAC495271d0F", // DAI
          "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
          "0xdAC17F958D2ee523a2206206994597C13D831ec7", // USDT
        ],
        tokenOut: "0x6c3F90f043a72FA612cbac8115EE7e52BDe6E490", // 3Crv LP token
        amountIn: [
          "10000000000000000000", // 10 DAI (18 decimals)
          "10000000", // 10 USDC (6 decimals)
          "10000000", // 10 USDT (6 decimals)
        ],
        primaryAddress: "0xbEbc44782C7dB0a1A60Cb6fe97d0b483032FF1C7", // Curve 3pool
        receiver: "0x742d35Cc6634C0532925a3b844Bc454e4438f44e", // Optional: Receiver
      },
    },
  ],
);
console.log(JSON.stringify(bundle, null, 2));

Parameter	Description	Required
`tokenIn`	Array of addresses of tokens to deposit	Yes
`tokenOut`	Address of the LP token or receipt token to receive	No
`amountIn`	Array of amounts to deposit in wei (with full decimals). Must match the length of `tokenIn` array	Yes
`primaryAddress`	Address of the pool or protocol contract to interact with	Yes
`receiver`	Address to receive the LP tokens if not the caller	No

`tokenizedSingleDeposit`

Deprecation Notice: This action is deprecated in favor of using singleDeposit with the appropriate protocol. It will be removed in a future API version.

Deposits a single token and receives a tokenized position.

{
  "protocol": "compound-v3",
  "action": "tokenizedsingledeposit",
  "args": {
    "tokenIn": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
    "tokenOut": "0xc3d688B66703497DAA19211EEdff47f25384cdc3", // cUSDCv3
    "amountIn": "10000000", // 10 USDC (6 decimals)
    "primaryAddress": "0xc3d688B66703497DAA19211EEdff47f25384cdc3", // Compound market
    "receiver": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e" // Optional: Receiver
  }
}

Parameter	Description	Required
`tokenIn`	Address of token to deposit	Yes
`tokenOut`	Address of tokenized position to receive	Yes
`amountIn`	Amount of `tokenIn` to deposit in wei (with full decimals)	Yes
`primaryAddress`	Address of the protocol contract to interact with	Yes
`receiver`	Address to receive the position tokens if not the caller	No

`tokenizedMultiDeposit`

Deprecation Notice: This action is deprecated in favor of using multiDeposit with the appropriate protocol. It will be removed in a future API version.

Deposits multiple tokens and receives a tokenized position.

{
  "protocol": "balancer-v2",
  "action": "tokenizedmultideposit",
  "args": {
    "tokenIn": [
      "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599", // WBTC
      "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2" // WETH
    ],
    "tokenOut": "0x8353157092ED8Be69a9DF8F95af097bbF33Cb2aF", // BPT token
    "amountIn": [
      "100000", // 0.01 WBTC (8 decimals)
      "10000000000000000" // 0.01 WETH (18 decimals)
    ],
    "primaryAddress": "0x8353157092ED8Be69a9DF8F95af097bbF33Cb2aF", // Balancer Pool
    "receiver": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e" // Optional: Receiver
  }
}

Parameter	Description	Required
`tokenIn`	Array of addresses of tokens to deposit	Yes
`tokenOut`	Address of the tokenized position to receive	Yes
`amountIn`	Array of amounts to deposit in wei (with full decimals). Must match the length of `tokenIn` array	Yes
`primaryAddress`	Address of the protocol contract to interact with	Yes
`receiver`	Address to receive the position token if not the caller	No

`multiOutSingleDeposit`

Deposits a single token and receives multiple output tokens (typically used for certain AMM positions).

const bundle = await client.getBundleData(
  {
    chainId: 1,
    fromAddress: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
    routingStrategy: "delegate",
  },
  [
    {
      protocol: "uniswap-v3",
      action: "multioutsingledeposit",
      args: {
        tokenIn: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
        tokenOut: [
          "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599", // WBTC
          "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
        ],
        amountIn: "1000000000000000000", // 1 WETH (18 decimals)
        primaryAddress: "0x88e6A0c2dDD26FEEb64F039a2c41296FcB3f5640", // Uniswap pool
        receiver: "0x742d35Cc6634C0532925a3b844Bc454e4438f44e", // Optional: Receiver
      },
    },
  ],
);
console.log(JSON.stringify(bundle, null, 2));

Parameter	Description	Required
`tokenIn`	Address of the single token to deposit	Yes
`tokenOut`	Array of addresses of tokens to receive	Yes
`amountIn`	Amount of `tokenIn` to deposit in wei (with full decimals)	Yes
`primaryAddress`	Address of the protocol contract to interact with	Yes
`receiver`	Address to receive the output tokens if not the caller	No

Lending Actions

`flashloan`

Borrows tokens from a lending protocol without upfront collateral, executes callback actions atomically, and repays the debt within the same transaction.

Flashloans have dedicated documentation. See the Flashloans Reference for supported protocols, chain availability, parameters, and examples.

`borrow`

Borrows a token from a lending protocol using a deposited token as collateral.

const bundle = await client.getBundleData(
  {
    chainId: 1,
    fromAddress: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
    routingStrategy: "delegate",
  },
  [
    {
      protocol: "aave-v3",
      action: "deposit",
      args: {
        tokenIn: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", // WETH address
        tokenOut: "0x4d5F47FA6A74757f35C14fD3a6Ef8E3C9BC514E8", // aWETH address (optional)
        amountIn: "1000000000000000000", // Amount in wei (1 WETH)
        primaryAddress: "0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2", // Aave V3 pool
        receiver: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045", // Optional: Receiver address
      },
    },
    {
      protocol: "aave-v3",
      action: "borrow",
      args: {
        collateral: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", // WETH address (collateral)
        tokenOut: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48", // USDC address (to borrow)
        amountOut: "1000000000", // Amount to borrow in wei (1000 USDC with 6 decimals)
        primaryAddress: "0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2", // Aave V3 pool
      },
    },
  ],
);

Parameter	Description	Required
`collateral`	Address of the token used as collateral. Can be an array for multiple collateral tokens	Yes
`tokenOut`	Address of the token to borrow	Yes
`amountOut`	Amount to borrow in wei (with full decimals)	Yes
`primaryAddress`	Address of the lending pool contract	Yes

`repay`

Repays a loan on a lending protocol.

const bundle = await client.getBundleData(
  {
    chainId: 1,
    fromAddress: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
    routingStrategy: "delegate",
  },
  [
    {
      protocol: "aave-v3",
      action: "deposit",
      args: {
        tokenIn: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", // WETH address
        tokenOut: "0x4d5F47FA6A74757f35C14fD3a6Ef8E3C9BC514E8", // aWETH address (optional)
        amountIn: "1000000000000000000", // Amount in wei (1 WETH)
        primaryAddress: "0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2", // Aave V3 pool
        receiver: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045", // Optional: Receiver address
      },
    },
    {
      protocol: "aave-v3",
      action: "borrow",
      args: {
        collateral: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", // WETH address (collateral)
        tokenOut: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48", // USDC address (to borrow)
        amountOut: "1000000000", // Amount to borrow in wei (1000 USDC with 6 decimals)
        primaryAddress: "0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2", // Aave V3 pool
      },
    },
    // Step 3: Now repay the borrowed USDT
    {
      protocol: "aave-v3",
      action: "repay",
      args: {
        tokenIn: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48", // USDC
        amountIn: "1000000000", // 100 USDC
        primaryAddress: "0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2",
      },
    },
  ],
);

Parameter	Description	Required
`tokenIn`	Address of token to repay	Yes
`amountIn`	Amount to repay in wei (with full decimals)	Yes
`primaryAddress`	Address of the lending pool contract	Yes
`onBehalfOf`	Address to repay debt for	Yes

`repay` on Behalf of Another address

Repay parameter onBehalfOf enables you to repay a loan on behalf of a given address:

const bundleData = await client.getBundleData(
  {
    chainId: 1, // Mainnet
    fromAddress: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045" as Address,
    routingStrategy: "delegate",
  },
  [
    // 3. Repay the ETH debt
    {
      protocol: "compound-v2",
      action: "repay",
      args: {
        tokenIn: "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", // ETH
        amountIn: "300000000000000000",
        primaryAddress: "0x4Ddc2D193948926D02f9B1fE9e1daa0718270ED5", // cETH contract
        onBehalfOf: "0x80fCBfbC698Aca3B3BCB83ceB13301a639A39832",
      },
    },
  ],
);

console.log(bundleData);

Yield Farming Actions

`harvest`

Harvests rewards from yield-generating positions.

const bundle = await client.getBundleData(
  {
    chainId: 1,
    fromAddress: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
    routingStrategy: "delegate",
  },
  [
    {
      protocol: "curve-gauge",
      action: "harvest",
      args: {
        token: "0x7f39c581f595b53c5cb19bd0b3f8da6c935e2ca0", // Token address (LP token or gauge token)
        primaryAddress: "0x182B723a58739a9c974cFDB385ceaDb237453c28", // Curve gauge address
      },
    },
  ],
);

Parameter	Description	Required
`token`	Address of token to harvest rewards for	Yes
`primaryAddress`	Address of the contract to interact with (e.g., gauge, farm)	Yes

Token Management Actions

`approve`

Approves a spender to use tokens.

const bundle = await client.getBundleData(
  {
    chainId: 1,
    fromAddress: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
    routingStrategy: "delegate",
  },
  [
    {
      protocol: "erc20",
      action: "approve",
      args: {
        token: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", // WETH address
        spender: "0xe592427a0aece92de3edee1f18e0157c05861564", // Spender address (e.g., Uniswap router)
        amount: "1000000000000000000000000", // Amount to approve in wei (1M WETH)
      },
    },
  ],
);

Parameter	Description	Required
`token`	Address of the token to approve	Yes
`spender`	Address of the spender (protocol or router)	Yes
`amount`	Amount to approve in wei (with full decimals)	Yes

`transfer`

Transfers tokens to a specified address.

const bundle = await client.getBundleData(
  {
    chainId: 1,
    fromAddress: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
    routingStrategy: "delegate",
  },
  [
    {
      protocol: "erc20",
      action: "transfer",
      args: {
        token: "0xd26114cd6EE289AccF82350c8d8487fedB8A0C07", // OMG token address
        receiver: "0x80eba3855878739f4710233a8a19d89bdd2ffb8e", // Recipient address
        amount: "1000000000000000000", // Amount to transfer in wei (1 OMG)
      },
    },
  ],
);

Parameter	Description	Required
`token`	Address of the token to transfer	Yes
`receiver`	Address of the recipient	Yes
`amount`	Amount to transfer in wei (with full decimals)	Yes

For NFT transfers see erc721:transfer below.

`transferFrom`

Transfers tokens from a specified address to another address.

const bundle = await client.getBundleData(
  {
    chainId: 1,
    fromAddress: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
    routingStrategy: "delegate",
  },
  [
    {
      protocol: "enso",
      action: "balance",
      args: {
        token: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
      },
    },
    {
      protocol: "erc20",
      action: "transferfrom",
      args: {
        token: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // OMG token address
        sender: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045", // Sender address
        receiver: "0x93621DCA56fE26Cdee86e4F6B18E116e9758Ff11", // Recipient address
        amount: "1000000000000000000", // Amount to transfer in wei (1 OMG)
      },
    },
  ],
);

Parameter	Description	Required
`token`	Address of the token to transfer	Yes
`sender`	Address of the sender	Yes
`receiver`	Address of the recipient	Yes
`amount`	Amount to transfer in wei (with full decimals)	Yes

For NFT transfers see erc721:transferFrom below.

`erc721:transfer`

ERC-721 doesn’t expose a transfer(to, tokenId) selector — this is a UX alias that emits a transferFrom(walletAddress(), receiver, tokenId) call. Unlike erc721:transferFrom, this action’s input schema does not accept sender; the sender is always the executing wallet at runtime.

const bundle = await client.getBundleData(
  {
    chainId: 1,
    fromAddress: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
    routingStrategy: "delegate",
  },
  [
    {
      protocol: "erc721",
      action: "transfer",
      args: {
        token: "0x15da4c7db6404b92894d5214FAc92057Fb8a263d", // NFT collection address
        receiver: "0x93621DCA56fE26Cdee86e4F6B18E116e9758Ff11", // Recipient
        tokenId: "715", // Token id to transfer
      },
    },
  ],
);

Parameter	Description	Required
`token`	Address of the ERC-721 collection	Yes
`receiver`	Address of the recipient	Yes
`tokenId`	The ERC-721 token id to transfer	Yes

`erc721:approve`

Approves a spender to operate on a single ERC-721 token id. Mirrors erc20:approve but with tokenId in place of amount.

const bundle = await client.getBundleData(
  {
    chainId: 1,
    fromAddress: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
    routingStrategy: "delegate",
  },
  [
    {
      protocol: "erc721",
      action: "approve",
      args: {
        token: "0x15da4c7db6404b92894d5214FAc92057Fb8a263d", // NFT collection address
        spender: "0x000000000000000000000000000000000000dEaD", // Spender address
        tokenId: "715", // Token id to approve
      },
    },
  ],
);

Parameter	Description	Required
`token`	Address of the ERC-721 collection	Yes
`spender`	Address allowed to operate on the token id	Yes
`tokenId`	The ERC-721 token id to approve	Yes

ERC-721 approve(spender, tokenId) requires msg.sender to be the owner of the token id (or an approved operator). The effective msg.sender inside a bundle depends on routingStrategy — for router, that is the shared EnsoShortcuts contract; for delegate / ensowallet-v2, the per-user wallet. The token id must be owned by whichever address msg.sender resolves to at execution time.

`erc721:transferFrom`

Transfers an ERC-721 token id between two addresses. Mirrors erc20:transferfrom but takes tokenId instead of amount, and sender is optional — when omitted it defaults to the executing wallet.

const bundle = await client.getBundleData(
  {
    chainId: 1,
    fromAddress: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
    routingStrategy: "delegate",
  },
  [
    {
      protocol: "erc721",
      action: "transferfrom",
      args: {
        token: "0x15da4c7db6404b92894d5214FAc92057Fb8a263d", // NFT collection address
        receiver: "0x93621DCA56fE26Cdee86e4F6B18E116e9758Ff11", // Recipient
        tokenId: "715", // Token id to transfer
      },
    },
  ],
);

Parameter	Description	Required
`token`	Address of the ERC-721 collection	Yes
`receiver`	Address of the recipient	Yes
`tokenId`	The ERC-721 token id to transfer	Yes
`sender`	Address holding the token id. Defaults to the executing wallet when omitted.	No

`permitTransferFrom`

Approves and transfers a token that supports permit in a single step using a signature. A permit signature needs to be generated offchain and passed to the API.

const bundle = await client.getBundleData(
  {
    chainId: 1,
    fromAddress: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
    routingStrategy: "delegate",
  },
  [
    {
      protocol: "permit2",
      action: "permittransferfrom",
      args: {
        token: "0xd26114cd6EE289AccF82350c8d8487fedB8A0C07", // Token address
        amount: "1000000000000000000", // Amount in wei (1 token)
        sender: "0xb67f3CE46bB9E1a1127796c27f38DbaB9f643ec0", // Sender address
        receiver: "0x35a2839b617F7da6534d636f22945f6Cb6137130", // Receiver address
        nonce: "1", // Nonce to prevent replay attacks
        deadline: "1710150268", // Timestamp deadline for signature validity
        signature: "0x...", // Permit signature
      },
    },
  ],
);

Parameter	Description	Required
`token`	Address of the token to transfer. Can be an array for multiple tokens	Yes
`amount`	Amount to transfer in wei (with full decimals). Can be an array for multiple tokens	Yes
`sender`	Address of the sender	Yes
`receiver`	Address of the recipient	Yes
`nonce`	Nonce value to prevent signature replay	Yes
`deadline`	Timestamp after which the signature is invalid	Yes
`signature`	The EIP-2612 permit signature	Yes

Utility Actions

`balance`

Gets the balance of a token for the caller’s address.

const bundle = await client.getBundleData(
  {
    chainId: 1,
    fromAddress: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
    routingStrategy: "delegate",
  },
  [
    {
      protocol: "enso",
      action: "balance",
      args: {
        token: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
      },
    },
  ],
);

Parameter	Description	Required
`token`	Address of the token to check balance	Yes

The balance action supports advanced parameters for checking external account balances and building routes with estimated amounts. See the Advanced Balance Reference for details, risk considerations, and examples.

`split`

Routes one input amount into more than one tokenOut. It returns an array with one amount per output token; downstream actions must select each value with index. This is not an arbitrary percentage splitter. See Chaining actions for a complete split -> depositclmm example. A split must feed a compatible later deposit flow; it is not a terminal transfer action.

Parameter	Description	Required
`tokenIn`	Address of the token to split	Yes
`tokenOut`	Array of token addresses for the split outputs	Yes
`amountIn`	Base-unit amount or previous output reference	Yes
`receiver`	Address to receive the split tokens	No

`merge`

Routes more than one input token into a single output amount.

const bundle = await client.getBundleData(
  {
    chainId: 1,
    fromAddress: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
    routingStrategy: "delegate",
  },
  [
    {
      protocol: "enso",
      action: "merge",
      args: {
        tokenIn: [
          "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
          "0x6b175474e89094c44da98b954eedeac495271d0f", // DAI
        ],
        tokenOut: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // Combined WETH
        amountIn: [
          "2000000", // 2 USDC
          "3000000000000000000", // 3 DAI
        ],
        receiver: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
      },
    },
  ],
);

Parameter	Description	Required
`tokenIn`	Array of input token addresses	Yes
`tokenOut`	Address of the output token	Yes
`amountIn`	Base-unit amount for each corresponding input token	Yes
`receiver`	Address to receive the merged tokens	No

`call`

Makes an arbitrary contract call for interactions not covered by a public action. The return shape follows the supplied ABI, and output references can be used inside nested argument objects.

Arbitrary calls can transfer assets or grant permissions. Verify the target, ABI, calldata, and returned transaction before signing. See the custom contract call guide.

For arithmetic over prior outputs, prefer the documented Math Actions.

const bundle = await client.getBundleData(
  {
    chainId: 1,
    fromAddress: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
    routingStrategy: "delegate",
  },
  [
    {
      protocol: "enso",
      action: "call",
      args: {
        address: "0xD0aF6F692bFa10d6a535A3A321Dc8377F4EeEF12", // Contract address
        method: "percentMul", // Method name
        abi: "function percentMul(uint256,uint256) external", // ABI signature
        args: [
          "1000000000000000000", // 1 ETH (first argument)
          "7000", // 70% (second argument)
        ],
      },
    },
  ],
);

Parameter	Description	Required
`address`	Address of the contract to call	Yes
`method`	Name of the method to call	Yes
`abi`	ABI signature of the method	Yes
`args`	Array of arguments to pass to the method	Yes
`tokenIn`	Input token address (when tokens are involved in the call)	No
`tokenOut`	Output token address (when tokens are involved in the call)	No
`value`	ETH value to send with the transaction in wei	No

`fee`

Calculates and deducts a fee from a specified amount, sending the fee to a designated receiver. This action is typically prepended to bridge operations to facilitate fee collection. The fee action calculates the fee as amount * (bps/10000) and sends this amount to the receiver. It returns amount - fee, which can be used in subsequent actions via useOutputOfCallAt.

const bundle = await client.getBundleData(
  {
    chainId: 1,
    fromAddress: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
    routingStrategy: "delegate",
  },
  [
    {
      protocol: "enso",
      action: "fee",
      args: {
        token: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
        amount: "1000000000000",
        bps: "500",
        receiver: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
      },
    },
  ],
);

Parameter	Description	Required
`token`	Token address to apply the fee to	Yes
`amount`	Amount to apply the fee to (with full decimals) or a return value from a previous action	Yes
`bps`	Fee percentage in basis points (1 bps = 0.01%, 100 bps = 1%)	Yes
`receiver`	Address to receive the fee	Yes

`ensofee`

Calculates and deducts Enso’s protocol fee from a specified amount. The ensofee action calculates the fee as amount * (bps/10000) and sends this amount to Enso. It returns amount - fee, which can be used in subsequent actions via useOutputOfCallAt.

const bundle = await client.getBundleData(
  {
    chainId: 1,
    fromAddress: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
    routingStrategy: "delegate",
  },
  [
    {
      protocol: "enso",
      action: "ensofee",
      args: {
        token: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
        amount: "1000000000", // 1000 USDC
        bps: "25", // 0.25% fee (25 basis points)
      },
    },
  ],
);

Parameter	Description	Required
`token`	Token address to apply the fee to	Yes
`amount`	Amount to apply the fee to (with full decimals) or a return value from a previous action	Yes
`bps`	Fee percentage in basis points (1 bps = 0.01%, 100 bps = 1%)	Yes

Math Actions

Math actions perform on-chain arithmetic operations over values from previous actions. These are useful for computing amounts dynamically within a bundle — for example, dividing a routed amount to distribute across multiple recipients. All math actions use protocol math and take two operands: amountA and amountB. Each operand can be a static value or a reference to a previous action’s output via useOutputOfCallAt.

`add`

Returns amountA + amountB.

`sub`

Returns amountA - amountB.

`mul`

Returns amountA * amountB.

`div`

Returns amountA / amountB (integer division).

`min`

Returns the smaller of amountA and amountB.

`max`

Returns the larger of amountA and amountB. Example: Route then divide output by 2 and transfer halves to two addresses

const bundle = await client.getBundleData(
  {
    chainId: 1,
    fromAddress: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
    routingStrategy: "delegate",
    receiver: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
  },
  [
    {
      protocol: "enso",
      action: "route",
      args: {
        tokenIn: "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
        tokenOut: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
        amountIn: "1000000000000000000",
        slippage: "300",
      },
    },
    {
      protocol: "math",
      action: "div",
      args: {
        amountA: { useOutputOfCallAt: 0 },
        amountB: "2",
      },
    },
    {
      protocol: "erc20",
      action: "transfer",
      args: {
        token: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
        amount: { useOutputOfCallAt: 1 },
        receiver: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
      },
    },
    {
      protocol: "erc20",
      action: "transfer",
      args: {
        token: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
        amount: { useOutputOfCallAt: 1 },
        receiver: "0x93621DCA56fE26Cdee86e4F6B18E116e9758Ff11",
      },
    },
  ],
);

Parameter	Description	Required
`amountA`	First operand — a static uint256 value or a reference to a previous action’s output	Yes
`amountB`	Second operand — a static uint256 value or a reference to a previous action’s output	Yes

Helpers Actions

Helpers actions provide on-chain comparison and conditional logic, enabling bundles to branch based on runtime values. These are useful for building guard conditions, assertions, and conditional flows. All helpers actions use protocol helpers.

Comparison Actions

Compare two uint256 values and return a boolean result. The result can be referenced by subsequent actions.

`isequal`

Returns true if amountA == amountB.

`islessthan`

Returns true if amountA < amountB.

`isequalorlessthan`

Returns true if amountA <= amountB.

`isgreaterthan`

Returns true if amountA > amountB.

`isequalorgreaterthan`

Returns true if amountA >= amountB.

Parameter	Description	Required
`amountA`	First operand — a static uint256 value or a reference to a previous action’s output	Yes
`amountB`	Second operand — a static uint256 value or a reference to a previous action’s output	Yes

`check`

Asserts that a boolean condition is true. If the condition is false, the entire transaction reverts. Use this to enforce invariants — for example, ensuring an output amount meets a minimum threshold.

Parameter	Description	Required
`condition`	A boolean value or a reference to a comparison action’s output	Yes

`not`

Negates a boolean condition. Returns true if the input is false, and vice versa.

Parameter	Description	Required
`condition`	A boolean value or a reference to a comparison action’s output	Yes

`toggle`

Selects between two values based on a condition. Returns amountA if the condition is true, otherwise returns amountB. This is the on-chain equivalent of a ternary expression (condition ? amountA : amountB).

Parameter	Description	Required
`condition`	A boolean value or a reference to a comparison action’s output	Yes
`amountA`	The value to return if the condition is `true`	Yes
`amountB`	The value to return if the condition is `false`	Yes

Example: Check that a routed amount is above a minimum before proceeding

const bundle = await client.getBundleData(
  {
    chainId: 1,
    fromAddress: "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
    routingStrategy: "delegate",
  },
  [
    {
      protocol: "enso",
      action: "route",
      args: {
        tokenIn: "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
        tokenOut: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
        amountIn: "1000000000000000000",
        slippage: "300",
      },
    },
    {
      protocol: "helpers",
      action: "isequalorgreaterthan",
      args: {
        amountA: { useOutputOfCallAt: 0 },
        amountB: "1000000000", // minimum 1000 USDC
      },
    },
    {
      protocol: "helpers",
      action: "check",
      args: {
        condition: { useOutputOfCallAt: 1 },
      },
    },
  ],
);

Protocol Support

The Bundle API supports a wide range of protocols. Some common ones include:

aave-v2, aave-v3: Aave lending/borrowing
balancer-v2: Balancer liquidity pools
curve: Curve Finance stable swaps and gauges
curve-gauge: Curve gauges for staking
erc20: Standard token operations
erc721: Non-fungible token operations (approve, transfer, transferfrom)
erc4626: ERC4626 vaults
enso: General Enso operations including route, split, merge, balance, and arbitrary calls
math: On-chain arithmetic operations (add, sub, mul, div, min, max)
helpers: On-chain comparisons and conditional logic (isequal, islessthan, isgreaterthan, check, not, toggle)
permit2: Uniswap’s Permit2 operations
uniswap-v2, uniswap-v3: Uniswap pools and routers
yearn: Yearn Finance vaults
compound-v2, compound-v3: Compound lending/borrowing
stargate: Cross-chain bridging

For a complete list of supported protocols, use the Projects API endpoint: GET /standards.

Updated

​Action index

​Chaining actions

​Action outputs

​Ondo quote estimates

​Core actions

​route

​swap

​deposit

​redeem

​Bridging

​bridge

​Slippage protection

​slippage

​minAmountOut

​Deposit & Redeem Actions

​depositCLMM

​redeemCLMM

​singleDeposit

​multiDeposit

​tokenizedSingleDeposit

​tokenizedMultiDeposit

​multiOutSingleDeposit

​Lending Actions

​flashloan

​borrow

​repay

​repay on Behalf of Another address

​Yield Farming Actions

​harvest

​Token Management Actions

​approve

​transfer

​transferFrom

​erc721:transfer

​erc721:approve

​erc721:transferFrom

​permitTransferFrom

​Utility Actions

​balance

​split

​merge

​call

​fee

​ensofee

​Math Actions

​add

​sub

​mul

​div

​min

​max

​Helpers Actions

​Comparison Actions

​isequal

​islessthan

​isequalorlessthan

​isgreaterthan

​isequalorgreaterthan

​check

​not

​toggle

​Protocol Support

Action index

Chaining actions

Action outputs

Ondo quote estimates

Core actions

`route`

`swap`

`deposit`

`redeem`

Bridging

`bridge`

Slippage protection

`slippage`

`minAmountOut`

Deposit & Redeem Actions

`depositCLMM`

`redeemCLMM`

`singleDeposit`

`multiDeposit`

`tokenizedSingleDeposit`

`tokenizedMultiDeposit`

`multiOutSingleDeposit`

Lending Actions

`flashloan`

`borrow`

`repay`

`repay` on Behalf of Another address

Yield Farming Actions

`harvest`

Token Management Actions

`approve`

`transfer`

`transferFrom`

`erc721:transfer`

`erc721:approve`

`erc721:transferFrom`

`permitTransferFrom`

Utility Actions

`balance`

`split`

`merge`

`call`

`fee`

`ensofee`

Math Actions

`add`

`sub`

`mul`

`div`

`min`

`max`

Helpers Actions

Comparison Actions

`isequal`

`islessthan`

`isequalorlessthan`

`isgreaterthan`

`isequalorgreaterthan`

`check`

`not`

`toggle`

Protocol Support