@skip-go/client 1.5.1 → 1.5.3-alpha.0

package/dist/cjs/{chunk-N5V3YW5K.cjs → chunk-H2T4LMS2.cjs}

@@ -1,22 +1,22 @@
 'use strict';
 
-var chunkEZGHN6ZL_cjs = require('./chunk-EZGHN6ZL.cjs');
-var chunkKHJQE3DI_cjs = require('./chunk-KHJQE3DI.cjs');
-var chunkOZUCMWNE_cjs = require('./chunk-OZUCMWNE.cjs');
-var chunkERGJBZUC_cjs = require('./chunk-ERGJBZUC.cjs');
+var chunkARCCHERF_cjs = require('./chunk-ARCCHERF.cjs');
+var chunkBCX2D6TE_cjs = require('./chunk-BCX2D6TE.cjs');
+var chunk3NHW3XWK_cjs = require('./chunk-3NHW3XWK.cjs');
+var chunkHFEMNOJS_cjs = require('./chunk-HFEMNOJS.cjs');
 
 // src/public-functions/executeRoute.ts
 var executeRoute = async (options) => {
   const { route, userAddresses, appendCosmosMsgs, timeoutSeconds } = options;
-  const { id: routeId } = chunkKHJQE3DI_cjs.updateRouteDetails({
+  const { id: routeId } = chunkBCX2D6TE_cjs.updateRouteDetails({
     status: "unconfirmed",
     options
   });
-  const addressList = await chunkEZGHN6ZL_cjs.createValidAddressList({
+  const addressList = await chunkARCCHERF_cjs.createValidAddressList({
     userAddresses,
     route
   });
-  const response = await chunkOZUCMWNE_cjs.messages({
+  const response = await chunk3NHW3XWK_cjs.messages({
     timeoutSeconds,
     amountIn: route?.amountIn,
     amountOut: route.estimatedAmountOut || "0",
@@ -27,7 +27,7 @@ var executeRoute = async (options) => {
     operations: route?.operations,
     addressList,
     slippageTolerancePercent: options.slippageTolerancePercent || "1",
-    chainIdsToAffiliates: chunkERGJBZUC_cjs.ApiState.chainIdsToAffiliates,
+    chainIdsToAffiliates: chunkHFEMNOJS_cjs.ApiState.chainIdsToAffiliates,
     postRouteHandler: options.postRouteHandler,
     feePayerAddress: options.svmFeePayer?.address
   });
@@ -43,8 +43,8 @@ var executeRoute = async (options) => {
       }
     });
   }
-  const { transactionDetails, executeTransaction } = await chunkEZGHN6ZL_cjs.executeTransactions({ ...options, routeId, txs: response?.txs });
-  await chunkKHJQE3DI_cjs.executeAndSubscribeToRouteStatus({
+  const { transactionDetails, executeTransaction } = await chunkARCCHERF_cjs.executeTransactions({ ...options, routeId, txs: response?.txs });
+  await chunkBCX2D6TE_cjs.executeAndSubscribeToRouteStatus({
     transactionDetails,
     executeTransaction,
     routeId,

package/dist/cjs/{chunk-ERGJBZUC.cjs → chunk-HFEMNOJS.cjs}

@@ -63,7 +63,13 @@ var createRequestClient = ({ apiUrl, apiKey, apiHeaders }) => {
     if (params && typeof params === "object") {
       Object.entries(params).forEach(([key, value]) => {
         if (value !== void 0 && value !== null) {
-          url.searchParams.append(key, String(value));
+          if (Array.isArray(value)) {
+            value.forEach((item) => {
+              url.searchParams.append(key, String(item));
+            });
+          } else {
+            url.searchParams.append(key, String(value));
+          }
         }
       });
     }
@@ -98,15 +104,14 @@ function createRequest({
   const request = async (options) => {
     const { apiKey, apiUrl, apiHeaders, abortDuplicateRequests, ...requestParams } = options ?? {};
     let fetchClient = ApiState.client;
-    if (apiUrl || apiKey) {
+    if (apiKey || apiUrl || apiHeaders || fetchClient === void 0) {
       fetchClient = createRequestClient({
         apiUrl: apiUrl || "https://api.skip.build",
         apiKey,
         apiHeaders
       });
-    } else {
-      await ApiState.clientInitialized;
     }
+    ApiState.apiCalled = true;
     if (abortDuplicateRequests && controller && !controller?.signal?.aborted) {
       controller?.abort();
     }
@@ -186,23 +191,12 @@ function pollingApi({
 }
 
 // src/state/apiState.ts
-var ApiState = class _ApiState {
+var ApiState = class {
   static client;
   static chainIdsToAffiliates;
   static cumulativeAffiliateFeeBPS = "0";
-  static isInitialized = false;
-  static resolveInitialization;
-  static clientInitialized = new Promise((resolve) => {
-    _ApiState.resolveInitialization = () => {
-      if (!_ApiState.isInitialized) {
-        _ApiState.isInitialized = true;
-        resolve();
-      }
-    };
-  });
-  static setClientInitialized() {
-    _ApiState.resolveInitialization();
-  }
+  static initialized = false;
+  static apiCalled = false;
 };
 
 exports.ApiState = ApiState;

package/dist/cjs/chunk-I6VYDEUV.cjs

@@ -0,0 +1,454 @@
+'use strict';
+
+var chunkWKYP2NMS_cjs = require('./chunk-WKYP2NMS.cjs');
+var chunk7SZZBUBD_cjs = require('./chunk-7SZZBUBD.cjs');
+var chunkQAHHTQ7V_cjs = require('./chunk-QAHHTQ7V.cjs');
+var viem = require('viem');
+var chains = require('viem/chains');
+
+// src/types/swaggerTypesJson.ts
+var AutopilotActionJson = /* @__PURE__ */ ((AutopilotActionJson2) => {
+  AutopilotActionJson2["LIQUID_STAKE"] = "LIQUID_STAKE";
+  AutopilotActionJson2["CLAIM"] = "CLAIM";
+  return AutopilotActionJson2;
+})(AutopilotActionJson || {});
+var AxelarTransferStateJson = /* @__PURE__ */ ((AxelarTransferStateJson2) => {
+  AxelarTransferStateJson2["AXELAR_TRANSFER_UNKNOWN"] = "AXELAR_TRANSFER_UNKNOWN";
+  AxelarTransferStateJson2["AXELAR_TRANSFER_PENDING_CONFIRMATION"] = "AXELAR_TRANSFER_PENDING_CONFIRMATION";
+  AxelarTransferStateJson2["AXELAR_TRANSFER_PENDING_RECEIPT"] = "AXELAR_TRANSFER_PENDING_RECEIPT";
+  AxelarTransferStateJson2["AXELAR_TRANSFER_SUCCESS"] = "AXELAR_TRANSFER_SUCCESS";
+  AxelarTransferStateJson2["AXELAR_TRANSFER_FAILURE"] = "AXELAR_TRANSFER_FAILURE";
+  return AxelarTransferStateJson2;
+})(AxelarTransferStateJson || {});
+var AxelarTransferTypeJson = /* @__PURE__ */ ((AxelarTransferTypeJson2) => {
+  AxelarTransferTypeJson2["AXELAR_TRANSFER_CONTRACT_CALL_WITH_TOKEN"] = "AXELAR_TRANSFER_CONTRACT_CALL_WITH_TOKEN";
+  AxelarTransferTypeJson2["AXELAR_TRANSFER_SEND_TOKEN"] = "AXELAR_TRANSFER_SEND_TOKEN";
+  return AxelarTransferTypeJson2;
+})(AxelarTransferTypeJson || {});
+var CCTPTransferStateJson = /* @__PURE__ */ ((CCTPTransferStateJson2) => {
+  CCTPTransferStateJson2["CCTP_TRANSFER_UNKNOWN"] = "CCTP_TRANSFER_UNKNOWN";
+  CCTPTransferStateJson2["CCTP_TRANSFER_SENT"] = "CCTP_TRANSFER_SENT";
+  CCTPTransferStateJson2["CCTP_TRANSFER_PENDING_CONFIRMATION"] = "CCTP_TRANSFER_PENDING_CONFIRMATION";
+  CCTPTransferStateJson2["CCTP_TRANSFER_CONFIRMED"] = "CCTP_TRANSFER_CONFIRMED";
+  CCTPTransferStateJson2["CCTP_TRANSFER_RECEIVED"] = "CCTP_TRANSFER_RECEIVED";
+  return CCTPTransferStateJson2;
+})(CCTPTransferStateJson || {});
+var StargateTransferStateJson = /* @__PURE__ */ ((StargateTransferStateJson2) => {
+  StargateTransferStateJson2["STARGATE_TRANSFER_UNKNOWN"] = "STARGATE_TRANSFER_UNKNOWN";
+  StargateTransferStateJson2["STARGATE_TRANSFER_SENT"] = "STARGATE_TRANSFER_SENT";
+  StargateTransferStateJson2["STARGATE_TRANSFER_PENDING_CONFIRMATION"] = "STARGATE_TRANSFER_PENDING_CONFIRMATION";
+  StargateTransferStateJson2["STARGATE_TRANSFER_CONFIRMED"] = "STARGATE_TRANSFER_CONFIRMED";
+  StargateTransferStateJson2["STARGATE_TRANSFER_RECEIVED"] = "STARGATE_TRANSFER_RECEIVED";
+  StargateTransferStateJson2["STARGATE_TRANSFER_FAILED"] = "STARGATE_TRANSFER_FAILED";
+  return StargateTransferStateJson2;
+})(StargateTransferStateJson || {});
+var GoFastTransferStateJson = /* @__PURE__ */ ((GoFastTransferStateJson2) => {
+  GoFastTransferStateJson2["GO_FAST_TRANSFER_UNKNOWN"] = "GO_FAST_TRANSFER_UNKNOWN";
+  GoFastTransferStateJson2["GO_FAST_TRANSFER_SENT"] = "GO_FAST_TRANSFER_SENT";
+  GoFastTransferStateJson2["GO_FAST_POST_ACTION_FAILED"] = "GO_FAST_POST_ACTION_FAILED";
+  GoFastTransferStateJson2["GO_FAST_TRANSFER_TIMEOUT"] = "GO_FAST_TRANSFER_TIMEOUT";
+  GoFastTransferStateJson2["GO_FAST_TRANSFER_FILLED"] = "GO_FAST_TRANSFER_FILLED";
+  GoFastTransferStateJson2["GO_FAST_TRANSFER_REFUNDED"] = "GO_FAST_TRANSFER_REFUNDED";
+  return GoFastTransferStateJson2;
+})(GoFastTransferStateJson || {});
+var BridgeTypeJson = /* @__PURE__ */ ((BridgeTypeJson2) => {
+  BridgeTypeJson2["IBC"] = "IBC";
+  BridgeTypeJson2["AXELAR"] = "AXELAR";
+  BridgeTypeJson2["CCTP"] = "CCTP";
+  BridgeTypeJson2["HYPERLANE"] = "HYPERLANE";
+  BridgeTypeJson2["OPINIT"] = "OPINIT";
+  BridgeTypeJson2["GO_FAST"] = "GO_FAST";
+  BridgeTypeJson2["STARGATE"] = "STARGATE";
+  BridgeTypeJson2["LAYER_ZERO"] = "LAYER_ZERO";
+  BridgeTypeJson2["EUREKA"] = "EUREKA";
+  return BridgeTypeJson2;
+})(BridgeTypeJson || {});
+var ChainTypeJson = /* @__PURE__ */ ((ChainTypeJson2) => {
+  ChainTypeJson2["Cosmos"] = "cosmos";
+  ChainTypeJson2["Evm"] = "evm";
+  ChainTypeJson2["Svm"] = "svm";
+  return ChainTypeJson2;
+})(ChainTypeJson || {});
+var ContractCallWithTokenErrorTypeJson = /* @__PURE__ */ ((ContractCallWithTokenErrorTypeJson2) => {
+  ContractCallWithTokenErrorTypeJson2["CONTRACT_CALL_WITH_TOKEN_EXECUTION_ERROR"] = "CONTRACT_CALL_WITH_TOKEN_EXECUTION_ERROR";
+  return ContractCallWithTokenErrorTypeJson2;
+})(ContractCallWithTokenErrorTypeJson || {});
+var HyperlaneTransferStateJson = /* @__PURE__ */ ((HyperlaneTransferStateJson2) => {
+  HyperlaneTransferStateJson2["HYPERLANE_TRANSFER_UNKNOWN"] = "HYPERLANE_TRANSFER_UNKNOWN";
+  HyperlaneTransferStateJson2["HYPERLANE_TRANSFER_SENT"] = "HYPERLANE_TRANSFER_SENT";
+  HyperlaneTransferStateJson2["HYPERLANE_TRANSFER_FAILED"] = "HYPERLANE_TRANSFER_FAILED";
+  HyperlaneTransferStateJson2["HYPERLANE_TRANSFER_RECEIVED"] = "HYPERLANE_TRANSFER_RECEIVED";
+  return HyperlaneTransferStateJson2;
+})(HyperlaneTransferStateJson || {});
+var PacketErrorTypeJson = /* @__PURE__ */ ((PacketErrorTypeJson2) => {
+  PacketErrorTypeJson2["PACKET_ERROR_UNKNOWN"] = "PACKET_ERROR_UNKNOWN";
+  PacketErrorTypeJson2["PACKET_ERROR_ACKNOWLEDGEMENT"] = "PACKET_ERROR_ACKNOWLEDGEMENT";
+  PacketErrorTypeJson2["PACKET_ERROR_TIMEOUT"] = "PACKET_ERROR_TIMEOUT";
+  return PacketErrorTypeJson2;
+})(PacketErrorTypeJson || {});
+var ReasonJson = /* @__PURE__ */ ((ReasonJson2) => {
+  ReasonJson2["UNKNOWN"] = "UNKNOWN";
+  ReasonJson2["MOST_LIQUID"] = "MOST_LIQUID";
+  ReasonJson2["BASE_TOKEN"] = "BASE_TOKEN";
+  ReasonJson2["DIRECT"] = "DIRECT";
+  return ReasonJson2;
+})(ReasonJson || {});
+var RoutePriceWarningTypeJson = /* @__PURE__ */ ((RoutePriceWarningTypeJson2) => {
+  RoutePriceWarningTypeJson2["LOW_INFO_WARNING"] = "LOW_INFO_WARNING";
+  RoutePriceWarningTypeJson2["BAD_PRICE_WARNING"] = "BAD_PRICE_WARNING";
+  return RoutePriceWarningTypeJson2;
+})(RoutePriceWarningTypeJson || {});
+var SendTokenErrorTypeJson = /* @__PURE__ */ ((SendTokenErrorTypeJson2) => {
+  SendTokenErrorTypeJson2["SEND_TOKEN_EXECUTION_ERROR"] = "SEND_TOKEN_EXECUTION_ERROR";
+  return SendTokenErrorTypeJson2;
+})(SendTokenErrorTypeJson || {});
+var StatusErrorTypeJson = /* @__PURE__ */ ((StatusErrorTypeJson2) => {
+  StatusErrorTypeJson2["STATUS_ERROR_UNKNOWN"] = "STATUS_ERROR_UNKNOWN";
+  StatusErrorTypeJson2["STATUS_ERROR_TRANSACTION_EXECUTION"] = "STATUS_ERROR_TRANSACTION_EXECUTION";
+  StatusErrorTypeJson2["STATUS_ERROR_INDEXING"] = "STATUS_ERROR_INDEXING";
+  StatusErrorTypeJson2["STATUS_ERROR_TRANSFER"] = "STATUS_ERROR_TRANSFER";
+  return StatusErrorTypeJson2;
+})(StatusErrorTypeJson || {});
+var TransactionStateJson = /* @__PURE__ */ ((TransactionStateJson2) => {
+  TransactionStateJson2["STATE_SUBMITTED"] = "STATE_SUBMITTED";
+  TransactionStateJson2["STATE_PENDING"] = "STATE_PENDING";
+  TransactionStateJson2["STATE_ABANDONED"] = "STATE_ABANDONED";
+  TransactionStateJson2["STATE_COMPLETED_SUCCESS"] = "STATE_COMPLETED_SUCCESS";
+  TransactionStateJson2["STATE_COMPLETED_ERROR"] = "STATE_COMPLETED_ERROR";
+  TransactionStateJson2["STATE_PENDING_ERROR"] = "STATE_PENDING_ERROR";
+  return TransactionStateJson2;
+})(TransactionStateJson || {});
+var OPInitTransferStateJson = /* @__PURE__ */ ((OPInitTransferStateJson2) => {
+  OPInitTransferStateJson2["OPINIT_TRANSFER_UNKNOWN"] = "OPINIT_TRANSFER_UNKNOWN";
+  OPInitTransferStateJson2["OPINIT_TRANSFER_SENT"] = "OPINIT_TRANSFER_SENT";
+  OPInitTransferStateJson2["OPINIT_TRANSFER_RECEIVED"] = "OPINIT_TRANSFER_RECEIVED";
+  return OPInitTransferStateJson2;
+})(OPInitTransferStateJson || {});
+var LayerZeroTransferStateJson = /* @__PURE__ */ ((LayerZeroTransferStateJson2) => {
+  LayerZeroTransferStateJson2["LAYER_ZERO_TRANSFER_UNKNOWN"] = "LAYER_ZERO_TRANSFER_UNKNOWN";
+  LayerZeroTransferStateJson2["LAYER_ZERO_TRANSFER_SENT"] = "LAYER_ZERO_TRANSFER_SENT";
+  LayerZeroTransferStateJson2["LAYER_ZERO_TRANSFER_WAITING_FOR_COMPOSE"] = "LAYER_ZERO_TRANSFER_WAITING_FOR_COMPOSE";
+  LayerZeroTransferStateJson2["LAYER_ZERO_TRANSFER_RECEIVED"] = "LAYER_ZERO_TRANSFER_RECEIVED";
+  LayerZeroTransferStateJson2["LAYER_ZERO_TRANSFER_FAILED"] = "LAYER_ZERO_TRANSFER_FAILED";
+  return LayerZeroTransferStateJson2;
+})(LayerZeroTransferStateJson || {});
+var TransferStateJson = /* @__PURE__ */ ((TransferStateJson2) => {
+  TransferStateJson2["TRANSFER_UNKNOWN"] = "TRANSFER_UNKNOWN";
+  TransferStateJson2["TRANSFER_PENDING"] = "TRANSFER_PENDING";
+  TransferStateJson2["TRANSFER_RECEIVED"] = "TRANSFER_RECEIVED";
+  TransferStateJson2["TRANSFER_SUCCESS"] = "TRANSFER_SUCCESS";
+  TransferStateJson2["TRANSFER_FAILURE"] = "TRANSFER_FAILURE";
+  return TransferStateJson2;
+})(TransferStateJson || {});
+var FeeTypeJson = /* @__PURE__ */ ((FeeTypeJson2) => {
+  FeeTypeJson2["SMART_RELAY"] = "SMART_RELAY";
+  return FeeTypeJson2;
+})(FeeTypeJson || {});
+var FeeBehaviorJson = /* @__PURE__ */ ((FeeBehaviorJson2) => {
+  FeeBehaviorJson2["FEE_BEHAVIOR_DEDUCTED"] = "FEE_BEHAVIOR_DEDUCTED";
+  FeeBehaviorJson2["FEE_BEHAVIOR_ADDITIONAL"] = "FEE_BEHAVIOR_ADDITIONAL";
+  return FeeBehaviorJson2;
+})(FeeBehaviorJson || {});
+
+// src/utils/coingecko.ts
+var getUsdPrice = async (coingeckoId) => {
+  try {
+    const response = await fetch(`https://api.coingecko.com/api/v3/simple/price?ids=${coingeckoId}&vs_currencies=usd`);
+    const data = await response.json();
+    return data?.[coingeckoId]?.usd;
+  } catch (error) {
+    return void 0;
+  }
+};
+
+// src/utils/numbers.ts
+var convertHumanReadableAmountToCryptoAmount = (humanReadableAmount, decimals) => {
+  const cryptoAmount = new chunkWKYP2NMS_cjs.bignumber_default(humanReadableAmount).shiftedBy(decimals);
+  return cryptoAmount.toFixed(0);
+};
+var formaTestnet = viem.defineChain({
+  id: 984123,
+  name: "Forma Testnet",
+  nativeCurrency: {
+    name: "TIA",
+    symbol: "TIA",
+    decimals: 18
+  },
+  rpcUrls: {
+    default: {
+      http: ["https://rpc.sketchpad-1.forma.art"]
+    }
+  },
+  blockExplorers: {
+    default: {
+      name: "Forma Explorer",
+      url: "https://explorer.sketchpad-1.forma.art"
+    }
+  },
+  testnet: true
+});
+var evmChains = [
+  chains.arbitrum,
+  chains.avalanche,
+  chains.base,
+  chains.bsc,
+  chains.celo,
+  chains.fantom,
+  chains.filecoin,
+  chains.kava,
+  chains.linea,
+  chains.mainnet,
+  chains.manta,
+  chains.moonbeam,
+  chains.optimism,
+  chains.polygon,
+  chains.polygonMumbai,
+  chains.sepolia,
+  chains.avalancheFuji,
+  chains.baseSepolia,
+  chains.optimismSepolia,
+  chains.arbitrumSepolia,
+  chains.blast,
+  chains.blastSepolia,
+  chains.forma,
+  formaTestnet,
+  chains.sei,
+  chains.bscTestnet,
+  chains.fantomTestnet,
+  chains.kavaTestnet,
+  chains.lineaSepolia,
+  chains.mantaSepoliaTestnet
+];
+
+// src/utils/array.ts
+function isSubset(arrayA, arrayB) {
+  const setA = new Set(arrayA);
+  return arrayB.every((item) => setA.has(item));
+}
+
+// src/public-functions/getRouteWithGasOnReceive.ts
+var GAS_ON_RECEIVE_AMOUNT_USD = {
+  ["cosmos" /* Cosmos */]: 0.1,
+  evm_l2: 2
+};
+var DISABLED_SOURCE_CHAINIDS = ["1", "11155111"];
+var DISABLED_DESTINATION_CHAINIDS = ["solana", "solana-devnet"];
+var getRouteWithGasOnReceive = async (props) => {
+  const originalRoute = props.routeResponse;
+  try {
+    if (DISABLED_SOURCE_CHAINIDS.includes(originalRoute.sourceAssetChainId)) {
+      throw new Error(
+        `Routes from ${originalRoute.sourceAssetChainId} are not supported`
+      );
+    }
+    if (DISABLED_DESTINATION_CHAINIDS.includes(originalRoute.destAssetChainId)) {
+      throw new Error(
+        `Routes to ${originalRoute.destAssetChainId} are not supported`
+      );
+    }
+    const skipChains = chunkQAHHTQ7V_cjs.ClientState.skipChains ? chunkQAHHTQ7V_cjs.ClientState.skipChains : await chunkQAHHTQ7V_cjs.chains({
+      includeEvm: true,
+      includeSvm: true,
+      chainIds: [
+        originalRoute.sourceAssetChainId,
+        originalRoute.destAssetChainId
+      ],
+      onlyTestnets: props.onlyTestnets
+    });
+    const skipAssets = chunkQAHHTQ7V_cjs.ClientState.skipAssets ? chunkQAHHTQ7V_cjs.ClientState.skipAssets : await chunkQAHHTQ7V_cjs.assets({
+      chainIds: [
+        originalRoute.sourceAssetChainId,
+        originalRoute.destAssetChainId
+      ],
+      includeEvmAssets: true,
+      includeSvmAssets: true,
+      onlyTestnets: props.onlyTestnets
+    });
+    const destinationChain = skipChains?.find(
+      (chain) => chain.chainId === originalRoute.destAssetChainId
+    );
+    if (destinationChain?.feeAssets.map((i) => i.denom).includes(originalRoute.destAssetDenom)) {
+      throw new Error(
+        "Destination asset is already a fee asset on the destination chain"
+      );
+    }
+    const gasOnReceiveAmount = await getGasOnReceiveAmount({
+      destinationChain,
+      skipAssets,
+      sourceAsset: skipAssets?.[originalRoute.sourceAssetChainId]?.find(
+        (i) => i.denom === originalRoute.sourceAssetDenom
+      )
+    });
+    if (!gasOnReceiveAmount || gasOnReceiveAmount.length === 0) {
+      throw new Error(
+        "No gas on receive amount found for the destination chain"
+      );
+    }
+    const splitDenoms = chunkArray(gasOnReceiveAmount, 3);
+    let gasRoute;
+    for (const chunk of splitDenoms) {
+      const feeAssetRoutes = chunk.map(
+        async ({ amountOut, denom, amountIn }) => {
+          try {
+            const res = await chunk7SZZBUBD_cjs.route({
+              ...props.routeRequest,
+              destAssetDenom: denom,
+              amountIn,
+              amountOut,
+              allowMultiTx: false
+            });
+            return res;
+          } catch (_e) {
+            return null;
+          }
+        }
+      );
+      const result = await Promise.all(feeAssetRoutes);
+      const _gasRoute = result.find((result2) => result2?.usdAmountOut);
+      if (_gasRoute?.usdAmountOut) {
+        gasRoute = _gasRoute;
+        break;
+      }
+    }
+    if (!gasRoute) {
+      throw new Error(
+        "No gas route found for the destination chain with the provided assets"
+      );
+    }
+    const mainRouteAmountIn = chunkWKYP2NMS_cjs.bignumber_default(originalRoute?.amountIn ?? 0).minus(chunkWKYP2NMS_cjs.bignumber_default(gasRoute.amountIn ?? 0)).toString();
+    const mainRoute = await chunk7SZZBUBD_cjs.route({
+      ...props.routeRequest,
+      amountIn: mainRouteAmountIn,
+      amountOut: void 0
+    });
+    if (!mainRoute) {
+      throw new Error("No main route found with the provided assets");
+    }
+    if (originalRoute.txsRequired !== mainRoute.txsRequired || !isSubset(
+      originalRoute?.requiredChainAddresses,
+      mainRoute.requiredChainAddresses
+    )) {
+      throw new Error("Main route does not match the original route");
+    }
+    return {
+      mainRoute,
+      gasRoute
+    };
+  } catch (error) {
+    return {
+      mainRoute: originalRoute,
+      gasRoute: void 0
+    };
+  }
+};
+var getGasOnReceiveAmount = async ({
+  destinationChain,
+  skipAssets,
+  sourceAsset
+}) => {
+  switch (destinationChain?.chainType) {
+    case "cosmos" /* Cosmos */: {
+      const usdPrice = sourceAsset?.coingeckoId ? await getUsdPrice(sourceAsset.coingeckoId) : void 0;
+      return destinationChain.feeAssets.map((asset) => {
+        const destinationAsset = skipAssets?.[destinationChain.chainId]?.find(
+          (i) => i.denom === asset.denom
+        );
+        const gasPrice = asset.gasPrice?.average ?? asset.gasPrice?.high ?? asset.gasPrice?.low;
+        if (!gasPrice || Number(gasPrice) === 0) {
+          if (!usdPrice || !sourceAsset?.decimals) return;
+          const gasOnReceiveAmountUsd = GAS_ON_RECEIVE_AMOUNT_USD["cosmos"];
+          const amountIn = chunkWKYP2NMS_cjs.bignumber_default(gasOnReceiveAmountUsd).multipliedBy(usdPrice).toString();
+          return {
+            amountIn: convertHumanReadableAmountToCryptoAmount(
+              amountIn,
+              sourceAsset.decimals
+            ),
+            amountOut: void 0,
+            denom: asset.denom
+          };
+        }
+        return {
+          amountIn: void 0,
+          amountOut: gasPrice && destinationAsset?.decimals ? convertHumanReadableAmountToCryptoAmount(
+            chunkWKYP2NMS_cjs.bignumber_default(gasPrice).multipliedBy(3).toNumber(),
+            destinationAsset.decimals
+          ) : void 0,
+          denom: asset.denom
+        };
+      }).filter(Boolean);
+    }
+    case "evm" /* Evm */: {
+      const sourceAssetPrice = sourceAsset?.coingeckoId ? await getUsdPrice(sourceAsset?.coingeckoId) : void 0;
+      const destinationAsset = skipAssets?.[destinationChain.chainId]?.find(
+        (i) => i.denom.includes("-native")
+      );
+      if (!sourceAssetPrice) {
+        const chain = evmChains.find(
+          (chain2) => chain2.id === Number(destinationChain?.chainId)
+        );
+        const client = viem.createPublicClient({
+          chain,
+          transport: viem.fallback([
+            viem.http("https://ethereum.publicnode.com"),
+            viem.http("https://rpc.ankr.com/eth"),
+            viem.http("https://cloudflare-eth.com")
+          ])
+        });
+        const fees = await client.estimateFeesPerGas();
+        return [
+          {
+            amountIn: void 0,
+            amountOut: chunkWKYP2NMS_cjs.bignumber_default(15e4).multipliedBy(fees.maxFeePerGas.toString()).multipliedBy(3).toString(),
+            denom: destinationAsset?.denom
+          }
+        ];
+      }
+      const gasPrice = chunkWKYP2NMS_cjs.bignumber_default(GAS_ON_RECEIVE_AMOUNT_USD["evm_l2"]).dividedBy(
+        sourceAssetPrice
+      ).toString();
+      return [
+        {
+          amountOut: void 0,
+          amountIn: sourceAsset?.decimals ? convertHumanReadableAmountToCryptoAmount(
+            gasPrice,
+            sourceAsset.decimals
+          ) : void 0,
+          denom: destinationAsset?.denom
+        }
+      ];
+    }
+    default: {
+      return;
+    }
+  }
+};
+var chunkArray = (arr, size = 3) => {
+  const result = [];
+  for (let i = 0; i < arr.length; i += size) {
+    result.push(arr.slice(i, i + size));
+  }
+  return result;
+};
+
+exports.AutopilotActionJson = AutopilotActionJson;
+exports.AxelarTransferStateJson = AxelarTransferStateJson;
+exports.AxelarTransferTypeJson = AxelarTransferTypeJson;
+exports.BridgeTypeJson = BridgeTypeJson;
+exports.CCTPTransferStateJson = CCTPTransferStateJson;
+exports.ChainTypeJson = ChainTypeJson;
+exports.ContractCallWithTokenErrorTypeJson = ContractCallWithTokenErrorTypeJson;
+exports.FeeBehaviorJson = FeeBehaviorJson;
+exports.FeeTypeJson = FeeTypeJson;
+exports.GoFastTransferStateJson = GoFastTransferStateJson;
+exports.HyperlaneTransferStateJson = HyperlaneTransferStateJson;
+exports.LayerZeroTransferStateJson = LayerZeroTransferStateJson;
+exports.OPInitTransferStateJson = OPInitTransferStateJson;
+exports.PacketErrorTypeJson = PacketErrorTypeJson;
+exports.ReasonJson = ReasonJson;
+exports.RoutePriceWarningTypeJson = RoutePriceWarningTypeJson;
+exports.SendTokenErrorTypeJson = SendTokenErrorTypeJson;
+exports.StargateTransferStateJson = StargateTransferStateJson;
+exports.StatusErrorTypeJson = StatusErrorTypeJson;
+exports.TransactionStateJson = TransactionStateJson;
+exports.TransferStateJson = TransferStateJson;
+exports.getRouteWithGasOnReceive = getRouteWithGasOnReceive;

package/dist/cjs/{chunk-RVXCF6AL.cjs → chunk-J7HZ6VJE.cjs}

@@ -2,7 +2,7 @@
 
 var chunk3M7YYWGL_cjs = require('./chunk-3M7YYWGL.cjs');
 var chunkKSJ5QYMR_cjs = require('./chunk-KSJ5QYMR.cjs');
-var chunkN4UW74AG_cjs = require('./chunk-N4UW74AG.cjs');
+var chunkQAHHTQ7V_cjs = require('./chunk-QAHHTQ7V.cjs');
 var stargate = require('@cosmjs/stargate');
 var utils = require('@cosmjs/utils');
 var binary_js = require('cosmjs-types/binary.js');
@@ -322,11 +322,11 @@ var accountEthParser = (ethAccount, pubKeyTypeUrl = "/injective.crypto.v1beta1.e
 
 // src/private-functions/getRpcEndpointForChain.ts
 var getRpcEndpointForChain = async (chainId) => {
-  if (chunkN4UW74AG_cjs.ClientState.endpointOptions.getRpcEndpointForChain) {
-    return chunkN4UW74AG_cjs.ClientState.endpointOptions.getRpcEndpointForChain(chainId);
+  if (chunkQAHHTQ7V_cjs.ClientState.endpointOptions.getRpcEndpointForChain) {
+    return chunkQAHHTQ7V_cjs.ClientState.endpointOptions.getRpcEndpointForChain(chainId);
   }
-  if (chunkN4UW74AG_cjs.ClientState.endpointOptions.endpoints && chunkN4UW74AG_cjs.ClientState.endpointOptions.endpoints[chainId]) {
-    const endpointOptions = chunkN4UW74AG_cjs.ClientState.endpointOptions.endpoints[chainId];
+  if (chunkQAHHTQ7V_cjs.ClientState.endpointOptions.endpoints && chunkQAHHTQ7V_cjs.ClientState.endpointOptions.endpoints[chainId]) {
+    const endpointOptions = chunkQAHHTQ7V_cjs.ClientState.endpointOptions.endpoints[chainId];
     if (endpointOptions?.rpc) {
       return endpointOptions.rpc;
     }
@@ -361,19 +361,19 @@ var getSigningStargateClient = async ({
   if (!getOfflineSigner) {
     throw new Error("'getCosmosSigner' is not provided or configured in skip router");
   }
-  if (!chunkN4UW74AG_cjs.ClientState.signingStargateClientByChainId?.[chainId]) {
+  if (!chunkQAHHTQ7V_cjs.ClientState.signingStargateClientByChainId?.[chainId]) {
     const [signer, endpoint] = await Promise.all([
       getOfflineSigner(chainId),
       getRpcEndpointForChain(chainId)
     ]);
-    chunkN4UW74AG_cjs.ClientState.signingStargateClientByChainId[chainId] = await stargate.SigningStargateClient.connectWithSigner(endpoint, signer, {
-      aminoTypes: chunkN4UW74AG_cjs.ClientState.aminoTypes,
-      registry: chunkN4UW74AG_cjs.ClientState.registry,
+    chunkQAHHTQ7V_cjs.ClientState.signingStargateClientByChainId[chainId] = await stargate.SigningStargateClient.connectWithSigner(endpoint, signer, {
+      aminoTypes: chunkQAHHTQ7V_cjs.ClientState.aminoTypes,
+      registry: chunkQAHHTQ7V_cjs.ClientState.registry,
       accountParser
     });
   }
   return {
-    stargateClient: chunkN4UW74AG_cjs.ClientState.signingStargateClientByChainId[chainId],
+    stargateClient: chunkQAHHTQ7V_cjs.ClientState.signingStargateClientByChainId[chainId],
     signer: await getOfflineSigner(chainId)
   };
 };

package/dist/cjs/{chunk-QPM7H2YL.cjs → chunk-JWWJIJUE.cjs}

@@ -1,9 +1,9 @@
 'use strict';
 
-var chunkERGJBZUC_cjs = require('./chunk-ERGJBZUC.cjs');
+var chunkHFEMNOJS_cjs = require('./chunk-HFEMNOJS.cjs');
 
 // src/api/postTransactionStatus.ts
-var transactionStatus = chunkERGJBZUC_cjs.pollingApi({
+var transactionStatus = chunkHFEMNOJS_cjs.pollingApi({
   methodName: "status",
   path: "v2/tx/status",
   method: "get",

package/dist/cjs/{chunk-RCGCQD6T.cjs → chunk-KWH6S7PB.cjs}

@@ -1,20 +1,22 @@
 'use strict';
 
-var chunkERGJBZUC_cjs = require('./chunk-ERGJBZUC.cjs');
+var chunkHFEMNOJS_cjs = require('./chunk-HFEMNOJS.cjs');
 
 // src/public-functions/setApiOptions.ts
 var setApiOptions = (options = {}) => {
-  chunkERGJBZUC_cjs.ApiState.client = chunkERGJBZUC_cjs.createRequestClient({
+  chunkHFEMNOJS_cjs.ApiState.client = chunkHFEMNOJS_cjs.createRequestClient({
     apiUrl: options.apiUrl || "https://api.skip.build",
     apiKey: options.apiKey,
     apiHeaders: options.apiHeaders
   });
-  chunkERGJBZUC_cjs.ApiState.setClientInitialized();
   if (options.chainIdsToAffiliates) {
-    chunkERGJBZUC_cjs.ApiState.cumulativeAffiliateFeeBPS = validateChainIdsToAffiliates(options.chainIdsToAffiliates);
-    chunkERGJBZUC_cjs.ApiState.chainIdsToAffiliates = options.chainIdsToAffiliates;
+    chunkHFEMNOJS_cjs.ApiState.cumulativeAffiliateFeeBPS = validateChainIdsToAffiliates(options.chainIdsToAffiliates);
+    chunkHFEMNOJS_cjs.ApiState.chainIdsToAffiliates = options.chainIdsToAffiliates;
   }
-  return chunkERGJBZUC_cjs.ApiState.clientInitialized;
+  if (!options.allowOptionsUpdateAfterApiCall && chunkHFEMNOJS_cjs.ApiState.apiCalled && !chunkHFEMNOJS_cjs.ApiState.initialized) {
+    throw new Error("setApiOptions must be called before an api request is made");
+  }
+  chunkHFEMNOJS_cjs.ApiState.initialized = true;
 };
 function validateChainIdsToAffiliates(chainIdsToAffiliates) {
   const affiliatesArray = Object.values(chainIdsToAffiliates).map((chain) => chain.affiliates).filter((a) => a !== void 0);