@skip-go/client 1.5.2 → 1.5.3-alpha.1

package/dist/cjs/chunk-KZOSEIWH.cjs

@@ -1,10 +0,0 @@
-'use strict';
-
-// src/constants/constants.ts
-var DEFAULT_GAS_DENOM_OVERRIDES = {
-  "noble-1": "uusdc"
-};
-var GAS_STATION_CHAIN_IDS = ["bbn-test-5", "bbn-1"];
-
-exports.DEFAULT_GAS_DENOM_OVERRIDES = DEFAULT_GAS_DENOM_OVERRIDES;
-exports.GAS_STATION_CHAIN_IDS = GAS_STATION_CHAIN_IDS;

package/dist/cjs/chunk-Q33F7U2Y.cjs

@@ -1,55 +0,0 @@
-'use strict';
-
-var chunkHEYFLFKD_cjs = require('./chunk-HEYFLFKD.cjs');
-var chunk7D433NQ5_cjs = require('./chunk-7D433NQ5.cjs');
-var chunkXPQRSO4J_cjs = require('./chunk-XPQRSO4J.cjs');
-var chunkMMGVGXA5_cjs = require('./chunk-MMGVGXA5.cjs');
-
-// src/public-functions/executeRoute.ts
-var executeRoute = async (options) => {
-  const { route, userAddresses, appendCosmosMsgs, timeoutSeconds } = options;
-  const { id: routeId } = chunk7D433NQ5_cjs.updateRouteDetails({
-    status: "unconfirmed",
-    options
-  });
-  const addressList = await chunkHEYFLFKD_cjs.createValidAddressList({
-    userAddresses,
-    route
-  });
-  const response = await chunkXPQRSO4J_cjs.messages({
-    timeoutSeconds,
-    amountIn: route?.amountIn,
-    amountOut: route.estimatedAmountOut || "0",
-    sourceAssetChainId: route?.sourceAssetChainId,
-    sourceAssetDenom: route?.sourceAssetDenom,
-    destAssetChainId: route?.destAssetChainId,
-    destAssetDenom: route?.destAssetDenom,
-    operations: route?.operations,
-    addressList,
-    slippageTolerancePercent: options.slippageTolerancePercent || "1",
-    chainIdsToAffiliates: chunkMMGVGXA5_cjs.ApiState.chainIdsToAffiliates,
-    postRouteHandler: options.postRouteHandler,
-    feePayerAddress: options.svmFeePayer?.address
-  });
-  if (appendCosmosMsgs) {
-    Object.entries(appendCosmosMsgs).forEach(([chainId, msgs]) => {
-      const txIndex = response?.txs?.findIndex(
-        (tx2) => "cosmosTx" in tx2 && tx2.cosmosTx.chainId === chainId
-      );
-      if (txIndex === void 0 || txIndex === -1) return;
-      const tx = response?.txs?.[txIndex];
-      if (tx && "cosmosTx" in tx) {
-        tx.cosmosTx.msgs?.unshift(...msgs);
-      }
-    });
-  }
-  const { transactionDetails, executeTransaction } = await chunkHEYFLFKD_cjs.executeTransactions({ ...options, routeId, txs: response?.txs });
-  await chunk7D433NQ5_cjs.executeAndSubscribeToRouteStatus({
-    transactionDetails,
-    executeTransaction,
-    routeId,
-    options
-  });
-};
-
-exports.executeRoute = executeRoute;

package/dist/esm/chunk-4YTLUDRU.js

@@ -1,212 +0,0 @@
-import { createValidAddressList, executeTransactions } from './chunk-JQOJIEZA.js';
-import { updateRouteDetails, executeAndSubscribeToRouteStatus } from './chunk-WSAZDCXR.js';
-import { messages } from './chunk-45B6E7AT.js';
-import { trackTransaction } from './chunk-6HKZYODA.js';
-import { ApiState } from './chunk-X3PQKUOS.js';
-import 'uuid';
-
-var executeMultipleRoutes = async (options) => {
-  const {
-    route,
-    userAddresses,
-    appendCosmosMsgs,
-    postRouteHandler,
-    slippageTolerancePercent,
-    ...restOptions
-  } = options;
-  const addressList = {};
-  for (const [routeKey, routeValue] of Object.entries(route)) {
-    const _userAddresses = userAddresses[routeKey];
-    if (_userAddresses === void 0) {
-      throw new Error(
-        `executeMultipleRoutes error: no user addresses found for route: ${routeKey}`
-      );
-    }
-    const routeAddressList = await createValidAddressList({
-      userAddresses: _userAddresses,
-      route: routeValue
-    });
-    addressList[routeKey] = routeAddressList;
-  }
-  const msgsResponses = await Promise.all(
-    Object.entries(route).map(async ([routeKey, routeValue]) => {
-      const routeAddressList = addressList[routeKey];
-      if (routeAddressList === void 0) {
-        throw new Error(
-          `executeMultipleRoutes error: address list not found for route ${routeKey}`
-        );
-      }
-      return await messages({
-        timeoutSeconds: options.timeoutSeconds,
-        amountIn: routeValue?.amountIn,
-        amountOut: routeValue.estimatedAmountOut || "0",
-        sourceAssetChainId: routeValue?.sourceAssetChainId,
-        sourceAssetDenom: routeValue?.sourceAssetDenom,
-        destAssetChainId: routeValue?.destAssetChainId,
-        destAssetDenom: routeValue?.destAssetDenom,
-        operations: routeValue?.operations,
-        addressList: routeAddressList,
-        slippageTolerancePercent: slippageTolerancePercent?.[routeKey] || "1",
-        chainIdsToAffiliates: ApiState.chainIdsToAffiliates,
-        postRouteHandler: postRouteHandler?.[routeKey],
-        feePayerAddress: options.svmFeePayer?.address
-      });
-    })
-  );
-  let msgsRecord = {};
-  msgsResponses.forEach((msg, index2) => {
-    const routeKey = Object.keys(route)[index2];
-    if (!routeKey) {
-      throw new Error(
-        `executeMultipleRoutes error: route key not found for index ${index2}`
-      );
-    }
-    const addedCosmosMsgs = appendCosmosMsgs?.[routeKey];
-    if (addedCosmosMsgs) {
-      Object.entries(addedCosmosMsgs).forEach(([chainId, msgs]) => {
-        const txIndex = msg?.txs?.findIndex(
-          (tx2) => "cosmosTx" in tx2 && tx2.cosmosTx.chainId === chainId
-        );
-        if (txIndex === void 0 || txIndex === -1) return;
-        const tx = msg?.txs?.[txIndex];
-        if (tx && "cosmosTx" in tx) {
-          tx.cosmosTx.msgs?.unshift(...msgs);
-        }
-      });
-    }
-    msgsRecord[routeKey] = msg;
-  });
-  let transferIndexToRouteKey = void 0;
-  const cosmosTxIndex0Map = /* @__PURE__ */ new Map();
-  let transferIndex = 0;
-  for (const [routeKey, msgs] of Object.entries(msgsRecord)) {
-    const firstTx = msgs?.txs?.[0];
-    if (firstTx && "cosmosTx" in firstTx) {
-      const { chainId, msgs: firstTxMsgs } = firstTx.cosmosTx;
-      if (!transferIndexToRouteKey) {
-        transferIndexToRouteKey = {};
-      }
-      transferIndexToRouteKey[transferIndex] = routeKey;
-      transferIndex++;
-      if (!cosmosTxIndex0Map.has(chainId)) {
-        cosmosTxIndex0Map.set(chainId, {
-          routeKey,
-          firstCosmosTx: firstTx.cosmosTx
-        });
-      } else {
-        const existing = cosmosTxIndex0Map.get(chainId);
-        if (existing && firstTxMsgs) {
-          const modifyTarget = msgsRecord[existing.routeKey]?.txs?.[0];
-          if (modifyTarget && "cosmosTx" in modifyTarget) {
-            modifyTarget.cosmosTx.msgs?.push(...firstTxMsgs);
-            msgsRecord[routeKey]?.txs?.shift();
-          }
-        }
-      }
-    }
-  }
-  Object.entries(msgsRecord).forEach(([routeKey, msgs]) => {
-    if (msgs?.txs?.length === 0) {
-      delete msgsRecord[routeKey];
-    }
-  });
-  let mainRouteId = void 0;
-  let msgsRecordIndexToRouteId = {};
-  let index = 0;
-  const transactionDetailsList = {};
-  const executeTransactionList = {};
-  const mergedMainAndSecondaryRoutes = Object.entries(msgsRecord).length !== Object.entries(route).length;
-  for (const [routeKey, msgsResponse] of Object.entries(msgsRecord)) {
-    const { id: routeId } = updateRouteDetails({
-      status: "unconfirmed",
-      options: {
-        route: route[routeKey],
-        ...restOptions
-      },
-      mainRouteId,
-      transferIndexToRouteKey
-    });
-    msgsRecordIndexToRouteId[index] = routeId;
-    if (routeKey === "mainRoute") {
-      mainRouteId = routeId;
-    }
-    const { transactionDetails, executeTransaction: _executeTransaction } = await executeTransactions({
-      ...restOptions,
-      routeId,
-      txs: msgsResponse?.txs,
-      route: route[routeKey],
-      userAddresses: userAddresses[routeKey],
-      isMultiRoutes: true
-    });
-    const executeTransaction = async (index2) => {
-      const txResult = await _executeTransaction(index2);
-      if (routeKey !== "mainRoute" || mergedMainAndSecondaryRoutes) {
-        const relatedRoutes = Object.entries(route).filter(([key]) => key !== "mainRoute").map(([key, route2]) => ({ route: route2, routeKey: key, status: "pending" }));
-        updateRouteDetails({
-          options: {
-            route: route[routeKey],
-            ...restOptions
-          },
-          routeId: mainRouteId,
-          transferIndexToRouteKey,
-          relatedRoutes
-        });
-      }
-      return txResult;
-    };
-    if (transactionDetails[0]?.chainType === "evm" /* Evm */) {
-      for (const [index2, transactionDetail] of transactionDetails.entries()) {
-        const txResult = await executeTransaction(index2);
-        if (txResult.txHash) {
-          const trackResponse = await trackTransaction({
-            chainId: transactionDetail.chainId,
-            txHash: txResult.txHash,
-            ...options.trackTxPollingOptions
-          });
-          await options?.onTransactionTracked?.({
-            txHash: txResult.txHash,
-            chainId: transactionDetail.chainId,
-            explorerLink: trackResponse.explorerLink
-          });
-          transactionDetail.txHash = txResult.txHash;
-          transactionDetail.explorerLink = trackResponse.explorerLink;
-        }
-      }
-    } else {
-      executeTransactionList[index] = executeTransaction;
-    }
-    transactionDetailsList[index] = transactionDetails;
-    index++;
-  }
-  await Promise.all(
-    Object.entries(msgsRecord).map(([routeKey, msgsResponse], index2) => {
-      return executeAndSubscribeToRouteStatus({
-        transactionDetails: transactionDetailsList[index2],
-        executeTransaction: executeTransactionList[index2],
-        routeId: msgsRecordIndexToRouteId[index2],
-        options: {
-          route: route[routeKey],
-          userAddresses: userAddresses[routeKey],
-          ...restOptions,
-          onRouteStatusUpdated: (routeStatus) => {
-            const relatedRoutes = Object.entries(route).filter(([key]) => key !== "mainRoute").map(([key, route2]) => ({ route: route2, routeKey: key, status: routeStatus.status }));
-            if (routeKey !== "mainRoute") {
-              updateRouteDetails({
-                options: {
-                  route: route[routeKey],
-                  ...restOptions
-                },
-                routeId: mainRouteId,
-                transferIndexToRouteKey,
-                relatedRoutes
-              });
-            }
-            options.onRouteStatusUpdated?.(routeStatus);
-          }
-        }
-      });
-    })
-  );
-};
-
-export { executeMultipleRoutes };

package/dist/esm/chunk-CP55HI6R.js

@@ -1,53 +0,0 @@
-import { createValidAddressList, executeTransactions } from './chunk-JQOJIEZA.js';
-import { updateRouteDetails, executeAndSubscribeToRouteStatus } from './chunk-WSAZDCXR.js';
-import { messages } from './chunk-45B6E7AT.js';
-import { ApiState } from './chunk-X3PQKUOS.js';
-
-// src/public-functions/executeRoute.ts
-var executeRoute = async (options) => {
-  const { route, userAddresses, appendCosmosMsgs, timeoutSeconds } = options;
-  const { id: routeId } = updateRouteDetails({
-    status: "unconfirmed",
-    options
-  });
-  const addressList = await createValidAddressList({
-    userAddresses,
-    route
-  });
-  const response = await messages({
-    timeoutSeconds,
-    amountIn: route?.amountIn,
-    amountOut: route.estimatedAmountOut || "0",
-    sourceAssetChainId: route?.sourceAssetChainId,
-    sourceAssetDenom: route?.sourceAssetDenom,
-    destAssetChainId: route?.destAssetChainId,
-    destAssetDenom: route?.destAssetDenom,
-    operations: route?.operations,
-    addressList,
-    slippageTolerancePercent: options.slippageTolerancePercent || "1",
-    chainIdsToAffiliates: ApiState.chainIdsToAffiliates,
-    postRouteHandler: options.postRouteHandler,
-    feePayerAddress: options.svmFeePayer?.address
-  });
-  if (appendCosmosMsgs) {
-    Object.entries(appendCosmosMsgs).forEach(([chainId, msgs]) => {
-      const txIndex = response?.txs?.findIndex(
-        (tx2) => "cosmosTx" in tx2 && tx2.cosmosTx.chainId === chainId
-      );
-      if (txIndex === void 0 || txIndex === -1) return;
-      const tx = response?.txs?.[txIndex];
-      if (tx && "cosmosTx" in tx) {
-        tx.cosmosTx.msgs?.unshift(...msgs);
-      }
-    });
-  }
-  const { transactionDetails, executeTransaction } = await executeTransactions({ ...options, routeId, txs: response?.txs });
-  await executeAndSubscribeToRouteStatus({
-    transactionDetails,
-    executeTransaction,
-    routeId,
-    options
-  });
-};
-
-export { executeRoute };