@skip-go/client 1.6.0-alpha.3 → 1.6.0-alpha.5

package/dist/cjs/chunk-A3UNNRKD.cjs

@@ -0,0 +1,574 @@
+'use strict';
+
+var chunkAUTOIM57_cjs = require('./chunk-AUTOIM57.cjs');
+var chunkPDNKS5R2_cjs = require('./chunk-PDNKS5R2.cjs');
+var chunk2QPPD3BB_cjs = require('./chunk-2QPPD3BB.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 getTxHashAndExplorerLink = (type) => {
+    switch (transferType) {
+      case "ibcTransfer" /* ibcTransfer */:
+        if (type === "send") {
+          return {
+            explorerLink: ibcTransfer.packetTxs.sendTx?.explorerLink,
+            txHash: ibcTransfer.packetTxs.sendTx?.txHash
+          };
+        }
+        return {
+          explorerLink: ibcTransfer.packetTxs.receiveTx?.explorerLink ?? ibcTransfer.packetTxs.timeoutTx?.explorerLink,
+          txHash: ibcTransfer.packetTxs.receiveTx?.txHash
+        };
+      case "eurekaTransfer" /* eurekaTransfer */:
+        if (type === "send") {
+          return {
+            explorerLink: eurekaTransfer.packetTxs.sendTx?.explorerLink,
+            txHash: eurekaTransfer.packetTxs.sendTx?.txHash
+          };
+        }
+        return {
+          explorerLink: eurekaTransfer.packetTxs.receiveTx?.explorerLink ?? eurekaTransfer.packetTxs.timeoutTx?.explorerLink,
+          txHash: eurekaTransfer.packetTxs.receiveTx?.txHash
+        };
+      case "goFastTransfer" /* goFastTransfer */:
+        if (type === "send") {
+          return {
+            explorerLink: goFastTransfer.txs.orderSubmittedTx?.explorerLink,
+            txHash: goFastTransfer.txs.orderSubmittedTx?.txHash
+          };
+        }
+        return {
+          explorerLink: goFastTransfer.txs.orderFilledTx?.explorerLink ?? goFastTransfer.txs.orderTimeoutTx?.explorerLink ?? goFastTransfer.txs.orderRefundedTx?.explorerLink,
+          txHash: goFastTransfer.txs.orderFilledTx?.txHash
+        };
+      case "axelarTransfer" /* axelarTransfer */:
+        const sendTokenTxs = axelarTransfer.txs;
+        const contractCallWithTokenTxs = axelarTransfer.txs?.contractCallWithTokenTxs;
+        if (type === "send") {
+          return {
+            explorerLink: sendTokenTxs?.sendTx?.explorerLink ?? contractCallWithTokenTxs?.sendTx?.explorerLink,
+            txHash: sendTokenTxs?.sendTx?.txHash ?? contractCallWithTokenTxs?.sendTx?.txHash
+          };
+        }
+        return {
+          explorerLink: sendTokenTxs?.executeTx?.explorerLink ?? contractCallWithTokenTxs?.executeTx?.explorerLink,
+          txHash: sendTokenTxs?.executeTx?.txHash ?? contractCallWithTokenTxs?.executeTx?.txHash
+        };
+      default:
+        if (type === "send") {
+          return {
+            explorerLink: combinedTransferEvent[transferType]?.txs?.sendTx?.explorerLink,
+            txHash: combinedTransferEvent[transferType]?.txs?.sendTx?.txHash
+          };
+        }
+        return {
+          explorerLink: combinedTransferEvent[transferType]?.txs?.receiveTx?.explorerLink,
+          txHash: combinedTransferEvent[transferType]?.txs?.receiveTx?.txHash
+        };
+    }
+  };
+  const getDuration = () => {
+    switch (transferType) {
+      case "ibcTransfer" /* ibcTransfer */: {
+        const sendTime = ibcTransfer.packetTxs.sendTx?.onChainAt;
+        const receiveTime = ibcTransfer.packetTxs.receiveTx?.onChainAt;
+        if (!sendTime || !receiveTime) return;
+        return new Date(receiveTime).getTime() - new Date(sendTime).getTime();
+      }
+      case "eurekaTransfer" /* eurekaTransfer */: {
+        const sendTime = eurekaTransfer.packetTxs.sendTx?.onChainAt;
+        const receiveTime = eurekaTransfer.packetTxs.receiveTx?.onChainAt;
+        if (!sendTime || !receiveTime) return;
+        return new Date(receiveTime).getTime() - new Date(sendTime).getTime();
+      }
+      case "goFastTransfer" /* goFastTransfer */: {
+        const submitTime = goFastTransfer.txs.orderSubmittedTx?.onChainAt;
+        const filledTime = goFastTransfer.txs.orderFilledTx?.onChainAt;
+        if (!submitTime || !filledTime) return;
+        return new Date(filledTime).getTime() - new Date(submitTime).getTime();
+      }
+      case "axelarTransfer" /* axelarTransfer */: {
+        const sendTokenTxs = axelarTransfer.txs;
+        const contractCallWithTokenTxs = axelarTransfer.txs?.contractCallWithTokenTxs;
+        const sendTime = sendTokenTxs?.sendTx?.onChainAt ?? contractCallWithTokenTxs?.sendTx?.onChainAt;
+        const confirmTime = sendTokenTxs?.confirmTx?.onChainAt ?? contractCallWithTokenTxs?.confirmTx?.onChainAt;
+        if (!sendTime || !confirmTime) return;
+        return new Date(confirmTime).getTime() - new Date(sendTime).getTime();
+      }
+      default: {
+        const remainingTransfer = combinedTransferEvent[transferType];
+        const sendTime = remainingTransfer?.txs?.sendTx?.onChainAt;
+        const receiveTime = remainingTransfer?.txs?.receiveTx?.onChainAt;
+        if (!sendTime || !receiveTime) return;
+        return new Date(receiveTime).getTime() - new Date(sendTime).getTime();
+      }
+    }
+  };
+  const _result = {
+    ...ibcTransfer,
+    ...axelarTransfer,
+    ...cctpTransfer,
+    ...hyperlaneTransfer,
+    ...stargateTransfer,
+    ...hyperlaneTransfer,
+    ...opInitTransfer,
+    ...goFastTransfer,
+    ...stargateTransfer,
+    ...eurekaTransfer,
+    ...layerZeroTransfer,
+    transferType,
+    fromExplorerLink: getTxHashAndExplorerLink("send")?.explorerLink,
+    toExplorerLink: getTxHashAndExplorerLink("receive")?.explorerLink,
+    fromTxHash: getTxHashAndExplorerLink("send")?.txHash,
+    toTxHash: getTxHashAndExplorerLink("receive")?.txHash,
+    durationInMs: getDuration()
+  };
+  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 getSimpleOverallStatus(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":
+    default:
+      return "failed";
+  }
+}
+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":
+    case "LAYER_ZERO_TRANSFER_WAITING_FOR_COMPOSE":
+      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";
+  }
+}
+var TransferType = /* @__PURE__ */ ((TransferType2) => {
+  TransferType2["ibcTransfer"] = "ibcTransfer";
+  TransferType2["axelarTransfer"] = "axelarTransfer";
+  TransferType2["cctpTransfer"] = "cctpTransfer";
+  TransferType2["hyperlaneTransfer"] = "hyperlaneTransfer";
+  TransferType2["opInitTransfer"] = "opInitTransfer";
+  TransferType2["goFastTransfer"] = "goFastTransfer";
+  TransferType2["stargateTransfer"] = "stargateTransfer";
+  TransferType2["eurekaTransfer"] = "eurekaTransfer";
+  TransferType2["layerZeroTransfer"] = "layerZeroTransfer";
+  return TransferType2;
+})(TransferType || {});
+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,
+  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 chunkAUTOIM57_cjs.trackTransaction({
+          chainId: transaction.chainId,
+          txHash: transaction.txHash,
+          ...trackTxPollingOptions
+        });
+        explorerLink = trackResponse.explorerLink;
+      }
+      transaction.explorerLink = explorerLink;
+      await options?.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) {
+        options?.onTransactionCompleted?.({
+          chainId: transaction.chainId,
+          txHash: transaction.txHash,
+          status: transaction.statusResponse
+        });
+        break;
+      }
+      if (isCancelled?.()) {
+        console.info(`Polling cancelled for route ${routeId}`);
+        break;
+      }
+      try {
+        const statusResponse = await chunkPDNKS5R2_cjs.transactionStatus({
+          chainId: transaction.chainId,
+          txHash: transaction.txHash
+        });
+        transaction.statusResponse = statusResponse;
+        updateRouteDetails({
+          routeId,
+          routeDetails,
+          transactionDetails,
+          options: {
+            onRouteStatusUpdated,
+            ...options
+          },
+          relatedRoutes: routeDetails?.relatedRoutes
+        });
+        if (isFinalState(transaction)) {
+          const relatedRoutes = updatedRouteDetails?.relatedRoutes && updatedRouteDetails?.relatedRoutes.length > 0 ? updatedRouteDetails.relatedRoutes : routeDetails?.relatedRoutes;
+          if (relatedRoutes && relatedRoutes.length > 0) {
+            if (relatedRoutes.every(
+              (relatedRoute) => isFinalRouteStatus(relatedRoute)
+            )) {
+              options?.onTransactionCompleted?.({
+                chainId: transaction.chainId,
+                txHash: transaction.txHash,
+                status: statusResponse
+              });
+              break;
+            }
+          } else {
+            options?.onTransactionCompleted?.({
+              chainId: transaction.chainId,
+              txHash: transaction.txHash,
+              status: statusResponse
+            });
+            break;
+          }
+        }
+      } catch (error) {
+        console.error(error);
+      } finally {
+        await chunk2QPPD3BB_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,
+    operations: route?.operations
+  };
+};
+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.TransferType = TransferType;
+exports.executeAndSubscribeToRouteStatus = executeAndSubscribeToRouteStatus;
+exports.getSimpleOverallStatus = getSimpleOverallStatus;
+exports.getTransactionStatus = getTransactionStatus;
+exports.getTransferEventsFromTxStatusResponse = getTransferEventsFromTxStatusResponse;
+exports.subscribeToRouteStatus = subscribeToRouteStatus;
+exports.updateRouteDetails = updateRouteDetails;

package/dist/cjs/chunk-A5S6SIYN.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var chunk2QPPD3BB_cjs = require('./chunk-2QPPD3BB.cjs');
+
+// src/api/postMessagesDirect.ts
+var messagesDirect = chunk2QPPD3BB_cjs.api({
+  methodName: "msgsDirect",
+  method: "post",
+  path: "v2/fungible/msgs_direct"
+});
+
+exports.messagesDirect = messagesDirect;

package/dist/cjs/chunk-ASDMDYTC.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var chunk2QPPD3BB_cjs = require('./chunk-2QPPD3BB.cjs');
+
+// src/api/getAssetsBetweenChains.ts
+var assetsBetweenChains = chunk2QPPD3BB_cjs.api({
+  methodName: "fungibleAssetsBetweenChainsCreate",
+  path: "v2/fungible/assets_between_chains"
+});
+
+exports.assetsBetweenChains = assetsBetweenChains;