@skip-go/client 1.4.0 → 1.5.0

package/dist/esm/{chunk-GHNH5QC3.js → chunk-JKN4E5VN.js}

@@ -1,6 +1,6 @@
 import { getCosmosGasAmountForMessage } from './chunk-KNXMSLOB.js';
 import { BigNumber } from './chunk-VQ5SIQWU.js';
-import { getSigningStargateClient } from './chunk-KYDY7QRT.js';
+import { getSigningStargateClient } from './chunk-MPSXXWKL.js';
 import { ClientState, balances } from './chunk-ZOUYAZU6.js';
 import { GasPrice, calculateFee } from '@cosmjs/stargate';
 import { Decimal } from '@cosmjs/math';
@@ -13,7 +13,8 @@ var validateCosmosGasBalance = async ({
   getOfflineSigner,
   txIndex,
   simulate,
-  getCosmosPriorityFeeDenom
+  getCosmosPriorityFeeDenom,
+  isMultiRoutes
 }) => {
   const skipAssets = (await ClientState.getSkipAssets({ chainId }))?.[chainId];
   const skipChains = await ClientState.getSkipChains();
@@ -81,6 +82,12 @@ var validateCosmosGasBalance = async ({
       return null;
     }
     if (chainId === "noble-1") {
+      if (isMultiRoutes && txIndex === 0) {
+        return calculateFee(
+          Math.ceil(parseFloat(estimatedGasAmount)),
+          gasPrice
+        );
+      }
       if (asset.denom.toLowerCase() === "ibc/EF48E6B1A1A19F47ECAEA62F5670C37C0580E86A9E88498B7E393EB6F49F33C0".toLowerCase()) {
         const fee2 = calculateFee(2e6, gasPrice);
         return fee2;

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

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

package/dist/esm/{chunk-KYDY7QRT.js → chunk-MPSXXWKL.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-IUYOY23L.js';
 import { ClientState } from './chunk-ZOUYAZU6.js';
 import { accountFromAny, SigningStargateClient } from '@cosmjs/stargate';
 import { assertDefinedAndNotNull } from '@cosmjs/utils';

package/dist/esm/{chunk-BAJFQZDT.js → chunk-MTAS5XMN.js}

@@ -1,18 +1,15 @@
-import { updateRouteDetails, executeAndSubscribeToRouteStatus } from './chunk-RQ7DXNSS.js';
-import { validateCosmosGasBalance } from './chunk-GHNH5QC3.js';
+import { updateRouteDetails } from './chunk-VUXLWWLF.js';
+import { validateCosmosGasBalance } from './chunk-JKN4E5VN.js';
 import { getEncodeObjectFromCosmosMessage } from './chunk-KNXMSLOB.js';
 import { getEVMGasAmountForMessage } from './chunk-GV2QOWB4.js';
 import { BigNumber } from './chunk-VQ5SIQWU.js';
 import { GAS_STATION_CHAIN_IDS } from './chunk-SWYON2RG.js';
-import { getRpcEndpointForChain, accountParser, getSigningStargateClient } from './chunk-KYDY7QRT.js';
-import { chains, findFirstWorkingEndpoint, getIsEthermint, getIsInitia } from './chunk-3J6O2PVK.js';
-import { messages } from './chunk-AND7HVIU.js';
+import { getRpcEndpointForChain, accountParser, getSigningStargateClient } from './chunk-MPSXXWKL.js';
+import { chains, findFirstWorkingEndpoint, getIsEthermint, getIsInitia } from './chunk-IUYOY23L.js';
 import { submitTransaction } from './chunk-JQ4F4WBG.js';
 import { venues } from './chunk-52PEBJRQ.js';
 import { ClientState, balances } from './chunk-ZOUYAZU6.js';
-import { ApiState, toCamel, wait } from './chunk-A6KSECAH.js';
-import { PublicKey, Transaction, Connection, LAMPORTS_PER_SOL } from '@solana/web3.js';
-import { bech32m, bech32 } from 'bech32';
+import { toCamel, wait } from './chunk-A6KSECAH.js';
 import { StargateClient } from '@cosmjs/stargate';
 import { TxRaw } from 'cosmjs-types/cosmos/tx/v1beta1/tx.js';
 import { isOfflineDirectSigner, makeAuthInfoBytes, makeSignDoc, encodePubkey } from '@cosmjs/proto-signing';
@@ -23,6 +20,8 @@ import { Any } from 'cosmjs-types/google/protobuf/any.js';
 import { Int53 } from '@cosmjs/math';
 import { SignMode } from 'cosmjs-types/cosmos/tx/signing/v1beta1/signing.js';
 import { isAddress, publicActions, maxUint256, formatUnits } from 'viem';
+import { Transaction, PublicKey, Connection, LAMPORTS_PER_SOL } from '@solana/web3.js';
+import { bech32m, bech32 } from 'bech32';
 
 // src/private-functions/getRestEndpointForChain.ts
 var getRestEndpointForChain = async (chainId) => {
@@ -172,11 +171,11 @@ var signCosmosMessageDirect = async (options) => {
   if (!accountFromSigner) {
     throw new Error("signCosmosMessageDirect error: failed to retrieve account from signer");
   }
-  const messages2 = cosmosMsgs.map((cosmosMsg) => getEncodeObjectFromCosmosMessage(cosmosMsg));
+  const messages = cosmosMsgs.map((cosmosMsg) => getEncodeObjectFromCosmosMessage(cosmosMsg));
   const txBodyEncodeObject = {
     typeUrl: "/cosmos.tx.v1beta1.TxBody",
     value: {
-      messages: messages2
+      messages
     }
   };
   const txBodyBytes = ClientState.registry.encode(txBodyEncodeObject);
@@ -207,26 +206,40 @@ var signCosmosMessageAmino = async (options) => {
     signerData: { accountNumber, sequence, chainId: signerChainId }
   } = options;
   const accounts = await signer.getAccounts();
-  const accountFromSigner = accounts.find((account) => account.address === signerAddress);
+  const accountFromSigner = accounts.find(
+    (account) => account.address === signerAddress
+  );
   if (!accountFromSigner) {
-    throw new Error("signCosmosMessageAmino: failed to retrieve account from signer");
+    throw new Error(
+      "signCosmosMessageAmino: failed to retrieve account from signer"
+    );
   }
-  const messages2 = cosmosMsgs.map((cosmosMsg) => getEncodeObjectFromCosmosMessage(cosmosMsg));
+  const messages = cosmosMsgs.map(
+    (cosmosMsg) => getEncodeObjectFromCosmosMessage(cosmosMsg)
+  );
   const signMode = SignMode.SIGN_MODE_LEGACY_AMINO_JSON;
-  const msgs = messages2.map((msg) => ClientState.aminoTypes.toAmino(msg));
-  console.log("sign cosmos message amino", msgs, fee, signerChainId, "", accountNumber, sequence);
-  const signDoc = makeSignDoc$1(msgs, fee, signerChainId, "", accountNumber, sequence);
+  const msgs = messages.map((msg) => ClientState.aminoTypes.toAmino(msg));
+  const signDoc = makeSignDoc$1(
+    msgs,
+    fee,
+    signerChainId,
+    "",
+    accountNumber,
+    sequence
+  );
   const { signature, signed } = await signer.signAmino(signerAddress, signDoc);
   const signedTxBody = {
     messages: signed.msgs.map((msg) => ClientState.aminoTypes.fromAmino(msg)),
     memo: signed.memo
   };
-  signedTxBody.messages[0].value.memo = messages2[0].value.memo;
+  signedTxBody.messages[0].value.memo = messages[0].value.memo;
   const signedTxBodyEncodeObject = {
     typeUrl: "/cosmos.tx.v1beta1.TxBody",
     value: signedTxBody
   };
-  const signedTxBodyBytes = ClientState.registry.encode(signedTxBodyEncodeObject);
+  const signedTxBodyBytes = ClientState.registry.encode(
+    signedTxBodyEncodeObject
+  );
   const signedGasLimit = Int53.fromString(signed.fee.gas).toNumber();
   const signedSequence = Int53.fromString(signed.sequence).toNumber();
   const pubkeyAny = makePubkeyAnyFromAccount(accountFromSigner, chainId);
@@ -257,7 +270,7 @@ var signCosmosTransaction = async ({
     throw new Error("executeCosmosTransaction error: tx is undefined");
   }
   const chainId = tx.cosmosTx?.chainId;
-  const messages2 = tx.cosmosTx?.msgs;
+  const messages = tx.cosmosTx?.msgs;
   const currentUserAddress = userAddresses.find((x) => x.chainId === tx.cosmosTx?.chainId)?.address;
   const gasArray = ClientState.validateGasResults;
   const gas = gasArray?.find((gas2) => gas2?.error !== null && gas2?.error !== void 0);
@@ -271,7 +284,7 @@ var signCosmosTransaction = async ({
   if (chainId === void 0) {
     throw new Error("no chainId found for tx");
   }
-  if (messages2 === void 0) {
+  if (messages === void 0) {
     throw new Error("no messages found for tx");
   }
   const { signer } = await getSigningStargateClient({
@@ -300,7 +313,7 @@ var signCosmosTransaction = async ({
   const commonRawTxBody = {
     signerAddress: currentUserAddress,
     chainId,
-    cosmosMsgs: messages2,
+    cosmosMsgs: messages,
     fee,
     signerData: {
       accountNumber,
@@ -876,7 +889,8 @@ var validateEvmGasBalance = async ({
   signer,
   tx,
   getFallbackGasAmount,
-  useUnlimitedApproval
+  useUnlimitedApproval,
+  bypassApprovalCheck
 }) => {
   const chainId = tx?.chainId ?? "";
   const skipAssets = (await ClientState.getSkipAssets({ chainId }))?.[chainId];
@@ -901,7 +915,7 @@ var validateEvmGasBalance = async ({
   )?.[1];
   const gasBalance = nativeGasBalance || zeroAddressGasBalance;
   const { requiredErc20Approvals } = tx;
-  if (requiredErc20Approvals) {
+  if (!bypassApprovalCheck && requiredErc20Approvals) {
     try {
       await validateEvmTokenApproval({
         requiredErc20Approvals,
@@ -1038,10 +1052,10 @@ var validateGasBalances = async ({
   simulate,
   disabledChainIds,
   enabledChainIds,
-  useUnlimitedApproval,
   getCosmosPriorityFeeDenom,
   routeId,
-  options
+  options,
+  isMultiRoutes
 }) => {
   const validateResult = await Promise.all(
     txs.map(async (tx, i) => {
@@ -1069,7 +1083,8 @@ var validateGasBalances = async ({
             getOfflineSigner: getCosmosSigner,
             txIndex: i,
             simulate,
-            getCosmosPriorityFeeDenom
+            getCosmosPriorityFeeDenom,
+            isMultiRoutes
           });
           return res;
         } catch (e) {
@@ -1101,7 +1116,8 @@ var validateGasBalances = async ({
             tx: tx.evmTx,
             signer,
             getFallbackGasAmount,
-            useUnlimitedApproval
+            useUnlimitedApproval: options?.useUnlimitedApproval,
+            bypassApprovalCheck: options?.bypassApprovalCheck
           });
           return res;
         } catch (e) {
@@ -1193,7 +1209,8 @@ var executeTransactions = async (options) => {
     onValidateGasBalance,
     trackTxPollingOptions,
     batchSignTxs = true,
-    routeId
+    routeId,
+    isMultiRoutes
   } = options;
   if (txs === void 0) {
     throw new Error(
@@ -1203,11 +1220,11 @@ var executeTransactions = async (options) => {
   const chainIds = getChainIdsFromTxs(txs);
   const transactionDetails = txs.map((tx) => {
     if ("cosmosTx" in tx) {
-      return { chainId: tx.cosmosTx?.chainId };
+      return { chainId: tx.cosmosTx?.chainId, chainType: "cosmos" /* Cosmos */ };
     } else if ("evmTx" in tx) {
-      return { chainId: tx.evmTx?.chainId };
+      return { chainId: tx.evmTx?.chainId, chainType: "evm" /* Evm */ };
     } else if ("svmTx" in tx) {
-      return { chainId: tx.svmTx?.chainId };
+      return { chainId: tx.svmTx?.chainId, chainType: "svm" /* Svm */ };
     } else {
       throw new Error("executeRoute error: invalid message type");
     }
@@ -1232,7 +1249,8 @@ var executeTransactions = async (options) => {
     disabledChainIds: validateChainIds,
     getCosmosPriorityFeeDenom: options.getCosmosPriorityFeeDenom,
     options,
-    routeId
+    routeId,
+    isMultiRoutes
   });
   const validateEnabledChainIds = async (chainId) => {
     await validateGasBalances({
@@ -1245,7 +1263,8 @@ var executeTransactions = async (options) => {
       enabledChainIds: !batchSimulate ? [chainId] : validateChainIds,
       getCosmosPriorityFeeDenom: options.getCosmosPriorityFeeDenom,
       options,
-      routeId
+      routeId,
+      isMultiRoutes
     });
   };
   let signedTxs = [];
@@ -1259,11 +1278,16 @@ var executeTransactions = async (options) => {
         await validateEnabledChainIds(tx.cosmosTx?.chainId ?? "");
         const isAllowedToBatchSignTxsUpfront = await (async () => {
           try {
-            const currentUserAddress = options.userAddresses.find((x) => x.chainId === tx.cosmosTx?.chainId)?.address;
+            const currentUserAddress = options.userAddresses.find(
+              (x) => x.chainId === tx.cosmosTx?.chainId
+            )?.address;
             if (!currentUserAddress) {
               return false;
             }
-            const { accountNumber } = await getAccountNumberAndSequence(currentUserAddress, tx.cosmosTx?.chainId);
+            const { accountNumber } = await getAccountNumberAndSequence(
+              currentUserAddress,
+              tx.cosmosTx?.chainId
+            );
             if (accountNumber) {
               return true;
             }
@@ -1290,7 +1314,12 @@ var executeTransactions = async (options) => {
       }
       if ("svmTx" in tx) {
         await validateEnabledChainIds(tx.svmTx?.chainId ?? "");
-        const signedTx = await signSvmTransaction({ tx, options, index: i, routeId });
+        const signedTx = await signSvmTransaction({
+          tx,
+          options,
+          index: i,
+          routeId
+        });
         if (!signedTx) {
           throw new Error(`executeRoute error: signedTx is undefined`);
         }
@@ -1331,7 +1360,12 @@ var executeTransactions = async (options) => {
         });
       } else if ("evmTx" in tx) {
         await validateEnabledChainIds(tx.evmTx?.chainId ?? "");
-        const txResponse = await executeEvmTransaction(tx, options, index, routeId);
+        const txResponse = await executeEvmTransaction(
+          tx,
+          options,
+          index,
+          routeId
+        );
         txResult = {
           chainId: tx?.evmTx?.chainId ?? "",
           txHash: txResponse.transactionHash
@@ -1346,12 +1380,10 @@ var executeTransactions = async (options) => {
     await onTransactionBroadcast?.({ ...txResult });
     return txResult;
   };
-  await executeAndSubscribeToRouteStatus({
+  return {
     transactionDetails,
-    executeTransaction,
-    routeId,
-    options
-  });
+    executeTransaction
+  };
 };
 var EVM_GAS_AMOUNT = 15e4;
 var COSMOS_GAS_AMOUNT = {
@@ -1376,59 +1408,6 @@ var getDefaultFallbackGasAmount = async (chainId, chainType) => {
   }
   return defaultGasAmount;
 };
-var executeRoute = async (options) => {
-  const { route, userAddresses, beforeMsg, afterMsg, timeoutSeconds } = options;
-  const { id: routeId } = updateRouteDetails({
-    status: "unconfirmed",
-    options
-  });
-  let addressList = [];
-  userAddresses.forEach((userAddress, index) => {
-    const requiredChainAddress = route.requiredChainAddresses[index];
-    if (requiredChainAddress === userAddress?.chainId) {
-      addressList.push(userAddress.address);
-    }
-  });
-  if (addressList.length !== route.requiredChainAddresses.length) {
-    addressList = userAddresses.map((x) => x.address);
-  }
-  const validLength = addressList.length === route.requiredChainAddresses.length || addressList.length === route.chainIds?.length;
-  if (!validLength) {
-    throw new Error("executeRoute error: invalid address list");
-  }
-  const isUserAddressesValid = await validateUserAddresses(userAddresses);
-  if (!isUserAddressesValid) {
-    throw new Error("executeRoute error: invalid user addresses");
-  }
-  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 (beforeMsg && (response?.txs?.length ?? 0) > 0) {
-    const firstTx = response?.txs?.[0];
-    if (firstTx && "cosmosTx" in firstTx) {
-      firstTx.cosmosTx?.msgs?.unshift(beforeMsg);
-    }
-  }
-  if (afterMsg && (response?.txs?.length ?? 0) > 0) {
-    const lastTx = response?.txs?.[response.txs.length - 1];
-    if (lastTx && "cosmosTx" in lastTx) {
-      lastTx.cosmosTx?.msgs?.push(afterMsg);
-    }
-  }
-  await executeTransactions({ ...options, routeId, txs: response?.txs });
-};
 var validateUserAddresses = async (userAddresses) => {
   const chains2 = await ClientState.getSkipChains();
   const validations = userAddresses.map((userAddress) => {
@@ -1468,5 +1447,29 @@ var validateUserAddresses = async (userAddresses) => {
   });
   return validations.every((validation) => validation);
 };
+var createValidAddressList = async ({
+  userAddresses,
+  route
+}) => {
+  let addressList = [];
+  userAddresses.forEach((userAddress, index) => {
+    const requiredChainAddress = route.requiredChainAddresses[index];
+    if (requiredChainAddress === userAddress?.chainId) {
+      addressList.push(userAddress.address);
+    }
+  });
+  if (addressList.length !== route.requiredChainAddresses.length) {
+    addressList = userAddresses.map((x) => x.address);
+  }
+  const validLength = addressList.length === route.requiredChainAddresses.length || addressList.length === route.chainIds?.length;
+  if (!validLength) {
+    throw new Error("createValidAddressList error: invalid address list");
+  }
+  const isUserAddressesValid = await validateUserAddresses(userAddresses);
+  if (!isUserAddressesValid) {
+    throw new Error("createValidAddressList error: invalid user addresses");
+  }
+  return addressList;
+};
 
-export { executeRoute };
+export { createValidAddressList, executeTransactions };

package/dist/esm/{chunk-RQ7DXNSS.js → chunk-VUXLWWLF.js}

@@ -140,12 +140,12 @@ var isFinalRouteStatus = (routeDetails) => {
   return false;
 };
 var isFinalState = (transaction) => {
-  const transactionState = transaction?.statusResponse?.state;
+  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?.state;
+  const transactionState = transaction?.statusResponse?.transfers?.[0]?.state;
   const transactionStatus2 = transaction?.status;
   return transactionState === "STATE_COMPLETED_SUCCESS" || transactionStatus2 === "success";
 };
@@ -161,22 +161,36 @@ var initializeNewRouteDetails = (options) => {
     txsSigned: 0,
     transactionDetails: [],
     transferEvents: [],
-    senderAddress: options?.userAddresses?.[0]?.address ?? "",
-    receiverAddress: options?.userAddresses?.at(-1)?.address ?? ""
+    relatedRoutes: [],
+    userAddresses: options?.userAddresses ?? []
   };
   routeDetailsMap.set(newRouteId, newRouteDetails);
   return newRouteDetails;
 };
 var subscribeToRouteStatus = (props) => {
-  let cancelled = false;
-  const unsubscribe = () => {
-    cancelled = true;
+  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 ?? 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();
+    }
   };
-  executeAndSubscribeToRouteStatus({
-    ...props,
-    isCancelled: () => cancelled
-  });
-  return unsubscribe;
+  return unsubscribeAll;
 };
 var executeAndSubscribeToRouteStatus = async ({
   transactionDetails,
@@ -194,7 +208,9 @@ var executeAndSubscribeToRouteStatus = async ({
   routeId ??= routeDetails?.id;
   const currentRouteDetails = routeDetailsMap.get(routeId ?? "");
   transactionDetails ??= routeDetails?.transactionDetails ?? currentRouteDetails?.transactionDetails ?? [];
-  if (routeDetails && isFinalRouteStatus(routeDetails)) {
+  if (routeDetails && isFinalRouteStatus(routeDetails) && routeDetails?.relatedRoutes?.every(
+    (relatedRoute) => isFinalRouteStatus(relatedRoute)
+  )) {
     return;
   }
   for (const [transactionIndex, transaction] of transactionDetails.entries()) {
@@ -210,7 +226,11 @@ var executeAndSubscribeToRouteStatus = async ({
         explorerLink = trackResponse.explorerLink;
       }
       transaction.explorerLink = explorerLink;
-      await onTransactionTracked?.({ txHash: transaction.txHash, chainId: transaction.chainId, explorerLink });
+      await onTransactionTracked?.({
+        txHash: transaction.txHash,
+        chainId: transaction.chainId,
+        explorerLink
+      });
     }
     if (transaction.txHash === void 0) {
       updateRouteDetails({
@@ -224,10 +244,17 @@ var executeAndSubscribeToRouteStatus = async ({
       });
       return;
     }
-    while (!isFinalState(transaction)) {
+    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}`);
-        return;
+        break;
       }
       try {
         const statusResponse = await transactionStatus({
@@ -242,7 +269,8 @@ var executeAndSubscribeToRouteStatus = async ({
           options: {
             onRouteStatusUpdated,
             ...options
-          }
+          },
+          relatedRoutes: routeDetails?.relatedRoutes
         });
         if (isFinalState(transaction)) {
           onTransactionCompleted?.({
@@ -250,7 +278,11 @@ var executeAndSubscribeToRouteStatus = async ({
             txHash: transaction.txHash,
             status: statusResponse
           });
-          break;
+          if (routeDetails?.relatedRoutes?.every(
+            (relatedRoute) => isFinalRouteStatus(relatedRoute)
+          )) {
+            break;
+          }
         }
       } catch (error) {
         console.error(error);
@@ -265,7 +297,10 @@ var updateRouteDetails = ({
   routeDetails,
   options,
   status,
-  routeId
+  routeId,
+  mainRouteId,
+  transferIndexToRouteKey,
+  relatedRoutes
 }) => {
   routeId ??= routeDetails?.id ?? "";
   let currentRouteDetails = routeDetails ?? routeDetailsMap.get(routeId);
@@ -273,6 +308,7 @@ var updateRouteDetails = ({
     currentRouteDetails = initializeNewRouteDetails(options);
     routeId = currentRouteDetails?.id;
   }
+  transferIndexToRouteKey ??= currentRouteDetails?.transferIndexToRouteKey;
   if (currentRouteDetails === void 0) {
     throw new Error("No route details found");
   }
@@ -281,7 +317,9 @@ var updateRouteDetails = ({
   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 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
   );
@@ -305,9 +343,14 @@ var updateRouteDetails = ({
     }
     return currentRouteDetails?.status;
   };
-  const transferAssetRelease = transactionDetails?.findLast((i) => i.statusResponse?.transferAssetRelease)?.statusResponse?.transferAssetRelease;
-  const senderAddress = options?.userAddresses?.at(0);
-  const receiverAddress = options?.userAddresses?.at(-1);
+  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,
@@ -317,9 +360,11 @@ var updateRouteDetails = ({
     transactionDetails,
     transferEvents,
     transferAssetRelease,
-    senderAddress: currentRouteDetails?.senderAddress ?? senderAddress?.address ?? "",
-    receiverAddress: currentRouteDetails?.receiverAddress ?? receiverAddress?.address ?? "",
-    txsSigned: currentRouteDetails?.txsSigned
+    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);
@@ -333,6 +378,8 @@ var updateRouteDetails = ({
 };
 var getSimpleRoute = (route) => {
   return {
+    usdAmountOut: route?.usdAmountOut,
+    usdAmountIn: route?.usdAmountIn,
     amountIn: route?.amountIn,
     amountOut: route?.amountOut,
     sourceAssetDenom: route?.sourceAssetDenom,
@@ -347,10 +394,11 @@ var getRouteDetailsWithSimpleTransactionDetailsStatus = (routeDetails) => {
     ...routeDetails,
     transactionDetails: routeDetails.transactionDetails.map((txDetails) => {
       const { statusResponse, ...rest } = txDetails;
-      return {
+      const newTxDetails = {
         ...rest,
-        status: txDetails?.status ?? getTransactionStatus(txDetails.statusResponse?.state)
+        status: txDetails?.status ?? getTransactionStatus(statusResponse?.transfers?.[0]?.state)
       };
+      return newTxDetails;
     })
   };
 };
@@ -361,5 +409,42 @@ var removeRoutesWithFinalStatus = () => {
     }
   });
 };
+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;
+};
 
 export { executeAndSubscribeToRouteStatus, getTransactionStatus, subscribeToRouteStatus, updateRouteDetails };