@skip-go/client 1.3.6 → 1.4.0

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({