Merge branch 'develop' of https://github.com/stacks-network/stacks-core into chore/merge-develop-to-aac-client-breaking

Author: jferrant

clarity-types/src/errors/mod.rs

@@ -44,7 +44,7 @@ pub struct IncomparableError<T> {
 
 /// Errors that can occur during the runtime execution of Clarity contracts in the virtual machine.
 /// These encompass type-checking failures, interpreter issues, runtime errors, and premature returns.
-/// Unlike static analysis errors in `ClarityError::StaticCheck(CheckError)` or `ClarityError::Parse(ParseError)`,
+/// Unlike static analysis errors in `ClarityError::StaticCheck(StaticCheckError)` or `ClarityError::Parse(ParseError)`,
 /// which are caught before execution during type-checking or parsing, these errors occur during dynamic
 /// evaluation and may involve conditions not detectable statically, such as dynamically constructed expressions
 /// (e.g., based on VRF seeds or runtime data).

clarity-types/src/types/signatures.rs

@@ -875,6 +875,18 @@ impl TypeSignature {
     /// Longest ([`MAX_TO_ASCII_RESULT_LEN`]) string allowed for `to-ascii?` call.
     pub const TO_ASCII_STRING_ASCII_MAX: TypeSignature =
         Self::type_ascii_const(MAX_TO_ASCII_RESULT_LEN);
+    /// Longest string result possible for `(to-ascii? <int>)` result
+    /// e.g. "-170141183460469231731687303715884105728"
+    pub const TO_ASCII_INT_RESULT_MAX: TypeSignature = Self::type_ascii_const(40);
+    /// Longest string result possible for `(to-ascii? <uint>)` result
+    /// e.g. "u340282366920938463463374607431768211455"
+    pub const TO_ASCII_UINT_RESULT_MAX: TypeSignature = Self::type_ascii_const(40);
+    /// Longest string result possible for `(to-ascii? <bool>)` result
+    /// e.g. "false"
+    pub const TO_ASCII_BOOL_RESULT_MAX: TypeSignature = Self::type_ascii_const(5);
+    /// Longest string result possible for `(to-ascii? <principal>)` result
+    /// e.g. "ST1PQHQKV0RJXZFY1DGX8MNSNYVE3VGZJSRTPGZGM.contract-name-can-be-up-to-128-characters-long-so-41-characters-for-the-address-plus-1-for-the-dot-plus-128-for-the-name-is-170-"
+    pub const TO_ASCII_PRINCIPAL_RESULT_MAX: TypeSignature = Self::type_ascii_const(170);
 
     /// Longest ([`CONTRACT_MAX_NAME_LENGTH`]) string allowed for `contract-name`.
     pub const CONTRACT_NAME_STRING_ASCII_MAX: TypeSignature =
@@ -920,6 +932,14 @@ impl TypeSignature {
         Self::type_ascii_const(len)
     }
 
+    /// Creates a string ASCII type with the specified length.
+    /// Returns an error if the provided length is invalid.
+    pub fn new_ascii_type(len: i128) -> Result<Self, CheckErrorKind> {
+        Ok(SequenceType(SequenceSubtype::StringType(
+            StringSubtype::ASCII(BufferLength::try_from_i128(len)?),
+        )))
+    }
+
     /// If one of the types is a NoType, return Ok(the other type), otherwise return least_supertype(a, b)
     pub fn factor_out_no_type(
         epoch: &StacksEpochId,

clarity/src/vm/analysis/type_checker/v2_1/natives/conversions.rs

@@ -1,3 +1,5 @@
+use clarity_types::errors::CheckErrorKind;
+use clarity_types::types::{StringSubtype, MAX_TO_ASCII_BUFFER_LEN};
 use stacks_common::types::StacksEpochId;
 
 use super::TypeChecker;
@@ -41,3 +43,61 @@ pub fn check_special_from_consensus_buff(
     checker.type_check_expects(&args[1], context, &TypeSignature::BUFFER_MAX)?;
     TypeSignature::new_option(result_type).map_err(StaticCheckError::from)
 }
+
+/// `to-ascii?` admits exactly one argument, a value to convert to a
+/// `string-ascii`. It can be any of the following types:
+/// - `int`
+/// - `uint`
+/// - `bool`
+/// - `principal`
+/// - `(buff 524284)`
+/// - `(string-utf8 262144)`
+///
+/// It returns a `(response (string-ascii 1048571) uint)`.
+pub fn check_special_to_ascii(
+    checker: &mut TypeChecker,
+    args: &[SymbolicExpression],
+    context: &TypingContext,
+) -> Result<TypeSignature, StaticCheckError> {
+    check_argument_count(1, args)?;
+    let input_type = checker.type_check(
+        args.first()
+            .ok_or(CheckErrorKind::CheckerImplementationFailure)?,
+        context,
+    )?;
+
+    let result_type = match input_type {
+        TypeSignature::IntType => TypeSignature::TO_ASCII_INT_RESULT_MAX,
+        TypeSignature::UIntType => TypeSignature::TO_ASCII_UINT_RESULT_MAX,
+        TypeSignature::BoolType => TypeSignature::TO_ASCII_BOOL_RESULT_MAX,
+        TypeSignature::PrincipalType | TypeSignature::CallableType(_) => {
+            TypeSignature::TO_ASCII_PRINCIPAL_RESULT_MAX
+        }
+        TypeSignature::SequenceType(SequenceSubtype::BufferType(len))
+            if u32::from(len.clone()) <= MAX_TO_ASCII_BUFFER_LEN =>
+        {
+            // Each byte in the buffer becomes two ASCII characters, plus "0x" prefix
+            TypeSignature::new_ascii_type((u32::from(len) * 2 + 2).into())?
+        }
+        TypeSignature::SequenceType(SequenceSubtype::StringType(StringSubtype::UTF8(len))) => {
+            // Each UTF-8 character is exactly one ASCII character
+            TypeSignature::new_ascii_type(u32::from(len).into())?
+        }
+        _ => {
+            let types = vec![
+                TypeSignature::IntType,
+                TypeSignature::UIntType,
+                TypeSignature::BoolType,
+                TypeSignature::PrincipalType,
+                TypeSignature::TO_ASCII_BUFFER_MAX,
+                TypeSignature::STRING_UTF8_MAX,
+            ];
+            return Err(CheckErrorKind::UnionTypeError(types, input_type.into()).into());
+        }
+    };
+    Ok(
+        TypeSignature::new_response(result_type, TypeSignature::UIntType).map_err(|_| {
+            CheckErrorKind::Expects("FATAL: Legal Clarity response type marked invalid".into())
+        })?,
+    )
+}

clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs

@@ -1207,25 +1207,7 @@ impl TypedNativeFunction {
                 )
                 .map_err(|_| CheckErrorKind::Expects("Bad constructor".into()))?,
             }))),
-            ToAscii => Simple(SimpleNativeFunction(FunctionType::UnionArgs(
-                vec![
-                    TypeSignature::IntType,
-                    TypeSignature::UIntType,
-                    TypeSignature::BoolType,
-                    TypeSignature::PrincipalType,
-                    TypeSignature::TO_ASCII_BUFFER_MAX,
-                    TypeSignature::STRING_UTF8_MAX,
-                ],
-                TypeSignature::new_response(
-                    TypeSignature::TO_ASCII_STRING_ASCII_MAX,
-                    TypeSignature::UIntType,
-                )
-                .map_err(|_| {
-                    CheckErrorKind::Expects(
-                        "FATAL: Legal Clarity response type marked invalid".into(),
-                    )
-                })?,
-            ))),
+            ToAscii => Special(SpecialNativeFunction(&conversions::check_special_to_ascii)),
             RestrictAssets => Special(SpecialNativeFunction(
                 &post_conditions::check_restrict_assets,
             )),

clarity/src/vm/analysis/type_checker/v2_1/tests/contracts.rs

@@ -3511,142 +3511,3 @@ fn test_contract_hash(#[case] version: ClarityVersion, #[case] epoch: StacksEpoc
         assert_eq!(&actual, expected, "Failed for test case: {description}");
     }
 }
-
-/// Pass various types to `to-ascii?`
-#[apply(test_clarity_versions)]
-fn test_to_ascii(#[case] version: ClarityVersion, #[case] epoch: StacksEpochId) {
-    let to_ascii_response_type = Some(
-        TypeSignature::new_response(
-            TypeSignature::TO_ASCII_STRING_ASCII_MAX,
-            TypeSignature::UIntType,
-        )
-        .unwrap(),
-    );
-    let to_ascii_expected_types = vec![
-        TypeSignature::IntType,
-        TypeSignature::UIntType,
-        TypeSignature::BoolType,
-        TypeSignature::PrincipalType,
-        TypeSignature::TO_ASCII_BUFFER_MAX,
-        TypeSignature::STRING_UTF8_MAX,
-    ];
-    let test_cases = [
-        (
-            "(to-ascii? 123)",
-            "int type",
-            Ok(to_ascii_response_type.clone()),
-        ),
-        (
-            "(to-ascii? u123)",
-            "uint type",
-            Ok(to_ascii_response_type.clone()),
-        ),
-        (
-            "(to-ascii? true)",
-            "bool type",
-            Ok(to_ascii_response_type.clone()),
-        ),
-        (
-            "(to-ascii? 'ST1PQHQKV0RJXZFY1DGX8MNSNYVE3VGZJSRTPGZGM)",
-            "standard principal",
-            Ok(to_ascii_response_type.clone()),
-        ),
-        (
-            "(to-ascii? 'ST1PQHQKV0RJXZFY1DGX8MNSNYVE3VGZJSRTPGZGM.foo)",
-            "contract principal",
-            Ok(to_ascii_response_type.clone()),
-        ),
-        (
-            "(to-ascii? 0x1234)",
-            "buffer type",
-            Ok(to_ascii_response_type.clone()),
-        ),
-        (
-            &format!("(to-ascii? 0x{})", "ff".repeat(524284)),
-            "max len buffer type",
-            Ok(to_ascii_response_type.clone()),
-        ),
-        (
-            &format!("(to-ascii? 0x{})", "ff".repeat(524285)),
-            "oversized buffer type",
-            Err(CheckErrorKind::UnionTypeError(
-                to_ascii_expected_types.clone(),
-                Box::new(TypeSignature::SequenceType(SequenceSubtype::BufferType(
-                    BufferLength::try_from(524285u32).unwrap(),
-                ))),
-            )),
-        ),
-        (
-            "(to-ascii? u\"I am serious, and don't call me Shirley.\")",
-            "utf8 string",
-            Ok(to_ascii_response_type),
-        ),
-        (
-            "(to-ascii? \"60 percent of the time, it works every time\")",
-            "ascii string",
-            Err(CheckErrorKind::UnionTypeError(
-                to_ascii_expected_types.clone(),
-                Box::new(TypeSignature::SequenceType(SequenceSubtype::StringType(
-                    StringSubtype::ASCII(BufferLength::try_from(43u32).unwrap()),
-                ))),
-            )),
-        ),
-        (
-            "(to-ascii? (list 1 2 3))",
-            "list type",
-            Err(CheckErrorKind::UnionTypeError(
-                to_ascii_expected_types.clone(),
-                Box::new(TypeSignature::SequenceType(SequenceSubtype::ListType(
-                    ListTypeData::new_list(TypeSignature::IntType, 3).unwrap(),
-                ))),
-            )),
-        ),
-        (
-            "(to-ascii? { a: 1, b: u2 })",
-            "tuple type",
-            Err(CheckErrorKind::UnionTypeError(
-                to_ascii_expected_types.clone(),
-                Box::new(TypeSignature::TupleType(
-                    vec![
-                        (ClarityName::from("a"), TypeSignature::IntType),
-                        (ClarityName::from("b"), TypeSignature::UIntType),
-                    ]
-                    .try_into()
-                    .unwrap(),
-                )),
-            )),
-        ),
-        (
-            "(to-ascii? (some u789))",
-            "optional type",
-            Err(CheckErrorKind::UnionTypeError(
-                to_ascii_expected_types.clone(),
-                Box::new(TypeSignature::new_option(TypeSignature::UIntType).unwrap()),
-            )),
-        ),
-        (
-            "(to-ascii? (ok true))",
-            "response type",
-            Err(CheckErrorKind::UnionTypeError(
-                to_ascii_expected_types.clone(),
-                Box::new(
-                    TypeSignature::new_response(TypeSignature::BoolType, TypeSignature::NoType)
-                        .unwrap(),
-                ),
-            )),
-        ),
-    ];
-
-    for (source, description, clarity4_expected) in test_cases.iter() {
-        let result = mem_run_analysis(source, version, epoch);
-        let actual = result.map(|(type_sig, _)| type_sig).map_err(|e| *e.err);
-
-        let expected = if version >= ClarityVersion::Clarity4 {
-            clarity4_expected
-        } else {
-            &Err(CheckErrorKind::UnknownFunction("to-ascii?".to_string()))
-        };
-
-        assert_eq!(&actual, expected, "Failed for test case: {description}");
-    }
-}