feat(sdk): asset lock quorum and core locked height verification

packages/dapi-grpc/build.rs

@@ -63,82 +63,87 @@ fn configure_platform(mut platform: MappingConfig) -> MappingConfig {
     // Derive features for versioned messages
     //
     // "GetConsensusParamsRequest" is excluded as this message does not support proofs
-    const VERSIONED_REQUESTS: [&str; 34] = [
+    //
+    // Sort alphabetically to simplify maintenance.
+    const VERSIONED_REQUESTS: [&str; 35] = [
+        "GetContestedResourceIdentityVotesRequest",
+        "GetContestedResourcesRequest",
+        "GetContestedResourceVoteStateRequest",
+        "GetContestedResourceVotersForIdentityRequest",
         "GetDataContractHistoryRequest",
         "GetDataContractRequest",
         "GetDataContractsRequest",
         "GetDocumentsRequest",
+        "GetEpochsInfoRequest",
+        "GetEvonodesProposedEpochBlocksByIdsRequest",
+        "GetEvonodesProposedEpochBlocksByRangeRequest",
+        "GetIdentitiesBalancesRequest",
         "GetIdentitiesByPublicKeyHashesRequest",
+        "GetIdentitiesContractKeysRequest",
         "GetIdentitiesRequest",
-        "GetIdentitiesBalancesRequest",
-        "GetIdentityNonceRequest",
-        "GetIdentityContractNonceRequest",
+        "GetIdentitiesTokenBalancesRequest",
+        "GetIdentitiesTokenInfosRequest",
         "GetIdentityBalanceAndRevisionRequest",
         "GetIdentityBalanceRequest",
         "GetIdentityByPublicKeyHashRequest",
+        "GetIdentityContractNonceRequest",
         "GetIdentityKeysRequest",
+        "GetIdentityNonceRequest",
         "GetIdentityRequest",
+        "GetIdentityTokenBalancesRequest",
+        "GetIdentityTokenInfosRequest",
+        "GetPathElementsRequest",
+        "GetPrefundedSpecializedBalanceRequest",
         "GetProofsRequest",
-        "WaitForStateTransitionResultRequest",
         "GetProtocolVersionUpgradeStateRequest",
         "GetProtocolVersionUpgradeVoteStatusRequest",
-        "GetPathElementsRequest",
-        "GetIdentitiesContractKeysRequest",
-        "GetPrefundedSpecializedBalanceRequest",
-        "GetContestedResourcesRequest",
-        "GetContestedResourceVoteStateRequest",
-        "GetContestedResourceVotersForIdentityRequest",
-        "GetContestedResourceIdentityVotesRequest",
-        "GetVotePollsByEndDateRequest",
-        "GetTotalCreditsInPlatformRequest",
-        "GetEvonodesProposedEpochBlocksByIdsRequest",
-        "GetEvonodesProposedEpochBlocksByRangeRequest",
         "GetStatusRequest",
-        "GetIdentityTokenBalancesRequest",
-        "GetIdentitiesTokenBalancesRequest",
-        "GetIdentityTokenInfosRequest",
-        "GetIdentitiesTokenInfosRequest",
+        "GetTotalCreditsInPlatformRequest",
+        "GetVotePollsByEndDateRequest",
+        "WaitForStateTransitionResultRequest",
     ];
 
     // The following responses are excluded as they don't support proofs:
     // - "GetConsensusParamsResponse"
     // - "GetStatusResponse"
     //
     //  "GetEvonodesProposedEpochBlocksResponse" is used for 2 Requests
+    //
+    // Sort alphabetically to simplify maintenance.
     const VERSIONED_RESPONSES: [&str; 33] = [
+        "GetContestedResourceIdentityVotesResponse",
+        "GetContestedResourcesResponse",
+        "GetContestedResourceVoteStateResponse",
+        "GetContestedResourceVotersForIdentityResponse",
         "GetDataContractHistoryResponse",
         "GetDataContractResponse",
         "GetDataContractsResponse",
         "GetDocumentsResponse",
-        "GetIdentitiesByPublicKeyHashesResponse",
-        "GetIdentitiesResponse",
-        "GetIdentitiesBalancesResponse",
+        "GetEpochsInfoResponse",
+        "GetEvonodesProposedEpochBlocksResponse",
         "GetIdentityBalanceAndRevisionResponse",
         "GetIdentityBalanceResponse",
-        "GetIdentityNonceResponse",
-        "GetIdentityContractNonceResponse",
         "GetIdentityByPublicKeyHashResponse",
+        "GetIdentityContractNonceResponse",
         "GetIdentityKeysResponse",
+        "GetIdentityNonceResponse",
         "GetIdentityResponse",
+        "GetIdentityTokenBalancesResponse",
+        "GetIdentityTokenInfosResponse",
+        "GetIdentitiesBalancesResponse",
+        "GetIdentitiesByPublicKeyHashesResponse",
+        "GetIdentitiesContractKeysResponse",
+        "GetIdentitiesResponse",
+        "GetIdentitiesTokenBalancesResponse",
+        "GetIdentitiesTokenInfosResponse",
+        "GetPathElementsResponse",
+        "GetPrefundedSpecializedBalanceResponse",
         "GetProofsResponse",
-        "WaitForStateTransitionResultResponse",
-        "GetEpochsInfoResponse",
         "GetProtocolVersionUpgradeStateResponse",
         "GetProtocolVersionUpgradeVoteStatusResponse",
-        "GetPathElementsResponse",
-        "GetIdentitiesContractKeysResponse",
-        "GetPrefundedSpecializedBalanceResponse",
-        "GetContestedResourcesResponse",
-        "GetContestedResourceVoteStateResponse",
-        "GetContestedResourceVotersForIdentityResponse",
-        "GetContestedResourceIdentityVotesResponse",
-        "GetVotePollsByEndDateResponse",
         "GetTotalCreditsInPlatformResponse",
-        "GetEvonodesProposedEpochBlocksResponse",
-        "GetIdentityTokenBalancesResponse",
-        "GetIdentitiesTokenBalancesResponse",
-        "GetIdentityTokenInfosResponse",
-        "GetIdentitiesTokenInfosResponse",
+        "GetVotePollsByEndDateResponse",
+        "WaitForStateTransitionResultResponse",
     ];
 
     check_unique(&VERSIONED_REQUESTS).expect("VERSIONED_REQUESTS");

packages/rs-dapi-client/src/executor.rs

@@ -1,6 +1,7 @@
 use crate::transport::TransportRequest;
 use crate::{Address, CanRetry, DapiClientError, RequestSettings};
 use dapi_grpc::mock::Mockable;
+use dapi_grpc::platform::VersionedGrpcResponse;
 use dapi_grpc::tonic::async_trait;
 use std::fmt::Debug;
 
@@ -127,6 +128,22 @@ where
     }
 }
 
+impl<T: VersionedGrpcResponse> VersionedGrpcResponse for ExecutionResponse<T> {
+    type Error = T::Error;
+
+    fn metadata(&self) -> Result<&dapi_grpc::platform::v0::ResponseMetadata, Self::Error> {
+        self.inner.metadata()
+    }
+
+    fn proof(&self) -> Result<&dapi_grpc::platform::v0::Proof, Self::Error> {
+        self.inner.proof()
+    }
+
+    fn proof_owned(self) -> Result<dapi_grpc::platform::v0::Proof, Self::Error> {
+        self.inner.proof_owned()
+    }
+}
+
 /// Result of request execution
 pub type ExecutionResult<R, E> = Result<ExecutionResponse<R>, ExecutionError<E>>;
 

packages/rs-dpp/Cargo.toml

@@ -14,7 +14,7 @@ authors = [
 [dependencies]
 anyhow = { version = "1.0.81" }
 async-trait = { version = "0.1.79" }
-ordered-float = { version = "4.6.0", features = ["serde"]}
+ordered-float = { version = "4.6.0", features = ["serde"] }
 base64 = "0.22.1"
 bs58 = "0.5"
 byteorder = { version = "1.4" }

packages/rs-dpp/src/core_types/validator_set/v0/mod.rs

@@ -311,7 +311,7 @@ mod tests {
         let node_ip = "192.168.1.1".to_string();
         let node_id = PubkeyHash::from_slice(&[4; 20]).unwrap();
         let validator = ValidatorV0 {
-            pro_tx_hash: pro_tx_hash.clone(),
+            pro_tx_hash,
             public_key,
             node_ip,
             node_id,

packages/rs-sdk/src/error.rs

@@ -55,6 +55,37 @@ pub enum Error {
     /// Epoch not found; we must have at least one epoch
     #[error("No epoch found on Platform; it should never happen")]
     EpochNotFound,
+    /// Quorum not found; try again later
+    #[error(
+        "Quorum {quorum_hash_hex} of type {quorum_type} at height {core_chain_locked_height}: {e}"
+    )]
+    QuorumNotFound {
+        quorum_hash_hex: String,
+        quorum_type: u32,
+        core_chain_locked_height: u32,
+        e: ContextProviderError,
+    },
+
+    /// Asset lock not found; try again later.
+    ///
+    /// ## Parameters
+    ///
+    /// - core locked height in asset lock
+    /// - current core locked height on the platform
+    #[error("Asset lock for core locked height {core_locked_height_in_asset_lock} not available yet, max avaiable locked core height is {core_locked_height_on_platform}; try again later")]
+    CoreLockedHeightNotYetAvailable {
+        core_locked_height_in_asset_lock: u32,
+        core_locked_height_on_platform: u32,
+    },
+
+    /// Provided asset lock is invalid
+    ///
+    /// ## Parameters
+    ///
+    /// - 0 - detailed error message
+    #[error("Invalid asset lock: {0}")]
+    InvalidAssetLock(String),
+
     /// SDK operation timeout reached error
     #[error("SDK operation timeout {} secs reached: {1}", .0.as_secs())]
     TimeoutReached(Duration, String),
@@ -100,7 +131,7 @@ impl TryFrom<StateTransitionBroadcastErrorProto> for StateTransitionBroadcastErr
     type Error = Error;
 
     fn try_from(value: StateTransitionBroadcastErrorProto) -> Result<Self, Self::Error> {
-        let cause = if value.data.len() > 0 {
+        let cause = if !value.data.is_empty() {
             let consensus_error =
                 ConsensusError::deserialize_from_bytes(&value.data).map_err(|e| {
                     tracing::debug!("Failed to deserialize consensus error: {}", e);
@@ -178,7 +209,13 @@ where
 
 impl CanRetry for Error {
     fn can_retry(&self) -> bool {
-        matches!(self, Error::StaleNode(..) | Error::TimeoutReached(_, _))
+        matches!(
+            self,
+            Error::StaleNode(..)
+                | Error::TimeoutReached(_, _)
+                | Error::CoreLockedHeightNotYetAvailable { .. }
+                | Error::QuorumNotFound { .. }
+        )
     }
 }
 

packages/rs-sdk/src/platform/fetch_unproved.rs

@@ -89,7 +89,7 @@ where
                 Self::maybe_from_unproved_with_metadata(
                     request.clone(),
                     response,
-                    sdk.network,
+                    sdk.core_network(),
                     sdk.version(),
                 )
                 .map_err(|e| ExecutionError {

packages/rs-sdk/src/platform/transition.rs

@@ -1,4 +1,5 @@
 //! State transitions used to put changed objects to the Dash Platform.
+pub mod asset_lock;
 pub mod broadcast;
 pub(crate) mod broadcast_identity;
 pub mod broadcast_request;

packages/rs-sdk/src/platform/transition/asset_lock.rs

@@ -0,0 +1,92 @@
+//! [AssetLockProof] utilities
+
+use crate::{Error, Sdk};
+use dapi_grpc::platform::v0::get_epochs_info_request::{self, GetEpochsInfoRequestV0};
+use dapi_grpc::platform::v0::GetEpochsInfoRequest;
+use dapi_grpc::platform::VersionedGrpcResponse;
+use dpp::prelude::AssetLockProof;
+use rs_dapi_client::{DapiRequestExecutor, RequestSettings};
+
+#[async_trait::async_trait]
+pub trait AssetLockProofVerifier {
+    /// Verifies the asset lock proof against the platform.
+    ///
+    /// This function verifies some assertions that are necessary for the asset lock proof to be used by Dash Platform,
+    /// and errors if any of them are not met.
+    ///
+    /// Verification involves fetching some information from DAPI and comparing it with the provided asset lock proof.
+    ///
+    /// Note that positive verification result does not imply that the asset lock proof is valid. Dash Platform can
+    /// still reject the asset lock.
+    ///
+    /// # Limitations
+    ///
+    /// Only [AssetLockProof::Chain] is supported.
+    ///
+    /// # Errors
+    ///
+    /// - [Error::CoreLockedHeightNotYetAvailable] if the core locked height in the proof is higher than the
+    /// current core locked height on the platform. Try again later.
+    /// - [Error::QuorumNotFound] if the quorum public key is not yet available on the platform, what implies that
+    /// the quorum is not (yet) available. Try again later.
+    /// - [Error::InvalidSignature] if the signature in the proof is invalid.
+    /// - other errors when something goes wrong.
+    ///
+    /// # Unstable
+    ///
+    /// This function is unstable and may change in the future.
+    async fn verify(&self, sdk: &Sdk) -> Result<(), Error>;
+}
+
+#[async_trait::async_trait]
+impl AssetLockProofVerifier for AssetLockProof {
+    async fn verify(&self, sdk: &Sdk) -> Result<(), Error> {
+        match self {
+            AssetLockProof::Chain(asset_lock) => {
+                let platform_core_chain_locked_height = fetch_platform_locked_height(sdk).await?;
+                if asset_lock.core_chain_locked_height > platform_core_chain_locked_height {
+                    Err(Error::CoreLockedHeightNotYetAvailable {
+                        core_locked_height_in_asset_lock: asset_lock.core_chain_locked_height,
+                        core_locked_height_on_platform: platform_core_chain_locked_height,
+                    })
+                } else {
+                    Ok(())
+                }
+            }
+            AssetLockProof::Instant(instant_asset_lock_proof) => {
+                instant_asset_lock_proof.validate_structure(sdk.version())?;
+                // To verify instant asset lock, we need to:
+                //
+                // 1. Determine quorum hash used to sign it.
+                // 2. Detch quorum public key for this hash.
+                // 3. Verify instant asset lock signature.
+                //
+                // Unfortunately, determining quorum used to sign the instant asset lock is not straightforward,
+                // as it requires processing of SML which is not implemented in the SDK yet.
+                //
+                // So we just accept the instant asset lock as valid for now.
+
+                Ok(())
+            }
+        }
+    }
+}
+
+/// Fetches the current core chain locked height from the platform.
+async fn fetch_platform_locked_height(sdk: &Sdk) -> Result<u32, Error> {
+    // Retrieve current core chain lock info from the platform
+    // TODO: implement some caching mechanism to avoid fetching the same data multiple times
+    let request = GetEpochsInfoRequest {
+        version: Some(get_epochs_info_request::Version::V0(
+            GetEpochsInfoRequestV0 {
+                ascending: false,
+                count: 1,
+                prove: true,
+                start_epoch: None,
+            },
+        )),
+    };
+    let response = sdk.execute(request, RequestSettings::default()).await?;
+
+    Ok(response.metadata()?.core_chain_locked_height)
+}

packages/rs-sdk/src/platform/transition/put_identity.rs

@@ -1,3 +1,4 @@
+use crate::platform::block_info_from_metadata::block_info_from_metadata;
 use crate::platform::transition::broadcast_identity::BroadcastRequestForNewIdentity;
 use crate::{Error, Sdk};
 

packages/rs-sdk/src/platform/types/epoch.rs

@@ -9,7 +9,7 @@ use crate::{
     Error, Sdk,
 };
 
-/// Epoch type used in the SDK.
+/// Epoch information
 pub type Epoch = ExtendedEpochInfo;
 
 #[async_trait]