feat: simple polymarket example

jasperdg · jasperdg · commit cf98420be94f · 2025-09-24T11:36:02.000+02:00
diff --git a/scripts/post-dr.ts b/scripts/post-dr.ts
@@ -16,7 +16,7 @@ async function main() {
             method: 'none'
         },
         execProgramId: process.env.ORACLE_PROGRAM_ID,
-        execInputs: Buffer.from('KXSB-26-BUF,540209'),
+        execInputs: Buffer.from('27824'),
         tallyInputs: Buffer.from([]),
         memo: Buffer.from(new Date().toISOString()),
     };
diff --git a/src/execution_phase.rs b/src/execution_phase.rs
@@ -6,129 +6,109 @@ use serde::{Deserialize, Serialize};
 // DATA STRUCTURES
 // ============================================================================
 
+#[derive(Serialize, Deserialize)]
+struct PolyMarketEvent {
+    closed: bool,
+    markets: Vec<PolyMarketMarket>,
+}
+
 #[derive(Serialize, Deserialize)]
 struct PolyMarketMarket {
     #[serde(rename = "outcomePrices")]
     outcome_prices: String, // PolyMarket returns this as a JSON string, not an array
-    volume: String,
 }
 
-#[derive(Serialize, Deserialize)]
-struct KalshiMarket {
-    yes_bid_dollars: String,
-    volume: u64,
-}
 
 #[derive(Serialize, Deserialize)]
-struct KalshiMarketResponse {
-    market: KalshiMarket,
+struct Response {
+    prices: Vec<f64>,
+    market_status: String,
 }
 
 // ============================================================================
-// EXECUTION PHASE - FETCHES LIVE DATA FROM KALSHI & POLYMARKET - TAKES VOLUME WEIGHTED PRICE
+// EXECUTION PHASE - FETCHES LIVE DATA FROM POLYMARKET ONLY
 // ============================================================================
 
 /**
  * Executes the data request phase within the SEDA network.
- * This phase fetches price data from both Kalshi and PolyMarket for the same market,
- * then calculates a volume-weighted average price between the two platforms.
- * Currently works with binary prediction markets and focuses on the "yes" outcome price.
- * Returns the volume-weighted average price as the final result.
+ * This phase fetches event data from PolyMarket for a specific event.
+ * Takes a single input: event_id
+ * Loops through all markets in the event and extracts the first outcome price from each market.
+ * Returns a JSON response with a vector of first outcome prices and whether the event is closed.
  */
 pub fn execution_phase() -> Result<()> {
     // Retrieve the input parameters for the data request (DR).
-    // Expected to be a market identifier that works for both Kalshi and PolyMarket APIs.
+    // Expected to be a single event_id
     let dr_inputs_raw = String::from_utf8(Process::get_inputs())?;
-    let dr_inputs_trimmed = dr_inputs_raw.trim();
-
-    let market_tickers: Vec<&str> = dr_inputs_trimmed.split(',').collect();
+    let event_id = dr_inputs_raw.trim();
 
-    log!("Fetching market data from Kalshi and PolyMarket for market: {} and {}", market_tickers[0], market_tickers[1]);
+    log!("Fetching event data from PolyMarket for event: {}", event_id);
 
-    // Step 1: Fetch Kalshi market data (yes bid price and volume)
-    let kalshi_market_response = http_fetch(
-                format!("https://api.elections.kalshi.com/trade-api/v2/markets/{}", market_tickers[0]),
+    // Fetch PolyMarket event data
+    let polymarket_event_response = http_fetch(
+        format!("https://gamma-api.polymarket.com/events/{}", event_id),
         None,
     );
 
-
-    // Check if the market request was successful
-    if !kalshi_market_response.is_ok() {
+    // Check if the event request was successful
+    if !polymarket_event_response.is_ok() {
         elog!(
-            "market HTTP Response was rejected: {} - {}",
-            kalshi_market_response.status,
-            String::from_utf8(kalshi_market_response.bytes)?
+            "PolyMarket HTTP Response was rejected: {} - {}",
+            polymarket_event_response.status,
+            String::from_utf8(polymarket_event_response.bytes)?
         );
-        Process::error("Error while fetching market information".as_bytes());
+        Process::error("Error while fetching PolyMarket event information".as_bytes());
         return Ok(());
     }
     
+    // Parse event information
+    let poly_market_event_data = serde_json::from_slice::<PolyMarketEvent>(&polymarket_event_response.bytes)?;
     
-    // Parse market informationmarket_response
-    let kalshi_market_data = serde_json::from_slice::<KalshiMarketResponse>(&kalshi_market_response.bytes)?;
-    log!(
-        "Fetched Kalshi Price (YES BID): {} cents with volume {}",
-        kalshi_market_data.market.yes_bid_dollars,
-        kalshi_market_data.market.volume
-    );
-
-    let kalshi_yes_bid_dollars = kalshi_market_data.market.yes_bid_dollars.parse::<f64>()?;
-
-
-    // Step 2: Fetch PolyMarket market data (yes outcome price and volume)
-    let polymarket_market_response = http_fetch(
-                format!("https://gamma-api.polymarket.com/markets/{}", market_tickers[1]),
-        None,
-    );
-
-
-    // Check if the market request was successful
-    if !polymarket_market_response.is_ok() {
-        elog!(
-            "market HTTP Response was rejected: {} - {}",
-            polymarket_market_response.status,
-            String::from_utf8(polymarket_market_response.bytes)?
-        );
-        Process::error("Error while fetching market information".as_bytes());
+    // Validate that the event has at least one market
+    if poly_market_event_data.markets.is_empty() {
+        elog!("Event has no markets available");
+        Process::error("Error: Event has no markets".as_bytes());
         return Ok(());
     }
     
-    // Parse market informationmarket_response
-    let poly_market_market_data = serde_json::from_slice::<PolyMarketMarket>(&polymarket_market_response.bytes)?;
-    let outcome_prices_array: Vec<String> = serde_json::from_str(&poly_market_market_data.outcome_prices)?;
-    let polymarket_yes_price = outcome_prices_array[0].parse::<f64>()?; // 0 = yes price
-
-    log!(
-        "Fetched Price (YES PRICE): {} cents with volume {}",
-        polymarket_yes_price,
-        poly_market_market_data.volume
-    );
-
-
-    let poly_market_volume = poly_market_market_data.volume.parse::<f64>()?;
-
-    // Step 3: Calculate volume-weighted average price between Kalshi and PolyMarket
-    let total_volume = kalshi_market_data.market.volume as f64 + poly_market_volume;
+    // Loop through all markets and extract the first outcome price from each
+    let mut yes_prices: Vec<f64> = Vec::new();
     
-    if total_volume == 0.0 {
-        elog!("Total volume is zero, cannot calculate volume weighted average price");
-        Process::error("Error: Total volume is zero".as_bytes());
-        return Ok(());
+    for (i, market) in poly_market_event_data.markets.iter().enumerate() {
+        // Parse the outcome_prices JSON string into a vector
+        let outcome_prices_array: Vec<String> = serde_json::from_str(&market.outcome_prices)?;
+        
+        if outcome_prices_array.is_empty() {
+            elog!("Market {} has no outcome prices", i);
+            continue;
+        }
+        
+        // Get the first outcome price and parse it as f64
+        let yes_price = outcome_prices_array[0].parse::<f64>().map_err(|e| {
+            elog!("Failed to parse first outcome price for market {}: {}", i, e);
+            anyhow::anyhow!("Invalid price format")
+        })?;
+        
+        yes_prices.push(yes_price);
+        log!("Market {}: First outcome price = {}", i, yes_price);
     }
 
-    // Calculate weighted prices: price × volume for each platform
-    let kalshi_weighted_price = kalshi_yes_bid_dollars * (kalshi_market_data.market.volume as f64);
-    let polymarket_weighted_price = polymarket_yes_price * poly_market_volume;
-
-    // Final volume-weighted average: (sum of weighted prices) / (total volume)
-    let volume_weighted_average_price = (kalshi_weighted_price + polymarket_weighted_price) / total_volume;
-
     log!(
-        "Volume Weighted Average Price: {:.8} cents",
-        volume_weighted_average_price
+        "Collected {} first outcome prices from all markets",
+        yes_prices.len()
     );
 
-    // Return the volume-weighted average price as the execution result
-    Process::success(volume_weighted_average_price.to_string().as_bytes());
+    let market_status = if poly_market_event_data.closed {
+        "closed".to_string()
+    } else {
+        "open".to_string()
+    };
+
+
+    // Return the PolyMarket first outcome prices and event status as JSON
+    Process::success(&serde_json::to_vec(&Response {
+        prices: yes_prices,
+        market_status: market_status,
+    })?);
     Ok(())
 }
diff --git a/src/tally_phase.rs b/src/tally_phase.rs
@@ -1,10 +1,18 @@
 use anyhow::Result;
 use seda_sdk_rs::{elog, get_reveals, log, Process};
+use serde::{Deserialize, Serialize};
+
+
+#[derive(Serialize, Deserialize)]
+struct Response {
+    prices: Vec<f64>,
+    market_status: String,
+}
 
 /**
  * Executes the tally phase within the SEDA network.
  * This phase aggregates the results (e.g., price data) revealed during the execution phase,
- * calculates the median value, and submits it as the final result.
+ * calculates the median value for each index position across all reveals, and submits the final result.
  * Note: The number of reveals depends on the replication factor set in the data request parameters.
  */
 pub fn tally_phase() -> Result<()> {
@@ -13,43 +21,72 @@ pub fn tally_phase() -> Result<()> {
 
     // Retrieve consensus reveals from the tally phase.
     let reveals = get_reveals()?;
-    let mut prices: Vec<f64> = Vec::new();
+    let mut market_status: Option<String> = None;
+    let mut all_price_vectors: Vec<Vec<f64>> = Vec::new();
 
-    // Iterate over each reveal, parse its content as a floating-point number (f64), and store it in the prices array.
+    // Iterate over each reveal and collect price vectors
     for reveal in reveals {
-        let price_str = match String::from_utf8(reveal.body.reveal) {
-            Ok(value) => value,
-            Err(_err) => {
-                // We should always handle a reveal body with care and not exit/panic when parsing went wrong
-                // It's better to skip that reveal
-                elog!("Reveal body could not be converted to string");
-                continue;
-            }
-        };
-
-        let price = match price_str.trim().parse::<f64>() {
-            Ok(value) => value,
-            Err(_err) => {
-                elog!("Reveal body could not be parsed as f64: {}", price_str);
-                continue;
-            }
-        };
-
-        log!("Received price: {}", price);
-        prices.push(price);
+        let response = serde_json::from_slice::<Response>(&reveal.body.reveal)?;
+        
+        // Check market_status consensus
+        if market_status.is_none() {
+            market_status = Some(response.market_status);
+        } else if market_status.as_ref().unwrap() != &response.market_status {
+            elog!("Market status is inconsistent between reveals");
+            Process::error("Market status is inconsistent between reveals".as_bytes());
+            return Ok(());
+        }
+        
+        // Collect price vectors for median calculation
+        log!("Received prices: {:?}", response.prices);
+        all_price_vectors.push(response.prices);
     }
 
-    if prices.is_empty() {
+    if all_price_vectors.is_empty() {
         // If no valid prices were revealed, report an error indicating no consensus.
         Process::error("No consensus among revealed results".as_bytes());
         return Ok(());
     }
 
-    // If there are valid prices revealed, calculate the median price from price reports.
-    let final_price = median(prices);
+    // Find the maximum vector length to determine how many indices we need to process
+    let max_length = all_price_vectors.iter().map(|v| v.len()).max().unwrap_or(0);
+    
+    if max_length == 0 {
+        elog!("All price vectors are empty");
+        Process::error("All price vectors are empty".as_bytes());
+        return Ok(());
+    }
+
+    // Calculate median for each index position
+    let mut median_prices: Vec<f64> = Vec::new();
+    
+    for index in 0..max_length {
+        let mut values_at_index: Vec<f64> = Vec::new();
+        
+        // Collect all values at this index from all reveals
+        for price_vector in &all_price_vectors {
+            if index < price_vector.len() {
+                values_at_index.push(price_vector[index]);
+            }
+        }
+        
+        if values_at_index.is_empty() {
+            log!("No values found at index {}, skipping", index);
+            continue;
+        }
+        
+        let median_value = median(values_at_index);
+        median_prices.push(median_value);
+        log!("Index {}: Median = {}", index, median_value);
+    }
+
+    log!("Final median prices: {:?}", median_prices);
 
-    // Report the successful result in the tally phase, encoding the result as bytes.
-    Process::success(&final_price.to_string().as_bytes());
+    // Return the median result
+    Process::success(&serde_json::to_vec(&Response {
+        prices: median_prices,
+        market_status: market_status.unwrap(),
+    })?);
 
     Ok(())
 }
