Merge branch 'develop' of https://github.com/stacks-network/stacks-core into feat/send-signer-state-updates

Author: jferrant

CHANGELOG.md

@@ -10,6 +10,7 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
 ### Added
 
 - Add fee information to transaction log ending with "success" or "skipped", while building a new block
+- Add `max_execution_time_secs` to miner config for limiting duration of contract calls
 - When a miner's config file is updated (ie with a new fee rate), a new block commit is issued using
   the new values ([#5924](https://github.com/stacks-network/stacks-core/pull/5924))
 

clarity/src/vm/analysis/errors.rs

@@ -194,6 +194,9 @@ pub enum CheckErrors {
 
     WriteAttemptedInReadOnly,
     AtBlockClosureMustBeReadOnly,
+
+    // time checker errors
+    ExecutionTimeExpired,
 }
 
 #[derive(Debug, PartialEq)]
@@ -277,6 +280,7 @@ impl From<CostErrors> for CheckErrors {
                 CheckErrors::Expects("Unexpected interpreter failure in cost computation".into())
             }
             CostErrors::Expect(s) => CheckErrors::Expects(s),
+            CostErrors::ExecutionTimeExpired => CheckErrors::ExecutionTimeExpired,
         }
     }
 }
@@ -466,6 +470,7 @@ impl DiagnosableError for CheckErrors {
             CheckErrors::UncheckedIntermediaryResponses => "intermediary responses in consecutive statements must be checked".into(),
             CheckErrors::CostComputationFailed(s) => format!("contract cost computation failed: {}", s),
             CheckErrors::CouldNotDetermineSerializationType => "could not determine the input type for the serialization function".into(),
+            CheckErrors::ExecutionTimeExpired => "execution time expired".into(),
         }
     }
 

clarity/src/vm/ast/errors.rs

@@ -92,6 +92,8 @@ pub enum ParseErrors {
     UnexpectedParserFailure,
     /// Should be an unreachable failure which invalidates the transaction
     InterpreterFailure,
+
+    ExecutionTimeExpired,
 }
 
 #[derive(Debug, PartialEq)]
@@ -173,6 +175,7 @@ impl From<CostErrors> for ParseError {
             CostErrors::InterpreterFailure | CostErrors::Expect(_) => {
                 ParseError::new(ParseErrors::InterpreterFailure)
             }
+            CostErrors::ExecutionTimeExpired => ParseError::new(ParseErrors::ExecutionTimeExpired),
         }
     }
 }
@@ -299,6 +302,7 @@ impl DiagnosableError for ParseErrors {
             ParseErrors::NoteToMatchThis(token) => format!("to match this '{}'", token),
             ParseErrors::UnexpectedParserFailure => "unexpected failure while parsing".to_string(),
             ParseErrors::InterpreterFailure => "unexpected failure while parsing".to_string(),
+            ParseErrors::ExecutionTimeExpired => "max execution time expired".to_string(),
         }
     }
 

clarity/src/vm/clarity.rs

@@ -61,6 +61,9 @@ impl From<CheckError> for Error {
             CheckErrors::MemoryBalanceExceeded(_a, _b) => {
                 Error::CostError(ExecutionCost::max_value(), ExecutionCost::max_value())
             }
+            CheckErrors::ExecutionTimeExpired => {
+                Error::CostError(ExecutionCost::max_value(), ExecutionCost::max_value())
+            }
             _ => Error::Analysis(e),
         }
     }
@@ -75,6 +78,9 @@ impl From<InterpreterError> for Error {
             InterpreterError::Unchecked(CheckErrors::CostOverflow) => {
                 Error::CostError(ExecutionCost::max_value(), ExecutionCost::max_value())
             }
+            InterpreterError::Unchecked(CheckErrors::ExecutionTimeExpired) => {
+                Error::CostError(ExecutionCost::max_value(), ExecutionCost::max_value())
+            }
             _ => Error::Interpreter(e),
         }
     }
@@ -90,6 +96,9 @@ impl From<ParseError> for Error {
             ParseErrors::MemoryBalanceExceeded(_a, _b) => {
                 Error::CostError(ExecutionCost::max_value(), ExecutionCost::max_value())
             }
+            ParseErrors::ExecutionTimeExpired => {
+                Error::CostError(ExecutionCost::max_value(), ExecutionCost::max_value())
+            }
             _ => Error::Parse(e),
         }
     }
@@ -284,6 +293,7 @@ pub trait TransactionConnection: ClarityConnection {
     /// abort_call_back is called with an AssetMap and a ClarityDatabase reference,
     ///   if abort_call_back returns true, all modifications from this transaction will be rolled back.
     ///      otherwise, they will be committed (though they may later be rolled back if the block itself is rolled back).
+    #[allow(clippy::too_many_arguments)]
     fn run_contract_call<F>(
         &mut self,
         sender: &PrincipalData,
@@ -292,6 +302,7 @@ pub trait TransactionConnection: ClarityConnection {
         public_function: &str,
         args: &[Value],
         abort_call_back: F,
+        max_execution_time: Option<std::time::Duration>,
     ) -> Result<(Value, AssetMap, Vec<StacksTransactionEvent>), Error>
     where
         F: FnOnce(&AssetMap, &mut ClarityDatabase) -> bool,
@@ -303,6 +314,11 @@ pub trait TransactionConnection: ClarityConnection {
 
         self.with_abort_callback(
             |vm_env| {
+                if let Some(max_execution_time_duration) = max_execution_time {
+                    vm_env
+                        .context
+                        .set_max_execution_time(max_execution_time_duration);
+                }
                 vm_env
                     .execute_transaction(
                         sender.clone(),
@@ -329,6 +345,7 @@ pub trait TransactionConnection: ClarityConnection {
     /// abort_call_back is called with an AssetMap and a ClarityDatabase reference,
     ///   if abort_call_back returns true, all modifications from this transaction will be rolled back.
     ///      otherwise, they will be committed (though they may later be rolled back if the block itself is rolled back).
+    #[allow(clippy::too_many_arguments)]
     fn initialize_smart_contract<F>(
         &mut self,
         identifier: &QualifiedContractIdentifier,
@@ -337,12 +354,18 @@ pub trait TransactionConnection: ClarityConnection {
         contract_str: &str,
         sponsor: Option<PrincipalData>,
         abort_call_back: F,
+        max_execution_time: Option<std::time::Duration>,
     ) -> Result<(AssetMap, Vec<StacksTransactionEvent>), Error>
     where
         F: FnOnce(&AssetMap, &mut ClarityDatabase) -> bool,
     {
         let (_, asset_map, events, aborted) = self.with_abort_callback(
             |vm_env| {
+                if let Some(max_execution_time_duration) = max_execution_time {
+                    vm_env
+                        .context
+                        .set_max_execution_time(max_execution_time_duration);
+                }
                 vm_env
                     .initialize_contract_from_ast(
                         identifier.clone(),

clarity/src/vm/contexts.rs

@@ -17,6 +17,7 @@
 use std::collections::BTreeMap;
 use std::fmt;
 use std::mem::replace;
+use std::time::{Duration, Instant};
 
 use hashbrown::{HashMap, HashSet};
 use serde::Serialize;
@@ -181,6 +182,17 @@ pub struct EventBatch {
     pub events: Vec<StacksTransactionEvent>,
 }
 
+/** ExecutionTimeTracker keeps track of how much time a contract call is taking.
+   It is checked at every eval call.
+*/
+pub enum ExecutionTimeTracker {
+    NoTracking,
+    MaxTime {
+        start_time: Instant,
+        max_duration: Duration,
+    },
+}
+
 /** GlobalContext represents the outermost context for a single transaction's
      execution. It tracks an asset changes that occurred during the
      processing of the transaction, whether or not the current context is read_only,
@@ -199,6 +211,7 @@ pub struct GlobalContext<'a, 'hooks> {
     /// This is the chain ID of the transaction
     pub chain_id: u32,
     pub eval_hooks: Option<Vec<&'hooks mut dyn EvalHook>>,
+    pub execution_time_tracker: ExecutionTimeTracker,
 }
 
 #[derive(Serialize, Deserialize, Clone)]
@@ -1553,13 +1566,21 @@ impl<'a, 'hooks> GlobalContext<'a, 'hooks> {
             epoch_id,
             chain_id,
             eval_hooks: None,
+            execution_time_tracker: ExecutionTimeTracker::NoTracking,
         }
     }
 
     pub fn is_top_level(&self) -> bool {
         self.asset_maps.is_empty()
     }
 
+    pub fn set_max_execution_time(&mut self, max_execution_time: Duration) {
+        self.execution_time_tracker = ExecutionTimeTracker::MaxTime {
+            start_time: Instant::now(),
+            max_duration: max_execution_time,
+        }
+    }
+
     fn get_asset_map(&mut self) -> Result<&mut AssetMap> {
         self.asset_maps
             .last_mut()

clarity/src/vm/costs/mod.rs

@@ -414,6 +414,7 @@ pub enum CostErrors {
     CostContractLoadFailure,
     InterpreterFailure,
     Expect(String),
+    ExecutionTimeExpired,
 }
 
 impl CostErrors {

clarity/src/vm/mod.rs

@@ -55,6 +55,7 @@ pub mod clarity;
 
 use std::collections::BTreeMap;
 
+use costs::CostErrors;
 use serde_json;
 use stacks_common::types::StacksEpochId;
 
@@ -63,10 +64,10 @@ use self::ast::ContractAST;
 use self::costs::ExecutionCost;
 use self::diagnostic::Diagnostic;
 use crate::vm::callables::CallableType;
-use crate::vm::contexts::GlobalContext;
 pub use crate::vm::contexts::{
     CallStack, ContractContext, Environment, LocalContext, MAX_CONTEXT_DEPTH,
 };
+use crate::vm::contexts::{ExecutionTimeTracker, GlobalContext};
 use crate::vm::costs::cost_functions::ClarityCostFunction;
 use crate::vm::costs::{
     runtime_cost, CostOverflowingMath, CostTracker, LimitedCostTracker, MemoryConsumer,
@@ -303,6 +304,22 @@ pub fn apply(
     }
 }
 
+fn check_max_execution_time_expired(global_context: &GlobalContext) -> Result<()> {
+    match global_context.execution_time_tracker {
+        ExecutionTimeTracker::NoTracking => Ok(()),
+        ExecutionTimeTracker::MaxTime {
+            start_time,
+            max_duration,
+        } => {
+            if start_time.elapsed() >= max_duration {
+                Err(CostErrors::ExecutionTimeExpired.into())
+            } else {
+                Ok(())
+            }
+        }
+    }
+}
+
 pub fn eval(
     exp: &SymbolicExpression,
     env: &mut Environment,
@@ -312,6 +329,8 @@ pub fn eval(
         Atom, AtomValue, Field, List, LiteralValue, TraitReference,
     };
 
+    check_max_execution_time_expired(env.global_context)?;
+
     if let Some(mut eval_hooks) = env.global_context.eval_hooks.take() {
         for hook in eval_hooks.iter_mut() {
             hook.will_begin_eval(env, context, exp);
@@ -502,13 +521,17 @@ pub fn execute_on_network(program: &str, use_mainnet: bool) -> Result<Option<Val
 
 /// Runs `program` in a test environment with the provided parameters.
 #[cfg(any(test, feature = "testing"))]
-pub fn execute_with_parameters(
+pub fn execute_with_parameters_and_call_in_global_context<F>(
     program: &str,
     clarity_version: ClarityVersion,
     epoch: StacksEpochId,
     ast_rules: ast::ASTRules,
     use_mainnet: bool,
-) -> Result<Option<Value>> {
+    mut global_context_function: F,
+) -> Result<Option<Value>>
+where
+    F: FnMut(&mut GlobalContext) -> Result<()>,
+{
     use crate::vm::database::MemoryBackingStore;
     use crate::vm::tests::test_only_mainnet_to_chain_id;
     use crate::vm::types::QualifiedContractIdentifier;
@@ -526,6 +549,7 @@ pub fn execute_with_parameters(
         epoch,
     );
     global_context.execute(|g| {
+        global_context_function(g)?;
         let parsed = ast::build_ast_with_rules(
             &contract_id,
             program,
@@ -539,6 +563,24 @@ pub fn execute_with_parameters(
     })
 }
 
+#[cfg(any(test, feature = "testing"))]
+pub fn execute_with_parameters(
+    program: &str,
+    clarity_version: ClarityVersion,
+    epoch: StacksEpochId,
+    ast_rules: ast::ASTRules,
+    use_mainnet: bool,
+) -> Result<Option<Value>> {
+    execute_with_parameters_and_call_in_global_context(
+        program,
+        clarity_version,
+        epoch,
+        ast_rules,
+        use_mainnet,
+        |_| Ok(()),
+    )
+}
+
 /// Execute for test with `version`, Epoch20, testnet.
 #[cfg(any(test, feature = "testing"))]
 pub fn execute_against_version(program: &str, version: ClarityVersion) -> Result<Option<Value>> {
@@ -563,6 +605,25 @@ pub fn execute(program: &str) -> Result<Option<Value>> {
     )
 }
 
+/// Execute for test in Clarity1, Epoch20, testnet.
+#[cfg(any(test, feature = "testing"))]
+pub fn execute_with_limited_execution_time(
+    program: &str,
+    max_execution_time: std::time::Duration,
+) -> Result<Option<Value>> {
+    execute_with_parameters_and_call_in_global_context(
+        program,
+        ClarityVersion::Clarity1,
+        StacksEpochId::Epoch20,
+        ast::ASTRules::PrecheckSize,
+        false,
+        |g| {
+            g.set_max_execution_time(max_execution_time);
+            Ok(())
+        },
+    )
+}
+
 /// Execute for test in Clarity2, Epoch21, testnet.
 #[cfg(any(test, feature = "testing"))]
 pub fn execute_v2(program: &str) -> Result<Option<Value>> {

clarity/src/vm/tests/simple_apply_eval.rs

@@ -14,6 +14,8 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+use std::time::Duration;
+
 use rstest::rstest;
 use rstest_reuse::{self, *};
 use stacks_common::address::{
@@ -37,8 +39,10 @@ use crate::vm::types::{
     StacksAddressExtensions, TypeSignature,
 };
 use crate::vm::{
-    eval, execute as vm_execute, execute_v2 as vm_execute_v2, execute_with_parameters, CallStack,
-    ClarityVersion, ContractContext, Environment, GlobalContext, LocalContext, Value,
+    eval, execute as vm_execute, execute_v2 as vm_execute_v2,
+    execute_with_limited_execution_time as vm_execute_with_limited_execution_time,
+    execute_with_parameters, CallStack, ClarityVersion, ContractContext, CostErrors, Environment,
+    GlobalContext, LocalContext, Value,
 };
 
 #[test]
@@ -1763,3 +1767,13 @@ fn test_chain_id() {
             )
         });
 }
+
+#[test]
+fn test_execution_time_expiration() {
+    assert_eq!(
+        vm_execute_with_limited_execution_time("(+ 1 1)", Duration::from_secs(0))
+            .err()
+            .unwrap(),
+        CostErrors::ExecutionTimeExpired.into()
+    );
+}

libsigner/src/v0/messages.rs

@@ -1040,14 +1040,14 @@ impl std::fmt::Display for BlockResponse {
             BlockResponse::Accepted(a) => {
                 write!(
                     f,
-                    "BlockAccepted: signer_sighash = {}, signature = {}, version = {}",
+                    "BlockAccepted: signer_signature_hash = {}, signature = {}, version = {}",
                     a.signer_signature_hash, a.signature, a.metadata.server_version
                 )
             }
             BlockResponse::Rejected(r) => {
                 write!(
                     f,
-                    "BlockRejected: signer_sighash = {}, code = {}, reason = {}, signature = {}, version = {}",
+                    "BlockRejected: signer_signature_hash = {}, code = {}, reason = {}, signature = {}, version = {}",
                     r.reason_code, r.reason, r.signer_signature_hash, r.signature, r.metadata.server_version
                 )
             }