aac: runtime check error to expect acceptable

clarity/fuzz/fuzz_targets/fuzz_sanitize.rs

@@ -245,9 +245,9 @@ pub fn strict_admits(me: &TypeSignature, x: &ClarityValue) -> Result<bool, Runti
         }
         TypeSignature::CallableType(_)
         | TypeSignature::ListUnionType(_)
-        | TypeSignature::TraitReferenceType(_) => Err(
-            RuntimeCheckErrorKind::TraitReferenceUnknown("Unknown trait reference".into()),
-        ),
+        | TypeSignature::TraitReferenceType(_) => Err(RuntimeCheckErrorKind::ExpectsAcceptable(
+            "Trait reference unknown".into(),
+        )),
     }
 }
 

clarity/fuzz/fuzz_targets/fuzz_value_sanitize.rs

@@ -251,8 +251,8 @@ pub fn strict_admits(me: &TypeSignature, x: &ClarityValue) -> Result<bool, Runti
         }
         TypeSignature::CallableType(_)
         | TypeSignature::ListUnionType(_)
-        | TypeSignature::TraitReferenceType(_) => Err(RuntimeCheckErrorKind::TraitReferenceUnknown(
-            "Unknown trait reference".into(),
+        | TypeSignature::TraitReferenceType(_) => Err(RuntimeCheckErrorKind::ExpectsAcceptable(
+            "Trait reference unknown".into(),
         )),
     }
 }

clarity/src/vm/callables.rs

@@ -329,16 +329,16 @@ impl DefinedFunction {
         let trait_name = trait_identifier.name.to_string();
         let constraining_trait = contract_defining_trait
             .lookup_trait_definition(&trait_name)
-            .ok_or(RuntimeCheckErrorKind::TraitReferenceUnknown(
-                trait_name.to_string(),
-            ))?;
+            .ok_or(RuntimeCheckErrorKind::ExpectsAcceptable(format!(
+                "Trait reference unknown: {trait_name}"
+            )))?;
         let expected_sig =
             constraining_trait
                 .get(&self.name)
-                .ok_or(RuntimeCheckErrorKind::TraitMethodUnknown(
-                    trait_name.to_string(),
-                    self.name.to_string(),
-                ))?;
+                .ok_or(RuntimeCheckErrorKind::ExpectsAcceptable(format!(
+                    "Trait method unknown: {trait_name}.{}",
+                    self.name
+                )))?;
 
         let args = self.arg_types.to_vec();
         if !expected_sig.check_args_trait_compliance(epoch, args)? {

clarity/src/vm/contexts.rs

@@ -1170,7 +1170,7 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> {
             if !allow_private && !func.is_public() {
                 return Err(RuntimeCheckErrorKind::NoSuchPublicFunction(contract_identifier.to_string(), tx_name.to_string()).into());
             } else if read_only && !func.is_read_only() {
-                return Err(RuntimeCheckErrorKind::PublicFunctionNotReadOnly(contract_identifier.to_string(), tx_name.to_string()).into());
+                return Err(RuntimeCheckErrorKind::ExpectsAcceptable(format!("Public function not read-only: {contract_identifier} {tx_name}")).into());
             }
 
             let args: Result<Vec<Value>, VmExecutionError> = args.iter()
@@ -1338,9 +1338,9 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> {
                 .database
                 .has_contract(&contract_identifier)
             {
-                return Err(RuntimeCheckErrorKind::ContractAlreadyExists(
-                    contract_identifier.to_string(),
-                )
+                return Err(RuntimeCheckErrorKind::ExpectsAcceptable(format!(
+                    "Contract already exists: {contract_identifier}"
+                ))
                 .into());
             }
 
@@ -1876,12 +1876,11 @@ impl<'a, 'hooks> GlobalContext<'a, 'hooks> {
                 self.commit()?;
                 Ok(result)
             } else {
-                Err(
-                    RuntimeCheckErrorKind::PublicFunctionMustReturnResponse(Box::new(
-                        TypeSignature::type_of(&result)?,
-                    ))
-                    .into(),
-                )
+                Err(RuntimeCheckErrorKind::ExpectsAcceptable(format!(
+                    "Public function must return response: {}",
+                    TypeSignature::type_of(&result)?
+                ))
+                .into())
             }
         } else {
             self.roll_back()?;
@@ -2504,9 +2503,11 @@ mod test {
             .initialize_contract_from_ast(contract_id.clone(), version, &ast, contract_src)
             .unwrap_err();
 
-        assert!(matches!(
+        assert_eq!(
             err,
-            VmExecutionError::RuntimeCheck(RuntimeCheckErrorKind::ContractAlreadyExists(_))
-        ));
+            VmExecutionError::RuntimeCheck(RuntimeCheckErrorKind::ExpectsAcceptable(
+                "Contract already exists: S1G2081040G2081040G2081040G208105NK8PE5.dup".to_string()
+            ))
+        );
     }
 }

clarity/src/vm/database/clarity_db.rs

@@ -1537,8 +1537,12 @@ impl ClarityDatabase<'_> {
     ) -> Result<DataVariableMetadata, VmExecutionError> {
         let key = ClarityDatabase::make_metadata_key(StoreType::VariableMeta, variable_name);
 
-        map_no_contract_as_none(self.fetch_metadata(contract_identifier, &key))?
-            .ok_or(RuntimeCheckErrorKind::NoSuchDataVariable(variable_name.to_string()).into())
+        map_no_contract_as_none(self.fetch_metadata(contract_identifier, &key))?.ok_or(
+            RuntimeCheckErrorKind::ExpectsAcceptable(format!(
+                "No such data variable: {variable_name}"
+            ))
+            .into(),
+        )
     }
 
     #[cfg(any(test, feature = "testing"))]
@@ -1678,8 +1682,9 @@ impl ClarityDatabase<'_> {
     ) -> Result<DataMapMetadata, VmExecutionError> {
         let key = ClarityDatabase::make_metadata_key(StoreType::DataMapMeta, map_name);
 
-        map_no_contract_as_none(self.fetch_metadata(contract_identifier, &key))?
-            .ok_or(RuntimeCheckErrorKind::NoSuchMap(map_name.to_string()).into())
+        map_no_contract_as_none(self.fetch_metadata(contract_identifier, &key))?.ok_or(
+            RuntimeCheckErrorKind::ExpectsAcceptable(format!("No such map: {map_name}")).into(),
+        )
     }
 
     pub fn make_key_for_data_map_entry(
@@ -2042,8 +2047,9 @@ impl ClarityDatabase<'_> {
     ) -> Result<FungibleTokenMetadata, VmExecutionError> {
         let key = ClarityDatabase::make_metadata_key(StoreType::FungibleTokenMeta, token_name);
 
-        map_no_contract_as_none(self.fetch_metadata(contract_identifier, &key))?
-            .ok_or(RuntimeCheckErrorKind::NoSuchFT(token_name.to_string()).into())
+        map_no_contract_as_none(self.fetch_metadata(contract_identifier, &key))?.ok_or(
+            RuntimeCheckErrorKind::ExpectsAcceptable(format!("No such FT: {token_name}")).into(),
+        )
     }
 
     pub fn create_non_fungible_token(
@@ -2068,8 +2074,9 @@ impl ClarityDatabase<'_> {
     ) -> Result<NonFungibleTokenMetadata, VmExecutionError> {
         let key = ClarityDatabase::make_metadata_key(StoreType::NonFungibleTokenMeta, token_name);
 
-        map_no_contract_as_none(self.fetch_metadata(contract_identifier, &key))?
-            .ok_or(RuntimeCheckErrorKind::NoSuchNFT(token_name.to_string()).into())
+        map_no_contract_as_none(self.fetch_metadata(contract_identifier, &key))?.ok_or(
+            RuntimeCheckErrorKind::ExpectsAcceptable(format!("No such NFT: {token_name}")).into(),
+        )
     }
 
     pub fn checked_increase_token_supply(

clarity/src/vm/functions/arithmetic.rs

@@ -601,10 +601,10 @@ pub fn native_bitwise_left_shift(input: Value, pos: Value) -> Result<Value, VmEx
                 let result = input.wrapping_shl(shamt);
                 Ok(Value::UInt(result))
             }
-            _ => Err(RuntimeCheckErrorKind::UnionTypeError(
-                vec![TypeSignature::IntType, TypeSignature::UIntType],
-                Box::new(TypeSignature::type_of(&input)?),
-            )
+            _ => Err(RuntimeCheckErrorKind::ExpectsAcceptable(format!(
+                "Union type error {}",
+                TypeSignature::type_of(&input)?
+            ))
             .into()),
         }
     } else {
@@ -630,10 +630,10 @@ pub fn native_bitwise_right_shift(input: Value, pos: Value) -> Result<Value, VmE
                 let result = input.wrapping_shr(shamt);
                 Ok(Value::UInt(result))
             }
-            _ => Err(RuntimeCheckErrorKind::UnionTypeError(
-                vec![TypeSignature::IntType, TypeSignature::UIntType],
-                Box::new(TypeSignature::type_of(&input)?),
-            )
+            _ => Err(RuntimeCheckErrorKind::ExpectsAcceptable(format!(
+                "Union type error {}",
+                TypeSignature::type_of(&input)?
+            ))
             .into()),
         }
     } else {