@skip-go/client 1.3.7 → 1.5.0

package/dist/cjs/chunk-UIQML2XG.cjs

@@ -0,0 +1,455 @@
+'use strict';
+
+var chunkLUVMRHAJ_cjs = require('./chunk-LUVMRHAJ.cjs');
+var chunkQPM7H2YL_cjs = require('./chunk-QPM7H2YL.cjs');
+var chunkERGJBZUC_cjs = require('./chunk-ERGJBZUC.cjs');
+var uuid = require('uuid');
+
+// src/utils/clientType.ts
+function getClientTransferEvent(transferEvent) {
+  const combinedTransferEvent = transferEvent;
+  const axelarTransfer = combinedTransferEvent?.axelarTransfer;
+  const ibcTransfer = combinedTransferEvent?.ibcTransfer;
+  const cctpTransfer = combinedTransferEvent?.cctpTransfer;
+  const hyperlaneTransfer = combinedTransferEvent?.hyperlaneTransfer;
+  const opInitTransfer = combinedTransferEvent?.opInitTransfer;
+  const goFastTransfer = combinedTransferEvent?.goFastTransfer;
+  const stargateTransfer = combinedTransferEvent?.stargateTransfer;
+  const eurekaTransfer = combinedTransferEvent?.eurekaTransfer;
+  const layerZeroTransfer = combinedTransferEvent?.layerZeroTransfer;
+  let transferType = "";
+  if (axelarTransfer) {
+    transferType = "axelarTransfer" /* axelarTransfer */;
+  } else if (ibcTransfer) {
+    transferType = "ibcTransfer" /* ibcTransfer */;
+  } else if (cctpTransfer) {
+    transferType = "cctpTransfer" /* cctpTransfer */;
+  } else if (hyperlaneTransfer) {
+    transferType = "hyperlaneTransfer" /* hyperlaneTransfer */;
+  } else if (opInitTransfer) {
+    transferType = "opInitTransfer" /* opInitTransfer */;
+  } else if (goFastTransfer) {
+    transferType = "goFastTransfer" /* goFastTransfer */;
+  } else if (stargateTransfer) {
+    transferType = "stargateTransfer" /* stargateTransfer */;
+  } else if (eurekaTransfer) {
+    transferType = "eurekaTransfer" /* eurekaTransfer */;
+  } else if (layerZeroTransfer) {
+    transferType = "layerZeroTransfer" /* layerZeroTransfer */;
+  }
+  const getExplorerLink = (type) => {
+    switch (transferType) {
+      case "ibcTransfer" /* ibcTransfer */:
+        if (type === "send") {
+          return ibcTransfer.packetTxs.sendTx?.explorerLink;
+        }
+        return ibcTransfer.packetTxs.receiveTx?.explorerLink;
+      case "eurekaTransfer" /* eurekaTransfer */:
+        if (type === "send") {
+          return eurekaTransfer.packetTxs.sendTx?.explorerLink;
+        }
+        return eurekaTransfer.packetTxs.receiveTx?.explorerLink;
+      case "goFastTransfer" /* goFastTransfer */:
+        if (type === "send") {
+          return goFastTransfer.txs.orderSubmittedTx?.explorerLink;
+        }
+        return goFastTransfer.txs.orderFilledTx?.explorerLink;
+      case "axelarTransfer" /* axelarTransfer */:
+        return axelarTransfer?.axelarScanLink;
+      default:
+        if (type === "send") {
+          return combinedTransferEvent[transferType]?.txs?.sendTx?.explorerLink;
+        }
+        return combinedTransferEvent[transferType]?.txs?.receiveTx?.explorerLink;
+    }
+  };
+  const _result = {
+    ...ibcTransfer,
+    ...axelarTransfer,
+    ...cctpTransfer,
+    ...hyperlaneTransfer,
+    ...stargateTransfer,
+    ...hyperlaneTransfer,
+    ...opInitTransfer,
+    ...goFastTransfer,
+    ...stargateTransfer,
+    ...eurekaTransfer,
+    ...layerZeroTransfer,
+    fromExplorerLink: getExplorerLink("send"),
+    toExplorerLink: getExplorerLink("receive")
+  };
+  const status = getSimpleStatus(_result.state);
+  const result = {
+    ..._result,
+    status
+  };
+  return result;
+}
+function getTransferEventsFromTxStatusResponse(txStatusResponse) {
+  if (!txStatusResponse) return [];
+  return txStatusResponse?.flatMap((txStatus) => {
+    return (txStatus.transferSequence ?? []).map((transferEvent) => {
+      return getClientTransferEvent(transferEvent);
+    });
+  });
+}
+function getSimpleStatus(state) {
+  switch (state) {
+    case "TRANSFER_PENDING":
+    case "TRANSFER_RECEIVED":
+    case "AXELAR_TRANSFER_PENDING_CONFIRMATION":
+    case "AXELAR_TRANSFER_PENDING_RECEIPT":
+    case "CCTP_TRANSFER_SENT":
+    case "CCTP_TRANSFER_PENDING_CONFIRMATION":
+    case "CCTP_TRANSFER_CONFIRMED":
+    case "HYPERLANE_TRANSFER_SENT":
+    case "OPINIT_TRANSFER_SENT":
+    case "GO_FAST_TRANSFER_SENT":
+    case "STARGATE_TRANSFER_SENT":
+    case "LAYER_ZERO_TRANSFER_SENT":
+      return "pending";
+    case "TRANSFER_SUCCESS":
+    case "AXELAR_TRANSFER_SUCCESS":
+    case "CCTP_TRANSFER_RECEIVED":
+    case "HYPERLANE_TRANSFER_RECEIVED":
+    case "OPINIT_TRANSFER_RECEIVED":
+    case "STARGATE_TRANSFER_RECEIVED":
+    case "GO_FAST_TRANSFER_FILLED":
+    case "LAYER_ZERO_TRANSFER_RECEIVED":
+      return "completed";
+    default:
+      return "failed";
+  }
+}
+function getTransactionStatus(state) {
+  switch (state) {
+    case "STATE_SUBMITTED":
+    case "STATE_PENDING":
+      return "pending";
+    case "STATE_COMPLETED_SUCCESS":
+      return "success";
+    case "STATE_COMPLETED_ERROR":
+    case "STATE_PENDING_ERROR":
+      return "failed";
+    default:
+      return "pending";
+  }
+}
+var isFinalRouteStatus = (routeDetails) => {
+  if (routeDetails.status === "completed" || routeDetails.status === "failed" || routeDetails.status === "incomplete") {
+    return true;
+  }
+  return false;
+};
+var isFinalState = (transaction) => {
+  const transactionState = transaction?.statusResponse?.transfers?.[0]?.state;
+  const transactionStatus2 = transaction?.status;
+  return transactionState === "STATE_COMPLETED_SUCCESS" || transactionState === "STATE_COMPLETED_ERROR" || transactionState === "STATE_ABANDONED" || transactionStatus2 === "failed" || transactionStatus2 === "success";
+};
+var isSuccessState = (transaction) => {
+  const transactionState = transaction?.statusResponse?.transfers?.[0]?.state;
+  const transactionStatus2 = transaction?.status;
+  return transactionState === "STATE_COMPLETED_SUCCESS" || transactionStatus2 === "success";
+};
+var routeDetailsMap = /* @__PURE__ */ new Map();
+var initializeNewRouteDetails = (options) => {
+  const newRouteId = uuid.v4();
+  const newRouteDetails = {
+    id: newRouteId,
+    timestamp: Date.now(),
+    route: getSimpleRoute(options?.route),
+    status: "unconfirmed",
+    txsRequired: options?.route?.txsRequired ?? 1,
+    txsSigned: 0,
+    transactionDetails: [],
+    transferEvents: [],
+    relatedRoutes: [],
+    userAddresses: options?.userAddresses ?? []
+  };
+  routeDetailsMap.set(newRouteId, newRouteDetails);
+  return newRouteDetails;
+};
+var subscribeToRouteStatus = (props) => {
+  const { routeDetails, onRouteStatusUpdated } = props;
+  const routeList = Array.isArray(routeDetails) ? routeDetails : [routeDetails];
+  const cancelFlags = /* @__PURE__ */ new Map();
+  const unsubscribers = [];
+  for (const route of routeList) {
+    const cancelFlag = { cancelled: false };
+    cancelFlags.set(route?.id ?? uuid.v4(), cancelFlag);
+    const unsubscribe = () => {
+      cancelFlag.cancelled = true;
+    };
+    unsubscribers.push(unsubscribe);
+    void executeAndSubscribeToRouteStatus({
+      routeDetails: route,
+      onRouteStatusUpdated,
+      isCancelled: () => cancelFlag.cancelled
+    });
+  }
+  const unsubscribeAll = () => {
+    for (const unsubscribe of unsubscribers) {
+      unsubscribe();
+    }
+  };
+  return unsubscribeAll;
+};
+var executeAndSubscribeToRouteStatus = async ({
+  transactionDetails,
+  executeTransaction,
+  trackTxPollingOptions,
+  onTransactionTracked,
+  onTransactionCompleted,
+  routeDetails,
+  onRouteStatusUpdated,
+  options,
+  routeId,
+  isCancelled
+}) => {
+  removeRoutesWithFinalStatus();
+  routeId ??= routeDetails?.id;
+  const currentRouteDetails = routeDetailsMap.get(routeId ?? "");
+  transactionDetails ??= routeDetails?.transactionDetails ?? currentRouteDetails?.transactionDetails ?? [];
+  if (routeDetails && isFinalRouteStatus(routeDetails) && routeDetails?.relatedRoutes?.every(
+    (relatedRoute) => isFinalRouteStatus(relatedRoute)
+  )) {
+    return;
+  }
+  for (const [transactionIndex, transaction] of transactionDetails.entries()) {
+    if (executeTransaction && !transaction.txHash) {
+      let { txHash, explorerLink } = await executeTransaction?.(transactionIndex);
+      transaction.txHash = txHash;
+      if (!explorerLink) {
+        const trackResponse = await chunkLUVMRHAJ_cjs.trackTransaction({
+          chainId: transaction.chainId,
+          txHash: transaction.txHash,
+          ...trackTxPollingOptions
+        });
+        explorerLink = trackResponse.explorerLink;
+      }
+      transaction.explorerLink = explorerLink;
+      await onTransactionTracked?.({
+        txHash: transaction.txHash,
+        chainId: transaction.chainId,
+        explorerLink
+      });
+    }
+    if (transaction.txHash === void 0) {
+      updateRouteDetails({
+        routeId,
+        routeDetails,
+        transactionDetails,
+        options: {
+          onRouteStatusUpdated,
+          ...options
+        }
+      });
+      return;
+    }
+    while (true) {
+      const updatedRouteDetails = routeDetailsMap.get(routeId ?? "");
+      const allRelatedRoutesFinal = updatedRouteDetails?.relatedRoutes?.every(
+        (relatedRoute) => relatedRoute && isFinalRouteStatus(relatedRoute)
+      );
+      if (isFinalState(transaction) && allRelatedRoutesFinal) {
+        break;
+      }
+      if (isCancelled?.()) {
+        console.info(`Polling cancelled for route ${routeId}`);
+        break;
+      }
+      try {
+        const statusResponse = await chunkQPM7H2YL_cjs.transactionStatus({
+          chainId: transaction.chainId,
+          txHash: transaction.txHash
+        });
+        transaction.statusResponse = statusResponse;
+        updateRouteDetails({
+          routeId,
+          routeDetails,
+          transactionDetails,
+          options: {
+            onRouteStatusUpdated,
+            ...options
+          },
+          relatedRoutes: routeDetails?.relatedRoutes
+        });
+        if (isFinalState(transaction)) {
+          onTransactionCompleted?.({
+            chainId: transaction.chainId,
+            txHash: transaction.txHash,
+            status: statusResponse
+          });
+          if (routeDetails?.relatedRoutes?.every(
+            (relatedRoute) => isFinalRouteStatus(relatedRoute)
+          )) {
+            break;
+          }
+        }
+      } catch (error) {
+        console.error(error);
+      } finally {
+        await chunkERGJBZUC_cjs.wait(1e3);
+      }
+    }
+  }
+};
+var updateRouteDetails = ({
+  transactionDetails,
+  routeDetails,
+  options,
+  status,
+  routeId,
+  mainRouteId,
+  transferIndexToRouteKey,
+  relatedRoutes
+}) => {
+  routeId ??= routeDetails?.id ?? "";
+  let currentRouteDetails = routeDetails ?? routeDetailsMap.get(routeId);
+  if (!routeId && currentRouteDetails == void 0) {
+    currentRouteDetails = initializeNewRouteDetails(options);
+    routeId = currentRouteDetails?.id;
+  }
+  transferIndexToRouteKey ??= currentRouteDetails?.transferIndexToRouteKey;
+  if (currentRouteDetails === void 0) {
+    throw new Error("No route details found");
+  }
+  transactionDetails ??= currentRouteDetails?.transactionDetails ?? [];
+  const txsRequired = currentRouteDetails?.txsRequired ?? options?.route?.txsRequired ?? 1;
+  if (currentRouteDetails?.status === "signing" && status === "pending") {
+    currentRouteDetails.txsSigned += 1;
+  }
+  const transferEvents = routeDetails?.transferEvents ?? getTransferEventsFromTxStatusResponse(
+    transactionDetails.map((tx) => tx.statusResponse).filter((status2) => status2 !== void 0)
+  );
+  const allExpectedTxsStarted = transactionDetails.every(
+    (tx) => tx.txHash || tx.status === void 0
+  );
+  const allKnownDetailsHaveFinalStatus = transactionDetails.every(
+    (transaction) => isFinalState(transaction)
+  );
+  const isAllSettled = allExpectedTxsStarted && allKnownDetailsHaveFinalStatus;
+  const someTxSucceeded = transactionDetails.some((tx) => isSuccessState(tx));
+  const someTxFailed = transactionDetails.some((tx) => !isSuccessState(tx));
+  const getRouteStatus = () => {
+    if (status) return status;
+    if (someTxSucceeded && !allExpectedTxsStarted) return "incomplete";
+    if (isAllSettled) {
+      if (!someTxFailed) {
+        return "completed";
+      } else if (someTxSucceeded && someTxFailed) {
+        return "incomplete";
+      } else if (someTxFailed) {
+        return "failed";
+      }
+    }
+    return currentRouteDetails?.status;
+  };
+  const transferAssetRelease = transactionDetails?.findLast(
+    (i) => i.statusResponse?.transferAssetRelease
+  )?.statusResponse?.transferAssetRelease;
+  const updatedRelatedRoutes = updateRelatedRoutes({
+    relatedRoutes: relatedRoutes ?? currentRouteDetails?.relatedRoutes ?? [],
+    transferIndexToRouteKey,
+    transactionDetails
+  });
+  const newRouteDetails = {
+    id: routeId,
+    timestamp: currentRouteDetails.timestamp,
+    status: getRouteStatus(),
+    route: getSimpleRoute(currentRouteDetails?.route ?? options?.route),
+    txsRequired,
+    transactionDetails,
+    transferEvents,
+    transferAssetRelease,
+    userAddresses: (currentRouteDetails?.userAddresses.length > 0 ? currentRouteDetails?.userAddresses : options?.userAddresses) ?? [],
+    txsSigned: currentRouteDetails?.txsSigned,
+    transferIndexToRouteKey,
+    mainRouteId: mainRouteId ?? currentRouteDetails?.mainRouteId,
+    relatedRoutes: updatedRelatedRoutes
+  };
+  const newRouteStatus = getRouteDetailsWithSimpleTransactionDetailsStatus(newRouteDetails);
+  const previousRouteStatus = getRouteDetailsWithSimpleTransactionDetailsStatus(currentRouteDetails);
+  if (options?.onRouteStatusUpdated && JSON.stringify(newRouteStatus) !== JSON.stringify(previousRouteStatus)) {
+    options?.onRouteStatusUpdated?.(newRouteStatus);
+  }
+  if (routeId) {
+    routeDetailsMap.set(routeId, newRouteDetails);
+  }
+  return newRouteDetails;
+};
+var getSimpleRoute = (route) => {
+  return {
+    usdAmountOut: route?.usdAmountOut,
+    usdAmountIn: route?.usdAmountIn,
+    amountIn: route?.amountIn,
+    amountOut: route?.amountOut,
+    sourceAssetDenom: route?.sourceAssetDenom,
+    sourceAssetChainId: route?.sourceAssetChainId,
+    destAssetDenom: route?.destAssetDenom,
+    destAssetChainId: route?.destAssetChainId,
+    estimatedRouteDurationSeconds: route?.estimatedRouteDurationSeconds
+  };
+};
+var getRouteDetailsWithSimpleTransactionDetailsStatus = (routeDetails) => {
+  return {
+    ...routeDetails,
+    transactionDetails: routeDetails.transactionDetails.map((txDetails) => {
+      const { statusResponse, ...rest } = txDetails;
+      const newTxDetails = {
+        ...rest,
+        status: txDetails?.status ?? getTransactionStatus(statusResponse?.transfers?.[0]?.state)
+      };
+      return newTxDetails;
+    })
+  };
+};
+var removeRoutesWithFinalStatus = () => {
+  routeDetailsMap.forEach((routeDetails, routeId) => {
+    if (routeDetails.status === "completed" || routeDetails.status === "failed" || routeDetails.status === "incomplete") {
+      routeDetailsMap.delete(routeId);
+    }
+  });
+};
+var convertTransactionStatusToRouteStatus = (transactionStatus2) => {
+  if (!transactionStatus2) return;
+  if (transactionStatus2 === "success") {
+    return "completed";
+  }
+  return transactionStatus2;
+};
+var updateRelatedRoutes = ({
+  relatedRoutes,
+  transferIndexToRouteKey,
+  transactionDetails
+}) => {
+  let updatedRelatedRoutes = [
+    ...relatedRoutes.map((relatedRoute) => ({ ...relatedRoute }))
+  ];
+  if (!transferIndexToRouteKey) return updatedRelatedRoutes;
+  transactionDetails?.forEach((transaction) => {
+    Object.entries(transferIndexToRouteKey).forEach(([indexStr, routeKey]) => {
+      const index = Number(indexStr);
+      const state = transaction?.statusResponse?.transfers?.[index]?.state;
+      const status = convertTransactionStatusToRouteStatus(
+        getTransactionStatus(state)
+      );
+      const transferAssetRelease = transaction?.statusResponse?.transfers?.[index]?.transferAssetRelease;
+      const targetRoute = updatedRelatedRoutes.find(
+        (r) => r.routeKey === routeKey
+      );
+      if (targetRoute && state) {
+        targetRoute.status = status ?? "failed";
+      }
+      if (targetRoute && transferAssetRelease) {
+        targetRoute.transferAssetRelease = transferAssetRelease;
+      }
+    });
+  });
+  return updatedRelatedRoutes;
+};
+
+exports.executeAndSubscribeToRouteStatus = executeAndSubscribeToRouteStatus;
+exports.getTransactionStatus = getTransactionStatus;
+exports.subscribeToRouteStatus = subscribeToRouteStatus;
+exports.updateRouteDetails = updateRouteDetails;

package/dist/cjs/chunk-VF65UG3E.cjs

@@ -0,0 +1,214 @@
+'use strict';
+
+var chunkHHZGD62Y_cjs = require('./chunk-HHZGD62Y.cjs');
+var chunkUIQML2XG_cjs = require('./chunk-UIQML2XG.cjs');
+var chunkOZUCMWNE_cjs = require('./chunk-OZUCMWNE.cjs');
+var chunkLUVMRHAJ_cjs = require('./chunk-LUVMRHAJ.cjs');
+var chunkERGJBZUC_cjs = require('./chunk-ERGJBZUC.cjs');
+require('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 chunkHHZGD62Y_cjs.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 chunkOZUCMWNE_cjs.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: chunkERGJBZUC_cjs.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 } = chunkUIQML2XG_cjs.updateRouteDetails({
+      status: "unconfirmed",
+      options: {
+        route: route[routeKey],
+        ...restOptions
+      },
+      mainRouteId,
+      transferIndexToRouteKey
+    });
+    msgsRecordIndexToRouteId[index] = routeId;
+    if (routeKey === "mainRoute") {
+      mainRouteId = routeId;
+    }
+    const { transactionDetails, executeTransaction: _executeTransaction } = await chunkHHZGD62Y_cjs.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" }));
+        chunkUIQML2XG_cjs.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 chunkLUVMRHAJ_cjs.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 chunkUIQML2XG_cjs.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") {
+              chunkUIQML2XG_cjs.updateRouteDetails({
+                options: {
+                  route: route[routeKey],
+                  ...restOptions
+                },
+                routeId: mainRouteId,
+                transferIndexToRouteKey,
+                relatedRoutes
+              });
+            }
+            options.onRouteStatusUpdated?.(routeStatus);
+          }
+        }
+      });
+    })
+  );
+};
+
+exports.executeMultipleRoutes = executeMultipleRoutes;