repair merged contract APIs and storage types

Author: Inkman007

contracts/ledgerlens-score/src/event_causality.rs

@@ -38,7 +38,10 @@
 /// - Logged in event data for recovery
 /// - Computed deterministically from stable inputs
 /// - Documented in event sequences for human auditors
-use soroban_sdk::{crypto::Hash, Address, Bytes, Env, Symbol};
+extern crate alloc;
+
+use alloc::{vec, vec::Vec};
+use soroban_sdk::{xdr::ToXdr, Address, Bytes, Env, Symbol};
 
 /// Correlation ID uniquely identifying a causal workflow
 /// This is a 32-byte hash computed from workflow parameters
@@ -60,12 +63,16 @@ impl EventCausality {
         asset_pair: &Symbol,
         timestamp: u64,
     ) -> CorrelationId {
-        Self::hash_bytes(&[
-            b"score_submit".as_slice(),
-            wallet.to_xdr(&Env::default()).to_bytes().as_slice(),
-            asset_pair.to_xdr(&Env::default()).to_bytes().as_slice(),
-            timestamp.to_le_bytes().as_slice(),
-        ])
+        let env = Env::default();
+        Self::hash_bytes(
+            &env,
+            &[
+                Bytes::from_slice(&env, b"score_submit"),
+                wallet.to_xdr(&env),
+                asset_pair.to_xdr(&env),
+                Bytes::from_array(&env, &timestamp.to_le_bytes()),
+            ],
+        )
     }
 
     /// Generate correlation ID for admin transfer workflow
@@ -80,12 +87,16 @@ impl EventCausality {
         to: &Address,
         timestamp: u64,
     ) -> CorrelationId {
-        Self::hash_bytes(&[
-            b"admin_xfer".as_slice(),
-            from.to_xdr(&Env::default()).to_bytes().as_slice(),
-            to.to_xdr(&Env::default()).to_bytes().as_slice(),
-            timestamp.to_le_bytes().as_slice(),
-        ])
+        let env = Env::default();
+        Self::hash_bytes(
+            &env,
+            &[
+                Bytes::from_slice(&env, b"admin_xfer"),
+                from.to_xdr(&env),
+                to.to_xdr(&env),
+                Bytes::from_array(&env, &timestamp.to_le_bytes()),
+            ],
+        )
     }
 
     /// Generate correlation ID for upgrade workflow
@@ -95,11 +106,15 @@ impl EventCausality {
     /// - `new_wasm_hash`: The new contract WASM hash being proposed
     /// - `timestamp`: The proposal timestamp
     pub fn upgrade_correlation_id(new_wasm_hash: &[u8; 32], timestamp: u64) -> CorrelationId {
-        Self::hash_bytes(&[
-            b"upgrade_prop".as_slice(),
-            new_wasm_hash.as_slice(),
-            timestamp.to_le_bytes().as_slice(),
-        ])
+        let env = Env::default();
+        Self::hash_bytes(
+            &env,
+            &[
+                Bytes::from_slice(&env, b"upgrade_prop"),
+                Bytes::from_array(&env, new_wasm_hash),
+                Bytes::from_array(&env, &timestamp.to_le_bytes()),
+            ],
+        )
     }
 
     /// Generate correlation ID for parameter change workflow
@@ -114,12 +129,16 @@ impl EventCausality {
         param_key: &Symbol,
         timestamp: u64,
     ) -> CorrelationId {
-        Self::hash_bytes(&[
-            b"param_change".as_slice(),
-            proposal_id.to_le_bytes().as_slice(),
-            param_key.to_xdr(&Env::default()).to_bytes().as_slice(),
-            timestamp.to_le_bytes().as_slice(),
-        ])
+        let env = Env::default();
+        Self::hash_bytes(
+            &env,
+            &[
+                Bytes::from_slice(&env, b"param_change"),
+                Bytes::from_array(&env, &proposal_id.to_le_bytes()),
+                param_key.to_xdr(&env),
+                Bytes::from_array(&env, &timestamp.to_le_bytes()),
+            ],
+        )
     }
 
     /// Generate correlation ID for dispute workflow
@@ -134,12 +153,16 @@ impl EventCausality {
         asset_pair: &Symbol,
         timestamp: u64,
     ) -> CorrelationId {
-        Self::hash_bytes(&[
-            b"dispute_open".as_slice(),
-            challenger.to_xdr(&Env::default()).to_bytes().as_slice(),
-            asset_pair.to_xdr(&Env::default()).to_bytes().as_slice(),
-            timestamp.to_le_bytes().as_slice(),
-        ])
+        let env = Env::default();
+        Self::hash_bytes(
+            &env,
+            &[
+                Bytes::from_slice(&env, b"dispute_open"),
+                challenger.to_xdr(&env),
+                asset_pair.to_xdr(&env),
+                Bytes::from_array(&env, &timestamp.to_le_bytes()),
+            ],
+        )
     }
 
     /// Generate correlation ID for governance action chain
@@ -149,11 +172,15 @@ impl EventCausality {
     /// - `action_index`: Sequential index of this action in the governance chain
     /// - `timestamp`: The action timestamp
     pub fn governance_chain_correlation_id(action_index: u64, timestamp: u64) -> CorrelationId {
-        Self::hash_bytes(&[
-            b"gov_chain".as_slice(),
-            action_index.to_le_bytes().as_slice(),
-            timestamp.to_le_bytes().as_slice(),
-        ])
+        let env = Env::default();
+        Self::hash_bytes(
+            &env,
+            &[
+                Bytes::from_slice(&env, b"gov_chain"),
+                Bytes::from_array(&env, &action_index.to_le_bytes()),
+                Bytes::from_array(&env, &timestamp.to_le_bytes()),
+            ],
+        )
     }
 
     /// Generate correlation ID for consensus score workflow
@@ -168,12 +195,16 @@ impl EventCausality {
         asset_pair: &Symbol,
         round_id: u64,
     ) -> CorrelationId {
-        Self::hash_bytes(&[
-            b"consensus_round".as_slice(),
-            wallet.to_xdr(&Env::default()).to_bytes().as_slice(),
-            asset_pair.to_xdr(&Env::default()).to_bytes().as_slice(),
-            round_id.to_le_bytes().as_slice(),
-        ])
+        let env = Env::default();
+        Self::hash_bytes(
+            &env,
+            &[
+                Bytes::from_slice(&env, b"consensus_round"),
+                wallet.to_xdr(&env),
+                asset_pair.to_xdr(&env),
+                Bytes::from_array(&env, &round_id.to_le_bytes()),
+            ],
+        )
     }
 
     /// Generate correlation ID for escalation workflow
@@ -188,25 +219,25 @@ impl EventCausality {
         asset_pair: &Symbol,
         timestamp: u64,
     ) -> CorrelationId {
-        Self::hash_bytes(&[
-            b"escalation".as_slice(),
-            wallet.to_xdr(&Env::default()).to_bytes().as_slice(),
-            asset_pair.to_xdr(&Env::default()).to_bytes().as_slice(),
-            timestamp.to_le_bytes().as_slice(),
-        ])
+        let env = Env::default();
+        Self::hash_bytes(
+            &env,
+            &[
+                Bytes::from_slice(&env, b"escalation"),
+                wallet.to_xdr(&env),
+                asset_pair.to_xdr(&env),
+                Bytes::from_array(&env, &timestamp.to_le_bytes()),
+            ],
+        )
     }
 
     /// Internal: Hash multiple byte sequences to produce a correlation ID
-    fn hash_bytes(parts: &[&[u8]]) -> CorrelationId {
-        let mut combined = Vec::new();
+    fn hash_bytes(env: &Env, parts: &[Bytes]) -> CorrelationId {
+        let mut combined = Bytes::new(env);
         for part in parts {
-            combined.extend_from_slice(part);
+            combined.append(part);
         }
-        // Use SHA-256 to produce a deterministic 32-byte ID
-        let hash_result = Hash::sha256(&Bytes::from_slice(&Env::default(), &combined));
-        let mut result = [0u8; 32];
-        result.copy_from_slice(hash_result.as_slice());
-        result
+        env.crypto().sha256(&combined).to_array()
     }
 }
 

contracts/ledgerlens-score/src/event_stability.rs

@@ -17,8 +17,6 @@
 /// 2. Document the breaking change in CHANGELOG.md
 /// 3. Add migration notes in the PR and event documentation
 /// 4. Update off-chain indexers to handle both versions during the transition window
-use soroban_sdk::Symbol;
-
 /// Stability level for event topics
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum EventStability {

contracts/ledgerlens-score/src/events.rs

@@ -2,6 +2,15 @@ use soroban_sdk::{contracttype, symbol_short, Address, Bytes, BytesN, Env, Symbo
 
 use crate::types::{AlertAckRecord, AlertType, Policy, RiskScore};
 
+pub fn alert_acknowledged(env: &Env, alert_type: &AlertType, record: &AlertAckRecord) {
+    env.events()
+        .publish((symbol_short!("alrt_ack"), EVENT_VERSION, alert_type.clone()), record.clone());
+}
+
+pub fn parameter_change_cleanup(env: &Env, count: u32, oldest_kept: u64) {
+    env.events().publish((symbol_short!("pc_clean"),), (count, oldest_kept));
+}
+
 /// Event Schema Versioning
 ///
 /// All events emitted by this contract carry an explicit schema version in their topic array.
@@ -313,39 +322,39 @@ pub enum BatchRejectionCategory {
 /// Emitted when a batch entry is rejected due to contract pause.
 /// Topics: ("bat_rej_pause",)  Data: (count)
 pub fn batch_rejected_contract_paused(env: &Env, count: u32) {
-    env.events().publish((symbol_short!("bat_rej_pa"),), count);
+    env.events().publish((Symbol::new(env, "bat_rej_pa"),), count);
 }
 
 /// Emitted when batch entries are rejected due to data quality issues.
 /// Topics: ("bat_rej_data",)  Data: (reason_code, count)
 /// reason_code: 1 = invalid_score, 2 = invalid_confidence, 3 = invalid_timestamp
 pub fn batch_rejected_data_quality(env: &Env, reason_code: u32, count: u32) {
-    env.events().publish((symbol_short!("bat_rej_dq"),), (reason_code, count));
+    env.events().publish((Symbol::new(env, "bat_rej_dq"),), (reason_code, count));
 }
 
 /// Emitted when batch entries are rejected due to model version issues.
 /// Topics: ("bat_rej_model",)  Data: (reason_code, count)
 /// reason_code: 1 = not_registered, 2 = deprecated
 pub fn batch_rejected_model_version(env: &Env, reason_code: u32, count: u32) {
-    env.events().publish((symbol_short!("bat_rej_mv"),), (reason_code, count));
+    env.events().publish((Symbol::new(env, "bat_rej_mv"),), (reason_code, count));
 }
 
 /// Emitted when batch entries exceed rate limits.
 /// Topics: ("bat_rej_ratelimit",)  Data: (count)
 pub fn batch_rejected_rate_limit(env: &Env, count: u32) {
-    env.events().publish((symbol_short!("bat_rej_rl"),), count);
+    env.events().publish((Symbol::new(env, "bat_rej_rl"),), count);
 }
 
 /// Emitted when batch entries fail attestation validation.
 /// Topics: ("bat_rej_attest",)  Data: (count)
 pub fn batch_rejected_attestation(env: &Env, count: u32) {
-    env.events().publish((symbol_short!("bat_rej_at"),), count);
+    env.events().publish((Symbol::new(env, "bat_rej_at"),), count);
 }
 
 /// Emitted when batch entries fail gate enforcement.
 /// Topics: ("bat_rej_gate",)  Data: (count)
 pub fn batch_rejected_gate_failure(env: &Env, count: u32) {
-    env.events().publish((symbol_short!("bat_rej_gt"),), count);
+    env.events().publish((Symbol::new(env, "bat_rej_gt"),), count);
 }
 
 /// Summary event emitted after batch processing completes.
@@ -745,7 +754,7 @@ pub fn governance_action_appended(env: &Env, new_head: &soroban_sdk::BytesN<32>)
 /// Data:  `(action_id: u32, action_name: Symbol, new_head: BytesN<32>)`
 pub fn gov_action(env: &Env, action_id: u8, action_name: &str, new_head: &soroban_sdk::BytesN<32>) {
     env.events().publish(
-        (symbol_short!("gov_action"), EVENT_VERSION),
+        (Symbol::new(env, "gov_action"), EVENT_VERSION),
         (action_id as u32, soroban_sdk::Symbol::new(env, action_name), new_head.clone()),
     );
 }
@@ -928,37 +937,6 @@ pub fn wallet_cluster_assigned(env: &Env, wallet: &Address, cluster: u32) {
     env.events().publish((symbol_short!("wc_asgn"), wallet.clone()), cluster);
 }
 
-pub fn escalation_triggered(
-    env: &Env,
-    wallet: &Address,
-    asset_pair: &Symbol,
-    breach_count: u32,
-    score: u32,
-    escalation_threshold: u32,
-) {
-    env.events().publish(
-        (symbol_short!("esc_trig"), wallet.clone(), asset_pair.clone()),
-        (breach_count, score, escalation_threshold),
-    );
-}
-
-pub fn escalation_resolved(
-    env: &Env,
-    wallet: &Address,
-    asset_pair: &Symbol,
-    breach_count: u32,
-    score: u32,
-) {
-    env.events().publish(
-        (symbol_short!("esc_res"), wallet.clone(), asset_pair.clone()),
-        (breach_count, score),
-    );
-}
-
-pub fn escalation_threshold_updated(env: &Env, old_threshold: u32, new_threshold: u32) {
-    env.events().publish((symbol_short!("esc_thr"),), (old_threshold, new_threshold));
-}
-
 // ── #631: Post-incident replay & reconciliation ──────────────────────────────
 
 /// Emitted when an admin takes a deterministic state snapshot via