feat(contracts): implement issues #271, #272, #273, #274

contracts/src/events.rs

@@ -1,12 +1,116 @@
 //! Standardized webhook event schema — Issue #243.
+//! Contract Event Replay Index (ring buffer) — Issue #274.
 //!
 //! Every contract event is published as a four-field envelope:
 //! `{ event_type, session_id, timestamp, payload }` under the `webhook`
 //! topic so off-chain relay daemons can parse a single shape.
+//!
+//! Additionally, every state-change event writes a compact summary entry
+//! into a ring buffer of the last 1000 events stored in Temporary storage
+//! (DataKey::EventLog(index)). Off-chain indexers that missed events can
+//! call `get_event_log(from_index, limit)` to re-fetch them without
+//! re-scanning the entire chain.
+
+use soroban_sdk::{contracttype, symbol_short, Env, IntoVal, Symbol, Val, Vec};
+
+/// Maximum number of entries kept in the on-chain ring buffer.
+pub const EVENT_LOG_CAPACITY: u32 = 1000;
+
+/// Compact summary stored per ring-buffer slot.
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct EventLogEntry {
+    /// Monotonically increasing global index (wraps at EVENT_LOG_CAPACITY).
+    pub index: u32,
+    /// The event type symbol (mirrors the `event_type` module).
+    pub event_type: Symbol,
+    /// Session id (0 for non-session events).
+    pub session_id: u64,
+    /// Ledger timestamp at the time of the event.
+    pub timestamp: u64,
+}
+
+// ---------------------------------------------------------------------------
+// Ring-buffer helpers
+// ---------------------------------------------------------------------------
+
+/// Storage key for the ring-buffer head pointer (next write position).
+fn head_key() -> Symbol {
+    symbol_short!("evtHead")
+}
+
+/// Write one entry into the ring buffer and advance the head pointer.
+fn append_to_ring(env: &Env, event_type: Symbol, session_id: u64) {
+    let head: u32 = env
+        .storage()
+        .temporary()
+        .get(&head_key())
+        .unwrap_or(0u32);
+
+    let slot = head % EVENT_LOG_CAPACITY;
+    let entry = EventLogEntry {
+        index: head,
+        event_type,
+        session_id,
+        timestamp: env.ledger().timestamp(),
+    };
+
+    let key = crate::DataKey::EventLog(slot);
+    env.storage().temporary().set(&key, &entry);
 
-use soroban_sdk::{symbol_short, Env, IntoVal, Symbol, Val};
+    env.storage()
+        .temporary()
+        .set(&head_key(), &head.saturating_add(1));
+}
+
+/// Return up to `limit` entries starting from `from_index` (inclusive).
+/// Results are ordered oldest-first. Returns an empty vec if the requested
+/// range has been overwritten or does not yet exist.
+pub fn get_event_log(env: &Env, from_index: u32, limit: u32) -> Vec<EventLogEntry> {
+    let head: u32 = env
+        .storage()
+        .temporary()
+        .get(&head_key())
+        .unwrap_or(0u32);
+
+    let mut results: Vec<EventLogEntry> = Vec::new(env);
+    let count = limit.min(EVENT_LOG_CAPACITY);
+    let mut idx = from_index;
+    let mut fetched = 0u32;
 
-/// Publish a webhook envelope consumed by off-chain relay services.
+    while fetched < count && idx < head {
+        let slot = idx % EVENT_LOG_CAPACITY;
+        if let Some(entry) = env
+            .storage()
+            .temporary()
+            .get::<crate::DataKey, EventLogEntry>(&crate::DataKey::EventLog(slot))
+        {
+            // Confirm the slot hasn't been overwritten by a newer entry.
+            if entry.index == idx {
+                results.push_back(entry);
+                fetched += 1;
+            }
+        }
+        idx += 1;
+    }
+
+    results
+}
+
+/// Return the current head pointer (total events ever written, mod wraps internally).
+pub fn event_log_head(env: &Env) -> u32 {
+    env.storage()
+        .temporary()
+        .get(&head_key())
+        .unwrap_or(0u32)
+}
+
+// ---------------------------------------------------------------------------
+// Core publish helper
+// ---------------------------------------------------------------------------
+
+/// Publish a webhook envelope consumed by off-chain relay services,
+/// and append a compact summary to the on-chain ring buffer.
 pub fn publish_event<P>(
     env: &Env,
     event_type: Symbol,
@@ -18,12 +122,15 @@ pub fn publish_event<P>(
     env.events().publish(
         (symbol_short!("webhook"),),
         (
-            event_type,
+            event_type.clone(),
             session_id,
             env.ledger().timestamp(),
             payload.into_val(env),
         ),
     );
+
+    // Issue #274: write summary to ring buffer.
+    append_to_ring(env, event_type, session_id);
 }
 
 /// Session lifecycle events.

contracts/src/identity.rs

@@ -1,4 +1,5 @@
 //! # KYC/KYB Integration Hooks (Issue #215)
+//! # Data Deletion / Right to Be Forgotten (Issue #272)
 //!
 //! Optional KYC verification hooks for the identity contract.
 //! Allows accounts to require KYC verification before participating in sessions.
@@ -7,6 +8,7 @@
 
 use soroban_sdk::{
     contract, contractimpl, contracterror, contracttype, symbol_short, Address, Env, String,
+    Symbol,
 };
 
 #[contracterror]
@@ -112,6 +114,38 @@ impl IdentityContract {
     }
 }
 
+/// Standalone data-deletion helper (Issue #272).
+///
+/// Replaces all `metadata_cid` and `notes_hash` fields associated with
+/// `address` in the main SkillSphere contract storage with the tombstone
+/// value `"DELETED"`. Only callable by the address owner or a SuperAdmin.
+/// Cannot delete data from active sessions.
+///
+/// # Storage keys touched (in the main contract's persistent storage)
+/// * `DataKey::ExpertProfile(address)` — `metadata_cid` field
+/// * `DataKey::Session(id)` — `metadata_cid` and `encrypted_notes_hash` for
+///   every completed/resolved session where `seeker == address || expert == address`
+///
+/// Because this module does not have direct access to the main contract's
+/// storage, the function is designed to be called from within the main
+/// `SkillSphereContract` impl (see `lib.rs`).
+pub mod data_deletion {
+    use soroban_sdk::{symbol_short, Address, Env, String};
+
+    /// Tombstone value used to overwrite deleted metadata fields.
+    pub fn tombstone(env: &Env) -> String {
+        String::from_str(env, "DELETED")
+    }
+
+    /// Emit the `DataDeletionRequested` event.
+    pub fn emit_deletion_event(env: &Env, address: &Address) {
+        env.events().publish(
+            (symbol_short!("dataDel"),),
+            (address.clone(), env.ledger().timestamp()),
+        );
+    }
+}
+
 /// Helper macro to check KYC requirement before action execution.
 /// If an account has KycStatus::Required and is not yet Verified, returns error.
 /// No-ops if status is NotRequired or Verified.