@sodax/sdk 2.0.0-rc.12 → 2.0.0-rc.14

package/dist/index.cjs

@@ -17,6 +17,7 @@ var anchor = require('@coral-xyz/anchor');
 var BN = require('bn.js');
 var IconSdkRaw = require('icon-sdk-js');
 var sdkTs = require('@injectivelabs/sdk-ts');
+var tx_js = require('cosmjs-types/cosmos/tx/v1beta1/tx.js');
 var networks = require('@injectivelabs/networks');
 var BigNumber5 = require('bignumber.js');
 var swapSdkCore = require('@pancakeswap/swap-sdk-core');
@@ -197,7 +198,8 @@ var SODAX_FEATURES = [
   "migration",
   "dex",
   "partner",
-  "recovery"
+  "recovery",
+  "leverageYield"
 ];
 
 // src/shared/utils/tiny-invariant.ts
@@ -330,7 +332,8 @@ var HubVaultSymbols = [
   "sodaNEAR",
   "sodaKAIA",
   "sodaSTX",
-  "sodaUSDS"
+  "sodaUSDS",
+  "sodaJITOSOL"
 ];
 var SodaTokens = {
   sodaBNB: {
@@ -557,6 +560,45 @@ var SodaTokens = {
     chainKey: ChainKeys.SONIC_MAINNET,
     hubAsset: "0x243b0c26c8b38793908d7C64e8510f21B19B4613",
     vault: "0x243b0c26c8b38793908d7C64e8510f21B19B4613"
+  },
+  sodaJITOSOL: {
+    symbol: "sodaJITOSOL",
+    name: "Soda JITOSOL",
+    decimals: 18,
+    address: "0xe1bad4400d947Bc4fa66f9c0A143D800002083a0",
+    chainKey: ChainKeys.SONIC_MAINNET,
+    hubAsset: "0xe1bad4400d947Bc4fa66f9c0A143D800002083a0",
+    vault: "0xe1bad4400d947Bc4fa66f9c0A143D800002083a0"
+  }
+};
+var LsodaSymbols = ["lsodaWEETH", "lsodaWSTETH", "lsodaJITOSOL"];
+var LsodaTokens = {
+  lsodaWEETH: {
+    symbol: "lsodaWEETH",
+    name: "Leveraged Soda weETH",
+    decimals: 18,
+    address: "0xD09de2f5070699A909c0FD32fb5A909d3886701D",
+    chainKey: ChainKeys.SONIC_MAINNET,
+    hubAsset: "0xD09de2f5070699A909c0FD32fb5A909d3886701D",
+    vault: "0xD09de2f5070699A909c0FD32fb5A909d3886701D"
+  },
+  lsodaWSTETH: {
+    symbol: "lsodaWSTETH",
+    name: "Leveraged Soda wstETH",
+    decimals: 18,
+    address: "0x136E5D1CEC5db1829E24941Eddd9C8640E02Ce7a",
+    chainKey: ChainKeys.SONIC_MAINNET,
+    hubAsset: "0x136E5D1CEC5db1829E24941Eddd9C8640E02Ce7a",
+    vault: "0x136E5D1CEC5db1829E24941Eddd9C8640E02Ce7a"
+  },
+  lsodaJITOSOL: {
+    symbol: "lsodaJITOSOL",
+    name: "Leveraged Soda JITOSOL",
+    decimals: 18,
+    address: "0xD7Ae4853E0f93682F5DaA14734F5D18cBa09Bd78",
+    chainKey: ChainKeys.SONIC_MAINNET,
+    hubAsset: "0xD7Ae4853E0f93682F5DaA14734F5D18cBa09Bd78",
+    vault: "0xD7Ae4853E0f93682F5DaA14734F5D18cBa09Bd78"
   }
 };
 var sonicSupportedTokens = {
@@ -623,7 +665,8 @@ var sonicSupportedTokens = {
     hubAsset: "0x7c7d53EEcda37a87ce0D5bf8E0b24512A48dC963",
     vault: SodaTokens.sodaSODA.address
   },
-  ...SodaTokens
+  ...SodaTokens,
+  ...LsodaTokens
 };
 var redbellySupportedTokens = {
   RBNT: {
@@ -833,7 +876,7 @@ var solanaSupportedTokens = {
     address: "J1toso1uCk3RLmjorhTtrVwY9HJ7X8V9yYac6Y7kGCPn",
     chainKey: ChainKeys.SOLANA_MAINNET,
     hubAsset: "0x942f89a324d2652e447b9fcf08effc9f9776a680",
-    vault: "0x942f89a324d2652e447b9fcf08effc9f9776a680"
+    vault: SodaTokens.sodaJITOSOL.address
   },
   mSOL: {
     symbol: "mSOL",
@@ -1266,6 +1309,15 @@ var baseSupportedTokens = {
     chainKey: ChainKeys.BASE_MAINNET,
     hubAsset: "0xaa81bb5ba3c972ab53605d3ba7e443a3de6d1cb9",
     vault: "0xaa81bb5ba3c972ab53605d3ba7e443a3de6d1cb9"
+  },
+  AERO: {
+    symbol: "AERO",
+    name: "Aerodrome Finance",
+    decimals: 18,
+    address: "0x940181a94A35A4569e4529A3CDfB74e38FD98631",
+    chainKey: ChainKeys.BASE_MAINNET,
+    hubAsset: "0x348e086ab6f424dfc575a325c28624ed23973173",
+    vault: "0x348e086ab6f424dfc575a325c28624ed23973173"
   }
 };
 var optimismSupportedTokens = {
@@ -1948,6 +2000,33 @@ var stellarSupportedTokens = {
     chainKey: ChainKeys.STELLAR_MAINNET,
     hubAsset: "0xD749B5FfFED7cEDaa3239abDd16D677179C29AEc",
     vault: SodaTokens.sodaSODA.address
+  },
+  sodaETH: {
+    symbol: "sodaETH",
+    name: "Soda ETH",
+    decimals: 7,
+    address: "CDK5EWVTZLGSLI6D5OSES7XUKWZUKBXDRNOWUVDNPP5RJRP5EYWCW7SL",
+    chainKey: ChainKeys.STELLAR_MAINNET,
+    hubAsset: "0x4985a4b72ac723723e9ae82382d12d77e9a715de",
+    vault: SodaTokens.sodaETH.address
+  },
+  sodaBTC: {
+    symbol: "sodaBTC",
+    name: "Soda BTC",
+    decimals: 7,
+    address: "CD6XWBW74YVFDQQYUM2GALCULMA5MAWGP6NTCWF3ZYXP4Z7MEVY4JKBX",
+    chainKey: ChainKeys.STELLAR_MAINNET,
+    hubAsset: "0xddee01f63c18843e2bac30cb702864d7632c83a2",
+    vault: SodaTokens.sodaBTC.address
+  },
+  sodaBNB: {
+    symbol: "sodaBNB",
+    name: "Soda BNB",
+    decimals: 7,
+    address: "CCXTXZAFLVNTMORVWYB6BGL7YEW3U3ONDAL2FGBRGDUQH7AGANVQPRS6",
+    chainKey: ChainKeys.STELLAR_MAINNET,
+    hubAsset: "0xa10be5f5c2dea7d272555dc73ea2a7317c3c5b63",
+    vault: SodaTokens.sodaBNB.address
   }
 };
 var suiSupportedTokens = {
@@ -3087,6 +3166,21 @@ var spokeChainConfig = {
         assetCode: "SODA",
         contractId: "CAH5LKJC2ZB4RVUVEVL2QWJWNJLHQE2UF767ILLQ5EQ4O3OURR2XIUGM",
         assetIssuer: "GDYUTHY75A7WUZJQDPOP66FB32BOYGZRXHWTWO4Q6LQTANT5X3V5HNFA"
+      },
+      {
+        assetCode: "sodaETH",
+        contractId: "CDK5EWVTZLGSLI6D5OSES7XUKWZUKBXDRNOWUVDNPP5RJRP5EYWCW7SL",
+        assetIssuer: "GDYUTHY75A7WUZJQDPOP66FB32BOYGZRXHWTWO4Q6LQTANT5X3V5HNFA"
+      },
+      {
+        assetCode: "sodaBTC",
+        contractId: "CD6XWBW74YVFDQQYUM2GALCULMA5MAWGP6NTCWF3ZYXP4Z7MEVY4JKBX",
+        assetIssuer: "GDYUTHY75A7WUZJQDPOP66FB32BOYGZRXHWTWO4Q6LQTANT5X3V5HNFA"
+      },
+      {
+        assetCode: "sodaBNB",
+        contractId: "CCXTXZAFLVNTMORVWYB6BGL7YEW3U3ONDAL2FGBRGDUQH7AGANVQPRS6",
+        assetIssuer: "GDYUTHY75A7WUZJQDPOP66FB32BOYGZRXHWTWO4Q6LQTANT5X3V5HNFA"
       }
     ],
     supportedTokens: stellarSupportedTokens,
@@ -3362,7 +3456,8 @@ var moneyMarketSupportedTokens = {
     spokeChainConfig[ChainKeys.SOLANA_MAINNET].supportedTokens.bnUSD,
     spokeChainConfig[ChainKeys.SOLANA_MAINNET].supportedTokens.USDC,
     spokeChainConfig[ChainKeys.SOLANA_MAINNET].supportedTokens.SODA,
-    spokeChainConfig[ChainKeys.SOLANA_MAINNET].supportedTokens.USDT
+    spokeChainConfig[ChainKeys.SOLANA_MAINNET].supportedTokens.USDT,
+    spokeChainConfig[ChainKeys.SOLANA_MAINNET].supportedTokens.JitoSOL
   ],
   [ChainKeys.ICON_MAINNET]: [
     // spokeChainConfig[ChainKeys.ICON].supportedTokens.ICX,
@@ -3373,7 +3468,10 @@ var moneyMarketSupportedTokens = {
     spokeChainConfig[ChainKeys.STELLAR_MAINNET].supportedTokens.XLM,
     spokeChainConfig[ChainKeys.STELLAR_MAINNET].supportedTokens.bnUSD,
     spokeChainConfig[ChainKeys.STELLAR_MAINNET].supportedTokens.SODA,
-    spokeChainConfig[ChainKeys.STELLAR_MAINNET].supportedTokens.USDC
+    spokeChainConfig[ChainKeys.STELLAR_MAINNET].supportedTokens.USDC,
+    spokeChainConfig[ChainKeys.STELLAR_MAINNET].supportedTokens.sodaETH,
+    spokeChainConfig[ChainKeys.STELLAR_MAINNET].supportedTokens.sodaBTC,
+    spokeChainConfig[ChainKeys.STELLAR_MAINNET].supportedTokens.sodaBNB
   ],
   [ChainKeys.SUI_MAINNET]: [
     spokeChainConfig[ChainKeys.SUI_MAINNET].supportedTokens.SUI,
@@ -3624,7 +3722,9 @@ var swapSupportedTokens = {
     spokeChainConfig[ChainKeys.SONIC_MAINNET].supportedTokens.USDT,
     spokeChainConfig[ChainKeys.SONIC_MAINNET].supportedTokens.wS,
     spokeChainConfig[ChainKeys.SONIC_MAINNET].supportedTokens.SODA,
-    ...Object.values(SodaTokens)
+    // sodaUSDS is staging-only — see stagingSwapSupportedTokens
+    ...Object.values(SodaTokens).filter((t) => t !== SodaTokens.sodaUSDS),
+    ...Object.values(LsodaTokens)
   ],
   [ChainKeys.AVALANCHE_MAINNET]: [
     spokeChainConfig[ChainKeys.AVALANCHE_MAINNET].supportedTokens.AVAX,
@@ -3643,36 +3743,35 @@ var swapSupportedTokens = {
     spokeChainConfig[ChainKeys.ARBITRUM_MAINNET].supportedTokens.tBTC,
     spokeChainConfig[ChainKeys.ARBITRUM_MAINNET].supportedTokens.USDC,
     spokeChainConfig[ChainKeys.ARBITRUM_MAINNET].supportedTokens.USDT,
-    spokeChainConfig[ChainKeys.ARBITRUM_MAINNET].supportedTokens.SODA,
     spokeChainConfig[ChainKeys.ARBITRUM_MAINNET].supportedTokens.ARB,
     spokeChainConfig[ChainKeys.ARBITRUM_MAINNET].supportedTokens.AAVE,
     spokeChainConfig[ChainKeys.ARBITRUM_MAINNET].supportedTokens.LINK,
     spokeChainConfig[ChainKeys.ARBITRUM_MAINNET].supportedTokens.UNI,
     spokeChainConfig[ChainKeys.ARBITRUM_MAINNET].supportedTokens.CRV,
     spokeChainConfig[ChainKeys.ARBITRUM_MAINNET].supportedTokens.PENDLE,
-    spokeChainConfig[ChainKeys.ARBITRUM_MAINNET].supportedTokens.rETH
+    spokeChainConfig[ChainKeys.ARBITRUM_MAINNET].supportedTokens.rETH,
+    spokeChainConfig[ChainKeys.ARBITRUM_MAINNET].supportedTokens.SODA
   ],
   [ChainKeys.BASE_MAINNET]: [
     spokeChainConfig[ChainKeys.BASE_MAINNET].supportedTokens.ETH,
-    spokeChainConfig[ChainKeys.BASE_MAINNET].supportedTokens.bnUSD,
     spokeChainConfig[ChainKeys.BASE_MAINNET].supportedTokens.weETH,
     spokeChainConfig[ChainKeys.BASE_MAINNET].supportedTokens.USDC,
     spokeChainConfig[ChainKeys.BASE_MAINNET].supportedTokens.wstETH,
     spokeChainConfig[ChainKeys.BASE_MAINNET].supportedTokens.cbBTC,
-    spokeChainConfig[ChainKeys.BASE_MAINNET].supportedTokens.SODA,
     spokeChainConfig[ChainKeys.BASE_MAINNET].supportedTokens.VIRTUAL,
-    spokeChainConfig[ChainKeys.BASE_MAINNET].supportedTokens.cbETH
+    spokeChainConfig[ChainKeys.BASE_MAINNET].supportedTokens.cbETH,
+    spokeChainConfig[ChainKeys.BASE_MAINNET].supportedTokens.SODA
   ],
   [ChainKeys.OPTIMISM_MAINNET]: [
     spokeChainConfig[ChainKeys.OPTIMISM_MAINNET].supportedTokens.ETH,
-    spokeChainConfig[ChainKeys.OPTIMISM_MAINNET].supportedTokens.bnUSD,
     spokeChainConfig[ChainKeys.OPTIMISM_MAINNET].supportedTokens.USDC,
     spokeChainConfig[ChainKeys.OPTIMISM_MAINNET].supportedTokens.wstETH,
     // spokeChainConfig[OPTIMISM_MAINNET_CHAIN_ID].supportedTokens.weETH, // NOTE: Not Implemented
     spokeChainConfig[ChainKeys.OPTIMISM_MAINNET].supportedTokens.USDT,
     spokeChainConfig[ChainKeys.OPTIMISM_MAINNET].supportedTokens.SODA,
     spokeChainConfig[ChainKeys.OPTIMISM_MAINNET].supportedTokens.OP,
-    spokeChainConfig[ChainKeys.OPTIMISM_MAINNET].supportedTokens.WBTC
+    spokeChainConfig[ChainKeys.OPTIMISM_MAINNET].supportedTokens.WBTC,
+    spokeChainConfig[ChainKeys.OPTIMISM_MAINNET].supportedTokens.bnUSD
   ],
   [ChainKeys.POLYGON_MAINNET]: [
     spokeChainConfig[ChainKeys.POLYGON_MAINNET].supportedTokens.POL,
@@ -3728,7 +3827,6 @@ var swapSupportedTokens = {
     spokeChainConfig[ChainKeys.LIGHTLINK_MAINNET].supportedTokens["SUI.LL"],
     spokeChainConfig[ChainKeys.LIGHTLINK_MAINNET].supportedTokens["S.LL"],
     spokeChainConfig[ChainKeys.LIGHTLINK_MAINNET].supportedTokens["POL.LL"],
-    spokeChainConfig[ChainKeys.LIGHTLINK_MAINNET].supportedTokens["HYPE.LL"],
     spokeChainConfig[ChainKeys.LIGHTLINK_MAINNET].supportedTokens.LL
   ],
   [ChainKeys.SOLANA_MAINNET]: [
@@ -3767,7 +3865,10 @@ var swapSupportedTokens = {
     spokeChainConfig[ChainKeys.STELLAR_MAINNET].supportedTokens.bnUSD,
     // NOTE: Not Implemented
     spokeChainConfig[ChainKeys.STELLAR_MAINNET].supportedTokens.USDC,
-    spokeChainConfig[ChainKeys.STELLAR_MAINNET].supportedTokens.SODA
+    spokeChainConfig[ChainKeys.STELLAR_MAINNET].supportedTokens.SODA,
+    spokeChainConfig[ChainKeys.STELLAR_MAINNET].supportedTokens.sodaETH,
+    spokeChainConfig[ChainKeys.STELLAR_MAINNET].supportedTokens.sodaBTC,
+    spokeChainConfig[ChainKeys.STELLAR_MAINNET].supportedTokens.sodaBNB
   ],
   [ChainKeys.SUI_MAINNET]: [
     spokeChainConfig[ChainKeys.SUI_MAINNET].supportedTokens.SUI,
@@ -3785,12 +3886,8 @@ var swapSupportedTokens = {
     spokeChainConfig[ChainKeys.SUI_MAINNET].supportedTokens.WAL,
     spokeChainConfig[ChainKeys.SUI_MAINNET].supportedTokens.NAVX
   ],
-  [ChainKeys.INJECTIVE_MAINNET]: [
-    spokeChainConfig[ChainKeys.INJECTIVE_MAINNET].supportedTokens.INJ,
-    spokeChainConfig[ChainKeys.INJECTIVE_MAINNET].supportedTokens.bnUSD,
-    spokeChainConfig[ChainKeys.INJECTIVE_MAINNET].supportedTokens.USDC
-    // spokeChainConfig[ChainKeys.INJECTIVE_MAINNET].supportedTokens.SODA, // NOTE: not in solver wiki
-  ],
+  // Injective is currently staging-only — see stagingSwapSupportedTokens
+  [ChainKeys.INJECTIVE_MAINNET]: [],
   [ChainKeys.NEAR_MAINNET]: [
     spokeChainConfig[ChainKeys.NEAR_MAINNET].supportedTokens.NEAR,
     spokeChainConfig[ChainKeys.NEAR_MAINNET].supportedTokens.bnUSD,
@@ -3857,24 +3954,112 @@ var swapSupportedTokens = {
     spokeChainConfig[ChainKeys.STACKS_MAINNET].supportedTokens.USDC
   ]
 };
+var stagingSwapSupportedTokens = {
+  [ChainKeys.SONIC_MAINNET]: [SodaTokens.sodaUSDS],
+  [ChainKeys.AVALANCHE_MAINNET]: [],
+  [ChainKeys.ARBITRUM_MAINNET]: [],
+  [ChainKeys.BASE_MAINNET]: [
+    spokeChainConfig[ChainKeys.BASE_MAINNET].supportedTokens.bnUSD,
+    spokeChainConfig[ChainKeys.BASE_MAINNET].supportedTokens.AERO
+  ],
+  [ChainKeys.OPTIMISM_MAINNET]: [],
+  [ChainKeys.POLYGON_MAINNET]: [
+    spokeChainConfig[ChainKeys.POLYGON_MAINNET].supportedTokens.USDT,
+    spokeChainConfig[ChainKeys.POLYGON_MAINNET].supportedTokens.wstETH
+  ],
+  [ChainKeys.BSC_MAINNET]: [],
+  [ChainKeys.HYPEREVM_MAINNET]: [],
+  [ChainKeys.LIGHTLINK_MAINNET]: [
+    spokeChainConfig[ChainKeys.LIGHTLINK_MAINNET].supportedTokens["HYPE.LL"]
+  ],
+  [ChainKeys.SOLANA_MAINNET]: [],
+  [ChainKeys.ICON_MAINNET]: [],
+  [ChainKeys.STELLAR_MAINNET]: [],
+  [ChainKeys.SUI_MAINNET]: [spokeChainConfig[ChainKeys.SUI_MAINNET].supportedTokens.USDT],
+  [ChainKeys.INJECTIVE_MAINNET]: [
+    spokeChainConfig[ChainKeys.INJECTIVE_MAINNET].supportedTokens.INJ,
+    spokeChainConfig[ChainKeys.INJECTIVE_MAINNET].supportedTokens.bnUSD,
+    spokeChainConfig[ChainKeys.INJECTIVE_MAINNET].supportedTokens.USDC
+    // spokeChainConfig[ChainKeys.INJECTIVE_MAINNET].supportedTokens.SODA, // NOTE: not in solver wiki
+  ],
+  [ChainKeys.NEAR_MAINNET]: [],
+  [ChainKeys.BITCOIN_MAINNET]: [],
+  [ChainKeys.ETHEREUM_MAINNET]: [
+    spokeChainConfig[ChainKeys.ETHEREUM_MAINNET].supportedTokens.wstETH,
+    spokeChainConfig[ChainKeys.ETHEREUM_MAINNET].supportedTokens.weETH
+  ],
+  [ChainKeys.REDBELLY_MAINNET]: [],
+  [ChainKeys.KAIA_MAINNET]: [],
+  [ChainKeys.STACKS_MAINNET]: []
+};
 var swapsConfig = {
-  partnerFee: void 0,
   supportedTokens: swapSupportedTokens
 };
 var getSupportedSolverTokens = (chainId) => swapSupportedTokens[chainId];
-var isSwapSupportedToken = (chainId, token) => swapSupportedTokens[chainId].some((t) => t.address.toLowerCase() === token.toLowerCase());
+var getStagingSolverTokens = (chainId) => [
+  ...swapSupportedTokens[chainId],
+  ...stagingSwapSupportedTokens[chainId]
+];
+var isSwapSupportedToken = (chainId, token) => [...swapSupportedTokens[chainId], ...stagingSwapSupportedTokens[chainId]].some((t) => t.address.toLowerCase() === token.toLowerCase());
 
-// ../types/dist/sodax-config/sodax-config.js
-var bridgeConfig = {
-  partnerFee: void 0
+// ../types/dist/leverageYield/leverageYield.js
+var leverageYieldVaults = [
+  {
+    name: LsodaTokens.lsodaWEETH.symbol,
+    vault: LsodaTokens.lsodaWEETH.vault,
+    asset: SodaTokens.sodaWEETH.address,
+    // sodaWEETH on Sonic
+    borrowToken: SodaTokens.sodaETH.address,
+    // sodaETH on Sonic
+    lsdSource: {
+      // DefiLlama pool for EtherFi's weETH on Ethereum (project: 'ether.fi-stake').
+      poolId: "46bd2bdf-6d92-4066-b482-e885ee172264",
+      fallbackAprPct: 3,
+      label: "EtherFi (weETH)"
+    }
+  },
+  {
+    name: LsodaTokens.lsodaWSTETH.symbol,
+    vault: LsodaTokens.lsodaWSTETH.vault,
+    asset: SodaTokens.sodaWSTETH.address,
+    // sodaWSTETH on Sonic
+    borrowToken: SodaTokens.sodaETH.address,
+    // sodaETH on Sonic
+    lsdSource: {
+      // DefiLlama pool for Lido's stETH on Ethereum (wstETH inherits this rate via redeem).
+      poolId: "747c1d2a-c668-4682-b9f9-296708a3dd90",
+      fallbackAprPct: 2.4,
+      label: "Lido (stETH)"
+    }
+  },
+  {
+    name: LsodaTokens.lsodaJITOSOL.symbol,
+    vault: LsodaTokens.lsodaJITOSOL.vault,
+    asset: SodaTokens.sodaJITOSOL.address,
+    // sodaJITOSOL on Sonic
+    borrowToken: SodaTokens.sodaSOL.address,
+    // sodaSOL on Sonic
+    lsdSource: {
+      // DefiLlama pool for Jito's JitoSOL native staking on Solana (project: 'jito-liquid-staking').
+      poolId: "0e7d0722-9054-4907-8593-567b353c0900",
+      fallbackAprPct: 5.5,
+      label: "Jito (JitoSOL)"
+    }
+  }
+];
+var leverageYieldConfig = {
+  vaults: leverageYieldVaults
 };
+
+// ../types/dist/sodax-config/sodax-config.js
+var bridgeConfig = {};
 var sodaxConfig = {
-  fee: void 0,
   chains: spokeChainConfig,
   swaps: swapsConfig,
   moneyMarket: moneyMarketConfig,
   bridge: bridgeConfig,
   dex: dexConfig,
+  leverageYield: leverageYieldConfig,
   hub: hubConfig,
   api: apiConfig,
   solver: solverConfig,
@@ -4016,7 +4201,7 @@ function isValidWalletProviderForChainKey(chainKey, walletProvider) {
 }
 
 // ../types/dist/index.js
-var CONFIG_VERSION = 210;
+var CONFIG_VERSION = 212;
 function isEvmSpokeChainConfig(value) {
   return typeof value === "object" && value !== null && value.chain.type === "EVM" && value.chain.key !== HUB_CHAIN_KEY;
 }
@@ -4403,7 +4588,10 @@ async function pollForExecutedPacket(payload) {
   }
   const txPackets = txPacketsResult.value;
   if (txPackets.success && txPackets.data.length > 0) {
-    const packet = txPackets.data.find((packet2) => packet2.src_tx_hash.toLowerCase() === payload.srcTxHash.toLowerCase());
+    const candidates = txPackets.data.filter(
+      (packet2) => packet2.src_tx_hash.toLowerCase() === payload.srcTxHash.toLowerCase()
+    );
+    const packet = payload.selectPacket ? payload.selectPacket(candidates) : candidates[0];
     if (packet?.status === "executed") {
       return { kind: "found", packet };
     }
@@ -13293,14 +13481,7 @@ function deepMerge(target, source) {
 
 // src/shared/config/mergeSodaxConfig.ts
 function mergeSodaxConfig(base2, override) {
-  const merged = deepMerge(base2, override);
-  if (override.fee !== void 0) {
-    merged.fee = override.fee;
-  }
-  if (override.bridge?.partnerFee !== void 0) {
-    merged.bridge.partnerFee = override.bridge.partnerFee;
-  }
-  return merged;
+  return deepMerge(base2, override);
 }
 
 // src/shared/logger.ts
@@ -13340,6 +13521,12 @@ var ConfigService = class {
    * {@link initialize}'s dynamic-config swap never clobbers it. Read by services via `config.logger`.
    */
   logger;
+  /**
+   * Global partner fee. Resolved once at construction and kept independent of {@link sodax} so that
+   * {@link initialize}'s dynamic-config swap never clobbers it. The backend never supplies it — it is
+   * a client-side option set via `new Sodax({ fee })`. Per-feature overrides live on the feature config.
+   */
+  fee;
   initialized = false;
   // data structures for quick lookup
   supportedHubAssetsSet;
@@ -13351,11 +13538,12 @@ var ConfigService = class {
   stakedATokenAddressesSet;
   chainToSupportedTokenAddressMap;
   hubAssetToXTokenMap;
-  constructor({ api, config, userConfig, logger }) {
+  constructor({ api, config, userConfig, logger, fee }) {
     this.api = api;
     this.sodax = config;
     this.userConfig = userConfig;
     this.logger = logger ?? resolveLogger(void 0);
+    this.fee = fee;
     this.loadSodaxConfigDataStructures(config);
   }
   async initialize() {
@@ -13588,6 +13776,24 @@ var ConfigService = class {
   get moneyMarket() {
     return this.sodax.moneyMarket;
   }
+  get leverageYield() {
+    return this.sodax.leverageYield;
+  }
+  // Effective partner fee per feature: the feature-specific override if set, otherwise the global
+  // `fee` client option ({@link fee}). The global fee is the default, overridable per-feature. `??`
+  // (never a merge) keeps the chosen PartnerFee variant intact — no discriminated-union hybrid.
+  get swapPartnerFee() {
+    return this.swaps.partnerFee ?? this.fee;
+  }
+  get moneyMarketPartnerFee() {
+    return this.moneyMarket.partnerFee ?? this.fee;
+  }
+  get bridgePartnerFee() {
+    return this.bridge.partnerFee ?? this.fee;
+  }
+  get leverageYieldPartnerFee() {
+    return this.leverageYield.partnerFee ?? this.fee;
+  }
   get dex() {
     return this.sodax.dex;
   }
@@ -14399,12 +14605,23 @@ var StacksSpokeService = class {
       postConditionMode: core.PostConditionMode.Allow
     };
     if (params.raw === true) {
-      if (core.validateStacksAddress(params.srcAddress)) {
-        throw new Error('When using raw transactions, the public key must be provided as "from" parameter');
+      if (!params.srcPublicKey) {
+        throw new Error("Stacks raw transactions require srcPublicKey (the signer public key for srcAddress).");
+      }
+      let derivedAddress;
+      try {
+        derivedAddress = core.getAddressFromPublicKey(params.srcPublicKey, this.network);
+      } catch (error) {
+        throw new Error(`srcPublicKey is not a valid Stacks public key: ${error.message}`);
+      }
+      if (derivedAddress !== params.srcAddress) {
+        throw new Error(
+          `srcPublicKey does not match srcAddress: it derives ${derivedAddress}, but srcAddress is ${params.srcAddress}.`
+        );
       }
       const tx = await core.makeUnsignedContractCall({
         ...reqData,
-        publicKey: params.srcAddress,
+        publicKey: params.srcPublicKey,
         network: this.network,
         fee: 0,
         // placeholder — we'll estimate
@@ -17360,8 +17577,8 @@ function chain(...args) {
   const id = (a) => a;
   const wrap = (a, b) => (c) => a(b(c));
   const encode3 = args.map((x) => x.encode).reduceRight(wrap, id);
-  const decode = args.map((x) => x.decode).reduce(wrap, id);
-  return { encode: encode3, decode };
+  const decode2 = args.map((x) => x.decode).reduce(wrap, id);
+  return { encode: encode3, decode: decode2 };
 }
 // @__NO_SIDE_EFFECTS__
 function alphabet(letters) {
@@ -22295,17 +22512,11 @@ var SuiSpokeService = class {
       ]
     });
     if (params.raw === true) {
-      tx.setSender(from);
-      const transactionRaw = await tx.build({
-        client: this.publicClient,
-        onlyTransactionKind: true
-      });
-      const transactionRawBase64String = Buffer.from(transactionRaw).toString("base64");
       return {
         from,
         to: `${assetManager.packageId}::${assetManager.moduleId}::transfer`,
         value: amount,
-        data: transactionRawBase64String
+        data: tx.serialize()
       };
     }
     return params.walletProvider.signAndExecuteTxn(tx);
@@ -22325,17 +22536,11 @@ var SuiSpokeService = class {
       ]
     });
     if (params.raw === true) {
-      txb.setSender(from);
-      const transactionRaw = await txb.build({
-        client: this.publicClient,
-        onlyTransactionKind: true
-      });
-      const transactionRawBase64String = Buffer.from(transactionRaw).toString("base64");
       return {
         from,
         to: `${connection.packageId}::${connection.moduleId}::send_message_ua`,
         value: 0n,
-        data: transactionRawBase64String
+        data: txb.serialize()
       };
     }
     return params.walletProvider.signAndExecuteTxn(txb);
@@ -22346,7 +22551,7 @@ var SuiSpokeService = class {
    * @returns {Promise<bigint>} The estimated computation cost.
    */
   async estimateGas({ tx }) {
-    const txb = transactions.Transaction.fromKind(tx.data);
+    const txb = transactions.Transaction.from(tx.data);
     const result = await this.publicClient.devInspectTransactionBlock({
       sender: tx.from,
       transactionBlock: txb
@@ -22577,6 +22782,7 @@ var CustomStellarAccount = class {
   decrementSequenceNumber() {
     if (this.sequenceNumber > this.startingSequenceNumber) {
       this.sequenceNumber--;
+      return;
     }
     throw new Error(
       `Sequence number cannot be decremented below the starting sequence number: ${this.startingSequenceNumber}`
@@ -22683,7 +22889,7 @@ var StellarSpokeService = class {
       );
       const assembledPriorityTx = stellarSdk.rpc.assembleTransaction(rawPriorityTx, simulation).build();
       if (params.raw) {
-        const transactionXdr = rawPriorityTx.toXDR();
+        const transactionXdr = assembledPriorityTx.toXDR();
         return {
           from,
           to: this.config.getChainConfig(srcChainKey).addresses.assetManager,
@@ -22800,7 +23006,7 @@ var StellarSpokeService = class {
       );
       const assembledPriorityTx = stellarSdk.rpc.assembleTransaction(rawPriorityTx, simulation).build();
       if (params.raw) {
-        const transactionXdr = rawPriorityTx.toXDR();
+        const transactionXdr = assembledPriorityTx.toXDR();
         return {
           from,
           to: this.config.getChainConfig(srcChainKey).addresses.assetManager,
@@ -23473,6 +23679,8 @@ var IconSpokeService = class {
     };
   }
 };
+var GAS_BUFFER_MULTIPLIER = 1.2;
+var GAS_PRICE_REGEX = /^(\d+)(.*)$/;
 var InjectiveSpokeService = class {
   config;
   chainGrpcWasmApi;
@@ -23480,6 +23688,7 @@ var InjectiveSpokeService = class {
   endpoints;
   pollingIntervalMs;
   maxTimeoutMs;
+  gasPrice;
   constructor(config) {
     this.config = config;
     this.endpoints = networks.getNetworkEndpoints(networks.Network.Mainnet);
@@ -23487,6 +23696,16 @@ var InjectiveSpokeService = class {
     this.txClient = new sdkTs.TxGrpcApi(this.endpoints.grpc);
     this.pollingIntervalMs = this.config.sodaxConfig.chains[ChainKeys.INJECTIVE_MAINNET].pollingConfig.pollingIntervalMs;
     this.maxTimeoutMs = this.config.sodaxConfig.chains[ChainKeys.INJECTIVE_MAINNET].pollingConfig.maxTimeoutMs;
+    this.gasPrice = this.config.getChainConfig(ChainKeys.INJECTIVE_MAINNET).gasPrice;
+  }
+  /** Parse a chain-config gas price like `"500000000inj"` into its numeric price and denom. */
+  parseGasPrice(gasPrice) {
+    const match = GAS_PRICE_REGEX.exec(gasPrice);
+    const price = match?.[1];
+    if (price === void 0) {
+      throw new Error(`Invalid Injective gasPrice config: ${gasPrice}`);
+    }
+    return { price: BigInt(price), denom: match?.[2] || "inj" };
   }
   /**
    * Estimate the gas for a transaction.
@@ -23495,7 +23714,7 @@ var InjectiveSpokeService = class {
    * @returns {Promise<InjectiveGasEstimate>} The estimated gas for the transaction.
    */
   async estimateGas({ tx }) {
-    const txRaw = sdkTs.CosmosTxV1Beta1TxPb.TxRaw.fromPartial({
+    const txRaw = tx_js.TxRaw.fromPartial({
       bodyBytes: tx.signedDoc.bodyBytes,
       authInfoBytes: tx.signedDoc.authInfoBytes,
       signatures: []
@@ -23534,7 +23753,9 @@ var InjectiveSpokeService = class {
         chainConfig.networkId,
         from,
         chainConfig.addresses.assetManager,
-        msg
+        msg,
+        void 0,
+        funds
       );
     }
     const res = await params.walletProvider.execute(from, chainConfig.addresses.assetManager, msg, funds);
@@ -23555,27 +23776,50 @@ var InjectiveSpokeService = class {
     );
     return BigInt(sdkTs.fromBase64(response.data));
   }
-  async getRawTransaction(chainId, senderAddress, contractAddress, msg, memo) {
+  async getRawTransaction(chainId, senderAddress, contractAddress, msg, memo, funds = []) {
     const msgExec = sdkTs.MsgExecuteContract.fromJSON({
       contractAddress,
       sender: senderAddress,
       msg,
-      funds: []
+      funds
     });
-    const { txRaw } = await sdkTs.createTransactionForAddressAndMsg({
+    const accountResponse = await new sdkTs.ChainRestAuthApi(this.endpoints.rest).fetchCosmosAccount(senderAddress);
+    const baseAccount = sdkTs.BaseAccount.fromRestCosmosApi(accountResponse);
+    const pubKey = baseAccount.pubKey.key;
+    if (!pubKey) {
+      throw new Error(`The pubKey for ${senderAddress} is missing \u2014 the account has not signed a transaction yet.`);
+    }
+    const txArgs = {
       message: msgExec,
       memo: memo || "",
-      address: senderAddress,
-      endpoint: this.endpoints.grpc,
+      pubKey,
+      sequence: baseAccount.sequence,
+      accountNumber: baseAccount.accountNumber,
       chainId
-    });
+    };
+    const draft = sdkTs.createTransaction(txArgs);
+    const { gasInfo } = await this.txClient.simulate(
+      tx_js.TxRaw.fromPartial({
+        bodyBytes: draft.txRaw.bodyBytes,
+        authInfoBytes: draft.txRaw.authInfoBytes,
+        signatures: []
+        // not required for simulation
+      })
+    );
+    const gas = Math.ceil(gasInfo.gasUsed * GAS_BUFFER_MULTIPLIER);
+    const { price, denom } = this.parseGasPrice(this.gasPrice);
+    const fee = {
+      amount: [{ denom, amount: (BigInt(gas) * price).toString() }],
+      gas: gas.toString()
+    };
+    const { txRaw, signDoc } = sdkTs.createTransaction({ ...txArgs, fee });
     const rawTx = {
       from: senderAddress,
       to: contractAddress,
       signedDoc: {
         bodyBytes: txRaw.bodyBytes,
         chainId,
-        accountNumber: BigInt(0),
+        accountNumber: BigInt(signDoc.accountNumber),
         authInfoBytes: txRaw.authInfoBytes
       }
     };
@@ -25714,6 +25958,24 @@ var SolverApiService = class {
     }
   }
 };
+function decodePacketIntentTarget(payload) {
+  try {
+    const hex = payload.startsWith("0x") ? payload.slice(2) : payload;
+    const decoded = rlp__namespace.decode(Buffer.from(hex, "hex"));
+    const field1 = decoded?.[1];
+    if (!field1 || field1.length === 0) return void 0;
+    return `0x${Buffer.from(field1).toString("hex")}`.toLowerCase();
+  } catch {
+    return void 0;
+  }
+}
+function selectSolvedIntentPacket(packets, intentsContract) {
+  if (packets.length <= 1) return packets[0];
+  const target = intentsContract.toLowerCase();
+  const matched = packets.find((packet) => decodePacketIntentTarget(packet.payload) === target);
+  if (matched) return matched;
+  return packets.reduce((highest, packet) => packet.conn_sn > highest.conn_sn ? packet : highest);
+}
 
 // src/swap/errors.ts
 var swapInvariant = createInvariant("swap");
@@ -25749,7 +26011,7 @@ var SwapService = class {
   relayerApiEndpoint;
   constructor({ config, hubProvider, spoke }) {
     this.solver = config.solver;
-    this.partnerFee = config.swaps.partnerFee;
+    this.partnerFee = config.swapPartnerFee;
     this.relayerApiEndpoint = config.relay.relayerApiEndpoint;
     this.config = config;
     this.hubProvider = hubProvider;
@@ -25767,10 +26029,13 @@ var SwapService = class {
   /**
    * Requests a price quote from the solver API for a given token pair and amount.
    *
-   * Adjusts `payload.amount` by the configured partner fee before forwarding to the solver,
-   * so the returned `quoted_amount` reflects the net output the user actually receives.
+   * Adjusts `payload.amount` by the partner fee before forwarding to the solver, so the returned
+   * `quoted_amount` reflects the net output the user actually receives. Pass `partnerFee` to match
+   * a per-action override supplied to `createIntent` (`extras.partnerFee`); omit it to use the
+   * configured swap fee.
    *
-   * @param payload - Source/destination tokens, chain IDs, input amount, and quote type.
+   * @param payload - The solver quote request, optionally carrying a per-call `partnerFee` override
+   *   (defaults to the configured swap partner fee). `partnerFee` is stripped before forwarding.
    * @returns A `Result` containing `{ quoted_amount: bigint }` on success, or a
    *   `SolverErrorResponse` (with a `SolverIntentErrorCode`) on failure.
    *
@@ -25786,11 +26051,12 @@ var SwapService = class {
    * if (response.ok) console.log('Quoted amount:', response.value.quoted_amount);
    */
   async getQuote(payload) {
-    payload = {
-      ...payload,
-      amount: adjustAmountByFee(payload.amount, this.partnerFee, payload.quote_type)
+    const { partnerFee = this.partnerFee, ...request } = payload;
+    const adjustedPayload = {
+      ...request,
+      amount: adjustAmountByFee(request.amount, partnerFee, request.quote_type)
     };
-    return SolverApiService.getQuote(payload, this.solver, this.config);
+    return SolverApiService.getQuote(adjustedPayload, this.solver, this.config);
   }
   /**
    * Calculates the partner fee that will be deducted from the given input amount.
@@ -26140,7 +26406,8 @@ var SwapService = class {
    *   - `UNKNOWN` — defensive fallback.
    */
   async createIntent(_params) {
-    const { params, skipSimulation } = _params;
+    const { params, skipSimulation, extras } = _params;
+    const partnerFee = extras?.partnerFee ?? this.partnerFee;
     const baseCtx = { srcChainKey: params.srcChainKey, dstChainKey: params.dstChainKey };
     try {
       swapInvariant(
@@ -26175,6 +26442,13 @@ var SwapService = class {
           { ...baseCtx, field: "minOutputAmount" }
         );
       }
+      if (isStacksChainKeyType(params.srcChainKey) && _params.raw === true) {
+        swapInvariant(
+          extras?.srcPublicKey !== void 0,
+          "srcPublicKey is required for Stacks createIntent (raw) \u2014 the source tx is built unsigned and needs the signer public key",
+          { ...baseCtx, field: "srcPublicKey" }
+        );
+      }
       const personalAddress = params.srcAddress;
       let walletAddress = personalAddress;
       if (isBitcoinChainKeyType(params.srcChainKey) && _params.raw === false) {
@@ -26192,7 +26466,7 @@ var SwapService = class {
           createIntentParams: params,
           creatorHubWalletAddress,
           solverConfig: this.solver,
-          fee: this.config.swaps.partnerFee,
+          fee: partnerFee,
           hubProvider: this.hubProvider
         };
         const [txResult2, intent2, feeAmount2, data2] = await SonicSpokeService.createSwapIntent(
@@ -26218,11 +26492,12 @@ var SwapService = class {
         },
         creatorHubWalletAddress,
         this.config,
-        this.config.swaps.partnerFee
+        partnerFee
       );
       const coreDepositParams = {
         srcChainKey: params.srcChainKey,
         srcAddress: walletAddress,
+        srcPublicKey: extras?.srcPublicKey,
         to: creatorHubWalletAddress,
         token: params.inputToken,
         amount: params.inputAmount,
@@ -26541,6 +26816,11 @@ var SwapService = class {
    * Use this after `getStatus` returns `SolverIntentStatusCode.SOLVED (3)` to obtain the
    * destination-chain transaction hash from `packet.dst_tx_hash`.
    *
+   * A single solver fill tx emits multiple relay packets sharing the same `src_tx_hash`. The
+   * user-facing `IntentFilled` delivery is the packet whose payload targets the hub intents
+   * contract; `selectSolvedIntentPacket` disambiguates so the returned `dst_tx_hash` is the
+   * destination delivery tx rather than an internal hop.
+   *
    * @param chainId - The destination spoke chain key (where output tokens are delivered).
    * @param fillTxHash - The solver's fill transaction hash, obtained from `getStatus.fill_tx_hash`.
    * @param timeout - Poll timeout in milliseconds. Defaults to `DEFAULT_RELAY_TX_TIMEOUT` (120 s).
@@ -26556,7 +26836,8 @@ var SwapService = class {
       intentRelayChainId: getIntentRelayChainId(chainId).toString(),
       srcTxHash: fillTxHash,
       timeout,
-      apiUrl: this.relayerApiEndpoint
+      apiUrl: this.relayerApiEndpoint,
+      selectPacket: (packets) => selectSolvedIntentPacket(packets, this.solver.intentsContract)
     });
   }
   /**
@@ -29081,10 +29362,10 @@ var BridgeService = class {
    * @returns Fee amount to be deducted, in the same units as `inputAmount`.
    */
   getFee(inputAmount) {
-    if (!this.config.bridge.partnerFee) {
+    if (!this.config.bridgePartnerFee) {
       return 0n;
     }
-    return calculateFeeAmount(inputAmount, this.config.bridge.partnerFee);
+    return calculateFeeAmount(inputAmount, this.config.bridgePartnerFee);
   }
   /**
    * Checks whether the caller has sufficient token allowance to execute the bridge.
@@ -29361,7 +29642,7 @@ var BridgeService = class {
       }
       const hubWallet = await this.hubProvider.getUserHubWalletAddress(walletAddress, params.srcChainKey);
       const effectiveSkipSimulation = skipSimulation || isBitcoinChainKeyType(params.srcChainKey) && this.spoke.bitcoin.walletMode === "USER";
-      const data = this.buildBridgeData(params, srcToken, dstToken, this.config.bridge.partnerFee);
+      const data = this.buildBridgeData(params, srcToken, dstToken, this.config.bridgePartnerFee);
       const coreParams = {
         srcChainKey: params.srcChainKey,
         srcAddress: walletAddress,
@@ -35240,7 +35521,7 @@ var MoneyMarketService = class _MoneyMarketService {
     this.config = config;
     this.hubProvider = hubProvider;
     this.spoke = spoke;
-    this.partnerFee = config.moneyMarket.partnerFee;
+    this.partnerFee = config.moneyMarketPartnerFee;
     this.relayerApiEndpoint = config.relay.relayerApiEndpoint;
     this.data = new MoneyMarketDataService({ hubProvider, config });
   }
@@ -37013,7 +37294,12 @@ var RecoveryService = class {
         srcChainKey: chainKey,
         field: "chainKey"
       });
-      const entries = Object.values(chainConfig.supportedTokens).filter((token) => viem.isAddress(token.hubAsset));
+      const leverageVaultAddresses = new Set(
+        this.config.sodaxConfig.leverageYield.vaults.map((vault) => vault.vault.toLowerCase())
+      );
+      const entries = Object.values(chainConfig.supportedTokens).filter(
+        (token) => viem.isAddress(token.hubAsset) && !leverageVaultAddresses.has(token.hubAsset.toLowerCase())
+      );
       if (entries.length === 0) {
         return { ok: true, value: [] };
       }
@@ -37115,6 +37401,871 @@ var RecoveryService = class {
   }
 };
 
+// src/leverageYield/errors.ts
+var leverageYieldInvariant = createInvariant("leverageYield");
+var LEVERAGE_YIELD_CODES = /* @__PURE__ */ new Set([
+  "VALIDATION_FAILED",
+  "INTENT_CREATION_FAILED",
+  "APPROVE_FAILED",
+  "ALLOWANCE_CHECK_FAILED",
+  "LOOKUP_FAILED",
+  "TX_VERIFICATION_FAILED",
+  "TX_SUBMIT_FAILED",
+  "RELAY_TIMEOUT",
+  "RELAY_FAILED",
+  "EXECUTION_FAILED",
+  "EXTERNAL_API_ERROR",
+  "UNKNOWN"
+]);
+var LEVERAGE_YIELD_POST_EXECUTION_CODES = /* @__PURE__ */ new Set([
+  "EXECUTION_FAILED",
+  "EXTERNAL_API_ERROR",
+  "UNKNOWN"
+]);
+var LEVERAGE_YIELD_SWAP_CODES = /* @__PURE__ */ new Set([
+  "VALIDATION_FAILED",
+  "INTENT_CREATION_FAILED",
+  "TX_VERIFICATION_FAILED",
+  "TX_SUBMIT_FAILED",
+  "RELAY_TIMEOUT",
+  "RELAY_FAILED",
+  "EXECUTION_FAILED",
+  "EXTERNAL_API_ERROR",
+  "UNKNOWN"
+]);
+var isLeverageYieldCreateIntentError = isCodeMember(CREATE_INTENT_CODES);
+var isLeverageYieldApproveError = isCodeMember(APPROVE_CODES);
+var isLeverageYieldAllowanceCheckError = isCodeMember(ALLOWANCE_CHECK_CODES);
+var isLeverageYieldLookupError = isCodeMember(LOOKUP_CODES);
+var isLeverageYieldPostExecutionError = isCodeMember(
+  LEVERAGE_YIELD_POST_EXECUTION_CODES
+);
+var isLeverageYieldSwapError = isCodeMember(LEVERAGE_YIELD_SWAP_CODES);
+var isLeverageYieldError = isCodeMember(LEVERAGE_YIELD_CODES);
+
+// src/leverageYield/LeverageYieldService.ts
+var leverageYieldVaultAbi = viem.parseAbi([
+  "function asset() view returns (address)",
+  "function getPositionDetails() view returns (uint256 collateral, uint256 debt, uint256 ltv, uint256 healthFactor, uint256 idleAsset)",
+  // Used by getApr() — read-only metadata that doesn't change per pass.
+  "function pool() view returns (address)",
+  "function borrowToken() view returns (address)",
+  "function targetLTV() view returns (uint256)"
+]);
+var INTENT_DEADLINE_BUFFER_SECONDS = 5 * 60;
+var ANY_SOLVER_ADDRESS = "0x0000000000000000000000000000000000000000";
+var MAX_WITHDRAW_DUST_BUFFER = 1000n;
+function pctToRay(aprPct) {
+  return BigInt(Math.round(aprPct * 1e9)) * 10n ** 16n;
+}
+var DEFILLAMA_FETCH_TIMEOUT_MS = 1e4;
+var DEFILLAMA_FETCH_MAX_ATTEMPTS = 2;
+async function fetchWithTimeout(url, timeoutMs) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { signal: controller.signal });
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+async function fetchDefillamaApr(poolId) {
+  return retry(async () => {
+    const response = await fetchWithTimeout(`https://yields.llama.fi/chart/${poolId}`, DEFILLAMA_FETCH_TIMEOUT_MS);
+    if (!response.ok) throw new Error(`DefiLlama APR fetch failed: HTTP ${response.status}`);
+    const json = await response.json();
+    const series = json?.data;
+    if (!Array.isArray(series) || series.length === 0) {
+      throw new Error("DefiLlama APR response: empty time series");
+    }
+    const latest = series[series.length - 1]?.apy;
+    if (typeof latest !== "number") throw new Error("DefiLlama APR: latest entry missing numeric apy");
+    return latest;
+  }, DEFILLAMA_FETCH_MAX_ATTEMPTS);
+}
+var LeverageYieldService = class {
+  hubProvider;
+  config;
+  spoke;
+  constructor({ hubProvider, config, spoke }) {
+    this.hubProvider = hubProvider;
+    this.config = config;
+    this.spoke = spoke;
+  }
+  // ─── Registry ──────────────────────────────────────────────────────────
+  /** Returns the static registry of known leverage-yield vaults. */
+  listVaults() {
+    return this.config.sodaxConfig.leverageYield.vaults;
+  }
+  /** Looks up a vault by its `name` field. Returns `undefined` when not registered. */
+  getVault(name) {
+    return this.listVaults().find((v) => v.name === name);
+  }
+  /**
+   * Looks up a registered vault by its on-chain proxy address (case-insensitive).
+   * Returns `undefined` when the address isn't in the registry.
+   */
+  getVaultByAddress(address) {
+    const normalized = address.toLowerCase();
+    return this.listVaults().find((v) => v.vault.toLowerCase() === normalized);
+  }
+  /**
+   * Resolves the intent `deadline`: returns the caller-supplied value verbatim, otherwise
+   * derives a default from the hub-chain (Sonic) block timestamp plus
+   * {@link INTENT_DEADLINE_BUFFER_SECONDS}. The deadline is enforced on-chain against the hub
+   * block time, so the default is anchored to that block — never the client clock, which can
+   * drift and produce an already-expired or over-extended deadline.
+   *
+   * Returns a {@link Result}: a `getBlock` RPC outage is a read failure, surfaced as
+   * `LOOKUP_FAILED` (`method: 'resolveDeadline'`) rather than masquerading as an intent-build
+   * failure. The `deposit` / `withdraw` callers forward it verbatim.
+   */
+  async resolveDeadline(deadline, srcChainKey) {
+    if (deadline !== void 0) return { ok: true, value: deadline };
+    try {
+      const block = await this.hubProvider.publicClient.getBlock({
+        includeTransactions: false,
+        blockTag: "latest"
+      });
+      return { ok: true, value: block.timestamp + BigInt(INTENT_DEADLINE_BUFFER_SECONDS) };
+    } catch (error) {
+      return { ok: false, error: lookupFailed("leverageYield", "resolveDeadline", error, { srcChainKey }) };
+    }
+  }
+  /**
+   * Builds the {@link LeverageYieldSwapPayload} for a leverage-yield deposit (any token → lsoda*).
+   * The lsoda* output is delivered to the user's hub wallet on Sonic so a later
+   * {@link LeverageYieldService.withdraw} can swap it back. Spread the result into
+   * {@link LeverageYieldService.vaultSwap}: `vaultSwap({ ...payload, walletProvider })`.
+   * An optional `partnerFee` is forwarded on the payload as the per-intent fee override.
+   *
+   * For `minOutputAmount`, quote via `sodax.swaps.getQuote` with the vault address as the
+   * destination token (`token_dst`) — vault shares are solver-tradeable, so the generic swap
+   * quote applies; then subtract your slippage tolerance.
+   */
+  async deposit(params) {
+    const baseCtx = { srcChainKey: params.srcChainKey, action: "deposit" };
+    try {
+      leverageYieldInvariant(params.inputAmount > 0n, "inputAmount must be greater than 0", {
+        ...baseCtx,
+        field: "inputAmount"
+      });
+      leverageYieldInvariant(params.vault.length > 0, "Vault address is required", { ...baseCtx, field: "vault" });
+      leverageYieldInvariant(params.inputToken.length > 0, "inputToken is required", {
+        ...baseCtx,
+        field: "inputToken"
+      });
+      const hubWallet = await this.hubProvider.getUserHubWalletAddress(params.srcAddress, params.srcChainKey);
+      const deadlineResult = await this.resolveDeadline(params.deadline, params.srcChainKey);
+      if (!deadlineResult.ok) return deadlineResult;
+      const deadline = deadlineResult.value;
+      return {
+        ok: true,
+        value: {
+          params: {
+            inputToken: params.inputToken,
+            outputToken: params.vault,
+            inputAmount: params.inputAmount,
+            minOutputAmount: params.minOutputAmount,
+            deadline,
+            allowPartialFill: false,
+            srcChainKey: params.srcChainKey,
+            dstChainKey: this.hubProvider.chainConfig.chain.key,
+            srcAddress: params.srcAddress,
+            dstAddress: hubWallet,
+            solver: params.solver ?? ANY_SOLVER_ADDRESS,
+            data: "0x"
+          },
+          // Per-intent fee override — only included when the caller supplies one, so the
+          // payload stays free of undefined-valued keys.
+          ...params.partnerFee !== void 0 && { partnerFee: params.partnerFee }
+        }
+      };
+    } catch (error) {
+      if (isLeverageYieldCreateIntentError(error)) return { ok: false, error };
+      return { ok: false, error: intentCreationFailed("leverageYield", error, baseCtx) };
+    }
+  }
+  /**
+   * Builds the {@link LeverageYieldSwapPayload} for a leverage-yield withdraw (lsoda* → any
+   * token). The payload carries `hubWalletSwap: true` — {@link LeverageYieldService.vaultSwap}
+   * then spends the lsoda* held in the user's hub wallet by authorising it via a
+   * `Connection.sendMessage` the user signs on `srcChainKey`. Wrapped in a {@link Result} for
+   * a call shape uniform with {@link LeverageYieldService.deposit}; async because the default
+   * `deadline` is read from the hub block timestamp.
+   *
+   * For `minOutputAmount`, quote via `sodax.swaps.getQuote` with the vault address as the
+   * source token (`token_src`) — vault shares are solver-tradeable, so the generic swap quote
+   * applies; then subtract your slippage tolerance.
+   */
+  async withdraw(params) {
+    const baseCtx = { srcChainKey: params.srcChainKey, action: "withdraw" };
+    try {
+      leverageYieldInvariant(params.inputAmount > 0n, "inputAmount must be greater than 0", {
+        ...baseCtx,
+        field: "inputAmount"
+      });
+      leverageYieldInvariant(params.vault.length > 0, "Vault address is required", { ...baseCtx, field: "vault" });
+      leverageYieldInvariant(params.outputToken.length > 0, "outputToken is required", {
+        ...baseCtx,
+        field: "outputToken"
+      });
+      const deadlineResult = await this.resolveDeadline(params.deadline, params.srcChainKey);
+      if (!deadlineResult.ok) return deadlineResult;
+      const deadline = deadlineResult.value;
+      return {
+        ok: true,
+        value: {
+          params: {
+            inputToken: params.vault,
+            outputToken: params.outputToken,
+            inputAmount: params.inputAmount,
+            minOutputAmount: params.minOutputAmount,
+            deadline,
+            allowPartialFill: false,
+            srcChainKey: params.srcChainKey,
+            dstChainKey: params.dstChainKey,
+            srcAddress: params.srcAddress,
+            dstAddress: params.recipient ?? params.srcAddress,
+            solver: params.solver ?? ANY_SOLVER_ADDRESS,
+            data: "0x"
+          },
+          hubWalletSwap: true
+        }
+      };
+    } catch (error) {
+      if (isLeverageYieldCreateIntentError(error)) return { ok: false, error };
+      return { ok: false, error: intentCreationFailed("leverageYield", error, baseCtx) };
+    }
+  }
+  /**
+   * Creates a vault swap intent on the user's source spoke chain without submitting it to
+   * the solver. Leverage-yield copy of the swap domain's `createIntent`, specialised for
+   * vault flows — duplicated deliberately so the vault-specific execution modifiers
+   * (`hubWalletSwap`, per-intent `partnerFee`) stay off the generic swap surface.
+   *
+   * Use {@link LeverageYieldService.vaultSwap} for the full end-to-end flow
+   * (create → relay → notify solver); use this directly when you need the raw transaction
+   * or drive the relay yourself (e.g. the backend submit-tx path). To complete a manual flow,
+   * relay the returned `relayData` (the shared `relayTxAndWaitPacket` helper) and then call
+   * {@link LeverageYieldService.notifySolver} with the hub-side intent tx hash.
+   *
+   * @param _params - Intent parameters, source chain key, wallet provider (when `raw: false`),
+   *   and optional `skipSimulation` / `hubWalletSwap` / `partnerFee`.
+   * @returns A `Result<CreateVaultIntentResult<K, Raw>, LeverageYieldCreateIntentError>`.
+   *   On success contains:
+   *   - `tx` — chain-specific tx hash (executed) or raw tx data (raw mode).
+   *   - `intent` — the fully constructed `Intent` object augmented with `feeAmount`.
+   *   - `relayData` — `{ address, payload }` needed to submit the intent to the relayer.
+   *
+   *   On failure `result.error` is a SodaxError with `VALIDATION_FAILED` (invariant
+   *   precondition), `INTENT_CREATION_FAILED` (spoke-side creation/deposit failed) or
+   *   `UNKNOWN` (defensive fallback).
+   */
+  async createVaultIntent(_params) {
+    const { params, skipSimulation, hubWalletSwap, partnerFee = this.config.swapPartnerFee } = _params;
+    const baseCtx = { srcChainKey: params.srcChainKey, dstChainKey: params.dstChainKey };
+    try {
+      leverageYieldInvariant(
+        isUndefinedOrValidWalletProviderForChainKey(params.srcChainKey, _params.walletProvider),
+        `Invalid wallet provider for chain key: ${params.srcChainKey}`,
+        baseCtx
+      );
+      const hubChainKey = this.hubProvider.chainConfig.chain.key;
+      const inputTokenChainKey = hubWalletSwap ? hubChainKey : params.srcChainKey;
+      leverageYieldInvariant(
+        this.config.isValidOriginalAssetAddress(inputTokenChainKey, params.inputToken),
+        `Unsupported spoke chain token (srcChainKey: ${inputTokenChainKey}, inputToken: ${params.inputToken})`,
+        { ...baseCtx, field: "inputToken" }
+      );
+      leverageYieldInvariant(
+        this.config.isValidOriginalAssetAddress(params.dstChainKey, params.outputToken),
+        `Unsupported spoke chain token (params.dstChain: ${params.dstChainKey}, params.outputToken: ${params.outputToken})`,
+        { ...baseCtx, field: "outputToken" }
+      );
+      leverageYieldInvariant(
+        this.config.isValidSpokeChainKey(params.srcChainKey),
+        `Invalid spoke chain (srcChainKey): ${params.srcChainKey}`,
+        { ...baseCtx, field: "srcChainKey" }
+      );
+      leverageYieldInvariant(
+        this.config.isValidSpokeChainKey(params.dstChainKey),
+        `Invalid spoke chain (params.dstChain): ${params.dstChainKey}`,
+        { ...baseCtx, field: "dstChainKey" }
+      );
+      if (isBitcoinChainKey(params.dstChainKey) && params.outputToken === "BTC") {
+        leverageYieldInvariant(
+          params.minOutputAmount >= 546n,
+          `Invalid minOutputAmount (params.minOutputAmount): ${params.minOutputAmount}`,
+          { ...baseCtx, field: "minOutputAmount" }
+        );
+      }
+      const personalAddress = params.srcAddress;
+      let walletAddress = personalAddress;
+      if (isBitcoinChainKeyType(params.srcChainKey) && _params.raw === false) {
+        leverageYieldInvariant(
+          isBitcoinWalletProviderType(_params.walletProvider),
+          `Invalid wallet provider for chain key: ${params.srcChainKey}`,
+          baseCtx
+        );
+        walletAddress = await this.spoke.bitcoin.getEffectiveWalletAddress(personalAddress);
+        await this.spoke.bitcoin.radfi.ensureRadfiAccessToken(_params.walletProvider);
+      }
+      const creatorHubWalletAddress = await this.hubProvider.getUserHubWalletAddress(walletAddress, params.srcChainKey);
+      if (hubWalletSwap) {
+        const [data2, intent2, feeAmount2] = EvmSolverService.constructCreateIntentData(
+          { ...params, srcChainKey: hubChainKey, srcAddress: creatorHubWalletAddress },
+          creatorHubWalletAddress,
+          this.config,
+          partnerFee
+        );
+        const coreSendMessageParams = {
+          srcChainKey: params.srcChainKey,
+          // Personal address — NOT the resolved trading `walletAddress`. SpokeService.sendMessage
+          // re-resolves the effective (Bitcoin trading) address itself; passing the already-resolved
+          // trading address here would double-resolve it (getTradingWallet(tradingAddress) →
+          // "Trading wallet not found"). The trading address is used only for the hub-wallet
+          // derivation above (creatorHubWalletAddress). Mirrors MoneyMarketService borrow/withdraw.
+          srcAddress: personalAddress,
+          dstChainKey: hubChainKey,
+          dstAddress: creatorHubWalletAddress,
+          payload: data2,
+          skipSimulation
+        };
+        const txResult2 = await this.spoke.sendMessage(
+          _params.raw ? { ...coreSendMessageParams, raw: true } : {
+            ...coreSendMessageParams,
+            raw: false,
+            walletProvider: _params.walletProvider
+          }
+        );
+        if (!txResult2.ok) {
+          if (isLeverageYieldCreateIntentError(txResult2.error)) {
+            return { ok: false, error: txResult2.error };
+          }
+          return { ok: false, error: intentCreationFailed("leverageYield", txResult2.error, baseCtx) };
+        }
+        return {
+          ok: true,
+          value: {
+            tx: txResult2.value,
+            intent: { ...intent2, feeAmount: feeAmount2 },
+            relayData: { address: creatorHubWalletAddress, payload: data2 }
+          }
+        };
+      }
+      if (isHubChainKeyType(params.srcChainKey) && isSonicChainKeyType(params.srcChainKey)) {
+        const coreSonicParams = {
+          createIntentParams: params,
+          creatorHubWalletAddress,
+          solverConfig: this.config.solver,
+          fee: partnerFee,
+          hubProvider: this.hubProvider
+        };
+        const [txResult2, intent2, feeAmount2, data2] = await SonicSpokeService.createSwapIntent(
+          _params.raw ? { ...coreSonicParams, raw: true } : {
+            ...coreSonicParams,
+            raw: false,
+            walletProvider: _params.walletProvider
+          }
+        );
+        return {
+          ok: true,
+          value: {
+            tx: txResult2,
+            intent: { ...intent2, feeAmount: feeAmount2 },
+            relayData: { address: intent2.creator, payload: data2 }
+          }
+        };
+      }
+      const [data, intent, feeAmount] = EvmSolverService.constructCreateIntentData(
+        {
+          ...params,
+          srcAddress: walletAddress
+        },
+        creatorHubWalletAddress,
+        this.config,
+        partnerFee
+      );
+      const coreDepositParams = {
+        srcChainKey: params.srcChainKey,
+        srcAddress: walletAddress,
+        to: creatorHubWalletAddress,
+        token: params.inputToken,
+        amount: params.inputAmount,
+        data,
+        skipSimulation
+      };
+      const txResult = await this.spoke.deposit(
+        _params.raw ? {
+          ...coreDepositParams,
+          raw: true
+        } : {
+          ...coreDepositParams,
+          raw: false,
+          walletProvider: _params.walletProvider
+        }
+      );
+      if (!txResult.ok) {
+        if (isLeverageYieldCreateIntentError(txResult.error)) {
+          return { ok: false, error: txResult.error };
+        }
+        return {
+          ok: false,
+          error: intentCreationFailed("leverageYield", txResult.error, baseCtx)
+        };
+      }
+      return {
+        ok: true,
+        value: {
+          tx: txResult.value,
+          intent: { ...intent, feeAmount },
+          relayData: { address: intent.creator, payload: data }
+        }
+      };
+    } catch (error) {
+      if (isLeverageYieldCreateIntentError(error)) return { ok: false, error };
+      return {
+        ok: false,
+        error: intentCreationFailed("leverageYield", error, baseCtx)
+      };
+    }
+  }
+  /**
+   * Executes a full end-to-end leverage-yield vault swap (deposit or withdraw).
+   * Leverage-yield copy of the swap domain's `swap()` orchestrator:
+   * 1. Calls {@link LeverageYieldService.createVaultIntent} to submit the intent
+   *    transaction on the source spoke chain.
+   * 2. Verifies the spoke transaction landed on-chain.
+   * 3. For non-hub source chains: submits the spoke tx to the relayer and waits for the
+   *    relay packet to land on the hub (Sonic). Skipped when `srcChainKey` is the hub.
+   * 4. Notifies the solver, triggering it to fill the intent.
+   *
+   * Spread a {@link LeverageYieldSwapPayload} from `deposit` / `withdraw` into this method
+   * alongside the wallet provider: `vaultSwap({ ...payload, walletProvider })`.
+   *
+   * @returns A `Result<VaultSwapResponse, LeverageYieldSwapError>`. On success:
+   *   - `solverExecutionResponse` — solver acknowledgement (`{ answer: 'OK', intent_hash }`).
+   *   - `intent` — the on-chain intent object that was created.
+   *   - `intentDeliveryInfo` — source/destination chain keys, tx hashes, and user addresses.
+   *
+   *   On failure `result.error` carries one of the create-intent codes plus
+   *   `TX_VERIFICATION_FAILED`, `TX_SUBMIT_FAILED`, `RELAY_TIMEOUT`, `RELAY_FAILED`,
+   *   `EXECUTION_FAILED`, `EXTERNAL_API_ERROR` or `UNKNOWN`.
+   */
+  async vaultSwap(_params) {
+    const { params } = _params;
+    const srcChainKey = params.srcChainKey;
+    const baseCtx = { srcChainKey, dstChainKey: params.dstChainKey, action: "vaultSwap" };
+    try {
+      const timeout = _params.timeout;
+      const createIntentResult = await this.createVaultIntent(_params);
+      if (!createIntentResult.ok) {
+        return { ok: false, error: createIntentResult.error };
+      }
+      const { tx: spokeTxHash, intent, relayData } = createIntentResult.value;
+      const verifyTxHashResult = await this.spoke.verifyTxHash({
+        txHash: spokeTxHash,
+        chainKey: srcChainKey
+      });
+      if (!verifyTxHashResult.ok) {
+        return {
+          ok: false,
+          error: verifyFailed("leverageYield", verifyTxHashResult.error, baseCtx)
+        };
+      }
+      let dstIntentTxHash;
+      if (isHubChainKeyType(srcChainKey)) {
+        dstIntentTxHash = spokeTxHash;
+      } else {
+        const packet = await relayTxAndWaitPacket({
+          srcTxHash: spokeTxHash,
+          data: relayData,
+          chainKey: srcChainKey,
+          relayerApiEndpoint: this.config.relay.relayerApiEndpoint,
+          timeout
+        });
+        if (!packet.ok) {
+          return {
+            ok: false,
+            error: mapRelayFailure(packet.error, { feature: "leverageYield", ...baseCtx })
+          };
+        }
+        dstIntentTxHash = packet.value.dst_tx_hash;
+      }
+      const postExecResult = await this.notifySolver({
+        intent_tx_hash: dstIntentTxHash
+      });
+      if (!postExecResult.ok) {
+        return { ok: false, error: postExecResult.error };
+      }
+      return {
+        ok: true,
+        value: {
+          solverExecutionResponse: postExecResult.value,
+          intent,
+          intentDeliveryInfo: {
+            srcChainKey,
+            srcTxHash: spokeTxHash,
+            srcAddress: params.srcAddress,
+            dstChainKey: params.dstChainKey,
+            dstTxHash: dstIntentTxHash,
+            dstAddress: params.dstAddress
+          }
+        }
+      };
+    } catch (error) {
+      if (isLeverageYieldSwapError(error)) return { ok: false, error };
+      return {
+        ok: false,
+        error: unknownFailed("leverageYield", error, baseCtx)
+      };
+    }
+  }
+  /**
+   * Notifies the solver that the vault intent landed on the hub, triggering it to fill.
+   * Leverage-yield copy of the swap domain's `postExecution` — emits only
+   * `EXECUTION_FAILED` / `EXTERNAL_API_ERROR` / `UNKNOWN` (relay/verify codes appear only
+   * on {@link LeverageYieldService.vaultSwap}, which owns the verify + relay steps).
+   *
+   * Called automatically by {@link LeverageYieldService.vaultSwap} after the relay packet
+   * lands on the hub. Public so callers who created the intent via
+   * {@link LeverageYieldService.createVaultIntent} and relayed it themselves can finish the
+   * flow manually.
+   *
+   * @param request - `{ intent_tx_hash }` — the hub-chain (Sonic) tx hash where the intent
+   *   was registered (the relay packet's `dst_tx_hash`, or the spoke tx hash for hub-sourced
+   *   intents).
+   */
+  async notifySolver(request) {
+    try {
+      const result = await SolverApiService.postExecution(request, this.config.solver, this.config.logger);
+      if (result.ok) return result;
+      const detail = result.error?.detail ?? {
+        code: -999,
+        // SolverIntentErrorCode.UNKNOWN
+        message: "Solver returned malformed error response"
+      };
+      return {
+        ok: false,
+        error: new SodaxError("EXTERNAL_API_ERROR", detail.message, {
+          feature: "leverageYield",
+          context: {
+            phase: "postExecution",
+            api: "solver",
+            solverCode: detail.code,
+            solverDetail: detail
+          }
+        })
+      };
+    } catch (error) {
+      if (isLeverageYieldPostExecutionError(error)) return { ok: false, error };
+      return { ok: false, error: executionFailed("leverageYield", error, { phase: "postExecution" }) };
+    }
+  }
+  /**
+   * Approves the vault's underlying asset to the leverage vault on Sonic. For callers
+   * interacting with the vault directly on the hub — the swap-style {@link
+   * LeverageYieldService.deposit} flow handles its own approvals.
+   */
+  async approve(params) {
+    const baseCtx = { action: "approve" };
+    try {
+      leverageYieldInvariant(params.amount > 0n, "Amount must be greater than 0", { ...baseCtx, field: "amount" });
+      leverageYieldInvariant(params.vault.length > 0, "Vault address is required", { ...baseCtx, field: "vault" });
+      const assetResult = await this.getAsset(params.vault);
+      if (!assetResult.ok) {
+        return { ok: false, error: approveFailed("leverageYield", assetResult.error, baseCtx) };
+      }
+      const from = await params.walletProvider.getWalletAddress();
+      const baseApprove = {
+        token: assetResult.value,
+        amount: params.amount,
+        from,
+        spender: params.vault
+      };
+      if (params.raw) {
+        const tx2 = await Erc20Service.approve({ ...baseApprove, raw: true });
+        return { ok: true, value: tx2 };
+      }
+      const tx = await Erc20Service.approve({
+        ...baseApprove,
+        raw: false,
+        walletProvider: params.walletProvider
+      });
+      return { ok: true, value: tx };
+    } catch (error) {
+      if (isLeverageYieldApproveError(error)) return { ok: false, error };
+      return { ok: false, error: approveFailed("leverageYield", error, baseCtx) };
+    }
+  }
+  /**
+   * Reads on-chain allowance of the vault's underlying asset for `owner → vault`. Returns
+   * `true` when the allowance covers `amount`. Use before a direct
+   * {@link LeverageYieldService.deposit}.
+   */
+  async isAllowanceValid(params) {
+    const baseCtx = { action: "allowanceCheck" };
+    try {
+      leverageYieldInvariant(params.amount > 0n, "Amount must be greater than 0", { ...baseCtx, field: "amount" });
+      const assetResult = await this.getAsset(params.vault);
+      if (!assetResult.ok) {
+        return { ok: false, error: allowanceCheckFailed("leverageYield", assetResult.error, baseCtx) };
+      }
+      const allowance = await this.hubProvider.publicClient.readContract({
+        address: assetResult.value,
+        abi: viem.erc20Abi,
+        functionName: "allowance",
+        args: [params.owner, params.vault]
+      });
+      return { ok: true, value: allowance >= params.amount };
+    } catch (error) {
+      if (isLeverageYieldAllowanceCheckError(error)) return { ok: false, error };
+      return { ok: false, error: allowanceCheckFailed("leverageYield", error, baseCtx) };
+    }
+  }
+  // ─── Reads ──────────────────────────────────────────────────────────────
+  /** ERC-4626 `asset()` of the vault — the sodaWEETH-style underlying. */
+  async getAsset(vault) {
+    try {
+      const value = await this.hubProvider.publicClient.readContract({
+        address: vault,
+        abi: leverageYieldVaultAbi,
+        functionName: "asset"
+      });
+      return { ok: true, value };
+    } catch (error) {
+      if (isLeverageYieldLookupError(error)) return { ok: false, error };
+      return { ok: false, error: lookupFailed("leverageYield", "getAsset", error) };
+    }
+  }
+  /** Reads the vault's leveraged position snapshot via the non-standard `getPositionDetails`. */
+  async getPosition(vault) {
+    try {
+      const [collateral, debt, ltv, healthFactor, idleAsset] = await this.hubProvider.publicClient.readContract({
+        address: vault,
+        abi: leverageYieldVaultAbi,
+        functionName: "getPositionDetails"
+      });
+      return { ok: true, value: { collateral, debt, ltv, healthFactor, idleAsset } };
+    } catch (error) {
+      if (isLeverageYieldLookupError(error)) return { ok: false, error };
+      return { ok: false, error: lookupFailed("leverageYield", "getPosition", error) };
+    }
+  }
+  /**
+   * Computes the steady-state APR of a leverage-yield vault from the AAVE supply/borrow
+   * rates of its asset and borrowToken, scaled by the vault's target leverage. Matches the
+   * convention used by leveraged-LSD vaults (Origami, Gearbox, etc.) — assumes constant
+   * LTV at `targetLTV` and constant AAVE rates.
+   *
+   * Returns raw fields in RAY (1e27, AAVE's native rate scale) plus the leverage multiplier
+   * in WAD (1e18). See {@link LeverageYieldApr} for the formula and caveats.
+   */
+  async getApr(vault) {
+    try {
+      const [pool, asset, borrowToken, targetLtvBps] = await Promise.all([
+        this.hubProvider.publicClient.readContract({
+          address: vault,
+          abi: leverageYieldVaultAbi,
+          functionName: "pool"
+        }),
+        this.hubProvider.publicClient.readContract({
+          address: vault,
+          abi: leverageYieldVaultAbi,
+          functionName: "asset"
+        }),
+        this.hubProvider.publicClient.readContract({
+          address: vault,
+          abi: leverageYieldVaultAbi,
+          functionName: "borrowToken"
+        }),
+        this.hubProvider.publicClient.readContract({
+          address: vault,
+          abi: leverageYieldVaultAbi,
+          functionName: "targetLTV"
+        })
+      ]);
+      const [assetReserve, borrowReserve] = await Promise.all([
+        this.hubProvider.publicClient.readContract({
+          address: pool,
+          abi: poolAbi,
+          functionName: "getReserveData",
+          args: [asset]
+        }),
+        this.hubProvider.publicClient.readContract({
+          address: pool,
+          abi: poolAbi,
+          functionName: "getReserveData",
+          args: [borrowToken]
+        })
+      ]);
+      const supplyAprRay = assetReserve.currentLiquidityRate;
+      const borrowAprRay = borrowReserve.currentVariableBorrowRate;
+      const BPS = 10000n;
+      const WAD2 = 1000000000000000000n;
+      leverageYieldInvariant(targetLtvBps < BPS, `targetLTV (${targetLtvBps}) must be < 100% (10_000 bps)`, {
+        method: "getApr",
+        field: "targetLtvBps"
+      });
+      const leverageMultiplierWad = targetLtvBps * WAD2 / (BPS - targetLtvBps);
+      const spreadRay = supplyAprRay - borrowAprRay;
+      const netAprRay = supplyAprRay + spreadRay * leverageMultiplierWad / WAD2;
+      return {
+        ok: true,
+        value: { supplyAprRay, borrowAprRay, targetLtvBps, leverageMultiplierWad, netAprRay }
+      };
+    } catch (error) {
+      if (isLeverageYieldLookupError(error)) return { ok: false, error };
+      return { ok: false, error: lookupFailed("leverageYield", "getApr", error) };
+    }
+  }
+  /**
+   * Off-chain LSD staking-APR for the vault's underlying asset. Looks the vault up in the
+   * registry, hits DefiLlama's per-pool chart endpoint for the configured `poolId`, and on
+   * any fetch failure returns the registry's hardcoded `fallbackAprPct` with `stale: true`.
+   *
+   * Always resolves to `{ ok: true, ... }` for a known vault — the fallback path replaces
+   * the error, since a missing LSD APR shouldn't break the parent call. Returns
+   * `{ aprRay: 0n, stale: true, label: 'no LSD source' }` for vaults without an
+   * `lsdSource` configured (non-LSD strategies); callers can treat that as "skip LSD".
+   */
+  async getLsdApr(vault) {
+    try {
+      const cfg = this.getVaultByAddress(vault);
+      const source = cfg?.lsdSource;
+      if (!source) {
+        return { ok: true, value: { aprRay: 0n, label: "no LSD source", stale: true } };
+      }
+      try {
+        const aprPct = await fetchDefillamaApr(source.poolId);
+        return { ok: true, value: { aprRay: pctToRay(aprPct), label: source.label, stale: false } };
+      } catch (fetchError) {
+        this.config.logger.warn("[leverageYield] DefiLlama APR fetch failed; using fallbackAprPct", {
+          vault,
+          poolId: source.poolId,
+          fallbackAprPct: source.fallbackAprPct,
+          error: fetchError instanceof Error ? fetchError.message : String(fetchError)
+        });
+        return {
+          ok: true,
+          value: { aprRay: pctToRay(source.fallbackAprPct), label: `${source.label} (fallback)`, stale: true }
+        };
+      }
+    } catch (error) {
+      if (isLeverageYieldLookupError(error)) return { ok: false, error };
+      return { ok: false, error: lookupFailed("leverageYield", "getLsdApr", error) };
+    }
+  }
+  /**
+   * Combined view of {@link getApr} + {@link getLsdApr}: re-applies the vault's leverage
+   * formula with the LSD's native staking yield folded into the supply side, exposing the
+   * **effective** net APR that LSD-backed strategies actually earn. The AAVE-only
+   * `netAprRay` is preserved on the return value for callers who want to display both.
+   *
+   *   effectiveSupply = supplyAprRay + lsdApr.aprRay
+   *   effectiveNet    = effectiveSupply + leverage × (effectiveSupply − borrowAprRay)
+   *
+   * Fetches AAVE rates and the LSD APR in parallel for one round-trip's worth of latency.
+   */
+  async getEffectiveApr(vault) {
+    try {
+      const [aprResult, lsdResult] = await Promise.all([this.getApr(vault), this.getLsdApr(vault)]);
+      if (!aprResult.ok) return aprResult;
+      if (!lsdResult.ok) return lsdResult;
+      const apr = aprResult.value;
+      const lsd = lsdResult.value;
+      const effectiveSupplyAprRay = apr.supplyAprRay + lsd.aprRay;
+      const spreadRay = effectiveSupplyAprRay - apr.borrowAprRay;
+      const WAD2 = 1000000000000000000n;
+      const effectiveNetAprRay = effectiveSupplyAprRay + spreadRay * apr.leverageMultiplierWad / WAD2;
+      return {
+        ok: true,
+        value: { ...apr, lsdApr: lsd, effectiveSupplyAprRay, effectiveNetAprRay }
+      };
+    } catch (error) {
+      if (isLeverageYieldLookupError(error)) return { ok: false, error };
+      return { ok: false, error: lookupFailed("leverageYield", "getEffectiveApr", error) };
+    }
+  }
+  /** Synchronously withdrawable assets for `owner` (clamped against leverage HF floor). */
+  async getMaxWithdraw(vault, owner) {
+    const inner = await Erc4626Service.getMaxWithdraw(vault, owner, this.hubProvider.publicClient);
+    if (!inner.ok) return { ok: false, error: lookupFailed("leverageYield", "getMaxWithdraw", inner.error) };
+    return { ok: true, value: inner.value };
+  }
+  /** Total underlying assets currently held by the vault (vault-asset units, 18 decimals) — TVL. */
+  async getTotalAssets(vault) {
+    const inner = await Erc4626Service.getTotalAssets(vault, this.hubProvider.publicClient);
+    if (!inner.ok) return { ok: false, error: lookupFailed("leverageYield", "getTotalAssets", inner.error) };
+    return { ok: true, value: inner.value };
+  }
+  /** Shares minted for a given asset deposit. */
+  async previewDeposit(vault, assets) {
+    const inner = await Erc4626Service.previewDeposit(vault, assets, this.hubProvider.publicClient);
+    if (!inner.ok) return { ok: false, error: lookupFailed("leverageYield", "previewDeposit", inner.error) };
+    return { ok: true, value: inner.value };
+  }
+  /** Shares burned for a given asset withdrawal. */
+  async previewWithdraw(vault, assets) {
+    const inner = await Erc4626Service.previewWithdraw(vault, assets, this.hubProvider.publicClient);
+    if (!inner.ok) return { ok: false, error: lookupFailed("leverageYield", "previewWithdraw", inner.error) };
+    return { ok: true, value: inner.value };
+  }
+  /** Assets received for a given share redemption. */
+  async previewRedeem(vault, shares) {
+    const inner = await Erc4626Service.previewRedeem(vault, shares, this.hubProvider.publicClient);
+    if (!inner.ok) return { ok: false, error: lookupFailed("leverageYield", "previewRedeem", inner.error) };
+    return { ok: true, value: inner.value };
+  }
+  /** Vault shares held by `owner`. */
+  async getShareBalance(vault, owner) {
+    try {
+      const value = await this.hubProvider.publicClient.readContract({
+        address: vault,
+        abi: viem.erc20Abi,
+        functionName: "balanceOf",
+        args: [owner]
+      });
+      return { ok: true, value };
+    } catch (error) {
+      if (isLeverageYieldLookupError(error)) return { ok: false, error };
+      return { ok: false, error: lookupFailed("leverageYield", "getShareBalance", error) };
+    }
+  }
+  /**
+   * Convenience: resolves the user's hub wallet from `(srcChainKey, srcAddress)` and
+   * returns its on-chain `maxWithdraw`, less {@link MAX_WITHDRAW_DUST_BUFFER}. The trim
+   * keeps the value safe for an asset-denominated ERC-4626 `withdraw` — the raw
+   * `maxWithdraw` can trip the round-up that asks for one more share than the user holds.
+   */
+  async getMaxWithdrawForUser(vault, srcChainKey, srcAddress) {
+    try {
+      const hubWallet = await this.hubProvider.getUserHubWalletAddress(srcAddress, srcChainKey);
+      const maxWithdrawResult = await this.getMaxWithdraw(vault, hubWallet);
+      if (!maxWithdrawResult.ok) return maxWithdrawResult;
+      const buffered = maxWithdrawResult.value > MAX_WITHDRAW_DUST_BUFFER ? maxWithdrawResult.value - MAX_WITHDRAW_DUST_BUFFER : 0n;
+      return { ok: true, value: buffered };
+    } catch (error) {
+      if (isLeverageYieldLookupError(error)) return { ok: false, error };
+      return { ok: false, error: lookupFailed("leverageYield", "getMaxWithdrawForUser", error, { srcChainKey }) };
+    }
+  }
+  /**
+   * Convenience: resolves the user's hub wallet from `(srcChainKey, srcAddress)` and
+   * returns its on-chain share balance.
+   */
+  async getShareBalanceForUser(vault, srcChainKey, srcAddress) {
+    try {
+      const hubWallet = await this.hubProvider.getUserHubWalletAddress(srcAddress, srcChainKey);
+      return await this.getShareBalance(vault, hubWallet);
+    } catch (error) {
+      if (isLeverageYieldLookupError(error)) return { ok: false, error };
+      return { ok: false, error: lookupFailed("leverageYield", "getShareBalanceForUser", error, { srcChainKey }) };
+    }
+  }
+};
+
 // src/shared/entities/Sodax.ts
 var Sodax = class {
   instanceConfig;
@@ -37136,17 +38287,26 @@ var Sodax = class {
   // Recovery service for withdrawing stuck hub-wallet assets back to a spoke chain
   dex;
   // Dex service enabling DEX operations
+  leverageYield;
+  // Leverage-yield service: cross-chain deposits / withdrawals into ERC-4626 leverage vaults on Sonic
   config;
   // Config service enabling configuration data fetching from the backend API or fallbacking to default values
   hubProvider;
   // hub provider for the hub chain (e.g. Sonic mainnet)
   spoke;
   // spoke service enabling spoke chain operations
-  constructor(config) {
-    const logger = resolveLogger(config?.logger);
-    this.instanceConfig = config ? mergeSodaxConfig(sodaxConfig, config) : sodaxConfig;
+  constructor(options) {
+    const logger = resolveLogger(options?.logger);
+    const fee = options?.fee;
+    this.instanceConfig = options ? mergeSodaxConfig(sodaxConfig, options) : sodaxConfig;
     this.backendApi = new BackendApiService(this.instanceConfig.api, logger);
-    this.config = new ConfigService({ api: this.backendApi, config: this.instanceConfig, userConfig: config, logger });
+    this.config = new ConfigService({
+      api: this.backendApi,
+      config: this.instanceConfig,
+      userConfig: options,
+      logger,
+      fee
+    });
     this.hubProvider = new EvmHubProvider({ config: this.config });
     this.spoke = new SpokeService({ config: this.config, hubProvider: this.hubProvider });
     this.swaps = new SwapService({
@@ -37181,6 +38341,11 @@ var Sodax = class {
       config: this.config,
       spoke: this.spoke
     });
+    this.leverageYield = new LeverageYieldService({
+      hubProvider: this.hubProvider,
+      config: this.config,
+      spoke: this.spoke
+    });
   }
   /**
    * Initializes the Sodax instance with dynamic configuration.
@@ -37289,8 +38454,11 @@ exports.IntentsAbi = IntentsAbi;
 exports.LOOKUP_CODES = LOOKUP_CODES;
 exports.LTV_PRECISION = LTV_PRECISION;
 exports.LendingPoolService = LendingPoolService;
+exports.LeverageYieldService = LeverageYieldService;
 exports.LockupMultiplier = LockupMultiplier;
 exports.LockupPeriod = LockupPeriod;
+exports.LsodaSymbols = LsodaSymbols;
+exports.LsodaTokens = LsodaTokens;
 exports.MAX_UINT256 = MAX_UINT256;
 exports.MigrationService = MigrationService;
 exports.MintPositionEventAbi = MintPositionEventAbi;
@@ -37433,6 +38601,7 @@ exports.getReserveNormalizedIncome = getReserveNormalizedIncome;
 exports.getReservesEModes = getReservesEModes;
 exports.getSolanaAddressBytes = getSolanaAddressBytes;
 exports.getSolverConfig = getSolverConfig;
+exports.getStagingSolverTokens = getStagingSolverTokens;
 exports.getSupportedSolverTokens = getSupportedSolverTokens;
 exports.getTransactionPackets = getTransactionPackets;
 exports.getbnUSDToken = getbnUSDToken;
@@ -37475,6 +38644,13 @@ exports.isInjectiveChainKeyType = isInjectiveChainKeyType;
 exports.isJsonRpcPayloadResponse = isJsonRpcPayloadResponse;
 exports.isLegacybnUSDChainId = isLegacybnUSDChainId;
 exports.isLegacybnUSDToken = isLegacybnUSDToken;
+exports.isLeverageYieldAllowanceCheckError = isLeverageYieldAllowanceCheckError;
+exports.isLeverageYieldApproveError = isLeverageYieldApproveError;
+exports.isLeverageYieldCreateIntentError = isLeverageYieldCreateIntentError;
+exports.isLeverageYieldError = isLeverageYieldError;
+exports.isLeverageYieldLookupError = isLeverageYieldLookupError;
+exports.isLeverageYieldPostExecutionError = isLeverageYieldPostExecutionError;
+exports.isLeverageYieldSwapError = isLeverageYieldSwapError;
 exports.isMigrateOrchestrationError = isMigrateOrchestrationError;
 exports.isMigrationAllowanceCheckError = isMigrationAllowanceCheckError;
 exports.isMigrationApproveError = isMigrationApproveError;
@@ -37541,6 +38717,9 @@ exports.isUndefinedOrValidWalletProviderForChainKey = isUndefinedOrValidWalletPr
 exports.isUnifiedBnUSDMigrateParams = isUnifiedBnUSDMigrateParams;
 exports.isValidWalletProviderForChainKey = isValidWalletProviderForChainKey;
 exports.kaiaSupportedTokens = kaiaSupportedTokens;
+exports.leverageYieldConfig = leverageYieldConfig;
+exports.leverageYieldInvariant = leverageYieldInvariant;
+exports.leverageYieldVaults = leverageYieldVaults;
 exports.lightlinkSupportedTokens = lightlinkSupportedTokens;
 exports.lookupFailed = lookupFailed;
 exports.mapRelayFailure = mapRelayFailure;
@@ -37600,6 +38779,7 @@ exports.spokeAssetManagerAbi = spokeAssetManagerAbi;
 exports.spokeChainConfig = spokeChainConfig;
 exports.spokeChainKeysSet = spokeChainKeysSet;
 exports.stacksSupportedTokens = stacksSupportedTokens;
+exports.stagingSwapSupportedTokens = stagingSwapSupportedTokens;
 exports.stakedSodaAbi = stakedSodaAbi;
 exports.stakingInvariant = stakingInvariant;
 exports.stakingRouterAbi = stakingRouterAbi;