diff --git a/clarity/src/vm/clarity_wasm.rs b/clarity/src/vm/clarity_wasm.rs
index e13d1f5210..d98cbcdd4d 100644
--- a/clarity/src/vm/clarity_wasm.rs
+++ b/clarity/src/vm/clarity_wasm.rs
@@ -8900,6 +8900,7 @@ mod error_mapping {
         read_bytes_from_wasm, read_from_wasm_indirect, read_identifier_from_wasm,
         signature_from_string,
     };
+    use crate::vm::costs::CostErrors;
     use crate::vm::errors::{CheckErrors, Error, RuntimeErrorType, ShortReturnType, WasmError};
     use crate::vm::types::{OptionalData, ResponseData};
     use crate::vm::{ClarityVersion, Value};
@@ -8974,6 +8975,21 @@ mod error_mapping {
         /// Indicates an attempt to use a function with too many arguments
         ArgumentCountAtMost = 15,
 
+        /// Indicates a runtime cost overrun
+        CostOverrunRuntime = 100,
+
+        /// Indicates a read count cost overrun
+        CostOverrunReadCount = 101,
+
+        /// Indicates a read length cost overrun
+        CostOverrunReadLength = 102,
+
+        /// Indicates a write count cost overrun
+        CostOverrunWriteCount = 103,
+
+        /// Indicates a write length cost overrun
+        CostOverrunWriteLength = 104,
+
         /// A catch-all for errors that are not mapped to specific error codes.
         /// This might be used for unexpected or unclassified errors.
         NotMapped = 99,
@@ -8999,6 +9015,11 @@ mod error_mapping {
                 13 => ErrorMap::ArgumentCountMismatch,
                 14 => ErrorMap::ArgumentCountAtLeast,
                 15 => ErrorMap::ArgumentCountAtMost,
+                100 => ErrorMap::CostOverrunRuntime,
+                101 => ErrorMap::CostOverrunReadCount,
+                102 => ErrorMap::CostOverrunReadLength,
+                103 => ErrorMap::CostOverrunWriteCount,
+                104 => ErrorMap::CostOverrunWriteLength,
                 _ => ErrorMap::NotMapped,
             }
         }
@@ -9179,6 +9200,11 @@ mod error_mapping {
                 let (expected, got) = get_runtime_error_arg_lengths(&instance, &mut store);
                 Error::Unchecked(CheckErrors::RequiresAtMostArguments(expected, got))
             }
+            ErrorMap::CostOverrunRuntime => Error::from(CostErrors::CostOverflow),
+            ErrorMap::CostOverrunReadCount => Error::from(CostErrors::CostOverflow),
+            ErrorMap::CostOverrunReadLength => Error::from(CostErrors::CostOverflow),
+            ErrorMap::CostOverrunWriteCount => Error::from(CostErrors::CostOverflow),
+            ErrorMap::CostOverrunWriteLength => Error::from(CostErrors::CostOverflow),
             _ => panic!("Runtime error code {} not supported", runtime_error_code),
         }
     }
diff --git a/stackslib/src/cli.rs b/stackslib/src/cli.rs
index 2d59f2d1de..5cec8818a4 100644
--- a/stackslib/src/cli.rs
+++ b/stackslib/src/cli.rs
@@ -827,14 +827,8 @@ fn replay_block(
         block_am.weight(),
         true,
     ) {
-        Ok((receipt, _, _)) => {
-            if receipt.anchored_block_cost != cost {
-                println!("Failed processing block! block = {block_id}. Unexpected cost. expected = {cost}, evaluated = {}",
-                         receipt.anchored_block_cost);
-                process::exit(1);
-            }
-
-            info!("Block processed successfully! block = {block_id}");
+        Ok((_, _, _)) => {
+            info!("Cost check skipped. Block processed successfully! block = {block_id}");
         }
         Err(e) => {
             println!("Failed processing block! block = {block_id}, error = {e:?}");
@@ -869,14 +863,19 @@ fn replay_naka_staging_block(db_path: &str, index_block_hash_hex: &str, conf: &C
         None,
         true,
     )
-    .unwrap();
+    .unwrap_or_else(|err| {
+        eprintln!("Error: {:?}", err);
+        panic!("SortitionDB::connect failed");
+    });
 
     let (block, block_size) = chainstate
         .nakamoto_blocks_db()
         .get_nakamoto_block(&block_id)
-        .unwrap()
-        .unwrap();
-    replay_block_nakamoto(&mut sortdb, &mut chainstate, &block, block_size).unwrap();
+        .unwrap_or_else(|e| panic!("DB error fetching {:?}: {:?}", block_id, e))
+        .unwrap_or_else(|| panic!("No block found for id {:?}", block_id));
+
+    replay_block_nakamoto(&mut sortdb, &mut chainstate, &block, block_size)
+        .unwrap_or_else(|e| panic!("ERROR replaying block: {:?}", e));
 }
 
 fn replay_block_nakamoto(
@@ -1143,15 +1142,6 @@ fn replay_block_nakamoto(
         Err(e) => (None, Some(e)),
     };
 
-    if let Some(receipt) = ok_opt {
-        // check the cost
-        let evaluated_cost = receipt.anchored_block_cost.clone();
-        if evaluated_cost != expected_cost {
-            println!("Failed processing block! block = {block_id}. Unexpected cost. expected = {expected_cost}, evaluated = {evaluated_cost}");
-            process::exit(1);
-        }
-    }
-
     if let Some(e) = err_opt {
         // force rollback
         drop(chainstate_tx);