feat: implement market creation

Author: ComputerOracle

contracts/src/errors.rs

@@ -5,4 +5,8 @@ use soroban_sdk::contracterror;
 #[repr(u32)]
 pub enum PredictXError {
     NotImplemented = 1,
+    EmptyTitle = 2,
+    EmptyDescription = 3,
+    InvalidOutcomeCount = 4,
+    InvalidEndTime = 5,
 }

contracts/src/lib.rs

@@ -8,7 +8,12 @@ pub mod resolution;
 pub mod rewards;
 pub mod storage;
 
-use soroban_sdk::{contract, contractimpl, Env, String};
+use crate::{
+    errors::PredictXError,
+    market::Market,
+    storage::{get_next_market_id, save_market},
+};
+use soroban_sdk::{contract, contractimpl, Env, String, Vec};
 
 #[contract]
 pub struct PredictXContract;
@@ -18,6 +23,45 @@ impl PredictXContract {
     pub fn version(env: Env) -> String {
         String::from_str(&env, env!("CARGO_PKG_VERSION"))
     }
+
+    pub fn create_market(
+        env: Env,
+        title: String,
+        description: String,
+        end_time: u64,
+        outcomes: Vec<String>,
+    ) -> Result<u64, PredictXError> {
+        if title.len() == 0 {
+            return Err(PredictXError::EmptyTitle);
+        }
+
+        if description.len() == 0 {
+            return Err(PredictXError::EmptyDescription);
+        }
+
+        if outcomes.len() < 2 {
+            return Err(PredictXError::InvalidOutcomeCount);
+        }
+
+        if end_time <= env.ledger().timestamp() {
+            return Err(PredictXError::InvalidEndTime);
+        }
+
+        let market_id = get_next_market_id(&env);
+        let market = Market {
+            id: market_id,
+            creator: env.current_contract_address(),
+            title,
+            description,
+            end_time,
+            outcomes,
+            resolved: false,
+        };
+
+        save_market(&env, &market);
+
+        Ok(market_id)
+    }
 }
 
 #[cfg(test)]

contracts/src/tests.rs

@@ -1,5 +1,6 @@
 use super::{PredictXContract, PredictXContractClient};
 use crate::{
+    errors::PredictXError,
     market::Market,
     storage::{get_market, get_next_market_id, save_market},
 };
@@ -63,3 +64,125 @@ fn returns_none_for_missing_market() {
         assert_eq!(get_market(&env, 404), None);
     });
 }
+
+#[test]
+fn creates_market_successfully() {
+    let env = Env::default();
+    let contract_id = env.register(PredictXContract, ());
+
+    env.as_contract(&contract_id, || {
+        let outcomes = vec![
+            &env,
+            String::from_str(&env, "Yes"),
+            String::from_str(&env, "No"),
+        ];
+        let market_id = PredictXContract::create_market(
+            env.clone(),
+            String::from_str(&env, "Will PredictX launch on testnet?"),
+            String::from_str(&env, "A scaffolded market creation test."),
+            env.ledger().timestamp() + 1,
+            outcomes.clone(),
+        )
+        .unwrap();
+
+        let market = get_market(&env, market_id).unwrap();
+
+        assert_eq!(market.id, market_id);
+        assert_eq!(market.creator, env.current_contract_address());
+        assert_eq!(
+            market.title,
+            String::from_str(&env, "Will PredictX launch on testnet?")
+        );
+        assert_eq!(
+            market.description,
+            String::from_str(&env, "A scaffolded market creation test.")
+        );
+        assert_eq!(market.end_time, env.ledger().timestamp() + 1);
+        assert_eq!(market.outcomes, outcomes);
+        assert!(!market.resolved);
+    });
+}
+
+#[test]
+fn rejects_empty_title() {
+    let env = Env::default();
+    let contract_id = env.register(PredictXContract, ());
+
+    env.as_contract(&contract_id, || {
+        let result = PredictXContract::create_market(
+            env.clone(),
+            String::from_str(&env, ""),
+            String::from_str(&env, "A valid description."),
+            env.ledger().timestamp() + 1,
+            vec![
+                &env,
+                String::from_str(&env, "Yes"),
+                String::from_str(&env, "No"),
+            ],
+        );
+
+        assert_eq!(result, Err(PredictXError::EmptyTitle));
+    });
+}
+
+#[test]
+fn rejects_empty_description() {
+    let env = Env::default();
+    let contract_id = env.register(PredictXContract, ());
+
+    env.as_contract(&contract_id, || {
+        let result = PredictXContract::create_market(
+            env.clone(),
+            String::from_str(&env, "A valid title"),
+            String::from_str(&env, ""),
+            env.ledger().timestamp() + 1,
+            vec![
+                &env,
+                String::from_str(&env, "Yes"),
+                String::from_str(&env, "No"),
+            ],
+        );
+
+        assert_eq!(result, Err(PredictXError::EmptyDescription));
+    });
+}
+
+#[test]
+fn rejects_invalid_outcome_count() {
+    let env = Env::default();
+    let contract_id = env.register(PredictXContract, ());
+
+    env.as_contract(&contract_id, || {
+        let result = PredictXContract::create_market(
+            env.clone(),
+            String::from_str(&env, "A valid title"),
+            String::from_str(&env, "A valid description."),
+            env.ledger().timestamp() + 1,
+            vec![&env, String::from_str(&env, "Only one outcome")],
+        );
+
+        assert_eq!(result, Err(PredictXError::InvalidOutcomeCount));
+    });
+}
+
+#[test]
+fn rejects_invalid_end_time() {
+    let env = Env::default();
+    let contract_id = env.register(PredictXContract, ());
+
+    env.as_contract(&contract_id, || {
+        let result = PredictXContract::create_market(
+            env.clone(),
+            String::from_str(&env, "A valid title"),
+            String::from_str(&env, "A valid description."),
+            env.ledger().timestamp(),
+            vec![
+                &env,
+                String::from_str(&env, "Yes"),
+                String::from_str(&env, "No"),
+            ],
+        );
+
+        assert_eq!(result, Err(PredictXError::InvalidEndTime));
+    });
+}