openoracle-node-sdk/src/schemas/prediction-market-schemas.ts

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

/**
 * Prediction Market Schemas
 * TypeScript interfaces and Zod schemas for prediction market creation
 */

import { z } from 'zod';

// Enums
export enum MarketCategory {
  SPORTS = 'Sports',
  POLITICS = 'Politics',
  ENTERTAINMENT = 'Entertainment',
  CRYPTO = 'Crypto',
  FINANCE = 'Finance',
  TECHNOLOGY = 'Technology',
  CUSTOM = 'Custom'
}

export enum MarketStatus {
  PENDING = 'pending',
  ACTIVE = 'active',
  RESOLVED = 'resolved',
  CANCELLED = 'cancelled'
}

// Request Schema
export const PredictionMarketRequestSchema = z.object({
  text: z.string().min(1).describe('The text to analyze for prediction market creation'),
  creator_address: z.string().regex(/^0x[a-fA-F0-9]{40}$/),
  initial_liquidity: z.number().min(0).default(0),
  resolution_time: z.date().optional(),
  metadata: z.record(z.any()).optional()
});

export type PredictionMarketRequest = z.infer<typeof PredictionMarketRequestSchema>;

// Qualification Schema
export const PredictionQualificationSchema = z.object({
  is_prediction_market: z.boolean(),
  confidence: z.number().min(0).max(1),
  reasoning: z.string(),
  has_clear_outcome: z.boolean(),
  is_measurable: z.boolean(),
  is_verifiable: z.boolean(),
  has_timeframe: z.boolean(),
  outcomes: z.array(z.string()),
  timeframe: z.string().optional(),
  verification_method: z.string()
});

export type PredictionQualification = z.infer<typeof PredictionQualificationSchema>;

// Oracle Routing Schema
export const OracleRoutingSchema = z.object({
  oracle_provider: z.enum(['chainlink', 'pyth', 'uma', 'band', 'api3']),
  reasoning: z.string(),
  confidence: z.number().min(0).max(1),
  data_type: z.enum(['price', 'sports', 'weather', 'social', 'custom']),
  update_frequency: z.enum(['realtime', 'hourly', 'daily', 'on_demand']),
  resolution_method: z.enum(['direct', 'optimistic', 'aggregated']),
  expected_latency_ms: z.number(),
  estimated_cost_usd: z.number(),
  resolution_sources: z.array(z.string())
});

export type OracleRouting = z.infer<typeof OracleRoutingSchema>;

// Market Parameters Schema
export const MarketParametersSchema = z.object({
  market_title: z.string().max(100),
  market_description: z.string(),
  market_category: z.nativeEnum(MarketCategory),
  market_labels: z.array(z.string()),
  market_type: z.enum(['binary', 'multiple', 'scalar']),
  outcomes: z.array(z.string()),
  resolution_timestamp: z.date(),
  oracle_address: z.string().regex(/^0x[a-fA-F0-9]{40}$/),
  resolution_criteria: z.string(),
  initial_odds: z.record(z.number()),
  liquidity_amount: z.number(),
  creator_fee_bps: z.number().min(0).max(10000)
});

export type MarketParameters = z.infer<typeof MarketParametersSchema>;

// Contract Call Data Schema
export const ContractCallDataSchema = z.object({
  contract_address: z.string().regex(/^0x[a-fA-F0-9]{40}$/),
  function_name: z.string(),
  parameters: z.record(z.any()),
  encoded_data: z.string(),
  estimated_gas: z.number(),
  chain_id: z.number()
});

export type ContractCallData = z.infer<typeof ContractCallDataSchema>;

// Market Creation Response Schema
export const PredictionMarketCreationResponseSchema = z.object({
  qualification: PredictionQualificationSchema,
  routing: OracleRoutingSchema,
  parameters: MarketParametersSchema,
  contract_data: ContractCallDataSchema,
  success: z.boolean(),
  market_id: z.string().optional(),
  estimated_total_cost: z.number(),
  request_id: z.string(),
  processing_time_ms: z.number()
});

export type PredictionMarketCreationResponse = z.infer<typeof PredictionMarketCreationResponseSchema>;

// Market Analysis Log Schema (for database)
export const MarketAnalysisLogSchema = z.object({
  request_id: z.string(),
  creator_address: z.string(),
  input_text: z.string(),
  is_valid_market: z.boolean(),
  confidence_score: z.number(),
  oracle_provider: z.string().optional(),
  market_category: z.nativeEnum(MarketCategory).optional(),
  market_labels: z.array(z.string()).optional(),
  market_title: z.string().optional(),
  outcomes: z.array(z.string()).optional(),
  resolution_criteria: z.string().optional(),
  resolution_timestamp: z.date().optional(),
  initial_liquidity: z.number().optional(),
  contract_address: z.string().optional(),
  status: z.nativeEnum(MarketStatus),
  error_message: z.string().optional(),
  created_at: z.date(),
  updated_at: z.date().optional()
});

export type MarketAnalysisLog = z.infer<typeof MarketAnalysisLogSchema>;

// Market Odds Display Schema
export const MarketOddsSchema = z.object({
  probabilities: z.array(z.number()), // Implied probability (basis points)
  payouts: z.array(z.number()), // Payout per 1 USDC (18 decimals)
  totalVolume: z.number(),
  lastUpdate: z.date()
});

export type MarketOdds = z.infer<typeof MarketOddsSchema>;

// Batch Market Creation Schema
export const BatchMarketRequestSchema = z.object({
  markets: z.array(PredictionMarketRequestSchema),
  creator_address: z.string().regex(/^0x[a-fA-F0-9]{40}$/),
  batch_id: z.string().optional()
});

export type BatchMarketRequest = z.infer<typeof BatchMarketRequestSchema>;

// Market Transformation Schema (for optimizer service)
export const MarketTransformationSchema = z.object({
  original_text: z.string(),
  original_valid: z.boolean(),
  original_issue: z.string().optional(),
  transformations: z.array(z.object({
    oracle: z.string(),
    transformed_question: z.string(),
    explanation: z.string(),
    confidence: z.number(),
    data_source: z.string()
  })),
  success: z.boolean()
});

export type MarketTransformation = z.infer<typeof MarketTransformationSchema>;

// Oracle Capabilities Schema
export const OracleCapabilitiesSchema = z.object({
  provider: z.string(),
  can_measure: z.record(z.string()),
  cannot_measure: z.record(z.string()),
  examples: z.object({
    valid: z.array(z.string()),
    invalid: z.array(z.string())
  })
});

export type OracleCapabilities = z.infer<typeof OracleCapabilitiesSchema>;