Feat/explicit-contract-version

.github/actions/bitcoin-int-tests/Dockerfile.code-cov

@@ -2,6 +2,8 @@ FROM rust:bullseye AS test
 
 WORKDIR /build
 
+ENV CARGO_MANIFEST_DIR="$(pwd)"
+
 RUN rustup override set nightly-2022-01-14 && \
     rustup component add llvm-tools-preview && \
     cargo install grcov

clarity/src/vm/analysis/analysis_db.rs

@@ -25,6 +25,8 @@ use crate::vm::representations::ClarityName;
 use crate::vm::types::signatures::FunctionSignature;
 use crate::vm::types::{FunctionType, QualifiedContractIdentifier, TraitIdentifier, TypeSignature};
 
+use crate::vm::ClarityVersion;
+
 pub struct AnalysisDatabase<'a> {
     store: RollbackWrapper<'a>,
 }
@@ -110,6 +112,20 @@ impl<'a> AnalysisDatabase<'a> {
         Ok(())
     }
 
+    pub fn get_clarity_version(
+        &mut self,
+        contract_identifier: &QualifiedContractIdentifier,
+    ) -> CheckResult<ClarityVersion> {
+        // TODO: this function loads the whole contract to obtain the function type.
+        //         but it doesn't need to -- rather this information can just be
+        //         stored as its own entry. the analysis cost tracking currently only
+        //         charges based on the function type size.
+        let contract = self
+            .load_contract(contract_identifier)
+            .ok_or(CheckErrors::NoSuchContract(contract_identifier.to_string()))?;
+        Ok(contract.clarity_version)
+    }
+
     pub fn get_public_function_type(
         &mut self,
         contract_identifier: &QualifiedContractIdentifier,

clarity/src/vm/clarity.rs

@@ -12,6 +12,7 @@ use crate::vm::errors::Error as InterpreterError;
 use crate::vm::events::StacksTransactionEvent;
 use crate::vm::types::{BuffData, PrincipalData, QualifiedContractIdentifier};
 use crate::vm::ClarityVersion;
+use crate::vm::ContractContext;
 use crate::vm::{ast, SymbolicExpression, Value};
 use stacks_common::types::StacksEpochId;
 use std::fmt;
@@ -120,6 +121,7 @@ pub trait ClarityConnection {
         &mut self,
         mainnet: bool,
         chain_id: u32,
+        clarity_version: ClarityVersion,
         sender: PrincipalData,
         sponsor: Option<PrincipalData>,
         cost_track: LimitedCostTracker,
@@ -130,11 +132,13 @@ pub trait ClarityConnection {
     {
         let epoch_id = self.get_epoch();
         self.with_clarity_db_readonly_owned(|clarity_db| {
+            let initial_context =
+                ContractContext::new(QualifiedContractIdentifier::transient(), clarity_version);
             let mut vm_env = OwnedEnvironment::new_cost_limited(
                 mainnet, chain_id, clarity_db, cost_track, epoch_id,
             );
             let result = vm_env
-                .execute_in_env(sender, sponsor, to_do)
+                .execute_in_env(sender, sponsor, Some(initial_context), to_do)
                 .map(|(result, _, _)| result);
             let (db, _) = vm_env
                 .destruct()
@@ -167,13 +171,11 @@ pub trait TransactionConnection: ClarityConnection {
     fn analyze_smart_contract(
         &mut self,
         identifier: &QualifiedContractIdentifier,
+        clarity_version: ClarityVersion,
         contract_content: &str,
     ) -> Result<(ContractAST, ContractAnalysis), Error> {
         let epoch_id = self.get_epoch();
 
-        // ClarityVersionPragmaTodo: need to use contract's declared version or default
-        let clarity_version = ClarityVersion::default_for_epoch(epoch_id);
-
         self.with_analysis_db(|db, mut cost_track| {
             let ast_result = ast::build_ast(
                 identifier,
@@ -304,6 +306,7 @@ pub trait TransactionConnection: ClarityConnection {
     fn initialize_smart_contract<F>(
         &mut self,
         identifier: &QualifiedContractIdentifier,
+        clarity_version: ClarityVersion,
         contract_ast: &ContractAST,
         contract_str: &str,
         sponsor: Option<PrincipalData>,
@@ -317,6 +320,7 @@ pub trait TransactionConnection: ClarityConnection {
                 vm_env
                     .initialize_contract_from_ast(
                         identifier.clone(),
+                        clarity_version,
                         contract_ast,
                         contract_str,
                         sponsor,

clarity/src/vm/contexts.rs

@@ -79,7 +79,6 @@ pub struct Environment<'a, 'b> {
 
 pub struct OwnedEnvironment<'a> {
     context: GlobalContext<'a>,
-    default_contract: ContractContext,
     call_stack: CallStack,
 }
 
@@ -553,10 +552,6 @@ impl<'a> OwnedEnvironment<'a> {
                 LimitedCostTracker::new_free(),
                 StacksEpochId::Epoch2_05,
             ),
-            default_contract: ContractContext::new(
-                QualifiedContractIdentifier::transient(),
-                ClarityVersion::Clarity1,
-            ),
             call_stack: CallStack::new(),
         }
     }
@@ -580,10 +575,6 @@ impl<'a> OwnedEnvironment<'a> {
                 LimitedCostTracker::new_free(),
                 epoch,
             ),
-            default_contract: ContractContext::new(
-                QualifiedContractIdentifier::transient(),
-                version,
-            ),
             call_stack: CallStack::new(),
         }
     }
@@ -595,17 +586,12 @@ impl<'a> OwnedEnvironment<'a> {
         use_mainnet: bool,
     ) -> OwnedEnvironment<'a> {
         use crate::vm::tests::test_only_mainnet_to_chain_id;
-        let version = ClarityVersion::default_for_epoch(epoch);
         let cost_track = LimitedCostTracker::new_max_limit(&mut database, epoch, use_mainnet)
             .expect("FAIL: problem instantiating cost tracking");
         let chain_id = test_only_mainnet_to_chain_id(use_mainnet);
 
         OwnedEnvironment {
             context: GlobalContext::new(use_mainnet, chain_id, database, cost_track, epoch),
-            default_contract: ContractContext::new(
-                QualifiedContractIdentifier::transient(),
-                version,
-            ),
             call_stack: CallStack::new(),
         }
     }
@@ -624,7 +610,6 @@ impl<'a> OwnedEnvironment<'a> {
         database: ClarityDatabase<'a>,
         epoch_id: StacksEpochId,
     ) -> OwnedEnvironment<'a> {
-        let version = ClarityVersion::default_for_epoch(epoch_id);
         OwnedEnvironment {
             context: GlobalContext::new(
                 mainnet,
@@ -633,10 +618,6 @@ impl<'a> OwnedEnvironment<'a> {
                 LimitedCostTracker::new_free(),
                 epoch_id,
             ),
-            default_contract: ContractContext::new(
-                QualifiedContractIdentifier::transient(),
-                version,
-            ),
             call_stack: CallStack::new(),
         }
     }
@@ -648,13 +629,8 @@ impl<'a> OwnedEnvironment<'a> {
         cost_tracker: LimitedCostTracker,
         epoch_id: StacksEpochId,
     ) -> OwnedEnvironment<'a> {
-        let version = ClarityVersion::default_for_epoch(epoch_id);
         OwnedEnvironment {
             context: GlobalContext::new(mainnet, chain_id, database, cost_tracker, epoch_id),
-            default_contract: ContractContext::new(
-                QualifiedContractIdentifier::transient(),
-                version,
-            ),
             call_stack: CallStack::new(),
         }
     }
@@ -663,10 +639,11 @@ impl<'a> OwnedEnvironment<'a> {
         &'b mut self,
         sender: Option<PrincipalData>,
         sponsor: Option<PrincipalData>,
+        context: &'b mut ContractContext,
     ) -> Environment<'b, 'a> {
         Environment::new(
             &mut self.context,
-            &self.default_contract,
+            context,
             &mut self.call_stack,
             sender.clone(),
             sender,
@@ -678,6 +655,7 @@ impl<'a> OwnedEnvironment<'a> {
         &mut self,
         sender: PrincipalData,
         sponsor: Option<PrincipalData>,
+        initial_context: Option<ContractContext>,
         f: F,
     ) -> std::result::Result<(A, AssetMap, Vec<StacksTransactionEvent>), E>
     where
@@ -688,7 +666,12 @@ impl<'a> OwnedEnvironment<'a> {
         self.begin();
 
         let result = {
-            let mut exec_env = self.get_exec_environment(Some(sender), sponsor);
+            let mut initial_context = initial_context.unwrap_or(ContractContext::new(
+                QualifiedContractIdentifier::transient(),
+                ClarityVersion::Clarity1,
+            ));
+            let mut exec_env =
+                self.get_exec_environment(Some(sender), sponsor, &mut initial_context);
             f(&mut exec_env)
         };
 
@@ -704,6 +687,9 @@ impl<'a> OwnedEnvironment<'a> {
         }
     }
 
+    /// Initialize a contract with the "default" contract context (i.e. clarity1, transient ID).
+    /// No longer appropriate outside of testing, now that there are multiple clarity versions.
+    #[cfg(any(test, feature = "testing"))]
     pub fn initialize_contract(
         &mut self,
         contract_identifier: QualifiedContractIdentifier,
@@ -713,23 +699,48 @@ impl<'a> OwnedEnvironment<'a> {
         self.execute_in_env(
             contract_identifier.issuer.clone().into(),
             sponsor.clone(),
+            None,
+            |exec_env| exec_env.initialize_contract(contract_identifier, contract_content),
+        )
+    }
+
+    pub fn initialize_versioned_contract(
+        &mut self,
+        contract_identifier: QualifiedContractIdentifier,
+        version: ClarityVersion,
+        contract_content: &str,
+        sponsor: Option<PrincipalData>,
+    ) -> Result<((), AssetMap, Vec<StacksTransactionEvent>)> {
+        self.execute_in_env(
+            contract_identifier.issuer.clone().into(),
+            sponsor.clone(),
+            Some(ContractContext::new(
+                QualifiedContractIdentifier::transient(),
+                version,
+            )),
             |exec_env| exec_env.initialize_contract(contract_identifier, contract_content),
         )
     }
 
     pub fn initialize_contract_from_ast(
         &mut self,
         contract_identifier: QualifiedContractIdentifier,
+        clarity_version: ClarityVersion,
         contract_content: &ContractAST,
         contract_string: &str,
         sponsor: Option<PrincipalData>,
     ) -> Result<((), AssetMap, Vec<StacksTransactionEvent>)> {
         self.execute_in_env(
             contract_identifier.issuer.clone().into(),
             sponsor.clone(),
+            Some(ContractContext::new(
+                QualifiedContractIdentifier::transient(),
+                clarity_version,
+            )),
             |exec_env| {
                 exec_env.initialize_contract_from_ast(
                     contract_identifier,
+                    clarity_version,
                     contract_content,
                     contract_string,
                 )
@@ -745,7 +756,7 @@ impl<'a> OwnedEnvironment<'a> {
         tx_name: &str,
         args: &[SymbolicExpression],
     ) -> Result<(Value, AssetMap, Vec<StacksTransactionEvent>)> {
-        self.execute_in_env(sender, sponsor, |exec_env| {
+        self.execute_in_env(sender, sponsor, None, |exec_env| {
             exec_env.execute_contract(&contract_identifier, tx_name, args, false)
         })
     }
@@ -757,30 +768,35 @@ impl<'a> OwnedEnvironment<'a> {
         amount: u128,
         memo: &BuffData,
     ) -> Result<(Value, AssetMap, Vec<StacksTransactionEvent>)> {
-        self.execute_in_env(from.clone(), None, |exec_env| {
+        self.execute_in_env(from.clone(), None, None, |exec_env| {
             exec_env.stx_transfer(from, to, amount, memo)
         })
     }
 
     #[cfg(any(test, feature = "testing"))]
     pub fn stx_faucet(&mut self, recipient: &PrincipalData, amount: u128) {
-        self.execute_in_env::<_, _, crate::vm::errors::Error>(recipient.clone(), None, |env| {
-            let mut snapshot = env
-                .global_context
-                .database
-                .get_stx_balance_snapshot(&recipient);
+        self.execute_in_env::<_, _, crate::vm::errors::Error>(
+            recipient.clone(),
+            None,
+            None,
+            |env| {
+                let mut snapshot = env
+                    .global_context
+                    .database
+                    .get_stx_balance_snapshot(&recipient);
 
-            snapshot.credit(amount);
-            snapshot.save();
+                snapshot.credit(amount);
+                snapshot.save();
 
-            env.global_context
-                .database
-                .increment_ustx_liquid_supply(amount)
-                .unwrap();
+                env.global_context
+                    .database
+                    .increment_ustx_liquid_supply(amount)
+                    .unwrap();
 
-            let res: std::result::Result<(), crate::vm::errors::Error> = Ok(());
-            res
-        })
+                let res: std::result::Result<(), crate::vm::errors::Error> = Ok(());
+                res
+            },
+        )
         .unwrap();
     }
 
@@ -792,6 +808,7 @@ impl<'a> OwnedEnvironment<'a> {
         self.execute_in_env(
             QualifiedContractIdentifier::transient().issuer.into(),
             None,
+            None,
             |exec_env| exec_env.eval_raw(program),
         )
     }
@@ -804,6 +821,7 @@ impl<'a> OwnedEnvironment<'a> {
         self.execute_in_env(
             QualifiedContractIdentifier::transient().issuer.into(),
             None,
+            None,
             |exec_env| exec_env.eval_read_only(contract, program),
         )
     }
@@ -1084,6 +1102,7 @@ impl<'a, 'b> Environment<'a, 'b> {
                 return Err(CheckErrors::CircularReference(vec![func_identifier.to_string()]).into())
             }
             self.call_stack.insert(&func_identifier, true);
+
             let res = self.execute_function_as_transaction(&func, &args, Some(&contract.contract_context));
             self.call_stack.remove(&func_identifier, true)?;
 
@@ -1178,12 +1197,18 @@ impl<'a, 'b> Environment<'a, 'b> {
             clarity_version,
             self.global_context.epoch_id,
         )?;
-        self.initialize_contract_from_ast(contract_identifier, &contract_ast, &contract_content)
+        self.initialize_contract_from_ast(
+            contract_identifier,
+            clarity_version,
+            &contract_ast,
+            &contract_content,
+        )
     }
 
     pub fn initialize_contract_from_ast(
         &mut self,
         contract_identifier: QualifiedContractIdentifier,
+        contract_version: ClarityVersion,
         contract_content: &ContractAST,
         contract_string: &str,
     ) -> Result<()> {
@@ -1217,16 +1242,12 @@ impl<'a, 'b> Environment<'a, 'b> {
             let memory_use = contract_string.len() as u64;
             self.add_memory(memory_use)?;
 
-            let version = ClarityVersion::default_for_epoch(
-                self.global_context.database.get_clarity_epoch_version(),
-            );
-
             let result = Contract::initialize_from_ast(
                 contract_identifier.clone(),
                 contract_content,
                 self.sponsor.clone(),
                 &mut self.global_context,
-                version,
+                contract_version,
             );
             self.drop_memory(memory_use);
             result