@skip-go/client 1.0.0-alpha-0 → 1.0.0-alpha-3

package/dist/chunk-KSMJWLEH.mjs

@@ -0,0 +1,2315 @@
+import { BigNumber } from './chunk-TUBI6VE6.mjs';
+import { GAS_STATION_CHAIN_IDS } from './chunk-ZAF3Z56R.mjs';
+import { getSigningStargateClient, getRpcEndpointForChain, accountParser } from './chunk-B72MYSG5.mjs';
+import { chains, findFirstWorkingEndpoint, getIsEthermint, getIsInitia } from './chunk-NU7MCJOK.mjs';
+import { MsgDepositForBurn, MsgDepositForBurnWithCaller, MsgExecute, MsgInitiateTokenDeposit, BaseVestingAccount, Timestamp, toTimestamp, Period, fromTimestamp, isSet, fromJsonTimestamp } from './chunk-OTLFF5OB.mjs';
+import { messages } from './chunk-KPK3Z6QZ.mjs';
+import { submitTransaction } from './chunk-LJVI5DLG.mjs';
+import { trackTransaction } from './chunk-CAAR7GDJ.mjs';
+import { transactionStatus } from './chunk-C5CGY2X7.mjs';
+import { ClientState, balances } from './chunk-DKIWPD5I.mjs';
+import { __spreadValues, __async, __objRest, __spreadProps, ApiState, wait, createRequestClient, toCamel } from './chunk-RXWDHQLG.mjs';
+import { PublicKey, Transaction, Connection, LAMPORTS_PER_SOL } from '@solana/web3.js';
+import { bech32m, bech32 } from 'bech32';
+import { StargateClient, GasPrice, calculateFee } from '@cosmjs/stargate';
+import { TxRaw } from 'cosmjs-types/cosmos/tx/v1beta1/tx';
+import { isOfflineDirectSigner } from '@cosmjs/proto-signing/build/signer';
+import { fromBase64 } from '@cosmjs/encoding/build/base64';
+import { toUtf8, fromBase64 as fromBase64$1, toBase64 } from '@cosmjs/encoding';
+import { ChainRestTendermintApi, MsgTransfer as MsgTransfer$1, MsgExecuteContractCompat, createTransactionWithSigners } from '@injectivelabs/sdk-ts';
+import { MsgSend } from 'cosmjs-types/cosmos/bank/v1beta1/tx';
+import { MsgExecuteContract } from 'cosmjs-types/cosmwasm/wasm/v1/tx';
+import { MsgTransfer } from 'cosmjs-types/ibc/applications/transfer/v1/tx';
+import * as _m0 from 'protobufjs/minimal';
+import { BigNumberInBase, DEFAULT_BLOCK_TIMEOUT_HEIGHT, DEFAULT_STD_FEE } from '@injectivelabs/utils';
+import { makeAuthInfoBytes, makeSignDoc } from '@cosmjs/proto-signing/build/signing';
+import { pubkeyType as pubkeyType$1, makeSignDoc as makeSignDoc$1, encodeSecp256k1Pubkey } from '@cosmjs/amino';
+import { encodePubkey } from '@cosmjs/proto-signing';
+import { PubKey } from 'cosmjs-types/cosmos/crypto/secp256k1/keys';
+import { Any } from 'cosmjs-types/google/protobuf/any';
+import { Int53 } from '@cosmjs/math/build/integers';
+import { SignMode } from 'cosmjs-types/cosmos/tx/signing/v1beta1/signing';
+import { isAddress, publicActions, maxUint256, formatUnits } from 'viem';
+import { Decimal } from '@cosmjs/math/build/decimal';
+
+// src/types/swaggerTypes.ts
+var AutopilotAction = /* @__PURE__ */ ((AutopilotAction2) => {
+  AutopilotAction2["LIQUID_STAKE"] = "LIQUID_STAKE";
+  AutopilotAction2["CLAIM"] = "CLAIM";
+  return AutopilotAction2;
+})(AutopilotAction || {});
+var AxelarTransferState = /* @__PURE__ */ ((AxelarTransferState2) => {
+  AxelarTransferState2["AXELAR_TRANSFER_UNKNOWN"] = "AXELAR_TRANSFER_UNKNOWN";
+  AxelarTransferState2["AXELAR_TRANSFER_PENDING_CONFIRMATION"] = "AXELAR_TRANSFER_PENDING_CONFIRMATION";
+  AxelarTransferState2["AXELAR_TRANSFER_PENDING_RECEIPT"] = "AXELAR_TRANSFER_PENDING_RECEIPT";
+  AxelarTransferState2["AXELAR_TRANSFER_SUCCESS"] = "AXELAR_TRANSFER_SUCCESS";
+  AxelarTransferState2["AXELAR_TRANSFER_FAILURE"] = "AXELAR_TRANSFER_FAILURE";
+  return AxelarTransferState2;
+})(AxelarTransferState || {});
+var AxelarTransferType = /* @__PURE__ */ ((AxelarTransferType2) => {
+  AxelarTransferType2["AXELAR_TRANSFER_CONTRACT_CALL_WITH_TOKEN"] = "AXELAR_TRANSFER_CONTRACT_CALL_WITH_TOKEN";
+  AxelarTransferType2["AXELAR_TRANSFER_SEND_TOKEN"] = "AXELAR_TRANSFER_SEND_TOKEN";
+  return AxelarTransferType2;
+})(AxelarTransferType || {});
+var CCTPTransferState = /* @__PURE__ */ ((CCTPTransferState2) => {
+  CCTPTransferState2["CCTP_TRANSFER_UNKNOWN"] = "CCTP_TRANSFER_UNKNOWN";
+  CCTPTransferState2["CCTP_TRANSFER_SENT"] = "CCTP_TRANSFER_SENT";
+  CCTPTransferState2["CCTP_TRANSFER_PENDING_CONFIRMATION"] = "CCTP_TRANSFER_PENDING_CONFIRMATION";
+  CCTPTransferState2["CCTP_TRANSFER_CONFIRMED"] = "CCTP_TRANSFER_CONFIRMED";
+  CCTPTransferState2["CCTP_TRANSFER_RECEIVED"] = "CCTP_TRANSFER_RECEIVED";
+  return CCTPTransferState2;
+})(CCTPTransferState || {});
+var StargateTransferState = /* @__PURE__ */ ((StargateTransferState2) => {
+  StargateTransferState2["STARGATE_TRANSFER_UNKNOWN"] = "STARGATE_TRANSFER_UNKNOWN";
+  StargateTransferState2["STARGATE_TRANSFER_SENT"] = "STARGATE_TRANSFER_SENT";
+  StargateTransferState2["STARGATE_TRANSFER_PENDING_CONFIRMATION"] = "STARGATE_TRANSFER_PENDING_CONFIRMATION";
+  StargateTransferState2["STARGATE_TRANSFER_CONFIRMED"] = "STARGATE_TRANSFER_CONFIRMED";
+  StargateTransferState2["STARGATE_TRANSFER_RECEIVED"] = "STARGATE_TRANSFER_RECEIVED";
+  StargateTransferState2["STARGATE_TRANSFER_FAILED"] = "STARGATE_TRANSFER_FAILED";
+  return StargateTransferState2;
+})(StargateTransferState || {});
+var GoFastTransferState = /* @__PURE__ */ ((GoFastTransferState2) => {
+  GoFastTransferState2["GO_FAST_TRANSFER_UNKNOWN"] = "GO_FAST_TRANSFER_UNKNOWN";
+  GoFastTransferState2["GO_FAST_TRANSFER_SENT"] = "GO_FAST_TRANSFER_SENT";
+  GoFastTransferState2["GO_FAST_POST_ACTION_FAILED"] = "GO_FAST_POST_ACTION_FAILED";
+  GoFastTransferState2["GO_FAST_TRANSFER_TIMEOUT"] = "GO_FAST_TRANSFER_TIMEOUT";
+  GoFastTransferState2["GO_FAST_TRANSFER_FILLED"] = "GO_FAST_TRANSFER_FILLED";
+  GoFastTransferState2["GO_FAST_TRANSFER_REFUNDED"] = "GO_FAST_TRANSFER_REFUNDED";
+  return GoFastTransferState2;
+})(GoFastTransferState || {});
+var BridgeType = /* @__PURE__ */ ((BridgeType2) => {
+  BridgeType2["IBC"] = "IBC";
+  BridgeType2["AXELAR"] = "AXELAR";
+  BridgeType2["CCTP"] = "CCTP";
+  BridgeType2["HYPERLANE"] = "HYPERLANE";
+  BridgeType2["OPINIT"] = "OPINIT";
+  BridgeType2["GO_FAST"] = "GO_FAST";
+  BridgeType2["STARGATE"] = "STARGATE";
+  BridgeType2["EUREKA"] = "EUREKA";
+  return BridgeType2;
+})(BridgeType || {});
+var ChainType = /* @__PURE__ */ ((ChainType2) => {
+  ChainType2["Cosmos"] = "cosmos";
+  ChainType2["Evm"] = "evm";
+  ChainType2["Svm"] = "svm";
+  return ChainType2;
+})(ChainType || {});
+var ContractCallWithTokenErrorType = /* @__PURE__ */ ((ContractCallWithTokenErrorType2) => {
+  ContractCallWithTokenErrorType2["CONTRACT_CALL_WITH_TOKEN_EXECUTION_ERROR"] = "CONTRACT_CALL_WITH_TOKEN_EXECUTION_ERROR";
+  return ContractCallWithTokenErrorType2;
+})(ContractCallWithTokenErrorType || {});
+var HyperlaneTransferState = /* @__PURE__ */ ((HyperlaneTransferState2) => {
+  HyperlaneTransferState2["HYPERLANE_TRANSFER_UNKNOWN"] = "HYPERLANE_TRANSFER_UNKNOWN";
+  HyperlaneTransferState2["HYPERLANE_TRANSFER_SENT"] = "HYPERLANE_TRANSFER_SENT";
+  HyperlaneTransferState2["HYPERLANE_TRANSFER_FAILED"] = "HYPERLANE_TRANSFER_FAILED";
+  HyperlaneTransferState2["HYPERLANE_TRANSFER_RECEIVED"] = "HYPERLANE_TRANSFER_RECEIVED";
+  return HyperlaneTransferState2;
+})(HyperlaneTransferState || {});
+var PacketErrorType = /* @__PURE__ */ ((PacketErrorType2) => {
+  PacketErrorType2["PACKET_ERROR_UNKNOWN"] = "PACKET_ERROR_UNKNOWN";
+  PacketErrorType2["PACKET_ERROR_ACKNOWLEDGEMENT"] = "PACKET_ERROR_ACKNOWLEDGEMENT";
+  PacketErrorType2["PACKET_ERROR_TIMEOUT"] = "PACKET_ERROR_TIMEOUT";
+  return PacketErrorType2;
+})(PacketErrorType || {});
+var Reason = /* @__PURE__ */ ((Reason2) => {
+  Reason2["UNKNOWN"] = "UNKNOWN";
+  Reason2["MOST_LIQUID"] = "MOST_LIQUID";
+  Reason2["BASE_TOKEN"] = "BASE_TOKEN";
+  Reason2["DIRECT"] = "DIRECT";
+  return Reason2;
+})(Reason || {});
+var RoutePriceWarningType = /* @__PURE__ */ ((RoutePriceWarningType2) => {
+  RoutePriceWarningType2["LOW_INFO_WARNING"] = "LOW_INFO_WARNING";
+  RoutePriceWarningType2["BAD_PRICE_WARNING"] = "BAD_PRICE_WARNING";
+  return RoutePriceWarningType2;
+})(RoutePriceWarningType || {});
+var SendTokenErrorType = /* @__PURE__ */ ((SendTokenErrorType2) => {
+  SendTokenErrorType2["SEND_TOKEN_EXECUTION_ERROR"] = "SEND_TOKEN_EXECUTION_ERROR";
+  return SendTokenErrorType2;
+})(SendTokenErrorType || {});
+var StatusErrorType = /* @__PURE__ */ ((StatusErrorType2) => {
+  StatusErrorType2["STATUS_ERROR_UNKNOWN"] = "STATUS_ERROR_UNKNOWN";
+  StatusErrorType2["STATUS_ERROR_TRANSACTION_EXECUTION"] = "STATUS_ERROR_TRANSACTION_EXECUTION";
+  StatusErrorType2["STATUS_ERROR_INDEXING"] = "STATUS_ERROR_INDEXING";
+  StatusErrorType2["STATUS_ERROR_TRANSFER"] = "STATUS_ERROR_TRANSFER";
+  return StatusErrorType2;
+})(StatusErrorType || {});
+var TransactionState = /* @__PURE__ */ ((TransactionState2) => {
+  TransactionState2["STATE_SUBMITTED"] = "STATE_SUBMITTED";
+  TransactionState2["STATE_PENDING"] = "STATE_PENDING";
+  TransactionState2["STATE_COMPLETED_SUCCESS"] = "STATE_COMPLETED_SUCCESS";
+  TransactionState2["STATE_COMPLETED_ERROR"] = "STATE_COMPLETED_ERROR";
+  TransactionState2["STATE_ABANDONED"] = "STATE_ABANDONED";
+  TransactionState2["STATE_PENDING_ERROR"] = "STATE_PENDING_ERROR";
+  return TransactionState2;
+})(TransactionState || {});
+var OPInitTransferState = /* @__PURE__ */ ((OPInitTransferState2) => {
+  OPInitTransferState2["OPINIT_TRANSFER_UNKNOWN"] = "OPINIT_TRANSFER_UNKNOWN";
+  OPInitTransferState2["OPINIT_TRANSFER_SENT"] = "OPINIT_TRANSFER_SENT";
+  OPInitTransferState2["OPINIT_TRANSFER_RECEIVED"] = "OPINIT_TRANSFER_RECEIVED";
+  return OPInitTransferState2;
+})(OPInitTransferState || {});
+var LayerZeroTransferState = /* @__PURE__ */ ((LayerZeroTransferState2) => {
+  LayerZeroTransferState2["LAYER_ZERO_TRANSFER_UNKNOWN"] = "LAYER_ZERO_TRANSFER_UNKNOWN";
+  LayerZeroTransferState2["LAYER_ZERO_TRANSFER_SENT"] = "LAYER_ZERO_TRANSFER_SENT";
+  LayerZeroTransferState2["LAYER_ZERO_TRANSFER_RECEIVED"] = "LAYER_ZERO_TRANSFER_RECEIVED";
+  LayerZeroTransferState2["LAYER_ZERO_TRANSFER_FAILED"] = "LAYER_ZERO_TRANSFER_FAILED";
+  return LayerZeroTransferState2;
+})(LayerZeroTransferState || {});
+var TransferState = /* @__PURE__ */ ((TransferState2) => {
+  TransferState2["TRANSFER_UNKNOWN"] = "TRANSFER_UNKNOWN";
+  TransferState2["TRANSFER_PENDING"] = "TRANSFER_PENDING";
+  TransferState2["TRANSFER_RECEIVED"] = "TRANSFER_RECEIVED";
+  TransferState2["TRANSFER_SUCCESS"] = "TRANSFER_SUCCESS";
+  TransferState2["TRANSFER_FAILURE"] = "TRANSFER_FAILURE";
+  return TransferState2;
+})(TransferState || {});
+var FeeType = /* @__PURE__ */ ((FeeType2) => {
+  FeeType2["SMART_RELAY"] = "SMART_RELAY";
+  return FeeType2;
+})(FeeType || {});
+var ContentType = /* @__PURE__ */ ((ContentType2) => {
+  ContentType2["Json"] = "application/json";
+  ContentType2["FormData"] = "multipart/form-data";
+  ContentType2["UrlEncoded"] = "application/x-www-form-urlencoded";
+  ContentType2["Text"] = "text/plain";
+  return ContentType2;
+})(ContentType || {});
+var HttpClient = class {
+  constructor(apiConfig = {}) {
+    this.baseUrl = "https://api.skip.build";
+    this.securityData = null;
+    this.abortControllers = /* @__PURE__ */ new Map();
+    this.customFetch = (...fetchParams) => fetch(...fetchParams);
+    this.baseApiParams = {
+      credentials: "same-origin",
+      headers: {},
+      redirect: "follow",
+      referrerPolicy: "no-referrer"
+    };
+    this.setSecurityData = (data) => {
+      this.securityData = data;
+    };
+    this.contentFormatters = {
+      ["application/json" /* Json */]: (input) => input !== null && (typeof input === "object" || typeof input === "string") ? JSON.stringify(input) : input,
+      ["text/plain" /* Text */]: (input) => input !== null && typeof input !== "string" ? JSON.stringify(input) : input,
+      ["multipart/form-data" /* FormData */]: (input) => Object.keys(input || {}).reduce((formData, key) => {
+        const property = input[key];
+        formData.append(
+          key,
+          property instanceof Blob ? property : typeof property === "object" && property !== null ? JSON.stringify(property) : `${property}`
+        );
+        return formData;
+      }, new FormData()),
+      ["application/x-www-form-urlencoded" /* UrlEncoded */]: (input) => this.toQueryString(input)
+    };
+    this.createAbortSignal = (cancelToken) => {
+      if (this.abortControllers.has(cancelToken)) {
+        const abortController2 = this.abortControllers.get(cancelToken);
+        if (abortController2) {
+          return abortController2.signal;
+        }
+        return void 0;
+      }
+      const abortController = new AbortController();
+      this.abortControllers.set(cancelToken, abortController);
+      return abortController.signal;
+    };
+    this.abortRequest = (cancelToken) => {
+      const abortController = this.abortControllers.get(cancelToken);
+      if (abortController) {
+        abortController.abort();
+        this.abortControllers.delete(cancelToken);
+      }
+    };
+    this.request = (_a) => __async(this, null, function* () {
+      var _b = _a, {
+        body,
+        secure,
+        path,
+        type,
+        query,
+        format,
+        baseUrl,
+        cancelToken
+      } = _b, params = __objRest(_b, [
+        "body",
+        "secure",
+        "path",
+        "type",
+        "query",
+        "format",
+        "baseUrl",
+        "cancelToken"
+      ]);
+      const secureParams = (typeof secure === "boolean" ? secure : this.baseApiParams.secure) && this.securityWorker && (yield this.securityWorker(this.securityData)) || {};
+      const requestParams = this.mergeRequestParams(params, secureParams);
+      const queryString = query && this.toQueryString(query);
+      const payloadFormatter = this.contentFormatters[type || "application/json" /* Json */];
+      const responseFormat = format || requestParams.format;
+      return this.customFetch(`${baseUrl || this.baseUrl || ""}${path}${queryString ? `?${queryString}` : ""}`, __spreadProps(__spreadValues({}, requestParams), {
+        headers: __spreadValues(__spreadValues({}, requestParams.headers || {}), type && type !== "multipart/form-data" /* FormData */ ? { "Content-Type": type } : {}),
+        signal: (cancelToken ? this.createAbortSignal(cancelToken) : requestParams.signal) || null,
+        body: typeof body === "undefined" || body === null ? null : payloadFormatter(body)
+      })).then((response) => __async(this, null, function* () {
+        const r = response.clone();
+        r.data = null;
+        r.error = null;
+        const data = !responseFormat ? r : yield response[responseFormat]().then((data2) => {
+          if (r.ok) {
+            r.data = data2;
+          } else {
+            r.error = data2;
+          }
+          return r;
+        }).catch((e) => {
+          r.error = e;
+          return r;
+        });
+        if (cancelToken) {
+          this.abortControllers.delete(cancelToken);
+        }
+        if (!response.ok) throw data;
+        return data;
+      }));
+    });
+    Object.assign(this, apiConfig);
+  }
+  encodeQueryParam(key, value) {
+    const encodedKey = encodeURIComponent(key);
+    return `${encodedKey}=${encodeURIComponent(typeof value === "number" ? value : `${value}`)}`;
+  }
+  addQueryParam(query, key) {
+    return this.encodeQueryParam(key, query[key]);
+  }
+  addArrayQueryParam(query, key) {
+    const value = query[key];
+    return value.map((v) => this.encodeQueryParam(key, v)).join("&");
+  }
+  toQueryString(rawQuery) {
+    const query = rawQuery || {};
+    const keys = Object.keys(query).filter((key) => "undefined" !== typeof query[key]);
+    return keys.map((key) => Array.isArray(query[key]) ? this.addArrayQueryParam(query, key) : this.addQueryParam(query, key)).join("&");
+  }
+  addQueryParams(rawQuery) {
+    const queryString = this.toQueryString(rawQuery);
+    return queryString ? `?${queryString}` : "";
+  }
+  mergeRequestParams(params1, params2) {
+    return __spreadProps(__spreadValues(__spreadValues(__spreadValues({}, this.baseApiParams), params1), params2 || {}), {
+      headers: __spreadValues(__spreadValues(__spreadValues({}, this.baseApiParams.headers || {}), params1.headers || {}), params2 && params2.headers || {})
+    });
+  }
+};
+var Api = class extends HttpClient {
+  constructor() {
+    super(...arguments);
+    /**
+     * @description Get all supported chains along with additional data useful for building applications + frontends that interface with them (e.g. logo URI, IBC capabilities, fee assets, bech32 prefix, etc...)
+     *
+     * @tags Info
+     * @name GetChains
+     * @request GET:/v2/info/chains
+     */
+    this.getChains = (query, params = {}) => this.request(__spreadValues({
+      path: `/v2/info/chains`,
+      method: "GET",
+      query,
+      format: "json"
+    }, params));
+    /**
+     * @description Get the balances of a given set of assets on a given chain and wallet address. Compatible with all Skip Go-supported assets, excluding CW20 assets, across SVM, EVM, and Cosmos chains.
+     *
+     * @tags Info
+     * @name GetBalances
+     * @request POST:/v2/info/balances
+     */
+    this.getBalances = (data, params = {}) => this.request(__spreadValues({
+      path: `/v2/info/balances`,
+      method: "POST",
+      body: data,
+      type: "application/json" /* Json */,
+      format: "json"
+    }, params));
+    /**
+     * @description Get all supported bridges
+     *
+     * @tags Info
+     * @name GetBridges
+     * @request GET:/v2/info/bridges
+     */
+    this.getBridges = (params = {}) => this.request(__spreadValues({
+      path: `/v2/info/bridges`,
+      method: "GET",
+      format: "json"
+    }, params));
+    /**
+     * @description Get supported swap venues.
+     *
+     * @tags Fungible
+     * @name GetVenues
+     * @request GET:/v2/fungible/venues
+     */
+    this.getVenues = (query, params = {}) => this.request(__spreadValues({
+      path: `/v2/fungible/venues`,
+      method: "GET",
+      query,
+      format: "json"
+    }, params));
+    /**
+     * @description Get supported assets. Optionally limit to assets on a given chain and/or native assets.
+     *
+     * @tags Fungible
+     * @name GetAssets
+     * @request GET:/v2/fungible/assets
+     */
+    this.getAssets = (query, params = {}) => this.request(__spreadValues({
+      path: `/v2/fungible/assets`,
+      method: "GET",
+      query,
+      format: "json"
+    }, params));
+    /**
+     * @description Get assets that can be reached from a source via transfers under different conditions (e.g. single vs multiple txs)
+     *
+     * @tags Fungible
+     * @name GetAssetsFromSource
+     * @request POST:/v2/fungible/assets_from_source
+     */
+    this.getAssetsFromSource = (data, params = {}) => this.request(__spreadValues({
+      path: `/v2/fungible/assets_from_source`,
+      method: "POST",
+      body: data,
+      type: "application/json" /* Json */,
+      format: "json"
+    }, params));
+    /**
+     * @description This supports cross-chain actions among EVM chains, Cosmos chains, and between them. Returns the sequence of transfers and/or swaps to reach the given destination asset from the given source asset, along with estimated amount out. Commonly called before /msgs to generate route info and quote.
+     *
+     * @tags Fungible
+     * @name GetRouteV2
+     * @request POST:/v2/fungible/route
+     */
+    this.getRouteV2 = (data, params = {}) => this.request(__spreadValues({
+      path: `/v2/fungible/route`,
+      method: "POST",
+      body: data,
+      type: "application/json" /* Json */,
+      format: "json"
+    }, params));
+    /**
+     * @description This supports cross-chain actions among EVM chains, Cosmos chains, and between them. Returns minimal number of messages required to execute a multi-chain swap or transfer. Input consists of the output of route with additional information required for message construction (e.g. destination addresses for each chain)
+     *
+     * @tags Fungible
+     * @name GetMsgsV2
+     * @request POST:/v2/fungible/msgs
+     */
+    this.getMsgsV2 = (data, params = {}) => this.request(__spreadValues({
+      path: `/v2/fungible/msgs`,
+      method: "POST",
+      body: data,
+      type: "application/json" /* Json */,
+      format: "json"
+    }, params));
+    /**
+     * @description This supports cross-chain actions among EVM chains, Cosmos chains, and between them. Returns minimal number of messages required to execute a multi-chain swap or transfer. This is a convenience endpoint that combines /route and /msgs into a single call.
+     *
+     * @tags Fungible
+     * @name GetMsgsDirectV2
+     * @request POST:/v2/fungible/msgs_direct
+     */
+    this.getMsgsDirectV2 = (data, params = {}) => this.request(__spreadValues({
+      path: `/v2/fungible/msgs_direct`,
+      method: "POST",
+      body: data,
+      type: "application/json" /* Json */,
+      format: "json"
+    }, params));
+    /**
+     * @description Request asset recommendations for the given source assets on a given destination chain. The response includes recommended destination assets and recommendation reasons.
+     *
+     * @tags Fungible
+     * @name GetAssetRecommendations
+     * @request POST:/v2/fungible/recommend_assets
+     */
+    this.getAssetRecommendations = (data, params = {}) => this.request(__spreadValues({
+      path: `/v2/fungible/recommend_assets`,
+      method: "POST",
+      body: data,
+      type: "application/json" /* Json */,
+      format: "json"
+    }, params));
+    /**
+     * @description Submit a signed base64 encoded transaction to be broadcast to the specified network. On successful submission, the status of the transaction and any subsequent IBC or Axelar transfers can be queried through the /status endpoint.
+     *
+     * @tags Transaction
+     * @name SubmitTransactionV2
+     * @request POST:/v2/tx/submit
+     */
+    this.submitTransactionV2 = (data, params = {}) => this.request(__spreadValues({
+      path: `/v2/tx/submit`,
+      method: "POST",
+      body: data,
+      type: "application/json" /* Json */,
+      format: "json"
+    }, params));
+    /**
+     * @description Requests tracking of a transaction that has already landed on-chain but was not broadcast through the Skip Go API. The status of a tracked transaction and subsequent IBC or Axelar transfers if routing assets cross chain can be queried through the /status endpoint.
+     *
+     * @tags Transaction
+     * @name TrackTransactionV2
+     * @request POST:/v2/tx/track
+     */
+    this.trackTransactionV2 = (data, params = {}) => this.request(__spreadValues({
+      path: `/v2/tx/track`,
+      method: "POST",
+      body: data,
+      type: "application/json" /* Json */,
+      format: "json"
+    }, params));
+    /**
+     * @description Get the status of the specified transaction and any subsequent IBC or Axelar transfers if routing assets cross chain. The transaction must have previously been submitted to either the /submit or /track endpoints.
+     *
+     * @tags Transaction
+     * @name GetTransactionStatusV2
+     * @request GET:/v2/tx/status
+     */
+    this.getTransactionStatusV2 = (query, params = {}) => this.request(__spreadValues({
+      path: `/v2/tx/status`,
+      method: "GET",
+      query,
+      format: "json"
+    }, params));
+    /**
+     * @description Get origin assets from a given list of denoms and chain IDs.
+     *
+     * @tags Fungible
+     * @name GetOriginAssets
+     * @request POST:/v2/fungible/ibc_origin_assets
+     */
+    this.getOriginAssets = (data, params = {}) => this.request(__spreadValues({
+      path: `/v2/fungible/ibc_origin_assets`,
+      method: "POST",
+      body: data,
+      type: "application/json" /* Json */,
+      format: "json"
+    }, params));
+    /**
+     * @description Given 2 chain IDs, returns a list of equivalent assets that can be transferred
+     *
+     * @tags Fungible
+     * @name FungibleAssetsBetweenChainsCreate
+     * @request POST:/v2/fungible/assets_between_chains
+     */
+    this.fungibleAssetsBetweenChainsCreate = (data, params = {}) => this.request(__spreadValues({
+      path: `/v2/fungible/assets_between_chains`,
+      method: "POST",
+      body: data,
+      type: "application/json" /* Json */,
+      format: "json"
+    }, params));
+  }
+};
+
+// src/private-functions/getRestEndpointForChain.ts
+var getRestEndpointForChain = (chainId) => __async(void 0, null, function* () {
+  var _a, _b, _c, _d, _e;
+  if (ClientState.endpointOptions.getRestEndpointForChain) {
+    return ClientState.endpointOptions.getRestEndpointForChain(chainId);
+  }
+  if (ClientState.endpointOptions.endpoints && ClientState.endpointOptions.endpoints[chainId]) {
+    const endpointOptions = ClientState.endpointOptions.endpoints[chainId];
+    if (endpointOptions == null ? void 0 : endpointOptions.rest) {
+      return endpointOptions.rest;
+    }
+  }
+  const chain = chains().find((chain2) => chain2.chain_id === chainId);
+  if (!chain) {
+    throw new Error(
+      `getRestEndpointForChain error: failed to find chain id '${chainId}' in registry`
+    );
+  }
+  if (((_b = (_a = chain.apis) == null ? void 0 : _a.rest) == null ? void 0 : _b.length) === 0 || !((_c = chain.apis) == null ? void 0 : _c.rest)) {
+    throw new Error(
+      `getRpcEndpointForChain error: failed to find RPC endpoint for chain '${chainId}'`
+    );
+  }
+  const endpoints = (_e = (_d = chain.apis) == null ? void 0 : _d.rest) == null ? void 0 : _e.map((api) => api.address);
+  const endpoint = yield findFirstWorkingEndpoint(endpoints, "rest");
+  if (!endpoint) {
+    throw new Error(
+      `getRestEndpointForChain error: failed to find REST endpoint for chain '${chainId}'`
+    );
+  }
+  return endpoint;
+});
+
+// src/private-functions/getAccountNumberAndSequence.ts
+var getAccountNumberAndSequence = (address, chainId) => __async(void 0, null, function* () {
+  var _a;
+  if (chainId.includes("dymension")) {
+    return getAccountNumberAndSequenceFromDymension(address, chainId);
+  }
+  const endpoint = yield getRpcEndpointForChain(chainId);
+  const client = (_a = ClientState.signingStargateClientByChainId[chainId]) != null ? _a : yield StargateClient.connect(endpoint, {
+    accountParser
+  });
+  const account = yield client.getAccount(address);
+  if (!account) {
+    throw new Error("getAccountNumberAndSequence: failed to retrieve account");
+  }
+  client.disconnect();
+  return {
+    accountNumber: account.accountNumber,
+    sequence: account.sequence
+  };
+});
+var getAccountNumberAndSequenceFromDymension = (address, chainId) => __async(void 0, null, function* () {
+  const endpoint = yield getRestEndpointForChain(chainId);
+  const jsonResponse = yield createRequestClient({
+    baseUrl: `${endpoint}/cosmos/auth/v1beta1/accounts/${address}`
+  }).get();
+  const response = toCamel(jsonResponse);
+  let sequence = 0;
+  let accountNumber = 0;
+  if (response.account.baseAccount) {
+    sequence = response.account.baseAccount.sequence;
+    accountNumber = response.account.baseAccount.accountNumber;
+  } else {
+    sequence = response.account.sequence;
+    accountNumber = response.account.accountNumber;
+  }
+  return {
+    accountNumber,
+    sequence
+  };
+});
+function createBaseClawbackVestingAccount() {
+  return {
+    baseVestingAccount: void 0,
+    funderAddress: "",
+    startTime: /* @__PURE__ */ new Date(),
+    lockupPeriods: [],
+    vestingPeriods: []
+  };
+}
+var ClawbackVestingAccount = {
+  typeUrl: "/evmos.vesting.v2.ClawbackVestingAccount",
+  encode(message, writer = _m0.Writer.create()) {
+    if (message.baseVestingAccount !== void 0) {
+      BaseVestingAccount.encode(message.baseVestingAccount, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.funderAddress !== "") {
+      writer.uint32(18).string(message.funderAddress);
+    }
+    if (message.startTime !== void 0) {
+      Timestamp.encode(toTimestamp(message.startTime), writer.uint32(26).fork()).ldelim();
+    }
+    for (const v of message.lockupPeriods) {
+      Period.encode(v, writer.uint32(34).fork()).ldelim();
+    }
+    for (const v of message.vestingPeriods) {
+      Period.encode(v, writer.uint32(42).fork()).ldelim();
+    }
+    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 = createBaseClawbackVestingAccount();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.baseVestingAccount = BaseVestingAccount.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.funderAddress = reader.string();
+          break;
+        case 3:
+          message.startTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          break;
+        case 4:
+          message.lockupPeriods.push(Period.decode(reader, reader.uint32()));
+          break;
+        case 5:
+          message.vestingPeriods.push(Period.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      baseVestingAccount: isSet(object.baseVestingAccount) ? BaseVestingAccount.fromJSON(object.baseVestingAccount) : void 0,
+      funderAddress: isSet(object.funderAddress) ? String(object.funderAddress) : "",
+      startTime: isSet(object.startTime) ? fromJsonTimestamp(object.startTime) : void 0,
+      lockupPeriods: Array.isArray(object == null ? void 0 : object.lockupPeriods) ? object.lockupPeriods.map((e) => Period.fromJSON(e)) : [],
+      vestingPeriods: Array.isArray(object == null ? void 0 : object.vestingPeriods) ? object.vestingPeriods.map((e) => Period.fromJSON(e)) : []
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    message.baseVestingAccount !== void 0 && (obj.baseVestingAccount = message.baseVestingAccount ? BaseVestingAccount.toJSON(message.baseVestingAccount) : void 0);
+    message.funderAddress !== void 0 && (obj.funderAddress = message.funderAddress);
+    message.startTime !== void 0 && (obj.startTime = message.startTime.toISOString());
+    if (message.lockupPeriods) {
+      obj.lockupPeriods = message.lockupPeriods.map((e) => e ? Period.toJSON(e) : void 0);
+    } else {
+      obj.lockupPeriods = [];
+    }
+    if (message.vestingPeriods) {
+      obj.vestingPeriods = message.vestingPeriods.map((e) => e ? Period.toJSON(e) : void 0);
+    } else {
+      obj.vestingPeriods = [];
+    }
+    return obj;
+  },
+  fromPartial(object) {
+    var _a, _b, _c, _d;
+    const message = createBaseClawbackVestingAccount();
+    message.baseVestingAccount = object.baseVestingAccount !== void 0 && object.baseVestingAccount !== null ? BaseVestingAccount.fromPartial(object.baseVestingAccount) : void 0;
+    message.funderAddress = (_a = object.funderAddress) != null ? _a : "";
+    message.startTime = (_b = object.startTime) != null ? _b : void 0;
+    message.lockupPeriods = ((_c = object.lockupPeriods) == null ? void 0 : _c.map((e) => Period.fromPartial(e))) || [];
+    message.vestingPeriods = ((_d = object.vestingPeriods) == null ? void 0 : _d.map((e) => Period.fromPartial(e))) || [];
+    return message;
+  },
+  fromAmino(object) {
+    var _a, _b;
+    const message = createBaseClawbackVestingAccount();
+    if (object.base_vesting_account !== void 0 && object.base_vesting_account !== null) {
+      message.baseVestingAccount = BaseVestingAccount.fromAmino(object.base_vesting_account);
+    }
+    if (object.funder_address !== void 0 && object.funder_address !== null) {
+      message.funderAddress = object.funder_address;
+    }
+    if (object.start_time !== void 0 && object.start_time !== null) {
+      message.startTime = fromTimestamp(Timestamp.fromAmino(object.start_time));
+    }
+    message.lockupPeriods = ((_a = object.lockup_periods) == null ? void 0 : _a.map((e) => Period.fromAmino(e))) || [];
+    message.vestingPeriods = ((_b = object.vesting_periods) == null ? void 0 : _b.map((e) => Period.fromAmino(e))) || [];
+    return message;
+  },
+  toAmino(message) {
+    const obj = {};
+    obj.base_vesting_account = message.baseVestingAccount ? BaseVestingAccount.toAmino(message.baseVestingAccount) : void 0;
+    obj.funder_address = message.funderAddress === "" ? void 0 : message.funderAddress;
+    obj.start_time = message.startTime ? Timestamp.toAmino(toTimestamp(message.startTime)) : void 0;
+    if (message.lockupPeriods) {
+      obj.lockup_periods = message.lockupPeriods.map((e) => e ? Period.toAmino(e) : void 0);
+    } else {
+      obj.lockup_periods = message.lockupPeriods;
+    }
+    if (message.vestingPeriods) {
+      obj.vesting_periods = message.vestingPeriods.map((e) => e ? Period.toAmino(e) : void 0);
+    } else {
+      obj.vesting_periods = message.vestingPeriods;
+    }
+    return obj;
+  },
+  fromAminoMsg(object) {
+    return ClawbackVestingAccount.fromAmino(object.value);
+  },
+  toAminoMsg(message) {
+    return {
+      type: "vesting/ClawbackVestingAccount",
+      value: ClawbackVestingAccount.toAmino(message)
+    };
+  },
+  fromProtoMsg(message) {
+    return ClawbackVestingAccount.decode(message.value);
+  },
+  toProto(message) {
+    return ClawbackVestingAccount.encode(message).finish();
+  },
+  toProtoMsg(message) {
+    return {
+      typeUrl: "/evmos.vesting.v2.ClawbackVestingAccount",
+      value: ClawbackVestingAccount.encode(message).finish()
+    };
+  }
+};
+
+// src/private-functions/cosmos/getEncodeObjectFromCosmosMessage.ts
+function getEncodeObjectFromCosmosMessage(message) {
+  var _a, _b;
+  const msgJson = JSON.parse((_a = message.msg) != null ? _a : "");
+  if (message.msgTypeUrl === "/ibc.applications.transfer.v1.MsgTransfer") {
+    return {
+      typeUrl: "/ibc.applications.transfer.v1.MsgTransfer",
+      value: MsgTransfer.fromJSON({
+        sourcePort: msgJson.source_port,
+        sourceChannel: msgJson.source_channel,
+        token: msgJson.token,
+        sender: msgJson.sender,
+        receiver: msgJson.receiver,
+        timeoutHeight: msgJson.timeout_height,
+        timeoutTimestamp: msgJson.timeout_timestamp,
+        memo: msgJson.memo
+      })
+    };
+  }
+  if (message.msgTypeUrl === "/cosmwasm.wasm.v1.MsgExecuteContract") {
+    return {
+      typeUrl: message.msgTypeUrl,
+      value: MsgExecuteContract.fromPartial({
+        sender: msgJson.sender,
+        contract: msgJson.contract,
+        msg: toUtf8(JSON.stringify(msgJson.msg)),
+        funds: msgJson.funds
+      })
+    };
+  }
+  if (message.msgTypeUrl === "/cosmos.bank.v1beta1.MsgSend") {
+    return {
+      typeUrl: message.msgTypeUrl,
+      value: MsgSend.fromPartial({
+        fromAddress: msgJson.from_address,
+        toAddress: msgJson.to_address,
+        amount: msgJson.amount
+      })
+    };
+  }
+  if (message.msgTypeUrl === "/circle.cctp.v1.MsgDepositForBurn") {
+    return {
+      typeUrl: message.msgTypeUrl,
+      value: MsgDepositForBurn.fromAmino(msgJson)
+    };
+  }
+  if (message.msgTypeUrl === "/circle.cctp.v1.MsgDepositForBurnWithCaller") {
+    return {
+      typeUrl: message.msgTypeUrl,
+      value: MsgDepositForBurnWithCaller.fromAmino(msgJson)
+    };
+  }
+  if (message.msgTypeUrl === "/initia.move.v1.MsgExecute") {
+    return {
+      typeUrl: message.msgTypeUrl,
+      value: MsgExecute.fromPartial({
+        sender: msgJson.sender,
+        moduleAddress: msgJson.module_address,
+        moduleName: msgJson.module_name,
+        functionName: msgJson.function_name,
+        args: msgJson.args
+      })
+    };
+  }
+  if (message.msgTypeUrl === "/opinit.ophost.v1.MsgInitiateTokenDeposit") {
+    return {
+      typeUrl: message.msgTypeUrl,
+      value: MsgInitiateTokenDeposit.fromPartial({
+        sender: msgJson.sender,
+        to: msgJson.to,
+        amount: msgJson.amount,
+        bridgeId: msgJson.bridge_id
+      })
+    };
+  }
+  if (message.msgTypeUrl === "/evmos.vesting.v2.ClawbackVestingAccount") {
+    return {
+      typeUrl: message.msgTypeUrl,
+      value: ClawbackVestingAccount.fromPartial({
+        baseVestingAccount: msgJson.base_vesting_account,
+        funderAddress: msgJson.funder_address,
+        lockupPeriods: msgJson.lockup_periods,
+        startTime: msgJson.start_time,
+        vestingPeriods: msgJson.vesting_periods
+      })
+    };
+  }
+  return {
+    typeUrl: (_b = message.msgTypeUrl) != null ? _b : "",
+    value: msgJson
+  };
+}
+function getEncodeObjectFromCosmosMessageInjective(message) {
+  var _a;
+  const msgJson = JSON.parse((_a = message.msg) != null ? _a : "");
+  if (message.msgTypeUrl === "/ibc.applications.transfer.v1.MsgTransfer") {
+    return MsgTransfer$1.fromJSON({
+      port: msgJson.source_port,
+      channelId: msgJson.source_channel,
+      amount: msgJson.token,
+      sender: msgJson.sender,
+      receiver: msgJson.receiver,
+      timeout: msgJson.timeout_timestamp,
+      memo: msgJson.memo
+    });
+  }
+  if (message.msgTypeUrl === "/cosmwasm.wasm.v1.MsgExecuteContract") {
+    return MsgExecuteContractCompat.fromJSON({
+      sender: msgJson.sender,
+      contractAddress: msgJson.contract,
+      msg: msgJson.msg,
+      funds: msgJson.funds
+    });
+  }
+  throw new Error("Unsupported message type");
+}
+function createTransaction({
+  chainId,
+  message,
+  timeoutHeight,
+  memo = "",
+  fee = DEFAULT_STD_FEE,
+  signMode = 1,
+  pubKey,
+  accountNumber,
+  sequence
+}) {
+  const signers = {
+    pubKey,
+    accountNumber,
+    sequence
+  };
+  return createTransactionWithSigners({
+    fee,
+    memo,
+    message,
+    signers,
+    chainId,
+    signMode,
+    timeoutHeight
+  });
+}
+
+// src/private-functions/cosmos/signCosmosMessageDirectEvmos.ts
+var signCosmosMessageDirectEvmos = (_0, _1, _2, _3, _4) => __async(void 0, [_0, _1, _2, _3, _4], function* (signerAddress, signer, cosmosMsgs, fee, { accountNumber, sequence, chainId }) {
+  const accounts = yield signer.getAccounts();
+  const accountFromSigner = accounts.find((account) => account.address === signerAddress);
+  if (!accountFromSigner) {
+    throw new Error("signCosmosMessageDirectEvmos: failed to retrieve account from signer");
+  }
+  const messages2 = cosmosMsgs.map(
+    (cosmosMsg) => getEncodeObjectFromCosmosMessageInjective(cosmosMsg)
+  );
+  const pk = Buffer.from(accountFromSigner.pubkey).toString("base64");
+  const { signDoc } = createTransaction({
+    pubKey: pk,
+    chainId,
+    message: messages2,
+    sequence,
+    accountNumber,
+    timeoutHeight: 0,
+    fee
+  });
+  const directSignResponse = yield signer.signDirect(signerAddress, signDoc);
+  return TxRaw.fromPartial({
+    bodyBytes: directSignResponse.signed.bodyBytes,
+    authInfoBytes: directSignResponse.signed.authInfoBytes,
+    signatures: [fromBase64(directSignResponse.signature.signature)]
+  });
+});
+var signCosmosMessageDirectInjective = (_0, _1, _2, _3, _4) => __async(void 0, [_0, _1, _2, _3, _4], function* (signerAddress, signer, cosmosMsgs, fee, { accountNumber, sequence, chainId }) {
+  const accounts = yield signer.getAccounts();
+  const accountFromSigner = accounts.find((account) => account.address === signerAddress);
+  if (!accountFromSigner) {
+    throw new Error("signCosmosMessageDirectInjective: failed to retrieve account from signer");
+  }
+  const restEndpoint = yield getRestEndpointForChain(chainId);
+  const chainRestTendermintApi = new ChainRestTendermintApi(restEndpoint);
+  const latestBlock = yield chainRestTendermintApi.fetchLatestBlock();
+  const latestHeight = latestBlock.header.height;
+  const timeoutHeight = new BigNumberInBase(latestHeight).plus(DEFAULT_BLOCK_TIMEOUT_HEIGHT);
+  const pk = Buffer.from(accountFromSigner.pubkey).toString("base64");
+  const messages2 = cosmosMsgs.map(
+    (cosmosMsg) => getEncodeObjectFromCosmosMessageInjective(cosmosMsg)
+  );
+  const { signDoc } = createTransaction({
+    pubKey: pk,
+    chainId,
+    message: messages2,
+    sequence,
+    accountNumber,
+    timeoutHeight: timeoutHeight.toNumber(),
+    fee
+  });
+  const directSignResponse = yield signer.signDirect(
+    signerAddress,
+    // @ts-expect-error TODO: Fix this
+    signDoc
+  );
+  return TxRaw.fromPartial({
+    bodyBytes: directSignResponse.signed.bodyBytes,
+    authInfoBytes: directSignResponse.signed.authInfoBytes,
+    signatures: [fromBase64(directSignResponse.signature.signature)]
+  });
+});
+var pubkeyType = __spreadValues({
+  ethsecp256k1: "ethermint/PubKeyEthSecp256k1"
+}, pubkeyType$1);
+
+// src/amino/encoding.ts
+function encodeEthSecp256k1Pubkey(pubkey) {
+  if (pubkey.length !== 33 || pubkey[0] !== 2 && pubkey[0] !== 3) {
+    throw new Error(
+      "Public key must be compressed secp256k1, i.e. 33 bytes starting with 0x02 or 0x03"
+    );
+  }
+  return {
+    type: pubkeyType.ethsecp256k1,
+    value: toBase64(pubkey)
+  };
+}
+
+// src/proto-signing/pubkey.ts
+function makePubkeyAnyFromAccount(account, chainId) {
+  const isEthermint = getIsEthermint(chainId);
+  const pubkey = isEthermint ? encodeEthSecp256k1Pubkey(account.pubkey) : encodeSecp256k1Pubkey(account.pubkey);
+  const pubkeyAny = encodePubkeyToAny(pubkey, chainId, isEthermint);
+  return pubkeyAny;
+}
+function encodePubkeyToAny(pubkey, chainId, isEthermint) {
+  if (isEthermint) {
+    const pubkeyProto = PubKey.fromPartial({
+      key: fromBase64$1(pubkey.value)
+    });
+    let typeUrl = "";
+    if (chainId == null ? void 0 : chainId.includes("injective")) {
+      typeUrl = "/injective.crypto.v1beta1.ethsecp256k1.PubKey";
+    } else {
+      typeUrl = "/ethermint.crypto.v1.ethsecp256k1.PubKey";
+    }
+    return Any.fromPartial({
+      typeUrl,
+      value: Uint8Array.from(PubKey.encode(pubkeyProto).finish())
+    });
+  } else {
+    const isInitia = getIsInitia(chainId);
+    const pubkeyProto = PubKey.fromPartial({
+      key: fromBase64$1(pubkey.value)
+    });
+    if (isInitia) {
+      return Any.fromPartial({
+        typeUrl: "/initia.crypto.v1beta1.ethsecp256k1.PubKey",
+        value: Uint8Array.from(PubKey.encode(pubkeyProto).finish())
+      });
+    }
+    return encodePubkey(pubkey);
+  }
+}
+var signCosmosMessageDirect = (options) => __async(void 0, null, function* () {
+  const {
+    signer,
+    signerAddress,
+    chainId,
+    cosmosMsgs,
+    fee,
+    signerData: { accountNumber, sequence, chainId: signerChainId }
+  } = options;
+  if (chainId.includes("evmos")) {
+    return signCosmosMessageDirectEvmos(signerAddress, signer, cosmosMsgs, fee, {
+      accountNumber,
+      sequence,
+      chainId: signerChainId
+    });
+  }
+  if (chainId.includes("injective")) {
+    return signCosmosMessageDirectInjective(signerAddress, signer, cosmosMsgs, fee, {
+      accountNumber,
+      sequence,
+      chainId: signerChainId
+    });
+  }
+  const accounts = yield signer.getAccounts();
+  const accountFromSigner = accounts.find((account) => account.address === signerAddress);
+  if (!accountFromSigner) {
+    throw new Error("signCosmosMessageDirect error: failed to retrieve account from signer");
+  }
+  const messages2 = cosmosMsgs.map((cosmosMsg) => getEncodeObjectFromCosmosMessage(cosmosMsg));
+  const txBodyEncodeObject = {
+    typeUrl: "/cosmos.tx.v1beta1.TxBody",
+    value: {
+      messages: messages2
+    }
+  };
+  const txBodyBytes = ClientState.registry.encode(txBodyEncodeObject);
+  const gasLimit = Int53.fromString(fee.gas).toNumber();
+  const pubkeyAny = makePubkeyAnyFromAccount(accountFromSigner, chainId);
+  const authInfoBytes = makeAuthInfoBytes(
+    [{ pubkey: pubkeyAny, sequence }],
+    fee.amount,
+    gasLimit,
+    fee.granter,
+    fee.payer
+  );
+  const signDoc = makeSignDoc(txBodyBytes, authInfoBytes, chainId, accountNumber);
+  const { signature, signed } = yield signer.signDirect(signerAddress, signDoc);
+  return TxRaw.fromPartial({
+    bodyBytes: signed.bodyBytes,
+    authInfoBytes: signed.authInfoBytes,
+    signatures: [fromBase64(signature.signature)]
+  });
+});
+var signCosmosMessageAmino = (options) => __async(void 0, null, function* () {
+  const {
+    signer,
+    signerAddress,
+    chainId,
+    cosmosMsgs,
+    fee,
+    signerData: { accountNumber, sequence, chainId: signerChainId }
+  } = options;
+  const accounts = yield signer.getAccounts();
+  const accountFromSigner = accounts.find((account) => account.address === signerAddress);
+  if (!accountFromSigner) {
+    throw new Error("signCosmosMessageAmino: failed to retrieve account from signer");
+  }
+  const messages2 = cosmosMsgs.map((cosmosMsg) => getEncodeObjectFromCosmosMessage(cosmosMsg));
+  const signMode = SignMode.SIGN_MODE_LEGACY_AMINO_JSON;
+  const msgs = messages2.map((msg) => ClientState.aminoTypes.toAmino(msg));
+  console.log("sign cosmos message amino", msgs, fee, signerChainId, "", accountNumber, sequence);
+  const signDoc = makeSignDoc$1(msgs, fee, signerChainId, "", accountNumber, sequence);
+  const { signature, signed } = yield signer.signAmino(signerAddress, signDoc);
+  const signedTxBody = {
+    messages: signed.msgs.map((msg) => ClientState.aminoTypes.fromAmino(msg)),
+    memo: signed.memo
+  };
+  signedTxBody.messages[0].value.memo = messages2[0].value.memo;
+  const signedTxBodyEncodeObject = {
+    typeUrl: "/cosmos.tx.v1beta1.TxBody",
+    value: signedTxBody
+  };
+  const signedTxBodyBytes = ClientState.registry.encode(signedTxBodyEncodeObject);
+  const signedGasLimit = Int53.fromString(signed.fee.gas).toNumber();
+  const signedSequence = Int53.fromString(signed.sequence).toNumber();
+  const pubkeyAny = makePubkeyAnyFromAccount(accountFromSigner, chainId);
+  const signedAuthInfoBytes = makeAuthInfoBytes(
+    [{ pubkey: pubkeyAny, sequence: signedSequence }],
+    signed.fee.amount,
+    signedGasLimit,
+    signed.fee.granter,
+    signed.fee.payer,
+    signMode
+  );
+  return TxRaw.fromPartial({
+    bodyBytes: signedTxBodyBytes,
+    authInfoBytes: signedAuthInfoBytes,
+    signatures: [fromBase64(signature.signature)]
+  });
+});
+
+// src/private-functions/cosmos/executeCosmosTransaction.ts
+var executeCosmosTransaction = (_0) => __async(void 0, [_0], function* ({
+  tx,
+  options,
+  index
+}) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const { userAddresses } = options;
+  if (tx === void 0) {
+    throw new Error("executeCosmosTransaction error: tx is undefined");
+  }
+  const chainId = (_a = tx.cosmosTx) == null ? void 0 : _a.chainId;
+  const messages2 = (_b = tx.cosmosTx) == null ? void 0 : _b.msgs;
+  const currentUserAddress = (_c = userAddresses.find((x) => {
+    var _a2;
+    return x.chainId === ((_a2 = tx.cosmosTx) == null ? void 0 : _a2.chainId);
+  })) == null ? void 0 : _c.address;
+  const gasArray = ClientState.validateGasResults;
+  const gas = gasArray == null ? void 0 : gasArray.find((gas2) => (gas2 == null ? void 0 : gas2.error) !== null && (gas2 == null ? void 0 : gas2.error) !== void 0);
+  if (typeof (gas == null ? void 0 : gas.error) === "string") {
+    throw new Error(gas == null ? void 0 : gas.error);
+  }
+  const gasUsed = gasArray == null ? void 0 : gasArray[index];
+  if (!gasUsed) {
+    throw new Error(`executeRoute error: invalid gas at index ${index}`);
+  }
+  if (chainId === void 0) {
+    throw new Error("no chainId found for tx");
+  }
+  if (messages2 === void 0) {
+    throw new Error("no messages found for tx");
+  }
+  const { stargateClient, signer } = yield getSigningStargateClient({
+    chainId,
+    getOfflineSigner: options == null ? void 0 : options.getCosmosSigner
+  });
+  if (!currentUserAddress) {
+    throw new Error(
+      `executeCosmosTransaction error: invalid address for chain '${(_d = tx.cosmosTx) == null ? void 0 : _d.chainId}'`
+    );
+  }
+  const accounts = yield signer.getAccounts();
+  const accountFromSigner = accounts.find((account) => account.address === currentUserAddress);
+  if (!accountFromSigner) {
+    throw new Error("executeCosmosTransaction error: failed to retrieve account from signer");
+  }
+  const fee = gasUsed == null ? void 0 : gasUsed.fee;
+  if (!fee) {
+    throw new Error("executeCosmosTransaction error: failed to retrieve fee from gas");
+  }
+  const { accountNumber, sequence } = yield getAccountNumberAndSequence(
+    currentUserAddress,
+    chainId
+  );
+  let rawTx;
+  const commonRawTxBody = {
+    signerAddress: currentUserAddress,
+    chainId,
+    cosmosMsgs: messages2,
+    fee,
+    signerData: {
+      accountNumber,
+      sequence,
+      chainId
+    }
+  };
+  if (isOfflineDirectSigner(signer)) {
+    rawTx = yield signCosmosMessageDirect(__spreadProps(__spreadValues({}, commonRawTxBody), {
+      signer
+    }));
+  } else {
+    rawTx = yield signCosmosMessageAmino(__spreadProps(__spreadValues({}, commonRawTxBody), { signer }));
+  }
+  (_e = options == null ? void 0 : options.onTransactionSigned) == null ? void 0 : _e.call(options, {
+    chainId
+  });
+  const txBytes = TxRaw.encode(rawTx).finish();
+  const txResponse = yield stargateClient.broadcastTx(txBytes);
+  return {
+    chainId: (_g = (_f = tx == null ? void 0 : tx.cosmosTx) == null ? void 0 : _f.chainId) != null ? _g : "",
+    txHash: txResponse.transactionHash
+  };
+});
+
+// src/constants/abis.ts
+function createAbi(abi) {
+  return abi;
+}
+var erc20ABI = /* @__PURE__ */ createAbi([
+  {
+    type: "event",
+    name: "Approval",
+    inputs: [
+      {
+        indexed: true,
+        name: "owner",
+        type: "address"
+      },
+      {
+        indexed: true,
+        name: "spender",
+        type: "address"
+      },
+      {
+        indexed: false,
+        name: "value",
+        type: "uint256"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "Transfer",
+    inputs: [
+      {
+        indexed: true,
+        name: "from",
+        type: "address"
+      },
+      {
+        indexed: true,
+        name: "to",
+        type: "address"
+      },
+      {
+        indexed: false,
+        name: "value",
+        type: "uint256"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "allowance",
+    stateMutability: "view",
+    inputs: [
+      {
+        name: "owner",
+        type: "address"
+      },
+      {
+        name: "spender",
+        type: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "approve",
+    stateMutability: "nonpayable",
+    inputs: [
+      {
+        name: "spender",
+        type: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    stateMutability: "view",
+    inputs: [
+      {
+        name: "account",
+        type: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "decimals",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint8"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "name",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "string"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "symbol",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "string"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "totalSupply",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint256"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "transfer",
+    stateMutability: "nonpayable",
+    inputs: [
+      {
+        name: "recipient",
+        type: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool"
+      }
+    ]
+  },
+  {
+    type: "function",
+    name: "transferFrom",
+    stateMutability: "nonpayable",
+    inputs: [
+      {
+        name: "sender",
+        type: "address"
+      },
+      {
+        name: "recipient",
+        type: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool"
+      }
+    ]
+  }
+]);
+
+// src/private-functions/evm/executeEvmTransaction.ts
+var executeEvmTransaction = (message, options) => __async(void 0, null, function* () {
+  const gasArray = ClientState.validateGasResults;
+  const gas = gasArray == null ? void 0 : gasArray.find((gas2) => (gas2 == null ? void 0 : gas2.error) !== null && (gas2 == null ? void 0 : gas2.error) !== void 0);
+  if (typeof (gas == null ? void 0 : gas.error) === "string") {
+    throw new Error(gas == null ? void 0 : gas.error);
+  }
+  const { evmTx } = message;
+  const getEvmSigner = options.getEvmSigner || ClientState.getEvmSigner;
+  if (!getEvmSigner) {
+    throw new Error("Unable to get EVM signer");
+  }
+  if (!(evmTx == null ? void 0 : evmTx.chainId)) {
+    throw new Error("chain id not found in evmTx");
+  }
+  const evmSigner = yield getEvmSigner(evmTx.chainId);
+  if (!evmSigner.account) {
+    throw new Error("executeEVMTransaction error: failed to retrieve account from signer");
+  }
+  if (!evmTx.chainId) {
+    throw new Error("executeEVMTransaction error: chainId not found for evmTx");
+  }
+  if (!evmTx.value) {
+    throw new Error("executeEVMTransaction error: no value found in evmTx");
+  }
+  const { onApproveAllowance, onTransactionSigned, bypassApprovalCheck, useUnlimitedApproval } = options;
+  const extendedSigner = evmSigner.extend(publicActions);
+  if (!bypassApprovalCheck && evmTx.requiredErc20Approvals) {
+    for (const requiredApproval of evmTx.requiredErc20Approvals) {
+      const allowance = yield extendedSigner.readContract({
+        address: requiredApproval.tokenContract,
+        abi: erc20ABI,
+        functionName: "allowance",
+        args: [
+          evmSigner.account.address,
+          requiredApproval.spender
+        ]
+      });
+      if (!requiredApproval.amount) {
+        throw new Error("executeEVMTransaction error: no amount found in a requiredApproval");
+      }
+      if (allowance > BigInt(requiredApproval.amount)) {
+        continue;
+      }
+      onApproveAllowance == null ? void 0 : onApproveAllowance({
+        status: "pending",
+        allowance: requiredApproval
+      });
+      const txHash2 = yield extendedSigner.writeContract({
+        account: evmSigner.account,
+        address: requiredApproval.tokenContract,
+        abi: erc20ABI,
+        functionName: "approve",
+        args: [
+          requiredApproval.spender,
+          useUnlimitedApproval ? maxUint256 : BigInt(requiredApproval.amount) + BigInt(1e3)
+        ],
+        chain: evmSigner.chain
+      });
+      const receipt2 = yield extendedSigner.waitForTransactionReceipt({
+        hash: txHash2
+      });
+      if (receipt2.status === "reverted") {
+        throw new Error(
+          `executeEVMTransaction error: evm tx reverted for hash ${receipt2.transactionHash}`
+        );
+      }
+    }
+    onApproveAllowance == null ? void 0 : onApproveAllowance({
+      status: "completed"
+    });
+  }
+  const txHash = yield extendedSigner.sendTransaction({
+    account: evmSigner.account,
+    to: evmTx.to,
+    data: `0x${evmTx.data}`,
+    chain: evmSigner.chain,
+    value: evmTx.value === "" ? void 0 : BigInt(evmTx.value)
+  });
+  onTransactionSigned == null ? void 0 : onTransactionSigned({
+    chainId: evmTx.chainId
+  });
+  const receipt = yield extendedSigner.waitForTransactionReceipt({
+    hash: txHash
+  });
+  return receipt;
+});
+var executeSvmTransaction = (tx, options) => __async(void 0, null, function* () {
+  var _a, _b, _c;
+  const gasArray = ClientState.validateGasResults;
+  if (tx === void 0) {
+    throw new Error("executeSvmTransaction error: tx is undefined");
+  }
+  const gas = gasArray == null ? void 0 : gasArray.find((gas2) => (gas2 == null ? void 0 : gas2.error) !== null && (gas2 == null ? void 0 : gas2.error) !== void 0);
+  if (typeof (gas == null ? void 0 : gas.error) === "string") {
+    throw new Error(gas == null ? void 0 : gas.error);
+  }
+  const svmTx = tx == null ? void 0 : tx.svmTx;
+  const getSvmSigner = (options == null ? void 0 : options.getSvmSigner) || ClientState.getSvmSigner;
+  if (!getSvmSigner) {
+    throw new Error(
+      "executeRoute error: 'getSVMSigner' is not provided or configured in skip router"
+    );
+  }
+  const signer = yield getSvmSigner();
+  if (!(svmTx == null ? void 0 : svmTx.chainId)) {
+    throw new Error("executeSvmTransaction error: chainId not found in svmTx");
+  }
+  const txBuffer = Buffer.from((_a = svmTx.tx) != null ? _a : "", "base64");
+  const transaction = Transaction.from(txBuffer);
+  const endpoint = yield getRpcEndpointForChain(svmTx.chainId);
+  const connection = new Connection(endpoint);
+  let signature;
+  if ("signTransaction" in signer) {
+    const signedTx = yield signer.signTransaction(transaction);
+    (_b = options == null ? void 0 : options.onTransactionSigned) == null ? void 0 : _b.call(options, { chainId: svmTx.chainId });
+    const serializedTx = signedTx.serialize();
+    yield submitTransaction({
+      chainId: svmTx.chainId,
+      tx: serializedTx.toString("base64")
+    }).then((res) => {
+      signature = res == null ? void 0 : res.txHash;
+    });
+    const rpcSig = yield connection.sendRawTransaction(serializedTx, {
+      preflightCommitment: "confirmed",
+      maxRetries: 5
+    });
+    signature = rpcSig;
+  }
+  if (!signature) {
+    throw new Error("executeSvmTransaction error: signature not found");
+  }
+  let getStatusCount = 0;
+  let errorCount = 0;
+  while (true) {
+    try {
+      const status = yield connection.getSignatureStatus(signature, {
+        searchTransactionHistory: true
+      });
+      if (((_c = status == null ? void 0 : status.value) == null ? void 0 : _c.confirmationStatus) === "confirmed") {
+        return {
+          chainId: svmTx.chainId,
+          txHash: signature
+        };
+      }
+      if (getStatusCount > 12) {
+        yield wait(3e3);
+        throw new Error(
+          `executeSvmTransaction error: waiting finalized status timed out for ${signature}`
+        );
+      }
+      getStatusCount++;
+      yield wait(3e3);
+    } catch (error) {
+      errorCount++;
+      if (errorCount > 12) {
+        throw error;
+      }
+    }
+  }
+});
+
+// src/private-functions/cosmos/getCosmosGasAmountForMessage.ts
+var DEFAULT_GAS_MULTIPLIER = 1.5;
+function getCosmosGasAmountForMessage(_0, _1, _2, _3, _4) {
+  return __async(this, arguments, function* (client, signerAddress, chainId, messages2, encodedMsgs, multiplier = DEFAULT_GAS_MULTIPLIER) {
+    if (!messages2 && !encodedMsgs) {
+      throw new Error("Either message or encodedMsg must be provided");
+    }
+    const _encodedMsgs = messages2 == null ? void 0 : messages2.map((message) => getEncodeObjectFromCosmosMessage(message));
+    encodedMsgs = encodedMsgs || _encodedMsgs;
+    if (!encodedMsgs) {
+      throw new Error("Either message or encodedMsg must be provided");
+    }
+    if (chainId.includes("evmos") || chainId.includes("injective") || chainId.includes("dymension") || (process == null ? void 0 : process.env.NODE_ENV) === "test") {
+      if (messages2 == null ? void 0 : messages2.find((i) => i.msgTypeUrl === "/cosmwasm.wasm.v1.MsgExecuteContract")) {
+        return "2400000";
+      }
+      return "280000";
+    }
+    const estimatedGas = yield client.simulate(signerAddress, encodedMsgs, "");
+    const estimatedGasWithBuffer = estimatedGas * multiplier;
+    return Math.ceil(estimatedGasWithBuffer).toFixed(0);
+  });
+}
+
+// src/private-functions/cosmos/validateCosmosGasBalance.ts
+var validateCosmosGasBalance = (_0) => __async(void 0, [_0], function* ({
+  chainId,
+  signerAddress,
+  messages: messages2,
+  getFallbackGasAmount,
+  getOfflineSigner,
+  txIndex,
+  simulate
+}) {
+  var _a, _b, _c;
+  const skipAssets = (_a = yield ClientState.getSkipAssets({ chainId })) == null ? void 0 : _a[chainId];
+  const skipChains = yield ClientState.getSkipChains();
+  const chain = skipChains == null ? void 0 : skipChains.find((c) => c.chainId === chainId);
+  if (!chain) {
+    throw new Error(`failed to find chain id for '${chainId}'`);
+  }
+  const { feeAssets } = chain;
+  if (!feeAssets) {
+    throw new Error(`failed to find fee assets for chain '${chainId}'`);
+  }
+  const estimatedGasAmount = yield (() => __async(void 0, null, function* () {
+    try {
+      if (!simulate) throw new Error("simulate");
+      if (txIndex !== 0 && chainId === "noble-1") {
+        return "0";
+      }
+      const { stargateClient } = yield getSigningStargateClient({
+        chainId,
+        getOfflineSigner
+      });
+      const estimatedGas = yield getCosmosGasAmountForMessage(
+        stargateClient,
+        signerAddress,
+        chainId,
+        messages2
+      );
+      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 = yield getFallbackGasAmount(chainId, "cosmos" /* Cosmos */);
+        if (!fallbackGasAmount) {
+          throw new Error(`unable to estimate gas for message(s) ${messages2}`);
+        }
+        return String(fallbackGasAmount);
+      }
+      throw error;
+    }
+  }))();
+  const fees = feeAssets.map((asset) => {
+    const gasPrice = (() => {
+      var _a2;
+      if (!(asset == null ? void 0 : 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),
+        (_a2 = asset == null ? void 0 : asset.denom) != null ? _a2 : ""
+      );
+    })();
+    if (!gasPrice) {
+      return null;
+    }
+    if (chainId === "noble-1") {
+      const fee = calculateFee(2e5, gasPrice);
+      return fee;
+    }
+    return calculateFee(Math.ceil(parseFloat(estimatedGasAmount)), gasPrice);
+  });
+  const feeBalance = yield balances({
+    chains: {
+      [chainId]: {
+        address: signerAddress,
+        denoms: feeAssets.map((asset) => {
+          var _a2;
+          return (_a2 = asset.denom) != null ? _a2 : "";
+        })
+      }
+    }
+  });
+  const validatedAssets = feeAssets.map((asset, index) => {
+    var _a2, _b2, _c2, _d, _e, _f, _g, _h, _i, _j;
+    const chainAsset = skipAssets == null ? void 0 : skipAssets.find((x) => x.denom === asset.denom);
+    const symbol = (_a2 = chainAsset == null ? void 0 : chainAsset.recommendedSymbol) == null ? void 0 : _a2.toUpperCase();
+    const decimal = Number(chainAsset == null ? void 0 : chainAsset.decimals);
+    if (!chainAsset) {
+      return {
+        error: `(${chain == null ? void 0 : chain.prettyName}) Unable to find asset for ${asset.denom}`
+      };
+    }
+    if (isNaN(decimal))
+      return {
+        error: `(${chain == null ? void 0 : chain.prettyName}) Unable to find decimal for ${symbol}`
+      };
+    const fee = fees[index];
+    if (!fee) {
+      return {
+        error: `(${chain == null ? void 0 : chain.prettyName}) Unable to calculate fee for ${symbol}`,
+        asset
+      };
+    }
+    if (txIndex !== 0 && chainId === "noble-1") {
+      return {
+        error: null,
+        asset,
+        fee
+      };
+    }
+    let balance = (_e = (_c2 = (_b2 = feeBalance == null ? void 0 : feeBalance.chains) == null ? void 0 : _b2[chainId]) == null ? void 0 : _c2.denoms) == null ? void 0 : _e[(_d = asset == null ? void 0 : asset.denom) != null ? _d : ""];
+    if (!balance) {
+      balance = {
+        amount: "0",
+        formattedAmount: "0"
+      };
+    }
+    if (!((_f = fee.amount[0]) == null ? void 0 : _f.amount)) {
+      return {
+        error: `(${chain == null ? void 0 : chain.prettyName}) Unable to get fee for ${symbol}`,
+        asset
+      };
+    }
+    if (parseInt((_g = balance == null ? void 0 : balance.amount) != null ? _g : "") < parseInt((_h = fee.amount[0]) == null ? void 0 : _h.amount)) {
+      const userAmount = new BigNumber(parseFloat((_i = balance == null ? void 0 : balance.amount) != null ? _i : "")).shiftedBy(-decimal).toFixed(decimal);
+      const feeAmount = new BigNumber(parseFloat((_j = fee.amount[0]) == null ? void 0 : _j.amount)).shiftedBy(-decimal).toFixed(decimal);
+      return {
+        error: `Insufficient balance for gas on ${chain == null ? void 0 : chain.prettyName}. Need ${feeAmount} ${symbol} but only have ${userAmount} ${symbol}.`,
+        asset
+      };
+    }
+    return {
+      error: null,
+      asset,
+      fee
+    };
+  });
+  const feeUsed = validatedAssets.find((res) => (res == null ? void 0 : res.error) === null);
+  if (!feeUsed) {
+    if (validatedAssets.length > 1) {
+      throw new Error(
+        ((_b = validatedAssets[0]) == null ? void 0 : _b.error) || `Insufficient fee token to initiate transfer on ${chainId}.`
+      );
+    }
+    throw new Error(
+      ((_c = validatedAssets[0]) == null ? void 0 : _c.error) || `Insufficient fee token to initiate transfer on ${chainId}.`
+    );
+  }
+  return feeUsed;
+});
+var validateEvmTokenApproval = (_0) => __async(void 0, [_0], function* ({
+  requiredErc20Approvals,
+  signer,
+  chain,
+  gasBalance,
+  tx,
+  useUnlimitedApproval
+}) {
+  var _a, _b;
+  if (!((_a = signer.account) == null ? void 0 : _a.address)) {
+    throw new Error("validateEvmGasBalance: Signer address not found");
+  }
+  for (const requiredApproval of requiredErc20Approvals) {
+    const extendedSigner = signer.extend(publicActions);
+    const allowance = yield extendedSigner.readContract({
+      address: requiredApproval.tokenContract,
+      abi: erc20ABI,
+      functionName: "allowance",
+      args: [(_b = signer.account) == null ? void 0 : _b.address, requiredApproval.spender]
+    });
+    if (allowance > BigInt(requiredApproval.amount)) {
+      continue;
+    }
+    const fee = yield extendedSigner.estimateFeesPerGas();
+    const allowanceGasFee = BigInt(fee.maxFeePerGas) * BigInt(1e5);
+    if (!gasBalance) {
+      const chainAssets = (yield ClientState.getSkipAssets({ chainId: tx.chainId }))[tx.chainId];
+      const nativeAsset = chainAssets == null ? void 0 : chainAssets.find((x) => x.denom.includes("-native"));
+      const zeroAddressAsset = chainAssets == null ? void 0 : chainAssets.find(
+        (x) => x.denom.toLowerCase() === "0x0000000000000000000000000000000000000000"
+      );
+      const asset = nativeAsset || zeroAddressAsset;
+      if (!(asset == null ? void 0 : asset.decimals)) {
+        throw new Error(
+          `Insufficient balance for gas on ${chain.prettyName}. Need ${allowanceGasFee} gwei.`
+        );
+      }
+      const formattedGasAmount = formatUnits(allowanceGasFee, asset == null ? void 0 : asset.decimals);
+      throw new Error(
+        `Insufficient balance for gas on ${chain.prettyName}. Need ${formattedGasAmount} ${asset.symbol}.`
+      );
+    }
+    if (BigNumber(gasBalance.amount).lt(Number(allowanceGasFee))) {
+      const chainAssets = (yield ClientState.getSkipAssets({ chainId: tx.chainId }))[tx.chainId];
+      const asset = chainAssets == null ? void 0 : chainAssets.find(
+        (x) => x.denom.includes("-native") || x.denom.toLowerCase() === "0x0000000000000000000000000000000000000000"
+      );
+      if (!(asset == null ? void 0 : asset.decimals)) {
+        return {
+          error: `Insufficient balance for gas on ${chain.prettyName}. Need ${allowanceGasFee} gwei but only have ${gasBalance.amount} gwei.`,
+          asset: null,
+          fee: null
+        };
+      }
+      const formattedGasAmount = formatUnits(allowanceGasFee, asset == null ? void 0 : asset.decimals);
+      return {
+        error: `Insufficient balance for gas on ${chain.prettyName}. Need ${formattedGasAmount} ${asset.symbol} but only have ${gasBalance.formattedAmount} ${asset.symbol}.`,
+        asset: null,
+        fee: null
+      };
+    }
+    const txHash = yield extendedSigner.writeContract({
+      account: signer.account,
+      address: requiredApproval.tokenContract,
+      abi: erc20ABI,
+      functionName: "approve",
+      args: [
+        requiredApproval.spender,
+        useUnlimitedApproval ? maxUint256 : BigInt(requiredApproval.amount) + BigInt(1e3)
+      ],
+      chain: signer.chain
+    });
+    const receipt = yield extendedSigner.waitForTransactionReceipt({
+      hash: txHash
+    });
+    if (receipt.status === "reverted") {
+      throw new Error(
+        `executeEVMTransaction error: evm tx reverted for hash ${receipt.transactionHash}`
+      );
+    }
+  }
+});
+function getEVMGasAmountForMessage(signer, tx, getFallbackGasAmount) {
+  return __async(this, null, function* () {
+    var _a;
+    const { to, data, value } = tx;
+    if (!signer.account) throw new Error("estimateGasForEvmTx: No account found");
+    const extendedSigner = signer.extend(publicActions);
+    const fee = yield extendedSigner.estimateFeesPerGas();
+    try {
+      const gasAmount = yield extendedSigner.estimateGas({
+        account: signer.account,
+        to,
+        data: `0x${data}`,
+        value: value === "" ? void 0 : BigInt(value != null ? value : "")
+      });
+      return gasAmount * fee.maxFeePerGas;
+    } catch (error) {
+      const fallbackGasAmount = yield getFallbackGasAmount == null ? void 0 : getFallbackGasAmount((_a = tx.chainId) != null ? _a : "", "evm" /* Evm */);
+      if (fallbackGasAmount) {
+        return BigInt(fallbackGasAmount) * fee.maxFeePerGas;
+      }
+      throw error;
+    }
+  });
+}
+
+// src/private-functions/evm/validateEvmGasBalance.ts
+var validateEvmGasBalance = (_0) => __async(void 0, [_0], function* ({
+  signer,
+  tx,
+  getFallbackGasAmount,
+  useUnlimitedApproval
+}) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+  const chainId = (_a = tx == null ? void 0 : tx.chainId) != null ? _a : "";
+  const skipAssets = (_b = yield ClientState.getSkipAssets({ chainId })) == null ? void 0 : _b[chainId];
+  const skipChains = yield ClientState.getSkipChains();
+  const chain = (_c = skipChains == null ? void 0 : skipChains.find) == null ? void 0 : _c.call(skipChains, (chain2) => chain2.chainId === chainId);
+  if (!chain) {
+    throw new Error(`failed to find chain for chainId: '${chainId}'`);
+  }
+  if (!((_d = signer.account) == null ? void 0 : _d.address)) {
+    throw new Error("validateEvmGasBalance: Signer address not found");
+  }
+  const skipBalances = (_j = (_i = (_g = yield balances({
+    chains: {
+      [(_e = tx == null ? void 0 : tx.chainId) != null ? _e : ""]: {
+        address: (_f = signer.account) == null ? void 0 : _f.address
+      }
+    }
+  })) == null ? void 0 : _g.chains) == null ? void 0 : _i[(_h = tx == null ? void 0 : tx.chainId) != null ? _h : ""]) == null ? void 0 : _j.denoms;
+  const nativeGasBalance = skipBalances && ((_k = Object.entries(skipBalances).find(([denom]) => denom.includes("-native"))) == null ? void 0 : _k[1]);
+  const zeroAddressGasBalance = skipBalances && ((_l = Object.entries(skipBalances).find(
+    ([denom]) => denom.toLowerCase() === "0x0000000000000000000000000000000000000000"
+  )) == null ? void 0 : _l[1]);
+  const gasBalance = nativeGasBalance || zeroAddressGasBalance;
+  const { requiredErc20Approvals } = tx;
+  if (requiredErc20Approvals) {
+    try {
+      yield validateEvmTokenApproval({
+        requiredErc20Approvals,
+        signer,
+        chain,
+        gasBalance,
+        tx,
+        useUnlimitedApproval
+      });
+    } catch (error) {
+      const err = error;
+      return {
+        error: err.message,
+        asset: null,
+        fee: null
+      };
+    }
+  }
+  const gasAmount = yield getEVMGasAmountForMessage(signer, tx, getFallbackGasAmount);
+  if (!gasBalance) {
+    const nativeAsset = skipAssets == null ? void 0 : skipAssets.find((x) => {
+      var _a2;
+      return (_a2 = x.denom) == null ? void 0 : _a2.includes("-native");
+    });
+    const zeroAddressAsset = skipAssets == null ? void 0 : skipAssets.find(
+      (x) => {
+        var _a2;
+        return ((_a2 = x.denom) == null ? void 0 : _a2.toLowerCase()) === "0x0000000000000000000000000000000000000000";
+      }
+    );
+    const asset = nativeAsset || zeroAddressAsset;
+    if (!(asset == null ? void 0 : asset.decimals)) {
+      return {
+        error: `Insufficient balance for gas on ${chain.prettyName}. Need ${gasAmount} gwei.`,
+        asset: null,
+        fee: null
+      };
+    }
+    const formattedGasAmount = formatUnits(gasAmount, asset == null ? void 0 : asset.decimals);
+    return {
+      error: `Insufficient balance for gas on ${chain.prettyName}. Need ${formattedGasAmount} ${asset.symbol}.`,
+      asset: null,
+      fee: null
+    };
+  }
+  if (BigNumber((_m = gasBalance.amount) != null ? _m : "").lt(Number(gasAmount))) {
+    const asset = skipAssets == null ? void 0 : skipAssets.find(
+      (x) => {
+        var _a2, _b2;
+        return ((_a2 = x.denom) == null ? void 0 : _a2.includes("-native")) || ((_b2 = x.denom) == null ? void 0 : _b2.toLowerCase()) === "0x0000000000000000000000000000000000000000";
+      }
+    );
+    if (!(asset == null ? void 0 : asset.decimals)) {
+      return {
+        error: `Insufficient balance for gas on ${chain.prettyName}. Need ${gasAmount} gwei but only have ${gasBalance.amount} gwei.`,
+        asset: null,
+        fee: null
+      };
+    }
+    const formattedGasAmount = formatUnits(gasAmount, asset == null ? void 0 : asset.decimals);
+    return {
+      error: `Insufficient balance for gas on ${chain.prettyName}. Need ${formattedGasAmount} ${asset.symbol} but only have ${gasBalance.formattedAmount} ${asset.symbol}.`,
+      asset: null,
+      fee: null
+    };
+  }
+});
+var validateSvmGasBalance = (_0) => __async(void 0, [_0], function* ({
+  tx
+}) {
+  var _a, _b, _c;
+  if (!tx) throw new Error("Transaction is required");
+  const endpoint = yield getRpcEndpointForChain((_a = tx.chainId) != null ? _a : "");
+  const connection = new Connection(endpoint);
+  if (!connection) throw new Error(`Failed to connect to ${tx.chainId}`);
+  if (!tx.tx) {
+    throw new Error("Transaction is required");
+  }
+  const txBuffer = Buffer.from(tx.tx, "base64");
+  let transaction;
+  try {
+    transaction = Transaction.from(txBuffer);
+  } catch (decodeError) {
+    return {
+      success: false,
+      error: { decodeError: decodeError.message },
+      asset: null,
+      fee: null
+    };
+  }
+  const simulation = yield connection.simulateTransaction(transaction);
+  if (simulation.value.err) {
+    const logs = (_b = simulation.value.logs) != null ? _b : [];
+    const shortfall = getSolShortfall(logs);
+    const insufficientLamports = logs.some((log) => log.includes("insufficient lamports")) && shortfall !== null;
+    const insufficientFundsForRent = Object.keys(simulation.value.err).includes(
+      "InsufficientFundsForRent"
+    );
+    const errMsg = insufficientLamports ? `Insufficient balance for gas on Solana. You need ${shortfall.toFixed(6)} SOL to proceed.` : insufficientFundsForRent ? "Insufficient funds for rent on Solana. You need to fund your account." : "Simulation failed";
+    return {
+      success: false,
+      logs,
+      error: errMsg,
+      asset: null,
+      fee: null
+    };
+  }
+  return {
+    success: true,
+    logs: (_c = simulation.value.logs) != null ? _c : [],
+    error: null,
+    asset: null,
+    fee: null
+  };
+});
+function getSolShortfall(logs) {
+  var _a, _b;
+  const line = logs.find((l) => l.includes("insufficient lamports"));
+  if (!line) return null;
+  const m = line.match(/insufficient lamports (\d+), need (\d+)/);
+  if (!m) return null;
+  const have = parseInt((_a = m[1]) != null ? _a : "0", 10);
+  const need = parseInt((_b = m[2]) != null ? _b : "0", 10);
+  const shortfallLamports = need - have;
+  return shortfallLamports / LAMPORTS_PER_SOL;
+}
+
+// src/private-functions/validateGasBalances.ts
+var validateGasBalances = (_0) => __async(void 0, [_0], function* ({
+  txs,
+  onValidateGasBalance,
+  getFallbackGasAmount,
+  getCosmosSigner,
+  getEvmSigner,
+  simulate,
+  disabledChainIds,
+  enabledChainIds,
+  useUnlimitedApproval
+}) {
+  if (txs.every((tx) => "cosmosTx" in tx === void 0) || txs.every((tx) => "svmTx" in tx === void 0)) {
+    return;
+  }
+  onValidateGasBalance == null ? void 0 : onValidateGasBalance({
+    status: "pending"
+  });
+  const validateResult = yield Promise.all(
+    txs.map((tx, i) => __async(void 0, null, function* () {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s;
+      if (!tx) {
+        throw new Error(`invalid tx at index ${i}`);
+      }
+      if ("cosmosTx" in tx && !(disabledChainIds == null ? void 0 : disabledChainIds.includes((_b = (_a = tx == null ? void 0 : tx.cosmosTx) == null ? void 0 : _a.chainId) != null ? _b : "")) && (enabledChainIds === void 0 || enabledChainIds.includes((_d = (_c = tx == null ? void 0 : tx.cosmosTx) == null ? void 0 : _c.chainId) != null ? _d : ""))) {
+        if (!((_e = tx == null ? void 0 : tx.cosmosTx) == null ? void 0 : _e.msgs)) {
+          throw new Error(`invalid msgs ${(_f = tx == null ? void 0 : tx.cosmosTx) == null ? void 0 : _f.msgs}`);
+        }
+        try {
+          const res = yield validateCosmosGasBalance({
+            chainId: (_g = tx.cosmosTx.chainId) != null ? _g : "",
+            signerAddress: (_h = tx.cosmosTx.signerAddress) != null ? _h : "",
+            messages: tx.cosmosTx.msgs,
+            getFallbackGasAmount,
+            getOfflineSigner: getCosmosSigner,
+            txIndex: i,
+            simulate
+          });
+          return res;
+        } catch (e) {
+          const error = e;
+          return {
+            error: error.message,
+            asset: null,
+            fee: null
+          };
+        }
+      }
+      if ("evmTx" in tx && !(disabledChainIds == null ? void 0 : disabledChainIds.includes((_j = (_i = tx == null ? void 0 : tx.evmTx) == null ? void 0 : _i.chainId) != null ? _j : "")) && (enabledChainIds === void 0 || enabledChainIds.includes((_l = (_k = tx == null ? void 0 : tx.evmTx) == null ? void 0 : _k.chainId) != null ? _l : ""))) {
+        const signer = yield getEvmSigner == null ? void 0 : getEvmSigner((_n = (_m = tx == null ? void 0 : tx.evmTx) == null ? void 0 : _m.chainId) != null ? _n : "");
+        if (!signer) {
+          throw new Error(`failed to get signer for chain ${(_o = tx == null ? void 0 : tx.evmTx) == null ? void 0 : _o.chainId}`);
+        }
+        try {
+          const res = yield validateEvmGasBalance({
+            tx: tx.evmTx,
+            signer,
+            getFallbackGasAmount,
+            useUnlimitedApproval
+          });
+          return res;
+        } catch (e) {
+          const error = e;
+          return {
+            error: error.message,
+            asset: null,
+            fee: null
+          };
+        }
+      }
+      if ("svmTx" in tx && !(disabledChainIds == null ? void 0 : disabledChainIds.includes((_q = (_p = tx == null ? void 0 : tx.svmTx) == null ? void 0 : _p.chainId) != null ? _q : "")) && (enabledChainIds === void 0 || enabledChainIds.includes((_s = (_r = tx == null ? void 0 : tx.svmTx) == null ? void 0 : _r.chainId) != null ? _s : ""))) {
+        try {
+          const res = yield validateSvmGasBalance({
+            tx: tx.svmTx
+          });
+          return res;
+        } catch (e) {
+          const error = e;
+          return {
+            error: error.message,
+            asset: null,
+            fee: null
+          };
+        }
+      }
+    }))
+  );
+  if (validateResult.filter(Boolean).length === 0) {
+    return;
+  }
+  const txError = validateResult.find((res) => res && (res == null ? void 0 : res.error) !== null);
+  if (txError) {
+    onValidateGasBalance == null ? void 0 : onValidateGasBalance({
+      status: "error"
+    });
+    ClientState.validateGasResults = validateResult;
+    throw new Error(`${txError.error}`);
+  }
+  onValidateGasBalance == null ? void 0 : onValidateGasBalance({
+    status: "completed"
+  });
+  ClientState.validateGasResults = validateResult;
+});
+
+// src/private-functions/waitForTransaction.ts
+var waitForTransaction = (_0) => __async(void 0, [_0], function* ({
+  chainId,
+  txHash,
+  onTransactionTracked
+}) {
+  var _a, _b;
+  const { explorerLink } = yield trackTransaction({
+    chainId,
+    txHash
+  });
+  yield onTransactionTracked == null ? void 0 : onTransactionTracked({ txHash, chainId, explorerLink });
+  while (true) {
+    const txStatusResponse = yield transactionStatus({
+      chainId,
+      txHash
+    });
+    if (txStatusResponse.state === "STATE_COMPLETED_SUCCESS") {
+      return txStatusResponse;
+    }
+    if (txStatusResponse.state === "STATE_COMPLETED_ERROR") {
+      throw new Error(`${(_a = txStatusResponse.error) == null ? void 0 : _a.type}: ${(_b = txStatusResponse.error) == null ? void 0 : _b.message}`);
+    }
+    if (txStatusResponse.state === "STATE_ABANDONED") {
+      throw new Error("Tracking for the transaction has been abandoned");
+    }
+    yield wait(1e3);
+  }
+});
+
+// src/private-functions/executeTransactions.ts
+var executeTransactions = (options) => __async(void 0, null, function* () {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const {
+    txs,
+    onTransactionBroadcast,
+    onTransactionCompleted,
+    simulate = true,
+    batchSimulate = true
+  } = options;
+  if (txs === void 0) {
+    throw new Error("executeTransactions error: txs is undefined in executeTransactions");
+  }
+  const chainIds = txs.map((tx) => {
+    var _a2, _b2, _c2;
+    if ("cosmosTx" in tx) {
+      return {
+        chainType: "cosmos",
+        chainId: (_a2 = tx.cosmosTx) == null ? void 0 : _a2.chainId
+      };
+    }
+    if ("svmTx" in tx) {
+      return {
+        chainType: "svm",
+        chainId: (_b2 = tx.svmTx) == null ? void 0 : _b2.chainId
+      };
+    }
+    if ("evmTx" in tx) {
+      return {
+        chainType: "evm",
+        chainId: (_c2 = tx.evmTx) == null ? void 0 : _c2.chainId
+      };
+    }
+  });
+  const isGasStationSourceEVM = chainIds.find((item, i, array) => {
+    var _a2, _b2;
+    return GAS_STATION_CHAIN_IDS.includes((_a2 = item == null ? void 0 : item.chainId) != null ? _a2 : "") && ((_b2 = array[i - 1]) == null ? void 0 : _b2.chainType) === "evm";
+  });
+  ClientState.validateGasResults = void 0;
+  const validateChainIds = !batchSimulate ? chainIds.map((x) => {
+    var _a2;
+    return (_a2 = x == null ? void 0 : x.chainId) != null ? _a2 : "";
+  }) : isGasStationSourceEVM ? GAS_STATION_CHAIN_IDS : [];
+  yield validateGasBalances({
+    txs,
+    getFallbackGasAmount: options.getFallbackGasAmount,
+    getCosmosSigner: options.getCosmosSigner,
+    getEvmSigner: options.getEvmSigner,
+    onValidateGasBalance: options.onValidateGasBalance,
+    simulate,
+    disabledChainIds: validateChainIds
+  });
+  const validateEnabledChainIds = (chainId) => __async(void 0, null, function* () {
+    yield validateGasBalances({
+      txs,
+      getFallbackGasAmount: options.getFallbackGasAmount,
+      getCosmosSigner: options.getCosmosSigner,
+      getEvmSigner: options.getEvmSigner,
+      onValidateGasBalance: options.onValidateGasBalance,
+      simulate,
+      enabledChainIds: !batchSimulate ? [chainId] : validateChainIds
+    });
+  });
+  for (let i = 0; i < txs.length; i++) {
+    const tx = txs[i];
+    if (!tx) {
+      throw new Error(`executeRoute error: invalid message at index ${i}`);
+    }
+    let txResult;
+    if ("cosmosTx" in tx) {
+      yield validateEnabledChainIds((_b = (_a = tx.cosmosTx) == null ? void 0 : _a.chainId) != null ? _b : "");
+      txResult = yield executeCosmosTransaction({
+        tx,
+        options,
+        index: i
+      });
+    } else if ("evmTx" in tx) {
+      yield validateEnabledChainIds((_d = (_c = tx.evmTx) == null ? void 0 : _c.chainId) != null ? _d : "");
+      const txResponse = yield executeEvmTransaction(tx, options);
+      txResult = {
+        chainId: (_f = (_e = tx == null ? void 0 : tx.evmTx) == null ? void 0 : _e.chainId) != null ? _f : "",
+        txHash: txResponse.transactionHash
+      };
+    } else if ("svmTx" in tx) {
+      yield validateEnabledChainIds((_h = (_g = tx.svmTx) == null ? void 0 : _g.chainId) != null ? _h : "");
+      txResult = yield executeSvmTransaction(tx, options);
+    } else {
+      throw new Error("executeRoute error: invalid message type");
+    }
+    yield onTransactionBroadcast == null ? void 0 : onTransactionBroadcast(__spreadValues({}, txResult));
+    const txStatusResponse = yield waitForTransaction(__spreadProps(__spreadValues({}, txResult), {
+      onTransactionTracked: options.onTransactionTracked
+    }));
+    yield onTransactionCompleted == null ? void 0 : onTransactionCompleted({
+      chainId: txResult.chainId,
+      txHash: txResult.txHash,
+      status: txStatusResponse
+    });
+  }
+});
+var executeRoute = (options) => __async(void 0, null, function* () {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+  const { route, userAddresses, beforeMsg, afterMsg, timeoutSeconds } = options;
+  let addressList = [];
+  userAddresses.forEach((userAddress, index) => {
+    const requiredChainAddress = route.requiredChainAddresses[index];
+    if (requiredChainAddress === (userAddress == null ? void 0 : userAddress.chainId)) {
+      addressList.push(userAddress.address);
+    }
+  });
+  if (addressList.length !== route.requiredChainAddresses.length) {
+    addressList = userAddresses.map((x) => x.address);
+  }
+  const validLength = addressList.length === route.requiredChainAddresses.length || addressList.length === ((_a = route.chainIds) == null ? void 0 : _a.length);
+  if (!validLength) {
+    throw new Error("executeRoute error: invalid address list");
+  }
+  const isUserAddressesValid = yield validateUserAddresses(userAddresses);
+  if (!isUserAddressesValid) {
+    throw new Error("executeRoute error: invalid user addresses");
+  }
+  const response = yield messages({
+    timeoutSeconds,
+    amountIn: route == null ? void 0 : route.amountIn,
+    amountOut: route.estimatedAmountOut || "0",
+    sourceAssetChainId: route == null ? void 0 : route.sourceAssetChainId,
+    sourceAssetDenom: route == null ? void 0 : route.sourceAssetDenom,
+    destAssetChainId: route == null ? void 0 : route.destAssetChainId,
+    destAssetDenom: route == null ? void 0 : route.destAssetDenom,
+    operations: route == null ? void 0 : route.operations,
+    addressList,
+    slippageTolerancePercent: options.slippageTolerancePercent || "1",
+    chainIdsToAffiliates: ApiState.chainIdsToAffiliates
+  });
+  if (beforeMsg && ((_c = (_b = response == null ? void 0 : response.txs) == null ? void 0 : _b.length) != null ? _c : 0) > 0) {
+    const firstTx = (_d = response == null ? void 0 : response.txs) == null ? void 0 : _d[0];
+    if (firstTx && "cosmosTx" in firstTx) {
+      (_f = (_e = firstTx.cosmosTx) == null ? void 0 : _e.msgs) == null ? void 0 : _f.unshift(beforeMsg);
+    }
+  }
+  if (afterMsg && ((_h = (_g = response == null ? void 0 : response.txs) == null ? void 0 : _g.length) != null ? _h : 0) > 0) {
+    const lastTx = (_i = response == null ? void 0 : response.txs) == null ? void 0 : _i[response.txs.length - 1];
+    if (lastTx && "cosmosTx" in lastTx) {
+      (_k = (_j = lastTx.cosmosTx) == null ? void 0 : _j.msgs) == null ? void 0 : _k.push(afterMsg);
+    }
+  }
+  yield executeTransactions(__spreadProps(__spreadValues({}, options), { txs: response == null ? void 0 : response.txs }));
+});
+var validateUserAddresses = (userAddresses) => __async(void 0, null, function* () {
+  const chains2 = yield ClientState.getSkipChains();
+  const validations = userAddresses.map((userAddress) => {
+    var _a, _b;
+    const chain = chains2.find((chain2) => chain2.chainId === userAddress.chainId);
+    switch (chain == null ? void 0 : chain.chainType) {
+      case "cosmos" /* Cosmos */:
+        try {
+          if ((_a = chain.chainId) == null ? void 0 : _a.includes("penumbra")) {
+            try {
+              return chain.bech32Prefix === ((_b = bech32m.decode(userAddress.address, 143)) == null ? void 0 : _b.prefix);
+            } catch (e) {
+              return ["penumbracompat1", "tpenumbra"].includes(
+                bech32.decode(userAddress.address, 1023).prefix
+              );
+            }
+          }
+          return chain.bech32Prefix === bech32.decode(userAddress.address, 1023).prefix;
+        } catch (e) {
+          return false;
+        }
+      case "evm" /* Evm */:
+        try {
+          return isAddress(userAddress.address);
+        } catch (_error) {
+          return false;
+        }
+      case "svm" /* Svm */:
+        try {
+          const publicKey = new PublicKey(userAddress.address);
+          return PublicKey.isOnCurve(publicKey);
+        } catch (_error) {
+          return false;
+        }
+      default:
+        return false;
+    }
+  });
+  return validations.every((validation) => validation);
+});
+
+export { Api, AutopilotAction, AxelarTransferState, AxelarTransferType, BridgeType, CCTPTransferState, ChainType, ContentType, ContractCallWithTokenErrorType, FeeType, GoFastTransferState, HttpClient, HyperlaneTransferState, LayerZeroTransferState, OPInitTransferState, PacketErrorType, Reason, RoutePriceWarningType, SendTokenErrorType, StargateTransferState, StatusErrorType, TransactionState, TransferState, executeRoute };