@sodax/sdk 1.0.1-beta-rc3 → 1.0.2-beta

package/dist/index.mjs

@@ -6905,6 +6905,11 @@ var ConfigService = class {
   getMoneyMarketTokens() {
     return this.sodaxConfig.supportedMoneyMarketTokens;
   }
+  getMoneyMarketToken(chainId, token) {
+    return this.sodaxConfig.supportedMoneyMarketTokens[chainId].find(
+      (t) => t.address.toLowerCase() === token.toLowerCase()
+    );
+  }
   getMoneyMarketReserveAssets() {
     return this.sodaxConfig.supportedMoneyMarketReserveAssets;
   }
@@ -6924,7 +6929,10 @@ var ConfigService = class {
     return this.supportedSodaVaultAssetsSet.has(vault.toLowerCase());
   }
   isValidVault(vault) {
-    return this.isValidSodaVaultAsset(vault);
+    if (typeof vault === "string") {
+      return this.isValidSodaVaultAsset(vault);
+    }
+    return this.isValidSodaVaultAsset(vault.address);
   }
   isValidChainHubAsset(chainId, hubAsset) {
     return this.chainIdToHubAssetsMap.get(chainId)?.has(hubAsset.toLowerCase()) ?? false;
@@ -12899,7 +12907,8 @@ var SwapService = class {
     intentParams: params,
     spokeProvider,
     fee = this.config.partnerFee,
-    raw
+    raw,
+    skipSimulation = false
   }) {
     invariant6(
       this.configService.isValidOriginalAssetAddress(params.srcChain, params.inputToken),
@@ -12968,7 +12977,8 @@ var SwapService = class {
           },
           spokeProvider,
           this.hubProvider,
-          raw
+          raw,
+          skipSimulation
         );
         return {
           ok: true,
@@ -12988,6 +12998,179 @@ var SwapService = class {
       };
     }
   }
+  /**
+   * Creates a limit order intent (no deadline, must be cancelled manually by user).
+   * Similar to swap but enforces deadline=0n (no deadline).
+   * Limit orders remain active until manually cancelled by the user.
+   *
+   * @param {Prettify<LimitOrderParams<S> & OptionalTimeout>} params - Object containing:
+   *   - intentParams: The parameters for creating the limit order (deadline is automatically set to 0n, deadline field should be omitted).
+   *   - spokeProvider: The spoke provider instance.
+   *   - fee: (Optional) Partner fee configuration.
+   *   - timeout: (Optional) Timeout in milliseconds for the transaction (default: 60 seconds).
+   *   - skipSimulation: (Optional) Whether to skip transaction simulation (default: false).
+   * @returns {Promise<Result<[SolverExecutionResponse, Intent, IntentDeliveryInfo], IntentError<IntentErrorCode>>>} A promise resolving to a Result containing a tuple of SolverExecutionResponse, Intent, and intent delivery info, or an IntentError if the operation fails.
+   *
+   * @example
+   * const payload = {
+   *     "inputToken": "0x2170Ed0880ac9A755fd29B2688956BD959F933F8", // BSC ETH token address
+   *     "outputToken": "0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f", // ARB WBTC token address
+   *     "inputAmount": 1000000000000000n, // The amount of input tokens
+   *     "minOutputAmount": 900000000000000n, // min amount you are expecting to receive
+   *     // deadline is omitted - will be automatically set to 0n
+   *     "allowPartialFill": false, // Whether the intent can be partially filled
+   *     "srcChain": "0x38.bsc", // Chain ID where input tokens originate
+   *     "dstChain": "0xa4b1.arbitrum", // Chain ID where output tokens should be delivered
+   *     "srcAddress": "0x..", // Source address (original address on spoke chain)
+   *     "dstAddress": "0x...", // Destination address (original address on spoke chain)
+   *     "solver": "0x..", // Optional specific solver address (address(0) = any solver)
+   *     "data": "0x..", // Additional arbitrary data
+   * } satisfies CreateLimitOrderParams;
+   *
+   * const createLimitOrderResult = await swapService.createLimitOrder({
+   *   intentParams: payload,
+   *   spokeProvider,
+   *   fee, // optional
+   *   timeout, // optional
+   * });
+   *
+   * if (createLimitOrderResult.ok) {
+   *   const [solverExecutionResponse, intent, intentDeliveryInfo] = createLimitOrderResult.value;
+   *   console.log('Intent execution response:', solverExecutionResponse);
+   *   console.log('Intent:', intent);
+   *   console.log('Intent delivery info:', intentDeliveryInfo);
+   *   // Limit order is now active and will remain until cancelled manually
+   * } else {
+   *   // handle error
+   * }
+   */
+  async createLimitOrder({
+    intentParams: params,
+    spokeProvider,
+    fee = this.config.partnerFee,
+    timeout = DEFAULT_RELAY_TX_TIMEOUT,
+    skipSimulation = false
+  }) {
+    const limitOrderParams = {
+      ...params,
+      deadline: 0n
+    };
+    return this.createAndSubmitIntent({
+      intentParams: limitOrderParams,
+      spokeProvider,
+      fee,
+      timeout,
+      skipSimulation
+    });
+  }
+  /**
+   * Creates a limit order intent (no deadline, must be cancelled manually by user).
+   * Similar to createIntent but enforces deadline=0n (no deadline) and uses LimitOrderParams.
+   * Limit orders remain active until manually cancelled by the user.
+   * NOTE: This method does not submit the intent to the Solver API
+   *
+   * @param {Prettify<LimitOrderParams<S> & OptionalRaw<R>>} params - Object containing:
+   *   - intentParams: The parameters for creating the limit order (deadline is automatically set to 0n, deadline field should be omitted).
+   *   - spokeProvider: The spoke provider instance.
+   *   - fee: (Optional) Partner fee configuration.
+   *   - raw: (Optional) Whether to return the raw transaction data instead of executing it
+   *   - skipSimulation: (Optional) Whether to skip transaction simulation (default: false).
+   * @returns {Promise<Result<[TxReturnType<S, R>, Intent & FeeAmount, Hex], IntentError<'CREATION_FAILED'>>>} The encoded contract call or raw transaction data, Intent and intent data as hex
+   *
+   * @example
+   * const payload = {
+   *     "inputToken": "0x2170Ed0880ac9A755fd29B2688956BD959F933F8", // BSC ETH token address
+   *     "outputToken": "0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f", // ARB WBTC token address
+   *     "inputAmount": 1000000000000000n, // The amount of input tokens
+   *     "minOutputAmount": 900000000000000n, // min amount you are expecting to receive
+   *     // deadline is omitted - will be automatically set to 0n
+   *     "allowPartialFill": false, // Whether the intent can be partially filled
+   *     "srcChain": "0x38.bsc", // Chain ID where input tokens originate
+   *     "dstChain": "0xa4b1.arbitrum", // Chain ID where output tokens should be delivered
+   *     "srcAddress": "0x..", // Source address (original address on spoke chain)
+   *     "dstAddress": "0x...", // Destination address (original address on spoke chain)
+   *     "solver": "0x..", // Optional specific solver address (address(0) = any solver)
+   *     "data": "0x..", // Additional arbitrary data
+   * } satisfies CreateLimitOrderParams;
+   *
+   * const createLimitOrderIntentResult = await swapService.createLimitOrderIntent({
+   *   intentParams: payload,
+   *   spokeProvider,
+   *   fee, // optional
+   *   raw, // optional
+   * });
+   *
+   * if (createLimitOrderIntentResult.ok) {
+   *   const [txResult, intent, intentData] = createLimitOrderIntentResult.value;
+   *   console.log('Transaction result:', txResult);
+   *   console.log('Intent:', intent);
+   *   console.log('Intent data:', intentData);
+   * } else {
+   *   // handle error
+   * }
+   */
+  async createLimitOrderIntent({
+    intentParams: params,
+    spokeProvider,
+    fee = this.config.partnerFee,
+    raw,
+    skipSimulation = false
+  }) {
+    const limitOrderParams = {
+      ...params,
+      deadline: 0n
+    };
+    return this.createIntent({
+      intentParams: limitOrderParams,
+      spokeProvider,
+      fee,
+      raw,
+      skipSimulation
+    });
+  }
+  /**
+   * Syntactic sugar for cancelAndSubmitIntent: cancels a limit order intent and submits it to the Relayer API.
+   * Similar to swap function that wraps createAndSubmitIntent.
+   *
+   * @param params - Object containing:
+   * @param params.intent - The limit order intent to cancel.
+   * @param params.spokeProvider - The spoke provider instance.
+   * @param params.timeout - (Optional) Timeout in milliseconds for the transaction (default: 60 seconds).
+   * @returns
+   *   A promise resolving to a Result containing a tuple of cancel transaction hash and destination transaction hash,
+   *   or an IntentError if the operation fails.
+   *
+   * @example
+   * // Get intent first (or use intent from createLimitOrder response)
+   * const intent: Intent = await swapService.getIntent(txHash);
+   *
+   * // Cancel the limit order
+   * const result = await swapService.cancelLimitOrder({
+   *   intent,
+   *   spokeProvider,
+   *   timeout, // optional
+   * });
+   *
+   * if (result.ok) {
+   *   const [cancelTxHash, dstTxHash] = result.value;
+   *   console.log('Cancel transaction hash:', cancelTxHash);
+   *   console.log('Destination transaction hash:', dstTxHash);
+   * } else {
+   *   // handle error
+   *   console.error('[cancelLimitOrder] error:', result.error);
+   * }
+   */
+  async cancelLimitOrder({
+    intent,
+    spokeProvider,
+    timeout = DEFAULT_RELAY_TX_TIMEOUT
+  }) {
+    return this.cancelAndSubmitIntent({
+      intent,
+      spokeProvider,
+      timeout
+    });
+  }
   /**
    * Cancels an intent
    * @param {Intent} intent - The intent to cancel
@@ -13029,7 +13212,97 @@ var SwapService = class {
     } catch (error) {
       return {
         ok: false,
-        error
+        error: {
+          code: "CANCEL_FAILED",
+          data: {
+            payload: intent,
+            error
+          }
+        }
+      };
+    }
+  }
+  /**
+   * Cancels an intent on the spoke chain, submits the cancel intent to the relayer API,
+   * and waits until the intent cancel is executed (on the destination/hub chain).
+   * Follows a similar workflow to createAndSubmitIntent, but for cancelling.
+   *
+   * @param params - The parameters for canceling and submitting the intent.
+   * @param params.intent - The intent to be canceled.
+   * @param params.spokeProvider - The provider for the spoke chain.
+   * @param params.timeout - Optional timeout in milliseconds (default: 60 seconds).
+   * @returns
+   *   A Result containing the SolverExecutionResponse (cancel tx), intent, and relay info,
+   *   or an IntentError on failure.
+   */
+  async cancelAndSubmitIntent({
+    intent,
+    spokeProvider,
+    timeout = DEFAULT_RELAY_TX_TIMEOUT
+  }) {
+    try {
+      const cancelResult = await this.cancelIntent(intent, spokeProvider, false);
+      if (!cancelResult.ok) {
+        return cancelResult;
+      }
+      const cancelTxHash = cancelResult.value;
+      const verifyTxHashResult = await SpokeService.verifyTxHash(cancelTxHash, spokeProvider);
+      if (!verifyTxHashResult.ok) {
+        return {
+          ok: false,
+          error: {
+            code: "CANCEL_FAILED",
+            data: {
+              payload: intent,
+              error: verifyTxHashResult.error
+            }
+          }
+        };
+      }
+      let dstIntentTxHash;
+      if (spokeProvider.chainConfig.chain.id !== this.hubProvider.chainConfig.chain.id) {
+        const intentRelayChainId = intent.srcChain.toString();
+        const submitPayload = {
+          action: "submit",
+          params: {
+            chain_id: intentRelayChainId,
+            tx_hash: cancelTxHash
+          }
+        };
+        const submitResult = await this.submitIntent(submitPayload);
+        if (!submitResult.ok) {
+          return submitResult;
+        }
+        const packet = await waitUntilIntentExecuted({
+          intentRelayChainId,
+          spokeTxHash: cancelTxHash,
+          timeout,
+          apiUrl: this.config.relayerApiEndpoint
+        });
+        if (!packet.ok) {
+          return {
+            ok: false,
+            error: packet.error
+          };
+        }
+        dstIntentTxHash = packet.value.dst_tx_hash;
+      } else {
+        dstIntentTxHash = cancelTxHash;
+      }
+      return {
+        ok: true,
+        value: [cancelTxHash, dstIntentTxHash]
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        error: {
+          code: "CANCEL_FAILED",
+          data: {
+            payload: intent,
+            error
+          }
+        }
       };
     }
   }
@@ -13346,7 +13619,7 @@ var SonicSpokeService = class _SonicSpokeService {
     const aTokenAddress = (await dataService.getReserveData(vaultAddress)).aTokenAddress;
     return {
       aTokenAddress,
-      aTokenAmount: amount,
+      aTokenAmount: EvmVaultTokenService.translateIncomingDecimals(assetConfig.decimal, amount),
       token
     };
   }
@@ -13359,12 +13632,15 @@ var SonicSpokeService = class _SonicSpokeService {
    * @param configService - The config service
    * @returns BorrowInfo containing variable debt token address and vault address
    */
-  static async getBorrowInfo(token, amount, chainId, dataService, configService) {
+  static async getBorrowInfo(token, amount, chainId, dataService, configService, moneyMarketConfig) {
     const assetConfig = configService.getHubAssetInfo(chainId, token);
     if (!assetConfig) {
       throw new Error("[SonicSpokeService.getBorrowInfo] Hub asset not found");
     }
-    const vaultAddress = assetConfig.vault;
+    let vaultAddress = assetConfig.vault;
+    if (moneyMarketConfig.bnUSDVault.toLowerCase() === vaultAddress.toLowerCase()) {
+      vaultAddress = moneyMarketConfig.bnUSD;
+    }
     const reserveData = await dataService.getReserveData(vaultAddress);
     const variableDebtTokenAddress = reserveData.variableDebtTokenAddress;
     return {
@@ -13576,10 +13852,18 @@ var MoneyMarketService = class _MoneyMarketService {
     try {
       invariant6(params.amount > 0n, "Amount must be greater than 0");
       invariant6(params.token.length > 0, "Token is required");
-      invariant6(
-        this.configService.isMoneyMarketSupportedToken(spokeProvider.chainConfig.chain.id, params.token),
-        `Unsupported spoke chain (${spokeProvider.chainConfig.chain.id}) token: ${params.token}`
-      );
+      if (params.action === "withdraw" || params.action === "borrow") {
+        const toChainId = params.toChainId ?? spokeProvider.chainConfig.chain.id;
+        invariant6(
+          this.configService.isMoneyMarketSupportedToken(toChainId, params.token),
+          `Unsupported spoke chain (${toChainId}) token: ${params.token}`
+        );
+      } else {
+        invariant6(
+          this.configService.isMoneyMarketSupportedToken(spokeProvider.chainConfig.chain.id, params.token),
+          `Unsupported spoke chain (${spokeProvider.chainConfig.chain.id}) token: ${params.token}`
+        );
+      }
       const walletAddress = await spokeProvider.walletProvider.getWalletAddress();
       if (spokeProvider instanceof StellarSpokeProvider && (params.action === "supply" || params.action === "repay")) {
         return {
@@ -13617,7 +13901,8 @@ var MoneyMarketService = class _MoneyMarketService {
             params.amount,
             params.toChainId ?? spokeProvider.chainConfig.chain.id,
             this.data,
-            this.configService
+            this.configService,
+            this.config
           );
           return await SonicSpokeService.isBorrowApproved(
             walletAddress,
@@ -13681,10 +13966,18 @@ var MoneyMarketService = class _MoneyMarketService {
     try {
       invariant6(params.amount > 0n, "Amount must be greater than 0");
       invariant6(params.token.length > 0, "Token is required");
-      invariant6(
-        this.configService.isMoneyMarketSupportedToken(spokeProvider.chainConfig.chain.id, params.token),
-        `Unsupported spoke chain (${spokeProvider.chainConfig.chain.id}) token: ${params.token}`
-      );
+      if (params.action === "withdraw" || params.action === "borrow") {
+        const toChainId = params.toChainId ?? spokeProvider.chainConfig.chain.id;
+        invariant6(
+          this.configService.isMoneyMarketSupportedToken(toChainId, params.token),
+          `Unsupported spoke chain (${toChainId}) token: ${params.token}`
+        );
+      } else {
+        invariant6(
+          this.configService.isMoneyMarketSupportedToken(spokeProvider.chainConfig.chain.id, params.token),
+          `Unsupported spoke chain (${spokeProvider.chainConfig.chain.id}) token: ${params.token}`
+        );
+      }
       const walletAddress = await spokeProvider.walletProvider.getWalletAddress();
       if (spokeProvider instanceof StellarSpokeProvider) {
         invariant6(
@@ -13746,7 +14039,8 @@ var MoneyMarketService = class _MoneyMarketService {
             params.amount,
             params?.toChainId ?? spokeProvider.chainConfig.chain.id,
             this.data,
-            this.configService
+            this.configService,
+            this.config
           );
           const result = await SonicSpokeService.approveBorrow(
             walletAddress,
@@ -13835,7 +14129,7 @@ var MoneyMarketService = class _MoneyMarketService {
         };
       }
       let intentTxHash = null;
-      if (spokeProvider.chainConfig.chain.id !== SONIC_MAINNET_CHAIN_ID) {
+      if (spokeProvider.chainConfig.chain.id !== this.hubProvider.chainConfig.chain.id) {
         const packetResult = await relayTxAndWaitPacket(
           txResult.value,
           spokeProvider instanceof SolanaSpokeProvider ? txResult.data : void 0,
@@ -14000,10 +14294,8 @@ var MoneyMarketService = class _MoneyMarketService {
           }
         };
       }
-      const fromChainId = spokeProvider.chainConfig.chain.id;
-      const toChainId = params.toChainId ?? fromChainId;
       let intentTxHash = null;
-      if (toChainId !== SONIC_MAINNET_CHAIN_ID) {
+      if (spokeProvider.chainConfig.chain.id !== this.hubProvider.chainConfig.chain.id || params.toChainId && params.toAddress && params.toChainId !== this.hubProvider.chainConfig.chain.id) {
         const packetResult = await relayTxAndWaitPacket(
           txResult.value,
           spokeProvider instanceof SolanaSpokeProvider ? txResult.data : void 0,
@@ -14079,13 +14371,11 @@ var MoneyMarketService = class _MoneyMarketService {
     const fromAddress = await spokeProvider.walletProvider.getWalletAddress();
     const toChainId = params.toChainId ?? fromChainId;
     const toAddress = params.toAddress ?? fromAddress;
-    invariant6(
-      this.configService.isMoneyMarketSupportedToken(toChainId, params.token),
-      `Unsupported spoke chain (${toChainId}) token: ${params.token}`
-    );
+    const dstToken = this.configService.getMoneyMarketToken(toChainId, params.token);
+    invariant6(dstToken, `Money market token not found for spoke chain (${toChainId}) token: ${params.token}`);
     const encodedToAddress = encodeAddress(toChainId, toAddress);
     const fromHubWallet = await deriveUserWalletAddress(this.hubProvider, fromChainId, fromAddress);
-    const data = this.buildBorrowData(fromHubWallet, encodedToAddress, params.token, params.amount, toChainId);
+    const data = this.buildBorrowData(fromHubWallet, encodedToAddress, dstToken.address, params.amount, toChainId);
     let txResult;
     if (fromChainId === this.hubProvider.chainConfig.chain.id && isSonicSpokeProviderType(spokeProvider)) {
       txResult = await SonicSpokeService.callWallet(data, spokeProvider, raw);
@@ -14148,10 +14438,8 @@ var MoneyMarketService = class _MoneyMarketService {
           }
         };
       }
-      const fromChainId = spokeProvider.chainConfig.chain.id;
-      const toChainId = params.toChainId ?? fromChainId;
       let intentTxHash = null;
-      if (toChainId !== SONIC_MAINNET_CHAIN_ID) {
+      if (spokeProvider.chainConfig.chain.id !== this.hubProvider.chainConfig.chain.id || params.toChainId && params.toAddress && params.toChainId !== this.hubProvider.chainConfig.chain.id && params.toAddress !== this.hubProvider.chainConfig.addresses.walletRouter) {
         const packetResult = await relayTxAndWaitPacket(
           txResult.value,
           spokeProvider instanceof SolanaSpokeProvider ? txResult.data : void 0,
@@ -14312,7 +14600,7 @@ var MoneyMarketService = class _MoneyMarketService {
         };
       }
       let intentTxHash = null;
-      if (spokeProvider.chainConfig.chain.id !== SONIC_MAINNET_CHAIN_ID) {
+      if (spokeProvider.chainConfig.chain.id !== this.hubProvider.chainConfig.chain.id) {
         const packetResult = await relayTxAndWaitPacket(
           txResult.value,
           spokeProvider instanceof SolanaSpokeProvider ? txResult.data : void 0,
@@ -14431,8 +14719,10 @@ var MoneyMarketService = class _MoneyMarketService {
     const fromHubAsset = this.configService.getHubAssetInfo(fromChainId, fromToken);
     invariant6(fromHubAsset, `hub asset not found for source chain token (token): ${fromToken}`);
     const lendingPool = this.config.lendingPool;
-    calls.push(Erc20Service.encodeApprove(fromHubAsset.asset, fromHubAsset.vault, amount));
-    calls.push(EvmVaultTokenService.encodeDeposit(fromHubAsset.vault, fromHubAsset.asset, amount));
+    if (!this.configService.isValidVault(fromHubAsset.asset)) {
+      calls.push(Erc20Service.encodeApprove(fromHubAsset.asset, fromHubAsset.vault, amount));
+      calls.push(EvmVaultTokenService.encodeDeposit(fromHubAsset.vault, fromHubAsset.asset, amount));
+    }
     const translatedAmount = EvmVaultTokenService.translateIncomingDecimals(fromHubAsset.decimal, amount);
     calls.push(Erc20Service.encodeApprove(fromHubAsset.vault, lendingPool, translatedAmount));
     calls.push(
@@ -14454,29 +14744,44 @@ var MoneyMarketService = class _MoneyMarketService {
    */
   buildBorrowData(fromHubAddress, toAddress, toToken, amount, toChainId) {
     const toHubAsset = this.configService.getHubAssetInfo(toChainId, toToken);
+    const dstToken = this.configService.getMoneyMarketToken(toChainId, toToken);
     invariant6(toHubAsset, `hub asset not found for target chain token (toToken): ${toToken}`);
+    invariant6(dstToken, `Money market token not found for spoke chain (${toChainId}) token: ${toToken}`);
     const assetAddress = toHubAsset.asset;
     const vaultAddress = toHubAsset.vault;
     const bnUSDVault = this.config.bnUSDVault;
     const bnUSD = this.config.bnUSD;
-    const feeAmount = calculateFeeAmount(amount, this.config.partnerFee);
+    const translatedInAmount = EvmVaultTokenService.translateIncomingDecimals(toHubAsset.decimal, amount);
+    const feeAmount = calculateFeeAmount(translatedInAmount, this.config.partnerFee);
     const calls = [];
-    if (bnUSDVault && bnUSD && bnUSDVault.toLowerCase() === vaultAddress.toLowerCase()) {
+    if (bnUSDVault.toLowerCase() === vaultAddress.toLowerCase()) {
       calls.push(
         _MoneyMarketService.encodeBorrow(
-          { asset: bnUSD, amount, interestRateMode: 2n, referralCode: 0, onBehalfOf: fromHubAddress },
+          {
+            asset: bnUSD,
+            amount: translatedInAmount,
+            interestRateMode: 2n,
+            referralCode: 0,
+            onBehalfOf: fromHubAddress
+          },
           this.config.lendingPool
         )
       );
-      calls.push(Erc20Service.encodeApprove(bnUSD, bnUSDVault, amount));
-      calls.push(EvmVaultTokenService.encodeDeposit(bnUSDVault, bnUSD, amount));
+      calls.push(Erc20Service.encodeApprove(bnUSD, bnUSDVault, translatedInAmount));
+      calls.push(EvmVaultTokenService.encodeDeposit(bnUSDVault, bnUSD, translatedInAmount));
       if (this.config.partnerFee && feeAmount) {
         calls.push(Erc20Service.encodeTransfer(bnUSDVault, this.config.partnerFee.address, feeAmount));
       }
     } else {
       calls.push(
         _MoneyMarketService.encodeBorrow(
-          { asset: vaultAddress, amount, interestRateMode: 2n, referralCode: 0, onBehalfOf: fromHubAddress },
+          {
+            asset: vaultAddress,
+            amount: translatedInAmount,
+            interestRateMode: 2n,
+            referralCode: 0,
+            onBehalfOf: fromHubAddress
+          },
           this.config.lendingPool
         )
       );
@@ -14484,8 +14789,21 @@ var MoneyMarketService = class _MoneyMarketService {
         calls.push(Erc20Service.encodeTransfer(vaultAddress, this.config.partnerFee.address, feeAmount));
       }
     }
-    calls.push(EvmVaultTokenService.encodeWithdraw(vaultAddress, assetAddress, amount - feeAmount));
-    const translatedAmountOut = EvmVaultTokenService.translateOutgoingDecimals(toHubAsset.decimal, amount - feeAmount);
+    if (toToken.toLowerCase() !== vaultAddress.toLowerCase()) {
+      calls.push(EvmVaultTokenService.encodeWithdraw(vaultAddress, assetAddress, translatedInAmount - feeAmount));
+    }
+    let translatedAmountOut;
+    if (this.configService.isValidVault(toToken)) {
+      translatedAmountOut = EvmVaultTokenService.translateOutgoingDecimals(
+        toHubAsset.decimal,
+        translatedInAmount - feeAmount
+      );
+    } else {
+      translatedAmountOut = EvmVaultTokenService.translateOutgoingDecimals(
+        dstToken.decimals,
+        translatedInAmount - feeAmount
+      );
+    }
     if (toChainId === this.hubProvider.chainConfig.chain.id) {
       if (assetAddress.toLowerCase() === this.configService.spokeChainConfig[toChainId].addresses.wrappedSonic.toLowerCase()) {
         const withdrawToCall = {
@@ -14525,17 +14843,27 @@ var MoneyMarketService = class _MoneyMarketService {
   buildWithdrawData(fromHubAddress, toAddress, toToken, amount, toChainId) {
     const calls = [];
     const toHubAsset = this.configService.getHubAssetInfo(toChainId, toToken);
+    const dstToken = this.configService.getMoneyMarketToken(toChainId, toToken);
     invariant6(toHubAsset, `hub asset not found for target chain token (toToken): ${toToken}`);
+    invariant6(dstToken, `Money market token not found for spoke chain (${toChainId}) token: ${toToken}`);
     const assetAddress = toHubAsset.asset;
     const vaultAddress = toHubAsset.vault;
+    const translatedInAmount = EvmVaultTokenService.translateIncomingDecimals(toHubAsset.decimal, amount);
     calls.push(
       _MoneyMarketService.encodeWithdraw(
-        { asset: vaultAddress, amount, to: fromHubAddress },
+        { asset: vaultAddress, amount: translatedInAmount, to: fromHubAddress },
         this.config.lendingPool
       )
     );
-    calls.push(EvmVaultTokenService.encodeWithdraw(vaultAddress, assetAddress, amount));
-    const translatedAmountOut = EvmVaultTokenService.translateOutgoingDecimals(toHubAsset.decimal, amount);
+    if (!this.configService.isValidVault(toToken)) {
+      calls.push(EvmVaultTokenService.encodeWithdraw(vaultAddress, assetAddress, translatedInAmount));
+    }
+    let translatedAmountOut;
+    if (this.configService.isValidVault(toToken)) {
+      translatedAmountOut = EvmVaultTokenService.translateOutgoingDecimals(toHubAsset.decimal, translatedInAmount);
+    } else {
+      translatedAmountOut = EvmVaultTokenService.translateOutgoingDecimals(dstToken.decimals, translatedInAmount);
+    }
     if (toChainId === this.hubProvider.chainConfig.chain.id) {
       if (assetAddress.toLowerCase() === this.configService.spokeChainConfig[toChainId].addresses.wrappedSonic.toLowerCase()) {
         const withdrawToCall = {
@@ -14579,18 +14907,23 @@ var MoneyMarketService = class _MoneyMarketService {
     const vaultAddress = fromHubAsset.vault;
     const bnUSDVault = this.config.bnUSDVault;
     const bnUSD = this.config.bnUSD;
-    calls.push(Erc20Service.encodeApprove(assetAddress, vaultAddress, amount));
-    calls.push(EvmVaultTokenService.encodeDeposit(vaultAddress, assetAddress, amount));
-    const translatedAmount = EvmVaultTokenService.translateIncomingDecimals(fromHubAsset.decimal, amount);
+    const translatedAmountIn = EvmVaultTokenService.translateIncomingDecimals(fromHubAsset.decimal, amount);
     let repayToken = vaultAddress;
-    if (bnUSDVault && bnUSD && bnUSDVault.toLowerCase() === vaultAddress.toLowerCase()) {
+    if (bnUSDVault.toLowerCase() === vaultAddress.toLowerCase()) {
       repayToken = bnUSD;
-      calls.push(EvmVaultTokenService.encodeWithdraw(bnUSDVault, bnUSD, translatedAmount));
+      if (assetAddress.toLowerCase() !== bnUSDVault.toLowerCase()) {
+        calls.push(Erc20Service.encodeApprove(assetAddress, vaultAddress, translatedAmountIn));
+        calls.push(EvmVaultTokenService.encodeDeposit(vaultAddress, assetAddress, translatedAmountIn));
+      }
+      calls.push(EvmVaultTokenService.encodeWithdraw(bnUSDVault, bnUSD, translatedAmountIn));
+    } else {
+      calls.push(Erc20Service.encodeApprove(assetAddress, vaultAddress, amount));
+      calls.push(EvmVaultTokenService.encodeDeposit(vaultAddress, assetAddress, amount));
     }
-    calls.push(Erc20Service.encodeApprove(repayToken, this.config.lendingPool, translatedAmount));
+    calls.push(Erc20Service.encodeApprove(repayToken, this.config.lendingPool, translatedAmountIn));
     calls.push(
       _MoneyMarketService.encodeRepay(
-        { asset: repayToken, amount: translatedAmount, interestRateMode: 2n, onBehalfOf: toHubAddress },
+        { asset: repayToken, amount: translatedAmountIn, interestRateMode: 2n, onBehalfOf: toHubAddress },
         this.config.lendingPool
       )
     );
@@ -15610,6 +15943,29 @@ var BackendApiService = class {
     const endpoint = `/solver/orderbook?${queryString}`;
     return this.makeRequest(endpoint, { method: "GET" });
   }
+  /**
+   * Get all intents created by a specific user address with optional filters.
+   *
+   * @param params - Options to filter the user intents.
+   * @param params.userAddress - The user's wallet address on the hub chain (required).
+   * @param params.startDate - Optional. Start timestamp in milliseconds (number, required if filtering by date).
+   * @param params.endDate - Optional. End timestamp in milliseconds (number, required if filtering by date).
+   * @param params.limit - Optional. Max number of results (string).
+   * @param params.offset - Optional. Pagination offset (string).
+   *
+   * @returns {Promise<UserIntentsResponse>} Promise resolving to an array of intent responses for the user.
+   */
+  async getUserIntents(params) {
+    const { userAddress, startDate, endDate, limit, offset } = params;
+    const queryParams = new URLSearchParams();
+    if (startDate) queryParams.append("startDate", new Date(startDate).toISOString());
+    if (endDate) queryParams.append("endDate", new Date(endDate).toISOString());
+    if (limit) queryParams.append("limit", limit);
+    if (offset) queryParams.append("offset", offset);
+    const queryString = queryParams.toString();
+    const endpoint = queryString.length > 0 ? `/intent/user/${userAddress}?${queryString}` : `/intent/user/${userAddress}`;
+    return this.makeRequest(endpoint, { method: "GET" });
+  }
   // Money Market endpoints
   /**
    * Get money market position for a specific user
@@ -17086,7 +17442,13 @@ var StakingService = class {
         spokeProvider,
         this.hubProvider
       );
-      const data = this.buildUnstakeData(hubWallet, params);
+      const xSoda = this.hubProvider.chainConfig.addresses.xSoda;
+      const underlyingSodaAmount = await StakingLogic.convertXSodaSharesToSoda(
+        xSoda,
+        params.amount,
+        this.hubProvider.publicClient
+      );
+      const data = this.buildUnstakeData(hubWallet, params, xSoda, underlyingSodaAmount);
       let txResult;
       if (isHub) {
         txResult = await SpokeService.deposit(
@@ -17129,13 +17491,12 @@ var StakingService = class {
    * @param params - The unstake parameters
    * @returns The encoded contract call data
    */
-  buildUnstakeData(hubWallet, params) {
+  buildUnstakeData(hubWallet, params, xSoda, underlyingSodaAmount) {
     const hubConfig = getHubChainConfig();
     const stakedSoda = hubConfig.addresses.stakedSoda;
-    const xSoda = hubConfig.addresses.xSoda;
     const calls = [];
     calls.push(StakingLogic.encodeXSodaRedeem(xSoda, params.amount, hubWallet, hubWallet));
-    calls.push(StakingLogic.encodeUnstake(stakedSoda, hubWallet, params.amount));
+    calls.push(StakingLogic.encodeUnstake(stakedSoda, hubWallet, underlyingSodaAmount));
     return encodeContractCalls(calls);
   }
   /**