Add global storage version for data migrations (#3469)

* feat(storage): add global storage versioning and helpers

Introduce a global storage version key to the database, enabling versioned
migrations for breaking changes in stored data structures. Add helper
functions to get and set the storage version, and provide unit tests to
verify versioning logic. This lays the groundwork for safe, enclave-only
data migrations by allowing detection and management of storage schema
versions.

* feat(storage): add storage versioning and migration test

Introduce global storage versioning to enable future database migrations.
Add an example migration in `init_storage` that checks and updates the
storage version. Implement a unit test demonstrating a struct migration
from version 0 to 1 using SCALE encoding, ensuring data compatibility
across schema changes.

* refactor(storage): restrict storage version API visibility

Change `get_storage_version` and `set_storage_version` functions from
public to private, as they are only used internally. Add a `dead_code`
allowance to `set_storage_version` for future migration use.

Author: silva-fj

tee-worker/omni-executor/executor-storage/src/lib.rs

@@ -27,6 +27,7 @@ pub use intent_id::IntentIdStorage;
 use tracing::error;
 
 const STORAGE_DB_PATH: &str = "storage_db";
+const STORAGE_VERSION_KEY: &[u8] = b"__storage_version__";
 
 pub type StorageDB = DB;
 
@@ -82,10 +83,38 @@ pub fn storage_key(storage_name: &str, key: &[u8]) -> Vec<u8> {
 		.collect()
 }
 
+fn get_storage_version(db: &StorageDB) -> u32 {
+	match db.get(STORAGE_VERSION_KEY) {
+		Ok(Some(v)) => u32::decode(&mut &v[..]).unwrap_or(0),
+		Ok(None) => 0,
+		Err(e) => {
+			error!("Error getting storage version: {:?}", e);
+			0
+		},
+	}
+}
+
+#[allow(dead_code)] // TODO: remove this when adding the first migration
+fn set_storage_version(db: &StorageDB, version: u32) -> Result<(), ()> {
+	let mut opts = WriteOptions::default();
+	opts.set_sync(true);
+	db.put_opt(STORAGE_VERSION_KEY, version.encode(), &opts).map_err(|e| {
+		error!("Error setting storage version: {:?}", e);
+	})
+}
+
 pub async fn init_storage(ws_rpc_endpoint: &str) -> Result<Arc<StorageDB>, ()> {
 	let db = Arc::new(StorageDB::open_default(STORAGE_DB_PATH).map_err(|e| {
 		error!("Could not open db: {:?}", e);
 	})?);
+
+	// Migration example: if version == 0, do migration, then set to 1
+	let current_version = get_storage_version(&db);
+	if current_version == 0 {
+		// ... perform migration logic here ...
+		// set_storage_version(&db, 1)?;
+	}
+
 	let client_factory: SubxtClientFactory<CustomConfig> = SubxtClientFactory::new(ws_rpc_endpoint);
 	let mut client = client_factory.new_client().await.map_err(|e| {
 		error!("Could not create client: {:?}", e);
@@ -207,3 +236,79 @@ fn extract_account_id_from_storage_key<K: Decode>(raw_storage_key: &[u8]) -> Res
 		error!("Error decoding account id: {:?}", e);
 	})
 }
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use std::fs;
+	use std::path::Path;
+
+	#[test]
+	fn test_storage_version_helpers() {
+		let db_path = "test_storage_db";
+		if Path::new(db_path).exists() {
+			fs::remove_dir_all(db_path).unwrap();
+		}
+		let db = StorageDB::open_default(db_path).unwrap();
+
+		// Initially, version should be 0
+		assert_eq!(get_storage_version(&db), 0);
+
+		// Set version to 1
+		set_storage_version(&db, 1).unwrap();
+		assert_eq!(get_storage_version(&db), 1);
+
+		// Set version to 42
+		set_storage_version(&db, 42).unwrap();
+		assert_eq!(get_storage_version(&db), 42);
+
+		fs::remove_dir_all(db_path).unwrap();
+	}
+
+	#[test]
+	fn test_struct_migration_v0_to_v1() {
+		use parity_scale_codec::{Decode, Encode};
+		use std::fs;
+		use std::path::Path;
+
+		#[derive(Debug, PartialEq, Encode, Decode)]
+		struct TestDataV0 {
+			a: u32,
+			b: String,
+		}
+
+		#[derive(Debug, PartialEq, Encode, Decode)]
+		struct TestDataV1 {
+			a: u32,
+			c: Option<u64>,
+		}
+
+		let db_path = "test_struct_migration_db_scale";
+		if Path::new(db_path).exists() {
+			fs::remove_dir_all(db_path).unwrap();
+		}
+		let db = StorageDB::open_default(db_path).unwrap();
+
+		// Simulate old data (version 0)
+		let old = TestDataV0 { a: 42, b: "hello".to_string() };
+		db.put(b"testkey", old.encode()).unwrap();
+		set_storage_version(&db, 0).unwrap();
+
+		// Migration: if version == 0, read old, convert, write new, set version = 1
+		if get_storage_version(&db) == 0 {
+			let bytes = db.get(b"testkey").unwrap().unwrap();
+			let old = TestDataV0::decode(&mut &bytes[..]).unwrap();
+			let new = TestDataV1 { a: old.a, c: None };
+			db.put(b"testkey", new.encode()).unwrap();
+			set_storage_version(&db, 1).unwrap();
+		}
+
+		// Check migrated data
+		let bytes = db.get(b"testkey").unwrap().unwrap();
+		let new = TestDataV1::decode(&mut &bytes[..]).unwrap();
+		assert_eq!(new, TestDataV1 { a: 42, c: None });
+		assert_eq!(get_storage_version(&db), 1);
+
+		fs::remove_dir_all(db_path).unwrap();
+	}
+}