Merge remote-tracking branch 'upstream/develop' into feat/stacks-profiler

Author: cylewitruk-stacks

Cargo.lock

@@ -0,0 +1 @@
+Moved `StacksTransaction` and its supporting types (`TransactionAuth`, `*SpendingCondition`, `TransactionPayload`, `ClarityVersion`, `StacksMicroblockHeader`, `Txid`, `StacksString`, `TenureChangePayload`, and related) from `stackslib` into the `stacks-codec` crate ([#7200](https://github.com/stacks-network/stacks-core/pull/7200))

changelog.d/7200-move-stacks-transaction-to-codec.changed

@@ -0,0 +1 @@
+Added documentation for the arithmetic checker

changelog.d/arithmetic-checker.added

@@ -27,11 +27,13 @@ pub use stacks_common::{
 pub mod errors;
 pub mod representations;
 pub mod types;
+pub mod version;
 
 pub use errors::{ClarityTypeError, IncomparableError};
 pub use representations::{ClarityName, ContractName};
 use stacks_common::types::StacksEpochId;
 pub use types::Value;
+pub use version::ClarityVersion;
 
 /// Max call stack depth for Epoch 3.4+.
 const MAX_CALL_STACK_DEPTH: u64 = 128;

clarity-types/src/lib.rs

@@ -0,0 +1,153 @@
+// Copyright (C) 2026 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// 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::fmt;
+use std::str::FromStr;
+
+use stacks_common::types::StacksEpochId;
+
+#[derive(Serialize, Deserialize, Clone, Copy, Debug, PartialEq, PartialOrd)]
+pub enum ClarityVersion {
+    Clarity1,
+    Clarity2,
+    Clarity3,
+    Clarity4,
+    Clarity5,
+}
+
+impl fmt::Display for ClarityVersion {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ClarityVersion::Clarity1 => write!(f, "Clarity 1"),
+            ClarityVersion::Clarity2 => write!(f, "Clarity 2"),
+            ClarityVersion::Clarity3 => write!(f, "Clarity 3"),
+            ClarityVersion::Clarity4 => write!(f, "Clarity 4"),
+            ClarityVersion::Clarity5 => write!(f, "Clarity 5"),
+        }
+    }
+}
+
+impl ClarityVersion {
+    pub const fn latest() -> ClarityVersion {
+        ClarityVersion::Clarity5
+    }
+
+    pub const ALL: &'static [ClarityVersion] = &[
+        ClarityVersion::Clarity1,
+        ClarityVersion::Clarity2,
+        ClarityVersion::Clarity3,
+        ClarityVersion::Clarity4,
+        ClarityVersion::Clarity5,
+    ];
+
+    /// Returns all [`ClarityVersion`] starting from the given `version` (inclusive)
+    #[cfg(any(test, feature = "testing"))]
+    pub fn since(version: ClarityVersion) -> &'static [ClarityVersion] {
+        let idx = Self::ALL
+            .iter()
+            .position(|&v| v == version)
+            .expect("version not found in ALL");
+
+        &Self::ALL[idx..]
+    }
+
+    /// Returns all [`ClarityVersion`] up to the given `version` (inclusive)
+    #[cfg(any(test, feature = "testing"))]
+    pub fn up_to(version: ClarityVersion) -> &'static [ClarityVersion] {
+        let idx = Self::ALL
+            .iter()
+            .position(|&v| v == version)
+            .expect("version not found in ALL");
+
+        &Self::ALL[..=idx]
+    }
+
+    pub fn default_for_epoch(epoch_id: StacksEpochId) -> ClarityVersion {
+        match epoch_id {
+            // Clarity does not exist in Epoch 1.0; callers that hit this branch are buggy.
+            StacksEpochId::Epoch10 => ClarityVersion::Clarity1,
+            StacksEpochId::Epoch20 => ClarityVersion::Clarity1,
+            StacksEpochId::Epoch2_05 => ClarityVersion::Clarity1,
+            StacksEpochId::Epoch21 => ClarityVersion::Clarity2,
+            StacksEpochId::Epoch22 => ClarityVersion::Clarity2,
+            StacksEpochId::Epoch23 => ClarityVersion::Clarity2,
+            StacksEpochId::Epoch24 => ClarityVersion::Clarity2,
+            StacksEpochId::Epoch25 => ClarityVersion::Clarity2,
+            StacksEpochId::Epoch30 => ClarityVersion::Clarity3,
+            StacksEpochId::Epoch31 => ClarityVersion::Clarity3,
+            StacksEpochId::Epoch32 => ClarityVersion::Clarity3,
+            StacksEpochId::Epoch33 => ClarityVersion::Clarity4,
+            StacksEpochId::Epoch34 => ClarityVersion::Clarity5,
+        }
+    }
+
+    pub fn supports_callables(&self) -> bool {
+        match self {
+            ClarityVersion::Clarity1 => false,
+            ClarityVersion::Clarity2
+            | ClarityVersion::Clarity3
+            | ClarityVersion::Clarity4
+            | ClarityVersion::Clarity5 => true,
+        }
+    }
+
+    pub fn uses_secp256r1_double_hashing(&self) -> bool {
+        match self {
+            ClarityVersion::Clarity1
+            | ClarityVersion::Clarity2
+            | ClarityVersion::Clarity3
+            | ClarityVersion::Clarity4 => true,
+            ClarityVersion::Clarity5 => false,
+        }
+    }
+
+    /// Beginning in Clarity 5, cost functions that call `logn` are ensured to
+    /// always pass an argument greater than zero, to avoid hitting a runtime
+    /// error during cost computation. After reviewing the usage, the only
+    /// function that requires this protection is `from-consensus-buff?`, other
+    /// cost functions that call `logn` are already protected from zeros.
+    pub fn protects_logn_cost_fn(&self) -> bool {
+        match self {
+            ClarityVersion::Clarity1
+            | ClarityVersion::Clarity2
+            | ClarityVersion::Clarity3
+            | ClarityVersion::Clarity4 => false,
+            ClarityVersion::Clarity5 => true,
+        }
+    }
+}
+
+impl FromStr for ClarityVersion {
+    type Err = &'static str;
+
+    fn from_str(version: &str) -> Result<ClarityVersion, &'static str> {
+        let s = version.to_string().to_lowercase();
+        if s == "clarity1" {
+            Ok(ClarityVersion::Clarity1)
+        } else if s == "clarity2" {
+            Ok(ClarityVersion::Clarity2)
+        } else if s == "clarity3" {
+            Ok(ClarityVersion::Clarity3)
+        } else if s == "clarity4" {
+            Ok(ClarityVersion::Clarity4)
+        } else if s == "clarity5" {
+            Ok(ClarityVersion::Clarity5)
+        } else {
+            Err(
+                "Invalid clarity version. Valid versions are: Clarity1, Clarity2, Clarity3, Clarity4, Clarity5.",
+            )
+        }
+    }
+}

clarity-types/src/version.rs

@@ -14,6 +14,34 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+//! Static-analysis pass that decides whether a contract is eligible to be
+//! installed as a *cost-function* contract under the SIP-006 cost-voting
+//! system.
+//!
+//! A cost-function contract supplies a Clarity function that the VM invokes
+//! on every call to a native operation in order to compute that operation's
+//! runtime/read/write cost. Because such functions run inside the cost
+//! accounting path itself, they must be:
+//!
+//! - **Deterministic**: no chain-state reads (`block-height`, `tx-sender`,
+//!   `contract-caller`, `chain-id`, ...), no `contract-call?`.
+//! - **Side-effect free**: no map/var/FT/NFT defines or mutations, no STX
+//!   transfers, no asset mints or burns, no `print`.
+//! - **Bounded**: no `map`/`fold`/`filter`/list-cons or other iterating
+//!   constructs whose work scales with input size — the cost function must
+//!   itself be cheap and predictable.
+//! - **Trait-free**: traits introduce dynamic dispatch that the cost
+//!   accountant cannot reason about statically.
+//! - **Cheap**: only a restricted, predictable, constant-time subset of
+//!   native forms is allowed, including arithmetic/logic and certain simple
+//!   expression-building constructs.
+//!
+//! The pass walks every top-level form and expression and rejects anything
+//! outside the set of allowed constructs. The result is stored in
+//! [`ContractAnalysis::is_cost_contract_eligible`]; the cost-voting
+//! machinery in `vm::costs` later refuses to adopt a proposal whose target
+//! contract is not eligible.
+
 use clarity_types::representations::ClarityName;
 
 pub use super::errors::{