​
Unstake styHONEY to BERA

Unstake a styHONEY position and convert it back to the native gas token, BERA, on Berachain. Try this route → Route Mechanics:
  • Redeem styHONEY to receive yHONEY.
  • Redeem yHONEY to receive HONEY.
  • Swap HONEY to BERA through Enso’s routing.
import { Address, EnsoClient, RouteParams } from "@ensofinance/sdk";

const BERACHAIN_MAINNET = 80094;
const userAddress = "your-wallet-address" as Address;

const styHONEY = "0x99d6A0FB9420F3995fD07dCc36AC827a8E146cf9" as Address;
const yHONEY = "0xC82971BcFF09171e16Ac08AEE9f4EA3fB16C3BDC" as Address;
const HONEY = "0xfcbd14dc51f0a4d49d5e53c2e0950e0bc26d0dce" as Address;
const BERA = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE" as Address;

const routeParams: RouteParams = {
 fromAddress: userAddress,
 receiver: userAddress,
 chainId: BERACHAIN_MAINNET,
 amountIn: ["1000000000000000000"], // 1 styHONEY
 tokenIn: [styHONEY],
 tokenOut: [BERA],
 routingStrategy: "delegate",
 slippage: "300", // 3% slippage for redemption
 referralCode: "styhoney-bera",
};

const route = await client.getRouteData(routeParams);
await sendSmartWallet(route.tx, route.gas);

​
Withdraw Yearn Curve mUSD Vault to USDC

Unwind a Yearn Curve mUSD vault position back to the base asset, USDC, on Ethereum. Try this route → 
const CurveMUSD_yVault = "0x8cc94ccd0f3841a468184aca3cc478d2148e1757" as Address; // Yearn Curve mUSD Pool yVault
const USDC = "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48" as Address;

const routeParams: RouteParams = {
 fromAddress: userAddress,
 receiver: userAddress,
 chainId: ETHEREUM_CHAIN,
 amountIn: ["1000000000000000000"], // Example amount for yVault token
 tokenIn: [CurveMUSD_yVault],
 tokenOut: [USDC],
 routingStrategy: "delegate",
 slippage: "100", // 1% slippage
};

const route = await client.getRouteData(routeParams);
await sendSmartWallet(route.tx, route.gas);
Route Mechanics:
  • Redeem from Yearn Curve mUSD Pool yVault ( 0x8cc94ccd0f3841a468184aca3cc478d2148e1757 ) to receive Curve mUSD LP tokens
  • Redeem from Curve.fi mUSD Pool ( 0x8474ddbe98f5aa3179b3b3f5942d724afcdec9f6 ) to receive Curve 3pool LP tokens
  • Redeem from Curve.fi 3pool ( 0xbebc44782c7db0a1a60cb6fe97d0b483032ff1c7 ) to receive USDC

​
Withdraw Yearn Curve alUSD Vault to USDC

Unwind a Yearn Curve alUSD vault position back to the base asset, USDC, on Ethereum. Try this route → 
const CurveAlUSD_yVault = "0xa74d4b67b3368e83797a35382afb776baae4f5c8" as Address; // Yearn Curve alUSD Pool yVault
const USDC = "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48" as Address;

const routeParams: RouteParams = {
 fromAddress: userAddress,
 receiver: userAddress,
 chainId: ETHEREUM_CHAIN,
 amountIn: ["1000000000000000000"], // Example amount for yVault token
 tokenIn: [CurveAlUSD_yVault],
 tokenOut: [USDC],
 routingStrategy: "delegate",
 slippage: "100", // 1% slippage
};

const route = await client.getRouteData(routeParams);
await sendSmartWallet(route.tx, route.gas);
Route Mechanics:
  • Redeem from Yearn Curve alUSD Pool yVault ( 0xa74d4b67b3368e83797a35382afb776baae4f5c8 ) to receive Curve alUSD LP tokens
  • Redeem from Curve.fi alUSD Pool ( 0x43b4fdfd4ff969587185cdb6f0bd875c5fc83f8c ) to receive Curve 3pool LP tokens
  • Redeem from Curve.fi 3pool ( 0xbebc44782c7db0a1a60cb6fe97d0b483032ff1c7 ) to receive USDC

​
Withdraw Rooster LP (nALPHA/pUSD) to Native Plume

Completely unwind a Rooster YAP LP (nALPHA/pUSD) position back to the native Plume token on Plume. Try this route → 
const ROOSTER_YAP_NALPHA_PUSD = "0xfc3bd0e01b4e755aedd2a4087ccdb90c4d28f038" as Address;
const PLUME = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee" as Address;

const routeParams: RouteParams = {
 fromAddress: userAddress,
 receiver: userAddress,
 chainId: ROOSTER_CHAIN,
 amountIn: ["100000000000000000000"], // 100 Rooster YAP tokens
 tokenIn: [ROOSTER_YAP_NALPHA_PUSD],
 tokenOut: [PLUME],
 routingStrategy: "delegate",
 slippage: "100", // 1% slippage
 referralCode: "rooster-exit-native",
};

const route = await client.getRouteData(routeParams);
await sendSmartWallet(route.tx, route.gas);
Route Mechanics:
  • Redeem Rooster YAP pool tokens to underlying PUSD and nALPHA
  • Merge tokens using the enso.merge action
  • Swap PUSD to native Plume via internal exchange
  • Swap nALPHA to native Plume via internal exchange
  • Consolidate native Plume tokens in user wallet

​
Unstake kHYPE to USDT0

Unstake kHYPE and convert the underlying assets to the USDT0 stablecoin on HyperEVM. Try this route → 
const KHYPE = "0xfd739d4e423301ce9385c1fb8850539d657c296d" as Address;
const USDT0 = "0xb8ce59fc3717ada4c02eadf9682a9e934f625ebb" as Address;

const routeParams: RouteParams = {
 fromAddress: userAddress,
 receiver: userAddress,
 chainId: HYPEREVM_CHAIN,
 amountIn: ["1000000000000000000"], // 1 kHYPE
 tokenIn: [KHYPE],
 tokenOut: [USDT0],
 routingStrategy: "delegate",
 slippage: "100", // 1% slippage
 referralCode: "kinetiq-withdraw",
};

const route = await client.getRouteData(routeParams);
await sendSmartWallet(route.tx, route.gas);
Route Mechanics:
  • Unstake kHYPE to HYPE via Kinetiq Protocol
  • Swap HYPE to USDT0 via internal exchange
  • Transfer USDT0 to user wallet

​
Unstake kHYPE to Native HYPE

Unstake kHYPE back to the native HYPE token on HyperEVM. Try this route → 
const KHYPE = "0xfd739d4e423301ce9385c1fb8850539d657c296d" as Address;
const HYPE = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee" as Address;

const routeParams: RouteParams = {
 fromAddress: userAddress,
 receiver: userAddress,
 chainId: HYPEREVM_CHAIN,
 amountIn: ["1000000000000000000"], // 1 kHYPE
 tokenIn: [KHYPE],
 tokenOut: [HYPE],
 routingStrategy: "delegate",
 slippage: "50", // 0.5% slippage
 referralCode: "kinetiq-unstake-native",
};

const route = await client.getRouteData(routeParams);
await sendSmartWallet(route.tx, route.gas);
Route Mechanics:
  • Unstake kHYPE to native HYPE.

​
Unstake kHYPE to KEI

Unstake kHYPE and convert the underlying assets to Wrapped Ethereum (KEI) on HyperEVM. Try this route → 
const KHYPE = "0xfd739d4e423301ce9385c1fb8850539d657c296d" as Address;
const KEI = "0xb5fe77d323d69eb352a02006ea8ecc38d882620c" as Address;

const routeParams: RouteParams = {
 fromAddress: userAddress,
 receiver: userAddress,
 chainId: HYPEREVM_CHAIN,
 amountIn: ["1000000000000000000"], // 1 kHYPE
 tokenIn: [KHYPE],
 tokenOut: [KEI],
 routingStrategy: "delegate",
 slippage: "100", // 1% slippage
 referralCode: "kinetiq-unstake-weth",
};

const route = await client.getRouteData(routeParams);
await sendSmartWallet(route.tx, route.gas);
Route Mechanics:
  • Unstake kHYPE to HYPE and swap to KEI (WETH).

​
Unstake kHYPE to UBTC

Unstake kHYPE and convert the underlying assets to Wrapped Bitcoin (UBTC) on HyperEVM. Try this route → 
const KHYPE = "0xfd739d4e423301ce9385c1fb8850539d657c296d" as Address;
const UBTC = "0x9fdbda0a5e284c32744d2f17ee5c74b284993463" as Address;

const routeParams: RouteParams = {
 fromAddress: userAddress,
 receiver: userAddress,
 chainId: HYPEREVM_CHAIN,
 amountIn: ["1000000000000000000"], // 1 kHYPE
 tokenIn: [KHYPE],
 tokenOut: [UBTC],
 routingStrategy: "delegate",
 slippage: "100", // 1% slippage
 referralCode: "kinetiq-unstake-wbtc",
};

const route = await client.getRouteData(routeParams);
await sendSmartWallet(route.tx, route.gas);
Route Mechanics:
  • Unstake kHYPE to HYPE and swap to UBTC.

​
Zap PLUME into Mystic myUSDC Vault

Deposit native PLUME and convert it into a myUSDC vault position on Mystic. Try this route → 
// SDK Example
const client = new EnsoClient({
apiKey: 'your-api-key'
});

const routeData = await client.getRouteData({
 fromAddress: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
 receiver: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
 chainId: 98866,
 amountIn: ['1000000000000000000'],
 slippage: '300',
 tokenIn: ['0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE'],
 tokenOut: ['0x6c92efa3F77760619bb13d395836415ac18C86dc'],
 routingStrategy: 'router'
});

// If using 'router' strategy, approval is often required for the input token.
await sendEoa(client.getApprovalData(routeData.route.tokenIn[0]));
await sendEoa(routeData.tx, routeData.gas);
Route Mechanics:
  • swap PLUME (input token) for USDC.e
  • deposit USDC.e into the myUSDC pool, interacting with primary 0xCE192A6E105cD8dd97b8Dedc5B5b263B52bb6AE0

​
Deposit native PLUME into Solera aPlunALPHA

Deposit native PLUME and convert it into a Solera aPlunALPHA vault position. Try this route → 
// SDK Example
const client = new EnsoClient({
apiKey: 'your-api-key'
});

const routeData = await client.getRouteData({
 fromAddress: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
 receiver: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
 chainId: 98866,
 amountIn: ['1000000000000000'],
 slippage: '300',
 tokenIn: ['0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE'],
 tokenOut: ['0x5d0EC9B10e6759719CeFE14b8c881634678b32f2'],
 routingStrategy: 'router'
});

// If using 'router' strategy, approval is often required for the input token.
await sendEoa(client.getApprovalData(routeData.route.tokenIn[0]));
await sendEoa(routeData.tx, routeData.gas);
Route Mechanics:
  • swap PLUME for PUSD using enso.swap action
  • deposit PUSD into NALPHA Nucleus pool, interacting with primary 0xc9f6a492fb1d623690dc065bbced6dfb4a324a35
  • deposit NALPHA into the Solera pool, interacting with primary 0x5d0ec9b10e6759719cefe14b8c881634678b32f2

​
Deposit USDC.e into Nucleus nYIELD Vault

Deposit bridged USDC.e and convert it into an nYIELD vault position on Nucleus. Try this route → 
// SDK Example
const client = new EnsoClient({
    apiKey: 'your-api-key'
});

const routeData = await client.getRouteData({
 fromAddress: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
 receiver: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
 chainId: 98866,
 amountIn: ['1000000000'],
 slippage: '300',
 tokenIn: ['0x78adD880A697070c1e765Ac44D65323a0DcCE913'],
 tokenOut: ['0x892DFf5257B39f7afB7803dd7C81E8ECDB6af3E8'],
 routingStrategy: 'delegate'
});
await sendSmartWallet(routeData.tx, routeData.gas);
Route Mechanics:
  • swap USDC for PUSD using enso.swap action
  • deposit PUSD into nYIELD Nucleus pool, interacting with primary 0x92a735f600175fe9ba350a915572a86f68ebbe66 to get nUSDY

​
Deposit USDC.e into Tempest PUSD Vault

Deposit bridged USDC.e and convert it into a Tempest PUSD vault position. Try this route → 
// SDK Example
const client = new EnsoClient({
apiKey: 'your-api-key'
});

const routeData = await client.getRouteData({
 fromAddress: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
 receiver: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
 chainId: 98866,
 amountIn: ['1000000000'],
 slippage: '300',
 tokenIn: ['0x78adD880A697070c1e765Ac44D65323a0DcCE913'],
 tokenOut: ['0x3C4F9804ce0810821F61289Eb4F92c8E5007c119'],
 routingStrategy: 'delegate'
});
await sendSmartWallet(routeData.tx, routeData.gas);
Route Mechanics:
  • swap USDC.e for PUSD using enso.swap action
  • deposit PUSD into Tempest pool, interacting with primary 0x3C4F9804ce0810821F61289Eb4F92c8E5007c119

​
Stake PLUME for pETH on Dinero

Deposit native PLUME and convert it into the pETH liquid staking derivative on Dinero. Try this route → 
// SDK Example
const client = new EnsoClient({
apiKey: 'your-api-key'
});

const routeData = await client.getRouteData({
 fromAddress: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
 receiver: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
 chainId: 98866,
 amountIn: ['1000000000'],
 slippage: '300',
 tokenIn: ['0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE'],
 tokenOut: ['0x39d1F90eF89C52dDA276194E9a832b484ee45574'],
 routingStrategy: 'delegate'
});
await sendSmartWallet(routeData.tx, routeData.gas);

​
Deposit PUSD into Rooster (nALPHA/PUSD) LP

Deposit PUSD and convert it into a Rooster (nALPHA/PUSD) LP position. Try this route → 
// SDK Example
const client = new EnsoClient({
apiKey: 'your-api-key'
});

const routeData = await client.getRouteData({
 fromAddress: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
 receiver: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
 chainId: 98866,
 amountIn: ['1000000000'],
 slippage: '300',
 tokenIn: ['0xdddd73f5df1f0dc31373357beac77545dc5a6f3f'],
 tokenOut: ['0xfc3bd0e01b4e755aedd2a4087ccdb90c4d28f038'],
 routingStrategy: 'delegate'
});
await sendSmartWallet(routeData.tx, routeData.gas);
Route Mechanics:
  • split PUSD to NALPHA and PUSD using the enso.split action
  • deposit NALPHA and PUSD into the Rooster pool, interacting with primary 0xfc3bd0e01b4e755aedd2a4087ccdb90c4d28f038

​
Deposit WETH into the Nest Alpha Vault

Deposit WETH and convert it into a Nest Alpha Vault position. Try this route → 
// SDK Example
const client = new EnsoClient({
apiKey: 'your-api-key'
});

const routeData = await client.getRouteData({
 fromAddress: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
 receiver: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
 chainId: 98866,
 amountIn: ['1000000000'],
 slippage: '300',
 tokenIn: ['0xca59ca09e5602fae8b629dee83ffa819741f14be'],
 tokenOut: ['0x593ccca4c4bf58b7526a4c164ceef4003c6388db'],
 routingStrategy: 'delegate'
});
await sendSmartWallet(routeData.tx, routeData.gas);
Route Mechanics:
  • swap WETH for PUSD using the enso.swap action
  • deposit PUSD into the Nest Vault, interacting with primary 0xc9f6a492fb1d623690dc065bbced6dfb4a324a35

​
Deposit USDC to get yDAI (Yearn)

Convert USDC to DAI and deposit it into the Yearn DAI v2 Vault. Try this route → 
const USDC = "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48" as Address;
const yvDAI = "0xda816459f1ab5631232fe5e97a05bbbb94970c95" as Address; // Yearn DAI v2 Vault token

const routeParams: RouteParams = {
 fromAddress: userAddress,
 receiver: userAddress,
 chainId: ETHEREUM_CHAIN,
 amountIn: ["1000000000"], // 1000 USDC
 tokenIn: [USDC],
 tokenOut: [yvDAI],
 routingStrategy: "delegate",
 slippage: "100", // 1% slippage
};

const route = await client.getRouteData(routeParams);
await sendSmartWallet(route.tx, route.gas);
Route Mechanics:
  • Swap USDC to DAI via Enso DEX Aggregator
  • Deposit DAI into Yearn DAI v2 Vault (0xda816459f1ab5631232fe5e97a05bbbb94970c95)

​
HONEY to yHONEY Zap

Deposit HONEY into the Bearn yHONEY vault. Try this route → 
import { Address, EnsoClient, RouteParams } from "@ensofinance/sdk";

const BERACHAIN_MAINNET = 80094;
const userAddress = "your-wallet-address" as Address;

const HONEY = "0xfcbd14dc51f0a4d49d5e53c2e0950e0bc26d0dce" as Address;
const yHONEY = "0xc82971BcFF09171e16Ac08AEE9f4EA3fB16C3BDC" as Address;

const routeParams: RouteParams = {
 fromAddress: userAddress,
 receiver: userAddress,
 chainId: BERACHAIN_MAINNET,
 amountIn: ["1000000000000000000"], // 1 HONEY
 tokenIn: [HONEY],
 tokenOut: [yHONEY],
 routingStrategy: "delegate",
 slippage: "50", // 0.5% slippage for stable yield
 referralCode: "bearn-deposit",
};

const route = await client.getRouteData(routeParams);
await sendSmartWallet(route.tx, route.gas);
Route Mechanics:
  • Swap HONEY to HONEY through Enso’s routing.
  • Deposit HONEY into Bearn yHONEY vault.

​
BERA to yHONEY Yield Zap

Convert native BERA into a Bearn yHONEY vault position. Try this route → 
import { Address, EnsoClient, RouteParams } from "@ensofinance/sdk";

const BERACHAIN_MAINNET = 80094;
const userAddress = "your-wallet-address" as Address;

const BERA = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE" as Address;
const yHONEY = "0xC82971BcFF09171e16Ac08AEE9f4EA3fB16C3BDC" as Address;

const routeParams: RouteParams = {
 fromAddress: userAddress,
 receiver: userAddress,
 chainId: BERACHAIN_MAINNET,
 amountIn: ["1500000000000000000"], // 1.5 BERA
 tokenIn: [BERA],
 tokenOut: [yHONEY],
 routingStrategy: "delegate",
 slippage: "100", // 1% slippage
 referralCode: "bera-yhoney",
};

const route = await client.getRouteData(routeParams);
await sendSmartWallet(route.tx, route.gas);
Route Mechanics:
  • Swap BERA to HONEY through Enso’s routing.
  • Deposit HONEY into Bearn yHONEY vault.

​
USDCe to yHONEY Vault Zap

Convert bridged USDC.e into a Bearn yHONEY vault position. Try this route → 
import { Address, EnsoClient, RouteParams } from "@ensofinance/sdk";

const BERACHAIN_MAINNET = 80094;
const userAddress = "your-wallet-address" as Address;

const USDCe = "0x549943e04f40284185054145c6E4e9568C1D3241" as Address;
const HONEY = "0xfcbd14dc51f0a4d49d5e53c2e0950e0bc26d0dce" as Address;
const yHONEY = "0xC82971BcFF09171e16Ac08AEE9f4EA3fB16C3BDC" as Address;

const routeParams: RouteParams = {
 fromAddress: userAddress,
 receiver: userAddress,
 chainId: BERACHAIN_MAINNET,
 amountIn: ["1000000000"], // 1,000 USDCe
 tokenIn: [USDCe],
 tokenOut: [yHONEY],
 routingStrategy: "delegate",
 slippage: "200", // 2% slippage for bridge + swap
 referralCode: "bridge-yhoney",
};

const route = await client.getRouteData(routeParams);
await sendSmartWallet(route.tx, route.gas);
Route Mechanics:
  • Swap USDCe to HONEY through Enso’s routing.
  • Deposit HONEY into Bearn yHONEY vault.

​
iBGT to yHONEY Vault Zap

Convert iBGT governance tokens into a Bearn yHONEY vault position. Try this route → 
import { Address, EnsoClient, RouteParams } from "@ensofinance/sdk";

const BERACHAIN_MAINNET = 80094;
const userAddress = "your-wallet-address" as Address;

const iBGT = "0xac03CABA51e17c86c921E1f6CBFBdC91F8BB2E6b" as Address;
const yHONEY = "0xC82971BcFF09171e16Ac08AEE9f4EA3fB16C3BDC" as Address;

const routeParams: RouteParams = {
 fromAddress: userAddress,
 receiver: userAddress,
 chainId: BERACHAIN_MAINNET,
 amountIn: ["500000000000000000"], // 0.5 iBGT
 tokenIn: [iBGT],
 tokenOut: [yHONEY],
 routingStrategy: "delegate",
 slippage: "400", // 4% slippage for governance token
 referralCode: "ibgt-yield",
};

const route = await client.getRouteData(routeParams);
await sendSmartWallet(route.tx, route.gas);
Route Mechanics:
  • Swap iBGT to HONEY through Enso’s routing.
  • Deposit HONEY into Bearn yHONEY vault.

​
YEET to styHONEY Yield Zap

Convert YEET tokens into a staked yield position (styHONEY). Try this route → 
import { Address, EnsoClient, RouteParams } from "@ensofinance/sdk";

const BERACHAIN_MAINNET = 80094;
const userAddress = "your-wallet-address" as Address;

const YEET = "0x08A38Caa631DE329FF2DAD1656CE789F31AF3142" as Address;
const styHONEY = "0x99d6A0FB9420F3995fD07dCc36AC827a8E146cf9" as Address;

const routeParams: RouteParams = {
 fromAddress: userAddress,
 receiver: userAddress,
 chainId: BERACHAIN_MAINNET,
 amountIn: ["100000000000000000000"], // 100 YEET
 tokenIn: [YEET],
 tokenOut: [styHONEY],
 routingStrategy: "delegate",
 slippage: "500", // 5% slippage for volatile meme token
 referralCode: "yeet-styhoney",
};

const route = await client.getRouteData(routeParams);
await sendSmartWallet(route.tx, route.gas);
Route Mechanics:
  • Swap YEET to HONEY through Enso’s routing.
  • Deposit HONEY into Bearn yHONEY vault.
  • Stake yHONEY to receive styHONEY.

​
Layer AUSD into Morpho bbqAUSD Vault

Deposit AUSD into a Yearn vault and subsequently into a Morpho Blue bbqAUSD vault. Try this route → 
import { Address, EnsoClient, RouteParams } from "@ensofinance/sdk";

const KATANA_MAINNET = 747474;
const userAddress = "your-wallet-address" as Address;

const AUSD = "0x00000000eFE302BEAA2b3e6e1b18d08D69a9012a" as Address;
const bbqAUSD = "0xdE6a4F28Acfe431DD1CfA2D9c7A3d8301624a841" as Address;

const routeParams: RouteParams = {
 fromAddress: userAddress,
 receiver: userAddress,
 chainId: KATANA_MAINNET,
 amountIn: ["1000000000"], // 1,000 AUSD
 tokenIn: [AUSD],
 tokenOut: [bbqAUSD],
 routingStrategy: "delegate",
 slippage: "150", // 1.5% slippage for multi-step
 referralCode: "ausd-morpho",
};

const route = await client.getRouteData(routeParams);
await sendSmartWallet(route.tx, route.gas);
Route Mechanics:
  • Deposit AUSD into Yearn AUSD vault to receive yvAUSD.
  • Deposit yvAUSD into Morpho Blue bbqAUSD vault for enhanced yield.

​
USDS to steakUSDC Prime Vault

Convert USDS into a Morpho Steakhouse prime USDC vault position. Try this route → 
const USDC_VB = "0x203a662b0bd271a6ed5a60edfbd04bfce608fd36" as Address; // Assuming USDS input is USDC_VB
const steakUSDC = "0x61d4f9d3797ba4da152238c53a6f93fb665c3c1d" as Address;

const routeParams: RouteParams = {
 fromAddress: userAddress,
 receiver: userAddress,
 chainId: KATANA_MAINNET,
 amountIn: ["1000000000"], // 1,000 USDS
 tokenIn: [USDC_VB],
 tokenOut: [steakUSDC],
 routingStrategy: "delegate",
 slippage: "150", // 1.5% slippage for prime vault
 referralCode: "usds-prime",
};
const route = await client.getRouteData(routeParams);
await sendSmartWallet(route.tx, route.gas);
Route Mechanics:
  • Convert USDC to USDS for stablecoin diversification.
  • Deposit USDS into Yearn vault for base yield.
  • Deposit vault tokens into Morpho steakUSDC prime vault.

​
Convert LBTC into Yearn WBTC Vault

Convert Liquid Bitcoin (LBTC) into a Yearn WBTC vault position. Try this route → 
const routeParams: RouteParams = {
 fromAddress: userAddress,
 receiver: userAddress,
 chainId: KATANA_MAINNET,
 amountIn: ["100000000"], // 1 LBTC
 tokenIn: [LBTC],
 tokenOut: [yvvbWBTC],
 routingStrategy: "delegate",
 slippage: "200", // 2% slippage for BTC yield
 referralCode: "lbtc-yield",
};
const route = await client.getRouteData(routeParams);
await sendSmartWallet(route.tx, route.gas);
Route Mechanics:
  • Convert LBTC to WBTC through liquidity protocols.
  • Deposit WBTC into Yearn vault for Bitcoin yield farming.

​
Compound KAT Rewards into Yearn USDC Vault

Convert KAT reward tokens into a Yearn USDC vault position. Try this route → 
const KAT = "0x7f1f4b4b29f5058fa32cc7a97141b8d7e5abdc2d" as Address;
const yvvbUSDC = "0x80c34bd3a3569e126e7055831036aa7b212cb159" as Address;

const routeParams: RouteParams = {
 fromAddress: userAddress,
 receiver: userAddress,
 chainId: KATANA_MAINNET,
 amountIn: ["10000000000000000000000"], // 10,000 KAT
 tokenIn: [KAT],
 tokenOut: [yvvbUSDC],
 routingStrategy: "delegate",
 slippage: "500", // 5% slippage for native token
 referralCode: "kat-compound",
};
const route = await client.getRouteData(routeParams);
await sendSmartWallet(route.tx, route.gas);
Route Mechanics:
  • Convert KAT rewards to USDC through DEX protocols.
  • Deposit USDC into Yearn vault for optimized yield.
  • Compound rewards automatically through vault strategies.

​
Zap PUSD into Rooster Stablecoin LP (USDT/pUSD)

Deposit PUSD to create a stablecoin LP position (USDT/pUSD) on Rooster Finance. Try this route → 
const PLUME_USD = "0xdddd73f5df1f0dc31373357beac77545dc5a6f3f" as Address;
const ROOSTER_YAP_USDT_PUSD = "0xd5c02efe86ebbc03126281e07b4d43f0b1021065" as Address;

const routeParams: RouteParams = {
 fromAddress: userAddress,
 receiver: userAddress,
 chainId: ROOSTER_CHAIN,
 amountIn: ["100000000000000000000"], // 100 PUSD
 tokenIn: [PLUME_USD],
 tokenOut: [ROOSTER_YAP_USDT_PUSD],
 routingStrategy: "delegate",
 slippage: "50", // 0.5% slippage
 referralCode: "rooster-usdt-pusd",
};

const route = await client.getRouteData(routeParams);
await sendSmartWallet(route.tx, route.gas);
Route Mechanics:
  • Split Plume USD between USDT and pUSD paths using the enso.split action
  • Swap portion of PUSD to USDT via internal exchange
  • Keep portion as pUSD (direct conversion)
  • Deposit USDT and pUSD into Rooster YAP stablecoin liquidity pool

​
Zap Plume USD into Rooster (nALPHA/pUSD) LP

Deposit Plume USD to create a balanced LP position (nALPHA/pUSD) on Rooster Finance. Try this route → 
const PLUME_USD = "0xdddd73f5df1f0dc31373357beac77545dc5a6f3f" as Address;
const ROOSTER_YAP_NALPHA_PUSD = "0xfc3bd0e01b4e755aedd2a4087ccdb90c4d28f038" as Address;

const routeParams: RouteParams = {
 fromAddress: userAddress,
 receiver: userAddress,
 chainId: ROOSTER_CHAIN,
 amountIn: ["100000000000000000000"], // 100 PUSD
 tokenIn: [PLUME_USD],
 tokenOut: [ROOSTER_YAP_NALPHA_PUSD],
 routingStrategy: "delegate",
 slippage: "100", // 1% slippage
 referralCode: "rooster-nalpha-pusd",
};

const route = await client.getRouteData(routeParams);
await sendSmartWallet(route.tx, route.gas);
Route Mechanics:
  • Split Plume USD between pUSD and nALPHA paths using the enso.split action
  • Keep portion as pUSD (direct conversion)
  • Swap portion of PUSD to nALPHA via internal exchange
  • Deposit pUSD and nALPHA into Rooster YAP nALPHA/pUSD pool

​
Zap Plume Native into Rooster (USDC.e/XAUM) LP

Deposit native PLUME to create a multi-asset LP position (USDC.e/XAUM) on Rooster Finance. Try this route → 
const PLUME = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee" as Address;
const ROOSTER_YAP_USDC_XAUM = "0xd9822928f894b12e5e4ea1ec2890ac233b9fd871" as Address;

const routeParams: RouteParams = {
 fromAddress: userAddress,
 receiver: userAddress,
 chainId: ROOSTER_CHAIN,
 amountIn: ["100000000000000000000"], // 100 PLUME
 tokenIn: [PLUME],
 tokenOut: [ROOSTER_YAP_USDC_XAUM],
 routingStrategy: "delegate",
 slippage: "100", // 1% slippage
 referralCode: "rooster-yap-zap",
};

const route = await client.getRouteData(routeParams);
await sendSmartWallet(route.tx, route.gas);
Route Mechanics:
  • Split native PLUME between USDC.e and XAUM conversion paths using the enso.split action
  • Swap portion of PLUME to USDC.e via internal exchange
  • Swap portion of PLUME to XAUM via internal exchange
  • Deposit USDC.e and XAUM into Rooster YAP-USDC.e-XAUM pool

​
Convert UETH to Staked HYPE (kHYPE)

Convert UETH stablecoin into a staked HYPE position (kHYPE). Try this route → 
const UETH = "0xbe6727b535545c67d5caa73dea54865b92cf7907" as Address;
const KHYPE = "0xfd739d4e423301ce9385c1fb8850539d657c296d" as Address;

const routeParams: RouteParams = {
 fromAddress: userAddress,
 receiver: userAddress,
 chainId: HYPEREVM_CHAIN,
 amountIn: ["1000000000000000000"], // 1 DAI
 tokenIn: [UETH],
 tokenOut: [KHYPE],
 routingStrategy: "delegate",
 slippage: "100", // 1% slippage
 referralCode: "kinetiq-dai-stake",
};

const route = await client.getRouteData(routeParams);
await sendSmartWallet(route.tx, route.gas);
Route Mechanics:
  • Swap UETH for HYPE and stake to kHYPE.