Merge branch 'develop' into feat/stacks-inspect-improvements

Author: brice-stacks

CHANGELOG.md

@@ -9,16 +9,23 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
 
 ### Added
 
-- Fixed an issue where `event.committed` was always equal to `true` in the block replay RPC endpoint
-- Added `result_hex` and `post_condition_aborted` to the block replay RPC endpoint
-- Added `--epoch <epoch_number>` flag to `clarity-cli` commands to specify the epoch context for evaluation.
 - In the `/v3/transaction/{txid}` RPC endpoint, added `block_height` and `is_canonical` to the response.
 - Improved block validation in `stacks-inspect`.
 
 ### Changed
 
 - Removed `validate-naka-block` option in `stacks-inspect`, merging it with `validate-block` so that users do not need to differentiate between the two.
 
+## [3.3.0.0.2]
+
+### Added
+
+- Fixed an issue where `event.committed` was always equal to `true` in the block replay RPC endpoint
+- Added `result_hex` and `post_condition_aborted` to the block replay RPC endpoint
+- Added `--epoch <epoch_number>` flag to `clarity-cli` commands to specify the epoch context for evaluation.
+- Added miner support for generating read-count tenure extends
+  - Added `read_count_extend_cost_threshold` config option (in the miner config) which specifies the percentage of the block budget that must be used before attempting a time-based tenure extend. Defaults to 25%.
+
 ### Fixed
 
 - Correctly produce the receipt for the `costs-4` contract, which was deployed on epoch 3.3 activation. Users who consume node events and want to fill in the missing receipt (e.g. the Hiro API) will need to revert their chainstate to before the 3.3 activation and then resume sync to receive the previously missing event.

clarity-types/src/errors/analysis.rs

@@ -20,7 +20,7 @@ pub mod lexer;
 
 use std::{error, fmt};
 
-pub use analysis::{CheckErrorKind, StaticCheckError};
+pub use analysis::{CheckErrorKind, CommonCheckErrorKind, StaticCheckError, StaticCheckErrorKind};
 pub use ast::{ParseError, ParseErrorKind, ParseResult};
 pub use cost::CostErrors;
 pub use lexer::LexerError;
@@ -292,15 +292,21 @@ impl From<RuntimeError> for VmExecutionError {
     }
 }
 
+impl From<CommonCheckErrorKind> for VmExecutionError {
+    fn from(err: CommonCheckErrorKind) -> Self {
+        VmExecutionError::Unchecked(err.into())
+    }
+}
+
 impl From<CheckErrorKind> for VmExecutionError {
     fn from(err: CheckErrorKind) -> Self {
         VmExecutionError::Unchecked(err)
     }
 }
 
-impl From<(CheckErrorKind, &SymbolicExpression)> for VmExecutionError {
-    fn from(err: (CheckErrorKind, &SymbolicExpression)) -> Self {
-        VmExecutionError::Unchecked(err.0)
+impl From<(CommonCheckErrorKind, &SymbolicExpression)> for VmExecutionError {
+    fn from(err: (CommonCheckErrorKind, &SymbolicExpression)) -> Self {
+        VmExecutionError::Unchecked(err.0.into())
     }
 }
 

clarity-types/src/errors/mod.rs

@@ -19,6 +19,7 @@ use rstest::rstest;
 use stacks_common::types::StacksEpochId;
 
 use crate::VmExecutionError;
+use crate::errors::analysis::CommonCheckErrorKind;
 use crate::errors::{CheckErrorKind, RuntimeError, VmInternalError};
 use crate::types::{
     ASCIIData, BuffData, CharType, ListTypeData, MAX_VALUE_SIZE, PrincipalData,
@@ -38,7 +39,7 @@ fn test_constructors() {
     );
     assert_eq!(
         ListTypeData::new_list(TypeSignature::IntType, MAX_VALUE_SIZE),
-        Err(CheckErrorKind::ValueTooLarge)
+        Err(CommonCheckErrorKind::ValueTooLarge)
     );
 
     assert_eq!(

clarity-types/src/tests/types/mod.rs

@@ -14,7 +14,7 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 use std::collections::HashSet;
 
-use crate::errors::CheckErrorKind;
+use crate::errors::analysis::CommonCheckErrorKind;
 use crate::representations::CONTRACT_MAX_NAME_LENGTH;
 use crate::types::TypeSignature::{BoolType, IntType, ListUnionType, UIntType};
 use crate::types::signatures::{CallableSubtype, TypeSignature};
@@ -43,7 +43,7 @@ fn test_buffer_length_try_from_u32_trait() {
     assert_eq!(MAX_VALUE_SIZE, buffer.get_value());
 
     let err = BufferLength::try_from(MAX_VALUE_SIZE + 1).unwrap_err();
-    assert_eq!(CheckErrorKind::ValueTooLarge, err);
+    assert_eq!(CommonCheckErrorKind::ValueTooLarge, err);
 }
 
 #[test]
@@ -55,7 +55,7 @@ fn test_buffer_length_try_from_usize_trait() {
     assert_eq!(MAX_VALUE_SIZE, buffer.get_value());
 
     let err = BufferLength::try_from(MAX_VALUE_SIZE as usize + 1).unwrap_err();
-    assert_eq!(CheckErrorKind::ValueTooLarge, err);
+    assert_eq!(CommonCheckErrorKind::ValueTooLarge, err);
 }
 
 #[test]
@@ -67,10 +67,10 @@ fn test_buffer_length_try_from_i128_trait() {
     assert_eq!(MAX_VALUE_SIZE, buffer.get_value());
 
     let err = BufferLength::try_from(MAX_VALUE_SIZE as i128 + 1).unwrap_err();
-    assert_eq!(CheckErrorKind::ValueTooLarge, err);
+    assert_eq!(CommonCheckErrorKind::ValueTooLarge, err);
 
     let err = BufferLength::try_from(-1_i128).unwrap_err();
-    assert_eq!(CheckErrorKind::ValueOutOfBounds, err);
+    assert_eq!(CommonCheckErrorKind::ValueOutOfBounds, err);
 }
 
 #[test]
@@ -229,7 +229,7 @@ fn test_string_utf8_length_try_from_u32_trait() {
     assert_eq!(MAX_UTF8_VALUE_SIZE, string.get_value());
 
     let err = StringUTF8Length::try_from(MAX_UTF8_VALUE_SIZE + 1).unwrap_err();
-    assert_eq!(CheckErrorKind::ValueTooLarge, err);
+    assert_eq!(CommonCheckErrorKind::ValueTooLarge, err);
 }
 
 #[test]
@@ -244,7 +244,7 @@ fn test_string_utf8_length_try_from_usize_trait() {
     assert_eq!(MAX_UTF8_VALUE_SIZE, string.get_value());
 
     let err = StringUTF8Length::try_from(MAX_UTF8_VALUE_SIZE as usize + 1).unwrap_err();
-    assert_eq!(CheckErrorKind::ValueTooLarge, err);
+    assert_eq!(CommonCheckErrorKind::ValueTooLarge, err);
 }
 
 #[test]
@@ -259,10 +259,10 @@ fn test_string_utf8_length_try_from_i128_trait() {
     assert_eq!(MAX_UTF8_VALUE_SIZE, string.get_value());
 
     let err = StringUTF8Length::try_from(MAX_UTF8_VALUE_SIZE as i128 + 1).unwrap_err();
-    assert_eq!(CheckErrorKind::ValueTooLarge, err);
+    assert_eq!(CommonCheckErrorKind::ValueTooLarge, err);
 
     let err = StringUTF8Length::try_from(-1_i128).unwrap_err();
-    assert_eq!(CheckErrorKind::ValueOutOfBounds, err);
+    assert_eq!(CommonCheckErrorKind::ValueOutOfBounds, err);
 }
 
 #[test]
@@ -826,11 +826,11 @@ fn test_least_supertype() {
     for pair in bad_pairs {
         matches!(
             TypeSignature::least_supertype_v2_1(&pair.0, &pair.1).unwrap_err(),
-            CheckErrorKind::TypeError(..)
+            CommonCheckErrorKind::TypeError(..)
         );
         matches!(
             TypeSignature::least_supertype_v2_1(&pair.1, &pair.0).unwrap_err(),
-            CheckErrorKind::TypeError(..)
+            CommonCheckErrorKind::TypeError(..)
         );
     }
 }

clarity-types/src/tests/types/signatures.rs

@@ -36,6 +36,7 @@ pub use self::signatures::{
     AssetIdentifier, BufferLength, ListTypeData, SequenceSubtype, StringSubtype, StringUTF8Length,
     TupleTypeSignature, TypeSignature,
 };
+use crate::errors::analysis::CommonCheckErrorKind;
 use crate::errors::{CheckErrorKind, RuntimeError, VmExecutionError, VmInternalError};
 use crate::representations::{ClarityName, ContractName, SymbolicExpression};
 
@@ -711,7 +712,7 @@ impl fmt::Display for UTF8Data {
 }
 
 pub trait SequencedValue<T> {
-    fn type_signature(&self) -> std::result::Result<TypeSignature, CheckErrorKind>;
+    fn type_signature(&self) -> std::result::Result<TypeSignature, CommonCheckErrorKind>;
 
     fn items(&self) -> &Vec<T>;
 
@@ -736,7 +737,7 @@ impl SequencedValue<Value> for ListData {
         self.data.drain(..).collect()
     }
 
-    fn type_signature(&self) -> std::result::Result<TypeSignature, CheckErrorKind> {
+    fn type_signature(&self) -> std::result::Result<TypeSignature, CommonCheckErrorKind> {
         Ok(TypeSignature::SequenceType(SequenceSubtype::ListType(
             self.type_signature.clone(),
         )))
@@ -756,9 +757,11 @@ impl SequencedValue<u8> for BuffData {
         self.data.drain(..).collect()
     }
 
-    fn type_signature(&self) -> std::result::Result<TypeSignature, CheckErrorKind> {
+    fn type_signature(&self) -> std::result::Result<TypeSignature, CommonCheckErrorKind> {
         let buff_length = BufferLength::try_from(self.data.len()).map_err(|_| {
-            CheckErrorKind::Expects("ERROR: Too large of a buffer successfully constructed.".into())
+            CommonCheckErrorKind::Expects(
+                "ERROR: Too large of a buffer successfully constructed.".into(),
+            )
         })?;
         Ok(TypeSignature::SequenceType(SequenceSubtype::BufferType(
             buff_length,
@@ -779,9 +782,11 @@ impl SequencedValue<u8> for ASCIIData {
         self.data.drain(..).collect()
     }
 
-    fn type_signature(&self) -> std::result::Result<TypeSignature, CheckErrorKind> {
+    fn type_signature(&self) -> std::result::Result<TypeSignature, CommonCheckErrorKind> {
         let buff_length = BufferLength::try_from(self.data.len()).map_err(|_| {
-            CheckErrorKind::Expects("ERROR: Too large of a buffer successfully constructed.".into())
+            CommonCheckErrorKind::Expects(
+                "ERROR: Too large of a buffer successfully constructed.".into(),
+            )
         })?;
         Ok(TypeSignature::SequenceType(SequenceSubtype::StringType(
             StringSubtype::ASCII(buff_length),
@@ -805,9 +810,11 @@ impl SequencedValue<Vec<u8>> for UTF8Data {
         self.data.drain(..).collect()
     }
 
-    fn type_signature(&self) -> std::result::Result<TypeSignature, CheckErrorKind> {
+    fn type_signature(&self) -> std::result::Result<TypeSignature, CommonCheckErrorKind> {
         let str_len = StringUTF8Length::try_from(self.data.len()).map_err(|_| {
-            CheckErrorKind::Expects("ERROR: Too large of a buffer successfully constructed.".into())
+            CommonCheckErrorKind::Expects(
+                "ERROR: Too large of a buffer successfully constructed.".into(),
+            )
         })?;
         Ok(TypeSignature::SequenceType(SequenceSubtype::StringType(
             StringSubtype::UTF8(str_len),
@@ -823,19 +830,19 @@ impl SequencedValue<Vec<u8>> for UTF8Data {
 }
 
 impl OptionalData {
-    pub fn type_signature(&self) -> std::result::Result<TypeSignature, CheckErrorKind> {
+    pub fn type_signature(&self) -> std::result::Result<TypeSignature, CommonCheckErrorKind> {
         let type_result = match self.data {
             Some(ref v) => TypeSignature::new_option(TypeSignature::type_of(v)?),
             None => TypeSignature::new_option(TypeSignature::NoType),
         };
         type_result.map_err(|_| {
-            CheckErrorKind::Expects("Should not have constructed too large of a type.".into())
+            CommonCheckErrorKind::Expects("Should not have constructed too large of a type.".into())
         })
     }
 }
 
 impl ResponseData {
-    pub fn type_signature(&self) -> std::result::Result<TypeSignature, CheckErrorKind> {
+    pub fn type_signature(&self) -> std::result::Result<TypeSignature, CommonCheckErrorKind> {
         let type_result = match self.committed {
             true => TypeSignature::new_response(
                 TypeSignature::type_of(&self.data)?,
@@ -847,7 +854,7 @@ impl ResponseData {
             ),
         };
         type_result.map_err(|_| {
-            CheckErrorKind::Expects("Should not have constructed too large of a type.".into())
+            CommonCheckErrorKind::Expects("Should not have constructed too large of a type.".into())
         })
     }
 }