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

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { getAbiItem, isAddress, toHex, hexToBytes, encodeAbiParameters, parseAbiParameters, defineChain, encodeFunctionData, erc20Abi as erc20Abi$1, createPublicClient, http, bytesToHex, keccak256, stringToBytes, fromHex, encodePacked, decodeAbiParameters, parseEventLogs, maxUint160, maxUint48 } from 'viem';
+import { getAbiItem, parseAbi, isAddress, toHex, hexToBytes, encodeAbiParameters, parseAbiParameters, defineChain, encodeFunctionData, erc20Abi as erc20Abi$1, createPublicClient, http, bytesToHex, keccak256, stringToBytes, fromHex, encodePacked, decodeAbiParameters, parseEventLogs, maxUint160, maxUint48 } from 'viem';
 import { bcs } from '@mysten/sui/bcs';
 import { PublicKey, Connection, VersionedTransaction, SystemProgram, ComputeBudgetProgram, TransactionMessage, TransactionInstruction } from '@solana/web3.js';
 import { rpc, Address, xdr, Account, Horizon, Contract, TransactionBuilder, nativeToScVal, TimeoutInfinite, scValToBigInt, Operation, Asset, FeeBumpTransaction } from '@stellar/stellar-sdk';
@@ -169,7 +169,8 @@ var SODAX_FEATURES = [
   "migration",
   "dex",
   "partner",
-  "recovery"
+  "recovery",
+  "leverageYield"
 ];
 
 // src/shared/utils/tiny-invariant.ts
@@ -531,6 +532,27 @@ var SodaTokens = {
     vault: "0x243b0c26c8b38793908d7C64e8510f21B19B4613"
   }
 };
+var LsodaSymbols = ["lsodaWEETH", "lsodaWSTETH"];
+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"
+  }
+};
 var sonicSupportedTokens = {
   S: {
     symbol: "S",
@@ -595,7 +617,8 @@ var sonicSupportedTokens = {
     hubAsset: "0x7c7d53EEcda37a87ce0D5bf8E0b24512A48dC963",
     vault: SodaTokens.sodaSODA.address
   },
-  ...SodaTokens
+  ...SodaTokens,
+  ...LsodaTokens
 };
 var redbellySupportedTokens = {
   RBNT: {
@@ -3596,7 +3619,8 @@ var swapSupportedTokens = {
     spokeChainConfig[ChainKeys.SONIC_MAINNET].supportedTokens.USDT,
     spokeChainConfig[ChainKeys.SONIC_MAINNET].supportedTokens.wS,
     spokeChainConfig[ChainKeys.SONIC_MAINNET].supportedTokens.SODA,
-    ...Object.values(SodaTokens)
+    ...Object.values(SodaTokens),
+    ...Object.values(LsodaTokens)
   ],
   [ChainKeys.AVALANCHE_MAINNET]: [
     spokeChainConfig[ChainKeys.AVALANCHE_MAINNET].supportedTokens.AVAX,
@@ -3836,6 +3860,41 @@ var swapsConfig = {
 var getSupportedSolverTokens = (chainId) => swapSupportedTokens[chainId];
 var isSwapSupportedToken = (chainId, token) => swapSupportedTokens[chainId].some((t) => t.address.toLowerCase() === token.toLowerCase());
 
+// ../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)"
+    }
+  }
+];
+var leverageYieldConfig = {
+  vaults: leverageYieldVaults
+};
+
 // ../types/dist/sodax-config/sodax-config.js
 var bridgeConfig = {
   partnerFee: void 0
@@ -3847,6 +3906,7 @@ var sodaxConfig = {
   moneyMarket: moneyMarketConfig,
   bridge: bridgeConfig,
   dex: dexConfig,
+  leverageYield: leverageYieldConfig,
   hub: hubConfig,
   api: apiConfig,
   solver: solverConfig,
@@ -3988,7 +4048,7 @@ function isValidWalletProviderForChainKey(chainKey, walletProvider) {
 }
 
 // ../types/dist/index.js
-var CONFIG_VERSION = 210;
+var CONFIG_VERSION = 211;
 function isEvmSpokeChainConfig(value) {
   return typeof value === "object" && value !== null && value.chain.type === "EVM" && value.chain.key !== HUB_CHAIN_KEY;
 }
@@ -22267,17 +22327,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);
@@ -22297,17 +22351,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);
@@ -22318,7 +22366,7 @@ var SuiSpokeService = class {
    * @returns {Promise<bigint>} The estimated computation cost.
    */
   async estimateGas({ tx }) {
-    const txb = Transaction$1.fromKind(tx.data);
+    const txb = Transaction$1.from(tx.data);
     const result = await this.publicClient.devInspectTransactionBlock({
       sender: tx.from,
       transactionBlock: txb
@@ -22549,6 +22597,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}`
@@ -22655,7 +22704,7 @@ var StellarSpokeService = class {
       );
       const assembledPriorityTx = 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,
@@ -22772,7 +22821,7 @@ var StellarSpokeService = class {
       );
       const assembledPriorityTx = 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,
@@ -36985,7 +37034,12 @@ var RecoveryService = class {
         srcChainKey: chainKey,
         field: "chainKey"
       });
-      const entries = Object.values(chainConfig.supportedTokens).filter((token) => 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) => isAddress(token.hubAsset) && !leverageVaultAddresses.has(token.hubAsset.toLowerCase())
+      );
       if (entries.length === 0) {
         return { ok: true, value: [] };
       }
@@ -37087,6 +37141,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 = 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.swaps.partnerFee } = _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: erc20Abi$1,
+        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: erc20Abi$1,
+        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;
@@ -37108,6 +38027,8 @@ 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;
@@ -37153,6 +38074,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.
@@ -37193,4 +38119,4 @@ var isPartnerError = isCodeMember(PARTNER_CODES);
   (*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 */
 
-export { ALLOWANCE_CHECK_CODES, APPROVE_CODES, AssetService, BITCOIN_CHAIN_KEYS, BITCOIN_CHAIN_KEYS_SET, BTC_WALLET_ADDRESS_TYPES, BackendApiService, BalnSwapService, BigIntToHex, BigNumberZeroDecimal, BitcoinSpokeService, BnUSDMigrationService, BridgeService, CHAIN_KEYS, CONFIG_VERSION, CREATE_INTENT_CODES, ChainKeys, ChainTypeArr, ClService, ConfigService, CustomSorobanServer, CustomStellarAccount, DEFAULT_BACKEND_API_ENDPOINT, DEFAULT_BACKEND_API_HEADERS, DEFAULT_BACKEND_API_TIMEOUT, DEFAULT_DEADLINE_OFFSET, DEFAULT_MAX_RETRY, DEFAULT_RELAYER_API_ENDPOINT, DEFAULT_RELAY_TX_TIMEOUT, DEFAULT_RETRY_DELAY_MS, DexService, EVM_CHAIN_ID_TO_KEY, EVM_CHAIN_KEYS, EVM_CHAIN_KEYS_SET, EVM_SPOKE_ONLY_CHAIN_KEYS, EVM_SPOKE_ONLY_CHAIN_KEYS_SET, Erc20Service, Erc4626Service, EvmAssetManagerService, EvmHubProvider, EvmSolverService, EvmSpokeService, EvmVaultTokenService, FEE_PERCENTAGE_SCALE, GAS_ESTIMATION_CODES, HALF_RAY, HALF_WAD, HUB_CHAIN_KEY, HttpRelayError, HubVaultSymbols, ICON_CHAIN_KEYS, ICON_CHAIN_KEYS_SET, ICON_TX_RESULT_WAIT_MAX_RETRY, INJECTIVE_CHAIN_KEYS, INJECTIVE_CHAIN_KEYS_SET, INTENT_CHAIN_IDS, IconSpokeService, IcxMigrationService, Injective20Token, InjectiveSpokeService, IntentCreatedEventAbi, IntentDataType, IntentFilledEventAbi, IntentRelayChainIdToChainKey, IntentsAbi, LOOKUP_CODES, LTV_PRECISION, LendingPoolService, LockupMultiplier, LockupPeriod, MAX_UINT256, MigrationService, MintPositionEventAbi, MoneyMarketDataService, MoneyMarketService, NEAR_CHAIN_KEYS, NEAR_CHAIN_KEYS_SET, NEAR_DEFAULT_GAS, NEAR_STORAGE_DEPOSIT, NearSpokeService, PartnerFeeClaimService, PartnerService, Permit2Service, ProtocolIntentsAbi, RAY, RAY_DECIMALS, RELAY_ERROR_CODES, RadfiApiError, RadfiProvider, RecoveryService, RelayChainIdMap, SECONDS_PER_YEAR, SODAX_ERROR_CODES, SODAX_FEATURES, SOLANA_CHAIN_KEYS, SOLANA_CHAIN_KEYS_SET, SONIC_CHAIN_KEYS, SONIC_CHAIN_KEYS_SET, STACKS_CHAIN_KEYS, STACKS_CHAIN_KEYS_SET, STELLAR_CHAIN_KEYS, STELLAR_CHAIN_KEYS_SET, SUI_CHAIN_KEYS, SUI_CHAIN_KEYS_SET, SodaTokens, Sodax, SodaxError, SolanaSpokeService, SolverApiService, SolverIntentErrorCode, SolverIntentStatusCode, SonicSpokeService, SpokeService, StacksSpokeService, StakingLogic, StakingService, StatATokenAddresses, StellarSpokeService, SuiSpokeService, SupportedMigrationTokens, SwapService, USD_DECIMALS, UiPoolDataProviderService, VAULT_TOKEN_DECIMALS, WAD, WAD_RAY_RATIO, WEI_DECIMALS, adjustAmountByFee, allowanceCheckFailed, apiConfig, approveFailed, arbitrumSupportedTokens, assetManagerAbi, avalancheSupportedTokens, balnSwapAbi, baseChainInfo, baseSupportedTokens, binomialApproximatedRayPow, bitcoinSupportedTokens, bnUSDLegacySpokeChainIds, bnUSDLegacyTokens, bridgeConfig, bridgeInvariant, bscSupportedTokens, calcOpReturnOutputVbytes, calculateAllReserveIncentives, calculateAllUserIncentives, calculateAvailableBorrowsMarketReferenceCurrency, calculateCompoundedInterest, calculateCompoundedRate, calculateFeeAmount, calculateHealthFactorFromBalances, calculateHealthFactorFromBalancesBigUnits, calculateLinearInterest, calculatePercentageFeeAmount, clPoolAbi, clPoolManagerAbi, clPositionManagerAbi, clQuoterAbi, clRouterAbi, clTickLensAbi, concentratedLiquidityConfig, connectionAbi, consoleLogger, convertTransactionInstructionToRaw, createInvariant, deepMerge, defaultHookAbi, detectBitcoinAddressType, dexConfig, dexInvariant, dexPools, encodeAddress, encodeBtcPayloadToBytes, encodeContractCalls, erc20Abi, erc4626Abi, estimateBitcoinTxSize, ethereumSupportedTokens, executionFailed, formatBasisPoints, formatEModeCategory, formatEModes, formatPercentage, formatReserve, formatReserveUSD, formatReserves, formatReservesAndIncentives, formatUserSummary, formatUserSummaryAndIncentives, gasEstimationFailed, getAllLegacybnUSDTokens, getAndFormatReserveEModes, getAssetManagerIdl, getAssetManagerProgram, getChainKeyFromRelayChainId, getChainType, getCompoundedBalance, getConcentratedLiquidityConfig, getConnectionIdl, getConnectionProgram, getEvmChainKeyByChainId, getEvmViemChain, getIconAddressBytes, getIntentRelayChainId, getLinearBalance, getMarketReferenceCurrencyAndUsdBalance, getPacket, getProvider, getRandomBytes, getReserveNormalizedIncome, getReservesEModes, getSolanaAddressBytes, getSolverConfig, getSupportedSolverTokens, getTransactionPackets, getbnUSDToken, hexToBigInt, hexToSolanaAddress, hubConfig, hyper, hyperevmSupportedTokens, iconSupportedTokens, injectiveSupportedTokens, intentCreationFailed, isBalnMigrateParams, isBitcoinChainKey, isBitcoinChainKeyType, isBitcoinWalletProviderType, isBridgeAllowanceCheckError, isBridgeApproveError, isBridgeCreateIntentError, isBridgeError, isBridgeLookupError, isBridgeOrchestrationError, isCodeMember, isDexError, isEvmChainKey, isEvmChainKeyType, isEvmSpokeChainConfig, isEvmSpokeOnlyChainKey, isEvmSpokeOnlyChainKeyType, isEvmWalletProviderType, isFeatureError, isHubChainKey, isHubChainKeyType, isIconAddress, isIconChainKey, isIconChainKeyType, isIcxCreateRevertMigrationParams, isIcxMigrateParams, isInjectiveChainKey, isInjectiveChainKeyType, isJsonRpcPayloadResponse, isLegacybnUSDChainId, isLegacybnUSDToken, isMigrateOrchestrationError, isMigrationAllowanceCheckError, isMigrationApproveError, isMigrationCreateIntentError, isMigrationError, isMigrationLookupError, isMoneyMarketAllowanceCheckError, isMoneyMarketApproveError, isMoneyMarketCreateIntentError, isMoneyMarketError, isMoneyMarketGasEstimationError, isMoneyMarketOrchestrationError, isNativeToken, isNearChainKey, isNearChainKeyType, isNewbnUSDChainId, isNewbnUSDToken, isOptionalBitcoinWalletProviderType, isOptionalEvmWalletProviderType, isOptionalStellarWalletProviderType, isPartnerError, isPartnerFeeAmount, isPartnerFeePercentage, isPostExecutionError, isRawDestinationParams, isRecoveryError, isResponseAddressType, isResponseSigningType, isRevertMigrationOrchestrationError, isSodaxError, isSolanaChainKey, isSolanaChainKeyType, isSolanaNativeToken, isSonicChainKey, isSonicChainKeyType, isSpokeApproveParamsEvmSpoke, isSpokeApproveParamsHub, isSpokeApproveParamsStellar, isSpokeChainKey, isSpokeIsAllowanceValidParamsEvmSpoke, isSpokeIsAllowanceValidParamsHub, isSpokeIsAllowanceValidParamsStellar, isStacksChainKey, isStacksChainKeyType, isStakeOrchestrationError, isStakingAllowanceCheckError, isStakingApproveError, isStakingCreateIntentError, isStakingError, isStakingInfoFetchError, isStakingOrchestrationError, isStellarChainKey, isStellarChainKeyType, isStellarWalletProviderType, isSubmitSwapTxResponse, isSubmitSwapTxStatusResponse, isSuiChainKey, isSuiChainKeyType, isSupportedBitcoinAddressType, isSwapCreateIntentError, isSwapError, isSwapSupportedToken, isUndefinedOrValidWalletProviderForChainKey, isUnifiedBnUSDMigrateParams, isValidWalletProviderForChainKey, kaiaSupportedTokens, lightlinkSupportedTokens, lookupFailed, mapRelayFailure, mergeSodaxConfig, messageOf, migrationInvariant, mintPositionParamsAbi, mmInvariant, modifyLiquidityParamsAbi, moneyMarketConfig, moneyMarketReserveAssets, moneyMarketSupportedTokens, nativeToUSD, nearSupportedTokens, newbnUSDSpokeChainIds, normalize, normalizeBN, normalizePsbtToBase64, normalizeSignatureToBase64, normalizedToUsd, optimismSupportedTokens, pancakeSwapInfinityDefaultHookAbi, pancakeSwapInfinityPoolManagerAbi, pancakeSwapInfinityPositionManagerAbi, parseToStroops, parseTokenArrayFromJson, partnerInvariant, permit2Abi, polygonSupportedTokens, poolAbi, poolKeyAbi, randomUint256, rayDiv, rayMul, rayPow, rayToWad, recoveryInvariant, redbellySupportedTokens, relayConfig, relayTxAndWaitPacket, requestAddress, requestJsonRpc, requestSigning, resolveLogger, retry, reverseEncodeAddress, serializeAddressData, silentLogger, sleep, sodaxConfig, sodaxInvariant, solanaSupportedTokens, solverConfig, sonicSupportedTokens, sonicWalletFactoryAbi, spokeAssetManagerAbi, spokeChainConfig, spokeChainKeysSet, stacksSupportedTokens, stakedSodaAbi, stakingInvariant, stakingRouterAbi, stataTokenFactoryAbi, stellarSupportedTokens, submitTransaction, suiSupportedTokens, supportedSpokeChains, supportedTokensByChain, swapExactInSingleParamsAbi, swapInvariant, swapSupportedTokens, swapsConfig, uiPoolDataAbi, universalRouterAbi, unknownFailed, usesBip322MessageSigning, valueToBigNumber, valueToZDBigNumber, variableDebtTokenAbi, vaultTokenAbi, verifyFailed, wadToRay, waitForStacksTransaction, waitForTransactionReceipt, waitUntilIntentExecuted, walletFactoryAbi, wrappedSonicAbi };
+export { ALLOWANCE_CHECK_CODES, APPROVE_CODES, AssetService, BITCOIN_CHAIN_KEYS, BITCOIN_CHAIN_KEYS_SET, BTC_WALLET_ADDRESS_TYPES, BackendApiService, BalnSwapService, BigIntToHex, BigNumberZeroDecimal, BitcoinSpokeService, BnUSDMigrationService, BridgeService, CHAIN_KEYS, CONFIG_VERSION, CREATE_INTENT_CODES, ChainKeys, ChainTypeArr, ClService, ConfigService, CustomSorobanServer, CustomStellarAccount, DEFAULT_BACKEND_API_ENDPOINT, DEFAULT_BACKEND_API_HEADERS, DEFAULT_BACKEND_API_TIMEOUT, DEFAULT_DEADLINE_OFFSET, DEFAULT_MAX_RETRY, DEFAULT_RELAYER_API_ENDPOINT, DEFAULT_RELAY_TX_TIMEOUT, DEFAULT_RETRY_DELAY_MS, DexService, EVM_CHAIN_ID_TO_KEY, EVM_CHAIN_KEYS, EVM_CHAIN_KEYS_SET, EVM_SPOKE_ONLY_CHAIN_KEYS, EVM_SPOKE_ONLY_CHAIN_KEYS_SET, Erc20Service, Erc4626Service, EvmAssetManagerService, EvmHubProvider, EvmSolverService, EvmSpokeService, EvmVaultTokenService, FEE_PERCENTAGE_SCALE, GAS_ESTIMATION_CODES, HALF_RAY, HALF_WAD, HUB_CHAIN_KEY, HttpRelayError, HubVaultSymbols, ICON_CHAIN_KEYS, ICON_CHAIN_KEYS_SET, ICON_TX_RESULT_WAIT_MAX_RETRY, INJECTIVE_CHAIN_KEYS, INJECTIVE_CHAIN_KEYS_SET, INTENT_CHAIN_IDS, IconSpokeService, IcxMigrationService, Injective20Token, InjectiveSpokeService, IntentCreatedEventAbi, IntentDataType, IntentFilledEventAbi, IntentRelayChainIdToChainKey, IntentsAbi, LOOKUP_CODES, LTV_PRECISION, LendingPoolService, LeverageYieldService, LockupMultiplier, LockupPeriod, LsodaSymbols, LsodaTokens, MAX_UINT256, MigrationService, MintPositionEventAbi, MoneyMarketDataService, MoneyMarketService, NEAR_CHAIN_KEYS, NEAR_CHAIN_KEYS_SET, NEAR_DEFAULT_GAS, NEAR_STORAGE_DEPOSIT, NearSpokeService, PartnerFeeClaimService, PartnerService, Permit2Service, ProtocolIntentsAbi, RAY, RAY_DECIMALS, RELAY_ERROR_CODES, RadfiApiError, RadfiProvider, RecoveryService, RelayChainIdMap, SECONDS_PER_YEAR, SODAX_ERROR_CODES, SODAX_FEATURES, SOLANA_CHAIN_KEYS, SOLANA_CHAIN_KEYS_SET, SONIC_CHAIN_KEYS, SONIC_CHAIN_KEYS_SET, STACKS_CHAIN_KEYS, STACKS_CHAIN_KEYS_SET, STELLAR_CHAIN_KEYS, STELLAR_CHAIN_KEYS_SET, SUI_CHAIN_KEYS, SUI_CHAIN_KEYS_SET, SodaTokens, Sodax, SodaxError, SolanaSpokeService, SolverApiService, SolverIntentErrorCode, SolverIntentStatusCode, SonicSpokeService, SpokeService, StacksSpokeService, StakingLogic, StakingService, StatATokenAddresses, StellarSpokeService, SuiSpokeService, SupportedMigrationTokens, SwapService, USD_DECIMALS, UiPoolDataProviderService, VAULT_TOKEN_DECIMALS, WAD, WAD_RAY_RATIO, WEI_DECIMALS, adjustAmountByFee, allowanceCheckFailed, apiConfig, approveFailed, arbitrumSupportedTokens, assetManagerAbi, avalancheSupportedTokens, balnSwapAbi, baseChainInfo, baseSupportedTokens, binomialApproximatedRayPow, bitcoinSupportedTokens, bnUSDLegacySpokeChainIds, bnUSDLegacyTokens, bridgeConfig, bridgeInvariant, bscSupportedTokens, calcOpReturnOutputVbytes, calculateAllReserveIncentives, calculateAllUserIncentives, calculateAvailableBorrowsMarketReferenceCurrency, calculateCompoundedInterest, calculateCompoundedRate, calculateFeeAmount, calculateHealthFactorFromBalances, calculateHealthFactorFromBalancesBigUnits, calculateLinearInterest, calculatePercentageFeeAmount, clPoolAbi, clPoolManagerAbi, clPositionManagerAbi, clQuoterAbi, clRouterAbi, clTickLensAbi, concentratedLiquidityConfig, connectionAbi, consoleLogger, convertTransactionInstructionToRaw, createInvariant, deepMerge, defaultHookAbi, detectBitcoinAddressType, dexConfig, dexInvariant, dexPools, encodeAddress, encodeBtcPayloadToBytes, encodeContractCalls, erc20Abi, erc4626Abi, estimateBitcoinTxSize, ethereumSupportedTokens, executionFailed, formatBasisPoints, formatEModeCategory, formatEModes, formatPercentage, formatReserve, formatReserveUSD, formatReserves, formatReservesAndIncentives, formatUserSummary, formatUserSummaryAndIncentives, gasEstimationFailed, getAllLegacybnUSDTokens, getAndFormatReserveEModes, getAssetManagerIdl, getAssetManagerProgram, getChainKeyFromRelayChainId, getChainType, getCompoundedBalance, getConcentratedLiquidityConfig, getConnectionIdl, getConnectionProgram, getEvmChainKeyByChainId, getEvmViemChain, getIconAddressBytes, getIntentRelayChainId, getLinearBalance, getMarketReferenceCurrencyAndUsdBalance, getPacket, getProvider, getRandomBytes, getReserveNormalizedIncome, getReservesEModes, getSolanaAddressBytes, getSolverConfig, getSupportedSolverTokens, getTransactionPackets, getbnUSDToken, hexToBigInt, hexToSolanaAddress, hubConfig, hyper, hyperevmSupportedTokens, iconSupportedTokens, injectiveSupportedTokens, intentCreationFailed, isBalnMigrateParams, isBitcoinChainKey, isBitcoinChainKeyType, isBitcoinWalletProviderType, isBridgeAllowanceCheckError, isBridgeApproveError, isBridgeCreateIntentError, isBridgeError, isBridgeLookupError, isBridgeOrchestrationError, isCodeMember, isDexError, isEvmChainKey, isEvmChainKeyType, isEvmSpokeChainConfig, isEvmSpokeOnlyChainKey, isEvmSpokeOnlyChainKeyType, isEvmWalletProviderType, isFeatureError, isHubChainKey, isHubChainKeyType, isIconAddress, isIconChainKey, isIconChainKeyType, isIcxCreateRevertMigrationParams, isIcxMigrateParams, isInjectiveChainKey, isInjectiveChainKeyType, isJsonRpcPayloadResponse, isLegacybnUSDChainId, isLegacybnUSDToken, isLeverageYieldAllowanceCheckError, isLeverageYieldApproveError, isLeverageYieldCreateIntentError, isLeverageYieldError, isLeverageYieldLookupError, isLeverageYieldPostExecutionError, isLeverageYieldSwapError, isMigrateOrchestrationError, isMigrationAllowanceCheckError, isMigrationApproveError, isMigrationCreateIntentError, isMigrationError, isMigrationLookupError, isMoneyMarketAllowanceCheckError, isMoneyMarketApproveError, isMoneyMarketCreateIntentError, isMoneyMarketError, isMoneyMarketGasEstimationError, isMoneyMarketOrchestrationError, isNativeToken, isNearChainKey, isNearChainKeyType, isNewbnUSDChainId, isNewbnUSDToken, isOptionalBitcoinWalletProviderType, isOptionalEvmWalletProviderType, isOptionalStellarWalletProviderType, isPartnerError, isPartnerFeeAmount, isPartnerFeePercentage, isPostExecutionError, isRawDestinationParams, isRecoveryError, isResponseAddressType, isResponseSigningType, isRevertMigrationOrchestrationError, isSodaxError, isSolanaChainKey, isSolanaChainKeyType, isSolanaNativeToken, isSonicChainKey, isSonicChainKeyType, isSpokeApproveParamsEvmSpoke, isSpokeApproveParamsHub, isSpokeApproveParamsStellar, isSpokeChainKey, isSpokeIsAllowanceValidParamsEvmSpoke, isSpokeIsAllowanceValidParamsHub, isSpokeIsAllowanceValidParamsStellar, isStacksChainKey, isStacksChainKeyType, isStakeOrchestrationError, isStakingAllowanceCheckError, isStakingApproveError, isStakingCreateIntentError, isStakingError, isStakingInfoFetchError, isStakingOrchestrationError, isStellarChainKey, isStellarChainKeyType, isStellarWalletProviderType, isSubmitSwapTxResponse, isSubmitSwapTxStatusResponse, isSuiChainKey, isSuiChainKeyType, isSupportedBitcoinAddressType, isSwapCreateIntentError, isSwapError, isSwapSupportedToken, isUndefinedOrValidWalletProviderForChainKey, isUnifiedBnUSDMigrateParams, isValidWalletProviderForChainKey, kaiaSupportedTokens, leverageYieldConfig, leverageYieldInvariant, leverageYieldVaults, lightlinkSupportedTokens, lookupFailed, mapRelayFailure, mergeSodaxConfig, messageOf, migrationInvariant, mintPositionParamsAbi, mmInvariant, modifyLiquidityParamsAbi, moneyMarketConfig, moneyMarketReserveAssets, moneyMarketSupportedTokens, nativeToUSD, nearSupportedTokens, newbnUSDSpokeChainIds, normalize, normalizeBN, normalizePsbtToBase64, normalizeSignatureToBase64, normalizedToUsd, optimismSupportedTokens, pancakeSwapInfinityDefaultHookAbi, pancakeSwapInfinityPoolManagerAbi, pancakeSwapInfinityPositionManagerAbi, parseToStroops, parseTokenArrayFromJson, partnerInvariant, permit2Abi, polygonSupportedTokens, poolAbi, poolKeyAbi, randomUint256, rayDiv, rayMul, rayPow, rayToWad, recoveryInvariant, redbellySupportedTokens, relayConfig, relayTxAndWaitPacket, requestAddress, requestJsonRpc, requestSigning, resolveLogger, retry, reverseEncodeAddress, serializeAddressData, silentLogger, sleep, sodaxConfig, sodaxInvariant, solanaSupportedTokens, solverConfig, sonicSupportedTokens, sonicWalletFactoryAbi, spokeAssetManagerAbi, spokeChainConfig, spokeChainKeysSet, stacksSupportedTokens, stakedSodaAbi, stakingInvariant, stakingRouterAbi, stataTokenFactoryAbi, stellarSupportedTokens, submitTransaction, suiSupportedTokens, supportedSpokeChains, supportedTokensByChain, swapExactInSingleParamsAbi, swapInvariant, swapSupportedTokens, swapsConfig, uiPoolDataAbi, universalRouterAbi, unknownFailed, usesBip322MessageSigning, valueToBigNumber, valueToZDBigNumber, variableDebtTokenAbi, vaultTokenAbi, verifyFailed, wadToRay, waitForStacksTransaction, waitForTransactionReceipt, waitUntilIntentExecuted, walletFactoryAbi, wrappedSonicAbi };