fix: resolve merge conflicts in create_user_profile - integrate rate limiting

Author: Josue19-08

Cargo.toml

@@ -25,4 +25,3 @@ lto = true
 [profile.release-with-logs]
 inherits = "release"
 debug-assertions = true
-

README.md

@@ -1,6 +1,6 @@
 # skillcert_contracts
 
-### Description
+## Description
 
 Skillcert is platform for issuing NFT-based digital certificates on the Stellar blockchain, ensuring authenticity, traceability, and instant verification. It also features an educational marketplace for courses with automated validated certification.
 
@@ -11,7 +11,6 @@ We are currently in the integration phase between the Web3 logic and the fronten
 The project roadmap is available in Notion:  
 🔗 [View Roadmap in Notion](https://www.notion.so/Skillcert-240bfdf2613c805898c9c91f0990600e)
 
-
 ### 📁 Project Architecture Overview
 
 ```txt
@@ -38,14 +37,13 @@ The project roadmap is available in Notion:
                 ├── lib.rs
                 └── test.rs
 ```
-> As the project grows, new modules, contracts and functions will arise in the architecture.
 
+> As the project grows, new modules, contracts and functions will arise in the architecture.
 
 #### Contract Deployment
 
 To deploy the contracts to the local network (Course Access, Course Registry, User Management), use the provided script:
 
-
 ```bash
 
 ./scripts/deploy_contracts.sh
@@ -58,6 +56,7 @@ This will deploy all contracts and save their addresses in a `contract.json` fil
 Here are some example interactions with the deployed contracts:
 
 1. Create a Course:
+
 ```bash
 stellar contract invoke \
   --id <course_registry_contract_id> \
@@ -74,6 +73,7 @@ stellar contract invoke \
 ```
 
 2. Grant Course Access:
+
 ```bash
 stellar contract invoke \
   --id <course_access_contract_id> \
@@ -85,6 +85,7 @@ stellar contract invoke \
 ```
 
 3. List User's Courses:
+
 ```bash
 stellar contract invoke \
   --id <course_access_contract_id> \
@@ -95,6 +96,7 @@ stellar contract invoke \
 ```
 
 4. View Course Details:
+
 ```bash
 stellar contract invoke \
   --id <course_registry_contract_id> \

contracts/course/course_access/Cargo.toml

@@ -9,8 +9,6 @@ publish = false
 crate-type = ["cdylib"]
 doctest = false
 
-
-
 [dependencies]
 soroban-sdk = { workspace = true }
 

contracts/course/course_access/src/error.rs

@@ -16,9 +16,9 @@ pub enum Error {
     InvalidCourseId = 7,
     InvalidUser = 8,
     EmptyCourseId = 9,
-    // Removed InvalidInput - replaced with specific validation errors below
     InvalidTransferData = 10,
     SameUserTransfer = 11,
+    Initialized = 12
 }
 
 pub fn handle_error(env: &Env, error: Error) -> ! {

contracts/course/course_access/src/functions/config.rs

@@ -4,32 +4,18 @@
 use soroban_sdk::{Address, Env, Symbol, symbol_short};
 use soroban_sdk::storage::Instance;
 
+use crate::error::{Error, handle_error};
 use crate::schema::{KEY_COURSE_REG_ADDR, KEY_USER_MGMT_ADDR};
 
 const INIT_EVENT: Symbol = symbol_short!("initialz");
 const UPDATE_ADDRESS_EVENT: Symbol = symbol_short!("updAddr");
 
-/// Storage key for initialization flag
+
 const KEY_INIT: &str = "init";
 
-/// Storage key for contract owner address
 const KEY_OWNER: &str = "owner";
 
-/// One-time constructor that sets owner and external contract addresses.
-///
-/// This function initializes the contract with the necessary configuration
-/// and can only be called once during the contract's lifetime.
-///
-/// # Arguments
-///
-/// * `env` - The Soroban environment
-/// * `caller` - The address of the contract deployer who becomes the owner
-/// * `user_mgmt_addr` - Address of the user management contract
-/// * `course_registry_addr` - Address of the course registry contract
-///
-/// # Panics
-///
-/// Panics if the contract has already been initialized.
+
 pub fn initialize(
     env: Env,
     caller: Address,
@@ -45,11 +31,10 @@ pub fn initialize(
         .get::<_, bool>(&((KEY_INIT,),))
         .unwrap_or(false)
     {
-        // TODO: Implement graceful initialization error handling instead of panic
-        panic!("already initialized");
+        handle_error(&env, Error::Initialized);
     }
 
-    let inst = env.storage().instance();
+    let inst: Instance = env.storage().instance();
     inst.set(&(KEY_OWNER,), &caller);
     inst.set(&(KEY_USER_MGMT_ADDR,), &user_mgmt_addr);
     inst.set(&(KEY_COURSE_REG_ADDR,), &course_registry_addr);
@@ -59,22 +44,7 @@ pub fn initialize(
         .publish((INIT_EVENT,), (caller, user_mgmt_addr, course_registry_addr));
 }
 
-/// Update external contract addresses.
-///
-/// This function allows the contract owner to update the addresses of external
-/// contracts that this contract depends on for authentication and authorization.
-/// Only the stored owner can perform this operation.
-///
-/// # Arguments
-///
-/// * `env` - The Soroban environment
-/// * `caller` - The address of the user attempting to update the configuration
-/// * `user_mgmt_addr` - New address of the user management contract
-/// * `course_registry_addr` - New address of the course registry contract
-///
-/// # Panics
-///
-/// Panics if the contract is not initialized or if the caller is not the owner.
+
 pub fn set_contract_addrs(
     env: Env,
     caller: Address,
@@ -93,7 +63,7 @@ pub fn set_contract_addrs(
         panic!("not initialized");
     }
 
-    // Only owner may update
+
     let owner: Address = env
         .storage()
         .instance()
@@ -110,6 +80,6 @@ pub fn set_contract_addrs(
         .publish((UPDATE_ADDRESS_EVENT,), (caller, user_mgmt_addr, course_registry_addr));
 }
 
-/// TTL configuration constants for persistent storage entries
+/* /// TTL configuration constants for persistent storage entries
 pub const TTL_TTL: u32 = 1000; // time-to-live
-pub const TTL_BUMP: u32 = 100; // bump amount on access
+pub const TTL_BUMP: u32 = 100; // bump amount on access */

contracts/course/course_access/src/functions/contract_versioning.rs

@@ -22,11 +22,11 @@ pub enum VersioningError {
     MigrationFailed = 6,
 }
 
-/// Storage keys for versioning data
+
 const VERSION_HISTORY_KEY: &str = "version_history";
 const MIGRATION_STATUS_KEY: &str = "migration_status";
 
-/// Get the version history of the contract
+
 pub fn get_version_history(env: &Env) -> Vec<String> {
     let key = String::from_str(env, VERSION_HISTORY_KEY);
     env.storage()
@@ -35,18 +35,17 @@ pub fn get_version_history(env: &Env) -> Vec<String> {
         .unwrap_or_else(|| vec![env])
 }
 
-/// Store a new version in the history
 fn store_version_in_history(env: &Env, version: String) {
-    let mut history = get_version_history(env);
+    let mut history: Vec<String> = get_version_history(env);
     history.push_back(version.clone());
 
-    let key = String::from_str(env, VERSION_HISTORY_KEY);
+    let key: String = String::from_str(env, VERSION_HISTORY_KEY);
     env.storage().instance().set(&key, &history);
 }
 
-/// Check if a version exists in the history
+
 fn version_exists_in_history(env: &Env, version: &String) -> bool {
-    let history = get_version_history(env);
+    let history: Vec<String> = get_version_history(env);
     for v in history.iter() {
         if &v == version {
             return true;
@@ -55,31 +54,29 @@ fn version_exists_in_history(env: &Env, version: &String) -> bool {
     false
 }
 
-/// Get migration status information
+
 pub fn get_migration_status(env: &Env) -> String {
-    let key = String::from_str(env, MIGRATION_STATUS_KEY);
+    let key: String = String::from_str(env, MIGRATION_STATUS_KEY);
     env.storage()
         .instance()
         .get::<String, String>(&key)
         .unwrap_or_else(|| String::from_str(env, "No migrations pending"))
 }
 
-/// Set migration status
+
 fn set_migration_status(env: &Env, status: String) {
     let key = String::from_str(env, MIGRATION_STATUS_KEY);
     env.storage().instance().set(&key, &status);
 }
 
-/// Check compatibility between two versions
+
 pub fn is_version_compatible(_env: &Env, _from_version: String, _to_version: String) -> bool {
     // Simple compatibility check - for now, assume all versions are compatible
     // In a real implementation, you would parse semantic versions properly
     true
 }
 
-/// Check if the caller is authorized to perform migration
-/// For course access, we'll allow any authenticated user for now
-/// In a production environment, this should check for admin privileges
+
 fn is_authorized_for_migration(_env: &Env, _caller: Address) -> bool {
     // For now, we'll allow any authenticated user
     // In a real implementation, you would check against user management contract
@@ -93,40 +90,39 @@ fn is_authorized_for_migration(_env: &Env, _caller: Address) -> bool {
     true // Placeholder - allow all authenticated users
 }
 
-/// Migrate access data between contract versions
 pub fn migrate_access_data(
     env: &Env,
     caller: Address,
     from_version: String,
     to_version: String,
 ) -> bool {
-    // Check if caller is authorized
+
     if !is_authorized_for_migration(env, caller.clone()) {
         set_migration_status(env, String::from_str(env, "Migration failed: Unauthorized"));
         return false;
     }
 
-    // Validate versions exist in history
+
     if !version_exists_in_history(env, &from_version) {
         set_migration_status(env, String::from_str(env, "Migration failed: Source version not found"));
         return false;
     }
 
-    // Check compatibility
+
     if !is_version_compatible(env, from_version.clone(), to_version.clone()) {
         set_migration_status(env, String::from_str(env, "Migration failed: Versions not compatible"));
         return false;
     }
 
-    // Perform migration based on version differences
-    let migration_result = perform_access_data_migration(env, &from_version, &to_version);
+
+    let migration_result: bool = perform_access_data_migration(env, &from_version, &to_version);
 
     if migration_result {
         // Update version history with new version
         store_version_in_history(env, to_version.clone());
 
         // Set successful migration status
-        let status = String::from_str(env, "Migration completed successfully");
+        let status: String = String::from_str(env, "Migration completed successfully");
         set_migration_status(env, status);
 
         // Emit migration event

contracts/course/course_access/src/functions/grant_access.rs

@@ -54,7 +54,7 @@ pub fn course_access_grant_access(env: Env, course_id: String, user: Address) {
     }
 
     // Update CourseUsers
-    let course_users_key = DataKey::CourseUsers(course_id.clone());
+    let course_users_key: DataKey = DataKey::CourseUsers(course_id.clone());
     let mut course_users: CourseUsers = env
         .storage()
         .persistent()
@@ -70,4 +70,4 @@ pub fn course_access_grant_access(env: Env, course_id: String, user: Address) {
     }
     env.events()
         .publish((COURSE_ACCESS_EVENT, &user.clone()), (course_id, user, course_users.users.len(),));
-}
+}

contracts/course/course_access/src/functions/list_user_courses.rs

@@ -1,24 +1,11 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) 2025 SkillCert
+
 use soroban_sdk::{Address, Env, Vec};
+
 use crate::schema::{DataKey, UserCourses};
 
-/// List all courses that a specific user has access to.
-///
-/// This function retrieves all courses that the specified user is enrolled in
-/// or has been granted access to. If the user has no courses, it returns
-/// an empty UserCourses struct.
-///
-/// # Arguments
-///
-/// * `env` - The Soroban environment
-/// * `user` - The address of the user to query courses for
-///
-/// # Returns
-///
-/// Returns a `UserCourses` struct containing the user's address and a list
-/// of course IDs they have access to. If no courses are found, returns
-/// an empty list.
+
 pub fn list_user_courses(env: Env, user: Address) -> UserCourses {
     let key: DataKey = DataKey::UserCourses(user.clone());
     let res: UserCourses = env.storage().persistent().get(&key).unwrap_or(UserCourses {

contracts/course/course_access/src/functions/mod.rs

@@ -10,11 +10,3 @@ pub mod revoke_access;
 pub mod revoke_all_access;
 pub mod save_profile;
 pub mod transfer_course_access;
-
-pub use config::*;
-pub use grant_access::*;
-pub use list_course_access::*;
-pub use list_user_courses::*;
-pub use revoke_access::*;
-pub use revoke_all_access::*;
-pub use save_profile::*;

contracts/course/course_access/src/functions/revoke_all_access.rs

@@ -15,35 +15,7 @@ const COURSES_KEY: Symbol = symbol_short!("courses");
 /// Event symbol for revoke all access operations
 const REVOKE_ALL_EVENT: Symbol = symbol_short!("revokeAll");
 
-/// Revoke access for all users from a specific course.
-///
-/// This function removes access for all users from the specified course and
-/// updates all related storage structures. Only admin users or course creators
-/// are authorized to perform this operation.
-///
-/// # Arguments
-///
-/// * `env` - The Soroban environment
-/// * `caller` - The address of the user requesting the operation
-/// * `course_id` - The unique identifier of the course to revoke all access from
-///
-/// # Returns
-///
-/// Returns the number of users whose access was revoked.
-///
-/// # Authorization
-///
-/// The caller must be either:
-/// - An admin user (verified via user management contract)
-/// - The creator of the course (verified via course registry contract)
-///
-/// # Events
-///
-/// Emits a `revokeall` event with the course ID and number of affected users.
-///
-/// # Panics
-///
-/// Panics with `Error::Unauthorized` if the caller is not authorized to perform this operation.
+
 pub fn revoke_all_access(env: Env, caller: Address, course_id: String) -> u32 {
     caller.require_auth();