feat: Message Finalization Function

contracts/inheritance-contract/src/lib.rs

@@ -3477,6 +3477,5 @@ impl InheritanceContract {
     }
 }
 
-#[cfg(test)]
 mod message_test;
 mod test;

contracts/inheritance-contract/src/test.rs

@@ -4321,6 +4321,127 @@ fn test_finalized_version_is_immutable() {
     assert!(client.is_will_finalized(&plan_id, &version));
 }
 
+// --- Issue #360: Message Update Before Lock / Issue: Message Finalization ---
+
+fn create_message(
+    env: &Env,
+    client: &InheritanceContractClient<'_>,
+    owner: &Address,
+    vault_id: u64,
+) -> u64 {
+    client.create_legacy_message(
+        owner,
+        &CreateLegacyMessageParams {
+            vault_id,
+            message_hash: BytesN::from_array(env, &[1u8; 32]),
+            unlock_timestamp: env.ledger().timestamp() + 10_000,
+            key_reference: soroban_sdk::String::from_str(env, "ref_1"),
+        },
+    )
+}
+
+#[test]
+fn test_update_legacy_message_before_lock() {
+    let env = Env::default();
+    env.mock_all_auths();
+    let (client, token_id, _admin, owner) = setup_with_token_and_admin(&env);
+    let plan_id = create_plan_and_get_id(&env, &client, &token_id, &owner);
+    let message_id = create_message(&env, &client, &owner, plan_id);
+
+    let updated_hash = BytesN::from_array(&env, &[2u8; 32]);
+    let new_unlock_ts = env.ledger().timestamp() + 20_000;
+    client.update_legacy_message(
+        &owner,
+        &message_id,
+        &CreateLegacyMessageParams {
+            vault_id: plan_id,
+            message_hash: updated_hash.clone(),
+            unlock_timestamp: new_unlock_ts,
+            key_reference: soroban_sdk::String::from_str(&env, "ref_updated"),
+        },
+    );
+
+    let stored = client.get_legacy_message(&message_id).unwrap();
+    assert_eq!(stored.message_hash, updated_hash);
+    assert_eq!(stored.unlock_timestamp, new_unlock_ts);
+    assert!(!stored.is_finalized);
+}
+
+#[test]
+fn test_finalize_legacy_message_sets_flag_and_emits_event() {
+    let env = Env::default();
+    env.mock_all_auths();
+    let (client, token_id, _admin, owner) = setup_with_token_and_admin(&env);
+    let plan_id = create_plan_and_get_id(&env, &client, &token_id, &owner);
+    let message_id = create_message(&env, &client, &owner, plan_id);
+
+    client.finalize_legacy_message(&owner, &message_id);
+
+    let stored = client.get_legacy_message(&message_id).unwrap();
+    assert!(stored.is_finalized);
+
+    // Verify at least one event was emitted during finalization
+    assert!(!env.events().all().is_empty());
+}
+
+#[test]
+fn test_update_legacy_message_rejected_after_lock() {
+    let env = Env::default();
+    env.mock_all_auths();
+    let (client, token_id, _admin, owner) = setup_with_token_and_admin(&env);
+    let plan_id = create_plan_and_get_id(&env, &client, &token_id, &owner);
+    let message_id = create_message(&env, &client, &owner, plan_id);
+
+    client.finalize_legacy_message(&owner, &message_id);
+
+    let result = client.try_update_legacy_message(
+        &owner,
+        &message_id,
+        &CreateLegacyMessageParams {
+            vault_id: plan_id,
+            message_hash: BytesN::from_array(&env, &[3u8; 32]),
+            unlock_timestamp: env.ledger().timestamp() + 10_000,
+            key_reference: soroban_sdk::String::from_str(&env, "ref_new"),
+        },
+    );
+    assert_eq!(result, Err(Ok(InheritanceError::WillAlreadyFinalized)));
+}
+
+#[test]
+fn test_finalize_legacy_message_twice_fails() {
+    let env = Env::default();
+    env.mock_all_auths();
+    let (client, token_id, _admin, owner) = setup_with_token_and_admin(&env);
+    let plan_id = create_plan_and_get_id(&env, &client, &token_id, &owner);
+    let message_id = create_message(&env, &client, &owner, plan_id);
+
+    client.finalize_legacy_message(&owner, &message_id);
+    let result = client.try_finalize_legacy_message(&owner, &message_id);
+    assert_eq!(result, Err(Ok(InheritanceError::WillAlreadyFinalized)));
+}
+
+#[test]
+fn test_update_legacy_message_unauthorized() {
+    let env = Env::default();
+    env.mock_all_auths();
+    let (client, token_id, _admin, owner) = setup_with_token_and_admin(&env);
+    let plan_id = create_plan_and_get_id(&env, &client, &token_id, &owner);
+    let message_id = create_message(&env, &client, &owner, plan_id);
+
+    let stranger = Address::generate(&env);
+    let result = client.try_update_legacy_message(
+        &stranger,
+        &message_id,
+        &CreateLegacyMessageParams {
+            vault_id: plan_id,
+            message_hash: BytesN::from_array(&env, &[9u8; 32]),
+            unlock_timestamp: env.ledger().timestamp() + 10_000,
+            key_reference: soroban_sdk::String::from_str(&env, "ref_9"),
+        },
+    );
+    assert_eq!(result, Err(Ok(InheritanceError::Unauthorized)));
+}
+
 // --- Issue #71: KYC Verification for Plan Creation and Claiming ---
 
 #[test]

contracts/inheritance-contract/test_snapshots/message_test/test_message_accessed_event.1.json

@@ -1888,7 +1888,7 @@
             "data": {
               "vec": [
                 {
-                  "string": "caught panic 'called `Result::unwrap()` on an `Err` value: ConversionError' from contract function 'Symbol(obj#407)'"
+                  "string": "caught panic 'called `Result::unwrap()` on an `Err` value: ConversionError' from contract function 'Symbol(obj#417)'"
                 },
                 {
                   "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3IM"