@skip-go/client 1.3.6 → 1.4.0

package/dist/cjs/{chunk-3FYU3BJ7.cjs → chunk-6LA66667.cjs}

@@ -1,16 +1,21 @@
 'use strict';
 
-var chunkMN763TPC_cjs = require('./chunk-MN763TPC.cjs');
-var chunkQSISUSYP_cjs = require('./chunk-QSISUSYP.cjs');
+var chunkVIG2BHYJ_cjs = require('./chunk-VIG2BHYJ.cjs');
+var chunk3M7YYWGL_cjs = require('./chunk-3M7YYWGL.cjs');
+var chunkN4UW74AG_cjs = require('./chunk-N4UW74AG.cjs');
 var stargate = require('@cosmjs/stargate');
 var utils = require('@cosmjs/utils');
 var binary_js = require('cosmjs-types/binary.js');
 var auth_js = require('cosmjs-types/cosmos/auth/v1beta1/auth.js');
 var coin_js = require('cosmjs-types/cosmos/base/v1beta1/coin.js');
 var protoSigning = require('@cosmjs/proto-signing');
-var sdkTs = require('@injectivelabs/sdk-ts');
 var keys_js = require('cosmjs-types/cosmos/crypto/secp256k1/keys.js');
 var amino = require('@cosmjs/amino');
+var _m0 = require('protobufjs/minimal.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var _m0__default = /*#__PURE__*/_interopDefault(_m0);
 
 var createBaseVestingAccount = () => {
   return {
@@ -170,6 +175,95 @@ var StridePeriodicVestingAccount = {
     return message;
   }
 };
+function createBaseEthAccount() {
+  return {
+    baseAccount: void 0,
+    codeHash: new Uint8Array()
+  };
+}
+var EthAccount = {
+  typeUrl: "/injective.types.v1beta1.EthAccount",
+  encode(message, writer = _m0__default.default.Writer.create()) {
+    if (message.baseAccount !== void 0) {
+      chunk3M7YYWGL_cjs.BaseAccount.encode(message.baseAccount, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.codeHash.length !== 0) {
+      writer.uint32(18).bytes(message.codeHash);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof _m0__default.default.Reader ? input : new _m0__default.default.Reader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseEthAccount();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.baseAccount = chunk3M7YYWGL_cjs.BaseAccount.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.codeHash = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      baseAccount: chunk3M7YYWGL_cjs.isSet(object.baseAccount) ? chunk3M7YYWGL_cjs.BaseAccount.fromJSON(object.baseAccount) : void 0,
+      codeHash: chunk3M7YYWGL_cjs.isSet(object.codeHash) ? chunk3M7YYWGL_cjs.bytesFromBase64(object.codeHash) : new Uint8Array()
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    message.baseAccount !== void 0 && (obj.baseAccount = message.baseAccount ? chunk3M7YYWGL_cjs.BaseAccount.toJSON(message.baseAccount) : void 0);
+    message.codeHash !== void 0 && (obj.codeHash = chunk3M7YYWGL_cjs.base64FromBytes(message.codeHash !== void 0 ? message.codeHash : new Uint8Array()));
+    return obj;
+  },
+  fromPartial(object) {
+    const message = createBaseEthAccount();
+    message.baseAccount = object.baseAccount !== void 0 && object.baseAccount !== null ? chunk3M7YYWGL_cjs.BaseAccount.fromPartial(object.baseAccount) : void 0;
+    message.codeHash = object.codeHash ?? new Uint8Array();
+    return message;
+  },
+  fromAmino(object) {
+    const message = createBaseEthAccount();
+    if (object.base_account !== void 0 && object.base_account !== null) {
+      message.baseAccount = chunk3M7YYWGL_cjs.BaseAccount.fromAmino(object.base_account);
+    }
+    if (object.code_hash !== void 0 && object.code_hash !== null) {
+      message.codeHash = chunk3M7YYWGL_cjs.bytesFromBase64(object.code_hash);
+    }
+    return message;
+  },
+  toAmino(message) {
+    const obj = {};
+    obj.base_account = message.baseAccount ? chunk3M7YYWGL_cjs.BaseAccount.toAmino(message.baseAccount) : void 0;
+    obj.code_hash = message.codeHash ? chunk3M7YYWGL_cjs.base64FromBytes(message.codeHash) : void 0;
+    return obj;
+  },
+  fromAminoMsg(object) {
+    return EthAccount.fromAmino(object.value);
+  },
+  fromProtoMsg(message) {
+    return EthAccount.decode(message.value);
+  },
+  toProto(message) {
+    return EthAccount.encode(message).finish();
+  },
+  toProtoMsg(message) {
+    return {
+      typeUrl: "/injective.types.v1beta1.EthAccount",
+      value: EthAccount.encode(message).finish()
+    };
+  }
+};
+
+// src/registry.ts
 var accountParser = (acc) => {
   switch (acc.typeUrl) {
     case "/stride.vesting.StridePeriodicVestingAccount": {
@@ -183,12 +277,12 @@ var accountParser = (acc) => {
       };
     }
     case "/injective.types.v1beta1.EthAccount":
-      return sdkTs.accountEthParser(
+      return accountEthParser(
         acc,
         "/injective.crypto.v1beta1.ethsecp256k1.PubKey"
       );
     case "/ethermint.types.v1.EthAccount":
-      return sdkTs.accountEthParser(acc, "/ethermint.crypto.v1.ethsecp256k1.PubKey");
+      return accountEthParser(acc, "/ethermint.crypto.v1.ethsecp256k1.PubKey");
     default: {
       if (acc.typeUrl === "/cosmos.auth.v1beta1.BaseAccount") {
         const { address, pubKey, accountNumber, sequence } = auth_js.BaseAccount.decode(
@@ -209,14 +303,30 @@ var accountParser = (acc) => {
     }
   }
 };
+var accountEthParser = (ethAccount, pubKeyTypeUrl = "/injective.crypto.v1beta1.ethsecp256k1.PubKey") => {
+  const account = EthAccount.decode(
+    ethAccount.value
+  );
+  const baseAccount = account.baseAccount;
+  const pubKey = baseAccount.pubKey;
+  return {
+    address: baseAccount.address,
+    pubkey: pubKey ? {
+      type: pubKeyTypeUrl,
+      value: Buffer.from(pubKey.value).toString("base64")
+    } : null,
+    accountNumber: parseInt(baseAccount.accountNumber.toString(), 10),
+    sequence: parseInt(baseAccount.sequence.toString(), 10)
+  };
+};
 
 // src/private-functions/getRpcEndpointForChain.ts
 var getRpcEndpointForChain = async (chainId) => {
-  if (chunkQSISUSYP_cjs.ClientState.endpointOptions.getRpcEndpointForChain) {
-    return chunkQSISUSYP_cjs.ClientState.endpointOptions.getRpcEndpointForChain(chainId);
+  if (chunkN4UW74AG_cjs.ClientState.endpointOptions.getRpcEndpointForChain) {
+    return chunkN4UW74AG_cjs.ClientState.endpointOptions.getRpcEndpointForChain(chainId);
   }
-  if (chunkQSISUSYP_cjs.ClientState.endpointOptions.endpoints && chunkQSISUSYP_cjs.ClientState.endpointOptions.endpoints[chainId]) {
-    const endpointOptions = chunkQSISUSYP_cjs.ClientState.endpointOptions.endpoints[chainId];
+  if (chunkN4UW74AG_cjs.ClientState.endpointOptions.endpoints && chunkN4UW74AG_cjs.ClientState.endpointOptions.endpoints[chainId]) {
+    const endpointOptions = chunkN4UW74AG_cjs.ClientState.endpointOptions.endpoints[chainId];
     if (endpointOptions?.rpc) {
       return endpointOptions.rpc;
     }
@@ -224,7 +334,7 @@ var getRpcEndpointForChain = async (chainId) => {
   console.warn(
     "Warning: You are using unreliable public endpoints. We strongly recommend overriding them via endpointOptions for use beyond development settings."
   );
-  const chain = chunkMN763TPC_cjs.chains().find((chain2) => chain2.chainId === chainId);
+  const chain = chunkVIG2BHYJ_cjs.chains().find((chain2) => chain2.chainId === chainId);
   if (!chain) {
     throw new Error(`getRpcEndpointForChain: failed to find chain id '${chainId}' in registry`);
   }
@@ -234,7 +344,7 @@ var getRpcEndpointForChain = async (chainId) => {
     );
   }
   const endpoints = chain.apis?.rpc?.map((api) => api.address);
-  const endpoint = await chunkMN763TPC_cjs.findFirstWorkingEndpoint(endpoints, "rpc");
+  const endpoint = await chunkVIG2BHYJ_cjs.findFirstWorkingEndpoint(endpoints, "rpc");
   if (!endpoint) {
     throw new Error(
       `getRpcEndpointForChain error: failed to find RPC endpoint for chain id '${chainId}'`
@@ -251,19 +361,19 @@ var getSigningStargateClient = async ({
   if (!getOfflineSigner) {
     throw new Error("'getCosmosSigner' is not provided or configured in skip router");
   }
-  if (!chunkQSISUSYP_cjs.ClientState.signingStargateClientByChainId?.[chainId]) {
+  if (!chunkN4UW74AG_cjs.ClientState.signingStargateClientByChainId?.[chainId]) {
     const [signer, endpoint] = await Promise.all([
       getOfflineSigner(chainId),
       getRpcEndpointForChain(chainId)
     ]);
-    chunkQSISUSYP_cjs.ClientState.signingStargateClientByChainId[chainId] = await stargate.SigningStargateClient.connectWithSigner(endpoint, signer, {
-      aminoTypes: chunkQSISUSYP_cjs.ClientState.aminoTypes,
-      registry: chunkQSISUSYP_cjs.ClientState.registry,
+    chunkN4UW74AG_cjs.ClientState.signingStargateClientByChainId[chainId] = await stargate.SigningStargateClient.connectWithSigner(endpoint, signer, {
+      aminoTypes: chunkN4UW74AG_cjs.ClientState.aminoTypes,
+      registry: chunkN4UW74AG_cjs.ClientState.registry,
       accountParser
     });
   }
   return {
-    stargateClient: chunkQSISUSYP_cjs.ClientState.signingStargateClientByChainId[chainId],
+    stargateClient: chunkN4UW74AG_cjs.ClientState.signingStargateClientByChainId[chainId],
     signer: await getOfflineSigner(chainId)
   };
 };

package/dist/cjs/chunk-7MC3BVQN.cjs

@@ -0,0 +1,370 @@
+'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?.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 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: [],
+    senderAddress: options?.userAddresses?.[0]?.address ?? "",
+    receiverAddress: options?.userAddresses?.at(-1)?.address ?? ""
+  };
+  routeDetailsMap.set(newRouteId, newRouteDetails);
+  return newRouteDetails;
+};
+var subscribeToRouteStatus = (props) => {
+  let cancelled = false;
+  const unsubscribe = () => {
+    cancelled = true;
+  };
+  executeAndSubscribeToRouteStatus({
+    ...props,
+    isCancelled: () => cancelled
+  });
+  return unsubscribe;
+};
+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)) {
+    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 (!isFinalState(transaction)) {
+      if (isCancelled?.()) {
+        console.info(`Polling cancelled for route ${routeId}`);
+        return;
+      }
+      try {
+        const statusResponse = await chunkQPM7H2YL_cjs.transactionStatus({
+          chainId: transaction.chainId,
+          txHash: transaction.txHash
+        });
+        transaction.statusResponse = statusResponse;
+        updateRouteDetails({
+          routeId,
+          routeDetails,
+          transactionDetails,
+          options: {
+            onRouteStatusUpdated,
+            ...options
+          }
+        });
+        if (isFinalState(transaction)) {
+          onTransactionCompleted?.({
+            chainId: transaction.chainId,
+            txHash: transaction.txHash,
+            status: statusResponse
+          });
+          break;
+        }
+      } catch (error) {
+        console.error(error);
+      } finally {
+        await chunkERGJBZUC_cjs.wait(1e3);
+      }
+    }
+  }
+};
+var updateRouteDetails = ({
+  transactionDetails,
+  routeDetails,
+  options,
+  status,
+  routeId
+}) => {
+  routeId ??= routeDetails?.id ?? "";
+  let currentRouteDetails = routeDetails ?? routeDetailsMap.get(routeId);
+  if (!routeId && currentRouteDetails == void 0) {
+    currentRouteDetails = initializeNewRouteDetails(options);
+    routeId = currentRouteDetails?.id;
+  }
+  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 senderAddress = options?.userAddresses?.at(0);
+  const receiverAddress = options?.userAddresses?.at(-1);
+  const newRouteDetails = {
+    id: routeId,
+    timestamp: currentRouteDetails.timestamp,
+    status: getRouteStatus(),
+    route: getSimpleRoute(currentRouteDetails?.route ?? options?.route),
+    txsRequired,
+    transactionDetails,
+    transferEvents,
+    transferAssetRelease,
+    senderAddress: currentRouteDetails?.senderAddress ?? senderAddress?.address ?? "",
+    receiverAddress: currentRouteDetails?.receiverAddress ?? receiverAddress?.address ?? "",
+    txsSigned: currentRouteDetails?.txsSigned
+  };
+  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 {
+    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;
+      return {
+        ...rest,
+        status: txDetails?.status ?? getTransactionStatus(txDetails.statusResponse?.state)
+      };
+    })
+  };
+};
+var removeRoutesWithFinalStatus = () => {
+  routeDetailsMap.forEach((routeDetails, routeId) => {
+    if (routeDetails.status === "completed" || routeDetails.status === "failed" || routeDetails.status === "incomplete") {
+      routeDetailsMap.delete(routeId);
+    }
+  });
+};
+
+exports.executeAndSubscribeToRouteStatus = executeAndSubscribeToRouteStatus;
+exports.getTransactionStatus = getTransactionStatus;
+exports.subscribeToRouteStatus = subscribeToRouteStatus;
+exports.updateRouteDetails = updateRouteDetails;

package/dist/cjs/{chunk-YYBGBKRE.cjs → chunk-A26H4FVN.cjs}

@@ -1,15 +1,15 @@
 'use strict';
 
-var chunkQSISUSYP_cjs = require('./chunk-QSISUSYP.cjs');
-var chunkHKQ5VION_cjs = require('./chunk-HKQ5VION.cjs');
+var chunkN4UW74AG_cjs = require('./chunk-N4UW74AG.cjs');
+var chunkERGJBZUC_cjs = require('./chunk-ERGJBZUC.cjs');
 
 // src/api/postAssetsFromSource.ts
-var assetsFromSource = chunkHKQ5VION_cjs.api({
+var assetsFromSource = chunkERGJBZUC_cjs.api({
   methodName: "assetsFromSource",
   method: "post",
   path: "v2/fungible/assets_from_source",
   transformResponse(response) {
-    return chunkQSISUSYP_cjs.transformAssetsMap(response.destAssets);
+    return chunkN4UW74AG_cjs.transformAssetsMap(response.destAssets);
   }
 });
 

package/dist/cjs/{chunk-P7CDAHIX.cjs → chunk-AXYRULAI.cjs}

@@ -1,9 +1,9 @@
 'use strict';
 
-var chunkHKQ5VION_cjs = require('./chunk-HKQ5VION.cjs');
+var chunkERGJBZUC_cjs = require('./chunk-ERGJBZUC.cjs');
 
 // src/api/getBridges.ts
-var bridges = chunkHKQ5VION_cjs.api({
+var bridges = chunkERGJBZUC_cjs.api({
   methodName: "bridges",
   path: "v2/info/bridges",
   transformResponse: (response) => response.bridges