feat: initial implementation of allowances

Author: obycode

CHANGELOG.md

@@ -19,6 +19,14 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
   - `current-contract`
   - `block-time`
   - `to-ascii?`
+  - `restrict-assets?`
+  - `as-contract?`
+  - Special allowance expressions:
+    - `with-stx`
+    - `with-ft`
+    - `with-nft`
+    - `with-stacking`
+    - `with-all-assets-unsafe`
 - Added `contract_cost_limit_percentage` to the miner config file — sets the percentage of a block’s execution cost at which, if a large non-boot contract call would cause a BlockTooBigError, the miner will stop adding further non-boot contract calls and only include STX transfers and boot contract calls for the remainder of the block.
 
 ### Changed

clarity-types/src/errors/analysis.rs

@@ -313,6 +313,7 @@ pub enum CheckErrors {
     AllowanceExprNotAllowed,
     ExpectedAllowanceExpr(String),
     WithAllAllowanceNotAllowed,
+    WithAllAllowanceNotAlone,
 }
 
 #[derive(Debug, PartialEq)]
@@ -615,6 +616,7 @@ impl DiagnosableError for CheckErrors {
             CheckErrors::AllowanceExprNotAllowed => "allowance expressions are only allowed in the context of a `restrict-assets?` or `as-contract?`".into(),
             CheckErrors::ExpectedAllowanceExpr(got_name) => format!("expected an allowance expression, got: {got_name}"),
             CheckErrors::WithAllAllowanceNotAllowed => "with-all-assets-unsafe is not allowed here, only in the allowance list for `as-contract?`".into(),
+            CheckErrors::WithAllAllowanceNotAlone => "with-all-assets-unsafe must not be used along with other allowances".into(),
         }
     }
 

clarity-types/src/types/mod.rs

@@ -1226,6 +1226,16 @@ impl Value {
             Err(InterpreterError::Expect("Expected response".into()).into())
         }
     }
+
+    pub fn expect_string_ascii(self) -> Result<String> {
+        if let Value::Sequence(SequenceData::String(CharType::ASCII(ASCIIData { data }))) = self {
+            Ok(String::from_utf8(data)
+                .map_err(|_| InterpreterError::Expect("Non UTF-8 data in string".into()))?)
+        } else {
+            error!("Value '{self:?}' is not an ASCII string");
+            Err(InterpreterError::Expect("Expected ASCII string".into()).into())
+        }
+    }
 }
 
 impl BuffData {

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

@@ -50,12 +50,9 @@ pub fn check_restrict_assets(
     checker.type_check_expects(asset_owner, context, &TypeSignature::PrincipalType)?;
 
     for allowance in allowance_list {
-        check_allowance(
-            checker,
-            allowance,
-            context,
-            &NativeFunctions::RestrictAssets,
-        )?;
+        if check_allowance(checker, allowance, context)? {
+            return Err(CheckErrors::WithAllAllowanceNotAllowed.into());
+        }
     }
 
     // Check the body expressions, ensuring any intermediate responses are handled
@@ -97,12 +94,9 @@ pub fn check_as_contract(
     )?;
 
     for allowance in allowance_list {
-        check_allowance(
-            checker,
-            allowance,
-            context,
-            &NativeFunctions::AsContractSafe,
-        )?;
+        if check_allowance(checker, allowance, context)? && allowance_list.len() > 1 {
+            return Err(CheckErrors::WithAllAllowanceNotAlone.into());
+        }
     }
 
     // Check the body expressions, ensuring any intermediate responses are handled
@@ -133,12 +127,13 @@ pub fn check_allowance_err(
     Err(CheckErrors::AllowanceExprNotAllowed.into())
 }
 
+/// Type check an allowance expression, returning whether it is a
+/// `with-all-assets-unsafe` allowance (which has special rules).
 pub fn check_allowance(
     checker: &mut TypeChecker,
     allowance: &SymbolicExpression,
     context: &TypingContext,
-    parent_expr: &NativeFunctions,
-) -> Result<(), CheckError> {
+) -> Result<bool, CheckError> {
     let list = allowance
         .match_list()
         .ok_or(CheckErrors::ExpectedListApplication)?;
@@ -155,19 +150,13 @@ pub fn check_allowance(
     };
 
     match native_function {
-        NativeFunctions::AllowanceWithStx => {
-            check_allowance_with_stx(checker, args, context, parent_expr)
-        }
-        NativeFunctions::AllowanceWithFt => {
-            check_allowance_with_ft(checker, args, context, parent_expr)
-        }
-        NativeFunctions::AllowanceWithNft => {
-            check_allowance_with_nft(checker, args, context, parent_expr)
-        }
+        NativeFunctions::AllowanceWithStx => check_allowance_with_stx(checker, args, context),
+        NativeFunctions::AllowanceWithFt => check_allowance_with_ft(checker, args, context),
+        NativeFunctions::AllowanceWithNft => check_allowance_with_nft(checker, args, context),
         NativeFunctions::AllowanceWithStacking => {
-            check_allowance_with_stacking(checker, args, context, parent_expr)
+            check_allowance_with_stacking(checker, args, context)
         }
-        NativeFunctions::AllowanceAll => check_allowance_all(checker, args, context, parent_expr),
+        NativeFunctions::AllowanceAll => check_allowance_all(checker, args, context),
         _ => Err(CheckErrors::ExpectedAllowanceExpr(function_name.to_string()).into()),
     }
 }
@@ -178,13 +167,12 @@ fn check_allowance_with_stx(
     checker: &mut TypeChecker,
     args: &[SymbolicExpression],
     context: &TypingContext,
-    _parent_expr: &NativeFunctions,
-) -> Result<(), CheckError> {
+) -> Result<bool, CheckError> {
     check_argument_count(1, args)?;
 
     checker.type_check_expects(&args[0], context, &TypeSignature::UIntType)?;
 
-    Ok(())
+    Ok(false)
 }
 
 /// Type check a `with-ft` allowance expression.
@@ -193,15 +181,14 @@ fn check_allowance_with_ft(
     checker: &mut TypeChecker,
     args: &[SymbolicExpression],
     context: &TypingContext,
-    _parent_expr: &NativeFunctions,
-) -> Result<(), CheckError> {
+) -> Result<bool, CheckError> {
     check_argument_count(3, args)?;
 
     checker.type_check_expects(&args[0], context, &TypeSignature::PrincipalType)?;
     checker.type_check_expects(&args[1], context, &ASCII_128)?;
     checker.type_check_expects(&args[2], context, &TypeSignature::UIntType)?;
 
-    Ok(())
+    Ok(false)
 }
 
 /// Type check a `with-nft` allowance expression.
@@ -210,15 +197,14 @@ fn check_allowance_with_nft(
     checker: &mut TypeChecker,
     args: &[SymbolicExpression],
     context: &TypingContext,
-    _parent_expr: &NativeFunctions,
-) -> Result<(), CheckError> {
+) -> Result<bool, CheckError> {
     check_argument_count(3, args)?;
 
     checker.type_check_expects(&args[0], context, &TypeSignature::PrincipalType)?;
     checker.type_check_expects(&args[1], context, &ASCII_128)?;
     // Asset ID can be any type
 
-    Ok(())
+    Ok(false)
 }
 
 /// Type check a `with-stacking` allowance expression.
@@ -227,13 +213,12 @@ fn check_allowance_with_stacking(
     checker: &mut TypeChecker,
     args: &[SymbolicExpression],
     context: &TypingContext,
-    _parent_expr: &NativeFunctions,
-) -> Result<(), CheckError> {
+) -> Result<bool, CheckError> {
     check_argument_count(1, args)?;
 
     checker.type_check_expects(&args[0], context, &TypeSignature::UIntType)?;
 
-    Ok(())
+    Ok(false)
 }
 
 /// Type check an `with-all-assets-unsafe` allowance expression.
@@ -242,13 +227,8 @@ fn check_allowance_all(
     _checker: &mut TypeChecker,
     args: &[SymbolicExpression],
     _context: &TypingContext,
-    parent_expr: &NativeFunctions,
-) -> Result<(), CheckError> {
+) -> Result<bool, CheckError> {
     check_argument_count(0, args)?;
 
-    if parent_expr != &NativeFunctions::AsContractSafe {
-        return Err(CheckErrors::WithAllAllowanceNotAllowed.into());
-    }
-
-    Ok(())
+    Ok(true)
 }

clarity/src/vm/analysis/type_checker/v2_1/tests/contracts/downcast-trait-5-c4.clar

@@ -0,0 +1,13 @@
+(impl-trait .math-trait.math)
+(define-read-only (add (x uint) (y uint)) (ok (+ x y)) )
+(define-read-only (sub (x uint) (y uint)) (ok (- x y)) )
+
+(use-trait math .math-trait.math)
+
+(define-public (use (math-contract <math>))
+  (ok true)
+)
+
+(define-public (downcast)
+  (as-contract? ((with-all-assets-unsafe)) (use tx-sender))
+)

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

@@ -270,6 +270,16 @@ fn test_as_contract(#[case] version: ClarityVersion, #[case] _epoch: StacksEpoch
             "(as-contract? ((with-stx u1000)) (err u1) true)",
             CheckErrors::UncheckedIntermediaryResponses,
         ),
+        // other allowances together with with-all-assets-unsafe (first)
+        (
+            "(as-contract? ((with-all-assets-unsafe) (with-stx u1000)) true)",
+            CheckErrors::WithAllAllowanceNotAlone,
+        ),
+        // other allowances together with with-all-assets-unsafe (second)
+        (
+            "(as-contract? ((with-stx u1000) (with-all-assets-unsafe)) true)",
+            CheckErrors::WithAllAllowanceNotAlone,
+        ),
     ];
 
     for (code, expected_type) in &good {

clarity/src/vm/contexts.rs

@@ -455,6 +455,14 @@ impl AssetMap {
         assets.get(asset_identifier).copied()
     }
 
+    pub fn get_all_fungible_tokens(
+        &self,
+        principal: &PrincipalData,
+    ) -> Option<&HashMap<AssetIdentifier, u128>> {
+        let assets = self.token_map.get(principal)?;
+        Some(assets)
+    }
+
     pub fn get_nonfungible_tokens(
         &self,
         principal: &PrincipalData,
@@ -463,6 +471,14 @@ impl AssetMap {
         let assets = self.asset_map.get(principal)?;
         assets.get(asset_identifier)
     }
+
+    pub fn get_all_nonfungible_tokens(
+        &self,
+        principal: &PrincipalData,
+    ) -> Option<&HashMap<AssetIdentifier, Vec<Value>>> {
+        let assets = self.asset_map.get(principal)?;
+        Some(assets)
+    }
 }
 
 impl fmt::Display for AssetMap {
@@ -1551,6 +1567,12 @@ impl<'a, 'hooks> GlobalContext<'a, 'hooks> {
             .ok_or_else(|| InterpreterError::Expect("Failed to obtain asset map".into()).into())
     }
 
+    pub fn get_readonly_asset_map(&mut self) -> Result<&AssetMap> {
+        self.asset_maps
+            .last()
+            .ok_or_else(|| InterpreterError::Expect("Failed to obtain asset map".into()).into())
+    }
+
     pub fn log_asset_transfer(
         &mut self,
         sender: &PrincipalData,