From 8e3f0f7a8e66b44379929058f05d3899bf9380ea Mon Sep 17 00:00:00 2001 From: Chris Guimaraes Date: Tue, 5 Aug 2025 14:08:44 -0300 Subject: [PATCH 1/4] disabling cost-tracking on block replay --- stackslib/src/cli.rs | 17 +---------------- 1 file changed, 1 insertion(+), 16 deletions(-) diff --git a/stackslib/src/cli.rs b/stackslib/src/cli.rs index 2d59f2d1de..c7b7d0ab8e 100644 --- a/stackslib/src/cli.rs +++ b/stackslib/src/cli.rs @@ -828,13 +828,7 @@ fn replay_block( 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}"); + info!("Cost check skipped. Block processed successfully! block = {block_id}"); } Err(e) => { println!("Failed processing block! block = {block_id}, error = {e:?}"); @@ -1143,15 +1137,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); From a022610985f28ec463aea4f34d04700fe860f6d2 Mon Sep 17 00:00:00 2001 From: Chris Guimaraes Date: Wed, 13 Aug 2025 10:36:17 -0300 Subject: [PATCH 2/4] add missing cost tracking errors --- clarity/src/vm/clarity_wasm.rs | 26 ++++++++++++++++++++++++++ stackslib/src/cli.rs | 7 +++++-- 2 files changed, 31 insertions(+), 2 deletions(-) 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 c7b7d0ab8e..9aa2e4e503 100644 --- a/stackslib/src/cli.rs +++ b/stackslib/src/cli.rs @@ -827,7 +827,7 @@ fn replay_block( block_am.weight(), true, ) { - Ok((receipt, _, _)) => { + Ok((_, _, _)) => { info!("Cost check skipped. Block processed successfully! block = {block_id}"); } Err(e) => { @@ -863,7 +863,10 @@ 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() From f9cb19df48be175084b89a4781d093df74f334a8 Mon Sep 17 00:00:00 2001 From: Chris Guimaraes Date: Mon, 18 Aug 2025 20:37:57 +0100 Subject: [PATCH 3/4] catch error --- stackslib/src/cli.rs | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/stackslib/src/cli.rs b/stackslib/src/cli.rs index 9aa2e4e503..1b9fb49067 100644 --- a/stackslib/src/cli.rs +++ b/stackslib/src/cli.rs @@ -871,8 +871,9 @@ fn replay_naka_staging_block(db_path: &str, index_block_hash_hex: &str, conf: &C let (block, block_size) = chainstate .nakamoto_blocks_db() .get_nakamoto_block(&block_id) - .unwrap() - .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(); } From 601677edd30be35730d9ab92125f73784e5e583a Mon Sep 17 00:00:00 2001 From: Chris Guimaraes Date: Tue, 19 Aug 2025 07:57:33 +0100 Subject: [PATCH 4/4] catch error --- stackslib/src/cli.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/stackslib/src/cli.rs b/stackslib/src/cli.rs index 1b9fb49067..5cec8818a4 100644 --- a/stackslib/src/cli.rs +++ b/stackslib/src/cli.rs @@ -874,7 +874,8 @@ fn replay_naka_staging_block(db_path: &str, index_block_hash_hex: &str, conf: &C .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(); + replay_block_nakamoto(&mut sortdb, &mut chainstate, &block, block_size) + .unwrap_or_else(|e| panic!("ERROR replaying block: {:?}", e)); } fn replay_block_nakamoto(