openoracle-sdk-js/dist/api/poll-api.d.ts

OpenOracle Node.js SDK - Intelligent Oracle Routing with Multiple LLM Providers

import { OracleClient } from '../core/client';
import { OracleConfig } from '../core/config';
import { DataCategory, ResolutionMethod, ConfidenceLevel } from '../types/enums';
import { OraclePollData } from '../schemas/oracle-schemas';

export interface CreatePollRequest {
    question: string;
    description?: string;
    category: DataCategory;
    options: string[];
    endTime: Date;
    resolutionMethod: ResolutionMethod;
    minimumStake?: number;
    maximumStake?: number;
    creatorStake?: number;
    tags?: string[];
    metadata?: Record<string, any>;
}
export interface PollVote {
    pollId: string;
    optionIndex: number;
    stake: number;
    confidence: ConfidenceLevel;
    reasoning?: string;
    timestamp: Date;
    voterAddress: string;
}
export interface PollResolution {
    pollId: string;
    winningOption: number;
    resolutionData: any;
    resolutionSource: string;
    confidence: ConfidenceLevel;
    timestamp: Date;
    totalPayout: number;
    resolverAddress: string;
}
export interface PollStatistics {
    pollId: string;
    totalVotes: number;
    totalStake: number;
    uniqueVoters: number;
    averageStake: number;
    confidenceDistribution: Record<ConfidenceLevel, number>;
    optionStatistics: Array<{
        option: string;
        votes: number;
        stake: number;
        percentage: number;
        averageConfidence: number;
    }>;
    timeSeriesData: Array<{
        timestamp: Date;
        cumulativeVotes: number;
        cumulativeStake: number;
        optionPercentages: number[];
    }>;
}
export interface UserPollActivity {
    userId: string;
    totalPolls: number;
    totalVotes: number;
    totalStake: number;
    successRate: number;
    averageConfidence: number;
    expertiseAreas: DataCategory[];
    recentPolls: OraclePollData[];
    recentVotes: PollVote[];
    earnings: {
        total: number;
        thisMonth: number;
        lastMonth: number;
        averageReturn: number;
    };
}
export declare class PollAPI {
    private readonly client;
    private readonly config;
    constructor(client: OracleClient, config: OracleConfig);
    /**
     * Create a new prediction poll
     */
    createPoll(request: CreatePollRequest): Promise<{
        pollId: string;
    }>;
    /**
     * Get poll details
     */
    getPoll(pollId: string): Promise<OraclePollData>;
    /**
     * List polls with filtering options
     */
    listPolls(options?: {
        category?: DataCategory;
        status?: 'active' | 'closed' | 'resolved' | 'cancelled';
        creator?: string;
        tags?: string[];
        limit?: number;
        offset?: number;
        sortBy?: 'created_time' | 'end_time' | 'total_stake' | 'total_votes';
        sortOrder?: 'asc' | 'desc';
    }): Promise<{
        polls: OraclePollData[];
        total: number;
        hasMore: boolean;
    }>;
    /**
     * Vote on a poll
     */
    vote(pollId: string, optionIndex: number, stake: number, confidence?: ConfidenceLevel, reasoning?: string): Promise<{
        success: boolean;
        voteId: string;
    }>;
    /**
     * Get poll statistics
     */
    getPollStatistics(pollId: string): Promise<PollStatistics>;
    /**
     * Get user's voting history
     */
    getUserActivity(userAddress: string): Promise<UserPollActivity>;
    /**
     * Resolve a poll (for authorized resolvers)
     */
    resolvePoll(pollId: string, winningOption: number, resolutionData: any, resolutionSource: string): Promise<{
        success: boolean;
        transactionHash?: string;
    }>;
    /**
     * Get poll resolution details
     */
    getPollResolution(pollId: string): Promise<PollResolution>;
    /**
     * Get trending polls
     */
    getTrendingPolls(timeframe?: '1h' | '6h' | '1d' | '1w', category?: DataCategory): Promise<Array<{
        poll: OraclePollData;
        metrics: {
            voteVelocity: number;
            stakeVelocity: number;
            socialMentions: number;
            trendingScore: number;
        };
    }>>;
    /**
     * Search polls by keywords
     */
    searchPolls(query: string, options?: {
        category?: DataCategory;
        status?: 'active' | 'closed' | 'resolved';
        limit?: number;
        includeContent?: boolean;
    }): Promise<OraclePollData[]>;
    /**
     * Get poll recommendations for user
     */
    getRecommendations(userAddress: string, limit?: number): Promise<Array<{
        poll: OraclePollData;
        relevanceScore: number;
        reason: string;
    }>>;
    /**
     * Subscribe to poll updates
     */
    subscribeToPollUpdates(pollId: string, callback: (update: {
        type: 'vote' | 'resolution' | 'status_change';
        data: any;
        timestamp: Date;
    }) => void): EventSource;
    /**
     * Subscribe to new polls in category
     */
    subscribeToNewPolls(category: DataCategory, callback: (poll: OraclePollData) => void): EventSource;
    /**
     * Get market maker opportunities
     */
    getMarketMakerOpportunities(minLiquidity: number, maxRisk: number, categories?: DataCategory[]): Promise<Array<{
        poll: OraclePollData;
        opportunity: {
            expectedReturn: number;
            riskScore: number;
            liquidityNeeded: number;
            timeToResolution: number;
            confidenceGap: number;
        };
    }>>;
    /**
     * Create automated poll resolution
     */
    createAutomatedResolution(pollId: string, resolutionConfig: {
        oracleProviders: string[];
        consensusThreshold: number;
        dataSource: string;
        resolutionLogic: string;
        fallbackMethod?: ResolutionMethod;
    }): Promise<{
        success: boolean;
        resolutionId: string;
    }>;
    /**
     * Get poll analytics
     */
    getPollAnalytics(pollId: string): Promise<{
        demographics: {
            voterDistribution: Record<string, number>;
            experienceDistribution: Record<string, number>;
            geographicDistribution: Record<string, number>;
        };
        predictions: {
            currentProbabilities: number[];
            probabilityHistory: Array<{
                timestamp: Date;
                probabilities: number[];
            }>;
            expertPredictions: Array<{
                expert: string;
                prediction: number;
                confidence: number;
                track_record: number;
            }>;
        };
        market: {
            efficiency: number;
            liquidity: number;
            volatility: number;
            arbitrageOpportunities: Array<{
                description: string;
                profit: number;
                risk: number;
            }>;
        };
    }>;
    private validatePollRequest;
}