@saturnbtcio/indexer-api-sdk/dist/index.mjs

SDK for Titan BTC indexer

var __defProp = Object.defineProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};

// src/generated/collection.ts
var collection_exports = {};
__export(collection_exports, {
  getCollectionById: () => getCollectionById,
  getCollectionByName: () => getCollectionByName,
  getCollectionsByIds: () => getCollectionsByIds,
  getCollectionsByNames: () => getCollectionsByNames,
  getGetCollectionByIdUrl: () => getGetCollectionByIdUrl,
  getGetCollectionByNameUrl: () => getGetCollectionByNameUrl,
  getGetCollectionsByIdsUrl: () => getGetCollectionsByIdsUrl,
  getGetCollectionsByNamesUrl: () => getGetCollectionsByNamesUrl,
  getGetMintableCollectionUrl: () => getGetMintableCollectionUrl,
  getMintableCollection: () => getMintableCollection,
  getMintableMultiSearchByIdUrl: () => getMintableMultiSearchByIdUrl,
  getMintableMultiSearchUrl: () => getMintableMultiSearchUrl,
  getMultiSearchUrl: () => getMultiSearchUrl,
  mintableMultiSearch: () => mintableMultiSearch,
  mintableMultiSearchById: () => mintableMultiSearchById,
  multiSearch: () => multiSearch
});

// src/custom-fetch.ts
var baseUrl = "";
var setBaseUrl = (url) => {
  baseUrl = url;
};
var getBody = (c) => {
  const contentType = c.headers.get("content-type");
  if (contentType && contentType.includes("application/json")) {
    return c.json();
  }
  return c.text();
};
var makeUrlWithBase = (contextUrl) => {
  if (!baseUrl) {
    throw new Error("Base URL not set");
  }
  try {
    const requestUrl = new URL(contextUrl, baseUrl);
    return requestUrl.toString();
  } catch (error) {
    if (error instanceof Error) {
      error.message = `Error creating URL with base URL ${baseUrl}. ` + error.message;
    }
    throw error;
  }
};
var customFetch = async (url, options) => {
  const requestUrl = makeUrlWithBase(url);
  const request = new Request(requestUrl, options);
  const response = await fetch(request);
  const data = await getBody(response);
  return { status: response.status, data, headers: response.headers };
};

// src/generated/collection.ts
var getGetCollectionByIdUrl = (id) => {
  return `/collection/id/${id}`;
};
var getCollectionById = async (id, options) => {
  return customFetch(
    getGetCollectionByIdUrl(id),
    {
      ...options,
      method: "GET"
    }
  );
};
var getGetCollectionsByIdsUrl = (params) => {
  const normalizedParams = new URLSearchParams();
  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== void 0) {
      normalizedParams.append(key, value === null ? "null" : value.toString());
    }
  });
  const stringifiedParams = normalizedParams.toString();
  return stringifiedParams.length > 0 ? `/collection/ids?${stringifiedParams}` : `/collection/ids`;
};
var getCollectionsByIds = async (params, options) => {
  return customFetch(
    getGetCollectionsByIdsUrl(params),
    {
      ...options,
      method: "GET"
    }
  );
};
var getMintableMultiSearchByIdUrl = () => {
  return `/collection/mintable/id`;
};
var mintableMultiSearchById = async (findManyByIdsRequest, options) => {
  return customFetch(
    getMintableMultiSearchByIdUrl(),
    {
      ...options,
      method: "POST",
      headers: { "Content-Type": "application/json", ...options?.headers },
      body: JSON.stringify(
        findManyByIdsRequest
      )
    }
  );
};
var getMintableMultiSearchUrl = () => {
  return `/collection/mintable/multi-search`;
};
var mintableMultiSearch = async (mintableCollectionSearchFilter, options) => {
  return customFetch(
    getMintableMultiSearchUrl(),
    {
      ...options,
      method: "POST",
      headers: { "Content-Type": "application/json", ...options?.headers },
      body: JSON.stringify(
        mintableCollectionSearchFilter
      )
    }
  );
};
var getGetMintableCollectionUrl = (id) => {
  return `/collection/mintable/${id}`;
};
var getMintableCollection = async (id, options) => {
  return customFetch(
    getGetMintableCollectionUrl(id),
    {
      ...options,
      method: "GET"
    }
  );
};
var getMultiSearchUrl = () => {
  return `/collection/multi-search`;
};
var multiSearch = async (collectionSearchFilter, options) => {
  return customFetch(
    getMultiSearchUrl(),
    {
      ...options,
      method: "POST",
      headers: { "Content-Type": "application/json", ...options?.headers },
      body: JSON.stringify(
        collectionSearchFilter
      )
    }
  );
};
var getGetCollectionByNameUrl = (name) => {
  return `/collection/name/${name}`;
};
var getCollectionByName = async (name, options) => {
  return customFetch(
    getGetCollectionByNameUrl(name),
    {
      ...options,
      method: "GET"
    }
  );
};
var getGetCollectionsByNamesUrl = (params) => {
  const normalizedParams = new URLSearchParams();
  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== void 0) {
      normalizedParams.append(key, value === null ? "null" : value.toString());
    }
  });
  const stringifiedParams = normalizedParams.toString();
  return stringifiedParams.length > 0 ? `/collection/names?${stringifiedParams}` : `/collection/names`;
};
var getCollectionsByNames = async (params, options) => {
  return customFetch(
    getGetCollectionsByNamesUrl(params),
    {
      ...options,
      method: "GET"
    }
  );
};

// src/generated/pool.ts
var pool_exports = {};
__export(pool_exports, {
  find: () => find,
  findByFilter: () => findByFilter,
  findByIds: () => findByIds,
  findByTokenFilter: () => findByTokenFilter,
  findManyByTokenIds: () => findManyByTokenIds,
  findManyByTokenNames: () => findManyByTokenNames,
  findOne: () => findOne,
  getFindByFilterUrl: () => getFindByFilterUrl,
  getFindByIdsUrl: () => getFindByIdsUrl,
  getFindByTokenFilterUrl: () => getFindByTokenFilterUrl,
  getFindManyByTokenIdsUrl: () => getFindManyByTokenIdsUrl,
  getFindManyByTokenNamesUrl: () => getFindManyByTokenNamesUrl,
  getFindOneUrl: () => getFindOneUrl,
  getFindUrl: () => getFindUrl
});
var getFindUrl = (params) => {
  const normalizedParams = new URLSearchParams();
  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== void 0) {
      normalizedParams.append(key, value === null ? "null" : value.toString());
    }
  });
  const stringifiedParams = normalizedParams.toString();
  return stringifiedParams.length > 0 ? `/pool?${stringifiedParams}` : `/pool`;
};
var find = async (params, options) => {
  return customFetch(
    getFindUrl(params),
    {
      ...options,
      method: "GET"
    }
  );
};
var getFindOneUrl = (id) => {
  return `/pool/by-id/${id}`;
};
var findOne = async (id, options) => {
  return customFetch(
    getFindOneUrl(id),
    {
      ...options,
      method: "GET"
    }
  );
};
var getFindManyByTokenIdsUrl = (params) => {
  const normalizedParams = new URLSearchParams();
  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== void 0) {
      normalizedParams.append(key, value === null ? "null" : value.toString());
    }
  });
  const stringifiedParams = normalizedParams.toString();
  return stringifiedParams.length > 0 ? `/pool/by-token-ids?${stringifiedParams}` : `/pool/by-token-ids`;
};
var findManyByTokenIds = async (params, options) => {
  return customFetch(
    getFindManyByTokenIdsUrl(params),
    {
      ...options,
      method: "GET"
    }
  );
};
var getFindManyByTokenNamesUrl = (params) => {
  const normalizedParams = new URLSearchParams();
  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== void 0) {
      normalizedParams.append(key, value === null ? "null" : value.toString());
    }
  });
  const stringifiedParams = normalizedParams.toString();
  return stringifiedParams.length > 0 ? `/pool/by-token-names?${stringifiedParams}` : `/pool/by-token-names`;
};
var findManyByTokenNames = async (params, options) => {
  return customFetch(
    getFindManyByTokenNamesUrl(params),
    {
      ...options,
      method: "GET"
    }
  );
};
var getFindByFilterUrl = () => {
  return `/pool/stats/by-filter`;
};
var findByFilter = async (poolSearchFilter, options) => {
  return customFetch(
    getFindByFilterUrl(),
    {
      ...options,
      method: "POST",
      headers: { "Content-Type": "application/json", ...options?.headers },
      body: JSON.stringify(
        poolSearchFilter
      )
    }
  );
};
var getFindByIdsUrl = (params) => {
  const normalizedParams = new URLSearchParams();
  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== void 0) {
      normalizedParams.append(key, value === null ? "null" : value.toString());
    }
  });
  const stringifiedParams = normalizedParams.toString();
  return stringifiedParams.length > 0 ? `/pool/stats/by-ids?${stringifiedParams}` : `/pool/stats/by-ids`;
};
var findByIds = async (params, options) => {
  return customFetch(
    getFindByIdsUrl(params),
    {
      ...options,
      method: "GET"
    }
  );
};
var getFindByTokenFilterUrl = () => {
  return `/pool/stats/by-token-filter`;
};
var findByTokenFilter = async (poolSearchFilter, options) => {
  return customFetch(
    getFindByTokenFilterUrl(),
    {
      ...options,
      method: "POST",
      headers: { "Content-Type": "application/json", ...options?.headers },
      body: JSON.stringify(
        poolSearchFilter
      )
    }
  );
};

// src/generated/position.ts
var position_exports = {};
__export(position_exports, {
  getGetPositionByIdUrl: () => getGetPositionByIdUrl,
  getGetPositionByPubkeyAndPoolUrl: () => getGetPositionByPubkeyAndPoolUrl,
  getGetPositionsByFilterUrl: () => getGetPositionsByFilterUrl,
  getGetPositionsByPubkeyUrl: () => getGetPositionsByPubkeyUrl,
  getPositionById: () => getPositionById,
  getPositionByPubkeyAndPool: () => getPositionByPubkeyAndPool,
  getPositionsByFilter: () => getPositionsByFilter,
  getPositionsByPubkey: () => getPositionsByPubkey
});
var getGetPositionByIdUrl = (id) => {
  return `/position/${id}`;
};
var getPositionById = async (id, options) => {
  return customFetch(
    getGetPositionByIdUrl(id),
    {
      ...options,
      method: "GET"
    }
  );
};
var getGetPositionByPubkeyAndPoolUrl = (pubkey, poolId) => {
  return `/position/${pubkey}/${poolId}`;
};
var getPositionByPubkeyAndPool = async (pubkey, poolId, options) => {
  return customFetch(
    getGetPositionByPubkeyAndPoolUrl(pubkey, poolId),
    {
      ...options,
      method: "GET"
    }
  );
};
var getGetPositionsByPubkeyUrl = (pubkey) => {
  return `/positions/${pubkey}`;
};
var getPositionsByPubkey = async (pubkey, options) => {
  return customFetch(
    getGetPositionsByPubkeyUrl(pubkey),
    {
      ...options,
      method: "GET"
    }
  );
};
var getGetPositionsByFilterUrl = (pubkey) => {
  return `/positions/${pubkey}/by-filter`;
};
var getPositionsByFilter = async (pubkey, positionSearchFilter, options) => {
  return customFetch(
    getGetPositionsByFilterUrl(pubkey),
    {
      ...options,
      method: "POST",
      headers: { "Content-Type": "application/json", ...options?.headers },
      body: JSON.stringify(
        positionSearchFilter
      )
    }
  );
};

// src/generated/ohlc.ts
var ohlc_exports = {};
__export(ohlc_exports, {
  getGetOhlcDataUrl: () => getGetOhlcDataUrl,
  getOhlcData: () => getOhlcData
});
var getGetOhlcDataUrl = (params) => {
  const normalizedParams = new URLSearchParams();
  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== void 0) {
      normalizedParams.append(key, value === null ? "null" : value.toString());
    }
  });
  const stringifiedParams = normalizedParams.toString();
  return stringifiedParams.length > 0 ? `/ohlc?${stringifiedParams}` : `/ohlc`;
};
var getOhlcData = async (params, options) => {
  return customFetch(
    getGetOhlcDataUrl(params),
    {
      ...options,
      method: "GET"
    }
  );
};

// src/generated/price.ts
var price_exports = {};
__export(price_exports, {
  getGetPricesForCollectionsUrl: () => getGetPricesForCollectionsUrl,
  getPricesForCollections: () => getPricesForCollections
});
var getGetPricesForCollectionsUrl = (params) => {
  const normalizedParams = new URLSearchParams();
  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== void 0) {
      normalizedParams.append(key, value === null ? "null" : value.toString());
    }
  });
  const stringifiedParams = normalizedParams.toString();
  return stringifiedParams.length > 0 ? `/price?${stringifiedParams}` : `/price`;
};
var getPricesForCollections = async (params, options) => {
  return customFetch(
    getGetPricesForCollectionsUrl(params),
    {
      ...options,
      method: "GET"
    }
  );
};

// src/generated/stats.ts
var stats_exports = {};
__export(stats_exports, {
  getGetMostTradedCollectionsUrl: () => getGetMostTradedCollectionsUrl,
  getMostTradedCollections: () => getMostTradedCollections
});
var getGetMostTradedCollectionsUrl = () => {
  return `/stats/most-traded`;
};
var getMostTradedCollections = async (options) => {
  return customFetch(
    getGetMostTradedCollectionsUrl(),
    {
      ...options,
      method: "GET"
    }
  );
};

// src/generated/transaction.ts
var transaction_exports = {};
__export(transaction_exports, {
  findAllTransactions: () => findAllTransactions,
  findSwapsByCollections: () => findSwapsByCollections,
  findTransactionsByPoolId: () => findTransactionsByPoolId,
  findTransactionsByPrevTransactions: () => findTransactionsByPrevTransactions,
  findTransactionsByUser: () => findTransactionsByUser,
  getFindAllTransactionsUrl: () => getFindAllTransactionsUrl,
  getFindSwapsByCollectionsUrl: () => getFindSwapsByCollectionsUrl,
  getFindTransactionsByPoolIdUrl: () => getFindTransactionsByPoolIdUrl,
  getFindTransactionsByPrevTransactionsUrl: () => getFindTransactionsByPrevTransactionsUrl,
  getFindTransactionsByUserUrl: () => getFindTransactionsByUserUrl
});
var getFindAllTransactionsUrl = (params) => {
  const normalizedParams = new URLSearchParams();
  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== void 0) {
      normalizedParams.append(key, value === null ? "null" : value.toString());
    }
  });
  const stringifiedParams = normalizedParams.toString();
  return stringifiedParams.length > 0 ? `/transaction/all?${stringifiedParams}` : `/transaction/all`;
};
var findAllTransactions = async (params, options) => {
  return customFetch(
    getFindAllTransactionsUrl(params),
    {
      ...options,
      method: "GET"
    }
  );
};
var getFindTransactionsByPoolIdUrl = (poolId, params) => {
  const normalizedParams = new URLSearchParams();
  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== void 0) {
      normalizedParams.append(key, value === null ? "null" : value.toString());
    }
  });
  const stringifiedParams = normalizedParams.toString();
  return stringifiedParams.length > 0 ? `/transaction/pool/${poolId}?${stringifiedParams}` : `/transaction/pool/${poolId}`;
};
var findTransactionsByPoolId = async (poolId, params, options) => {
  return customFetch(
    getFindTransactionsByPoolIdUrl(poolId, params),
    {
      ...options,
      method: "GET"
    }
  );
};
var getFindTransactionsByPrevTransactionsUrl = (pubkey, params) => {
  const normalizedParams = new URLSearchParams();
  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== void 0) {
      normalizedParams.append(key, value === null ? "null" : value.toString());
    }
  });
  const stringifiedParams = normalizedParams.toString();
  return stringifiedParams.length > 0 ? `/transaction/prev/${pubkey}?${stringifiedParams}` : `/transaction/prev/${pubkey}`;
};
var findTransactionsByPrevTransactions = async (pubkey, params, options) => {
  return customFetch(
    getFindTransactionsByPrevTransactionsUrl(pubkey, params),
    {
      ...options,
      method: "GET"
    }
  );
};
var getFindSwapsByCollectionsUrl = (params) => {
  const normalizedParams = new URLSearchParams();
  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== void 0) {
      normalizedParams.append(key, value === null ? "null" : value.toString());
    }
  });
  const stringifiedParams = normalizedParams.toString();
  return stringifiedParams.length > 0 ? `/transaction/swaps?${stringifiedParams}` : `/transaction/swaps`;
};
var findSwapsByCollections = async (params, options) => {
  return customFetch(
    getFindSwapsByCollectionsUrl(params),
    {
      ...options,
      method: "GET"
    }
  );
};
var getFindTransactionsByUserUrl = (pubkey, params) => {
  const normalizedParams = new URLSearchParams();
  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== void 0) {
      normalizedParams.append(key, value === null ? "null" : value.toString());
    }
  });
  const stringifiedParams = normalizedParams.toString();
  return stringifiedParams.length > 0 ? `/transaction/user/${pubkey}?${stringifiedParams}` : `/transaction/user/${pubkey}`;
};
var findTransactionsByUser = async (pubkey, params, options) => {
  return customFetch(
    getFindTransactionsByUserUrl(pubkey, params),
    {
      ...options,
      method: "GET"
    }
  );
};

// src/websocket-client.ts
var ConnectionEventType = /* @__PURE__ */ ((ConnectionEventType2) => {
  ConnectionEventType2["Connected"] = "connected";
  ConnectionEventType2["Disconnected"] = "disconnected";
  ConnectionEventType2["Error"] = "error";
  ConnectionEventType2["Reconnecting"] = "reconnecting";
  return ConnectionEventType2;
})(ConnectionEventType || {});
var Action = /* @__PURE__ */ ((Action2) => {
  Action2["Subscribe"] = "Subscribe";
  Action2["Unsubscribe"] = "Unsubscribe";
  Action2["UnsubscribeFilters"] = "UnsubscribeFilters";
  return Action2;
})(Action || {});
var WebSocketClient = class {
  constructor(options) {
    this.socket = null;
    this.eventHandlers = /* @__PURE__ */ new Map();
    this.connectionPromise = null;
    this.reconnectAttempts = 0;
    this.connectionEventHandlers = /* @__PURE__ */ new Map();
    this.pingIntervalId = null;
    this.pongTimeoutId = null;
    const {
      maxReconnectAttempts = 5,
      reconnectInterval = 2e3,
      pingInterval = 1e4,
      // Default enabled.
      pongTimeout = 1e4
      // Default 10s
    } = options;
    let url = options.url;
    if (!url.startsWith("ws://") && !url.startsWith("wss://")) {
      if (url.startsWith("https://")) {
        url = url.replace(/^https/, "wss");
      } else if (url.startsWith("http://")) {
        url = url.replace(/^http/, "ws");
      } else {
        url = `wss://${url}`;
      }
    }
    this.url = url;
    if (maxReconnectAttempts === 0) {
      this.maxReconnectAttempts = Number.MAX_SAFE_INTEGER;
    } else {
      this.maxReconnectAttempts = maxReconnectAttempts;
    }
    this.reconnectInterval = reconnectInterval;
    this.pingInterval = pingInterval;
    this.pongTimeout = pongTimeout;
  }
  /**
   * Connect to the WebSocket server
   */
  connect() {
    if (this.socket && this.socket.readyState === WebSocket.OPEN) {
      return Promise.resolve(this.socket);
    }
    if (this.connectionPromise) {
      return this.connectionPromise;
    }
    this.connectionPromise = new Promise((resolve, reject) => {
      try {
        const socket = new WebSocket(this.url);
        socket.onopen = () => {
          console.log("WebSocket connection established");
          this.reconnectAttempts = 0;
          this.triggerConnectionEvent("connected" /* Connected */);
          this.startPinging();
          resolve(socket);
        };
        socket.onmessage = (event) => {
          try {
            if (this.pongTimeoutId) {
              clearTimeout(this.pongTimeoutId);
              this.pongTimeoutId = null;
            }
            if (event.data === "3") {
              return;
            }
            const data = JSON.parse(event.data);
            this.handleEvent(data);
          } catch (error) {
            console.error("Error parsing event data:", error);
          }
        };
        socket.onerror = (error) => {
          console.error("WebSocket error:", error);
          this.triggerConnectionEvent("error" /* Error */, error);
          reject(error);
        };
        socket.onclose = (event) => {
          console.log(
            `WebSocket connection closed: ${event.code} ${event.reason}`
          );
          this.socket = null;
          this.connectionPromise = null;
          this.triggerConnectionEvent("disconnected" /* Disconnected */, {
            code: event.code,
            reason: event.reason
          });
          this.stopPinging();
          if (event.code !== 1e3 && this.reconnectAttempts < this.maxReconnectAttempts) {
            console.log(
              `Attempting to reconnect (${this.reconnectAttempts + 1}/${this.maxReconnectAttempts})...`
            );
            this.reconnectAttempts++;
            this.triggerConnectionEvent("reconnecting" /* Reconnecting */, {
              attempt: this.reconnectAttempts,
              maxAttempts: this.maxReconnectAttempts
            });
            setTimeout(() => this.connect(), this.reconnectInterval);
          }
        };
        this.socket = socket;
      } catch (error) {
        this.connectionPromise = null;
        this.triggerConnectionEvent("error" /* Error */, error);
        reject(error);
      }
    });
    return this.connectionPromise;
  }
  /**
   * Subscribe to one or more event types with optional filters
   */
  async subscribe(topics) {
    if (!topics || topics.length === 0) {
      return;
    }
    const socket = await this.connect();
    const formattedTopics = topics.map((topic) => {
      if (typeof topic === "string") {
        return {
          event_type: topic,
          filters: {}
        };
      } else {
        return topic;
      }
    });
    const message = {
      action: "Subscribe" /* Subscribe */,
      topics: formattedTopics
    };
    socket.send(JSON.stringify(message));
  }
  /**
   * Subscribe to an event type with specific filters
   */
  async subscribeWithFilter(eventType, filter) {
    return this.subscribe([
      {
        event_type: eventType,
        filters: filter
      }
    ]);
  }
  /**
   * Unsubscribe from one or more event types
   */
  async unsubscribe(topics) {
    if (!topics || topics.length === 0 || !this.socket) {
      return;
    }
    const socket = await this.connect();
    const message = {
      action: "Unsubscribe" /* Unsubscribe */,
      topics
    };
    socket.send(JSON.stringify(message));
  }
  /**
   * Unsubscribe from specific filters for an event type
   */
  async unsubscribeFilters(filters) {
    if (!filters || filters.length === 0 || !this.socket) {
      return;
    }
    const socket = await this.connect();
    const message = {
      action: "UnsubscribeFilters" /* UnsubscribeFilters */,
      topics: filters
    };
    socket.send(JSON.stringify(message));
  }
  /**
   * Unsubscribe from a specific filter for an event type
   */
  async unsubscribeFilter(eventType, filter) {
    return this.unsubscribeFilters([{ event_type: eventType, filter }]);
  }
  /**
   * Handle incoming events from the server
   */
  handleEvent(event) {
    const eventType = event.type;
    const data = event.data;
    const handlers = this.eventHandlers.get(eventType);
    if (handlers) {
      handlers.forEach((handler) => {
        try {
          handler(data);
        } catch (error) {
          console.error("Error in event handler:", error);
        }
      });
    }
  }
  /**
   * Register an event handler for a specific event type
   * @param eventType The type of event to listen for
   * @param handler The callback function to execute when an event is received
   * @returns A function that can be called to remove this event handler
   */
  on(eventType, handler) {
    if (!this.eventHandlers.has(eventType)) {
      this.eventHandlers.set(eventType, /* @__PURE__ */ new Set());
    }
    this.eventHandlers.get(eventType).add(handler);
    return () => {
      const handlers = this.eventHandlers.get(eventType);
      if (handlers) {
        handlers.delete(handler);
      }
    };
  }
  /**
   * Register an event handler for a specific event type that will be executed only once
   * @param eventType The type of event to listen for
   * @param handler The callback function to execute when an event is received
   * @returns A function that can be called to remove this event handler
   */
  once(eventType, handler) {
    const wrappedHandler = (data) => {
      removeHandler();
      handler(data);
    };
    const removeHandler = this.on(eventType, wrappedHandler);
    return removeHandler;
  }
  /**
   * Register a handler for connection events
   * @param eventType The type of connection event to listen for
   * @param handler The callback function to execute when the event occurs
   * @returns A function that can be called to remove this event handler
   */
  onConnection(eventType, handler) {
    if (!this.connectionEventHandlers.has(eventType)) {
      this.connectionEventHandlers.set(eventType, /* @__PURE__ */ new Set());
    }
    this.connectionEventHandlers.get(eventType).add(handler);
    return () => {
      const handlers = this.connectionEventHandlers.get(eventType);
      if (handlers) {
        handlers.delete(handler);
      }
    };
  }
  /**
   * Register a handler for connection events that will be executed only once
   * @param eventType The type of connection event to listen for
   * @param handler The callback function to execute when the event occurs
   * @returns A function that can be called to remove this event handler
   */
  onceConnection(eventType, handler) {
    const wrappedHandler = (event) => {
      removeHandler();
      handler(event);
    };
    const removeHandler = this.onConnection(eventType, wrappedHandler);
    return removeHandler;
  }
  /**
   * Trigger connection event handlers
   * @private
   */
  triggerConnectionEvent(type, data) {
    const handlers = this.connectionEventHandlers.get(type);
    if (handlers) {
      const event = { type, data };
      handlers.forEach((handler) => {
        try {
          handler(event);
        } catch (error) {
          console.error(`Error in ${type} event handler:`, error);
        }
      });
    }
  }
  /**
   * Close the WebSocket connection
   */
  close() {
    if (this.socket) {
      this.socket.close(1e3, "Client disconnected");
      this.socket = null;
      this.connectionPromise = null;
    }
  }
  /**
   * Remove a specific connection event handler
   * @param eventType The type of connection event
   * @param handler The handler function to remove
   */
  offConnection(eventType, handler) {
    const handlers = this.connectionEventHandlers.get(eventType);
    if (handlers) {
      handlers.delete(handler);
    }
  }
  /**
   * Remove all handlers for a specific connection event type
   * @param eventType The type of connection event
   */
  offAllConnections(eventType) {
    this.connectionEventHandlers.delete(eventType);
  }
  /**
   * Remove all connection event handlers
   */
  offAllConnectionEvents() {
    this.connectionEventHandlers.clear();
  }
  startPinging() {
    if (this.pingInterval <= 0 || this.pingIntervalId) {
      return;
    }
    console.log(`Starting client ping every ${this.pingInterval}ms`);
    this.pingIntervalId = setInterval(() => {
      if (this.socket && this.socket.readyState === WebSocket.OPEN) {
        if (this.pongTimeoutId) {
          clearTimeout(this.pongTimeoutId);
        }
        this.socket.send("2");
        this.pongTimeoutId = setTimeout(() => {
          console.warn(
            `Pong timeout (${this.pongTimeout}ms). Server unresponsive. Closing connection.`
          );
          this.socket?.close(4001, "Pong Timeout");
          this.stopPinging();
        }, this.pongTimeout);
      } else {
        console.warn("Cannot send ping, socket not open. Stopping ping timer.");
        this.stopPinging();
      }
    }, this.pingInterval);
  }
  stopPinging() {
    if (this.pingIntervalId) {
      console.log("Stopping client ping");
      clearInterval(this.pingIntervalId);
      this.pingIntervalId = null;
    }
    if (this.pongTimeoutId) {
      clearTimeout(this.pongTimeoutId);
      this.pongTimeoutId = null;
    }
  }
};

// src/generated/saturnIndexerAPI.schemas.ts
var BitcoinTxStatus = {
  pending: "pending",
  confirmed: "confirmed",
  failed: "failed",
  rolled_back: "rolled_back"
};
var CollectionOneOfAllOfType = {
  btc: "btc"
};
var CollectionOneOfFourAllOfType = {
  rune: "rune"
};
var NeedsConsolidationOneOfType = {
  no: "no"
};
var NeedsConsolidationOneOfThreeType = {
  yes: "yes"
};
var OHLCGranularity = {
  "1m": "1m",
  "5m": "5m",
  "15m": "15m",
  "30m": "30m",
  "1h": "1h",
  "4h": "4h",
  "1d": "1d",
  "1w": "1w"
};
var PaginationResponseVecCollectionResponseItemOneOfAllOfType = {
  btc: "btc"
};
var PaginationResponseVecCollectionResponseItemOneOfFourAllOfType = {
  rune: "rune"
};
var Period = {
  Day: "Day",
  Week: "Week",
  Month: "Month"
};
var RollbackStatusSchemaOneOfType = {
  rolledback: "rolledback"
};
var RollbackStatusSchemaOneOfThreeType = {
  notRolledback: "notRolledback"
};
var SortFieldSortFieldCollectionField = {
  id: "id",
  name: "name",
  supply: "supply",
  created_at: "created_at"
};
var SortFieldSortFieldPoolField = {
  token0_name: "token0_name",
  token1_name: "token1_name",
  tvl_now: "tvl_now",
  tvl_24h_ago: "tvl_24h_ago",
  tvl_diff: "tvl_diff",
  volume_24h: "volume_24h",
  volume_7d: "volume_7d",
  volume_diff_24h: "volume_diff_24h",
  fees_24h: "fees_24h",
  fees_7d: "fees_7d",
  smaller_24h_apy: "smaller_24h_apy",
  larger_24h_apy: "larger_24h_apy",
  smaller_7d_apy: "smaller_7d_apy",
  larger_7d_apy: "larger_7d_apy"
};
var SortFieldSortMintableFieldCollectionField = {
  id: "id",
  name: "name",
  supply: "supply",
  created_at: "created_at",
  start: "start",
  end: "end",
  progress: "progress"
};
var SortOrder = {
  ASC: "ASC",
  DESC: "DESC"
};
var StatusSchemaOneOfType = {
  Queued: "Queued"
};
var StatusSchemaOneOfThreeType = {
  Processed: "Processed"
};
var StatusSchemaOneOfFiveType = {
  Failed: "Failed"
};
var TransactionDetailsOneOfAllOfType = {
  open_position: "open_position"
};
var TransactionDetailsOneOfFourAllOfType = {
  increase_liquidity: "increase_liquidity"
};
var TransactionDetailsOneOfSevenAllOfType = {
  decrease_liquidity: "decrease_liquidity"
};
var TransactionDetailsOneOfOnezeroAllOfType = {
  close_position: "close_position"
};
var TransactionDetailsOneOfOnethreeAllOfType = {
  add_pool_shards: "add_pool_shards"
};
var TransactionDetailsOneOfOnesixAllOfType = {
  swap: "swap"
};
var TransactionDetailsOneOfOnenineAllOfType = {
  collect_protocol_fees: "collect_protocol_fees"
};
var TransactionDetailsOneOfTwotwoAllOfType = {
  initialize_pool: "initialize_pool"
};
var TransactionType = {
  open_position: "open_position",
  close_position: "close_position",
  increase_liquidity: "increase_liquidity",
  decrease_liquidity: "decrease_liquidity",
  swap: "swap",
  initialize_pool: "initialize_pool",
  add_pool_shards: "add_pool_shards",
  collect_protocol_fees: "collect_protocol_fees"
};

// src/types/events.ts
var EventType = /* @__PURE__ */ ((EventType2) => {
  EventType2["Swap"] = "swap";
  EventType2["Transaction"] = "transaction";
  return EventType2;
})(EventType || {});

// src/index.ts
var SaturnIndexerSDK = class {
  constructor(baseUrl2) {
    setBaseUrl(baseUrl2);
    this.api = {
      collection: collection_exports,
      pool: pool_exports,
      position: position_exports,
      ohlc: ohlc_exports,
      price: price_exports,
      stats: stats_exports,
      transaction: transaction_exports
    };
  }
};
export {
  Action,
  BitcoinTxStatus,
  CollectionOneOfAllOfType,
  CollectionOneOfFourAllOfType,
  ConnectionEventType,
  EventType,
  NeedsConsolidationOneOfThreeType,
  NeedsConsolidationOneOfType,
  OHLCGranularity,
  PaginationResponseVecCollectionResponseItemOneOfAllOfType,
  PaginationResponseVecCollectionResponseItemOneOfFourAllOfType,
  Period,
  RollbackStatusSchemaOneOfThreeType,
  RollbackStatusSchemaOneOfType,
  SaturnIndexerSDK,
  WebSocketClient as SaturnIndexerWebSocketClient,
  SortFieldSortFieldCollectionField,
  SortFieldSortFieldPoolField,
  SortFieldSortMintableFieldCollectionField,
  SortOrder,
  StatusSchemaOneOfFiveType,
  StatusSchemaOneOfThreeType,
  StatusSchemaOneOfType,
  TransactionDetailsOneOfAllOfType,
  TransactionDetailsOneOfFourAllOfType,
  TransactionDetailsOneOfOnenineAllOfType,
  TransactionDetailsOneOfOnesixAllOfType,
  TransactionDetailsOneOfOnethreeAllOfType,
  TransactionDetailsOneOfOnezeroAllOfType,
  TransactionDetailsOneOfSevenAllOfType,
  TransactionDetailsOneOfTwotwoAllOfType,
  TransactionType,
  WebSocketClient
};