@skip-go/client 1.3.7 → 1.4.0

package/dist/esm/{chunk-JIADJKRD.js → chunk-OTS5KO43.js}

@@ -1,4 +1,4 @@
-import { ApiState, api } from './chunk-LZI7A4JI.js';
+import { ApiState, api } from './chunk-A6KSECAH.js';
 
 // src/api/postRoute.ts
 var route = async (request) => {

package/dist/esm/{chunk-CU6W3622.js → chunk-QIS6ILPS.js}

@@ -1,6 +1,6 @@
-import { trackTransaction } from './chunk-7ITTEUMR.js';
-import { transactionStatus } from './chunk-MXCJ2M3K.js';
-import { wait } from './chunk-LZI7A4JI.js';
+import { trackTransaction } from './chunk-7X4ERB3R.js';
+import { transactionStatus } from './chunk-APRMN34M.js';
+import { wait } from './chunk-A6KSECAH.js';
 
 // src/public-functions/waitForTransaction.ts
 var waitForTransaction = async ({

package/dist/esm/chunk-QO2CYYF5.js

@@ -0,0 +1,278 @@
+import _m0 from 'protobufjs/minimal.js';
+import Long from 'long';
+export { default as Long } from 'long';
+import { Dec } from '@keplr-wallet/unit';
+
+// src/codegen/helpers.ts
+if (_m0.util.Long !== Long) {
+  _m0.util.Long = Long;
+  _m0.configure();
+}
+var globalThis = (() => {
+  if (typeof globalThis !== "undefined") return globalThis;
+  if (typeof self !== "undefined") return self;
+  if (typeof window !== "undefined") return window;
+  if (typeof global !== "undefined") return global;
+  throw "Unable to locate global object";
+})();
+var atob = globalThis.atob || ((b64) => globalThis.Buffer.from(b64, "base64").toString("binary"));
+function bytesFromBase64(b64) {
+  const bin = atob(b64);
+  const arr = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; ++i) {
+    arr[i] = bin.charCodeAt(i);
+  }
+  return arr;
+}
+var btoa = globalThis.btoa || ((bin) => globalThis.Buffer.from(bin, "binary").toString("base64"));
+function base64FromBytes(arr) {
+  const bin = [];
+  arr.forEach((byte) => {
+    bin.push(String.fromCharCode(byte));
+  });
+  return btoa(bin.join(""));
+}
+function isSet(value) {
+  return value !== null && value !== void 0;
+}
+function toTimestamp(date) {
+  const seconds = numberToLong(date.getTime() / 1e3);
+  const nanos = date.getTime() % 1e3 * 1e6;
+  return {
+    seconds,
+    nanos
+  };
+}
+function fromTimestamp(t) {
+  let millis = t.seconds.toNumber() * 1e3;
+  millis += t.nanos / 1e6;
+  return new Date(millis);
+}
+var timestampFromJSON = (object) => {
+  return {
+    seconds: isSet(object.seconds) ? Long.fromValue(object.seconds) : Long.ZERO,
+    nanos: isSet(object.nanos) ? Number(object.nanos) : 0
+  };
+};
+function fromJsonTimestamp(o) {
+  if (o instanceof Date) {
+    return toTimestamp(o);
+  } else if (typeof o === "string") {
+    return toTimestamp(new Date(o));
+  } else {
+    return timestampFromJSON(o);
+  }
+}
+function numberToLong(number) {
+  return Long.fromNumber(number);
+}
+function padDecimal(decStr) {
+  return decStr ? new Dec(decStr).toString() : decStr;
+}
+function createBaseAny() {
+  return {
+    $typeUrl: "/google.protobuf.Any",
+    typeUrl: "",
+    value: new Uint8Array()
+  };
+}
+var Any = {
+  typeUrl: "/google.protobuf.Any",
+  encode(message, writer = _m0.Writer.create()) {
+    if (message.typeUrl !== "") {
+      writer.uint32(10).string(message.typeUrl);
+    }
+    if (message.value.length !== 0) {
+      writer.uint32(18).bytes(message.value);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseAny();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.typeUrl = reader.string();
+          break;
+        case 2:
+          message.value = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      typeUrl: isSet(object.typeUrl) ? String(object.typeUrl) : "",
+      value: isSet(object.value) ? bytesFromBase64(object.value) : new Uint8Array()
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    message.typeUrl !== void 0 && (obj.typeUrl = message.typeUrl);
+    message.value !== void 0 && (obj.value = base64FromBytes(message.value !== void 0 ? message.value : new Uint8Array()));
+    return obj;
+  },
+  fromPartial(object) {
+    const message = createBaseAny();
+    message.typeUrl = object.typeUrl ?? "";
+    message.value = object.value ?? new Uint8Array();
+    return message;
+  },
+  fromAmino(object) {
+    return {
+      typeUrl: object.type,
+      value: object.value
+    };
+  },
+  toAmino(message) {
+    const obj = {};
+    obj.type = message.typeUrl;
+    obj.value = message.value;
+    return obj;
+  },
+  fromAminoMsg(object) {
+    return Any.fromAmino(object.value);
+  },
+  fromProtoMsg(message) {
+    return Any.decode(message.value);
+  },
+  toProto(message) {
+    return Any.encode(message).finish();
+  },
+  toProtoMsg(message) {
+    return {
+      typeUrl: "/google.protobuf.Any",
+      value: Any.encode(message).finish()
+    };
+  }
+};
+function createBaseBaseAccount() {
+  return {
+    address: "",
+    pubKey: void 0,
+    accountNumber: Long.UZERO,
+    sequence: Long.UZERO
+  };
+}
+var BaseAccount = {
+  typeUrl: "/cosmos.auth.v1beta1.BaseAccount",
+  encode(message, writer = _m0.Writer.create()) {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
+    }
+    if (message.pubKey !== void 0) {
+      Any.encode(message.pubKey, writer.uint32(18).fork()).ldelim();
+    }
+    if (!message.accountNumber.isZero()) {
+      writer.uint32(24).uint64(message.accountNumber);
+    }
+    if (!message.sequence.isZero()) {
+      writer.uint32(32).uint64(message.sequence);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseBaseAccount();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.address = reader.string();
+          break;
+        case 2:
+          message.pubKey = Any.decode(reader, reader.uint32());
+          break;
+        case 3:
+          message.accountNumber = reader.uint64();
+          break;
+        case 4:
+          message.sequence = reader.uint64();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      address: isSet(object.address) ? String(object.address) : "",
+      pubKey: isSet(object.pubKey) ? Any.fromJSON(object.pubKey) : void 0,
+      accountNumber: isSet(object.accountNumber) ? Long.fromValue(object.accountNumber) : Long.UZERO,
+      sequence: isSet(object.sequence) ? Long.fromValue(object.sequence) : Long.UZERO
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    message.address !== void 0 && (obj.address = message.address);
+    message.pubKey !== void 0 && (obj.pubKey = message.pubKey ? Any.toJSON(message.pubKey) : void 0);
+    message.accountNumber !== void 0 && (obj.accountNumber = (message.accountNumber || Long.UZERO).toString());
+    message.sequence !== void 0 && (obj.sequence = (message.sequence || Long.UZERO).toString());
+    return obj;
+  },
+  fromPartial(object) {
+    const message = createBaseBaseAccount();
+    message.address = object.address ?? "";
+    message.pubKey = object.pubKey !== void 0 && object.pubKey !== null ? Any.fromPartial(object.pubKey) : void 0;
+    message.accountNumber = object.accountNumber !== void 0 && object.accountNumber !== null ? Long.fromValue(object.accountNumber) : Long.UZERO;
+    message.sequence = object.sequence !== void 0 && object.sequence !== null ? Long.fromValue(object.sequence) : Long.UZERO;
+    return message;
+  },
+  fromAmino(object) {
+    const message = createBaseBaseAccount();
+    if (object.address !== void 0 && object.address !== null) {
+      message.address = object.address;
+    }
+    if (object.pub_key !== void 0 && object.pub_key !== null) {
+      message.pubKey = Any.fromAmino(object.pub_key);
+    }
+    if (object.account_number !== void 0 && object.account_number !== null) {
+      message.accountNumber = Long.fromString(object.account_number);
+    }
+    if (object.sequence !== void 0 && object.sequence !== null) {
+      message.sequence = Long.fromString(object.sequence);
+    }
+    return message;
+  },
+  toAmino(message) {
+    const obj = {};
+    obj.address = message.address === "" ? void 0 : message.address;
+    obj.pub_key = message.pubKey ? Any.toAmino(message.pubKey) : void 0;
+    obj.account_number = !message.accountNumber.isZero() ? message.accountNumber.toString() : void 0;
+    obj.sequence = !message.sequence.isZero() ? message.sequence.toString() : void 0;
+    return obj;
+  },
+  fromAminoMsg(object) {
+    return BaseAccount.fromAmino(object.value);
+  },
+  toAminoMsg(message) {
+    return {
+      type: "cosmos-sdk/BaseAccount",
+      value: BaseAccount.toAmino(message)
+    };
+  },
+  fromProtoMsg(message) {
+    return BaseAccount.decode(message.value);
+  },
+  toProto(message) {
+    return BaseAccount.encode(message).finish();
+  },
+  toProtoMsg(message) {
+    return {
+      typeUrl: "/cosmos.auth.v1beta1.BaseAccount",
+      value: BaseAccount.encode(message).finish()
+    };
+  }
+};
+
+export { BaseAccount, base64FromBytes, bytesFromBase64, fromJsonTimestamp, fromTimestamp, isSet, padDecimal, toTimestamp };

package/dist/esm/{chunk-OL7CWCPB.js → chunk-REWUSU53.js}

@@ -1,6 +1,7 @@
-import { MsgAcceptOwner, MsgAddRemoteTokenMessenger, MsgDepositForBurn, MsgDepositForBurnWithCaller, MsgDisableAttester, MsgEnableAttester, MsgLinkTokenPair, MsgPauseBurningAndMinting, MsgPauseSendingAndReceivingMessages, MsgReceiveMessage, MsgRemoveRemoteTokenMessenger, MsgReplaceDepositForBurn, MsgReplaceMessage, MsgSendMessage, MsgSendMessageWithCaller, MsgUnlinkTokenPair, MsgUnpauseBurningAndMinting, MsgUnpauseSendingAndReceivingMessages, MsgUpdateOwner, MsgUpdateAttesterManager, MsgUpdateTokenController, MsgUpdatePauser, MsgUpdateMaxMessageBodySize, MsgSetMaxBurnAmountPerMessage, MsgUpdateSignatureThreshold, MsgExecute, MsgInitiateTokenDeposit, Coin, isSet, Long, Timestamp, toTimestamp, Period, fromTimestamp, fromJsonTimestamp, padDecimal } from './chunk-TD63P2AG.js';
-import { ClientState } from './chunk-2L7PKZDY.js';
-import { ApiState, createRequestClient } from './chunk-LZI7A4JI.js';
+import { MsgAcceptOwner, MsgAddRemoteTokenMessenger, MsgDepositForBurn, MsgDepositForBurnWithCaller, MsgDisableAttester, MsgEnableAttester, MsgLinkTokenPair, MsgPauseBurningAndMinting, MsgPauseSendingAndReceivingMessages, MsgReceiveMessage, MsgRemoveRemoteTokenMessenger, MsgReplaceDepositForBurn, MsgReplaceMessage, MsgSendMessage, MsgSendMessageWithCaller, MsgUnlinkTokenPair, MsgUnpauseBurningAndMinting, MsgUnpauseSendingAndReceivingMessages, MsgUpdateOwner, MsgUpdateAttesterManager, MsgUpdateTokenController, MsgUpdatePauser, MsgUpdateMaxMessageBodySize, MsgSetMaxBurnAmountPerMessage, MsgUpdateSignatureThreshold, MsgExecute, MsgInitiateTokenDeposit, Coin, Timestamp, Period } from './chunk-UIDIKXMB.js';
+import { isSet, Long, toTimestamp, fromTimestamp, fromJsonTimestamp, padDecimal } from './chunk-QO2CYYF5.js';
+import { ClientState } from './chunk-ZOUYAZU6.js';
+import { ApiState, createRequestClient } from './chunk-A6KSECAH.js';
 import { AminoTypes, createDefaultAminoConverters, defaultRegistryTypes } from '@cosmjs/stargate';
 import { createWasmAminoConverters } from '@cosmjs/cosmwasm-stargate';
 import { Registry } from '@cosmjs/proto-signing';

package/dist/esm/chunk-RQ7DXNSS.js

@@ -0,0 +1,365 @@
+import { trackTransaction } from './chunk-7X4ERB3R.js';
+import { transactionStatus } from './chunk-APRMN34M.js';
+import { wait } from './chunk-A6KSECAH.js';
+import { v4 } from '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 = 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 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 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 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);
+    }
+  });
+};
+
+export { executeAndSubscribeToRouteStatus, getTransactionStatus, subscribeToRouteStatus, updateRouteDetails };

package/dist/esm/{chunk-XXTECZG3.js → chunk-S4RO2LHD.js}

@@ -1,4 +1,4 @@
-import { api } from './chunk-LZI7A4JI.js';
+import { api } from './chunk-A6KSECAH.js';
 
 // src/api/postIbcOriginAssets.ts
 var ibcOriginAssets = api({

package/dist/esm/{chunk-7YN3UVVF.js → chunk-UI3SIFZN.js}

@@ -1,4 +1,4 @@
-import { api } from './chunk-LZI7A4JI.js';
+import { api } from './chunk-A6KSECAH.js';
 
 // src/api/getBridges.ts
 var bridges = api({