@skip-go/client 1.0.1 → 1.0.3-alpha-0

package/dist/chunk-W6TBGBV3.js

@@ -0,0 +1,675 @@
+// 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 {
+  baseUrl = "https://api.skip.build";
+  securityData = null;
+  securityWorker;
+  abortControllers = /* @__PURE__ */ new Map();
+  customFetch = (...fetchParams) => fetch(...fetchParams);
+  baseApiParams = {
+    credentials: "same-origin",
+    headers: {},
+    redirect: "follow",
+    referrerPolicy: "no-referrer"
+  };
+  constructor(apiConfig = {}) {
+    Object.assign(this, apiConfig);
+  }
+  setSecurityData = (data) => {
+    this.securityData = data;
+  };
+  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}` : "";
+  }
+  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)
+  };
+  mergeRequestParams(params1, params2) {
+    return {
+      ...this.baseApiParams,
+      ...params1,
+      ...params2 || {},
+      headers: {
+        ...this.baseApiParams.headers || {},
+        ...params1.headers || {},
+        ...params2 && params2.headers || {}
+      }
+    };
+  }
+  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;
+  };
+  abortRequest = (cancelToken) => {
+    const abortController = this.abortControllers.get(cancelToken);
+    if (abortController) {
+      abortController.abort();
+      this.abortControllers.delete(cancelToken);
+    }
+  };
+  request = async ({
+    body,
+    secure,
+    path,
+    type,
+    query,
+    format,
+    baseUrl,
+    cancelToken,
+    ...params
+  }) => {
+    const secureParams = (typeof secure === "boolean" ? secure : this.baseApiParams.secure) && this.securityWorker && await 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}` : ""}`, {
+      ...requestParams,
+      headers: {
+        ...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(async (response) => {
+      const r = response.clone();
+      r.data = null;
+      r.error = null;
+      const data = !responseFormat ? r : await 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;
+    });
+  };
+};
+var Api = class extends HttpClient {
+  /**
+   * @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
+   */
+  getChains = (query, params = {}) => this.request({
+    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
+   */
+  getBalances = (data, params = {}) => this.request({
+    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
+   */
+  getBridges = (params = {}) => this.request({
+    path: `/v2/info/bridges`,
+    method: "GET",
+    format: "json",
+    ...params
+  });
+  /**
+   * @description Get supported swap venues.
+   *
+   * @tags Fungible
+   * @name GetVenues
+   * @request GET:/v2/fungible/venues
+   */
+  getVenues = (query, params = {}) => this.request({
+    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
+   */
+  getAssets = (query, params = {}) => this.request({
+    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
+   */
+  getAssetsFromSource = (data, params = {}) => this.request({
+    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
+   */
+  getRouteV2 = (data, params = {}) => this.request({
+    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
+   */
+  getMsgsV2 = (data, params = {}) => this.request({
+    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
+   */
+  getMsgsDirectV2 = (data, params = {}) => this.request({
+    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
+   */
+  getAssetRecommendations = (data, params = {}) => this.request({
+    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
+   */
+  submitTransactionV2 = (data, params = {}) => this.request({
+    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
+   */
+  trackTransactionV2 = (data, params = {}) => this.request({
+    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
+   */
+  getTransactionStatusV2 = (query, params = {}) => this.request({
+    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
+   */
+  getOriginAssets = (data, params = {}) => this.request({
+    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
+   */
+  fungibleAssetsBetweenChainsCreate = (data, params = {}) => this.request({
+    path: `/v2/fungible/assets_between_chains`,
+    method: "POST",
+    body: data,
+    type: "application/json" /* Json */,
+    format: "json",
+    ...params
+  });
+};
+
+// src/utils/convert.ts
+function toSnake(obj) {
+  return convertKeys(obj, (key) => key.replace(/([A-Z])/g, "_$1").toLowerCase());
+}
+function toCamel(obj) {
+  return convertKeys(obj, (key) => key.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase()));
+}
+function convertKeys(obj, convertKey) {
+  if (Array.isArray(obj)) {
+    return obj.map((item) => convertKeys(item, convertKey));
+  } else if (obj !== null && typeof obj === "object") {
+    return Object.keys(obj).reduce((acc, key) => {
+      acc[convertKey(key)] = convertKeys(obj[key], convertKey);
+      return acc;
+    }, {});
+  } else {
+    return obj;
+  }
+}
+
+// src/utils/timer.ts
+var wait = (ms) => {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+};
+
+// src/utils/generateApi.ts
+var createRequestClient = ({ baseUrl, apiKey }) => {
+  const defaultHeaders = {
+    "content-type": "application/json",
+    ...apiKey ? { authorization: apiKey } : {}
+  };
+  const handleResponse = async (response) => {
+    const contentType = response.headers.get("content-type");
+    const isJson = contentType?.includes("application/json");
+    const body = isJson ? await response.json() : await response.text();
+    if (!response.ok) {
+      const message = typeof body === "object" && body?.message ? body.message : response.statusText;
+      throw new Error(message);
+    }
+    return body;
+  };
+  const get = async (path, params, signal) => {
+    const url = new URL(baseUrl + (path ?? ""));
+    if (params && typeof params === "object") {
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== void 0 && value !== null) {
+          url.searchParams.append(key, String(value));
+        }
+      });
+    }
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers: defaultHeaders,
+      signal
+    });
+    return handleResponse(response);
+  };
+  const post = async (path, data = {}, signal) => {
+    const response = await fetch(new URL(baseUrl + path).toString(), {
+      method: "POST",
+      headers: defaultHeaders,
+      body: JSON.stringify(data),
+      signal
+    });
+    return handleResponse(response);
+  };
+  return { get, post };
+};
+function createRequest({
+  path,
+  method = "get",
+  onSuccess,
+  transformResponse
+}) {
+  let controller = null;
+  const request = async (options) => {
+    const { apiKey, apiUrl, abortDuplicateRequests, ...requestParams } = options ?? {};
+    let fetchClient = ApiState.client;
+    if (apiUrl || apiKey) {
+      fetchClient = createRequestClient({
+        baseUrl: apiUrl || "https://api.skip.build",
+        apiKey
+      });
+    } else {
+      await ApiState.clientInitialized;
+    }
+    if (abortDuplicateRequests && controller && !controller?.signal?.aborted) {
+      controller?.abort();
+    }
+    controller = new AbortController();
+    try {
+      const response = await fetchClient[method](
+        path,
+        requestParams ? toSnake(requestParams) : void 0,
+        controller.signal
+      );
+      const camelCased = toCamel(response ?? {});
+      const finalResponse = transformResponse ? transformResponse(camelCased) : camelCased;
+      onSuccess?.(finalResponse, requestParams);
+      return finalResponse;
+    } catch (error) {
+      if (error.name === "AbortError") {
+        console.log("Request was cancelled");
+      } else {
+        console.error("Error:", error);
+        throw error;
+      }
+    }
+  };
+  return request;
+}
+function api({
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  methodName,
+  path,
+  onSuccess,
+  method = "get",
+  transformResponse
+}) {
+  return createRequest({
+    path,
+    method,
+    onSuccess,
+    transformResponse
+  });
+}
+function pollingApi({
+  methodName,
+  path,
+  method = "get",
+  onSuccess,
+  onError,
+  isSuccess = () => true,
+  maxRetries = 5,
+  retryInterval = 1e3,
+  backoffMultiplier = 2
+}) {
+  const request = async (requestParams) => {
+    let attempt = 0;
+    let lastError;
+    while (attempt < maxRetries) {
+      try {
+        const result = await api({ methodName, path, method })(requestParams);
+        if (result && isSuccess(result)) {
+          onSuccess?.(result, attempt);
+          return result;
+        }
+      } catch (err) {
+        lastError = err;
+        onError?.(err, attempt);
+      }
+      const delay = retryInterval * Math.pow(backoffMultiplier, attempt);
+      await wait(delay);
+      attempt++;
+    }
+    throw lastError ?? new Error("pollingApi: max retries exceeded");
+  };
+  return (params) => request(params);
+}
+
+// src/state/apiState.ts
+var ApiState = class _ApiState {
+  static client;
+  static chainIdsToAffiliates;
+  static cumulativeAffiliateFeeBPS = "0";
+  static isInitialized = false;
+  static resolveInitialization;
+  static clientInitialized = new Promise((resolve) => {
+    _ApiState.resolveInitialization = () => {
+      if (!_ApiState.isInitialized) {
+        _ApiState.isInitialized = true;
+        resolve();
+      }
+    };
+  });
+  static setClientInitialized() {
+    _ApiState.resolveInitialization();
+  }
+};
+
+export { Api, ApiState, AutopilotAction, AxelarTransferState, AxelarTransferType, BridgeType, CCTPTransferState, ChainType, ContentType, ContractCallWithTokenErrorType, FeeType, GoFastTransferState, HttpClient, HyperlaneTransferState, LayerZeroTransferState, OPInitTransferState, PacketErrorType, Reason, RoutePriceWarningType, SendTokenErrorType, StargateTransferState, StatusErrorType, TransactionState, TransferState, api, createRequestClient, pollingApi, toCamel, wait };

package/dist/index.d.ts

@@ -28,9 +28,6 @@ import '@cosmjs/stargate';
 import 'viem';
 import '@solana/wallet-adapter-base';
 import './apiState-CdzxTxYd.js';
-import '@cosmjs/proto-signing/build/signer';
-import '@cosmjs/stargate/build/signingstargateclient';
-import '@cosmjs/stargate/build/fee';
 
 declare const GAS_STATION_CHAIN_IDS: string[];