feat(platform)!: withdrawal limits

packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_credit_withdrawal_transition_amount_error.rs

@@ -10,7 +10,7 @@ use bincode::{Decode, Encode};
 #[derive(
     Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize,
 )]
-#[error("Credit withdrawal amount {amount} must be greater or equal to {min_amount}")]
+#[error("Credit withdrawal amount {amount} must be greater or equal to {min_amount} and less than {max_amount}")]
 #[platform_serialize(unversioned)]
 pub struct InvalidIdentityCreditWithdrawalTransitionAmountError {
     /*
@@ -20,11 +20,16 @@ pub struct InvalidIdentityCreditWithdrawalTransitionAmountError {
     */
     pub amount: u64,
     pub min_amount: u64,
+    pub max_amount: u64,
 }
 
 impl InvalidIdentityCreditWithdrawalTransitionAmountError {
-    pub fn new(amount: u64, min_amount: u64) -> Self {
-        Self { amount, min_amount }
+    pub fn new(amount: u64, min_amount: u64, max_amount: u64) -> Self {
+        Self {
+            amount,
+            min_amount,
+            max_amount,
+        }
     }
 
     pub fn amount(&self) -> u64 {
@@ -34,6 +39,10 @@ impl InvalidIdentityCreditWithdrawalTransitionAmountError {
     pub fn min_amount(&self) -> u64 {
         self.min_amount
     }
+
+    pub fn max_amount(&self) -> u64 {
+        self.max_amount
+    }
 }
 
 impl From<InvalidIdentityCreditWithdrawalTransitionAmountError> for ConsensusError {

packages/rs-dpp/src/identity/core_script.rs

@@ -51,6 +51,16 @@ impl CoreScript {
         Self::from_bytes(bytes)
     }
 
+    pub fn new_p2sh(script_hash: [u8; 20]) -> Self {
+        let mut bytes = vec![
+            opcodes::all::OP_HASH160.to_u8(),
+            opcodes::all::OP_PUSHBYTES_20.to_u8(),
+        ];
+        bytes.extend_from_slice(&script_hash);
+        bytes.push(opcodes::all::OP_EQUAL.to_u8());
+        Self::from_bytes(bytes)
+    }
+
     pub fn random_p2pkh(rng: &mut StdRng) -> Self {
         Self::new_p2pkh(rng.gen::<[u8; 20]>())
     }

packages/rs-dpp/src/withdrawal/daily_withdrawal_limit/mod.rs

@@ -0,0 +1,18 @@
+use crate::fee::Credits;
+use crate::withdrawal::daily_withdrawal_limit::v0::daily_withdrawal_limit_v0;
+use crate::ProtocolError;
+use platform_version::version::PlatformVersion;
+
+mod v0;
+
+pub fn daily_withdrawal_limit(
+    total_credits_in_platform: Credits,
+    platform_version: &PlatformVersion,
+) -> Result<Credits, ProtocolError> {
+    match platform_version.dpp.methods.daily_withdrawal_limit {
+        0 => Ok(daily_withdrawal_limit_v0(total_credits_in_platform)),
+        v => Err(ProtocolError::UnknownVersionError(format!(
+            "Unknown daily_withdrawal_limit version {v}"
+        ))),
+    }
+}

packages/rs-dpp/src/withdrawal/daily_withdrawal_limit/v0/mod.rs

@@ -0,0 +1,31 @@
+use crate::fee::Credits;
+use crate::ProtocolError;
+
+/// Calculates the daily withdrawal limit based on the total credits available in the platform.
+///
+/// The function enforces the following rules:
+///
+/// 1. If the total credits are 1000 or more:
+///     - The withdrawal limit is set to 10% of the total credits.
+/// 2. If the total credits are between 100 and 999:
+///     - The withdrawal limit is capped at 100 credits.
+/// 3. If the total credits are less than 100:
+///     - The withdrawal limit is the total available credits, as no more than the available amount can be withdrawn.
+///
+/// # Parameters
+///
+/// * `total_credits_in_platform`: The total amount of credits available in the platform.
+///
+/// # Returns
+///
+/// * `Credits`: The calculated daily withdrawal limit based on the available credits.
+///
+pub fn daily_withdrawal_limit_v0(total_credits_in_platform: Credits) -> Credits {
+    if total_credits_in_platform >= 1000 {
+        total_credits_in_platform / 10
+    } else if total_credits_in_platform >= 100 {
+        100
+    } else {
+        total_credits_in_platform
+    }
+}

packages/rs-dpp/src/withdrawal/mod.rs

@@ -1,3 +1,4 @@
+pub mod daily_withdrawal_limit;
 #[cfg(feature = "system_contracts")]
 mod document_try_into_asset_unlock_base_transaction_info;
 
@@ -19,4 +20,6 @@ pub enum Pooling {
 pub type WithdrawalTransactionIndex = u64;
 
 /// Simple type alias for withdrawal transaction with it's index
+
 pub type WithdrawalTransactionIndexAndBytes = (WithdrawalTransactionIndex, Vec<u8>);
+pub type WithdrawalTransactionIndexAndBytesAndAmounts = (WithdrawalTransactionIndex, Vec<u8>, u64);

packages/rs-drive-abci/src/execution/engine/initialization/init_chain/v0/mod.rs

@@ -13,7 +13,7 @@ use crate::platform_types::platform_state::PlatformState;
 use crate::platform_types::validator_set::ValidatorSetExt;
 use dpp::version::PlatformVersion;
 use std::sync::Arc;
-use tenderdash_abci::proto::abci::{RequestInitChain, ResponseInitChain, ValidatorSetUpdate};
+use tenderdash_abci::proto::abci::{RequestInitChain, ResponseInitChain};
 use tenderdash_abci::proto::google::protobuf::Timestamp;
 use tenderdash_abci::proto::serializers::timestamp::FromMilis;
 

packages/rs-drive-abci/src/execution/engine/run_block_proposal/mod.rs

@@ -91,8 +91,20 @@ Your software version: {}, latest supported protocol version: {}."#,
                 );
             };
 
-            // Set current protocol version to the block platform state
-            block_platform_state.set_current_protocol_version_in_consensus(next_protocol_version);
+            let old_protocol_version = block_platform_state.current_protocol_version_in_consensus();
+
+            if old_protocol_version != next_protocol_version {
+                // Set current protocol version to the block platform state
+                block_platform_state
+                    .set_current_protocol_version_in_consensus(next_protocol_version);
+                // This is for events like adding stuff to the root tree, or making structural changes/fixes
+                self.perform_events_on_first_block_of_protocol_change(
+                    &epoch_info,
+                    transaction,
+                    old_protocol_version,
+                    next_platform_version,
+                )?;
+            }
 
             next_platform_version
         } else {

packages/rs-drive-abci/src/execution/platform_events/protocol_upgrade/mod.rs

@@ -1,2 +1,3 @@
 mod check_for_desired_protocol_upgrade;
+mod perform_events_on_first_block_of_protocol_change;
 mod upgrade_protocol_version;

packages/rs-drive-abci/src/execution/platform_events/protocol_upgrade/perform_events_on_first_block_of_protocol_change/mod.rs

@@ -0,0 +1,71 @@
+mod v0;
+
+use crate::error::execution::ExecutionError;
+use crate::error::Error;
+use crate::platform_types::epoch_info::EpochInfo;
+use crate::platform_types::platform::Platform;
+use dpp::version::PlatformVersion;
+use dpp::version::ProtocolVersion;
+use drive::grovedb::Transaction;
+
+impl<C> Platform<C> {
+    /// Executes specific events that need to be performed on the first block of a protocol change.
+    ///
+    /// # Parameters
+    ///
+    /// - `&self`: A reference to the current instance of the struct implementing this function.
+    /// - `block_info`: Information about the current block, encapsulated in a `BlockInfo` struct.
+    /// - `epoch_info`: Information about the current epoch, encapsulated in an `EpochInfo` struct.
+    /// - `last_committed_platform_state`: The state of the platform as it was after the last committed block, before the protocol change.
+    /// - `block_platform_state`: A mutable reference to the platform state that will be modified for the current block.
+    /// - `transaction`: The transaction object representing the current transaction context.
+    /// - `platform_version`: The version of the platform being executed, encapsulated in a `PlatformVersion` struct.
+    ///
+    /// # Returns
+    ///
+    /// - `Result<(), Error>`: Returns `Ok(())` if the events are successfully executed.
+    ///   Returns an `Error` if there is a version mismatch or another execution issue.
+    ///
+    /// # Errors
+    ///
+    /// - Returns an `Error::Execution(ExecutionError::UnknownVersionMismatch)` if an unknown version is received
+    ///   that is not supported by the current implementation.
+    ///
+    /// # Versioning
+    ///
+    /// This function uses the `platform_version` parameter to determine which version-specific implementation
+    /// of the protocol change events should be executed:
+    ///
+    /// - If the version is `0`, it calls the `perform_events_on_first_block_of_protocol_change_v0` function,
+    ///   which contains the logic for version `0`.
+    /// - If no version is specified (`None`), the function does nothing and returns `Ok(())`.
+    /// - If a different version is specified, it returns an error indicating an unknown version mismatch.
+    ///
+    pub fn perform_events_on_first_block_of_protocol_change(
+        &self,
+        epoch_info: &EpochInfo,
+        transaction: &Transaction,
+        previous_protocol_version: ProtocolVersion,
+        platform_version: &PlatformVersion,
+    ) -> Result<(), Error> {
+        match platform_version
+            .drive_abci
+            .methods
+            .protocol_upgrade
+            .perform_events_on_first_block_of_protocol_change
+        {
+            Some(0) => self.perform_events_on_first_block_of_protocol_change_v0(
+                epoch_info,
+                transaction,
+                previous_protocol_version,
+                platform_version,
+            ),
+            None => return Ok(()),
+            Some(version) => Err(Error::Execution(ExecutionError::UnknownVersionMismatch {
+                method: "perform_events_on_first_block_of_protocol_change".to_string(),
+                known_versions: vec![0],
+                received: version,
+            })),
+        }
+    }
+}

packages/rs-drive-abci/src/execution/platform_events/protocol_upgrade/perform_events_on_first_block_of_protocol_change/v0/mod.rs

@@ -0,0 +1,36 @@
+use crate::error::Error;
+use crate::platform_types::epoch_info::EpochInfo;
+use crate::platform_types::platform::Platform;
+use dpp::version::PlatformVersion;
+use dpp::version::ProtocolVersion;
+use drive::drive::identity::withdrawals::paths::{
+    get_withdrawal_root_path, WITHDRAWAL_TRANSACTIONS_SUM_AMOUNT_TREE_KEY,
+};
+use drive::drive::RootTree;
+use drive::grovedb::{Element, Transaction};
+
+impl<C> Platform<C> {
+    /// checks for a network upgrade and resets activation window
+    /// this should only be called on epoch change
+    pub(super) fn perform_events_on_first_block_of_protocol_change_v0(
+        &self,
+        _epoch_info: &EpochInfo,
+        transaction: &Transaction,
+        previous_protocol_version: ProtocolVersion,
+        platform_version: &PlatformVersion,
+    ) -> Result<(), Error> {
+        if previous_protocol_version < 4 && platform_version.protocol_version >= 4 {
+            let path = get_withdrawal_root_path();
+            self.drive.grove_insert_if_not_exists(
+                (&path).into(),
+                &WITHDRAWAL_TRANSACTIONS_SUM_AMOUNT_TREE_KEY,
+                Element::empty_sum_tree(),
+                Some(transaction),
+                None,
+                &platform_version.drive,
+            )?;
+        }
+
+        Ok(())
+    }
+}

packages/rs-drive-abci/src/execution/platform_events/withdrawals/append_signatures_and_broadcast_withdrawal_transactions/v0/mod.rs

@@ -10,7 +10,7 @@ use dashcore_rpc::Error as CoreRPCError;
 use dpp::dashcore::bls_sig_utils::BLSSignature;
 use dpp::dashcore::transaction::special_transaction::TransactionPayload::AssetUnlockPayloadType;
 use dpp::dashcore::{consensus, Transaction, Txid};
-use std::collections::{BTreeMap, HashMap};
+use std::collections::BTreeMap;
 
 use std::fs::{self, File};
 use std::io::Write;

packages/rs-drive-abci/src/execution/platform_events/withdrawals/build_untied_withdrawal_transactions_from_documents/mod.rs

@@ -4,8 +4,12 @@ use crate::platform_types::platform::Platform;
 use crate::rpc::core::CoreRPCLike;
 use dpp::block::block_info::BlockInfo;
 use dpp::document::Document;
+use dpp::fee::Credits;
 use dpp::version::PlatformVersion;
-use dpp::withdrawal::{WithdrawalTransactionIndex, WithdrawalTransactionIndexAndBytes};
+use dpp::withdrawal::{
+    WithdrawalTransactionIndex, WithdrawalTransactionIndexAndBytes,
+    WithdrawalTransactionIndexAndBytesAndAmounts,
+};
 
 mod v0;
 
@@ -35,7 +39,7 @@ where
         start_index: WithdrawalTransactionIndex,
         block_info: &BlockInfo,
         platform_version: &PlatformVersion,
-    ) -> Result<Vec<WithdrawalTransactionIndexAndBytes>, Error> {
+    ) -> Result<(Vec<WithdrawalTransactionIndexAndBytes>, Credits), Error> {
         match platform_version
             .drive_abci
             .methods