PoX 2 Unlock

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

@@ -4,13 +4,12 @@ WORKDIR /build
 
 ENV CARGO_MANIFEST_DIR="$(pwd)"
 
-RUN rustup override set nightly-2022-01-14 && \
-    rustup component add llvm-tools-preview && \
+RUN rustup component add llvm-tools-preview && \
     cargo install grcov
 
-ENV RUSTFLAGS="-Zinstrument-coverage" \
+ENV RUSTFLAGS="-Cinstrument-coverage" \
     LLVM_PROFILE_FILE="stacks-blockchain-%p-%m.profraw"
-    
+
 COPY . .
 
 RUN cargo build --workspace && \

.github/actions/bitcoin-int-tests/Dockerfile.generic.bitcoin-tests

@@ -6,11 +6,10 @@ COPY . .
 
 WORKDIR /src/testnet/stacks-node
 
-RUN rustup override set nightly-2022-01-14 && \
-    rustup component add llvm-tools-preview && \
+RUN rustup component add llvm-tools-preview && \
     cargo install grcov
 
-ENV RUSTFLAGS="-Zinstrument-coverage" \
+ENV RUSTFLAGS="-Cinstrument-coverage" \
     LLVM_PROFILE_FILE="stacks-blockchain-%p-%m.profraw"
 
 RUN cargo test --no-run && \

.github/actions/bitcoin-int-tests/Dockerfile.large-genesis

@@ -9,11 +9,10 @@ RUN cd / && tar -xvzf bitcoin-0.20.0-x86_64-linux-gnu.tar.gz
 
 RUN ln -s /bitcoin-0.20.0/bin/bitcoind /bin/
 
-RUN rustup override set nightly-2022-01-14 && \
-    rustup component add llvm-tools-preview && \
+RUN rustup component add llvm-tools-preview && \
     cargo install grcov
 
-ENV RUSTFLAGS="-Zinstrument-coverage" \
+ENV RUSTFLAGS="-Cinstrument-coverage" \
     LLVM_PROFILE_FILE="stacks-blockchain-%p-%m.profraw"
 
 RUN cargo test --no-run --workspace && \

clarity/src/vm/clarity.rs

@@ -149,6 +149,14 @@ pub trait ClarityConnection {
 }
 
 pub trait TransactionConnection: ClarityConnection {
+    /// Do something with this connection's Clarity environment that can be aborted
+    ///  with `abort_call_back`.
+    /// This returns the return value of `to_do`:
+    ///  * the generic term `R`
+    ///  * the asset changes during `to_do` in an `AssetMap`
+    ///  * the Stacks events during the transaction
+    /// and a `bool` value which is `true` if the `abort_call_back` caused the changes to abort
+    /// If `to_do` returns an `Err` variant, then the changes are aborted.
     fn with_abort_callback<F, A, R, E>(
         &mut self,
         to_do: F,

clarity/src/vm/contexts.rs

@@ -1061,11 +1061,41 @@ impl<'a, 'b> Environment<'a, 'b> {
     }
 
     pub fn execute_contract(
+        &mut self,
+        contract: &QualifiedContractIdentifier,
+        tx_name: &str,
+        args: &[SymbolicExpression],
+        read_only: bool,
+    ) -> Result<Value> {
+        self.inner_execute_contract(contract, tx_name, args, read_only, false)
+    }
+
+    /// This method is exposed for callers that need to invoke a private method directly.
+    /// For example, this is used by the Stacks chainstate for invoking private methods
+    /// on the pox-2 contract. This should not be called by user transaction processing.
+    pub fn execute_contract_allow_private(
+        &mut self,
+        contract: &QualifiedContractIdentifier,
+        tx_name: &str,
+        args: &[SymbolicExpression],
+        read_only: bool,
+    ) -> Result<Value> {
+        self.inner_execute_contract(contract, tx_name, args, read_only, true)
+    }
+
+    /// This method handles actual execution of contract-calls on a contract.
+    ///
+    /// `allow_private` should always be set to `false` for user transactions:
+    ///  this ensures that only `define-public` and `define-read-only` methods can
+    ///  be invoked. The `allow_private` mode should only be used by
+    ///  `Environment::execute_contract_allow_private`.
+    fn inner_execute_contract(
         &mut self,
         contract_identifier: &QualifiedContractIdentifier,
         tx_name: &str,
         args: &[SymbolicExpression],
         read_only: bool,
+        allow_private: bool,
     ) -> Result<Value> {
         let contract_size = self
             .global_context
@@ -1080,7 +1110,7 @@ impl<'a, 'b> Environment<'a, 'b> {
 
             let func = contract.contract_context.lookup_function(tx_name)
                 .ok_or_else(|| { CheckErrors::UndefinedFunction(tx_name.to_string()) })?;
-            if !func.is_public() {
+            if !allow_private && !func.is_public() {
                 return Err(CheckErrors::NoSuchPublicFunction(contract_identifier.to_string(), tx_name.to_string()).into());
             } else if read_only && !func.is_read_only() {
                 return Err(CheckErrors::PublicFunctionNotReadOnly(contract_identifier.to_string(), tx_name.to_string()).into());

clarity/src/vm/database/clarity_db.rs

@@ -1215,6 +1215,7 @@ impl<'a> ClarityDatabase<'a> {
         self.fetch_entry(contract_identifier, map_name, key_value, &descriptor)
     }
 
+    /// Returns a Clarity optional type wrapping a found or not found result
     pub fn fetch_entry(
         &mut self,
         contract_identifier: &QualifiedContractIdentifier,

clarity/src/vm/database/structures.rs

@@ -474,6 +474,32 @@ impl<'db, 'conn> STXBalanceSnapshot<'db, 'conn> {
         };
     }
 
+    /// If this snapshot is locked, then alter the lock height to be
+    /// the next burn block (i.e., `self.burn_block_height + 1`)
+    pub fn accelerate_unlock(&mut self) {
+        let unlocked = self.unlock_available_tokens_if_any();
+        if unlocked > 0 {
+            debug!("Consolidated after account-token-lock");
+        }
+
+        let new_unlock_height = self.burn_block_height + 1;
+        self.balance = match self.balance {
+            STXBalance::Unlocked { amount } => STXBalance::Unlocked { amount },
+            STXBalance::LockedPoxOne { .. } => {
+                unreachable!("Attempted to accelerate the unlock of a lockup created by PoX-1")
+            }
+            STXBalance::LockedPoxTwo {
+                amount_unlocked,
+                amount_locked,
+                ..
+            } => STXBalance::LockedPoxTwo {
+                amount_unlocked,
+                amount_locked,
+                unlock_height: new_unlock_height,
+            },
+        };
+    }
+
     /// Unlock any tokens that are unlockable at the current
     ///  burn block height, and return the amount newly unlocked
     fn unlock_available_tokens_if_any(&mut self) -> u128 {

src/burnchains/burnchain.rs

@@ -46,6 +46,7 @@ use crate::burnchains::{
     BurnchainStateTransition, BurnchainStateTransitionOps, BurnchainTransaction,
     Error as burnchain_error, PoxConstants,
 };
+use crate::chainstate::burn::db::sortdb::SortitionHandle;
 use crate::chainstate::burn::db::sortdb::{SortitionDB, SortitionHandleConn, SortitionHandleTx};
 use crate::chainstate::burn::distribution::BurnSamplePoint;
 use crate::chainstate::burn::operations::{
@@ -72,11 +73,11 @@ use crate::util_lib::db::Error as db_error;
 use stacks_common::address::public_keys_to_address_hash;
 use stacks_common::address::AddressHashMode;
 use stacks_common::deps_common::bitcoin::util::hash::Sha256dHash as BitcoinSha256dHash;
-use stacks_common::util::{get_epoch_time_ms, sleep_ms};
 use stacks_common::util::get_epoch_time_secs;
 use stacks_common::util::hash::to_hex;
 use stacks_common::util::log;
 use stacks_common::util::vrf::VRFPublicKey;
+use stacks_common::util::{get_epoch_time_ms, sleep_ms};
 
 use crate::burnchains::bitcoin::indexer::BitcoinIndexer;
 use crate::chainstate::stacks::boot::POX_2_MAINNET_CODE;
@@ -491,6 +492,23 @@ impl Burnchain {
         )
     }
 
+    /// Is this block either the first block in a reward cycle or
+    ///  right before the reward phase starts? This is the mod 0 or mod 1
+    ///  block. Reward cycle start events (like auto-unlocks) process *after*
+    ///  the first reward block, so this function is used to determine when
+    ///  that has passed.
+    pub fn is_before_reward_cycle(
+        first_block_ht: u64,
+        burn_ht: u64,
+        reward_cycle_length: u64,
+    ) -> bool {
+        let effective_height = burn_ht
+            .checked_sub(first_block_ht)
+            .expect("FATAL: attempted to check reward cycle start before first block height");
+        // first block of the new reward cycle
+        (effective_height % reward_cycle_length) <= 1
+    }
+
     pub fn static_is_in_prepare_phase(
         first_block_height: u64,
         reward_cycle_length: u64,