feat: implement market retrieval

Author: ComputerOracle

contracts/src/errors.rs

@@ -9,4 +9,5 @@ pub enum PredictXError {
     EmptyDescription = 3,
     InvalidOutcomeCount = 4,
     InvalidEndTime = 5,
+    MarketNotFound = 6,
 }

contracts/src/lib.rs

@@ -11,7 +11,7 @@ pub mod storage;
 use crate::{
     errors::PredictXError,
     market::Market,
-    storage::{get_next_market_id, save_market},
+    storage::{get_market as load_market, get_market_count, get_next_market_id, save_market},
 };
 use soroban_sdk::{contract, contractimpl, Env, String, Vec};
 
@@ -62,6 +62,23 @@ impl PredictXContract {
 
         Ok(market_id)
     }
+
+    pub fn get_market(env: Env, market_id: u64) -> Result<Market, PredictXError> {
+        load_market(&env, market_id).ok_or(PredictXError::MarketNotFound)
+    }
+
+    pub fn list_markets(env: Env) -> Vec<Market> {
+        let market_count = get_market_count(&env);
+        let mut markets = Vec::new(&env);
+
+        for market_id in 1..=market_count {
+            if let Some(market) = load_market(&env, market_id) {
+                markets.push_back(market);
+            }
+        }
+
+        markets
+    }
 }
 
 #[cfg(test)]

contracts/src/storage.rs

@@ -23,6 +23,13 @@ pub fn get_next_market_id(env: &Env) -> u64 {
     next_id
 }
 
+pub fn get_market_count(env: &Env) -> u64 {
+    env.storage()
+        .instance()
+        .get(&DataKey::MarketCounter)
+        .unwrap_or(0_u64)
+}
+
 pub fn save_market(env: &Env, market: &Market) {
     env.storage()
         .persistent()

contracts/src/tests.rs

@@ -186,3 +186,81 @@ fn rejects_invalid_end_time() {
         assert_eq!(result, Err(PredictXError::InvalidEndTime));
     });
 }
+
+#[test]
+fn retrieves_existing_market() {
+    let env = Env::default();
+    let contract_id = env.register(PredictXContract, ());
+
+    env.as_contract(&contract_id, || {
+        let market_id = PredictXContract::create_market(
+            env.clone(),
+            String::from_str(&env, "Existing market"),
+            String::from_str(&env, "A market that should be retrievable."),
+            env.ledger().timestamp() + 1,
+            vec![
+                &env,
+                String::from_str(&env, "Yes"),
+                String::from_str(&env, "No"),
+            ],
+        )
+        .unwrap();
+
+        let market = PredictXContract::get_market(env.clone(), market_id).unwrap();
+
+        assert_eq!(market.id, market_id);
+        assert_eq!(market.title, String::from_str(&env, "Existing market"));
+        assert!(!market.resolved);
+    });
+}
+
+#[test]
+fn rejects_missing_market_retrieval() {
+    let env = Env::default();
+    let contract_id = env.register(PredictXContract, ());
+
+    env.as_contract(&contract_id, || {
+        let result = PredictXContract::get_market(env.clone(), 404);
+
+        assert_eq!(result, Err(PredictXError::MarketNotFound));
+    });
+}
+
+#[test]
+fn lists_multiple_markets() {
+    let env = Env::default();
+    let contract_id = env.register(PredictXContract, ());
+
+    env.as_contract(&contract_id, || {
+        let first_id = PredictXContract::create_market(
+            env.clone(),
+            String::from_str(&env, "First market"),
+            String::from_str(&env, "The first market in the list."),
+            env.ledger().timestamp() + 1,
+            vec![
+                &env,
+                String::from_str(&env, "Yes"),
+                String::from_str(&env, "No"),
+            ],
+        )
+        .unwrap();
+        let second_id = PredictXContract::create_market(
+            env.clone(),
+            String::from_str(&env, "Second market"),
+            String::from_str(&env, "The second market in the list."),
+            env.ledger().timestamp() + 2,
+            vec![
+                &env,
+                String::from_str(&env, "Up"),
+                String::from_str(&env, "Down"),
+            ],
+        )
+        .unwrap();
+
+        let markets = PredictXContract::list_markets(env.clone());
+
+        assert_eq!(markets.len(), 2);
+        assert_eq!(markets.get(0).unwrap().id, first_id);
+        assert_eq!(markets.get(1).unwrap().id, second_id);
+    });
+}