@skip-go/client 1.3.7 → 1.5.0

package/dist/esm/chunk-VUXLWWLF.js

@@ -0,0 +1,450 @@
+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?.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 = 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 ?? 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,
+  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) && 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 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 (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}`);
+        break;
+      }
+      try {
+        const statusResponse = await transactionStatus({
+          chainId: transaction.chainId,
+          txHash: transaction.txHash
+        });
+        transaction.statusResponse = statusResponse;
+        updateRouteDetails({
+          routeId,
+          routeDetails,
+          transactionDetails,
+          options: {
+            onRouteStatusUpdated,
+            ...options
+          },
+          relatedRoutes: routeDetails?.relatedRoutes
+        });
+        if (isFinalState(transaction)) {
+          onTransactionCompleted?.({
+            chainId: transaction.chainId,
+            txHash: transaction.txHash,
+            status: statusResponse
+          });
+          if (routeDetails?.relatedRoutes?.every(
+            (relatedRoute) => isFinalRouteStatus(relatedRoute)
+          )) {
+            break;
+          }
+        }
+      } catch (error) {
+        console.error(error);
+      } finally {
+        await 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
+  };
+};
+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;
+};
+
+export { executeAndSubscribeToRouteStatus, getTransactionStatus, subscribeToRouteStatus, updateRouteDetails };

package/dist/esm/{chunk-OL7CWCPB.js → chunk-WBZVMPPV.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';
@@ -2199,6 +2200,34 @@ var evmosAminoConverters = {
   ...AminoConverter5
 };
 var evmosProtoRegistry = [...registry2, ...registry3, ...registry4, ...registry5];
+
+// src/codegen/initia/move/v1/tx.amino.ts
+var AminoConverter6 = {
+  "/initia.move.v1.MsgExecute": {
+    aminoType: "/initia.move.v1.MsgExecute",
+    toAmino: MsgExecute.toAmino,
+    fromAmino: MsgExecute.fromAmino
+  }
+};
+
+// src/codegen/initia/client.ts
+var initiaAminoConverters = {
+  ...AminoConverter6
+};
+
+// src/codegen/opinit/ophost/v1/tx.amino.ts
+var AminoConverter7 = {
+  "/opinit.ophost.v1.MsgInitiateTokenDeposit": {
+    aminoType: "ophost/MsgInitiateTokenDeposit",
+    toAmino: MsgInitiateTokenDeposit.toAmino,
+    fromAmino: MsgInitiateTokenDeposit.fromAmino
+  }
+};
+
+// src/codegen/opinit/client.ts
+var opinitAminoConverters = {
+  ...AminoConverter7
+};
 var setClientOptions = (options = {}) => {
   ApiState.client = createRequestClient({
     apiUrl: options.apiUrl || "https://api.skip.build",
@@ -2211,6 +2240,8 @@ var setClientOptions = (options = {}) => {
     ...createWasmAminoConverters(),
     ...circleAminoConverters,
     ...evmosAminoConverters,
+    ...initiaAminoConverters,
+    ...opinitAminoConverters,
     ...options.aminoTypes ?? {}
   });
   ClientState.registry = new Registry([

package/dist/esm/{chunk-HT6O3BQ7.js → chunk-Y2YCODZK.js}

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

package/dist/esm/{chunk-IPHFFTGO.js → chunk-ZI3SYUQH.js}

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

package/dist/esm/{chunk-2L7PKZDY.js → chunk-ZOUYAZU6.js}

@@ -1,4 +1,4 @@
-import { api } from './chunk-LZI7A4JI.js';
+import { api } from './chunk-A6KSECAH.js';
 
 // src/private-functions/getMainnetAndTestnetChains.ts
 var getMainnetAndTestnetChains = async (apiOptions) => {

package/dist/esm/client-types-Dk6ypWdO.d.ts

@@ -0,0 +1,114 @@
+import { OfflineAminoSigner } from '@cosmjs/amino';
+import { OfflineDirectSigner } from '@cosmjs/proto-signing';
+import { StdFee, GasPrice, SignerData } from '@cosmjs/stargate';
+import { WalletClient } from 'viem';
+import { Adapter } from '@solana/wallet-adapter-base';
+import { a3 as FeeAsset, L as ChainType, W as CosmosMsg } from './swaggerTypes-DDwqIjap.js';
+import { TrackTxPollingProps } from './api/postTrackTransaction.js';
+
+/** Common Types */
+type UserAddress = {
+    chainId: string;
+    address: string;
+};
+type EndpointOptions = {
+    rpc?: string;
+    rest?: string;
+};
+type ValidateGasResult = {
+    error: null | string;
+    asset: FeeAsset | null;
+    fee: StdFee | null;
+};
+/** Signer Getters */
+type SignerGetters = {
+    getEvmSigner?: (chainId: string) => Promise<WalletClient>;
+    getCosmosSigner?: (chainId: string) => Promise<(OfflineAminoSigner & OfflineDirectSigner) | OfflineAminoSigner | OfflineDirectSigner>;
+    getSvmSigner?: () => Promise<Adapter>;
+};
+/** Gas Options */
+type GetFallbackGasAmount = (chainId: string, chainType: ChainType) => Promise<number | undefined>;
+type GetGasPrice = (chainId: string, chainType: ChainType) => Promise<GasPrice | undefined>;
+type GasOptions = {
+    /**
+     * If `getGasPrice` is undefined, or returns undefined, the router will attempt to set the recommended gas price
+     **/
+    getGasPrice?: GetGasPrice;
+    /**
+     * If `getFallbackGasAmount` is set, when router fails to simulate the gas amount, it will use the fallback gas amount
+     */
+    getFallbackGasAmount?: GetFallbackGasAmount;
+    gasAmountMultiplier?: number;
+};
+type SignCosmosMessageOptionsBase = {
+    signerAddress: string;
+    chainId: string;
+    cosmosMsgs: CosmosMsg[];
+    fee: StdFee;
+    signerData: SignerData;
+};
+type SignCosmosMessageDirectOptions = SignCosmosMessageOptionsBase & {
+    signer: OfflineDirectSigner;
+};
+type SignCosmosMessageAminoOptions = SignCosmosMessageOptionsBase & {
+    signer: OfflineAminoSigner;
+};
+type TxResult = {
+    txHash: string;
+    chainId: string;
+    explorerLink?: string;
+};
+interface BaseSettings {
+    slippageTolerancePercent?: string;
+    simulate?: boolean;
+    /**
+     * Set allowance amount to max if EVM transaction requires allowance approval.
+     */
+    useUnlimitedApproval?: boolean;
+    /**
+      /**
+       * If `skipApproval` is set to `true`, the router will bypass checking whether
+       * the signer has granted approval for the specified token contract on an EVM chain.
+       * This can be useful if approval has already been handled externally or there are race conditions.
+       */
+    bypassApprovalCheck?: boolean;
+    /**
+     * defaults to true
+     * If `batchSimulate` is set to `true`, it will simulate all messages in a batch before the first tx run.
+     * If `batchSimulate` is set to `false`, it will simulate each message one by one.
+     */
+    batchSimulate?: boolean;
+    /**
+     * Optional configuration for transaction polling behavior.
+     * - `maxRetries`: Maximum number of polling attempts (default: 5)
+     * - `retryInterval`: Retry interval in milliseconds (default: 1000)
+     * - `backoffMultiplier`: Exponential backoff multiplier for increasing delay between retries (default: 2.5)
+     * Example backoff with retryInterval = 1000 and backoffMultiplier = 2:
+     * 1st retry: 1000ms → 2nd: 2000ms → 3rd: 4000ms → 4th: 8000ms ...
+     */
+    trackTxPollingOptions?: TrackTxPollingProps;
+    /**
+     * If `batchSignTxs` is set to `true`, it will sign all transactions in a batch up front.
+     * If `batchSignTxs` is set to `false`, it will sign each transaction one by one.
+     */
+    batchSignTxs?: boolean;
+    /**
+     * If `cosmosPriorityFeeDenom` is provided, it will be used to set the priority fee for Cosmos transactions.
+     * It should be a function that takes a chainId and returns the denom for the priority fee.
+     */
+    getCosmosPriorityFeeDenom?: (chainId: string) => Promise<string | undefined>;
+    /**
+     * SVM Fee Payer
+     *
+     * This is used to pay for the transaction fees on SVM chains.
+     * It should be an object with the following properties:
+     * `address`: The address of the fee payer.
+     * `signTransaction`: A function that takes the data to sign and returns a Promise that resolves to the signed transaction.
+     */
+    svmFeePayer?: {
+        address: string;
+        signTransaction: (dataToSign: Buffer) => Promise<Uint8Array>;
+    };
+}
+
+export type { BaseSettings as B, EndpointOptions as E, GetFallbackGasAmount as G, SignerGetters as S, TxResult as T, UserAddress as U, ValidateGasResult as V, GetGasPrice as a, GasOptions as b, SignCosmosMessageOptionsBase as c, SignCosmosMessageDirectOptions as d, SignCosmosMessageAminoOptions as e };

package/dist/esm/index.d.ts

@@ -1,6 +1,6 @@
 export { A as AcknowledgementErrorDetails, a as Affiliate, bx as Api, bt as ApiConfig, b as ApiError, c as Asset, d as AssetBetweenChains, e as AssetRecommendation, bi as AssetRecommendationsResponse, be as AssetsFromSourceResponse, bc as AssetsRequest, bd as AssetsResponse, f as AutopilotAction, g as AutopilotMsg, h as AutopilotMsgWrapper, i as AxelarTransfer, j as AxelarTransferInfo, k as AxelarTransferState, l as AxelarTransferType, m as AxelarTransferWrapper, B as BalanceRequestChainEntry, E as BalanceResponseChainEntry, D as BalanceResponseDenomEntry, b8 as BalancesResponse, F as BankSend, H as BankSendWrapper, I as Bridge, J as BridgeType, b9 as BridgesResponse, C as CCTPTransfer, n as CCTPTransferInfo, p as CCTPTransferState, o as CCTPTransferTxs, q as CCTPTransferWrapper, K as Chain, M as ChainAffiliates, am as ChainTransaction, L as ChainType, b6 as ChainsRequest, b7 as ChainsResponse, bv as ContentType, N as ContractCallWithTokenError, O as ContractCallWithTokenErrorType, P as ContractCallWithTokenTxs, Q as CosmWasmContractMsg, R as CosmWasmContractMsgWrapper, b1 as CosmosModuleSupport, W as CosmosMsg, X as CosmosTx, Y as CosmosTxWrapper, T as Erc20Approval, V as Error, U as ErrorDetail, aW as EurekaTransfer, aX as EurekaTransferInfo, aY as EurekaTransferWrapper, Z as EvmSwap, _ as EvmSwapWrapper, $ as EvmTx, a0 as EvmTxWrapper, b5 as Fee, a3 as FeeAsset, b4 as FeeBehavior, b3 as FeeType, br as FullRequestParams, bo as FungibleAssetsBetweenChainsCreateResponse, a5 as GRPCStatusCode, a4 as GoFastFee, G as GoFastTransfer, y as GoFastTransferInfo, w as GoFastTransferState, x as GoFastTransferTxs, z as GoFastTransferWrapper, bw as HttpClient, bu as HttpResponse, a6 as HyperlaneTransfer, a7 as HyperlaneTransferInfo, a8 as HyperlaneTransferState, a9 as HyperlaneTransferTransactions, aa as HyperlaneTransferWrapper, ab as IBCTransferInfo, b2 as IbcCapabilities, bn as IbcOriginAssetsResponse, aZ as LayerZeroTransfer, a_ as LayerZeroTransferInfo, aP as LayerZeroTransferState, ai as LayerZeroTransferTransactions, a$ as LayerZeroTransferWrapper, ac as Msg, bh as MsgsDirectResponse, bg as MsgsResponse, ae as MultiChainMsg, af as MultiChainMsgWrapper, aK as OPInitTransfer, aM as OPInitTransferInfo, aO as OPInitTransferState, aN as OPInitTransferTxs, aL as OPInitTransferWrapper, ag as Operation, ah as OptionalAsset, aj as Packet, ak as PacketError, al as PacketErrorType, an as PostHandler, bp as QueryParamsType, ao as Reason, b0 as RecommendationRequest, bs as RequestParams, bq as ResponseFormat, aq as Route, ap as RoutePriceWarningType, bf as RouteResponse, ar as SendTokenError, as as SendTokenErrorType, at as SendTokenTxs, S as SmartRelayFeeQuote, aD as SmartSwapExactCoinIn, aF as SmartSwapInWrapper, aE as SmartSwapOptions, r as StargateTransfer, u as StargateTransferInfo, s as StargateTransferState, t as StargateTransferTxs, v as StargateTransferWrapper, au as StatusError, av as StatusErrorType, bl as StatusRequest, bm as StatusResponse, bj as SubmitResponse, a1 as SvmTx, a2 as SvmTxWrapper, aw as Swap, ax as SwapExactCoinIn, ay as SwapExactCoinOut, az as SwapInWrapper, aA as SwapOperation, aB as SwapOutWrapper, aC as SwapRoute, aG as SwapVenue, aH as SwapWrapper, bk as TrackResponse, aI as TransactionExecutionErrorDetails, aJ as TransactionState, aQ as Transfer, aT as TransferAssetRelease, aR as TransferEvent, aS as TransferState, aU as TransferStatus, aV as TransferWrapper, ad as Tx, ba as VenuesRequest, bb as VenuesResponse } from './swaggerTypes-DDwqIjap.js';
-export { T as TransactionCallbacks } from './callbacks-CuL50GnB.js';
-export { E as EndpointOptions, b as GasOptions, G as GetFallbackGasAmount, a as GetGasPrice, e as SignCosmosMessageAminoOptions, d as SignCosmosMessageDirectOptions, c as SignCosmosMessageOptionsBase, S as SignerGetters, T as TxResult, U as UserAddress, V as ValidateGasResult } from './client-types-B7Fin0mq.js';
+export { E as ExecuteRouteOptions, R as RouteDetails, a as RouteStatus, d as TransactionCallbacks, T as TransactionDetails, b as TransactionStatus, c as TransferEventStatus, e as executeRoute, s as subscribeToRouteStatus } from './callbacks-CvqAtBJq.js';
+export { B as BaseSettings, E as EndpointOptions, b as GasOptions, G as GetFallbackGasAmount, a as GetGasPrice, e as SignCosmosMessageAminoOptions, d as SignCosmosMessageDirectOptions, c as SignCosmosMessageOptionsBase, S as SignerGetters, T as TxResult, U as UserAddress, V as ValidateGasResult } from './client-types-Dk6ypWdO.js';
 export { assets } from './api/getAssets.js';
 export { assetsBetweenChains } from './api/getAssetsBetweenChains.js';
 export { bridges } from './api/getBridges.js';
@@ -16,9 +16,9 @@ export { RouteRequest, route } from './api/postRoute.js';
 export { SubmitTransactionRequest, SubmitTransactionResponse, submitTransaction } from './api/postSubmitTransaction.js';
 export { trackTransaction } from './api/postTrackTransaction.js';
 export { TxStatusResponse, transactionStatus } from './api/postTransactionStatus.js';
-export { ExecuteRouteOptions, executeRoute } from './public-functions/executeRoute.js';
+export { ExecuteMultipleRoutesOptions, executeMultipleRoutes } from './public-functions/executeMultipleRoutes.js';
 export { getSigningStargateClient, getSigningStargateClientProps } from './public-functions/getSigningStargateClient.js';
-export { S as SkipClientOptions, s as setClientOptions } from './setClientOptions-BTRwCbmt.js';
+export { S as SkipClientOptions, s as setClientOptions } from './setClientOptions-BD8e7m2x.js';
 export { getRecommendedGasPrice } from './public-functions/getRecommendedGasPrice.js';
 export { getFeeInfoForChain } from './public-functions/getFeeInfoForChain.js';
 export { SetApiOptionsProps, setApiOptions } from './public-functions/setApiOptions.js';
@@ -26,13 +26,13 @@ export { waitForTransaction } from './public-functions/waitForTransaction.js';
 export { getCosmosGasAmountForMessage } from './public-functions/getCosmosGasAmountForMessage.js';
 export { getEVMGasAmountForMessage } from './public-functions/getEvmGasAmountForMessage.js';
 export { validateCosmosGasBalance } from './public-functions/validateCosmosGasBalance.js';
+import './generateApi-C_xgtxrO.js';
 import '@cosmjs/amino';
 import '@cosmjs/proto-signing';
 import '@cosmjs/stargate';
 import 'viem';
 import '@solana/wallet-adapter-base';
 import './apiState-DwZhwVul.js';
-import './generateApi-C_xgtxrO.js';
 
 interface AcknowledgementErrorDetailsJson {
     /** Error code */