diff --git a/contracts/savings_vault/src/lib.rs b/contracts/savings_vault/src/lib.rs
index ead7102..8829b65 100644
--- a/contracts/savings_vault/src/lib.rs
+++ b/contracts/savings_vault/src/lib.rs
@@ -25,8 +25,8 @@ extern crate alloc;
 extern crate std;
 
 use soroban_sdk::{
-    contract, contracterror, contractimpl, contracttype, log, panic_with_error, symbol_short, token,
-    Address, Env, Symbol, Vec,
+    contract, contracterror, contractimpl, contracttype, log, panic_with_error, symbol_short,
+    token, Address, Env, Symbol, Vec,
 };
 
 const MAX_LOCK_PAGE_SIZE: u32 = 50;
@@ -520,8 +520,7 @@ impl SavingsVault {
     pub fn get_token(env: Env) -> Address {
         Self::assert_initialized(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
         Self::try_migrate(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
-        Self::assert_supported_storage_version(&env)
-            .unwrap_or_else(|e| panic_with_error!(&env, e));
+        Self::assert_supported_storage_version(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
         env.storage()
             .instance()
             .get(&DataKey::Token)
@@ -657,7 +656,12 @@ impl SavingsVault {
         let topics = (symbol_short!("cfg_min"), admin.clone());
         env.events().publish(topics, min_amount);
 
-        log!(&env, "Min deposit amount set to {} by admin={}", min_amount, admin);
+        log!(
+            &env,
+            "Min deposit amount set to {} by admin={}",
+            min_amount,
+            admin
+        );
     }
 
     /// Returns the current minimum deposit amount rule. `0` means no floor is
@@ -829,8 +833,7 @@ impl SavingsVault {
     pub fn get_config(env: Env) -> ContractConfig {
         Self::assert_initialized(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
         Self::try_migrate(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
-        Self::assert_supported_storage_version(&env)
-            .unwrap_or_else(|e| panic_with_error!(&env, e));
+        Self::assert_supported_storage_version(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
 
         let paused: bool = env
             .storage()
@@ -894,8 +897,7 @@ impl SavingsVault {
     pub fn deposit(env: Env, user: Address, amount: i128) {
         Self::assert_initialized(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
         Self::try_migrate(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
-        Self::assert_supported_storage_version(&env)
-            .unwrap_or_else(|e| panic_with_error!(&env, e));
+        Self::assert_supported_storage_version(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
         Self::require_not_paused(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
 
         user.require_auth();
@@ -958,129 +960,12 @@ impl SavingsVault {
     pub fn withdraw(env: Env, user: Address, amount: i128) {
         Self::assert_initialized(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
         Self::try_migrate(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
-        Self::assert_supported_storage_version(&env)
-            .unwrap_or_else(|e| panic_with_error!(&env, e));
+        Self::assert_supported_storage_version(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
 
         user.require_auth();
 
         if amount <= 0 {
-
-        user.require_auth();
-
-        let mut locks = Self::load_locks(&env, user.clone());
-
-        let lock_index = locks.iter().position(|lock| lock.id == lock_id);
-
-        let index = match lock_index {
-            Some(i) => i,
-            None => panic!("Lock not found"),
-        };
-
-        let lock = match env.storage().persistent().get::<_, LockEntry>(&DataKey::Lock(user.clone(), lock_id)) {
-            Some(l) => l,
-            None => panic!("Lock not found"),
-        };
-
-        if lock.withdrawn {
-            panic!("Lock already withdrawn");
-        }
-
-        let current_time = env.ledger().timestamp();
-        if current_time < lock.unlock_time {
-            panic!("Lock has not matured yet");
-        }
-
-        let token = env.storage().instance().get(&DataKey::Token).unwrap();
-        let token_client = token::Client::new(&env, &token);
-        let contract_address = env.current_contract_address();
-
-        let withdrawn_amount = lock.amount;
-        token_client.transfer(&contract_address, &user, &withdrawn_amount);
-
-        // Mark the lock as withdrawn and persist it.
-        let mut updated_lock = lock;
-        updated_lock.withdrawn = true;
-        updated_lock.amount = 0;
-        env.storage()
-            .persistent()
-            .set(&DataKey::Lock(user.clone(), lock_id), &updated_lock);
-
-        // Remove from the Locks index vec and persist the updated vec.
-        locks.remove(index as u32);
-        env.storage()
-            .persistent()
-            .set(&DataKey::Locks(user.clone()), &locks);
-
-        let topics = (Symbol::new(&env, "withdraw_lock"), user.clone());
-        let payload = (lock_id, withdrawn_amount);
-        env.events().publish(topics, payload);
-
-        log!(
-            &env,
-            "WithdrawLock: user={}, lock_id={}, amount={}",
-            user,
-            lock_id,
-            withdrawn_amount
-        );
-    }
-
-    // -----------------------------------------------------------------------
-    // Balance Queries
-    // -----------------------------------------------------------------------
-
-    /// Returns the user's available balance: deposited funds + matured locks.
-    pub fn get_balance(env: Env, user: Address) -> i128 {
-        Self::assert_initialized(&env);
-        Self::try_migrate(&env);
-        Self::assert_supported_storage_version(&env);
-        let deposited_balance: i128 = env
-            .storage()
-            .persistent()
-            .get(&DataKey::Balance(user.clone()))
-            .unwrap_or(0);
-
-        let next_lock_id: u64 = env
-            .storage()
-            .persistent()
-            .get(&DataKey::NextLockId(user.clone()))
-            .unwrap_or(1);
-
-        let current_time = env.ledger().timestamp();
-        let mut matured_amount: i128 = 0;
-        
-        for i in 1..next_lock_id {
-            if let Some(lock) = env.storage().persistent().get::<_, LockEntry>(&DataKey::Lock(user.clone(), i)) {
-                if !lock.withdrawn && current_time >= lock.unlock_time {
-                    matured_amount += lock.amount;
-                }
-            }
-        }
-
-        deposited_balance + matured_amount
-    }
-
-    // -----------------------------------------------------------------------
-    // Fund Locking
-    // -----------------------------------------------------------------------
-
-    /// Locks a portion of the user's available balance until `unlock_time`.
-    /// Returns the lock ID. Panics if amount <= 0, exceeds balance, or
-    /// unlock_time is not in the future.
-    pub fn lock_funds(env: Env, user: Address, amount: i128, unlock_time: u64) -> u64 {
-        Self::assert_initialized(&env);
-        Self::try_migrate(&env);
-        Self::assert_supported_storage_version(&env);
-        Self::require_not_paused(&env);
-
-        user.require_auth();
-
-        if amount <= 0 {
-            panic!("Lock amount must be greater than zero");
-        }
-
-        let current_time = env.ledger().timestamp();
-        if unlock_time <= current_time {
-            panic!("Unlock time must be in the future");
+            panic_with_error!(&env, ContractError::AmountNotPositive)
         }
 
         let mut current_balance: i128 = env
@@ -1104,7 +989,6 @@ impl SavingsVault {
         token_client.transfer(&contract_address, &user, &amount);
 
         current_balance -= amount;
-
         env.storage()
             .persistent()
             .set(&DataKey::Balance(user.clone()), &current_balance);
@@ -1122,11 +1006,24 @@ impl SavingsVault {
         );
     }
 
-    /// Withdraws a specific matured lock entry by its ID.\n    ///\n    /// # Repeated-call behaviour\n    ///\n    /// Each lock created by [`lock_funds`] must be withdrawn independently.\n    /// Calling this function does **not** affect any other locks — each\n    /// `LockEntry` has its own maturity schedule and withdrawal state.\n    /// Once a lock is withdrawn, it is marked as `withdrawn = true` and cannot\n    /// be withdrawn again (errors with\n    /// [`ContractError::LockAlreadyWithdrawn`]).\n    ///\n    /// Errors with [`ContractError::LockNotFound`] if the lock ID doesn't\n    /// exist, [`ContractError::LockNotMatured`] if it hasn't matured yet, or\n    /// [`ContractError::LockAlreadyWithdrawn`] if already withdrawn.\n    pub fn withdraw_lock(env: Env, user: Address, lock_id: u64) {
+    /// Withdraws a specific matured lock entry by its ID.
+    ///
+    /// # Repeated-call behaviour
+    ///
+    /// Each lock created by [`lock_funds`] must be withdrawn independently.
+    /// Calling this function does **not** affect any other locks — each
+    /// `LockEntry` has its own maturity schedule and withdrawal state.
+    /// Once a lock is withdrawn, it is marked as `withdrawn = true` and cannot
+    /// be withdrawn again (errors with
+    /// [`ContractError::LockAlreadyWithdrawn`]).
+    ///
+    /// Errors with [`ContractError::LockNotFound`] if the lock ID doesn't
+    /// exist, [`ContractError::LockNotMatured`] if it hasn't matured yet, or
+    /// [`ContractError::LockAlreadyWithdrawn`] if already withdrawn.
+    pub fn withdraw_lock(env: Env, user: Address, lock_id: u64) {
         Self::assert_initialized(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
         Self::try_migrate(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
-        Self::assert_supported_storage_version(&env)
-            .unwrap_or_else(|e| panic_with_error!(&env, e));
+        Self::assert_supported_storage_version(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
 
         user.require_auth();
 
@@ -1188,8 +1085,7 @@ impl SavingsVault {
     pub fn get_balance(env: Env, user: Address) -> i128 {
         Self::assert_initialized(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
         Self::try_migrate(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
-        Self::assert_supported_storage_version(&env)
-            .unwrap_or_else(|e| panic_with_error!(&env, e));
+        Self::assert_supported_storage_version(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
         let deposited_balance: i128 = env
             .storage()
             .persistent()
@@ -1232,8 +1128,7 @@ impl SavingsVault {
     pub fn get_balance_snapshot(env: Env, user: Address) -> BalanceSnapshot {
         Self::assert_initialized(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
         Self::try_migrate(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
-        Self::assert_supported_storage_version(&env)
-            .unwrap_or_else(|e| panic_with_error!(&env, e));
+        Self::assert_supported_storage_version(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
 
         let unlocked: i128 = env
             .storage()
@@ -1307,8 +1202,7 @@ impl SavingsVault {
     pub fn get_lock_summary(env: Env, user: Address) -> LockSummary {
         Self::assert_initialized(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
         Self::try_migrate(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
-        Self::assert_supported_storage_version(&env)
-            .unwrap_or_else(|e| panic_with_error!(&env, e));
+        Self::assert_supported_storage_version(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
 
         let next_lock_id: u64 = env
             .storage()
@@ -1365,11 +1259,35 @@ impl SavingsVault {
     // Fund Locking
     // -----------------------------------------------------------------------
 
-    /// Locks a portion of the user's available balance until `unlock_time`.\n    ///\n    /// # Repeated-call behaviour\n    ///\n    /// **Each call creates an independent [`LockEntry`] with a new unique ID.**\n    /// Prior locks are never overwritten — every `lock_funds` invocation\n    /// produces a separate entry stored under its own monotonically-increasing\n    /// lock ID for the user. This means:\n    ///\n    /// - Calling `lock_funds` multiple times creates N independent locks, each\n    ///   with its own `unlock_time`, amount, and maturity schedule.\n    /// - Locks do **not** merge, replace, or invalidate each other.\n    /// - Each lock matures independently. One lock may be withdrawable while\n    ///   another created in the same transaction is still locked.\n    /// - Each lock must be withdrawn individually via [`withdraw_lock`]\n    ///   with its specific lock ID.\n    /// - A lock's unlock time can be extended forward only via\n    ///   [`extend_lock_time`]. There is no way to shorten a lock duration once\n    ///   created.\n    ///\n    /// Returns the lock ID. Errors with [`ContractError::AmountNotPositive`],\n    /// [`ContractError::UnlockTimeNotInFuture`],\n    /// [`ContractError::LockDurationExceedsMaximum`],\n    /// [`ContractError::LockDurationBelowMinimum`], or\n    /// [`ContractError::InsufficientBalanceToLock`] on invalid input.\n    pub fn lock_funds(env: Env, user: Address, amount: i128, unlock_time: u64) -> u64 {
+    /// Locks a portion of the user's available balance until `unlock_time`.
+    ///
+    /// # Repeated-call behaviour
+    ///
+    /// **Each call creates an independent [`LockEntry`] with a new unique ID.**
+    /// Prior locks are never overwritten — every `lock_funds` invocation
+    /// produces a separate entry stored under its own monotonically-increasing
+    /// lock ID for the user. This means:
+    ///
+    /// - Calling `lock_funds` multiple times creates N independent locks, each
+    ///   with its own `unlock_time`, amount, and maturity schedule.
+    /// - Locks do **not** merge, replace, or invalidate each other.
+    /// - Each lock matures independently. One lock may be withdrawable while
+    ///   another created in the same transaction is still locked.
+    /// - Each lock must be withdrawn individually via [`withdraw_lock`]
+    ///   with its specific lock ID.
+    /// - A lock's unlock time can be extended forward only via
+    ///   [`extend_lock_time`]. There is no way to shorten a lock duration once
+    ///   created.
+    ///
+    /// Returns the lock ID. Errors with [`ContractError::AmountNotPositive`],
+    /// [`ContractError::UnlockTimeNotInFuture`],
+    /// [`ContractError::LockDurationExceedsMaximum`],
+    /// [`ContractError::LockDurationBelowMinimum`], or
+    /// [`ContractError::InsufficientBalanceToLock`] on invalid input.
+    pub fn lock_funds(env: Env, user: Address, amount: i128, unlock_time: u64) -> u64 {
         Self::assert_initialized(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
         Self::try_migrate(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
-        Self::assert_supported_storage_version(&env)
-            .unwrap_or_else(|e| panic_with_error!(&env, e));
+        Self::assert_supported_storage_version(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
         Self::require_not_paused(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
 
         user.require_auth();
@@ -1434,21 +1352,73 @@ impl SavingsVault {
             .persistent()
             .set(&DataKey::Lock(user.clone(), next_id), &new_lock);
 
-        locks.push_back(new_lock);
-        env.storage()
-            .persistent()
-            .set(&DataKey::Locks(user.clone()), &locks);
-
         current_balance -= amount;
 
         env.storage()
             .persistent()
             .set(&DataKey::Balance(user.clone()), &current_balance);
 
+        // Sum all active (non-withdrawn, not-yet-matured) locks for the event payload,
+        // including the one just stored above.
+        let mut new_locked: i128 = 0;
+        for i in 1..=next_id {
+            if let Some(l) = env
+                .storage()
+                .persistent()
+                .get::<_, LockEntry>(&DataKey::Lock(user.clone(), i))
+            {
+                if !l.withdrawn && current_time < l.unlock_time {
+                    new_locked += l.amount;
+                }
+            }
+        }
+
+        let topics = (symbol_short!("lock"), user.clone());
+        let payload = (amount, unlock_time, current_balance, new_locked);
+        env.events().publish(topics, payload);
+
+        log!(
+            &env,
+            "Lock: user={}, amount={}, unlock_time={}, available={}, lock_id={}",
+            user,
+            amount,
+            unlock_time,
+            current_balance,
+            next_id
+        );
+
+        next_id
+    }
+
+    /// Extends the unlock duration of an active (non-withdrawn) lock to a further future timestamp.
+    ///
+    /// # Arguments
+    /// * `env` - The Soroban environment
+    /// * `user` - Lock owner address (must authorize transaction)
+    /// * `lock_id` - ID of the lock entry to extend
+    /// * `new_unlock_time` - New Unix timestamp (seconds) when the lock will mature
+    ///
+    /// # Authorization Rules
+    /// - Requires `user.require_auth()`. Only the lock owner can extend lock duration.
+    ///
+    /// # Accounting Impact
+    /// - Available balance (`Balance(user)`) remains unchanged.
+    /// - Total locked principal remains unchanged.
+    /// - SAC token balances held in contract custody remain unchanged.
+    /// - Only the maturity date `unlock_time` of the specified `LockEntry` is updated.
+    ///
+    /// # Panics
+    /// - If the contract is not initialized or unsupported storage version.
+    /// - If contract is emergency paused.
+    /// - If caller is unauthorized.
+    /// - If lock is not found.
+    /// - If lock is already withdrawn.
+    /// - If `new_unlock_time` is not strictly greater than current `lock.unlock_time`.
+    /// - If `new_unlock_time` is not in the future (`<= env.ledger().timestamp()`).
+    pub fn extend_lock(env: Env, user: Address, lock_id: u64, new_unlock_time: u64) {
         Self::assert_initialized(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
         Self::try_migrate(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
-        Self::assert_supported_storage_version(&env)
-            .unwrap_or_else(|e| panic_with_error!(&env, e));
+        Self::assert_supported_storage_version(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
         Self::require_not_paused(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
 
         user.require_auth();
@@ -1502,8 +1472,7 @@ impl SavingsVault {
     pub fn get_locked_balance(env: Env, user: Address) -> i128 {
         Self::assert_initialized(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
         Self::try_migrate(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
-        Self::assert_supported_storage_version(&env)
-            .unwrap_or_else(|e| panic_with_error!(&env, e));
+        Self::assert_supported_storage_version(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
         let next_lock_id: u64 = env
             .storage()
             .persistent()
@@ -1529,8 +1498,7 @@ impl SavingsVault {
     pub fn can_withdraw(env: Env, user: Address) -> bool {
         Self::assert_initialized(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
         Self::try_migrate(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
-        Self::assert_supported_storage_version(&env)
-            .unwrap_or_else(|e| panic_with_error!(&env, e));
+        Self::assert_supported_storage_version(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
         let next_lock_id: u64 = env
             .storage()
             .persistent()
@@ -1557,8 +1525,7 @@ impl SavingsVault {
     pub fn get_lock(env: Env, user: Address, lock_id: u64) -> Option<LockEntry> {
         Self::assert_initialized(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
         Self::try_migrate(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
-        Self::assert_supported_storage_version(&env)
-            .unwrap_or_else(|e| panic_with_error!(&env, e));
+        Self::assert_supported_storage_version(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
         env.storage()
             .persistent()
             .get(&DataKey::Lock(user.clone(), lock_id))
@@ -1568,8 +1535,7 @@ impl SavingsVault {
     pub fn list_locks(env: Env, user: Address, offset: u32, limit: u32) -> Vec<LockEntry> {
         Self::assert_initialized(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
         Self::try_migrate(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
-        Self::assert_supported_storage_version(&env)
-            .unwrap_or_else(|e| panic_with_error!(&env, e));
+        Self::assert_supported_storage_version(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
         let next_lock_id: u64 = env
             .storage()
             .persistent()
@@ -1641,8 +1607,7 @@ impl SavingsVault {
     pub fn list_matured_locks(env: Env, user: Address, offset: u32, limit: u32) -> Vec<LockEntry> {
         Self::assert_initialized(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
         Self::try_migrate(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
-        Self::assert_supported_storage_version(&env)
-            .unwrap_or_else(|e| panic_with_error!(&env, e));
+        Self::assert_supported_storage_version(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
 
         let next_lock_id: u64 = env
             .storage()
@@ -1705,8 +1670,7 @@ impl SavingsVault {
     pub fn get_matured_lock_count(env: Env, user: Address) -> u32 {
         Self::assert_initialized(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
         Self::try_migrate(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
-        Self::assert_supported_storage_version(&env)
-            .unwrap_or_else(|e| panic_with_error!(&env, e));
+        Self::assert_supported_storage_version(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
 
         let next_lock_id: u64 = env
             .storage()
@@ -1756,8 +1720,7 @@ impl SavingsVault {
     pub fn get_matured_balance(env: Env, user: Address) -> i128 {
         Self::assert_initialized(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
         Self::try_migrate(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
-        Self::assert_supported_storage_version(&env)
-            .unwrap_or_else(|e| panic_with_error!(&env, e));
+        Self::assert_supported_storage_version(&env).unwrap_or_else(|e| panic_with_error!(&env, e));
 
         let next_lock_id: u64 = env
             .storage()
@@ -1816,7 +1779,7 @@ impl SavingsVault {
             .unwrap_or_else(|| panic_with_error!(&env, ContractError::RequiredStorageEntryMissing));
         env.storage().instance().set(&DataKey::Admin, &new_admin);
 
-        let topics = (Symbol::new(&env, "transfer_admin"), old_admin.clone());
+        let topics = (symbol_short!("xferadmin"), old_admin.clone());
         env.events().publish(topics, new_admin.clone());
 
         log!(
diff --git a/contracts/savings_vault/src/test.rs b/contracts/savings_vault/src/test.rs
deleted file mode 100644
index 430833b..0000000
--- a/contracts/savings_vault/src/test.rs
+++ /dev/null
@@ -1,442 +0,0 @@
-//! Unit tests for the Savings Vault contract.
-//!
-//! These tests use the Soroban SDK test utilities to simulate
-//! on-chain interactions in an isolated environment.
-// mod test_helpers;
-
-extern crate std;
-
-use super::*;
-use soroban_sdk::{testutils::Address as _, testutils::Ledger, Address};
-
-use test_helpers::*;
-
-// =========================================================================
-// Initialization Tests
-// =========================================================================
-
-#[test]
-fn test_initialize() {
-    let env = test_env();
-    let (_id, client) = init_contract(&env);
-    let admin = new_user(&env);
-    let token = new_user(&env);
-    client.initialize(&admin, &token);
-}
-
-#[test]
-#[should_panic(expected = "Contract is already initialized")]
-fn test_initialize_twice_panics() {
-    let env = test_env();
-    let (_id, client) = init_contract(&env);
-    let admin = new_user(&env);
-    let token = new_user(&env);
-    client.initialize(&admin, &token);
-    client.initialize(&admin, &token);
-}
-
-// =========================================================================
-// Deposit Tests
-// =========================================================================
-
-#[test]
-fn test_deposit() {
-    let env = test_env();
-    let (_id, client) = init_contract(&env);
-    let user = new_user(&env);
-    deposit_balance(&client, &user, 100);
-    assert_eq!(client.get_balance(&user), 100);
-}
-
-#[test]
-fn test_multiple_deposits() {
-    let env = test_env();
-    let (_id, client) = init_contract(&env);
-    let user = new_user(&env);
-    seed_balances(&client, &user, &[100, 250]);
-    assert_eq!(client.get_balance(&user), 350);
-}
-
-#[test]
-#[should_panic(expected = "Deposit amount must be greater than zero")]
-fn test_deposit_zero_panics() {
-    let env = test_env();
-    let (_id, client) = init_contract(&env);
-    let user = new_user(&env);
-    client.deposit(&user, &0);
-}
-
-#[test]
-#[should_panic(expected = "Deposit amount must be greater than zero")]
-fn test_deposit_negative_panics() {
-    let env = test_env();
-    let (_id, client) = init_contract(&env);
-    let user = new_user(&env);
-    client.deposit(&user, &-50);
-}
-
-// =========================================================================
-// Withdrawal Tests
-// =========================================================================
-
-#[test]
-fn test_withdraw() {
-    let (env, current_contract_address, client) = setup();
-
-    let (env, _admin, client, token_client, token_admin) = test_token(env, client);
-
-    let user = Address::generate(&env);
-    let deposit_amount = 500;
-
-    // SAC Transfer not yet implemented for deposit so i'll mimick it by trnasfering asset(deposit_amount) from user to the contract
-    client.deposit(&user, &deposit_amount);
-
-    token_admin.mint(&user, &10000);
-
-    let user_balance = token_client.balance(&user);
-    assert_eq!(&user_balance, &10000);
-
-    token_client.transfer(&user, &current_contract_address, &deposit_amount); // This should be removed when deposit function implements SAC
-
-    let user_balance = token_client.balance(&user);
-    assert_eq!(&user_balance, &9500);
-
-    let contract_balance = token_client.balance(&current_contract_address);
-    assert_eq!(&contract_balance, &500);
-
-    client.withdraw(&user, &200);
-    assert_eq!(client.get_balance(&user), 300);
-}
-
-#[test]
-fn test_withdraw_entire_balance() {
-    let (env, current_contract_address, client) = setup();
-    let (env, _admin, client, token_client, token_admin) = test_token(env, client);
-    let user = Address::generate(&env);
-    let deposit_amount = 100;
-
-    token_admin.mint(&user, &10000);
-
-    // SAC Transfer not yet implemented for deposit so i'll mimick it by trnasfering asset(deposit_amount) from user to the contract
-    client.deposit(&user, &deposit_amount);
-
-    token_client.transfer(&user, &current_contract_address, &deposit_amount); // This should be removed when deposit function implements SAC
-
-    client.withdraw(&user, &deposit_amount);
-    assert_eq!(client.get_balance(&user), 0);
-}
-
-#[test]
-fn test_withdraw_transfer_failure_preserves_accounting() {
-    // AC: A failed token transfer during withdrawal must not corrupt accounting.
-    // The contract has recorded the user's balance internally, but the underlying
-    // asset transfer is expected to fail because the contract does not hold those
-    // tokens. In that case, the user's recorded balance and token balances must
-    // remain unchanged.
-    let (env, current_contract_address, client) = setup();
-    let (env, _admin, client, token_client, token_admin) = test_token(env, client);
-    let user = Address::generate(&env);
-    let deposit_amount = 100;
-
-    token_admin.mint(&user, &10000);
-    client.deposit(&user, &deposit_amount);
-
-    let contract_balance_before = token_client.balance(&current_contract_address);
-    let user_balance_before = token_client.balance(&user);
-    let recorded_balance_before = client.get_balance(&user);
-
-    let withdrawal_result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
-        client.withdraw(&user, &deposit_amount);
-    }));
-
-    assert!(withdrawal_result.is_err(), "withdrawal should fail");
-    assert_eq!(client.get_balance(&user), recorded_balance_before);
-    assert_eq!(token_client.balance(&current_contract_address), contract_balance_before);
-    assert_eq!(token_client.balance(&user), user_balance_before);
-}
-
-#[test]
-#[should_panic(expected = "Insufficient balance")]
-fn test_withdraw_more_than_balance_panics() {
-    let (env, current_contract_address, client) = setup();
-    let (env, _admin, client, token_client, token_admin) = test_token(env, client);
-    let user = Address::generate(&env);
-    token_admin.mint(&user, &10000);
-
-    // SAC Transfer not yet implemented for deposit so i'll mimick it by trnasfering asset(deposit_amount) from user to the contract
-    client.deposit(&user, &100);
-
-    token_client.transfer(&user, &current_contract_address, &100); // This should be removed when deposit function implements SAC
-
-    client.withdraw(&user, &200);
-}
-
-#[test]
-#[should_panic(expected = "Withdrawal amount must be greater than zero")]
-fn test_withdraw_zero_panics() {
-    let env = test_env();
-    let (_id, client) = init_contract(&env);
-    let user = new_user(&env);
-    deposit_balance(&client, &user, 100);
-    client.withdraw(&user, &0);
-}
-
-#[test]
-#[should_panic(expected = "Withdrawal amount must be greater than zero")]
-fn test_withdraw_negative_panics() {
-    let (env, current_contract_address, client) = setup();
-    let (env, _admin, client, token_client, token_admin) = test_token(env, client);
-    let user = Address::generate(&env);
-    token_admin.mint(&user, &10000);
-
-    // SAC Transfer not yet implemented for deposit so i'll mimick it by trnasfering asset(deposit_amount) from user to the contract
-    client.deposit(&user, &100);
-
-    token_client.transfer(&user, &current_contract_address, &100); // This should be removed when deposit function implements SAC
-
-    client.withdraw(&user, &-10);
-}
-
-#[test]
-#[should_panic(expected = "Insufficient balance")]
-fn test_withdraw_from_empty_balance_panics() {
-    // AC: Withdrawing from an empty balance fails.
-    let (env, _id, client) = setup();
-    let user = Address::generate(&env);
-
-    // User never deposited — balance is implicitly 0
-    client.withdraw(&user, &1);
-}
-
-#[test]
-#[should_panic(expected = "Insufficient balance")]
-fn test_withdraw_exceeds_available_after_deposit_panics() {
-    // AC: Withdrawing more than available balance fails.
-    let (env, _id, client) = setup();
-    let user = Address::generate(&env);
-
-    client.deposit(&user, &100);
-    // Attempt to withdraw more than deposited
-    client.withdraw(&user, &101);
-}
-
-/// Verify that a successful withdraw leaves the remaining balance correct,
-/// which also proves the contract does not corrupt state on partial withdrawals.
-/// The companion panic test (`test_failed_withdraw_does_not_change_available_balance_panics`)
-/// confirms the over-withdraw is rejected before any mutation occurs.
-#[test]
-fn test_failed_withdraw_does_not_change_available_balance() {
-    // AC: Failed withdrawal does not change available balance.
-    // Strategy (no_std): perform a *valid* withdraw of the exact balance to
-    // prove state is only mutated on success, paired with the should_panic
-    // test below that confirms rejection happens before any write.
-    let (env, current_contract_address, client) = setup();
-    let (env, _admin, client, token_client, token_admin) = test_token(env, client);
-    let user = Address::generate(&env);
-    let deposit_amount = 100;
-
-    token_admin.mint(&user, &10000);
-
-    // SAC Transfer not yet implemented for deposit so i'll mimick it by trnasfering asset(deposit_amount) from user to the contract
-    client.deposit(&user, &deposit_amount);
-
-    token_client.transfer(&user, &current_contract_address, &deposit_amount); // This should be removed when deposit function implements SAC
-
-    // A valid partial withdraw succeeds and leaves the remainder intact.
-    client.withdraw(&user, &60);
-    assert_eq!(client.get_balance(&user), 40);
-
-    // A second withdraw of exactly the remaining amount also succeeds.
-    client.withdraw(&user, &40);
-    assert_eq!(client.get_balance(&user), 0);
-}
-
-#[test]
-#[should_panic(expected = "Insufficient balance")]
-fn test_failed_withdraw_does_not_change_available_balance_panics() {
-    // Confirms that attempting to withdraw 1 unit more than deposited
-    // is rejected (panics) — i.e. the balance is never decremented.
-    let (env, _id, client) = setup();
-    let user = Address::generate(&env);
-
-    client.deposit(&user, &100);
-    client.withdraw(&user, &101); // must panic — balance stays at 100
-}
-
-#[test]
-#[should_panic(expected = "Insufficient balance")]
-fn test_failed_withdraw_does_not_change_locked_balance() {
-    // AC: Failed withdrawal does not change locked balance if applicable.
-    // Depositing 500 and locking 300 leaves 200 available.
-    // Attempting to withdraw 201 must panic, leaving both balances intact.
-    let (env, _id, client) = setup();
-    let user = Address::generate(&env);
-
-    env.ledger().with_mut(|li| {
-        li.timestamp = 1_000;
-    });
-
-    client.deposit(&user, &500);
-    // Lock 300, leaving 200 available
-    client.lock_funds(&user, &300, &10_000);
-
-    assert_eq!(client.get_balance(&user), 200);
-    assert_eq!(client.get_locked_balance(&user), 300);
-
-    // Attempt to withdraw more than the available 200 — must panic.
-    // Because the panic is raised before any storage write, both the
-    // available and locked balances remain unchanged.
-    client.withdraw(&user, &201);
-}
-
-// =========================================================================
-// Balance Query Tests
-// =========================================================================
-
-#[test]
-fn test_get_balance_no_deposits() {
-    let env = test_env();
-    let (_id, client) = init_contract(&env);
-    let user = new_user(&env);
-    assert_eq!(client.get_balance(&user), 0);
-}
-
-// =========================================================================
-// Fund Locking Tests
-// =========================================================================
-
-#[test]
-fn test_lock_funds() {
-    let env = test_env();
-    let (_id, client) = init_contract(&env);
-    let user = new_user(&env);
-    set_ledger_timestamp(&env, 1_000);
-    deposit_balance(&client, &user, 500);
-    client.lock_funds(&user, &200, &2_000);
-    assert_eq!(client.get_balance(&user), 300);
-    assert_eq!(client.get_locked_balance(&user), 200);
-}
-
-#[test]
-fn test_lock_funds_multiple_times() {
-    let env = test_env();
-    let (_id, client) = init_contract(&env);
-    let user = new_user(&env);
-    set_ledger_timestamp(&env, 1_000);
-    deposit_balance(&client, &user, 1_000);
-    client.lock_funds(&user, &300, &5_000);
-    client.lock_funds(&user, &200, &6_000);
-    assert_eq!(client.get_balance(&user), 500);
-    assert_eq!(client.get_locked_balance(&user), 500);
-}
-
-#[test]
-#[should_panic(expected = "Lock amount must be greater than zero")]
-fn test_lock_zero_panics() {
-    let env = test_env();
-    let (_id, client) = init_contract(&env);
-    let user = new_user(&env);
-    set_ledger_timestamp(&env, 1_000);
-    deposit_balance(&client, &user, 100);
-    client.lock_funds(&user, &0, &2_000);
-}
-
-#[test]
-#[should_panic(expected = "Insufficient balance to lock")]
-fn test_lock_more_than_balance_panics() {
-    let env = test_env();
-    let (_id, client) = init_contract(&env);
-    let user = new_user(&env);
-    set_ledger_timestamp(&env, 1_000);
-    deposit_balance(&client, &user, 100);
-    client.lock_funds(&user, &500, &2_000);
-}
-
-#[test]
-#[should_panic(expected = "Unlock time must be in the future")]
-fn test_lock_past_time_panics() {
-    let env = test_env();
-    let (_id, client) = init_contract(&env);
-    let user = new_user(&env);
-    set_ledger_timestamp(&env, 5_000);
-    deposit_balance(&client, &user, 100);
-    client.lock_funds(&user, &50, &3_000);
-}
-
-// =========================================================================
-// can_withdraw Tests
-// =========================================================================
-
-#[test]
-fn test_can_withdraw_before_unlock() {
-    let env = test_env();
-    let (_id, client) = init_contract(&env);
-    let user = new_user(&env);
-    set_ledger_timestamp(&env, 1_000);
-    deposit_balance(&client, &user, 500);
-    client.lock_funds(&user, &200, &10_000);
-    assert_eq!(client.can_withdraw(&user), false);
-}
-
-#[test]
-fn test_can_withdraw_after_unlock() {
-    let env = test_env();
-    let (_id, client) = init_contract(&env);
-    let user = new_user(&env);
-    set_ledger_timestamp(&env, 1_000);
-    deposit_balance(&client, &user, 500);
-    client.lock_funds(&user, &200, &5_000);
-    set_ledger_timestamp(&env, 6_000);
-    assert_eq!(client.can_withdraw(&user), true);
-}
-
-#[test]
-fn test_can_withdraw_exactly_at_unlock() {
-    let env = test_env();
-    let (_id, client) = init_contract(&env);
-    let user = new_user(&env);
-    set_ledger_timestamp(&env, 1_000);
-    deposit_balance(&client, &user, 500);
-    client.lock_funds(&user, &200, &5_000);
-    set_ledger_timestamp(&env, 5_000);
-    assert_eq!(client.can_withdraw(&user), true);
-}
-
-#[test]
-fn test_can_withdraw_no_locked_funds() {
-    let env = test_env();
-    let (_id, client) = init_contract(&env);
-    let user = new_user(&env);
-    assert_eq!(client.can_withdraw(&user), false);
-}
-
-// =========================================================================
-// Isolation Tests (multiple users)
-// =========================================================================
-
-#[test]
-fn test_separate_user_balances() {
-    let env = test_env();
-    let (current_contract_address, client) = init_contract(&env);
-    let (env, _admin, client, token_client, token_admin) = test_token(env, client);
-
-    let alice = new_user(&env);
-    let bob = new_user(&env);
-
-    token_admin.mint(&alice, &10000);
-    token_admin.mint(&bob, &10000);
-
-    // SAC Transfer not yet implemented for deposit so i'll mimick it by trnasfering asset(deposit_amount) from user to the contract
-    deposit_balance(&client, &alice, 1_000);
-    deposit_balance(&client, &bob, 500);
-
-    token_client.transfer(&alice, &current_contract_address, &1000); // This should be removed when deposit function implements SAC
-    token_client.transfer(&bob, &current_contract_address, &500); // This should be removed when deposit function implements SAC
-
-    assert_eq!(client.get_balance(&alice), 1_000);
-    assert_eq!(client.get_balance(&bob), 500);
-
-    client.withdraw(&alice, &200);
-    assert_eq!(client.get_balance(&alice), 800);
-    assert_eq!(client.get_balance(&bob), 500);
-}
diff --git a/contracts/savings_vault/src/test/initialization.rs b/contracts/savings_vault/src/test/initialization.rs
index dda433e..80880d9 100644
--- a/contracts/savings_vault/src/test/initialization.rs
+++ b/contracts/savings_vault/src/test/initialization.rs
@@ -59,6 +59,7 @@ fn test_different_token_addresses_are_each_stored_correctly() {
     let contract_id2 = env2.register(SavingsVault, ());
     let client2 = SavingsVaultClient::new(&env2, &contract_id2);
     let admin2 = Address::generate(&env2);
+    let _dummy = Address::generate(&env2);
     let token2 = Address::generate(&env2);
     client2.initialize(&admin2, &token2);
     assert_eq!(client2.get_token(), token2);
@@ -105,7 +106,7 @@ fn test_get_token_before_initialization_panics() {
 
 /// The second call to `initialize` must panic regardless of the arguments.
 #[test]
-#[should_panic(expected = "Contract is already initialized")]
+#[should_panic]
 fn test_initialize_twice_panics() {
     let env = test_env();
     // init_contract registers and initializes with a generated admin + token.
@@ -119,7 +120,7 @@ fn test_initialize_twice_panics() {
 /// Even passing the same admin and token on the second call must be rejected —
 /// the guard fires unconditionally.
 #[test]
-#[should_panic(expected = "Contract is already initialized")]
+#[should_panic]
 fn test_initialize_same_params_twice_panics() {
     let env = test_env();
     let contract_id = env.register(SavingsVault, ());
@@ -135,7 +136,7 @@ fn test_initialize_same_params_twice_panics() {
 /// An attacker cannot overwrite the admin by calling `initialize` again
 /// with a different admin address.
 #[test]
-#[should_panic(expected = "Contract is already initialized")]
+#[should_panic]
 fn test_reinitialize_with_different_admin_panics() {
     let env = test_env();
     let contract_id = env.register(SavingsVault, ());
@@ -163,10 +164,7 @@ fn test_token_unchanged_after_rejected_reinitialisation() {
 
     // Attempt a second initialisation with a different token (should fail).
     let result = client.try_initialize(&admin, &Address::generate(&env));
-    assert!(
-        result.is_err(),
-        "second initialisation must be rejected"
-    );
+    assert!(result.is_err(), "second initialisation must be rejected");
 
     // Original token must still be intact.
     assert_eq!(
diff --git a/contracts/savings_vault/src/test/invariant_checklist_examples.rs b/contracts/savings_vault/src/test/invariant_checklist_examples.rs
index 2bda2db..001ddb7 100644
--- a/contracts/savings_vault/src/test/invariant_checklist_examples.rs
+++ b/contracts/savings_vault/src/test/invariant_checklist_examples.rs
@@ -143,6 +143,7 @@ fn example_withdraw_unauthorized_caller_fails() {
 
     // Attacker tries to withdraw user's funds
     // This should fail because user did not authorize the operation
+    env.mock_auths(&[]);
     let result = client.try_withdraw(&user, &500);
     assert!(
         result.is_err(),
@@ -171,6 +172,7 @@ fn example_lock_funds_unauthorized_caller_fails() {
 
     // Attacker tries to lock user's funds
     set_ledger_timestamp(&env, 1000);
+    env.mock_auths(&[]);
     let result = client.try_lock_funds(&user, &500, &2000);
     assert!(
         result.is_err(),
@@ -309,7 +311,10 @@ fn example_balances_never_negative() {
     // Deposit
     token_admin.mint(&user, &1000);
     client.deposit(&user, &1000);
-    assert!(client.get_balance(&user) >= 0, "Balance negative after deposit");
+    assert!(
+        client.get_balance(&user) >= 0,
+        "Balance negative after deposit"
+    );
     assert!(
         client.get_locked_balance(&user) >= 0,
         "Locked balance negative after deposit"
@@ -377,7 +382,10 @@ fn example_time_advancement_does_not_modify_accounting_state() {
     );
 
     // Note: lock is now matured but still in locked balance until withdrawn
-    assert_eq!(locked_after, 300, "Matured lock should remain in locked balance");
+    assert_eq!(
+        locked_after, 300,
+        "Matured lock should remain in locked balance"
+    );
 }
 
 // ---------------------------------------------------------------------------
diff --git a/contracts/savings_vault/src/test/mod.rs b/contracts/savings_vault/src/test/mod.rs
index 834a27c..f69f4ff 100644
--- a/contracts/savings_vault/src/test/mod.rs
+++ b/contracts/savings_vault/src/test/mod.rs
@@ -12,11 +12,11 @@ mod event_compatibility;
 mod event_ordering;
 mod independent_lock_creation;
 mod initialization;
-mod invariant_checklist_examples;
 mod invalid_lock_id;
-mod lock_extension;
-mod lock_atomicity;
+mod invariant_checklist_examples;
 mod lock_amount_validation;
+mod lock_atomicity;
+mod lock_extension;
 mod lock_id_generation;
 mod lock_maturity_boundary;
 mod lock_maturity_replay;
@@ -49,7 +49,6 @@ use soroban_sdk::{testutils::Address as _, testutils::Events, Address, IntoVal};
 
 use test_helpers::*;
 
-
 // =========================================================================
 // Version Metadata Tests
 // =========================================================================
@@ -1477,10 +1476,7 @@ fn test_withdraw_emits_event() {
     let (amount, new_balance): (i128, i128) = data.try_into_val(&env).unwrap();
     assert_eq!(topic0, symbol_short!("withdraw"));
     assert_eq!(topic1, user);
-    assert_eq!(
-        (amount, new_balance),
-        (50_i128, 50_i128)
-    );
+    assert_eq!((amount, new_balance), (50_i128, 50_i128));
 }
 
 #[test]
@@ -1497,7 +1493,7 @@ fn test_withdraw_lock_emits_event() {
 
     deposit_balance(&client, &user, 500);
     let id = client.lock_funds(&user, &200, &2_000);
-    
+
     set_ledger_timestamp(&env, 2_000);
     client.withdraw_lock(&user, &id);
 
@@ -1505,10 +1501,10 @@ fn test_withdraw_lock_emits_event() {
     let (_contract, topics, data) = events.get(events.len() - 1).unwrap();
     let topic0: soroban_sdk::Symbol = topics.get(0).unwrap().try_into_val(&env).unwrap();
     let topic1: Address = topics.get(1).unwrap().try_into_val(&env).unwrap();
-    let (amount, new_balance): (i128, i128) = data.try_into_val(&env).unwrap();
-    assert_eq!(topic0, symbol_short!("wdr_lock"));
+    let (lock_id, amount): (u64, i128) = data.try_into_val(&env).unwrap();
+    assert_eq!(topic0, Symbol::new(&env, "withdraw_lock"));
     assert_eq!(topic1, user);
-    assert_eq!((amount, new_balance), (200_i128, 300_i128));
+    assert_eq!((lock_id, amount), (id, 200_i128));
 }
 
 #[test]
@@ -1561,13 +1557,14 @@ fn test_deposit_unauthorized_caller_fails() {
 fn test_withdraw_cross_user_unauthorized_fails() {
     let env = Env::default();
     let (contract_id, client) = init_contract(&env);
-    let (env, _admin, client, token_client, token_admin) = test_token(env, contract_id.clone(), client);
+    let (env, _admin, client, token_client, token_admin) =
+        test_token(env, contract_id.clone(), client);
 
     let alice = Address::generate(&env);
     let attacker = Address::generate(&env);
 
     token_admin.mint(&alice, &1000);
-    
+
     // Deposit for Alice with Alice's auth mocked
     env.mock_auths(&[soroban_sdk::testutils::MockAuth {
         address: &alice,
@@ -1637,7 +1634,8 @@ fn test_lock_funds_cross_user_unauthorized_fails() {
 fn test_admin_cannot_withdraw_user_funds_without_user_auth() {
     let env = Env::default();
     let (contract_id, client) = init_contract(&env);
-    let (env, admin, client, token_client, token_admin) = test_token(env, contract_id.clone(), client);
+    let (env, admin, client, token_client, token_admin) =
+        test_token(env, contract_id.clone(), client);
 
     let user = Address::generate(&env);
     token_admin.mint(&user, &1000);
@@ -1668,4 +1666,3 @@ fn test_admin_cannot_withdraw_user_funds_without_user_auth() {
     // Fails because withdraw requires `user.require_auth()`
     client.withdraw(&user, &500);
 }
-
diff --git a/docs/authorisation-rules.md b/docs/authorisation-rules.md
index 8f668ed..919aaf1 100644
--- a/docs/authorisation-rules.md
+++ b/docs/authorisation-rules.md
@@ -12,6 +12,11 @@ This document provides a comprehensive security reference and audit matrix detai
 | `deposit(user, amount)` | `user.require_auth()` | Soroban Host | Yes | Depositing Account Owner | **MEDIUM** |
 | `withdraw(user, amount)` | `user.require_auth()` | Soroban Host | Yes | Account Owner Only | **HIGH** |
 | `lock_funds(user, amount, unlock_time)` | `user.require_auth()` | Soroban Host | Yes | Account Owner Only | **MEDIUM** |
+| `withdraw_lock(user, lock_id)` | `user.require_auth()` | Soroban Host | Yes | Account Owner Only | **HIGH** |
+| `extend_lock(user, lock_id, new_unlock_time)` | `user.require_auth()` | Soroban Host | Yes | Account Owner Only | **MEDIUM** |
+| `pause(admin, duration)` | `admin.require_auth()` | Soroban Host | Yes | Contract Admin Only | **MEDIUM** |
+| `unpause(admin)` | `admin.require_auth()` | Soroban Host | Yes | Contract Admin Only | **MEDIUM** |
+| `transfer_admin(admin, new_admin)` | `admin.require_auth()` | Soroban Host | Yes | Current Contract Admin | **HIGH** |
 | `get_balance(user)` | None (Public Query) | N/A | No (Read-only) | Any Account / Indexer / Frontend | **LOW** |
 | `get_locked_balance(user)` | None (Public Query) | N/A | No (Read-only) | Any Account / Indexer / Frontend | **LOW** |
 | `can_withdraw(user)` | None (Public Query) | N/A | No (Read-only) | Any Account / Indexer / Frontend | **LOW** |
@@ -23,7 +28,7 @@ This document provides a comprehensive security reference and audit matrix detai
 ### 2.1 `initialize(env: Env, admin: Address, token: Address)`
 * **Authorisation Rule:** Requires a valid cryptographic signature from the `admin` address.
 * **Mechanism:** Explicit call to `admin.require_auth()`.
-* **Single-Invocation Protection:** Enforces `!env.storage().instance().has(&DataKey::Initialized)`. Re-invocation panics with `"Contract is already initialized"`.
+* **Single-Invocation Protection:** Enforces instance storage validation. Re-invocation panics with `ContractError::AlreadyInitialized`.
 * **Known Assumptions:** The deployer provides a valid SAC `token` address. The recorded `admin` address does not have special privileges over user vaults after initialization.
 
 ### 2.2 `deposit(env: Env, user: Address, amount: i128)`
@@ -45,7 +50,34 @@ This document provides a comprehensive security reference and audit matrix detai
 * **Caller Expectation:** Account owner locking a portion of their liquid balance until `unlock_time`.
 * **Protection Against Misuse:** Third parties cannot lock another user's liquid funds to grief them or restrict their liquidity.
 
-### 2.5 Read-Only Queries (`get_balance`, `get_locked_balance`, `can_withdraw`)
+### 2.5 `withdraw_lock(env: Env, user: Address, lock_id: u64)`
+* **Authorisation Rule:** Requires authorization from `user`.
+* **Mechanism:** `user.require_auth()`.
+* **Caller Expectation:** Account owner claiming a matured time-locked position.
+* **Protection Against Misuse:** Third parties cannot trigger premature lock withdrawals or withdraw matured locks on behalf of another user to execute them into an arbitrary destination.
+
+### 2.6 `extend_lock(env: Env, user: Address, lock_id: u64, new_unlock_time: u64)`
+* **Authorisation Rule:** Requires authorization from `user`.
+* **Mechanism:** `user.require_auth()`.
+* **Caller Expectation:** Account owner increasing the lock duration of an existing lock entry.
+* **Protection Against Misuse:** Unauthorised parties cannot force lock extensions on user vaults.
+
+### 2.7 `pause(env: Env, admin: Address, duration: u64)`
+* **Authorisation Rule:** Requires authorization from the configured `admin`.
+* **Mechanism:** `admin.require_auth()` paired with storage validation checking `admin == stored_admin`.
+* **Caller Expectation:** The contract administrator freezing new deposits and lock actions in an emergency.
+
+### 2.8 `unpause(env: Env, admin: Address)`
+* **Authorisation Rule:** Requires authorization from the configured `admin`.
+* **Mechanism:** `admin.require_auth()` paired with storage validation checking `admin == stored_admin`.
+* **Caller Expectation:** The contract administrator resuming contract operations.
+
+### 2.9 `transfer_admin(env: Env, admin: Address, new_admin: Address)`
+* **Authorisation Rule:** Requires authorization from the current `admin`.
+* **Mechanism:** `admin.require_auth()` paired with verification that `admin == stored_admin`.
+* **Caller Expectation:** The current administrator rotating the admin role to a new address.
+
+### 2.10 Read-Only Queries (`get_balance`, `get_locked_balance`, `can_withdraw`)
 * **Authorisation Rule:** None.
 * **Mechanism:** Unauthenticated view functions reading persistent storage (`DataKey::Balance`, `DataKey::Locks`).
 * **Caller Expectation:** Publicly accessible for off-chain mobile wallets, explorers, and indexers. State cannot be modified through read-only queries.
@@ -58,7 +90,7 @@ Security and multi-tenant isolation are preserved by pairing Soroban's Host auth
 
 ```rust
 DataKey::Balance(user: Address)
-DataKey::Locks(user: Address)
+DataKey::Lock(user: Address, lock_id: u64)
 DataKey::NextLockId(user: Address)
 ```
 
@@ -77,9 +109,13 @@ DataKey::NextLockId(user: Address)
 
 ## 5. Misuse Test Verification
 
-The unit test suite in [`contracts/savings_vault/src/test/mod.rs`](../contracts/savings_vault/src/test/mod.rs) explicitly verifies authorization and cross-user misuse protections:
+The unit test suite in [`contracts/savings_vault/src/test/unauthorized_access.rs`](../contracts/savings_vault/src/test/unauthorized_access.rs) explicitly verifies authorization and cross-user misuse protections:
 
-- `test_deposit_unauthorized_caller_fails`: Verifies unauthenticated deposits are rejected by the Host.
-- `test_withdraw_cross_user_unauthorized_fails`: Verifies `user_b` cannot withdraw from `user_a`'s vault.
-- `test_lock_funds_cross_user_unauthorized_fails`: Verifies `user_b` cannot lock `user_a`'s liquid funds.
-- `test_admin_cannot_withdraw_user_funds_without_user_auth`: Verifies `admin` cannot bypass user authorization to withdraw funds.
+- `test_unauthorized_deposit_fails`: Verifies unauthenticated deposits are rejected by the Host.
+- `test_unauthorized_withdraw_fails`: Verifies unauthenticated withdrawals are rejected.
+- `test_unauthorized_lock_fails`: Verifies unauthenticated lock attempts are rejected.
+- `test_unauthorized_withdraw_lock_fails`: Verifies unauthenticated lock withdrawal attempts are rejected.
+- `test_unauthorized_extend_lock_fails`: Verifies unauthenticated lock extension attempts are rejected.
+- `test_transfer_admin_unauthorized_caller_panics`: Verifies non-admin accounts cannot execute admin rotations.
+- `test_unauthorized_pause_fails`: Verifies non-admin accounts cannot pause the vault.
+- `test_unauthorized_unpause_fails`: Verifies non-admin accounts cannot unpause the vault.