index.js

import { streamRunner, queryRunner } from 'bitquery-helper';
import { newQuestionsQuery, newQuestionsStream } from './queries/newQuestionsQuery.js';
import { payoutRecievedQuery, payoutRecievedStream } from './queries/payoutRecievedQuery.js';
import { positionSplitsQuery, positionSplitsStream } from './queries/positionSplitsQuery.js';
import { resolvedQuestionsQuery, resolvedQuestionsStream } from './queries/resolvedQuestionsQuery.js';
import { allTradesQuery, allTradesStream } from './queries/allTradesQuery.js';
import { tradesByAddressQuery, tradesByAddressStream } from './queries/tradesByAddressQuery.js';
import { tradesByUserQuery, tradesByUserStream } from './queries/tradesByUserQuery.js';

/**
 * getNewQuestions
 * Get new questions data from Polymarket
 * @param {string} token - your Bitquery OAuth token
 * @param {number} count - number of results to return (default: 20)
 * @returns {Promise<Array>} - array of new question events
 */
const getNewQuestions = async (token, count = 20) => {
    try {
        const newQuestions = await queryRunner(newQuestionsQuery(count), token);
        return newQuestions.data.EVM.Events;
    } catch (error) {
        throw error;
    }
}

/**
 * getPayoutRecieved
 * Get payout received events for a specific address on Polymarket
 * @param {string} token - your Bitquery OAuth token
 * @param {string} address - wallet address to query
 * @param {number} count - number of results to return (default: 20)
 * @returns {Promise<Array>} - array of payout received events
 */
const getPayoutRecieved = async (token, address, count = 20) => {
    try {
        const payoutRecieved = await queryRunner(payoutRecievedQuery(address, count), token);
        return payoutRecieved.data.EVM.Events;
    } catch (error) {
        throw error;
    }
}

/**
 * getPositionSplits
 * Get position splits data from Polymarket
 * @param {string} token - your Bitquery OAuth token
 * @param {number} count - number of results to return (default: 20)
 * @returns {Promise<Array>} - array of position split events
 */
const getPositionSplits = async (token, count = 20) => {
    try {
        const positionSplits = await queryRunner(positionSplitsQuery(count), token);
        return positionSplits.data.EVM.Events;
    } catch (error) {
        throw error;
    }
}

/**
 * getResolvedQuestions
 * Get resolved questions data from Polymarket
 * @param {string} token - your Bitquery OAuth token
 * @param {number} count - number of results to return (default: 20)
 * @returns {Promise<Array>} - array of resolved question events
 */
const getResolvedQuestions = async (token, count = 20) => {
    try {
        const resolvedQuestions = await queryRunner(resolvedQuestionsQuery(count), token);
        return resolvedQuestions.data.EVM.Events;
    } catch (error) {
        throw error;
    }
}

/**
 * streamNewQuestions
 * Stream live new questions data from Polymarket
 * @param {string} token - your Bitquery OAuth token
 * @param {object} options - optional settings: { autoCloseMs, onData, onError }
 * @returns {Promise<WebSocket>} - active WebSocket connection
 */
const streamNewQuestions = (token, options = {}) => {
    try {
        return streamRunner(newQuestionsStream, token, {
                autoCloseMs: options.autoCloseMs,
                onData: options.onData,
                onError: options.onError,
            });
    } catch (error) {
        throw error;
    }
}

/**
 * streamPayoutRecieved
 * Stream live payout received events for a specific address on Polymarket
 * @param {string} token - your Bitquery OAuth token
 * @param {string} address - wallet address to stream
 * @param {object} options - optional settings: { autoCloseMs, onData, onError }
 * @returns {Promise<WebSocket>} - active WebSocket connection
 */
const streamPayoutRecieved = (token, address, options = {}) => {
    try {
        return streamRunner(payoutRecievedStream(address), token, {
            autoCloseMs: options.autoCloseMs,
            onData: options.onData,
            onError: options.onError,
        });
    }
    catch (error) {
        throw error;
    }
}

/**
 * streamPositionSplits
 * Stream live position splits data from Polymarket
 * @param {string} token - your Bitquery OAuth token
 * @param {object} options - optional settings: { autoCloseMs, onData, onError }
 * @returns {Promise<WebSocket>} - active WebSocket connection
 */
const streamPositionSplits = (token, options = {}) => {
    try {
        return streamRunner(positionSplitsStream, token, {
            autoCloseMs: options.autoCloseMs,
            onData: options.onData,
            onError: options.onError,
        });
    }
    catch (error) {
        throw error;
    }
}

/**
 * streamResolvedQuestions
 * Stream live resolved questions data from Polymarket
 * @param {string} token - your Bitquery OAuth token
 * @param {object} options - optional settings: { autoCloseMs, onData, onError }
 * @returns {Promise<WebSocket>} - active WebSocket connection
 */
const streamResolvedQuestions = (token, options = {}) => {
    try {
        return streamRunner(resolvedQuestionsStream, token, {
            autoCloseMs: options.autoCloseMs,
            onData: options.onData,
            onError: options.onError,
        });
    }
    catch (error) {
        throw error;
    }
}

/**
 * getAllTrades
 * Get all Polymarket trades data
 * @param {string} token - your Bitquery OAuth token
 * @param {number} count - number of results to return (default: 20)
 * @returns {Promise<Array>} - array of trade data
 */
const getAllTrades = async (token, count = 20) => {
    try {
        const allTrades = await queryRunner(allTradesQuery(count), token);
        return allTrades.data.EVM.DEXTradeByTokens;
    } catch (error) {
        throw error;
    }
}

/**
 * getTradesByAddress
 * Get trades for a specific position token address/market on Polymarket
 * @param {string} token - your Bitquery OAuth token
 * @param {string} address - position token ID to query
 * @param {number} count - number of results to return (default: 20)
 * @returns {Promise<Array>} - array of trade data for the specific address
 */
const getTradesByAddress = async (token, address, count = 20) => {
    try {
        const tradesByAddress = await queryRunner(tradesByAddressQuery(address, count), token);
        return tradesByAddress.data.EVM.DEXTradeByTokens;
    } catch (error) {
        throw error;
    }
}

/**
 * getTradesByUser
 * Get trades by a specific user on Polymarket
 * @param {string} token - your Bitquery OAuth token
 * @param {string} userAddress - wallet address of the user
 * @param {number} count - number of results to return (default: 20)
 * @returns {Promise<Array>} - array of trade data for the specific user
 */
const getTradesByUser = async (token, userAddress, count = 20) => {
    try {
        const tradesByUser = await queryRunner(tradesByUserQuery(userAddress, count), token);
        return tradesByUser.data.EVM.DEXTradeByTokens;
    } catch (error) {
        throw error;
    }
}

/**
 * streamAllTrades
 * Stream live all Polymarket trades data
 * @param {string} token - your Bitquery OAuth token
 * @param {object} options - optional settings: { autoCloseMs, onData, onError }
 * @returns {Promise<WebSocket>} - active WebSocket connection
 */
const streamAllTrades = (token, options = {}) => {
    try {
        return streamRunner(allTradesStream, token, {
            autoCloseMs: options.autoCloseMs,
            onData: options.onData,
            onError: options.onError,
        });
    } catch (error) {
        throw error;
    }
}

/**
 * streamTradesByAddress
 * Stream live trades for a specific position token address/market on Polymarket
 * @param {string} token - your Bitquery OAuth token
 * @param {string} address - position token ID to stream
 * @param {object} options - optional settings: { autoCloseMs, onData, onError }
 * @returns {Promise<WebSocket>} - active WebSocket connection
 */
const streamTradesByAddress = (token, address, options = {}) => {
    try {
        return streamRunner(tradesByAddressStream(address), token, {
            autoCloseMs: options.autoCloseMs,
            onData: options.onData,
            onError: options.onError,
        });
    } catch (error) {
        throw error;
    }
}

/**
 * streamTradesByUser
 * Stream live trades by a specific user on Polymarket
 * @param {string} token - your Bitquery OAuth token
 * @param {string} userAddress - wallet address of the user
 * @param {object} options - optional settings: { autoCloseMs, onData, onError }
 * @returns {Promise<WebSocket>} - active WebSocket connection
 */
const streamTradesByUser = (token, userAddress, options = {}) => {
    try {
        return streamRunner(tradesByUserStream(userAddress), token, {
            autoCloseMs: options.autoCloseMs,
            onData: options.onData,
            onError: options.onError,
        });
    } catch (error) {
        throw error;
    }
}

export { getNewQuestions, getPayoutRecieved, getPositionSplits, getResolvedQuestions, streamNewQuestions, streamPayoutRecieved, streamPositionSplits, streamResolvedQuestions, getAllTrades, getTradesByAddress, getTradesByUser, streamAllTrades, streamTradesByAddress, streamTradesByUser };