refactor: introduce dash-serialized-consensus-error-bin header to avoid CBOR

Author: shumkov

packages/dapi/lib/grpcServer/handlers/createGrpcErrorFromDriveResponse.js

@@ -64,6 +64,9 @@ async function createGrpcErrorFromDriveResponse(code, info) {
   const message = decodedInfo.message;
   const data = decodedInfo.data || {};
 
+  const serializedConsensusError = data.serializedError;
+  delete data.serializedError;
+
   // gRPC error codes
   if (code <= 16) {
     const CommonErrorClass = COMMON_ERROR_CLASSES[code.toString()];
@@ -111,6 +114,12 @@ async function createGrpcErrorFromDriveResponse(code, info) {
 
   // DPP errors
   if (code >= 10000 && code < 50000) {
+    const consensusMetadata = {
+      code,
+      ...createRawMetadata(data),
+      'dash-serialized-consensus-error-bin': serializedConsensusError
+    };
+
     let consensusError;
     try {
       consensusError = deserializeConsensusError(data.serializedError || []);
@@ -128,7 +137,7 @@ async function createGrpcErrorFromDriveResponse(code, info) {
     if (code >= 10000 && code < 20000) {
       return new InvalidArgumentGrpcError(
         consensusError.message,
-        { code, ...createRawMetadata(data) },
+        consensusMetadata,
       );
     }
 
@@ -137,23 +146,23 @@ async function createGrpcErrorFromDriveResponse(code, info) {
       return new GrpcError(
         GrpcErrorCodes.UNAUTHENTICATED,
         consensusError.message,
-        { code, ...createRawMetadata(data) },
+        consensusMetadata,
       );
     }
 
     // Fee
     if (code >= 30000 && code < 40000) {
       return new FailedPreconditionGrpcError(
         consensusError.message,
-        { code, ...createRawMetadata(data) },
+        consensusMetadata,
       );
     }
 
     // State
     if (code >= 40000 && code < 50000) {
       return new InvalidArgumentGrpcError(
         consensusError.message,
-        { code, ...createRawMetadata(data) },
+        consensusMetadata,
       );
     }
   }

packages/js-dapi-client/lib/transport/GrpcTransport/createGrpcTransportError.js

@@ -119,7 +119,13 @@ async function createGrpcTransportError(grpcError, dapiAddress) {
 
   // DPP consensus errors
   if (code >= 10000 && code < 50000) {
-    const consensusError = deserializeConsensusError(data.serializedError || []);
+    const consensusErrorString = metadata['dash-serialized-consensus-error-bin'];
+    if (!consensusErrorString) {
+      throw new Error(`Can't deserialize consensus error ${code}: serialized data is missing`);
+    }
+
+    const consensusErrorBytes = Buffer.from(consensusErrorString, 'base64');
+    const consensusError = deserializeConsensusError(consensusErrorBytes);
 
     delete data.serializedError;
 

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

@@ -11,10 +11,7 @@
 //!
 //! See `tests/mock_dapi_client.rs` for an example.
 
-use crate::{
-    transport::{TransportClient, TransportRequest},
-    DapiClientError, DapiRequestExecutor, RequestSettings,
-};
+use crate::{transport::TransportRequest, DapiClientError, DapiRequestExecutor, RequestSettings};
 use dapi_grpc::mock::Mockable;
 use dapi_grpc::tonic::async_trait;
 use hex::ToHex;
@@ -74,12 +71,12 @@ impl MockDapiClient {
     ///
     /// Panics if the file can't be read or the data can't be parsed.
     #[cfg(feature = "dump")]
-    pub fn load<T: TransportRequest, P: AsRef<std::path::Path>>(
+    pub fn load<T, P: AsRef<std::path::Path>>(
         &mut self,
         file: P,
     ) -> Result<(T, MockResult<T>), std::io::Error>
     where
-        T: Mockable,
+        T: TransportRequest + Mockable,
         T::Response: Mockable,
     {
         use crate::DumpData;

packages/rs-sdk/src/error.rs

@@ -74,11 +74,14 @@ pub enum Error {
     StaleNode(#[from] StaleNodeError),
 }
 
-// TODO: Return a more specific errors like connection, node error instead of DAPI client error
+// TODO: Decompose DapiClientError to more specific errors like connection, node error instead of DAPI client error
 impl From<DapiClientError> for Error {
     fn from(value: DapiClientError) -> Self {
         if let DapiClientError::Transport(TransportError::Grpc(status), _) = &value {
-            if let Some(consensus_error_value) = status.metadata().get_bin("drive-error-data-bin") {
+            if let Some(consensus_error_value) = status
+                .metadata()
+                .get_bin("dash-serialized-consensus-error-bin")
+            {
                 return ConsensusError::deserialize_from_bytes(
                     consensus_error_value.as_encoded_bytes(),
                 )