@skip-go/client 1.4.0 → 1.5.1

package/dist/esm/api/getBridges.d.ts

@@ -1,12 +1,12 @@
 import { S as SkipApiOptions } from '../apiState-DwZhwVul.js';
-import { bv as ContentType, J as BridgeType } from '../swaggerTypes-DDwqIjap.js';
+import { bE as ContentType, J as BridgeType } from '../swaggerTypes-Bh6hu5Q-.js';
 
 declare const bridges: (options?: ({
     cache?: RequestCache | undefined;
     credentials?: RequestCredentials | undefined;
-    headers?: string[][] | {
+    headers?: {
         [x: string]: string;
-    } | {
+    } | string[][] | {
         append: {};
         delete: {};
         get: {};

package/dist/esm/api/getChains.d.ts

@@ -1,4 +1,4 @@
-import { L as ChainType } from '../swaggerTypes-DDwqIjap.js';
+import { L as ChainType } from '../swaggerTypes-Bh6hu5Q-.js';
 import { S as SkipApiOptions } from '../apiState-DwZhwVul.js';
 
 declare const chains: (options?: ({

package/dist/esm/api/postAssetsFromSource.d.ts

@@ -1,10 +1,19 @@
-import { c as Asset } from '../swaggerTypes-DDwqIjap.js';
 import { S as SkipApiOptions } from '../apiState-DwZhwVul.js';
+import { ao as Reason, c as Asset } from '../swaggerTypes-Bh6hu5Q-.js';
 
 declare const assetsFromSource: (options?: ({
     sourceAssetDenom: string;
     sourceAssetChainId: string;
     allowMultiTx?: boolean | undefined;
+    recommendationReason?: Reason | undefined;
+    includeSwaps?: boolean | undefined;
+    swapVenues?: {
+        chainId?: string | undefined;
+        name?: string | undefined;
+        logoUri?: string | undefined;
+    }[] | undefined;
+    nativeOnly?: boolean | undefined;
+    groupBy?: string | undefined;
     includeCw20Assets?: boolean | undefined;
 } & SkipApiOptions & {
     abortDuplicateRequests?: boolean | undefined;

package/dist/esm/api/postBalances.d.ts

@@ -1,6 +1,6 @@
 import { S as SkipApiOptions } from '../apiState-DwZhwVul.js';
-import { A as ApiRequest, a as ApiResponse } from '../generateApi-C_xgtxrO.js';
-import '../swaggerTypes-DDwqIjap.js';
+import { A as ApiRequest, a as ApiResponse } from '../generateApi-CwM4Ca30.js';
+import '../swaggerTypes-Bh6hu5Q-.js';
 
 declare const balances: (options?: ({
     chains?: {

package/dist/esm/api/postMessages.d.ts

@@ -1,6 +1,6 @@
-import { b3 as FeeType, J as BridgeType, b4 as FeeBehavior } from '../swaggerTypes-DDwqIjap.js';
+import { b3 as FeeType, J as BridgeType, b4 as FeeBehavior } from '../swaggerTypes-Bh6hu5Q-.js';
 import { S as SkipApiOptions } from '../apiState-DwZhwVul.js';
-import { A as ApiRequest, a as ApiResponse } from '../generateApi-C_xgtxrO.js';
+import { A as ApiRequest, a as ApiResponse } from '../generateApi-CwM4Ca30.js';
 
 declare const messages: (request: MessagesRequest) => Promise<{
     msgs?: ({

package/dist/esm/api/postMessagesDirect.d.ts

@@ -1,5 +1,5 @@
 import { S as SkipApiOptions } from '../apiState-DwZhwVul.js';
-import { f as AutopilotAction, J as BridgeType, ap as RoutePriceWarningType, b3 as FeeType, b4 as FeeBehavior } from '../swaggerTypes-DDwqIjap.js';
+import { f as AutopilotAction, J as BridgeType, ap as RoutePriceWarningType, b3 as FeeType, b4 as FeeBehavior } from '../swaggerTypes-Bh6hu5Q-.js';
 
 declare const messagesDirect: (options?: ({
     sourceAssetDenom?: string | undefined;
@@ -275,6 +275,8 @@ declare const messagesDirect: (options?: ({
                 bridgeId?: BridgeType | undefined;
                 denomIn?: string | undefined;
                 denomOut?: string | undefined;
+                sourceDomain?: string | undefined;
+                destinationDomain?: string | undefined;
                 fee?: {
                     feeAsset: {
                         chainId: string;

package/dist/esm/api/postRecommendAssets.d.ts

@@ -1,5 +1,5 @@
 import { S as SkipApiOptions } from '../apiState-DwZhwVul.js';
-import { ao as Reason } from '../swaggerTypes-DDwqIjap.js';
+import { ao as Reason } from '../swaggerTypes-Bh6hu5Q-.js';
 
 declare const recommendAssets: (options?: ({
     requests?: {

package/dist/esm/api/postRoute.d.ts

@@ -1,6 +1,6 @@
-import { J as BridgeType, ap as RoutePriceWarningType, b3 as FeeType, b4 as FeeBehavior } from '../swaggerTypes-DDwqIjap.js';
+import { J as BridgeType, ap as RoutePriceWarningType, b3 as FeeType, b4 as FeeBehavior } from '../swaggerTypes-Bh6hu5Q-.js';
 import { S as SkipApiOptions } from '../apiState-DwZhwVul.js';
-import { A as ApiRequest } from '../generateApi-C_xgtxrO.js';
+import { A as ApiRequest } from '../generateApi-CwM4Ca30.js';
 
 declare const route: (request: RouteRequest) => Promise<{
     amountIn: string;
@@ -163,6 +163,8 @@ declare const route: (request: RouteRequest) => Promise<{
             bridgeId?: BridgeType | undefined;
             denomIn?: string | undefined;
             denomOut?: string | undefined;
+            sourceDomain?: string | undefined;
+            destinationDomain?: string | undefined;
             fee?: {
                 feeAsset: {
                     chainId: string;

package/dist/esm/api/postSubmitTransaction.d.ts

@@ -1,6 +1,6 @@
 import { S as SkipApiOptions } from '../apiState-DwZhwVul.js';
-import { A as ApiRequest, a as ApiResponse } from '../generateApi-C_xgtxrO.js';
-import '../swaggerTypes-DDwqIjap.js';
+import { A as ApiRequest, a as ApiResponse } from '../generateApi-CwM4Ca30.js';
+import '../swaggerTypes-Bh6hu5Q-.js';
 
 declare const submitTransaction: (options?: ({
     tx?: string | undefined;

package/dist/esm/api/postTrackTransaction.d.ts

@@ -1,6 +1,6 @@
 import { S as SkipApiOptions } from '../apiState-DwZhwVul.js';
-import { A as ApiRequest, P as PollingProps } from '../generateApi-C_xgtxrO.js';
-import '../swaggerTypes-DDwqIjap.js';
+import { A as ApiRequest, P as PollingProps } from '../generateApi-CwM4Ca30.js';
+import '../swaggerTypes-Bh6hu5Q-.js';
 
 type TrackTxRequest = ApiRequest<"status"> & TrackTxPollingProps & SkipApiOptions;
 type TrackTxPollingProps = Omit<PollingProps<"status">, "isSuccess" | "onError" | "onSuccess">;

package/dist/esm/api/postTransactionStatus.d.ts

@@ -1,5 +1,5 @@
-import { av as StatusErrorType, aJ as TransactionState, al as PacketErrorType, aS as TransferState, k as AxelarTransferState, O as ContractCallWithTokenErrorType, as as SendTokenErrorType, l as AxelarTransferType, p as CCTPTransferState, a8 as HyperlaneTransferState, aO as OPInitTransferState, s as StargateTransferState, w as GoFastTransferState, aP as LayerZeroTransferState } from '../swaggerTypes-DDwqIjap.js';
-import { a as ApiResponse } from '../generateApi-C_xgtxrO.js';
+import { av as StatusErrorType, aJ as TransactionState, al as PacketErrorType, aS as TransferState, k as AxelarTransferState, O as ContractCallWithTokenErrorType, as as SendTokenErrorType, l as AxelarTransferType, p as CCTPTransferState, a8 as HyperlaneTransferState, aO as OPInitTransferState, s as StargateTransferState, w as GoFastTransferState, aP as LayerZeroTransferState } from '../swaggerTypes-Bh6hu5Q-.js';
+import { a as ApiResponse } from '../generateApi-CwM4Ca30.js';
 import { S as SkipApiOptions } from '../apiState-DwZhwVul.js';
 
 declare const transactionStatus: (params?: ({

package/dist/esm/{callbacks-B3kjKg0v.d.ts → callbacks-DCqqd0D9.d.ts}

@@ -1,8 +1,7 @@
 import { TxStatusResponse } from './api/postTransactionStatus.js';
-import { aS as TransferState, k as AxelarTransferState, p as CCTPTransferState, a8 as HyperlaneTransferState, aO as OPInitTransferState, w as GoFastTransferState, s as StargateTransferState, aP as LayerZeroTransferState, bf as RouteResponse, W as CosmosMsg, an as PostHandler, aT as TransferAssetRelease, aJ as TransactionState, aq as Route, aU as TransferStatus, T as Erc20Approval } from './swaggerTypes-DDwqIjap.js';
-import { A as ApiRequest } from './generateApi-C_xgtxrO.js';
-import { S as SignerGetters, b as GasOptions, U as UserAddress, T as TxResult } from './client-types-B7Fin0mq.js';
-import { TrackTxPollingProps } from './api/postTrackTransaction.js';
+import { aS as TransferState, k as AxelarTransferState, p as CCTPTransferState, a8 as HyperlaneTransferState, aO as OPInitTransferState, w as GoFastTransferState, s as StargateTransferState, aP as LayerZeroTransferState, bo as RouteResponse, W as CosmosMsg, an as PostHandler, aT as TransferAssetRelease, aJ as TransactionState, aq as Route, aU as TransferStatus, T as Erc20Approval } from './swaggerTypes-Bh6hu5Q-.js';
+import { A as ApiRequest } from './generateApi-CwM4Ca30.js';
+import { S as SignerGetters, b as GasOptions, B as BaseSettings, U as UserAddress, T as TxResult } from './client-types-BSZasIDd.js';
 
 type TransferEventStatus = "unconfirmed" | "signing" | "pending" | "completed" | "failed" | "approving" | "incomplete";
 type ClientTransferEvent = {
@@ -16,71 +15,20 @@ type ClientTransferEvent = {
 };
 
 /** Execute Route Options */
-type ExecuteRouteOptions = SignerGetters & GasOptions & TransactionCallbacks & Pick<ApiRequest<"msgs">, "timeoutSeconds"> & {
+type ExecuteRouteOptions = SignerGetters & GasOptions & TransactionCallbacks & BaseSettings & Pick<ApiRequest<"msgs">, "timeoutSeconds"> & {
     route: RouteResponse;
     /**
-     * Addresses should be in the same order with the `chainIDs` in the `route`
+     * Addresses should be in the same order with the `requiredChainAddresses` in the `route`
      */
     userAddresses: UserAddress[];
-    simulate?: boolean;
-    slippageTolerancePercent?: string;
     /**
-     * Arbitrary Tx to be executed before or after route msgs
+     * If `appendCosmosMsgs` is provided, it will append the specified Cosmos messages to the transactions.
      */
-    beforeMsg?: CosmosMsg;
-    afterMsg?: CosmosMsg;
-    /**
-     * Set allowance amount to max if EVM transaction requires allowance approval.
-     */
-    useUnlimitedApproval?: boolean;
-    /**
-    /**
-     * If `skipApproval` is set to `true`, the router will bypass checking whether
-     * the signer has granted approval for the specified token contract on an EVM chain.
-     * This can be useful if approval has already been handled externally or there are race conditions.
-     */
-    bypassApprovalCheck?: boolean;
-    /**
-     * defaults to true
-     * If `batchSimulate` is set to `true`, it will simulate all messages in a batch before the first tx run.
-     * If `batchSimulate` is set to `false`, it will simulate each message one by one.
-     */
-    batchSimulate?: boolean;
-    /**
-     * Optional configuration for transaction polling behavior.
-     * - `maxRetries`: Maximum number of polling attempts (default: 5)
-     * - `retryInterval`: Retry interval in milliseconds (default: 1000)
-     * - `backoffMultiplier`: Exponential backoff multiplier for increasing delay between retries (default: 2.5)
-     * Example backoff with retryInterval = 1000 and backoffMultiplier = 2:
-     * 1st retry: 1000ms → 2nd: 2000ms → 3rd: 4000ms → 4th: 8000ms ...
-     */
-    trackTxPollingOptions?: TrackTxPollingProps;
-    /**
-     * If `batchSignTxs` is set to `true`, it will sign all transactions in a batch up front.
-     * If `batchSignTxs` is set to `false`, it will sign each transaction one by one.
-     */
-    batchSignTxs?: boolean;
+    appendCosmosMsgs?: Record<string, CosmosMsg[]>;
     /**
      * Specify actions to perform after the route is completed
      */
     postRouteHandler?: PostHandler;
-    /**
-     * If `cosmosPriorityFeeDenom` is provided, it will be used to set the priority fee for Cosmos transactions.
-     * It should be a function that takes a chainId and returns the denom for the priority fee.
-     */
-    getCosmosPriorityFeeDenom?: (chainId: string) => Promise<string | undefined>;
-    /**
-     * SVM Fee Payer
-     *
-     * This is used to pay for the transaction fees on SVM chains.
-     * It should be an object with the following properties:
-     * `address`: The address of the fee payer.
-     * `signTransaction`: A function that takes the data to sign and returns a Promise that resolves to the signed transaction.
-     */
-    svmFeePayer?: {
-        address: string;
-        signTransaction: (dataToSign: Buffer) => Promise<Uint8Array>;
-    };
 };
 declare const executeRoute: (options: ExecuteRouteOptions) => Promise<void>;
 
@@ -92,8 +40,10 @@ type TransactionDetails = {
     status?: TransactionStatus;
     statusResponse?: TxStatusResponse;
     explorerLink?: string;
+    routeKeyToStatus?: Record<string, TransactionStatus>;
+    routeKey?: string;
 };
-type SimpleRoute = Partial<Pick<Route, "amountIn" | "amountOut" | "sourceAssetDenom" | "sourceAssetChainId" | "destAssetDenom" | "destAssetChainId" | "estimatedRouteDurationSeconds">>;
+type SimpleRoute = Partial<Pick<Route, "usdAmountIn" | "usdAmountOut" | "amountIn" | "amountOut" | "sourceAssetDenom" | "sourceAssetChainId" | "destAssetDenom" | "destAssetChainId" | "estimatedRouteDurationSeconds">>;
 type RouteDetails = {
     id: string;
     timestamp: number;
@@ -104,14 +54,16 @@ type RouteDetails = {
     transactionDetails: TransactionDetails[];
     transferEvents: ClientTransferEvent[];
     transferAssetRelease?: TransferAssetRelease;
-    senderAddress: string;
-    receiverAddress: string;
+    transferIndexToRouteKey?: Record<number, string>;
+    mainRouteId?: string;
+    relatedRoutes?: Partial<RouteDetails>[];
+    routeKey?: string;
+    userAddresses: UserAddress[];
 };
 declare function getTransactionStatus(state?: TransactionState): TransactionStatus;
 type subscribeToRouteStatusProps = {
-    routeDetails?: RouteDetails;
+    routeDetails?: RouteDetails | RouteDetails[];
     onRouteStatusUpdated?: ExecuteRouteOptions["onRouteStatusUpdated"];
-    unsubscribe?: () => void;
 };
 type executeAndSubscribeToRouteStatusProps = {
     routeDetails?: RouteDetails;
@@ -119,22 +71,23 @@ type executeAndSubscribeToRouteStatusProps = {
     trackTxPollingOptions?: ExecuteRouteOptions["trackTxPollingOptions"];
     onRouteStatusUpdated?: ExecuteRouteOptions["onRouteStatusUpdated"];
     executeTransaction?: (index: number) => Promise<TxResult>;
-    onTransactionTracked?: ExecuteRouteOptions["onTransactionTracked"];
-    onTransactionCompleted?: ExecuteRouteOptions["onTransactionCompleted"];
     options?: ExecuteRouteOptions;
     routeId?: string;
     isCancelled?: () => boolean;
 };
 declare const subscribeToRouteStatus: (props: subscribeToRouteStatusProps) => () => void;
-declare const executeAndSubscribeToRouteStatus: ({ transactionDetails, executeTransaction, trackTxPollingOptions, onTransactionTracked, onTransactionCompleted, routeDetails, onRouteStatusUpdated, options, routeId, isCancelled, }: executeAndSubscribeToRouteStatusProps) => Promise<void>;
+declare const executeAndSubscribeToRouteStatus: ({ transactionDetails, executeTransaction, trackTxPollingOptions, routeDetails, onRouteStatusUpdated, options, routeId, isCancelled, }: executeAndSubscribeToRouteStatusProps) => Promise<void>;
 type updateRouteDetailsProps = {
     routeDetails?: RouteDetails;
     transactionDetails?: TransactionDetails[];
     options?: Partial<ExecuteRouteOptions>;
     status?: RouteStatus;
     routeId?: string;
+    mainRouteId?: string;
+    transferIndexToRouteKey?: Record<number, string>;
+    relatedRoutes?: Partial<RouteDetails>[];
 };
-declare const updateRouteDetails: ({ transactionDetails, routeDetails, options, status, routeId, }: updateRouteDetailsProps) => RouteDetails;
+declare const updateRouteDetails: ({ transactionDetails, routeDetails, options, status, routeId, mainRouteId, transferIndexToRouteKey, relatedRoutes, }: updateRouteDetailsProps) => RouteDetails;
 
 type CallbackStatus = "error" | "pending" | "completed";
 type TransactionCallbacks = {
@@ -172,4 +125,4 @@ type TransactionCallbacks = {
     }) => Promise<void>;
 };
 
-export { type ExecuteRouteOptions as E, type RouteDetails as R, type TransactionDetails as T, type RouteStatus as a, type TransferEventStatus as b, type TransactionCallbacks as c, type TransactionStatus as d, executeRoute as e, type subscribeToRouteStatusProps as f, getTransactionStatus as g, type executeAndSubscribeToRouteStatusProps as h, executeAndSubscribeToRouteStatus as i, subscribeToRouteStatus as s, updateRouteDetails as u };
+export { type ExecuteRouteOptions as E, type RouteDetails as R, type TransactionDetails as T, type RouteStatus as a, type TransactionStatus as b, type TransferEventStatus as c, type TransactionCallbacks as d, executeRoute as e, type subscribeToRouteStatusProps as f, getTransactionStatus as g, type executeAndSubscribeToRouteStatusProps as h, executeAndSubscribeToRouteStatus as i, subscribeToRouteStatus as s, updateRouteDetails as u };

package/dist/esm/{chunk-CIAOTO3M.js → chunk-2DD5F6PK.js}

@@ -1,5 +1,5 @@
 import { BigNumber } from './chunk-VQ5SIQWU.js';
-import { getFeeInfoForChain } from './chunk-4RLJWCQR.js';
+import { getFeeInfoForChain } from './chunk-3J5IMMMB.js';
 import { Decimal } from '@cosmjs/math';
 import { GasPrice } from '@cosmjs/stargate';
 

package/dist/esm/{chunk-4RLJWCQR.js → chunk-3J5IMMMB.js}

@@ -1,5 +1,5 @@
 import { DEFAULT_GAS_DENOM_OVERRIDES } from './chunk-SWYON2RG.js';
-import { chains } from './chunk-3J6O2PVK.js';
+import { chains } from './chunk-RHGDUD76.js';
 import { ClientState } from './chunk-ZOUYAZU6.js';
 
 // src/private-functions/getDefaultGasTokenForChain.ts

package/dist/esm/chunk-562J5DCB.js

@@ -0,0 +1,53 @@
+import { createValidAddressList, executeTransactions } from './chunk-W5EGS2G4.js';
+import { updateRouteDetails, executeAndSubscribeToRouteStatus } from './chunk-XYYXRVFN.js';
+import { messages } from './chunk-AND7HVIU.js';
+import { ApiState } from './chunk-A6KSECAH.js';
+
+// src/public-functions/executeRoute.ts
+var executeRoute = async (options) => {
+  const { route, userAddresses, appendCosmosMsgs, timeoutSeconds } = options;
+  const { id: routeId } = updateRouteDetails({
+    status: "unconfirmed",
+    options
+  });
+  const addressList = await createValidAddressList({
+    userAddresses,
+    route
+  });
+  const response = await messages({
+    timeoutSeconds,
+    amountIn: route?.amountIn,
+    amountOut: route.estimatedAmountOut || "0",
+    sourceAssetChainId: route?.sourceAssetChainId,
+    sourceAssetDenom: route?.sourceAssetDenom,
+    destAssetChainId: route?.destAssetChainId,
+    destAssetDenom: route?.destAssetDenom,
+    operations: route?.operations,
+    addressList,
+    slippageTolerancePercent: options.slippageTolerancePercent || "1",
+    chainIdsToAffiliates: ApiState.chainIdsToAffiliates,
+    postRouteHandler: options.postRouteHandler,
+    feePayerAddress: options.svmFeePayer?.address
+  });
+  if (appendCosmosMsgs) {
+    Object.entries(appendCosmosMsgs).forEach(([chainId, msgs]) => {
+      const txIndex = response?.txs?.findIndex(
+        (tx2) => "cosmosTx" in tx2 && tx2.cosmosTx.chainId === chainId
+      );
+      if (txIndex === void 0 || txIndex === -1) return;
+      const tx = response?.txs?.[txIndex];
+      if (tx && "cosmosTx" in tx) {
+        tx.cosmosTx.msgs?.unshift(...msgs);
+      }
+    });
+  }
+  const { transactionDetails, executeTransaction } = await executeTransactions({ ...options, routeId, txs: response?.txs });
+  await executeAndSubscribeToRouteStatus({
+    transactionDetails,
+    executeTransaction,
+    routeId,
+    options
+  });
+};
+
+export { executeRoute };

package/dist/esm/{chunk-KYDY7QRT.js → chunk-BZDVQMHK.js}

@@ -1,5 +1,5 @@
-import { chains, findFirstWorkingEndpoint } from './chunk-3J6O2PVK.js';
 import { BaseAccount as BaseAccount$1, isSet, bytesFromBase64, base64FromBytes } from './chunk-QO2CYYF5.js';
+import { chains, findFirstWorkingEndpoint } from './chunk-RHGDUD76.js';
 import { ClientState } from './chunk-ZOUYAZU6.js';
 import { accountFromAny, SigningStargateClient } from '@cosmjs/stargate';
 import { assertDefinedAndNotNull } from '@cosmjs/utils';

package/dist/esm/chunk-FVQFGEL2.js

@@ -0,0 +1,212 @@
+import { createValidAddressList, executeTransactions } from './chunk-W5EGS2G4.js';
+import { updateRouteDetails, executeAndSubscribeToRouteStatus } from './chunk-XYYXRVFN.js';
+import { messages } from './chunk-AND7HVIU.js';
+import { trackTransaction } from './chunk-7X4ERB3R.js';
+import { ApiState } from './chunk-A6KSECAH.js';
+import 'uuid';
+
+var executeMultipleRoutes = async (options) => {
+  const {
+    route,
+    userAddresses,
+    appendCosmosMsgs,
+    postRouteHandler,
+    slippageTolerancePercent,
+    ...restOptions
+  } = options;
+  const addressList = {};
+  for (const [routeKey, routeValue] of Object.entries(route)) {
+    const _userAddresses = userAddresses[routeKey];
+    if (_userAddresses === void 0) {
+      throw new Error(
+        `executeMultipleRoutes error: no user addresses found for route: ${routeKey}`
+      );
+    }
+    const routeAddressList = await createValidAddressList({
+      userAddresses: _userAddresses,
+      route: routeValue
+    });
+    addressList[routeKey] = routeAddressList;
+  }
+  const msgsResponses = await Promise.all(
+    Object.entries(route).map(async ([routeKey, routeValue]) => {
+      const routeAddressList = addressList[routeKey];
+      if (routeAddressList === void 0) {
+        throw new Error(
+          `executeMultipleRoutes error: address list not found for route ${routeKey}`
+        );
+      }
+      return await messages({
+        timeoutSeconds: options.timeoutSeconds,
+        amountIn: routeValue?.amountIn,
+        amountOut: routeValue.estimatedAmountOut || "0",
+        sourceAssetChainId: routeValue?.sourceAssetChainId,
+        sourceAssetDenom: routeValue?.sourceAssetDenom,
+        destAssetChainId: routeValue?.destAssetChainId,
+        destAssetDenom: routeValue?.destAssetDenom,
+        operations: routeValue?.operations,
+        addressList: routeAddressList,
+        slippageTolerancePercent: slippageTolerancePercent?.[routeKey] || "1",
+        chainIdsToAffiliates: ApiState.chainIdsToAffiliates,
+        postRouteHandler: postRouteHandler?.[routeKey],
+        feePayerAddress: options.svmFeePayer?.address
+      });
+    })
+  );
+  let msgsRecord = {};
+  msgsResponses.forEach((msg, index2) => {
+    const routeKey = Object.keys(route)[index2];
+    if (!routeKey) {
+      throw new Error(
+        `executeMultipleRoutes error: route key not found for index ${index2}`
+      );
+    }
+    const addedCosmosMsgs = appendCosmosMsgs?.[routeKey];
+    if (addedCosmosMsgs) {
+      Object.entries(addedCosmosMsgs).forEach(([chainId, msgs]) => {
+        const txIndex = msg?.txs?.findIndex(
+          (tx2) => "cosmosTx" in tx2 && tx2.cosmosTx.chainId === chainId
+        );
+        if (txIndex === void 0 || txIndex === -1) return;
+        const tx = msg?.txs?.[txIndex];
+        if (tx && "cosmosTx" in tx) {
+          tx.cosmosTx.msgs?.unshift(...msgs);
+        }
+      });
+    }
+    msgsRecord[routeKey] = msg;
+  });
+  let transferIndexToRouteKey = void 0;
+  const cosmosTxIndex0Map = /* @__PURE__ */ new Map();
+  let transferIndex = 0;
+  for (const [routeKey, msgs] of Object.entries(msgsRecord)) {
+    const firstTx = msgs?.txs?.[0];
+    if (firstTx && "cosmosTx" in firstTx) {
+      const { chainId, msgs: firstTxMsgs } = firstTx.cosmosTx;
+      if (!transferIndexToRouteKey) {
+        transferIndexToRouteKey = {};
+      }
+      transferIndexToRouteKey[transferIndex] = routeKey;
+      transferIndex++;
+      if (!cosmosTxIndex0Map.has(chainId)) {
+        cosmosTxIndex0Map.set(chainId, {
+          routeKey,
+          firstCosmosTx: firstTx.cosmosTx
+        });
+      } else {
+        const existing = cosmosTxIndex0Map.get(chainId);
+        if (existing && firstTxMsgs) {
+          const modifyTarget = msgsRecord[existing.routeKey]?.txs?.[0];
+          if (modifyTarget && "cosmosTx" in modifyTarget) {
+            modifyTarget.cosmosTx.msgs?.push(...firstTxMsgs);
+            msgsRecord[routeKey]?.txs?.shift();
+          }
+        }
+      }
+    }
+  }
+  Object.entries(msgsRecord).forEach(([routeKey, msgs]) => {
+    if (msgs?.txs?.length === 0) {
+      delete msgsRecord[routeKey];
+    }
+  });
+  let mainRouteId = void 0;
+  let msgsRecordIndexToRouteId = {};
+  let index = 0;
+  const transactionDetailsList = {};
+  const executeTransactionList = {};
+  const mergedMainAndSecondaryRoutes = Object.entries(msgsRecord).length !== Object.entries(route).length;
+  for (const [routeKey, msgsResponse] of Object.entries(msgsRecord)) {
+    const { id: routeId } = updateRouteDetails({
+      status: "unconfirmed",
+      options: {
+        route: route[routeKey],
+        ...restOptions
+      },
+      mainRouteId,
+      transferIndexToRouteKey
+    });
+    msgsRecordIndexToRouteId[index] = routeId;
+    if (routeKey === "mainRoute") {
+      mainRouteId = routeId;
+    }
+    const { transactionDetails, executeTransaction: _executeTransaction } = await executeTransactions({
+      ...restOptions,
+      routeId,
+      txs: msgsResponse?.txs,
+      route: route[routeKey],
+      userAddresses: userAddresses[routeKey],
+      isMultiRoutes: true
+    });
+    const executeTransaction = async (index2) => {
+      const txResult = await _executeTransaction(index2);
+      if (routeKey !== "mainRoute" || mergedMainAndSecondaryRoutes) {
+        const relatedRoutes = Object.entries(route).filter(([key]) => key !== "mainRoute").map(([key, route2]) => ({ route: route2, routeKey: key, status: "pending" }));
+        updateRouteDetails({
+          options: {
+            route: route[routeKey],
+            ...restOptions
+          },
+          routeId: mainRouteId,
+          transferIndexToRouteKey,
+          relatedRoutes
+        });
+      }
+      return txResult;
+    };
+    if (transactionDetails[0]?.chainType === "evm" /* Evm */) {
+      for (const [index2, transactionDetail] of transactionDetails.entries()) {
+        const txResult = await executeTransaction(index2);
+        if (txResult.txHash) {
+          const trackResponse = await trackTransaction({
+            chainId: transactionDetail.chainId,
+            txHash: txResult.txHash,
+            ...options.trackTxPollingOptions
+          });
+          await options?.onTransactionTracked?.({
+            txHash: txResult.txHash,
+            chainId: transactionDetail.chainId,
+            explorerLink: trackResponse.explorerLink
+          });
+          transactionDetail.txHash = txResult.txHash;
+          transactionDetail.explorerLink = trackResponse.explorerLink;
+        }
+      }
+    } else {
+      executeTransactionList[index] = executeTransaction;
+    }
+    transactionDetailsList[index] = transactionDetails;
+    index++;
+  }
+  await Promise.all(
+    Object.entries(msgsRecord).map(([routeKey, msgsResponse], index2) => {
+      return executeAndSubscribeToRouteStatus({
+        transactionDetails: transactionDetailsList[index2],
+        executeTransaction: executeTransactionList[index2],
+        routeId: msgsRecordIndexToRouteId[index2],
+        options: {
+          route: route[routeKey],
+          userAddresses: userAddresses[routeKey],
+          ...restOptions,
+          onRouteStatusUpdated: (routeStatus) => {
+            const relatedRoutes = Object.entries(route).filter(([key]) => key !== "mainRoute").map(([key, route2]) => ({ route: route2, routeKey: key, status: routeStatus.status }));
+            if (routeKey !== "mainRoute") {
+              updateRouteDetails({
+                options: {
+                  route: route[routeKey],
+                  ...restOptions
+                },
+                routeId: mainRouteId,
+                transferIndexToRouteKey,
+                relatedRoutes
+              });
+            }
+            options.onRouteStatusUpdated?.(routeStatus);
+          }
+        }
+      });
+    })
+  );
+};
+
+export { executeMultipleRoutes };