fix(drive): inconsistent platform state and version during ABCI calls

packages/dashmate/package.json

@@ -73,6 +73,7 @@
     "ajv-formats": "^2.1.1",
     "awilix": "^4.2.6",
     "begoo": "^2.0.2",
+    "bs58": "^4.0.1",
     "chalk": "^4.1.0",
     "cron": "^2.1.0",
     "dockerode": "^3.3.5",

packages/dashmate/src/listr/tasks/platform/waitForNodeToBeReadyTaskFactory.js

@@ -1,5 +1,7 @@
 import DAPIClient from '@dashevo/dapi-client';
+import bs58 from 'bs58';
 import { Listr } from 'listr2';
+import WithdrawalsContract from '@dashevo/withdrawals-contract/lib/systemIds.js';
 import wait from '../../../util/wait.js';
 
 /**
@@ -31,12 +33,16 @@ export default function waitForNodeToBeReadyTaskFactory() {
             },
           });
 
+          const withdrawalsContractId = bs58.decode(WithdrawalsContract.contractId);
+
           let success = false;
           do {
-            const response = await dapiClient.platform.getEpochsInfo(0, 1, {
+            const response = await dapiClient.platform.getDataContract(withdrawalsContractId, {
               retries: 0,
+              prove: false,
             })
-              .catch(() => {});
+              .catch(() => {
+              });
 
             success = Boolean(response);
 

packages/rs-drive-abci/Cargo.toml

@@ -13,6 +13,7 @@ rust-version = "1.76"
 license = "MIT"
 
 [dependencies]
+arc-swap = "1.7.0"
 bincode = { version = "2.0.0-rc.3", features = ["serde"] }
 ciborium = { git = "https://github.com/qrayven/ciborium", branch = "feat-ser-null-as-undefined" }
 chrono = "0.4.20"
@@ -29,7 +30,6 @@ drive = { path = "../rs-drive", default-features = false, features = [
 thiserror = "1.0.30"
 rand = "0.8.5"
 tempfile = "3.3.0"
-parking_lot = "0.12.1"
 hex = "0.4.3"
 indexmap = { version = "1.9.3", features = ["serde"] }
 sha2 = "0.10.6"

packages/rs-drive-abci/src/abci/app/consensus.rs

@@ -1,13 +1,15 @@
-use crate::abci::app::{PlatformApplication, TransactionalApplication};
+use crate::abci::app::{BlockExecutionApplication, PlatformApplication, TransactionalApplication};
 use crate::abci::handler;
 use crate::abci::handler::error::error_into_exception;
 use crate::error::execution::ExecutionError;
 use crate::error::Error;
+use crate::execution::types::block_execution_context::BlockExecutionContext;
 use crate::platform_types::platform::Platform;
 use crate::rpc::core::CoreRPCLike;
+use dpp::version::PlatformVersion;
 use drive::grovedb::Transaction;
+use std::cell::{Ref, RefCell, RefMut};
 use std::fmt::Debug;
-use std::sync::RwLock;
 use tenderdash_abci::proto::abci as proto;
 
 /// AbciApp is an implementation of ABCI Application, as defined by Tenderdash.
@@ -17,16 +19,19 @@ use tenderdash_abci::proto::abci as proto;
 pub struct ConsensusAbciApplication<'a, C> {
     /// Platform
     platform: &'a Platform<C>,
-    /// The current transaction
-    transaction: RwLock<Option<Transaction<'a>>>,
+    /// The current GroveDb transaction
+    transaction: RefCell<Option<Transaction<'a>>>,
+    /// The current block execution context
+    block_execution_context: RefCell<Option<BlockExecutionContext>>,
 }
 
 impl<'a, C> ConsensusAbciApplication<'a, C> {
     /// Create new ABCI app
     pub fn new(platform: &'a Platform<C>) -> Self {
         Self {
             platform,
-            transaction: RwLock::new(None),
+            transaction: Default::default(),
+            block_execution_context: Default::default(),
         }
     }
 }
@@ -37,30 +42,32 @@ impl<'a, C> PlatformApplication<C> for ConsensusAbciApplication<'a, C> {
     }
 }
 
+impl<'a, C> BlockExecutionApplication for ConsensusAbciApplication<'a, C> {
+    fn block_execution_context(&self) -> &RefCell<Option<BlockExecutionContext>> {
+        &self.block_execution_context
+    }
+}
+
 impl<'a, C> TransactionalApplication<'a> for ConsensusAbciApplication<'a, C> {
     /// create and store a new transaction
     fn start_transaction(&self) {
         let transaction = self.platform.drive.grove.start_transaction();
-        self.transaction.write().unwrap().replace(transaction);
+        self.transaction.borrow_mut().replace(transaction);
     }
 
-    fn transaction(&self) -> &RwLock<Option<Transaction<'a>>> {
+    fn transaction(&self) -> &RefCell<Option<Transaction<'a>>> {
         &self.transaction
     }
 
     /// Commit a transaction
-    fn commit_transaction(&self) -> Result<(), Error> {
-        let transaction = self
-            .transaction
-            .write()
-            .unwrap()
-            .take()
-            .ok_or(Error::Execution(ExecutionError::NotInTransaction(
-                "trying to commit a transaction, but we are not in one",
-            )))?;
-
-        let platform_state = self.platform.state.read();
-        let platform_version = platform_state.current_platform_version()?;
+    fn commit_transaction(&self, platform_version: &PlatformVersion) -> Result<(), Error> {
+        let transaction =
+            self.transaction
+                .take()
+                .ok_or(Error::Execution(ExecutionError::NotInTransaction(
+                    "trying to commit a transaction, but we are not in one",
+                )))?;
+
         self.platform
             .drive
             .commit_transaction(transaction, &platform_version.drive)

packages/rs-drive-abci/src/abci/app/full.rs

@@ -1,13 +1,18 @@
-use crate::abci::app::{PlatformApplication, TransactionalApplication};
+use crate::abci::app::{
+    BlockExecutionApplication, ConsensusAbciApplication, PlatformApplication,
+    TransactionalApplication,
+};
 use crate::abci::handler;
 use crate::abci::handler::error::error_into_exception;
 use crate::error::execution::ExecutionError;
 use crate::error::Error;
+use crate::execution::types::block_execution_context::BlockExecutionContext;
 use crate::platform_types::platform::Platform;
 use crate::rpc::core::CoreRPCLike;
+use dpp::version::PlatformVersion;
 use drive::grovedb::Transaction;
+use std::cell::RefCell;
 use std::fmt::Debug;
-use std::sync::RwLock;
 use tenderdash_abci::proto::abci as proto;
 
 /// AbciApp is an implementation of ABCI Application, as defined by Tenderdash.
@@ -17,16 +22,19 @@ use tenderdash_abci::proto::abci as proto;
 pub struct FullAbciApplication<'a, C> {
     /// Platform
     pub platform: &'a Platform<C>,
-    /// The current transaction
-    pub transaction: RwLock<Option<Transaction<'a>>>,
+    /// The current GroveDB transaction
+    pub transaction: RefCell<Option<Transaction<'a>>>,
+    /// The current block execution context
+    pub block_execution_context: RefCell<Option<BlockExecutionContext>>,
 }
 
 impl<'a, C> FullAbciApplication<'a, C> {
     /// Create new ABCI app
     pub fn new(platform: &'a Platform<C>) -> Self {
         Self {
             platform,
-            transaction: RwLock::new(None),
+            transaction: Default::default(),
+            block_execution_context: Default::default(),
         }
     }
 }
@@ -37,29 +45,32 @@ impl<'a, C> PlatformApplication<C> for FullAbciApplication<'a, C> {
     }
 }
 
+impl<'a, C> BlockExecutionApplication for FullAbciApplication<'a, C> {
+    fn block_execution_context(&self) -> &RefCell<Option<BlockExecutionContext>> {
+        &self.block_execution_context
+    }
+}
+
 impl<'a, C> TransactionalApplication<'a> for FullAbciApplication<'a, C> {
     /// create and store a new transaction
     fn start_transaction(&self) {
         let transaction = self.platform.drive.grove.start_transaction();
-        self.transaction.write().unwrap().replace(transaction);
+        self.transaction.borrow_mut().replace(transaction);
     }
 
-    fn transaction(&self) -> &RwLock<Option<Transaction<'a>>> {
+    fn transaction(&self) -> &RefCell<Option<Transaction<'a>>> {
         &self.transaction
     }
 
     /// Commit a transaction
-    fn commit_transaction(&self) -> Result<(), Error> {
-        let transaction = self
-            .transaction
-            .write()
-            .unwrap()
-            .take()
-            .ok_or(Error::Execution(ExecutionError::NotInTransaction(
-                "trying to commit a transaction, but we are not in one",
-            )))?;
-        let platform_state = self.platform.state.read();
-        let platform_version = platform_state.current_platform_version()?;
+    fn commit_transaction(&self, platform_version: &PlatformVersion) -> Result<(), Error> {
+        let transaction =
+            self.transaction
+                .take()
+                .ok_or(Error::Execution(ExecutionError::NotInTransaction(
+                    "trying to commit a transaction, but we are not in one",
+                )))?;
+
         self.platform
             .drive
             .commit_transaction(transaction, &platform_version.drive)

packages/rs-drive-abci/src/abci/app/mod.rs

@@ -1,17 +1,19 @@
 use crate::error::Error;
 use crate::platform_types::platform::Platform;
 use drive::grovedb::Transaction;
-use std::sync::RwLock;
+use std::cell::RefCell;
 
 mod check_tx;
 mod consensus;
 /// Convert state transition execution result into ABCI response
 pub mod execution_result;
 mod full;
 
+use crate::execution::types::block_execution_context::BlockExecutionContext;
 use crate::rpc::core::DefaultCoreRPC;
 pub use check_tx::CheckTxAbciApplication;
 pub use consensus::ConsensusAbciApplication;
+use dpp::version::PlatformVersion;
 pub use full::FullAbciApplication;
 
 /// Platform-based ABCI application
@@ -26,8 +28,14 @@ pub trait TransactionalApplication<'a> {
     fn start_transaction(&self);
 
     /// Returns the current transaction
-    fn transaction(&self) -> &RwLock<Option<Transaction<'a>>>;
+    fn transaction(&self) -> &RefCell<Option<Transaction<'a>>>;
 
     /// Commits created transaction
-    fn commit_transaction(&self) -> Result<(), Error>;
+    fn commit_transaction(&self, platform_version: &PlatformVersion) -> Result<(), Error>;
+}
+
+/// Application that executes blocks and need to keep context between handlers
+pub trait BlockExecutionApplication {
+    /// Returns the current block execution context
+    fn block_execution_context(&self) -> &RefCell<Option<BlockExecutionContext>>;
 }

packages/rs-drive-abci/src/abci/handler/check_tx.rs

@@ -16,12 +16,16 @@ where
 {
     let _timer = crate::metrics::abci_request_duration("check_tx");
 
-    let platform_state = platform.state.read();
+    let platform_state = platform.state.load();
     let platform_version = platform_state.current_platform_version()?;
-    drop(platform_state);
 
     let proto::RequestCheckTx { tx, r#type } = request;
-    match platform.check_tx(tx.as_slice(), r#type.try_into()?, platform_version) {
+    match platform.check_tx(
+        tx.as_slice(),
+        r#type.try_into()?,
+        &platform_state,
+        platform_version,
+    ) {
         Ok(validation_result) => {
             let first_consensus_error = validation_result.errors.first();
 

packages/rs-drive-abci/src/abci/handler/extend_vote.rs

@@ -1,4 +1,4 @@
-use crate::abci::app::{PlatformApplication, TransactionalApplication};
+use crate::abci::app::{BlockExecutionApplication, PlatformApplication, TransactionalApplication};
 use crate::abci::AbciError;
 use crate::error::execution::ExecutionError;
 use crate::error::Error;
@@ -14,7 +14,7 @@ pub fn extend_vote<'a, A, C>(
     request: proto::RequestExtendVote,
 ) -> Result<proto::ResponseExtendVote, Error>
 where
-    A: PlatformApplication<C> + TransactionalApplication<'a>,
+    A: PlatformApplication<C> + TransactionalApplication<'a> + BlockExecutionApplication,
     C: CoreRPCLike,
 {
     let _timer = crate::metrics::abci_request_duration("extend_vote");
@@ -24,24 +24,22 @@ where
         height,
         round,
     } = request;
-    let guarded_block_execution_context = app.platform().block_execution_context.read().unwrap();
-    let block_execution_context =
-        guarded_block_execution_context
-            .as_ref()
-            .ok_or(Error::Execution(ExecutionError::CorruptedCodeExecution(
-                "block execution context must be set in block begin handler for extend vote",
-            )))?;
+    let block_execution_context_ref = app.block_execution_context().borrow();
+    let block_execution_context = block_execution_context_ref
+        .as_ref()
+        .ok_or(Error::Execution(ExecutionError::CorruptedCodeExecution(
+            "block execution context must be set in block begin handler for extend vote",
+        )))?;
 
     // Verify Tenderdash that it called this handler correctly
     let block_state_info = &block_execution_context.block_state_info();
 
     if !block_state_info.matches_current_block(height as u64, round as u32, block_hash.clone())? {
-        return Err(Error::from(AbciError::RequestForWrongBlockReceived(format!(
+        return Err(AbciError::RequestForWrongBlockReceived(format!(
             "received extend vote request for height: {} round: {}, block: {};  expected height: {} round: {}, block: {}",
             height, round, hex::encode(block_hash),
             block_state_info.height(), block_state_info.round(), block_state_info.block_hash().map(hex::encode).unwrap_or("None".to_string())
-        )))
-            .into());
+        )).into());
     }
 
     // Extend vote with unsigned withdrawal transactions