feat: initial implementation for restric-assets?

This just adds the basic support for the syntax and some setup for the
full implementation.

Author: obycode

clarity-types/src/errors/analysis.rs

@@ -307,6 +307,9 @@ pub enum CheckErrors {
 
     // time checker errors
     ExecutionTimeExpired,
+
+    // contract post-conditions
+    RestrictAssetsExpectedListOfAllowances,
 }
 
 #[derive(Debug, PartialEq)]
@@ -605,6 +608,7 @@ impl DiagnosableError for CheckErrors {
             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(),
+            CheckErrors::RestrictAssetsExpectedListOfAllowances => "restrict-assets? expects a list of asset allowances as its second argument".into(),
         }
     }
 

clarity/src/vm/analysis/arithmetic_checker/mod.rs

@@ -175,7 +175,9 @@ impl ArithmeticOnlyChecker<'_> {
             | StxGetAccount => Err(Error::FunctionNotPermitted(function)),
             Append | Concat | AsMaxLen | ContractOf | PrincipalOf | ListCons | Print
             | AsContract | ElementAt | ElementAtAlias | IndexOf | IndexOfAlias | Map | Filter
-            | Fold | Slice | ReplaceAt | ContractHash => Err(Error::FunctionNotPermitted(function)),
+            | Fold | Slice | ReplaceAt | ContractHash | RestrictAssets => {
+                Err(Error::FunctionNotPermitted(function))
+            }
             BuffToIntLe | BuffToUIntLe | BuffToIntBe | BuffToUIntBe => {
                 Err(Error::FunctionNotPermitted(function))
             }

clarity/src/vm/analysis/read_only_checker/mod.rs

@@ -427,6 +427,23 @@ impl<'a, 'b> ReadOnlyChecker<'a, 'b> {
                 self.check_each_expression_is_read_only(&args[2..])
                     .map(|args_read_only| args_read_only && is_function_read_only)
             }
+            RestrictAssets => {
+                check_arguments_at_least(3, args)?;
+
+                // Check the asset owner argument.
+                let asset_owner_read_only = self.check_read_only(&args[0])?;
+
+                // Check the allowances argument.
+                let allowances = args[1]
+                    .match_list()
+                    .ok_or(CheckErrors::RestrictAssetsExpectedListOfAllowances)?;
+                let allowances_read_only = self.check_each_expression_is_read_only(allowances)?;
+
+                // Check the body expressions.
+                let body_read_only = self.check_each_expression_is_read_only(&args[2..])?;
+
+                Ok(asset_owner_read_only && allowances_read_only && body_read_only)
+            }
         }
     }
 

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

@@ -16,15 +16,15 @@
 
 use stacks_common::types::StacksEpochId;
 
-use super::{check_argument_count, check_arguments_at_least, no_type, TypeChecker, TypingContext};
+use super::{TypeChecker, TypingContext, check_argument_count, check_arguments_at_least, no_type};
 use crate::vm::analysis::errors::{CheckError, CheckErrors, SyntaxBindingErrorType};
 use crate::vm::costs::cost_functions::ClarityCostFunction;
 use crate::vm::costs::{analysis_typecheck_cost, runtime_cost};
 use crate::vm::diagnostic::DiagnosableError;
-use crate::vm::functions::{handle_binding_list, NativeFunctions};
+use crate::vm::functions::{NativeFunctions, handle_binding_list};
 use crate::vm::types::{
-    BlockInfoProperty, FixedFunction, FunctionArg, FunctionSignature, FunctionType, PrincipalData,
-    TupleTypeSignature, TypeSignature, Value, BUFF_20, BUFF_32, BUFF_33, BUFF_64, BUFF_65,
+    BUFF_20, BUFF_32, BUFF_33, BUFF_64, BUFF_65, BlockInfoProperty, FixedFunction, FunctionArg,
+    FunctionSignature, FunctionType, PrincipalData, TupleTypeSignature, TypeSignature, Value,
 };
 use crate::vm::{ClarityName, ClarityVersion, SymbolicExpression, SymbolicExpressionType};
 
@@ -782,7 +782,8 @@ impl TypedNativeFunction {
             | StringToUInt | IntToAscii | IntToUtf8 | GetBurnBlockInfo | StxTransferMemo
             | StxGetAccount | BitwiseAnd | BitwiseOr | BitwiseNot | BitwiseLShift
             | BitwiseRShift | BitwiseXor2 | Slice | ToConsensusBuff | FromConsensusBuff
-            | ReplaceAt | GetStacksBlockInfo | GetTenureInfo | ContractHash | ToAscii => {
+            | ReplaceAt | GetStacksBlockInfo | GetTenureInfo | ContractHash | ToAscii
+            | RestrictAssets => {
                 return Err(CheckErrors::Expects(
                     "Clarity 2+ keywords should not show up in 2.05".into(),
                 ));

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

@@ -1134,7 +1134,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
         Ok(())
     }
 
-    // Type check an expression, with an expected_type that should _admit_ the expression.
+    /// Type check an expression, with an expected_type that should _admit_ the expression.
     pub fn type_check_expects(
         &mut self,
         expr: &SymbolicExpression,
@@ -1156,7 +1156,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
         }
     }
 
-    // Type checks an expression, recursively type checking its subexpressions
+    /// Type checks an expression, recursively type checking its subexpressions
     pub fn type_check(
         &mut self,
         expr: &SymbolicExpression,
@@ -1175,6 +1175,8 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
         result
     }
 
+    /// Type checks a list of statements, ensuring that each statement is valid
+    /// and any responses before the last statement are handled.
     fn type_check_consecutive_statements(
         &mut self,
         args: &[SymbolicExpression],

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

@@ -17,23 +17,23 @@
 use stacks_common::types::StacksEpochId;
 
 use super::{
-    check_argument_count, check_arguments_at_least, check_arguments_at_most,
-    compute_typecheck_cost, no_type, TypeChecker, TypingContext,
+    TypeChecker, TypingContext, check_argument_count, check_arguments_at_least,
+    check_arguments_at_most, compute_typecheck_cost, no_type,
 };
 use crate::vm::analysis::errors::{CheckError, CheckErrors, SyntaxBindingErrorType};
 use crate::vm::costs::cost_functions::ClarityCostFunction;
-use crate::vm::costs::{analysis_typecheck_cost, runtime_cost, CostErrors, CostTracker};
+use crate::vm::costs::{CostErrors, CostTracker, analysis_typecheck_cost, runtime_cost};
 use crate::vm::diagnostic::DiagnosableError;
-use crate::vm::functions::{handle_binding_list, NativeFunctions};
+use crate::vm::functions::{NativeFunctions, handle_binding_list};
 use crate::vm::types::signatures::{
-    CallableSubtype, FunctionArgSignature, FunctionReturnsSignature, SequenceSubtype, ASCII_40,
+    ASCII_40, CallableSubtype, FunctionArgSignature, FunctionReturnsSignature, SequenceSubtype,
     TO_ASCII_MAX_BUFF, TO_ASCII_RESPONSE_STRING, UTF8_40,
 };
 use crate::vm::types::{
-    BlockInfoProperty, BufferLength, BurnBlockInfoProperty, FixedFunction, FunctionArg,
-    FunctionSignature, FunctionType, PrincipalData, StacksBlockInfoProperty, TenureInfoProperty,
-    TupleTypeSignature, TypeSignature, Value, BUFF_1, BUFF_20, BUFF_32, BUFF_33, BUFF_64, BUFF_65,
-    MAX_VALUE_SIZE,
+    BUFF_1, BUFF_20, BUFF_32, BUFF_33, BUFF_64, BUFF_65, BlockInfoProperty, BufferLength,
+    BurnBlockInfoProperty, FixedFunction, FunctionArg, FunctionSignature, FunctionType,
+    MAX_VALUE_SIZE, PrincipalData, StacksBlockInfoProperty, TenureInfoProperty, TupleTypeSignature,
+    TypeSignature, Value,
 };
 use crate::vm::{ClarityName, ClarityVersion, SymbolicExpression, SymbolicExpressionType};
 
@@ -819,6 +819,42 @@ fn check_get_tenure_info(
     Ok(TypeSignature::new_option(block_info_prop.type_result())?)
 }
 
+fn check_restrict_assets(
+    checker: &mut TypeChecker,
+    args: &[SymbolicExpression],
+    context: &TypingContext,
+) -> Result<TypeSignature, CheckError> {
+    check_arguments_at_least(3, args)?;
+
+    let asset_owner = &args[0];
+    let allowance_list = args[1].match_list().ok_or(CheckError::new(
+        CheckErrors::RestrictAssetsExpectedListOfAllowances,
+    ))?;
+    let body_exprs = &args[2..];
+
+    runtime_cost(
+        ClarityCostFunction::AnalysisListItemsCheck,
+        checker,
+        allowance_list.len() + body_exprs.len(),
+    )?;
+
+    checker.type_check_expects(asset_owner, context, &TypeSignature::PrincipalType)?;
+
+    // TODO: type-check the allowances
+
+    // Check the body expressions, ensuring any intermediate responses are handled
+    let mut last_return = None;
+    for expr in body_exprs {
+        let type_return = checker.type_check(expr, context)?;
+        if type_return.is_response_type() {
+            return Err(CheckErrors::UncheckedIntermediaryResponses.into());
+        }
+        last_return = Some(type_return);
+    }
+
+    last_return.ok_or_else(|| CheckError::new(CheckErrors::CheckerImplementationFailure))
+}
+
 impl TypedNativeFunction {
     pub fn type_check_application(
         &self,
@@ -1209,6 +1245,7 @@ impl TypedNativeFunction {
                     CheckErrors::Expects("FATAL: Legal Clarity response type marked invalid".into())
                 })?,
             ))),
+            RestrictAssets => Special(SpecialNativeFunction(&check_restrict_assets)),
         };
 
         Ok(out)

clarity/src/vm/costs/cost_functions.rs

@@ -159,6 +159,7 @@ define_named_enum!(ClarityCostFunction {
     BitwiseRShift("cost_bitwise_right_shift"),
     ContractHash("cost_contract_hash"),
     ToAscii("cost_to_ascii"),
+    RestrictAssets("cost_restrict_assets"),
     Unimplemented("cost_unimplemented"),
 });
 
@@ -330,6 +331,7 @@ pub trait CostValues {
     fn cost_bitwise_right_shift(n: u64) -> InterpreterResult<ExecutionCost>;
     fn cost_contract_hash(n: u64) -> InterpreterResult<ExecutionCost>;
     fn cost_to_ascii(n: u64) -> InterpreterResult<ExecutionCost>;
+    fn cost_restrict_assets(n: u64) -> InterpreterResult<ExecutionCost>;
 }
 
 impl ClarityCostFunction {
@@ -484,6 +486,7 @@ impl ClarityCostFunction {
             ClarityCostFunction::BitwiseRShift => C::cost_bitwise_right_shift(n),
             ClarityCostFunction::ContractHash => C::cost_contract_hash(n),
             ClarityCostFunction::ToAscii => C::cost_to_ascii(n),
+            ClarityCostFunction::RestrictAssets => C::cost_restrict_assets(n),
             ClarityCostFunction::Unimplemented => Err(RuntimeErrorType::NotImplemented.into()),
         }
     }

clarity/src/vm/costs/costs_1.rs

@@ -13,9 +13,9 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-/// This file implements the cost functions from costs.clar in Rust.
-use super::cost_functions::{linear, logn, nlogn, CostValues};
 use super::ExecutionCost;
+/// This file implements the cost functions from costs.clar in Rust.
+use super::cost_functions::{CostValues, linear, logn, nlogn};
 use crate::vm::errors::{InterpreterResult, RuntimeErrorType};
 
 pub struct Costs1;
@@ -753,4 +753,8 @@ impl CostValues for Costs1 {
     fn cost_to_ascii(n: u64) -> InterpreterResult<ExecutionCost> {
         Err(RuntimeErrorType::NotImplemented.into())
     }
+
+    fn cost_restrict_assets(n: u64) -> InterpreterResult<ExecutionCost> {
+        Err(RuntimeErrorType::NotImplemented.into())
+    }
 }

clarity/src/vm/costs/costs_2.rs

@@ -13,9 +13,9 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-/// This file implements the cost functions from costs-2.clar in Rust.
-use super::cost_functions::{linear, logn, nlogn, CostValues};
 use super::ExecutionCost;
+/// This file implements the cost functions from costs-2.clar in Rust.
+use super::cost_functions::{CostValues, linear, logn, nlogn};
 use crate::vm::errors::{InterpreterResult, RuntimeErrorType};
 
 pub struct Costs2;
@@ -753,4 +753,8 @@ impl CostValues for Costs2 {
     fn cost_to_ascii(n: u64) -> InterpreterResult<ExecutionCost> {
         Err(RuntimeErrorType::NotImplemented.into())
     }
+
+    fn cost_restrict_assets(n: u64) -> InterpreterResult<ExecutionCost> {
+        Err(RuntimeErrorType::NotImplemented.into())
+    }
 }

clarity/src/vm/costs/costs_2_testnet.rs

@@ -13,9 +13,9 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-/// This file implements the cost functions from costs-2-testnet.clar in Rust.
-use super::cost_functions::{linear, logn, nlogn, CostValues};
 use super::ExecutionCost;
+/// This file implements the cost functions from costs-2-testnet.clar in Rust.
+use super::cost_functions::{CostValues, linear, logn, nlogn};
 use crate::vm::errors::{InterpreterResult, RuntimeErrorType};
 
 pub struct Costs2Testnet;
@@ -753,4 +753,8 @@ impl CostValues for Costs2Testnet {
     fn cost_to_ascii(n: u64) -> InterpreterResult<ExecutionCost> {
         Err(RuntimeErrorType::NotImplemented.into())
     }
+
+    fn cost_restrict_assets(n: u64) -> InterpreterResult<ExecutionCost> {
+        Err(RuntimeErrorType::NotImplemented.into())
+    }
 }