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

package/dist/esm/chunk-BU5RCZQH.js

@@ -0,0 +1,187 @@
+import { getCosmosGasAmountForMessage } from './chunk-GPEO2I4P.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-CGJRRAFS.js

@@ -0,0 +1,22 @@
+import { getFeeInfoForChain } from './chunk-5WYMRZIO.js';
+import { Decimal } from '@cosmjs/math';
+import { GasPrice } from '@cosmjs/stargate';
+import { BigNumber } from 'bignumber.js';
+
+var getRecommendedGasPrice = async (props) => {
+  const feeInfo = await 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 GasPrice(Decimal.fromUserInput(BigNumber(price).toFixed(), 18), feeInfo.denom);
+};
+
+export { getRecommendedGasPrice };

package/dist/esm/chunk-DMJMN4J3.js

@@ -0,0 +1,379 @@
+import { BaseAccount as BaseAccount$1, base64FromBytes, bytesFromBase64, isSet } from './chunk-RTDD7HZ3.js';
+import { chains, findFirstWorkingEndpoint } from './chunk-NUHMTWHP.js';
+import { ClientState } from './chunk-J24LYWJE.js';
+import { accountFromAny, SigningStargateClient } from '@cosmjs/stargate';
+import { assertDefinedAndNotNull } from '@cosmjs/utils';
+import { BinaryWriter, BinaryReader } from 'cosmjs-types/binary.js';
+import { BaseAccount } from 'cosmjs-types/cosmos/auth/v1beta1/auth.js';
+import { Coin } from 'cosmjs-types/cosmos/base/v1beta1/coin.js';
+import { decodePubkey } from '@cosmjs/proto-signing';
+import { PubKey } from 'cosmjs-types/cosmos/crypto/secp256k1/keys.js';
+import { encodeSecp256k1Pubkey } from '@cosmjs/amino';
+import _m0 from 'protobufjs/minimal.js';
+
+var createBaseVestingAccount = () => {
+  return {
+    // @ts-expect-error
+    baseAccount: void 0,
+    originalVesting: [],
+    delegatedFree: [],
+    delegatedVesting: [],
+    endTime: BigInt(0)
+  };
+};
+var BaseVestingAccount = {
+  encode(message, writer = BinaryWriter.create()) {
+    if (message.baseAccount !== void 0) {
+      BaseAccount.encode(
+        message.baseAccount,
+        writer.uint32(10).fork()
+      ).ldelim();
+    }
+    for (const v of message.originalVesting) {
+      Coin.encode(v, writer.uint32(18).fork()).ldelim();
+    }
+    for (const v of message.delegatedFree) {
+      Coin.encode(v, writer.uint32(26).fork()).ldelim();
+    }
+    for (const v of message.delegatedVesting) {
+      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 BinaryReader ? input : new 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 = BaseAccount.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.originalVesting.push(Coin.decode(reader, reader.uint32()));
+          break;
+        case 3:
+          message.delegatedFree.push(Coin.decode(reader, reader.uint32()));
+          break;
+        case 4:
+          message.delegatedVesting.push(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 = 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.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 BinaryReader ? input : new 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.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 = 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 BinaryReader ? input : new 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;
+  }
+};
+function createBaseEthAccount() {
+  return {
+    baseAccount: void 0,
+    codeHash: new Uint8Array()
+  };
+}
+var EthAccount = {
+  typeUrl: "/injective.types.v1beta1.EthAccount",
+  encode(message, writer = _m0.Writer.create()) {
+    if (message.baseAccount !== void 0) {
+      BaseAccount$1.encode(message.baseAccount, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.codeHash.length !== 0) {
+      writer.uint32(18).bytes(message.codeHash);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseEthAccount();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.baseAccount = BaseAccount$1.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.codeHash = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      baseAccount: isSet(object.baseAccount) ? BaseAccount$1.fromJSON(object.baseAccount) : void 0,
+      codeHash: isSet(object.codeHash) ? bytesFromBase64(object.codeHash) : new Uint8Array()
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    message.baseAccount !== void 0 && (obj.baseAccount = message.baseAccount ? BaseAccount$1.toJSON(message.baseAccount) : void 0);
+    message.codeHash !== void 0 && (obj.codeHash = base64FromBytes(message.codeHash !== void 0 ? message.codeHash : new Uint8Array()));
+    return obj;
+  },
+  fromPartial(object) {
+    const message = createBaseEthAccount();
+    message.baseAccount = object.baseAccount !== void 0 && object.baseAccount !== null ? BaseAccount$1.fromPartial(object.baseAccount) : void 0;
+    message.codeHash = object.codeHash ?? new Uint8Array();
+    return message;
+  },
+  fromAmino(object) {
+    const message = createBaseEthAccount();
+    if (object.base_account !== void 0 && object.base_account !== null) {
+      message.baseAccount = BaseAccount$1.fromAmino(object.base_account);
+    }
+    if (object.code_hash !== void 0 && object.code_hash !== null) {
+      message.codeHash = bytesFromBase64(object.code_hash);
+    }
+    return message;
+  },
+  toAmino(message) {
+    const obj = {};
+    obj.base_account = message.baseAccount ? BaseAccount$1.toAmino(message.baseAccount) : void 0;
+    obj.code_hash = message.codeHash ? base64FromBytes(message.codeHash) : void 0;
+    return obj;
+  },
+  fromAminoMsg(object) {
+    return EthAccount.fromAmino(object.value);
+  },
+  fromProtoMsg(message) {
+    return EthAccount.decode(message.value);
+  },
+  toProto(message) {
+    return EthAccount.encode(message).finish();
+  },
+  toProtoMsg(message) {
+    return {
+      typeUrl: "/injective.types.v1beta1.EthAccount",
+      value: EthAccount.encode(message).finish()
+    };
+  }
+};
+
+// src/registry.ts
+var accountParser = (acc) => {
+  switch (acc.typeUrl) {
+    case "/stride.vesting.StridePeriodicVestingAccount": {
+      const baseAccount = StridePeriodicVestingAccount.decode(acc.value).baseVestingAccount?.baseAccount;
+      assertDefinedAndNotNull(baseAccount);
+      return {
+        address: baseAccount.address,
+        pubkey: baseAccount.pubKey ? decodePubkey(baseAccount.pubKey) : null,
+        accountNumber: Number(baseAccount.accountNumber),
+        sequence: Number(baseAccount.sequence)
+      };
+    }
+    case "/injective.types.v1beta1.EthAccount":
+      return accountEthParser(
+        acc,
+        "/injective.crypto.v1beta1.ethsecp256k1.PubKey"
+      );
+    case "/ethermint.types.v1.EthAccount":
+      return accountEthParser(acc, "/ethermint.crypto.v1.ethsecp256k1.PubKey");
+    default: {
+      if (acc.typeUrl === "/cosmos.auth.v1beta1.BaseAccount") {
+        const { address, pubKey, accountNumber, sequence } = BaseAccount.decode(
+          acc.value
+        );
+        switch (pubKey?.typeUrl) {
+          case "/initia.crypto.v1beta1.ethsecp256k1.PubKey":
+          case "/ethermint.crypto.v1.ethsecp256k1.PubKey":
+          case "/cosmos.evm.crypto.v1.ethsecp256k1.PubKey": {
+            const { key } = PubKey.decode(pubKey.value);
+            const pk = encodeSecp256k1Pubkey(key);
+            return {
+              address,
+              pubkey: pk,
+              accountNumber: Number(accountNumber),
+              sequence: Number(sequence)
+            };
+          }
+        }
+      }
+      return accountFromAny(acc);
+    }
+  }
+};
+var accountEthParser = (ethAccount, pubKeyTypeUrl = "/injective.crypto.v1beta1.ethsecp256k1.PubKey") => {
+  const account = EthAccount.decode(
+    ethAccount.value
+  );
+  const baseAccount = account.baseAccount;
+  const pubKey = baseAccount.pubKey;
+  return {
+    address: baseAccount.address,
+    pubkey: pubKey ? {
+      type: pubKeyTypeUrl,
+      value: Buffer.from(pubKey.value).toString("base64")
+    } : null,
+    accountNumber: parseInt(baseAccount.accountNumber.toString(), 10),
+    sequence: parseInt(baseAccount.sequence.toString(), 10)
+  };
+};
+
+// src/private-functions/getRpcEndpointForChain.ts
+var getRpcEndpointForChain = async (chainId) => {
+  if (ClientState.endpointOptions.getRpcEndpointForChain) {
+    return ClientState.endpointOptions.getRpcEndpointForChain(chainId);
+  }
+  if (ClientState.endpointOptions.endpoints && ClientState.endpointOptions.endpoints[chainId]) {
+    const endpointOptions = 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 = chains().find((chain2) => chain2.chainId === 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 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 (!ClientState.signingStargateClientByChainId?.[chainId]) {
+    const [signer, endpoint] = await Promise.all([
+      getOfflineSigner(chainId),
+      getRpcEndpointForChain(chainId)
+    ]);
+    ClientState.signingStargateClientByChainId[chainId] = await SigningStargateClient.connectWithSigner(endpoint, signer, {
+      aminoTypes: ClientState.aminoTypes,
+      registry: ClientState.registry,
+      accountParser
+    });
+  }
+  return {
+    stargateClient: ClientState.signingStargateClientByChainId[chainId],
+    signer: await getOfflineSigner(chainId)
+  };
+};
+
+export { accountParser, getRpcEndpointForChain, getSigningStargateClient };

package/dist/esm/chunk-E4NRDAVO.js

@@ -0,0 +1,65 @@
+import { trackTransaction } from './chunk-SXBG57J3.js';
+import { transactionStatus } from './chunk-N4PTRCNT.js';
+import { wait } from './chunk-F66EKL3W.js';
+
+// src/public-functions/waitForTransaction.ts
+var waitForTransaction = async ({
+  chainId,
+  txHash,
+  explorerLink,
+  doNotTrack = false,
+  onStatusUpdated,
+  onError,
+  onTransactionTracked,
+  isCancelled,
+  ...trackTxPollingOptions
+}) => {
+  try {
+    if (!explorerLink && !doNotTrack) {
+      const response = await trackTransaction({
+        chainId,
+        txHash,
+        ...trackTxPollingOptions
+      });
+      explorerLink = response.explorerLink;
+      await onTransactionTracked?.({ txHash, chainId, explorerLink });
+    }
+  } catch (error) {
+    console.warn(`track failed for txHash:${txHash}, chainId: ${chainId}`);
+  }
+  while (true) {
+    if (isCancelled?.()) {
+      throw new Error("waitForTransaction was aborted");
+    }
+    try {
+      const txStatusResponse = await transactionStatus({
+        chainId,
+        txHash
+      });
+      onStatusUpdated?.(txStatusResponse);
+      if (txStatusResponse.state === "STATE_COMPLETED_SUCCESS") {
+        return txStatusResponse;
+      }
+      if (txStatusResponse.state === "STATE_COMPLETED_ERROR") {
+        throw new Error(`${txStatusResponse.error?.type}: ${txStatusResponse.error?.message}`);
+      }
+      if (txStatusResponse.state === "STATE_ABANDONED") {
+        throw new Error("Tracking for the transaction has been abandoned");
+      }
+      await wait(1e3);
+    } catch (error) {
+      onError?.(error);
+      throw error;
+    }
+  }
+};
+var waitForTransactionWithCancel = (props) => {
+  let isCancelled = false;
+  const cancel = () => {
+    isCancelled = true;
+  };
+  const wrappedPromise = waitForTransaction({ ...props, isCancelled: () => isCancelled });
+  return { promise: wrappedPromise, cancel };
+};
+
+export { waitForTransaction, waitForTransactionWithCancel };

package/dist/esm/chunk-ETBJVFQP.js

@@ -0,0 +1,10 @@
+import { api } from './chunk-F66EKL3W.js';
+
+// src/api/postSubmitTransaction.ts
+var submitTransaction = api({
+  methodName: "submit",
+  method: "post",
+  path: "v2/tx/submit"
+});
+
+export { submitTransaction };