@skip-go/client 1.3.0 → 1.3.1

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;

package/dist/cjs/chunk-KMDNP6DN.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+var chunk4R6OCWRR_cjs = require('./chunk-4R6OCWRR.cjs');
+var chunkWE7KICKO_cjs = require('./chunk-WE7KICKO.cjs');
+var math = require('@cosmjs/math');
+var stargate = require('@cosmjs/stargate');
+
+var getRecommendedGasPrice = async (props) => {
+  const feeInfo = await chunkWE7KICKO_cjs.getFeeInfoForChain(props);
+  if (!feeInfo || !feeInfo.gasPrice) {
+    return void 0;
+  }
+  let price = feeInfo.gasPrice.average;
+  if (price === "") {
+    price = feeInfo.gasPrice.high;
+  }
+  if (price === "") {
+    price = feeInfo.gasPrice.low;
+  }
+  if (!price) return;
+  return new stargate.GasPrice(math.Decimal.fromUserInput(chunk4R6OCWRR_cjs.BigNumber(price).toFixed(), 18), feeInfo.denom);
+};
+
+exports.getRecommendedGasPrice = getRecommendedGasPrice;

package/dist/cjs/chunk-KZOSEIWH.cjs

@@ -0,0 +1,10 @@
+'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-MGYSCMET.cjs

@@ -0,0 +1,273 @@
+'use strict';
+
+var chunkT5LPU5A2_cjs = require('./chunk-T5LPU5A2.cjs');
+var chunkD2W4UBJB_cjs = require('./chunk-D2W4UBJB.cjs');
+var stargate = require('@cosmjs/stargate');
+var utils = require('@cosmjs/utils');
+var binary_js = require('cosmjs-types/binary.js');
+var auth_js = require('cosmjs-types/cosmos/auth/v1beta1/auth.js');
+var coin_js = require('cosmjs-types/cosmos/base/v1beta1/coin.js');
+var protoSigning = require('@cosmjs/proto-signing');
+var sdkTs = require('@injectivelabs/sdk-ts');
+var keys_js = require('cosmjs-types/cosmos/crypto/secp256k1/keys.js');
+var amino = require('@cosmjs/amino');
+
+var createBaseVestingAccount = () => {
+  return {
+    // @ts-expect-error
+    baseAccount: void 0,
+    originalVesting: [],
+    delegatedFree: [],
+    delegatedVesting: [],
+    endTime: BigInt(0)
+  };
+};
+var BaseVestingAccount = {
+  encode(message, writer = binary_js.BinaryWriter.create()) {
+    if (message.baseAccount !== void 0) {
+      auth_js.BaseAccount.encode(
+        message.baseAccount,
+        writer.uint32(10).fork()
+      ).ldelim();
+    }
+    for (const v of message.originalVesting) {
+      coin_js.Coin.encode(v, writer.uint32(18).fork()).ldelim();
+    }
+    for (const v of message.delegatedFree) {
+      coin_js.Coin.encode(v, writer.uint32(26).fork()).ldelim();
+    }
+    for (const v of message.delegatedVesting) {
+      coin_js.Coin.encode(v, writer.uint32(34).fork()).ldelim();
+    }
+    if (message.endTime !== BigInt(0)) {
+      writer.uint32(40).int64(message.endTime);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof binary_js.BinaryReader ? input : new binary_js.BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseVestingAccount();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.baseAccount = auth_js.BaseAccount.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.originalVesting.push(coin_js.Coin.decode(reader, reader.uint32()));
+          break;
+        case 3:
+          message.delegatedFree.push(coin_js.Coin.decode(reader, reader.uint32()));
+          break;
+        case 4:
+          message.delegatedVesting.push(coin_js.Coin.decode(reader, reader.uint32()));
+          break;
+        case 5:
+          message.endTime = reader.int64();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  }
+};
+function createBasePeriod() {
+  return {
+    startTime: BigInt(0),
+    length: BigInt(0),
+    amount: [],
+    actionType: 0
+  };
+}
+var Period = {
+  encode(message, writer = binary_js.BinaryWriter.create()) {
+    if (message.startTime !== BigInt(0)) {
+      writer.uint32(8).int64(message.startTime);
+    }
+    if (message.length !== BigInt(0)) {
+      writer.uint32(16).int64(message.length);
+    }
+    for (const v of message.amount) {
+      coin_js.Coin.encode(v, writer.uint32(26).fork()).ldelim();
+    }
+    if (message.actionType !== 0) {
+      writer.uint32(32).int32(message.actionType);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof binary_js.BinaryReader ? input : new binary_js.BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBasePeriod();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.startTime = reader.int64();
+          break;
+        case 2:
+          message.length = reader.int64();
+          break;
+        case 3:
+          message.amount.push(coin_js.Coin.decode(reader, reader.uint32()));
+          break;
+        case 4:
+          message.actionType = reader.int32();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  }
+};
+function createBaseStridePeriodicVestingAccount() {
+  return {
+    //eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    //@ts-ignore
+    baseVestingAccount: void 0,
+    vestingPeriods: []
+  };
+}
+var StridePeriodicVestingAccount = {
+  encode(message, writer = binary_js.BinaryWriter.create()) {
+    if (message.baseVestingAccount !== void 0) {
+      BaseVestingAccount.encode(
+        message.baseVestingAccount,
+        writer.uint32(10).fork()
+      ).ldelim();
+    }
+    for (const v of message.vestingPeriods) {
+      Period.encode(v, writer.uint32(26).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof binary_js.BinaryReader ? input : new binary_js.BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseStridePeriodicVestingAccount();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.baseVestingAccount = BaseVestingAccount.decode(
+            reader,
+            reader.uint32()
+          );
+          break;
+        case 3:
+          message.vestingPeriods.push(Period.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  }
+};
+var accountParser = (acc) => {
+  switch (acc.typeUrl) {
+    case "/stride.vesting.StridePeriodicVestingAccount": {
+      const baseAccount = StridePeriodicVestingAccount.decode(acc.value).baseVestingAccount?.baseAccount;
+      utils.assertDefinedAndNotNull(baseAccount);
+      return {
+        address: baseAccount.address,
+        pubkey: baseAccount.pubKey ? protoSigning.decodePubkey(baseAccount.pubKey) : null,
+        accountNumber: Number(baseAccount.accountNumber),
+        sequence: Number(baseAccount.sequence)
+      };
+    }
+    case "/injective.types.v1beta1.EthAccount":
+      return sdkTs.accountEthParser(
+        acc,
+        "/injective.crypto.v1beta1.ethsecp256k1.PubKey"
+      );
+    case "/ethermint.types.v1.EthAccount":
+      return sdkTs.accountEthParser(acc, "/ethermint.crypto.v1.ethsecp256k1.PubKey");
+    default: {
+      if (acc.typeUrl === "/cosmos.auth.v1beta1.BaseAccount") {
+        const { address, pubKey, accountNumber, sequence } = auth_js.BaseAccount.decode(
+          acc.value
+        );
+        if (pubKey?.typeUrl === "/initia.crypto.v1beta1.ethsecp256k1.PubKey") {
+          const { key } = keys_js.PubKey.decode(pubKey.value);
+          const pk = amino.encodeSecp256k1Pubkey(key);
+          return {
+            address,
+            pubkey: pk,
+            accountNumber: Number(accountNumber),
+            sequence: Number(sequence)
+          };
+        }
+      }
+      return stargate.accountFromAny(acc);
+    }
+  }
+};
+
+// src/private-functions/getRpcEndpointForChain.ts
+var getRpcEndpointForChain = async (chainId) => {
+  if (chunkD2W4UBJB_cjs.ClientState.endpointOptions.getRpcEndpointForChain) {
+    return chunkD2W4UBJB_cjs.ClientState.endpointOptions.getRpcEndpointForChain(chainId);
+  }
+  if (chunkD2W4UBJB_cjs.ClientState.endpointOptions.endpoints && chunkD2W4UBJB_cjs.ClientState.endpointOptions.endpoints[chainId]) {
+    const endpointOptions = chunkD2W4UBJB_cjs.ClientState.endpointOptions.endpoints[chainId];
+    if (endpointOptions?.rpc) {
+      return endpointOptions.rpc;
+    }
+  }
+  console.warn(
+    "Warning: You are using unreliable public endpoints. We strongly recommend overriding them via endpointOptions for use beyond development settings."
+  );
+  const chain = chunkT5LPU5A2_cjs.chains().find((chain2) => chain2.chain_id === chainId);
+  if (!chain) {
+    throw new Error(`getRpcEndpointForChain: failed to find chain id '${chainId}' in registry`);
+  }
+  if (chain.apis?.rpc?.length === 0 || !chain.apis?.rpc) {
+    throw new Error(
+      `getRpcEndpointForChain error: failed to find RPC endpoint for chain id '${chainId}'`
+    );
+  }
+  const endpoints = chain.apis?.rpc?.map((api) => api.address);
+  const endpoint = await chunkT5LPU5A2_cjs.findFirstWorkingEndpoint(endpoints, "rpc");
+  if (!endpoint) {
+    throw new Error(
+      `getRpcEndpointForChain error: failed to find RPC endpoint for chain id '${chainId}'`
+    );
+  }
+  return endpoint;
+};
+
+// src/public-functions/getSigningStargateClient.ts
+var getSigningStargateClient = async ({
+  chainId,
+  getOfflineSigner
+}) => {
+  if (!getOfflineSigner) {
+    throw new Error("'getCosmosSigner' is not provided or configured in skip router");
+  }
+  if (!chunkD2W4UBJB_cjs.ClientState.signingStargateClientByChainId?.[chainId]) {
+    const [signer, endpoint] = await Promise.all([
+      getOfflineSigner(chainId),
+      getRpcEndpointForChain(chainId)
+    ]);
+    chunkD2W4UBJB_cjs.ClientState.signingStargateClientByChainId[chainId] = await stargate.SigningStargateClient.connectWithSigner(endpoint, signer, {
+      aminoTypes: chunkD2W4UBJB_cjs.ClientState.aminoTypes,
+      registry: chunkD2W4UBJB_cjs.ClientState.registry,
+      accountParser
+    });
+  }
+  return {
+    stargateClient: chunkD2W4UBJB_cjs.ClientState.signingStargateClientByChainId[chainId],
+    signer: await getOfflineSigner(chainId)
+  };
+};
+
+exports.accountParser = accountParser;
+exports.getRpcEndpointForChain = getRpcEndpointForChain;
+exports.getSigningStargateClient = getSigningStargateClient;