@skip-go/client 1.3.0 → 1.3.2

package/dist/cjs/chunk-EINQFLWN.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var chunk5FR25GF5_cjs = require('./chunk-5FR25GF5.cjs');
+
+// src/api/postSubmitTransaction.ts
+var submitTransaction = chunk5FR25GF5_cjs.api({
+  methodName: "submit",
+  method: "post",
+  path: "v2/tx/submit"
+});
+
+exports.submitTransaction = submitTransaction;

package/dist/cjs/chunk-EQBTNGJJ.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var chunk5FR25GF5_cjs = require('./chunk-5FR25GF5.cjs');
+
+// src/api/getAssetsBetweenChains.ts
+var assetsBetweenChains = chunk5FR25GF5_cjs.api({
+  methodName: "fungibleAssetsBetweenChainsCreate",
+  path: "v2/fungible/assets_between_chains"
+});
+
+exports.assetsBetweenChains = assetsBetweenChains;

package/dist/cjs/chunk-F3EB2AQG.cjs

@@ -0,0 +1,28 @@
+'use strict';
+
+var viem = require('viem');
+
+// src/public-functions/getEvmGasAmountForMessage.ts
+async function getEVMGasAmountForMessage(signer, tx, getFallbackGasAmount) {
+  const { to, data, value } = tx;
+  if (!signer.account) throw new Error("estimateGasForEvmTx: No account found");
+  const extendedSigner = signer.extend(viem.publicActions);
+  const fee = await extendedSigner.estimateFeesPerGas();
+  try {
+    const gasAmount = await extendedSigner.estimateGas({
+      account: signer.account,
+      to,
+      data: `0x${data}`,
+      value: value === "" ? void 0 : BigInt(value ?? "")
+    });
+    return gasAmount * fee.maxFeePerGas;
+  } catch (error) {
+    const fallbackGasAmount = await getFallbackGasAmount?.(tx.chainId ?? "", "evm" /* Evm */);
+    if (fallbackGasAmount) {
+      return BigInt(fallbackGasAmount) * fee.maxFeePerGas;
+    }
+    throw error;
+  }
+}
+
+exports.getEVMGasAmountForMessage = getEVMGasAmountForMessage;

package/dist/cjs/chunk-G3G6PBIF.cjs

@@ -0,0 +1,47 @@
+'use strict';
+
+var chunk5FR25GF5_cjs = require('./chunk-5FR25GF5.cjs');
+
+// src/public-functions/setApiOptions.ts
+var setApiOptions = (options = {}) => {
+  chunk5FR25GF5_cjs.ApiState.client = chunk5FR25GF5_cjs.createRequestClient({
+    apiUrl: options.apiUrl || "https://api.skip.build",
+    apiKey: options.apiKey,
+    apiHeaders: options.apiHeaders
+  });
+  chunk5FR25GF5_cjs.ApiState.setClientInitialized();
+  if (options.chainIdsToAffiliates) {
+    chunk5FR25GF5_cjs.ApiState.cumulativeAffiliateFeeBPS = validateChainIdsToAffiliates(options.chainIdsToAffiliates);
+    chunk5FR25GF5_cjs.ApiState.chainIdsToAffiliates = options.chainIdsToAffiliates;
+  }
+  return chunk5FR25GF5_cjs.ApiState.clientInitialized;
+};
+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);
+}
+
+exports.setApiOptions = setApiOptions;

package/dist/cjs/chunk-HDKNPB2J.cjs

@@ -0,0 +1,182 @@
+'use strict';
+
+var chunkN3LR7KTI_cjs = require('./chunk-N3LR7KTI.cjs');
+var chunk4R6OCWRR_cjs = require('./chunk-4R6OCWRR.cjs');
+var chunkMGYSCMET_cjs = require('./chunk-MGYSCMET.cjs');
+var chunkD2W4UBJB_cjs = require('./chunk-D2W4UBJB.cjs');
+var stargate = require('@cosmjs/stargate');
+var math = require('@cosmjs/math');
+
+var validateCosmosGasBalance = async ({
+  chainId,
+  signerAddress,
+  messages,
+  getFallbackGasAmount,
+  getOfflineSigner,
+  txIndex,
+  simulate,
+  getCosmosPriorityFeeDenom
+}) => {
+  const skipAssets = (await chunkD2W4UBJB_cjs.ClientState.getSkipAssets({ chainId }))?.[chainId];
+  const skipChains = await chunkD2W4UBJB_cjs.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) throw new Error("simulate");
+      if (txIndex !== 0 && chainId === "noble-1") {
+        return "0";
+      }
+      const { stargateClient } = await chunkMGYSCMET_cjs.getSigningStargateClient({
+        chainId,
+        getOfflineSigner
+      });
+      const estimatedGas = await chunkN3LR7KTI_cjs.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 stargate.GasPrice(
+        math.Decimal.fromUserInput(chunk4R6OCWRR_cjs.BigNumber(price).toFixed(), 18),
+        asset?.denom ?? ""
+      );
+    })();
+    if (!gasPrice) {
+      return null;
+    }
+    if (chainId === "noble-1") {
+      if (asset.denom.toLowerCase() === "ibc/EF48E6B1A1A19F47ECAEA62F5670C37C0580E86A9E88498B7E393EB6F49F33C0".toLowerCase()) {
+        const fee2 = stargate.calculateFee(2e6, gasPrice);
+        return fee2;
+      }
+      const fee = stargate.calculateFee(2e5, gasPrice);
+      return fee;
+    }
+    return stargate.calculateFee(Math.ceil(parseFloat(estimatedGasAmount)), gasPrice);
+  });
+  const feeBalance = await chunkD2W4UBJB_cjs.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 chunk4R6OCWRR_cjs.BigNumber(parseFloat(balance?.amount ?? "")).shiftedBy(-decimal).toFixed(decimal);
+      const feeAmount = new chunk4R6OCWRR_cjs.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;
+};
+
+exports.validateCosmosGasBalance = validateCosmosGasBalance;