feat: implement market model and storage

Author: ComputerOracle

contracts/src/market.rs

@@ -1,7 +1,13 @@
-use soroban_sdk::{contracttype, String};
+use soroban_sdk::{contracttype, Address, String, Vec};
 
 #[contracttype]
 #[derive(Clone, Debug, Eq, PartialEq)]
-pub struct MarketDraft {
+pub struct Market {
+    pub id: u64,
+    pub creator: Address,
     pub title: String,
+    pub description: String,
+    pub end_time: u64,
+    pub outcomes: Vec<String>,
+    pub resolved: bool,
 }

contracts/src/storage.rs

@@ -1,7 +1,34 @@
-use soroban_sdk::{contracttype, Symbol};
+use crate::market::Market;
+use soroban_sdk::{contracttype, Env};
 
 #[contracttype]
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum DataKey {
-    Placeholder(Symbol),
+    Market(u64),
+    MarketCounter,
+}
+
+pub fn get_next_market_id(env: &Env) -> u64 {
+    let current_id = env
+        .storage()
+        .instance()
+        .get(&DataKey::MarketCounter)
+        .unwrap_or(0_u64);
+    let next_id = current_id.checked_add(1).expect("market counter overflow");
+
+    env.storage()
+        .instance()
+        .set(&DataKey::MarketCounter, &next_id);
+
+    next_id
+}
+
+pub fn save_market(env: &Env, market: &Market) {
+    env.storage()
+        .persistent()
+        .set(&DataKey::Market(market.id), market);
+}
+
+pub fn get_market(env: &Env, market_id: u64) -> Option<Market> {
+    env.storage().persistent().get(&DataKey::Market(market_id))
 }

contracts/src/tests.rs

@@ -1,5 +1,9 @@
 use super::{PredictXContract, PredictXContractClient};
-use soroban_sdk::{Env, String};
+use crate::{
+    market::Market,
+    storage::{get_market, get_next_market_id, save_market},
+};
+use soroban_sdk::{testutils::Address as _, vec, Address, Env, String};
 
 #[test]
 fn exposes_contract_version() {
@@ -9,3 +13,53 @@ fn exposes_contract_version() {
 
     assert_eq!(client.version(), String::from_str(&env, "0.1.0"));
 }
+
+#[test]
+fn increments_market_ids_from_one() {
+    let env = Env::default();
+    let contract_id = env.register(PredictXContract, ());
+
+    env.as_contract(&contract_id, || {
+        assert_eq!(get_next_market_id(&env), 1);
+        assert_eq!(get_next_market_id(&env), 2);
+        assert_eq!(get_next_market_id(&env), 3);
+    });
+}
+
+#[test]
+fn saves_and_loads_market_by_id() {
+    let env = Env::default();
+    let contract_id = env.register(PredictXContract, ());
+    let creator = Address::generate(&env);
+
+    env.as_contract(&contract_id, || {
+        let market_id = get_next_market_id(&env);
+        let market = Market {
+            id: market_id,
+            creator,
+            title: String::from_str(&env, "Will PredictX launch on testnet?"),
+            description: String::from_str(&env, "Placeholder market model test."),
+            end_time: 1_789_000_000,
+            outcomes: vec![
+                &env,
+                String::from_str(&env, "Yes"),
+                String::from_str(&env, "No"),
+            ],
+            resolved: false,
+        };
+
+        save_market(&env, &market);
+
+        assert_eq!(get_market(&env, market_id), Some(market));
+    });
+}
+
+#[test]
+fn returns_none_for_missing_market() {
+    let env = Env::default();
+    let contract_id = env.register(PredictXContract, ());
+
+    env.as_contract(&contract_id, || {
+        assert_eq!(get_market(&env, 404), None);
+    });
+}