Merge pull request #191 from iotaledger/feat/correction-records

feat: setup correction records

Author: itsyaasir

audit-trail-move/Move.lock

@@ -42,6 +42,6 @@ dependencies = [
 ]
 
 [move.toolchain-version]
-compiler-version = "1.14.1-rc"
+compiler-version = "1.15.0"
 edition = "2024.beta"
 flavor = "iota"

audit-trail-move/sources/audit_trail.move

@@ -12,6 +12,7 @@ use audit_trail::{
     locking::{Self, LockingConfig, LockingWindow, set_delete_record_lock},
     permission::{Self, Permission},
     record::{Self, Record},
+    record_correction,
     role_map::{Self, RoleMap}
 };
 use iota::{clock::{Self, Clock}, event, linked_table::{Self, LinkedTable}};
@@ -155,6 +156,7 @@ public fun create<D: store + copy>(
             0,
             creator,
             timestamp,
+            record_correction::new(),
         );
 
         linked_table::push_back(&mut records, 0, record);
@@ -278,6 +280,7 @@ public fun add_record<D: store + copy>(
         seq,
         caller,
         timestamp,
+        record_correction::new(),
     );
 
     linked_table::push_back(&mut trail.records, seq, record);

audit-trail-move/sources/record.move

@@ -3,13 +3,14 @@
 
 /// Record module for audit trail entries
 ///
-/// A Record represents a single entry in an audit trail, stored in a LinkedTable
-/// and addressed by trail_id + sequence_number.
+/// A Record represents a single entry in an audit trail, stored in a
+/// LinkedTable and addressed by trail_id + sequence_number.
 module audit_trail::record;
 
+use audit_trail::record_correction::RecordCorrection;
 use std::string::String;
 
-/// A single record in the audit trail (stored in LinkedTable, no ObjectID)
+/// A single record in the audit trail
 public struct Record<D: store + copy> has store {
     /// Arbitrary data stored on-chain
     stored_data: D,
@@ -21,24 +22,28 @@ public struct Record<D: store + copy> has store {
     added_by: address,
     /// When this record was added (milliseconds)
     added_at: u64,
+    /// Correction tracker for this record
+    correction: RecordCorrection,
 }
 
 // ===== Constructors =====
 
-/// Create a new record (package-private, called by audit_trails module)
+/// Create a new record
 public(package) fun new<D: store + copy>(
     stored_data: D,
     record_metadata: Option<String>,
     sequence_number: u64,
     added_by: address,
     added_at: u64,
+    correction: RecordCorrection,
 ): Record<D> {
     Record {
         stored_data,
         record_metadata,
         sequence_number,
         added_by,
         added_at,
+        correction,
     }
 }
 
@@ -69,16 +74,19 @@ public fun added_at<D: store + copy>(record: &Record<D>): u64 {
     record.added_at
 }
 
-// ===== Destructors =====
+/// Get the correction tracker for this record
+public fun correction<D: store + copy>(record: &Record<D>): &RecordCorrection {
+    &record.correction
+}
 
-/// Destroy a record (package-private, called by audit_trail module when deleting)
-/// Note: D must have `drop` ability to allow deletion
+/// Destroy a record
 public(package) fun destroy<D: store + copy + drop>(record: Record<D>) {
     let Record {
         stored_data: _,
         record_metadata: _,
         sequence_number: _,
         added_by: _,
         added_at: _,
+        correction: _,
     } = record;
 }

audit-trail-move/sources/record_correction.move

@@ -0,0 +1,64 @@
+// Copyright (c) 2025 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+/// Module for tracking correction relationships for a record
+module audit_trail::record_correction;
+
+use iota::vec_set::{Self, VecSet};
+
+/// Bidirectional correction tracking for audit records
+public struct RecordCorrection has copy, drop, store {
+    replaces: VecSet<u64>,
+    is_replaced_by: Option<u64>,
+}
+
+/// Create a new correction tracker for a normal (non-correcting) record
+public fun new(): RecordCorrection {
+    RecordCorrection {
+        replaces: vec_set::empty(),
+        is_replaced_by: option::none(),
+    }
+}
+
+/// Create a correction tracker for a correcting record
+public fun with_replaces(replaced_seq_nums: VecSet<u64>): RecordCorrection {
+    RecordCorrection {
+        replaces: replaced_seq_nums,
+        is_replaced_by: option::none(),
+    }
+}
+
+/// Get the set of sequence numbers this record replaces
+public fun replaces(correction: &RecordCorrection): &VecSet<u64> {
+    &correction.replaces
+}
+
+/// Get the sequence number of the record that replaced this one
+public fun is_replaced_by(correction: &RecordCorrection): Option<u64> {
+    correction.is_replaced_by
+}
+
+/// Check if this record is a correction (replaces other records)
+public fun is_correction(correction: &RecordCorrection): bool {
+    !vec_set::is_empty(&correction.replaces)
+}
+
+/// Check if this record has been replaced by another record
+public fun is_replaced(correction: &RecordCorrection): bool {
+    correction.is_replaced_by.is_some()
+}
+
+/// Set the sequence number of the record that replaced this one
+public(package) fun set_replaced_by(correction: &mut RecordCorrection, replacement_seq: u64) {
+    correction.is_replaced_by = option::some(replacement_seq);
+}
+
+/// Add a sequence number to the set of records this record replaces
+public(package) fun add_replaces(correction: &mut RecordCorrection, seq_num: u64) {
+    correction.replaces.insert(seq_num);
+}
+
+/// Destroy a RecordCorrection
+public(package) fun destroy(correction: RecordCorrection) {
+    let RecordCorrection { replaces: _, is_replaced_by: _ } = correction;
+}