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

package/dist/esm/chunk-OMOVHXSC.js

@@ -1,212 +0,0 @@
-import { createValidAddressList, executeTransactions } from './chunk-ZVFYCNA5.js';
-import { updateRouteDetails, executeAndSubscribeToRouteStatus } from './chunk-3DIX6KRJ.js';
-import { messages } from './chunk-P36PE4CR.js';
-import { trackTransaction } from './chunk-SXBG57J3.js';
-import { ApiState } from './chunk-F66EKL3W.js';
-
-// src/public-functions/executeMultipleRoutes.ts
-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-P36PE4CR.js

@@ -1,37 +0,0 @@
-import { api } from './chunk-F66EKL3W.js';
-
-// src/utils/filterMessagesRequest.ts
-var filterMessagesRequest = (request) => {
-  const messagesRequest = {
-    sourceAssetDenom: request.sourceAssetDenom,
-    sourceAssetChainId: request.sourceAssetChainId,
-    destAssetDenom: request.destAssetDenom,
-    destAssetChainId: request.destAssetChainId,
-    amountIn: request.amountIn,
-    amountOut: request.amountOut,
-    addressList: request.addressList,
-    operations: request.operations,
-    estimatedAmountOut: request.estimatedAmountOut,
-    slippageTolerancePercent: request.slippageTolerancePercent,
-    feePayerAddress: request.feePayerAddress,
-    timeoutSeconds: request.timeoutSeconds,
-    postRouteHandler: request.postRouteHandler,
-    chainIdsToAffiliates: request.chainIdsToAffiliates,
-    enableGasWarnings: request.enableGasWarnings,
-    apiUrl: request.apiUrl,
-    apiKey: request.apiKey,
-    abortDuplicateRequests: request.abortDuplicateRequests
-  };
-  return messagesRequest;
-};
-
-// src/api/postMessages.ts
-var messages = async (request) => {
-  return api({
-    methodName: "msgs",
-    method: "post",
-    path: "v2/fungible/msgs"
-  })(filterMessagesRequest(request));
-};
-
-export { messages };

package/dist/esm/chunk-PZ2624FK.js

@@ -1,187 +0,0 @@
-import { getCosmosGasAmountForMessage } from './chunk-R2GHDOWX.js';
-import { getSigningStargateClient } from './chunk-DMJMN4J3.js';
-import { ClientState, balances } from './chunk-J24LYWJE.js';
-import { BigNumber } from 'bignumber.js';
-import { GasPrice, calculateFee } from '@cosmjs/stargate';
-import { Decimal } from '@cosmjs/math';
-
-var validateCosmosGasBalance = async ({
-  chainId,
-  signerAddress,
-  messages,
-  getFallbackGasAmount,
-  getOfflineSigner,
-  txIndex,
-  simulate,
-  getCosmosPriorityFeeDenom,
-  isMultiRoutes
-}) => {
-  const skipAssets = (await ClientState.getSkipAssets({ chainId }))?.[chainId];
-  const skipChains = await ClientState.getSkipChains();
-  const prioFeeDenom = await getCosmosPriorityFeeDenom?.(chainId);
-  const chain = skipChains?.find((c) => c.chainId === chainId);
-  if (!chain) {
-    throw new Error(`failed to find chain id '${chainId}'`);
-  }
-  const { feeAssets } = chain;
-  if (!feeAssets) {
-    throw new Error(`failed to find fee assets for chain id '${chainId}'`);
-  }
-  const estimatedGasAmount = await (async () => {
-    try {
-      if (simulate === false) throw new Error("simulate");
-      if (txIndex !== 0 && chainId === "noble-1") {
-        return "0";
-      }
-      const { stargateClient } = await getSigningStargateClient({
-        chainId,
-        getOfflineSigner
-      });
-      const estimatedGas = await getCosmosGasAmountForMessage(
-        stargateClient,
-        signerAddress,
-        chainId,
-        messages
-      );
-      return estimatedGas;
-    } catch (e) {
-      const error = e;
-      if (error.message === "simulate" && !getFallbackGasAmount) {
-        throw new Error(`unable to get gas amount for ${chainId}'s message(s)`);
-      }
-      if (getFallbackGasAmount) {
-        const fallbackGasAmount = await getFallbackGasAmount(
-          chainId,
-          "cosmos" /* Cosmos */
-        );
-        if (!fallbackGasAmount) {
-          throw new Error(`unable to estimate gas for message(s) ${messages}`);
-        }
-        return String(fallbackGasAmount);
-      }
-      throw error;
-    }
-  })();
-  const fees = feeAssets.map((asset) => {
-    const gasPrice = (() => {
-      if (!asset?.gasPrice) return void 0;
-      let price = asset.gasPrice.average;
-      if (price === "") {
-        price = asset.gasPrice.high;
-      }
-      if (price === "") {
-        price = asset.gasPrice.low;
-      }
-      if (!price) return;
-      return new GasPrice(
-        Decimal.fromUserInput(BigNumber(price).toFixed(), 18),
-        asset?.denom ?? ""
-      );
-    })();
-    if (!gasPrice) {
-      return null;
-    }
-    if (chainId === "noble-1") {
-      if (isMultiRoutes && txIndex === 0) {
-        return calculateFee(
-          Math.ceil(parseFloat(estimatedGasAmount)),
-          gasPrice
-        );
-      }
-      if (asset.denom.toLowerCase() === "ibc/EF48E6B1A1A19F47ECAEA62F5670C37C0580E86A9E88498B7E393EB6F49F33C0".toLowerCase()) {
-        const fee2 = calculateFee(2e6, gasPrice);
-        return fee2;
-      }
-      const fee = calculateFee(2e5, gasPrice);
-      return fee;
-    }
-    return calculateFee(Math.ceil(parseFloat(estimatedGasAmount)), gasPrice);
-  });
-  const feeBalance = await balances({
-    chains: {
-      [chainId]: {
-        address: signerAddress,
-        denoms: feeAssets.map((asset) => asset.denom ?? "")
-      }
-    }
-  });
-  const validatedAssets = feeAssets.map((asset, index) => {
-    const chainAsset = skipAssets?.find((x) => x.denom === asset.denom);
-    const symbol = chainAsset?.recommendedSymbol?.toUpperCase();
-    const decimal = Number(chainAsset?.decimals);
-    if (!chainAsset) {
-      return {
-        error: `(${chain?.prettyName}) Unable to find asset for ${asset.denom}`
-      };
-    }
-    if (isNaN(decimal))
-      return {
-        error: `(${chain?.prettyName}) Unable to find decimal for ${symbol}`
-      };
-    const fee = fees[index];
-    if (!fee) {
-      return {
-        error: `(${chain?.prettyName}) Unable to calculate fee for ${symbol}`,
-        asset
-      };
-    }
-    if (txIndex !== 0 && chainId === "noble-1") {
-      return {
-        error: null,
-        asset,
-        fee
-      };
-    }
-    let balance = feeBalance?.chains?.[chainId]?.denoms?.[asset?.denom ?? ""];
-    if (!balance) {
-      balance = {
-        amount: "0",
-        formattedAmount: "0"
-      };
-    }
-    if (!fee.amount[0]?.amount) {
-      return {
-        error: `(${chain?.prettyName}) Unable to get fee for ${symbol}`,
-        asset
-      };
-    }
-    if (parseInt(balance?.amount ?? "") < parseInt(fee.amount[0]?.amount)) {
-      const userAmount = new BigNumber(parseFloat(balance?.amount ?? "")).shiftedBy(-decimal).toFixed(decimal);
-      const feeAmount = new BigNumber(parseFloat(fee.amount[0]?.amount)).shiftedBy(-decimal).toFixed(decimal);
-      return {
-        error: `Insufficient balance for gas on ${chain?.prettyName}. Need ${feeAmount} ${symbol} but only have ${userAmount} ${symbol}.`,
-        asset
-      };
-    }
-    return {
-      error: null,
-      asset,
-      fee
-    };
-  });
-  if (prioFeeDenom) {
-    const availableAssets = validatedAssets.filter(
-      (res) => res?.error === null
-    );
-    const prioFeeAsset = availableAssets.find(
-      (res) => res?.asset?.denom === prioFeeDenom
-    );
-    if (prioFeeAsset) {
-      return prioFeeAsset;
-    }
-  }
-  const feeUsed = validatedAssets.find((res) => res?.error === null);
-  if (!feeUsed) {
-    if (validatedAssets.length > 1) {
-      throw new Error(
-        validatedAssets[0]?.error || `Insufficient fee token to initiate transfer on ${chain.prettyName}.`
-      );
-    }
-    throw new Error(
-      validatedAssets[0]?.error || `Insufficient fee token to initiate transfer on ${chain.prettyName}.`
-    );
-  }
-  return feeUsed;
-};
-
-export { validateCosmosGasBalance };

package/dist/esm/chunk-QYXGDTUU.js

@@ -1,47 +0,0 @@
-import { createRequestClient, ApiState } from './chunk-F66EKL3W.js';
-
-// src/public-functions/setApiOptions.ts
-var setApiOptions = (options = {}) => {
-  ApiState.client = createRequestClient({
-    apiUrl: options.apiUrl || "https://api.skip.build",
-    apiKey: options.apiKey,
-    apiHeaders: options.apiHeaders
-  });
-  if (options.chainIdsToAffiliates) {
-    ApiState.cumulativeAffiliateFeeBPS = validateChainIdsToAffiliates(options.chainIdsToAffiliates);
-    ApiState.chainIdsToAffiliates = options.chainIdsToAffiliates;
-  }
-  if (!options.allowOptionsUpdateAfterApiCall && ApiState.apiCalled && !ApiState.initialized) {
-    throw new Error("setApiOptions must be called before an api request is made");
-  }
-  ApiState.initialized = true;
-};
-function validateChainIdsToAffiliates(chainIdsToAffiliates) {
-  const affiliatesArray = Object.values(chainIdsToAffiliates).map((chain) => chain.affiliates).filter((a) => a !== void 0);
-  const firstAffiliateBasisPointsFee = affiliatesArray[0]?.reduce((acc, affiliate) => {
-    if (!affiliate.basisPointsFee) {
-      throw new Error("basisPointFee must exist in each affiliate");
-    }
-    return acc + parseInt(affiliate.basisPointsFee, 10);
-  }, 0);
-  const allBasisPointsAreEqual = affiliatesArray.every((affiliate) => {
-    const totalBasisPointsFee = affiliate.reduce((acc, affiliate2) => {
-      if (!affiliate2.basisPointsFee) {
-        throw new Error("basisPointFee must exist in each affiliate");
-      }
-      if (!affiliate2.address) {
-        throw new Error("address to receive fee must exist in each affiliate");
-      }
-      return acc + parseInt(affiliate2?.basisPointsFee, 10);
-    }, 0);
-    return totalBasisPointsFee === firstAffiliateBasisPointsFee;
-  });
-  if (!allBasisPointsAreEqual) {
-    throw new Error(
-      "basisPointFee does not add up to the same number for each chain in chainIdsToAffiliates"
-    );
-  }
-  return firstAffiliateBasisPointsFee?.toFixed(0);
-}
-
-export { setApiOptions };