Merge pull request #180 from johnsaviour56-ship-it/refactor/modularize-monolithic-contracts

refactor: modularize documentation and credential_registry contracts

Author: ISTIFANUS-N

contracts/credential_registry/src/credentials.rs

@@ -0,0 +1,100 @@
+//! Core credential operations: issue, revoke, query, and status checks.
+
+use soroban_sdk::{symbol_short, Address, Bytes, BytesN, Env};
+
+use crate::events::{Crediss, Credrev};
+
+/// A credential record stored on-chain:
+/// `(issuer_did, subject_did, metadata_ptr, expires_at, status)`
+type CredRecord = (Bytes, Bytes, Bytes, i128, i32);
+
+pub struct CredentialManager;
+
+impl CredentialManager {
+    /// Issue a new credential.
+    ///
+    /// Panics if a credential with the same hash already exists.
+    pub fn issue(
+        env: &Env,
+        credential_hash: BytesN<32>,
+        issuer: Address,
+        issuer_did: Bytes,
+        subject_did: Bytes,
+        metadata_ptr: Bytes,
+        expires_at: i128,
+    ) {
+        issuer.require_auth();
+
+        let key = (symbol_short!("cred"), credential_hash.clone());
+        assert!(
+            !env.storage().persistent().has(&key),
+            "credential already exists"
+        );
+
+        let record: CredRecord = (
+            issuer_did.clone(),
+            subject_did.clone(),
+            metadata_ptr.clone(),
+            expires_at,
+            0i32,
+        );
+        env.storage().persistent().set(&key, &record);
+
+        Crediss {
+            credential_hash,
+            issuer_did,
+            subject_did,
+            metadata_ptr,
+            expires_at,
+        }
+        .publish(env);
+    }
+
+    /// Revoke an existing credential.
+    ///
+    /// Panics if the credential does not exist.
+    pub fn revoke(env: &Env, credential_hash: BytesN<32>, issuer: Address) {
+        issuer.require_auth();
+
+        let key = (symbol_short!("cred"), credential_hash.clone());
+        let opt: Option<CredRecord> = env.storage().persistent().get(&key);
+
+        match opt {
+            Some((issuer_did, subject_did, metadata_ptr, expires_at, _)) => {
+                let record: CredRecord =
+                    (issuer_did.clone(), subject_did.clone(), metadata_ptr, expires_at, 1i32);
+                env.storage().persistent().set(&key, &record);
+
+                Credrev {
+                    credential_hash,
+                    issuer_did,
+                    subject_did,
+                }
+                .publish(env);
+            }
+            None => panic!("credential not found"),
+        }
+    }
+
+    /// Retrieve a raw credential record, or `None` if not found.
+    pub fn get(env: &Env, credential_hash: BytesN<32>) -> Option<CredRecord> {
+        let key = (symbol_short!("cred"), credential_hash);
+        env.storage().persistent().get(&key)
+    }
+
+    /// Return `true` if the credential exists, is not revoked, and has not expired.
+    pub fn is_active(env: &Env, credential_hash: BytesN<32>, now_ts: i128) -> bool {
+        match Self::get(env, credential_hash) {
+            Some((_, _, _, expires_at, status)) => {
+                if status == 1 {
+                    return false;
+                }
+                if expires_at > 0 && now_ts > expires_at {
+                    return false;
+                }
+                true
+            }
+            None => false,
+        }
+    }
+}

contracts/credential_registry/src/errors.rs

@@ -0,0 +1,18 @@
+//! Error definitions for the credential registry contract.
+
+/// Errors that can occur during credential operations.
+pub enum CredentialError {
+    /// A credential with this hash already exists.
+    AlreadyExists,
+    /// No credential found for the given hash.
+    NotFound,
+}
+
+impl CredentialError {
+    pub fn message(&self) -> &'static str {
+        match self {
+            CredentialError::AlreadyExists => "credential already exists",
+            CredentialError::NotFound => "credential not found",
+        }
+    }
+}

contracts/credential_registry/src/events.rs

@@ -0,0 +1,23 @@
+//! On-chain events emitted by the credential registry.
+
+use soroban_sdk::{contractevent, Bytes, BytesN};
+
+/// Emitted when a credential is issued.
+#[contractevent]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Crediss {
+    pub credential_hash: BytesN<32>,
+    pub issuer_did: Bytes,
+    pub subject_did: Bytes,
+    pub metadata_ptr: Bytes,
+    pub expires_at: i128,
+}
+
+/// Emitted when a credential is revoked.
+#[contractevent]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Credrev {
+    pub credential_hash: BytesN<32>,
+    pub issuer_did: Bytes,
+    pub subject_did: Bytes,
+}

contracts/credential_registry/src/lib.rs

@@ -0,0 +1,69 @@
+//! TeachLink Credential Registry Contract
+//!
+//! On-chain registry for verifiable credentials (VCs).
+//! Functionality is split across focused modules:
+//!
+//! - [`types`]       — credential status enum
+//! - [`events`]      — on-chain event definitions
+//! - [`errors`]      — error definitions
+//! - [`credentials`] — issue, revoke, query, and status logic
+
+#![no_std]
+
+use soroban_sdk::{contract, contractimpl, Address, Bytes, BytesN, Env};
+
+mod credentials;
+mod errors;
+mod events;
+mod types;
+
+pub use events::{Crediss, Credrev};
+pub use types::CredentialStatus;
+
+/// Credential registry contract — delegates to focused sub-modules.
+#[contract]
+pub struct CredentialRegistryContract;
+
+#[contractimpl]
+impl CredentialRegistryContract {
+    /// Issue a credential by storing its hash and metadata pointer.
+    ///
+    /// `credential_hash` should be a deterministic hash (e.g. SHA-256) of the full VC JSON.
+    pub fn issue_credential(
+        env: &Env,
+        credential_hash: BytesN<32>,
+        issuer: Address,
+        issuer_did: Bytes,
+        subject_did: Bytes,
+        metadata_ptr: Bytes,
+        expires_at: i128,
+    ) {
+        credentials::CredentialManager::issue(
+            env,
+            credential_hash,
+            issuer,
+            issuer_did,
+            subject_did,
+            metadata_ptr,
+            expires_at,
+        );
+    }
+
+    /// Revoke a credential. Caller must be the original issuer.
+    pub fn revoke_credential(env: &Env, credential_hash: BytesN<32>, issuer: Address) {
+        credentials::CredentialManager::revoke(env, credential_hash, issuer);
+    }
+
+    /// Get a credential record: `(issuer_did, subject_did, metadata_ptr, expires_at, status)`.
+    pub fn get_credential(
+        env: &Env,
+        credential_hash: BytesN<32>,
+    ) -> Option<(Bytes, Bytes, Bytes, i128, i32)> {
+        credentials::CredentialManager::get(env, credential_hash)
+    }
+
+    /// Check if a credential is active (not revoked and not expired).
+    pub fn is_active(env: &Env, credential_hash: BytesN<32>, now_ts: i128) -> bool {
+        credentials::CredentialManager::is_active(env, credential_hash, now_ts)
+    }
+}

contracts/credential_registry/src/types.rs

@@ -0,0 +1,20 @@
+//! Credential registry data types.
+
+/// Status of a credential.
+#[derive(Clone, PartialEq)]
+pub enum CredentialStatus {
+    Active,
+    Revoked,
+    Expired,
+}
+
+impl CredentialStatus {
+    /// Numeric representation stored on-chain: 0 = Active, 1 = Revoked.
+    pub fn to_i32(status: &CredentialStatus) -> i32 {
+        match status {
+            CredentialStatus::Active => 0,
+            CredentialStatus::Revoked => 1,
+            CredentialStatus::Expired => 2,
+        }
+    }
+}

contracts/documentation/src/articles.rs

@@ -0,0 +1,101 @@
+//! Article management: create, retrieve, update, and analytics for documentation articles.
+
+use soroban_sdk::{Address, Env, String, Vec};
+
+use crate::storage::DocKey;
+use crate::types::{Article, DocCategory, Visibility};
+
+pub struct ArticleManager;
+
+impl ArticleManager {
+    /// Create a new documentation article.
+    pub fn create(
+        env: &Env,
+        id: String,
+        title: String,
+        content: String,
+        category: DocCategory,
+        language: String,
+        tags: Vec<String>,
+        visibility: Visibility,
+        author: Address,
+    ) -> Article {
+        let timestamp = env.ledger().timestamp();
+
+        let article = Article {
+            id: id.clone(),
+            title,
+            content,
+            category,
+            language,
+            version: 1,
+            author,
+            visibility,
+            tags,
+            created_at: timestamp,
+            updated_at: timestamp,
+            view_count: 0,
+            helpful_count: 0,
+        };
+
+        env.storage().instance().set(&id, &article);
+
+        let count: u64 = env
+            .storage()
+            .instance()
+            .get(&DocKey::ArticleCount)
+            .unwrap_or(0);
+        env.storage()
+            .instance()
+            .set(&DocKey::ArticleCount, &(count + 1));
+
+        article
+    }
+
+    /// Retrieve an article by ID.
+    pub fn get(env: &Env, id: String) -> Article {
+        env.storage().instance().get(&id).unwrap()
+    }
+
+    /// Update title, content, and tags of an existing article.
+    pub fn update(
+        env: &Env,
+        id: String,
+        title: String,
+        content: String,
+        tags: Vec<String>,
+    ) -> Article {
+        let mut article: Article = env.storage().instance().get(&id).unwrap();
+
+        article.title = title;
+        article.content = content;
+        article.tags = tags;
+        article.version += 1;
+        article.updated_at = env.ledger().timestamp();
+
+        env.storage().instance().set(&id, &article);
+        article
+    }
+
+    /// Increment the view counter for an article.
+    pub fn record_view(env: &Env, article_id: String) {
+        let mut article: Article = env.storage().instance().get(&article_id).unwrap();
+        article.view_count += 1;
+        env.storage().instance().set(&article_id, &article);
+    }
+
+    /// Increment the helpful counter for an article.
+    pub fn mark_helpful(env: &Env, article_id: String) {
+        let mut article: Article = env.storage().instance().get(&article_id).unwrap();
+        article.helpful_count += 1;
+        env.storage().instance().set(&article_id, &article);
+    }
+
+    /// Return total number of articles stored.
+    pub fn count(env: &Env) -> u64 {
+        env.storage()
+            .instance()
+            .get(&DocKey::ArticleCount)
+            .unwrap_or(0)
+    }
+}

contracts/documentation/src/faq.rs

@@ -0,0 +1,54 @@
+//! FAQ management: create and retrieve FAQ entries.
+
+use soroban_sdk::{Address, Env, String};
+
+use crate::storage::DocKey;
+use crate::types::FaqEntry;
+
+pub struct FaqManager;
+
+impl FaqManager {
+    /// Create a new FAQ entry.
+    pub fn create(
+        env: &Env,
+        id: String,
+        question: String,
+        answer: String,
+        category: String,
+        language: String,
+        author: Address,
+    ) -> FaqEntry {
+        let timestamp = env.ledger().timestamp();
+
+        let faq = FaqEntry {
+            id: id.clone(),
+            question,
+            answer,
+            category,
+            language,
+            author,
+            created_at: timestamp,
+            updated_at: timestamp,
+            helpful_count: 0,
+        };
+
+        env.storage().instance().set(&id, &faq);
+
+        let count: u64 = env.storage().instance().get(&DocKey::FaqCount).unwrap_or(0);
+        env.storage()
+            .instance()
+            .set(&DocKey::FaqCount, &(count + 1));
+
+        faq
+    }
+
+    /// Retrieve a FAQ entry by ID.
+    pub fn get(env: &Env, id: String) -> FaqEntry {
+        env.storage().instance().get(&id).unwrap()
+    }
+
+    /// Return total number of FAQ entries stored.
+    pub fn count(env: &Env) -> u64 {
+        env.storage().instance().get(&DocKey::FaqCount).unwrap_or(0)
+    }
+}