diff --git a/contracts/insurance/src/errors.rs b/contracts/insurance/src/errors.rs
new file mode 100644
index 0000000..d332a97
--- /dev/null
+++ b/contracts/insurance/src/errors.rs
@@ -0,0 +1,15 @@
+use soroban_sdk::contracterror;
+
+/// Insurance module errors
+#[contracterror]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum InsuranceError {
+    AlreadyInitialized = 500,
+    UserNotInsured = 501,
+    ClaimNotFound = 502,
+    ClaimAlreadyProcessed = 503,
+    ClaimNotVerified = 504,
+}
+
+/// Result type alias for insurance operations
+pub type InsuranceResult<T> = core::result::Result<T, InsuranceError>;
diff --git a/contracts/insurance/src/lib.rs b/contracts/insurance/src/lib.rs
index 7c87aab..eec598a 100644
--- a/contracts/insurance/src/lib.rs
+++ b/contracts/insurance/src/lib.rs
@@ -1,5 +1,6 @@
 #![no_std]
 
+use crate::errors::InsuranceError;
 use soroban_sdk::{contract, contractimpl, contracttype, token, Address, Env};
 
 #[contracttype]
@@ -44,9 +45,9 @@ impl InsurancePool {
         oracle: Address,
         premium_amount: i128,
         payout_amount: i128,
-    ) {
+    ) -> Result<(), InsuranceError> {
         if env.storage().instance().has(&DataKey::Admin) {
-            panic!("Already initialized");
+            return Err(InsuranceError::AlreadyInitialized);
         }
         env.storage().instance().set(&DataKey::Admin, &admin);
         env.storage().instance().set(&DataKey::Token, &token);
@@ -58,6 +59,8 @@ impl InsurancePool {
             .instance()
             .set(&DataKey::PayoutAmount, &payout_amount);
         env.storage().instance().set(&DataKey::ClaimCount, &0u64);
+        
+        Ok(())
     }
 
     pub fn pay_premium(env: Env, user: Address) {
@@ -78,7 +81,7 @@ impl InsurancePool {
             .set(&DataKey::IsInsured(user.clone()), &true);
     }
 
-    pub fn file_claim(env: Env, user: Address, course_id: u64) -> u64 {
+    pub fn file_claim(env: Env, user: Address, course_id: u64) -> Result<u64, InsuranceError> {
         user.require_auth();
 
         if !env
@@ -87,7 +90,7 @@ impl InsurancePool {
             .get::<_, bool>(&DataKey::IsInsured(user.clone()))
             .unwrap_or(false)
         {
-            panic!("User is not insured");
+            return Err(InsuranceError::UserNotInsured);
         }
 
         let mut claim_count = env
@@ -110,10 +113,10 @@ impl InsurancePool {
             .instance()
             .set(&DataKey::ClaimCount, &claim_count);
 
-        claim_count
+        Ok(claim_count)
     }
 
-    pub fn process_claim(env: Env, claim_id: u64, result: bool) {
+    pub fn process_claim(env: Env, claim_id: u64, result: bool) -> Result<(), InsuranceError> {
         let oracle = env.storage().instance().get::<_, Address>(&DataKey::Oracle).unwrap();
         oracle.require_auth();
 
@@ -121,10 +124,10 @@ impl InsurancePool {
             .storage()
             .instance()
             .get::<_, Claim>(&DataKey::Claim(claim_id))
-            .expect("Claim not found");
+            .ok_or(InsuranceError::ClaimNotFound)?;
 
         if claim.status != ClaimStatus::Pending {
-            panic!("Claim already processed");
+            return Err(InsuranceError::ClaimAlreadyProcessed);
         }
 
         if result {
@@ -136,17 +139,19 @@ impl InsurancePool {
         env.storage()
             .instance()
             .set(&DataKey::Claim(claim_id), &claim);
+            
+        Ok(())
     }
 
-    pub fn payout(env: Env, claim_id: u64) {
+    pub fn payout(env: Env, claim_id: u64) -> Result<(), InsuranceError> {
         let mut claim = env
             .storage()
             .instance()
             .get::<_, Claim>(&DataKey::Claim(claim_id))
-            .expect("Claim not found");
+            .ok_or(InsuranceError::ClaimNotFound)?;
 
         if claim.status != ClaimStatus::Verified {
-            panic!("Claim not verified");
+            return Err(InsuranceError::ClaimNotVerified);
         }
 
         let token_addr = env.storage().instance().get::<_, Address>(&DataKey::Token).unwrap();
@@ -164,13 +169,12 @@ impl InsurancePool {
             .instance()
             .set(&DataKey::Claim(claim_id), &claim);
         
-        // Remove insurance after payout? Or keep it? 
-        // Usually insurance is for a specific term or event. 
-        // Here we assume it's one-time use per premium for simplicity, or maybe not.
         // Let's remove insurance to prevent multiple claims for one premium if that's the model.
         // But the prompt says "protects against course completion failures". 
         // Let's assume one premium covers one claim for now.
         env.storage().instance().remove(&DataKey::IsInsured(claim.user));
+        
+        Ok(())
     }
 
     pub fn withdraw(env: Env, amount: i128) {
@@ -193,4 +197,4 @@ impl InsurancePool {
     }
 }
 
-mod test;
+mod errors;
diff --git a/contracts/teachlink/src/bridge.rs b/contracts/teachlink/src/bridge.rs
index 1adf913..54a071e 100644
--- a/contracts/teachlink/src/bridge.rs
+++ b/contracts/teachlink/src/bridge.rs
@@ -1,4 +1,5 @@
 use crate::events::{BridgeCompletedEvent, BridgeInitiatedEvent, DepositEvent, ReleaseEvent};
+use crate::errors::BridgeError;
 use crate::storage::{
     ADMIN, BRIDGE_FEE, BRIDGE_TXS, FEE_RECIPIENT, MIN_VALIDATORS, NONCE, SUPPORTED_CHAINS, TOKEN,
     VALIDATORS,
@@ -19,10 +20,10 @@ impl Bridge {
         admin: Address,
         min_validators: u32,
         fee_recipient: Address,
-    ) {
+    ) -> Result<(), BridgeError> {
         // Check if already initialized
         if env.storage().instance().has(&TOKEN) {
-            panic!("Contract already initialized");
+            return Err(BridgeError::AlreadyInitialized);
         }
 
         env.storage().instance().set(&TOKEN, &token);
@@ -41,6 +42,8 @@ impl Bridge {
         // Initialize empty supported chains map
         let chains: Map<u32, bool> = Map::new(env);
         env.storage().instance().set(&SUPPORTED_CHAINS, &chains);
+        
+        Ok(())
     }
 
     /// Bridge tokens out to another chain (lock/burn tokens on Stellar)
@@ -53,12 +56,12 @@ impl Bridge {
         amount: i128,
         destination_chain: u32,
         destination_address: soroban_sdk::Bytes,
-    ) -> u64 {
+    ) -> Result<u64, BridgeError> {
         from.require_auth();
 
         // Validate inputs
         if amount <= 0 {
-            panic!("Amount must be positive");
+            return Err(BridgeError::AmountMustBePositive);
         }
 
         // Check if destination chain is supported
@@ -68,7 +71,7 @@ impl Bridge {
             .get(&SUPPORTED_CHAINS)
             .unwrap_or_else(|| Map::new(env));
         if !supported_chains.get(destination_chain).unwrap_or(false) {
-            panic!("Destination chain not supported");
+            return Err(BridgeError::DestinationChainNotSupported);
         }
 
         // Get token address
@@ -146,7 +149,7 @@ impl Bridge {
         }
         .publish(env);
 
-        nonce
+        Ok(nonce)
     }
 
     /// Complete a bridge transaction (mint/release tokens on Stellar)
@@ -157,18 +160,18 @@ impl Bridge {
         env: &Env,
         message: CrossChainMessage,
         validator_signatures: Vec<Address>,
-    ) {
+    ) -> Result<(), BridgeError> {
         // Validate that we have enough validator signatures
         let min_validators: u32 = env.storage().instance().get(&MIN_VALIDATORS).unwrap();
         if (validator_signatures.len() as u32) < min_validators {
-            panic!("Insufficient validator signatures");
+            return Err(BridgeError::InsufficientValidatorSignatures);
         }
 
         // Verify all signatures are from valid validators
         let validators: Map<Address, bool> = env.storage().instance().get(&VALIDATORS).unwrap();
         for validator in validator_signatures.iter() {
             if !validators.get(validator.clone()).unwrap_or(false) {
-                panic!("Invalid validator signature");
+                return Err(BridgeError::InvalidValidatorSignature);
             }
         }
 
@@ -179,7 +182,7 @@ impl Bridge {
             .get(&NONCE)
             .unwrap_or_else(|| Map::new(env));
         if processed_nonces.get(message.nonce).unwrap_or(false) {
-            panic!("Nonce already processed");
+            return Err(BridgeError::NonceAlreadyProcessed);
         }
         processed_nonces.set(message.nonce, true);
         env.storage().persistent().set(&NONCE, &processed_nonces);
@@ -189,7 +192,7 @@ impl Bridge {
 
         // Verify token matches
         if message.token != token {
-            panic!("Token mismatch");
+            return Err(BridgeError::TokenMismatch);
         }
 
         // Mint/release tokens to recipient
@@ -217,12 +220,14 @@ impl Bridge {
             source_chain: message.source_chain,
         }
         .publish(env);
+        
+        Ok(())
     }
 
     /// Cancel a bridge transaction and refund locked tokens
     /// Only callable after a timeout period
     /// - nonce: The nonce of the bridge transaction to cancel
-    pub fn cancel_bridge(env: &Env, nonce: u64) {
+    pub fn cancel_bridge(env: &Env, nonce: u64) -> Result<(), BridgeError> {
         // Get bridge transaction
         let bridge_txs: Map<u64, BridgeTransaction> = env
             .storage()
@@ -231,13 +236,13 @@ impl Bridge {
             .unwrap_or_else(|| Map::new(env));
         let bridge_tx = bridge_txs
             .get(nonce)
-            .unwrap_or_else(|| panic!("Bridge transaction not found"));
+            .ok_or(BridgeError::BridgeTransactionNotFound)?;
 
         // Check timeout (7 days = 604800 seconds)
         const TIMEOUT: u64 = 604800;
         let elapsed = env.ledger().timestamp() - bridge_tx.timestamp;
         if elapsed < TIMEOUT {
-            panic!("Timeout not reached");
+            return Err(BridgeError::TimeoutNotReached);
         }
 
         // Get token address
@@ -259,6 +264,8 @@ impl Bridge {
         let mut updated_txs = bridge_txs;
         updated_txs.remove(nonce);
         env.storage().instance().set(&BRIDGE_TXS, &updated_txs);
+        
+        Ok(())
     }
 
     // ========== Admin Functions ==========
@@ -304,15 +311,17 @@ impl Bridge {
     }
 
     /// Set bridge fee (admin only)
-    pub fn set_bridge_fee(env: &Env, fee: i128) {
+    pub fn set_bridge_fee(env: &Env, fee: i128) -> Result<(), BridgeError> {
         let admin: Address = env.storage().instance().get(&ADMIN).unwrap();
         admin.require_auth();
 
         if fee < 0 {
-            panic!("Fee cannot be negative");
+            return Err(BridgeError::FeeCannotBeNegative);
         }
 
         env.storage().instance().set(&BRIDGE_FEE, &fee);
+        
+        Ok(())
     }
 
     /// Set fee recipient (admin only)
@@ -324,17 +333,19 @@ impl Bridge {
     }
 
     /// Set minimum validators (admin only)
-    pub fn set_min_validators(env: &Env, min_validators: u32) {
+    pub fn set_min_validators(env: &Env, min_validators: u32) -> Result<(), BridgeError> {
         let admin: Address = env.storage().instance().get(&ADMIN).unwrap();
         admin.require_auth();
 
         if min_validators == 0 {
-            panic!("Minimum validators must be at least 1");
+            return Err(BridgeError::MinimumValidatorsMustBeAtLeastOne);
         }
 
         env.storage()
             .instance()
             .set(&MIN_VALIDATORS, &min_validators);
+            
+        Ok(())
     }
 
     // ========== View Functions ==========
diff --git a/contracts/teachlink/src/errors.rs b/contracts/teachlink/src/errors.rs
new file mode 100644
index 0000000..0d3dc89
--- /dev/null
+++ b/contracts/teachlink/src/errors.rs
@@ -0,0 +1,80 @@
+use soroban_sdk::contracterror;
+
+/// Bridge module errors
+#[contracterror]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum BridgeError {
+    AlreadyInitialized = 100,
+    AmountMustBePositive = 101,
+    DestinationChainNotSupported = 102,
+    InsufficientValidatorSignatures = 103,
+    InvalidValidatorSignature = 104,
+    NonceAlreadyProcessed = 105,
+    TokenMismatch = 106,
+    BridgeTransactionNotFound = 107,
+    TimeoutNotReached = 108,
+    FeeCannotBeNegative = 109,
+    MinimumValidatorsMustBeAtLeastOne = 110,
+}
+
+/// Escrow module errors
+#[contracterror]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum EscrowError {
+    AmountMustBePositive = 200,
+    AtLeastOneSignerRequired = 201,
+    InvalidSignerThreshold = 202,
+    RefundTimeMustBeInFuture = 203,
+    RefundTimeMustBeAfterReleaseTime = 204,
+    DuplicateSigner = 205,
+    SignerNotAuthorized = 206,
+    SignerAlreadyApproved = 207,
+    CallerNotAuthorized = 208,
+    InsufficientApprovals = 209,
+    ReleaseTimeNotReached = 210,
+    OnlyDepositorCanRefund = 211,
+    RefundNotEnabled = 212,
+    RefundTimeNotReached = 213,
+    OnlyDepositorCanCancel = 214,
+    CannotCancelAfterApprovals = 215,
+    OnlyDepositorOrBeneficiaryCanDispute = 216,
+    EscrowNotInDispute = 217,
+    OnlyArbitratorCanResolve = 218,
+    EscrowNotPending = 219,
+    EscrowNotFound = 220,
+}
+
+/// Rewards module errors
+#[contracterror]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum RewardsError {
+    AlreadyInitialized = 300,
+    AmountMustBePositive = 301,
+    InsufficientRewardPoolBalance = 302,
+    NoRewardsAvailable = 303,
+    NoPendingRewards = 304,
+    RateCannotBeNegative = 305,
+}
+
+/// Common errors that can be used across modules
+#[contracterror]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum CommonError {
+    Unauthorized = 400,
+    InvalidInput = 401,
+    InsufficientBalance = 402,
+    TransferFailed = 403,
+    StorageError = 404,
+}
+
+/// Result type alias for bridge operations
+pub type BridgeResult<T> = core::result::Result<T, BridgeError>;
+
+/// Result type alias for escrow operations
+pub type EscrowResult<T> = core::result::Result<T, EscrowError>;
+
+/// Result type alias for rewards operations
+pub type RewardsResult<T> = core::result::Result<T, RewardsError>;
+
+/// Result type alias for common operations
+pub type CommonResult<T> = core::result::Result<T, CommonError>;
diff --git a/contracts/teachlink/src/escrow.rs b/contracts/teachlink/src/escrow.rs
index 7b3e089..63ac5fb 100644
--- a/contracts/teachlink/src/escrow.rs
+++ b/contracts/teachlink/src/escrow.rs
@@ -1,3 +1,4 @@
+use crate::errors::EscrowError;
 use crate::events::{
     EscrowApprovedEvent, EscrowCreatedEvent, EscrowDisputedEvent, EscrowRefundedEvent,
     EscrowReleasedEvent, EscrowResolvedEvent,
@@ -20,35 +21,35 @@ impl EscrowManager {
         release_time: Option<u64>,
         refund_time: Option<u64>,
         arbitrator: Address,
-    ) -> u64 {
+    ) -> Result<u64, EscrowError> {
         depositor.require_auth();
 
         if amount <= 0 {
-            panic!("Amount must be positive");
+            return Err(EscrowError::AmountMustBePositive);
         }
 
         if signers.len() == 0 {
-            panic!("At least one signer required");
+            return Err(EscrowError::AtLeastOneSignerRequired);
         }
 
         if threshold == 0 || threshold > signers.len() as u32 {
-            panic!("Invalid signer threshold");
+            return Err(EscrowError::InvalidSignerThreshold);
         }
 
         let now = env.ledger().timestamp();
         if let Some(refund_time) = refund_time {
             if refund_time < now {
-                panic!("Refund time must be in the future");
+                return Err(EscrowError::RefundTimeMustBeInFuture);
             }
         }
 
         if let (Some(release), Some(refund)) = (release_time, refund_time) {
             if refund < release {
-                panic!("Refund time must be after release time");
+                return Err(EscrowError::RefundTimeMustBeAfterReleaseTime);
             }
         }
 
-        Self::ensure_unique_signers(env, &signers);
+        Self::ensure_unique_signers(env, &signers)?;
 
         env.invoke_contract::<()>(
             &token,
@@ -88,17 +89,17 @@ impl EscrowManager {
 
         EscrowCreatedEvent { escrow }.publish(env);
 
-        escrow_count
+        Ok(escrow_count)
     }
 
-    pub fn approve_release(env: &Env, escrow_id: u64, signer: Address) -> u32 {
+    pub fn approve_release(env: &Env, escrow_id: u64, signer: Address) -> Result<u32, EscrowError> {
         signer.require_auth();
 
-        let mut escrow = Self::load_escrow(env, escrow_id);
-        Self::ensure_pending(&escrow);
+        let mut escrow = Self::load_escrow(env, escrow_id)?;
+        Self::ensure_pending(&escrow)?;
 
         if !Self::is_signer(&escrow.signers, &signer) {
-            panic!("Signer not authorized");
+            return Err(EscrowError::SignerNotAuthorized);
         }
 
         let approval_key = EscrowApprovalKey {
@@ -106,7 +107,7 @@ impl EscrowManager {
             signer: signer.clone(),
         };
         if env.storage().persistent().has(&approval_key) {
-            panic!("Signer already approved");
+            return Err(EscrowError::SignerAlreadyApproved);
         }
 
         env.storage().persistent().set(&approval_key, &true);
@@ -121,27 +122,27 @@ impl EscrowManager {
         }
         .publish(env);
 
-        escrow.approval_count
+        Ok(escrow.approval_count)
     }
 
-    pub fn release(env: &Env, escrow_id: u64, caller: Address) {
+    pub fn release(env: &Env, escrow_id: u64, caller: Address) -> Result<(), EscrowError> {
         caller.require_auth();
 
-        let mut escrow = Self::load_escrow(env, escrow_id);
-        Self::ensure_pending(&escrow);
+        let mut escrow = Self::load_escrow(env, escrow_id)?;
+        Self::ensure_pending(&escrow)?;
 
         if !Self::is_release_caller(&escrow, &caller) {
-            panic!("Caller not authorized");
+            return Err(EscrowError::CallerNotAuthorized);
         }
 
         if escrow.approval_count < escrow.threshold {
-            panic!("Insufficient approvals");
+            return Err(EscrowError::InsufficientApprovals);
         }
 
         if let Some(release_time) = escrow.release_time {
             let now = env.ledger().timestamp();
             if now < release_time {
-                panic!("Release time not reached");
+                return Err(EscrowError::ReleaseTimeNotReached);
             }
         }
 
@@ -155,22 +156,24 @@ impl EscrowManager {
             amount: escrow.amount,
         }
         .publish(env);
+        
+        Ok(())
     }
 
-    pub fn refund(env: &Env, escrow_id: u64, depositor: Address) {
+    pub fn refund(env: &Env, escrow_id: u64, depositor: Address) -> Result<(), EscrowError> {
         depositor.require_auth();
 
-        let mut escrow = Self::load_escrow(env, escrow_id);
-        Self::ensure_pending(&escrow);
+        let mut escrow = Self::load_escrow(env, escrow_id)?;
+        Self::ensure_pending(&escrow)?;
 
         if depositor != escrow.depositor {
-            panic!("Only depositor can refund");
+            return Err(EscrowError::OnlyDepositorCanRefund);
         }
 
-        let refund_time = escrow.refund_time.unwrap_or_else(|| panic!("Refund not enabled"));
+        let refund_time = escrow.refund_time.ok_or(EscrowError::RefundNotEnabled)?;
         let now = env.ledger().timestamp();
         if now < refund_time {
-            panic!("Refund time not reached");
+            return Err(EscrowError::RefundTimeNotReached);
         }
 
         Self::transfer_from_contract(env, &escrow.token, &escrow.depositor, escrow.amount);
@@ -183,35 +186,39 @@ impl EscrowManager {
             amount: escrow.amount,
         }
         .publish(env);
+        
+        Ok(())
     }
 
-    pub fn cancel(env: &Env, escrow_id: u64, depositor: Address) {
+    pub fn cancel(env: &Env, escrow_id: u64, depositor: Address) -> Result<(), EscrowError> {
         depositor.require_auth();
 
-        let mut escrow = Self::load_escrow(env, escrow_id);
-        Self::ensure_pending(&escrow);
+        let mut escrow = Self::load_escrow(env, escrow_id)?;
+        Self::ensure_pending(&escrow)?;
 
         if depositor != escrow.depositor {
-            panic!("Only depositor can cancel");
+            return Err(EscrowError::OnlyDepositorCanCancel);
         }
 
         if escrow.approval_count > 0 {
-            panic!("Cannot cancel after approvals");
+            return Err(EscrowError::CannotCancelAfterApprovals);
         }
 
         Self::transfer_from_contract(env, &escrow.token, &escrow.depositor, escrow.amount);
         escrow.status = EscrowStatus::Cancelled;
         Self::save_escrow(env, escrow_id, escrow.clone());
+        
+        Ok(())
     }
 
-    pub fn dispute(env: &Env, escrow_id: u64, disputer: Address, reason: Bytes) {
+    pub fn dispute(env: &Env, escrow_id: u64, disputer: Address, reason: Bytes) -> Result<(), EscrowError> {
         disputer.require_auth();
 
-        let mut escrow = Self::load_escrow(env, escrow_id);
-        Self::ensure_pending(&escrow);
+        let mut escrow = Self::load_escrow(env, escrow_id)?;
+        Self::ensure_pending(&escrow)?;
 
         if disputer != escrow.depositor && disputer != escrow.beneficiary {
-            panic!("Only depositor or beneficiary can dispute");
+            return Err(EscrowError::OnlyDepositorOrBeneficiaryCanDispute);
         }
 
         escrow.status = EscrowStatus::Disputed;
@@ -224,18 +231,20 @@ impl EscrowManager {
             reason,
         }
         .publish(env);
+        
+        Ok(())
     }
 
-    pub fn resolve(env: &Env, escrow_id: u64, arbitrator: Address, outcome: DisputeOutcome) {
+    pub fn resolve(env: &Env, escrow_id: u64, arbitrator: Address, outcome: DisputeOutcome) -> Result<(), EscrowError> {
         arbitrator.require_auth();
 
-        let mut escrow = Self::load_escrow(env, escrow_id);
+        let mut escrow = Self::load_escrow(env, escrow_id)?;
         if escrow.status != EscrowStatus::Disputed {
-            panic!("Escrow not in dispute");
+            return Err(EscrowError::EscrowNotInDispute);
         }
 
         if arbitrator != escrow.arbitrator {
-            panic!("Only arbitrator can resolve");
+            return Err(EscrowError::OnlyArbitratorCanResolve);
         }
 
         let new_status = match outcome {
@@ -258,6 +267,8 @@ impl EscrowManager {
             status: new_status,
         }
         .publish(env);
+        
+        Ok(())
     }
 
     pub fn get_escrow(env: &Env, escrow_id: u64) -> Option<Escrow> {
@@ -274,14 +285,15 @@ impl EscrowManager {
         env.storage().persistent().has(&approval_key)
     }
 
-    fn ensure_unique_signers(env: &Env, signers: &Vec<Address>) {
+    fn ensure_unique_signers(env: &Env, signers: &Vec<Address>) -> Result<(), EscrowError> {
         let mut seen: Map<Address, bool> = Map::new(env);
         for signer in signers.iter() {
             if seen.get(signer.clone()).unwrap_or(false) {
-                panic!("Duplicate signer");
+                return Err(EscrowError::DuplicateSigner);
             }
             seen.set(signer.clone(), true);
         }
+        Ok(())
     }
 
     fn is_signer(signers: &Vec<Address>, signer: &Address) -> bool {
@@ -300,10 +312,11 @@ impl EscrowManager {
         Self::is_signer(&escrow.signers, caller)
     }
 
-    fn ensure_pending(escrow: &Escrow) {
+    fn ensure_pending(escrow: &Escrow) -> Result<(), EscrowError> {
         if escrow.status != EscrowStatus::Pending {
-            panic!("Escrow not pending");
+            return Err(EscrowError::EscrowNotPending);
         }
+        Ok(())
     }
 
     fn load_escrows(env: &Env) -> Map<u64, Escrow> {
@@ -313,11 +326,11 @@ impl EscrowManager {
             .unwrap_or_else(|| Map::new(env))
     }
 
-    fn load_escrow(env: &Env, escrow_id: u64) -> Escrow {
+    fn load_escrow(env: &Env, escrow_id: u64) -> Result<Escrow, EscrowError> {
         let escrows = Self::load_escrows(env);
         escrows
             .get(escrow_id)
-            .unwrap_or_else(|| panic!("Escrow not found"))
+            .ok_or(EscrowError::EscrowNotFound)
     }
 
     fn save_escrow(env: &Env, escrow_id: u64, escrow: Escrow) {
diff --git a/contracts/teachlink/src/events.rs b/contracts/teachlink/src/events.rs
index 5b884d2..790f556 100644
--- a/contracts/teachlink/src/events.rs
+++ b/contracts/teachlink/src/events.rs
@@ -1,10 +1,8 @@
 use soroban_sdk::contractevent;
 
-
 use crate::types::{BridgeTransaction, CrossChainMessage, DisputeOutcome, Escrow, EscrowStatus};
 use soroban_sdk::{Address, Bytes, String};
 
-
 #[contractevent]
 #[derive(Clone, Debug)]
 pub struct DepositEvent {
@@ -46,10 +44,6 @@ pub struct RewardIssuedEvent {
     pub amount: i128,
     pub reward_type: String,
     pub timestamp: u64,
-#[contractevent]
-#[derive(Clone, Debug)]
-pub struct EscrowCreatedEvent {
-    pub escrow: Escrow,
 }
 
 #[contractevent]
@@ -58,6 +52,25 @@ pub struct RewardClaimedEvent {
     pub user: Address,
     pub amount: i128,
     pub timestamp: u64,
+}
+
+#[contractevent]
+#[derive(Clone, Debug)]
+pub struct RewardPoolFundedEvent {
+    pub funder: Address,
+    pub amount: i128,
+    pub timestamp: u64,
+}
+
+// Escrow Events
+#[contractevent]
+#[derive(Clone, Debug)]
+pub struct EscrowCreatedEvent {
+    pub escrow: Escrow,
+}
+
+#[contractevent]
+#[derive(Clone, Debug)]
 pub struct EscrowApprovedEvent {
     pub escrow_id: u64,
     pub signer: Address,
@@ -74,10 +87,6 @@ pub struct EscrowReleasedEvent {
 
 #[contractevent]
 #[derive(Clone, Debug)]
-pub struct RewardPoolFundedEvent {
-    pub funder: Address,
-    pub amount: i128,
-    pub timestamp: u64,
 pub struct EscrowRefundedEvent {
     pub escrow_id: u64,
     pub depositor: Address,
diff --git a/contracts/teachlink/src/lib.rs b/contracts/teachlink/src/lib.rs
index 23e81a8..8bd8c52 100644
--- a/contracts/teachlink/src/lib.rs
+++ b/contracts/teachlink/src/lib.rs
@@ -4,6 +4,7 @@ use soroban_sdk::{contract, contractimpl, Address, Bytes, Env, String, Vec};
 
 mod bridge;
 mod escrow;
+mod errors;
 mod events;
 mod rewards;
 mod storage;
@@ -12,6 +13,7 @@ mod types;
 pub use types::{
     BridgeTransaction, CrossChainMessage, DisputeOutcome, Escrow, EscrowStatus, RewardRate, UserReward
 };
+pub use errors::{BridgeError, EscrowError, RewardsError};
 
 #[contract]
 pub struct TeachLinkBridge;
@@ -25,8 +27,8 @@ impl TeachLinkBridge {
         admin: Address,
         min_validators: u32,
         fee_recipient: Address,
-    ) {
-        bridge::Bridge::initialize(&env, token, admin, min_validators, fee_recipient);
+    ) -> Result<(), BridgeError> {
+        bridge::Bridge::initialize(&env, token, admin, min_validators, fee_recipient)
     }
 
     /// Bridge tokens out to another chain (lock/burn tokens on Stellar)
@@ -36,7 +38,7 @@ impl TeachLinkBridge {
         amount: i128,
         destination_chain: u32,
         destination_address: Bytes,
-    ) -> u64 {
+    ) -> Result<u64, BridgeError> {
         bridge::Bridge::bridge_out(&env, from, amount, destination_chain, destination_address)
     }
 
@@ -45,13 +47,13 @@ impl TeachLinkBridge {
         env: Env,
         message: CrossChainMessage,
         validator_signatures: Vec<Address>,
-    ) {
-        bridge::Bridge::complete_bridge(&env, message, validator_signatures);
+    ) -> Result<(), BridgeError> {
+        bridge::Bridge::complete_bridge(&env, message, validator_signatures)
     }
 
     /// Cancel a bridge transaction and refund locked tokens
-    pub fn cancel_bridge(env: Env, nonce: u64) {
-        bridge::Bridge::cancel_bridge(&env, nonce);
+    pub fn cancel_bridge(env: Env, nonce: u64) -> Result<(), BridgeError> {
+        bridge::Bridge::cancel_bridge(&env, nonce)
     }
 
     // ========== Admin Functions ==========
@@ -77,8 +79,8 @@ impl TeachLinkBridge {
     }
 
     /// Set bridge fee (admin only)
-    pub fn set_bridge_fee(env: Env, fee: i128) {
-        bridge::Bridge::set_bridge_fee(&env, fee);
+    pub fn set_bridge_fee(env: Env, fee: i128) -> Result<(), BridgeError> {
+        bridge::Bridge::set_bridge_fee(&env, fee)
     }
 
     /// Set fee recipient (admin only)
@@ -87,8 +89,8 @@ impl TeachLinkBridge {
     }
 
     /// Set minimum validators (admin only)
-    pub fn set_min_validators(env: Env, min_validators: u32) {
-        bridge::Bridge::set_min_validators(&env, min_validators);
+    pub fn set_min_validators(env: Env, min_validators: u32) -> Result<(), BridgeError> {
+        bridge::Bridge::set_min_validators(&env, min_validators)
     }
 
     // ========== View Functions ==========
@@ -126,28 +128,28 @@ impl TeachLinkBridge {
     // ========== Rewards Functions ==========
 
     /// Initialize the rewards system
-    pub fn initialize_rewards(env: Env, token: Address, rewards_admin: Address) {
-        rewards::Rewards::initialize_rewards(&env, token, rewards_admin);
+    pub fn initialize_rewards(env: Env, token: Address, rewards_admin: Address) -> Result<(), RewardsError> {
+        rewards::Rewards::initialize_rewards(&env, token, rewards_admin)
     }
 
     /// Fund the reward pool
-    pub fn fund_reward_pool(env: Env, funder: Address, amount: i128) {
-        rewards::Rewards::fund_reward_pool(&env, funder, amount);
+    pub fn fund_reward_pool(env: Env, funder: Address, amount: i128) -> Result<(), RewardsError> {
+        rewards::Rewards::fund_reward_pool(&env, funder, amount)
     }
 
     /// Issue rewards to a user
-    pub fn issue_reward(env: Env, recipient: Address, amount: i128, reward_type: String) {
-        rewards::Rewards::issue_reward(&env, recipient, amount, reward_type);
+    pub fn issue_reward(env: Env, recipient: Address, amount: i128, reward_type: String) -> Result<(), RewardsError> {
+        rewards::Rewards::issue_reward(&env, recipient, amount, reward_type)
     }
 
     /// Claim pending rewards
-    pub fn claim_rewards(env: Env, user: Address) {
-        rewards::Rewards::claim_rewards(&env, user);
+    pub fn claim_rewards(env: Env, user: Address) -> Result<(), RewardsError> {
+        rewards::Rewards::claim_rewards(&env, user)
     }
 
     /// Set reward rate for a specific reward type (admin only)
-    pub fn set_reward_rate(env: Env, reward_type: String, rate: i128, enabled: bool) {
-        rewards::Rewards::set_reward_rate(&env, reward_type, rate, enabled);
+    pub fn set_reward_rate(env: Env, reward_type: String, rate: i128, enabled: bool) -> Result<(), RewardsError> {
+        rewards::Rewards::set_reward_rate(&env, reward_type, rate, enabled)
     }
 
     /// Update rewards admin (admin only)
@@ -178,6 +180,8 @@ impl TeachLinkBridge {
     /// Get rewards admin address
     pub fn get_rewards_admin(env: Env) -> Address {
         rewards::Rewards::get_rewards_admin(&env)
+    }
+
     // ========== Escrow Functions ==========
 
     /// Create a multi-signature escrow
@@ -192,7 +196,7 @@ impl TeachLinkBridge {
         release_time: Option<u64>,
         refund_time: Option<u64>,
         arbitrator: Address,
-    ) -> u64 {
+    ) -> Result<u64, EscrowError> {
         escrow::EscrowManager::create_escrow(
             &env,
             depositor,
@@ -208,32 +212,32 @@ impl TeachLinkBridge {
     }
 
     /// Approve escrow release (multi-signature)
-    pub fn approve_escrow_release(env: Env, escrow_id: u64, signer: Address) -> u32 {
+    pub fn approve_escrow_release(env: Env, escrow_id: u64, signer: Address) -> Result<u32, EscrowError> {
         escrow::EscrowManager::approve_release(&env, escrow_id, signer)
     }
 
     /// Release funds to the beneficiary once conditions are met
-    pub fn release_escrow(env: Env, escrow_id: u64, caller: Address) {
+    pub fn release_escrow(env: Env, escrow_id: u64, caller: Address) -> Result<(), EscrowError> {
         escrow::EscrowManager::release(&env, escrow_id, caller)
     }
 
     /// Refund escrow to the depositor after refund time
-    pub fn refund_escrow(env: Env, escrow_id: u64, depositor: Address) {
+    pub fn refund_escrow(env: Env, escrow_id: u64, depositor: Address) -> Result<(), EscrowError> {
         escrow::EscrowManager::refund(&env, escrow_id, depositor)
     }
 
     /// Cancel escrow before any approvals
-    pub fn cancel_escrow(env: Env, escrow_id: u64, depositor: Address) {
+    pub fn cancel_escrow(env: Env, escrow_id: u64, depositor: Address) -> Result<(), EscrowError> {
         escrow::EscrowManager::cancel(&env, escrow_id, depositor)
     }
 
     /// Raise a dispute on the escrow
-    pub fn dispute_escrow(env: Env, escrow_id: u64, disputer: Address, reason: Bytes) {
+    pub fn dispute_escrow(env: Env, escrow_id: u64, disputer: Address, reason: Bytes) -> Result<(), EscrowError> {
         escrow::EscrowManager::dispute(&env, escrow_id, disputer, reason)
     }
 
     /// Resolve a dispute as the arbitrator
-    pub fn resolve_escrow(env: Env, escrow_id: u64, arbitrator: Address, outcome: DisputeOutcome) {
+    pub fn resolve_escrow(env: Env, escrow_id: u64, arbitrator: Address, outcome: DisputeOutcome) -> Result<(), EscrowError> {
         escrow::EscrowManager::resolve(&env, escrow_id, arbitrator, outcome)
     }
 
diff --git a/contracts/teachlink/src/rewards.rs b/contracts/teachlink/src/rewards.rs
index b3db4d5..40b1c45 100644
--- a/contracts/teachlink/src/rewards.rs
+++ b/contracts/teachlink/src/rewards.rs
@@ -1,3 +1,4 @@
+use crate::errors::RewardsError;
 use crate::events::{RewardClaimedEvent, RewardIssuedEvent, RewardPoolFundedEvent};
 use crate::storage::{REWARD_POOL, REWARD_RATES, REWARDS_ADMIN, TOKEN, TOTAL_REWARDS_ISSUED, USER_REWARDS};
 use crate::types::{RewardRate, UserReward};
@@ -7,9 +8,9 @@ pub struct Rewards;
 
 impl Rewards {
     /// Initialize the rewards system
-    pub fn initialize_rewards(env: &Env, token: Address, rewards_admin: Address) {
+    pub fn initialize_rewards(env: &Env, token: Address, rewards_admin: Address) -> Result<(), RewardsError> {
         if env.storage().instance().has(&REWARDS_ADMIN) {
-            panic!("Rewards already initialized");
+            return Err(RewardsError::AlreadyInitialized);
         }
 
         env.storage().instance().set(&TOKEN, &token);
@@ -22,14 +23,16 @@ impl Rewards {
 
         let user_rewards: Map<Address, UserReward> = Map::new(env);
         env.storage().instance().set(&USER_REWARDS, &user_rewards);
+        
+        Ok(())
     }
 
     /// Fund the reward pool
-    pub fn fund_reward_pool(env: &Env, funder: Address, amount: i128) {
+    pub fn fund_reward_pool(env: &Env, funder: Address, amount: i128) -> Result<(), RewardsError> {
         funder.require_auth();
 
         if amount <= 0 {
-            panic!("Amount must be positive");
+            return Err(RewardsError::AmountMustBePositive);
         }
 
         let token: Address = env.storage().instance().get(&TOKEN).unwrap();
@@ -55,6 +58,8 @@ impl Rewards {
             timestamp: env.ledger().timestamp(),
         }
         .publish(env);
+        
+        Ok(())
     }
 
     /// Issue rewards to a user
@@ -63,17 +68,17 @@ impl Rewards {
         recipient: Address,
         amount: i128,
         reward_type: String,
-    ) {
+    ) -> Result<(), RewardsError> {
         let rewards_admin: Address = env.storage().instance().get(&REWARDS_ADMIN).unwrap();
         rewards_admin.require_auth();
 
         if amount <= 0 {
-            panic!("Amount must be positive");
+            return Err(RewardsError::AmountMustBePositive);
         }
 
         let pool_balance: i128 = env.storage().instance().get(&REWARD_POOL).unwrap_or(0i128);
         if pool_balance < amount {
-            panic!("Insufficient reward pool balance");
+            return Err(RewardsError::InsufficientRewardPoolBalance);
         }
 
         let mut user_rewards: Map<Address, UserReward> = env
@@ -111,10 +116,12 @@ impl Rewards {
             timestamp: env.ledger().timestamp(),
         }
         .publish(env);
+        
+        Ok(())
     }
 
     /// Claim pending rewards
-    pub fn claim_rewards(env: &Env, user: Address) {
+    pub fn claim_rewards(env: &Env, user: Address) -> Result<(), RewardsError> {
         user.require_auth();
 
         let mut user_rewards: Map<Address, UserReward> = env
@@ -125,17 +132,17 @@ impl Rewards {
 
         let mut user_reward = user_rewards
             .get(user.clone())
-            .unwrap_or_else(|| panic!("No rewards available"));
+            .ok_or(RewardsError::NoRewardsAvailable)?;
 
         if user_reward.pending <= 0 {
-            panic!("No pending rewards");
+            return Err(RewardsError::NoPendingRewards);
         }
 
         let amount_to_claim = user_reward.pending;
 
         let pool_balance: i128 = env.storage().instance().get(&REWARD_POOL).unwrap_or(0i128);
         if pool_balance < amount_to_claim {
-            panic!("Insufficient reward pool balance");
+            return Err(RewardsError::InsufficientRewardPoolBalance);
         }
 
         let token: Address = env.storage().instance().get(&TOKEN).unwrap();
@@ -168,17 +175,19 @@ impl Rewards {
             timestamp: env.ledger().timestamp(),
         }
         .publish(env);
+        
+        Ok(())
     }
 
     // ========== Admin Functions ==========
 
     /// Set reward rate for a specific reward type
-    pub fn set_reward_rate(env: &Env, reward_type: String, rate: i128, enabled: bool) {
+    pub fn set_reward_rate(env: &Env, reward_type: String, rate: i128, enabled: bool) -> Result<(), RewardsError> {
         let rewards_admin: Address = env.storage().instance().get(&REWARDS_ADMIN).unwrap();
         rewards_admin.require_auth();
 
         if rate < 0 {
-            panic!("Rate cannot be negative");
+            return Err(RewardsError::RateCannotBeNegative);
         }
 
         let mut reward_rates: Map<String, RewardRate> = env
@@ -195,6 +204,8 @@ impl Rewards {
 
         reward_rates.set(reward_type, reward_rate);
         env.storage().instance().set(&REWARD_RATES, &reward_rates);
+        
+        Ok(())
     }
 
     /// Update rewards admin
diff --git a/contracts/teachlink/src/types.rs b/contracts/teachlink/src/types.rs
index 87bf707..b5c1862 100644
--- a/contracts/teachlink/src/types.rs
+++ b/contracts/teachlink/src/types.rs
@@ -26,12 +26,6 @@ pub struct CrossChainMessage {
 
 #[contracttype]
 #[derive(Clone, Debug, Eq, PartialEq)]
-pub struct UserReward {
-    pub user: Address,
-    pub total_earned: i128,
-    pub claimed: i128,
-    pub pending: i128,
-    pub last_claim_timestamp: u64,
 pub enum EscrowStatus {
     Pending,
     Released,
@@ -40,12 +34,26 @@ pub enum EscrowStatus {
     Cancelled,
 }
 
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct UserReward {
+    pub user: Address,
+    pub total_earned: i128,
+    pub claimed: i128,
+    pub pending: i128,
+    pub last_claim_timestamp: u64,
+}
+
 #[contracttype]
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct RewardRate {
     pub reward_type: String,
     pub rate: i128,
     pub enabled: bool,
+}
+
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct Escrow {
     pub id: u64,
     pub depositor: Address,
diff --git a/contracts/teachlink/tests/test_bridge.rs b/contracts/teachlink/tests/test_bridge.rs
index 3fed02f..d6ff909 100644
--- a/contracts/teachlink/tests/test_bridge.rs
+++ b/contracts/teachlink/tests/test_bridge.rs
@@ -1,6 +1,6 @@
 use soroban_sdk::{testutils::Address as _, Address, Bytes, Env};
 
-use teachlink_contract::{TeachLinkBridge, TeachLinkBridgeClient};
+use teachlink_contract::{BridgeError, TeachLinkBridge, TeachLinkBridgeClient};
 
 #[test]
 fn test_initialize() {
@@ -12,7 +12,7 @@ fn test_initialize() {
     let fee_recipient = Address::generate(&env);
 
     let client = TeachLinkBridgeClient::new(&env, &contract_id);
-    client.initialize(&token, &admin, &2, &fee_recipient);
+    client.initialize(&token, &admin, &2, &fee_recipient).unwrap();
 
     assert_eq!(client.get_token(), token);
     assert_eq!(client.get_bridge_fee(), 0i128);
@@ -29,7 +29,7 @@ fn test_add_validator() {
     let fee_recipient = Address::generate(&env);
 
     let client = TeachLinkBridgeClient::new(&env, &contract_id);
-    client.initialize(&token, &admin, &2, &fee_recipient);
+    client.initialize(&token, &admin, &2, &fee_recipient).unwrap();
 
     let validator = Address::generate(&env);
     env.mock_all_auths(); // Mock authentication for admin
@@ -47,7 +47,7 @@ fn test_add_supported_chain() {
     let fee_recipient = Address::generate(&env);
 
     let client = TeachLinkBridgeClient::new(&env, &contract_id);
-    client.initialize(&token, &admin, &2, &fee_recipient);
+    client.initialize(&token, &admin, &2, &fee_recipient).unwrap();
 
     env.mock_all_auths(); // Mock authentication for admin
     client.add_supported_chain(&1); // Ethereum
@@ -58,7 +58,6 @@ fn test_add_supported_chain() {
 }
 
 #[test]
-#[should_panic(expected = "Destination chain not supported")]
 fn test_bridge_out_unsupported_chain() {
     let env = Env::default();
     let contract_id = env.register(TeachLinkBridge, ());
@@ -69,16 +68,16 @@ fn test_bridge_out_unsupported_chain() {
     let user = Address::generate(&env);
 
     let client = TeachLinkBridgeClient::new(&env, &contract_id);
-    client.initialize(&token, &admin, &2, &fee_recipient);
+    client.initialize(&token, &admin, &2, &fee_recipient).unwrap();
 
     env.mock_all_auths();
     // Try to bridge to unsupported chain
     let dest_addr = Bytes::from_array(&env, &[0; 20]);
-    client.bridge_out(&user, &1000, &999, &dest_addr);
+    let result = client.bridge_out(&user, &1000, &999, &dest_addr);
+    assert_eq!(result, Err(BridgeError::DestinationChainNotSupported));
 }
 
 #[test]
-#[should_panic(expected = "Amount must be positive")]
 fn test_bridge_out_invalid_amount() {
     let env = Env::default();
     let contract_id = env.register(TeachLinkBridge, ());
@@ -89,12 +88,13 @@ fn test_bridge_out_invalid_amount() {
     let user = Address::generate(&env);
 
     let client = TeachLinkBridgeClient::new(&env, &contract_id);
-    client.initialize(&token, &admin, &2, &fee_recipient);
+    client.initialize(&token, &admin, &2, &fee_recipient).unwrap();
 
     env.mock_all_auths();
     client.add_supported_chain(&1);
     let dest_addr = Bytes::from_array(&env, &[0; 20]);
-    client.bridge_out(&user, &0, &1, &dest_addr);
+    let result = client.bridge_out(&user, &0, &1, &dest_addr);
+    assert_eq!(result, Err(BridgeError::AmountMustBePositive));
 }
 
 #[test]
@@ -107,12 +107,12 @@ fn test_set_bridge_fee() {
     let fee_recipient = Address::generate(&env);
 
     let client = TeachLinkBridgeClient::new(&env, &contract_id);
-    client.initialize(&token, &admin, &2, &fee_recipient);
+    client.initialize(&token, &admin, &2, &fee_recipient).unwrap();
 
     assert_eq!(client.get_bridge_fee(), 0i128);
 
     env.mock_all_auths();
-    client.set_bridge_fee(&100);
+    client.set_bridge_fee(&100).unwrap();
     assert_eq!(client.get_bridge_fee(), 100i128);
 }
 
@@ -126,9 +126,9 @@ fn test_set_min_validators() {
     let fee_recipient = Address::generate(&env);
 
     let client = TeachLinkBridgeClient::new(&env, &contract_id);
-    client.initialize(&token, &admin, &2, &fee_recipient);
+    client.initialize(&token, &admin, &2, &fee_recipient).unwrap();
 
     env.mock_all_auths();
-    client.set_min_validators(&3);
+    client.set_min_validators(&3).unwrap();
     // Verify by attempting complete_bridge with insufficient validators
 }
diff --git a/contracts/teachlink/tests/test_escrow.rs b/contracts/teachlink/tests/test_escrow.rs
index 06f3b81..9639b85 100644
--- a/contracts/teachlink/tests/test_escrow.rs
+++ b/contracts/teachlink/tests/test_escrow.rs
@@ -1,8 +1,8 @@
 use soroban_sdk::{
-    contract, contractclient, contractimpl, symbol_short, Address, Bytes, Env, Map, Vec,
+    contract, contractclient, contractimpl, symbol_short, testutils::Address as _, Address, Bytes, Env, Map, Vec,
 };
 
-use teachlink_contract::{DisputeOutcome, EscrowStatus, TeachLinkBridge, TeachLinkBridgeClient};
+use teachlink_contract::{BridgeError, DisputeOutcome, EscrowStatus, TeachLinkBridge, TeachLinkBridgeClient};
 
 #[contract]
 pub struct TestToken;
@@ -100,14 +100,14 @@ fn test_escrow_release_flow() {
         &None,
         &None,
         &arbitrator,
-    );
+    ).unwrap();
 
     assert_eq!(token_client.balance(&depositor), 500);
     assert_eq!(token_client.balance(&escrow_contract_id), 500);
 
-    escrow_client.approve_escrow_release(&escrow_id, &signer1);
-    escrow_client.approve_escrow_release(&escrow_id, &signer2);
-    escrow_client.release_escrow(&escrow_id, &signer1);
+    escrow_client.approve_escrow_release(&escrow_id, &signer1).unwrap();
+    escrow_client.approve_escrow_release(&escrow_id, &signer2).unwrap();
+    escrow_client.release_escrow(&escrow_id, &signer1).unwrap();
 
     assert_eq!(token_client.balance(&beneficiary), 500);
     assert_eq!(token_client.balance(&escrow_contract_id), 0);
@@ -148,11 +148,11 @@ fn test_escrow_dispute_refund() {
         &None,
         &None,
         &arbitrator,
-    );
+    ).unwrap();
 
     let reason = Bytes::from_slice(&env, b"delay");
-    escrow_client.dispute_escrow(&escrow_id, &beneficiary, &reason);
-    escrow_client.resolve_escrow(&escrow_id, &arbitrator, &DisputeOutcome::RefundToDepositor);
+    escrow_client.dispute_escrow(&escrow_id, &beneficiary, &reason).unwrap();
+    escrow_client.resolve_escrow(&escrow_id, &arbitrator, &DisputeOutcome::RefundToDepositor).unwrap();
 
     assert_eq!(token_client.balance(&depositor), 800);
     let escrow = escrow_client.get_escrow(&escrow_id).unwrap();