@dashevo/dapi-grpc 1.0.0-dev.4 → 1.0.0-dev.5

package/clients/platform/v0/web/platform_pb_service.d.ts

@@ -40,6 +40,24 @@ type PlatformgetIdentityKeys = {
   readonly responseType: typeof platform_pb.GetIdentityKeysResponse;
 };
 
+type PlatformgetIdentityNonce = {
+  readonly methodName: string;
+  readonly service: typeof Platform;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof platform_pb.GetIdentityNonceRequest;
+  readonly responseType: typeof platform_pb.GetIdentityNonceResponse;
+};
+
+type PlatformgetIdentityContractNonce = {
+  readonly methodName: string;
+  readonly service: typeof Platform;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof platform_pb.GetIdentityContractNonceRequest;
+  readonly responseType: typeof platform_pb.GetIdentityContractNonceResponse;
+};
+
 type PlatformgetIdentityBalance = {
   readonly methodName: string;
   readonly service: typeof Platform;
@@ -172,6 +190,8 @@ export class Platform {
   static readonly getIdentity: PlatformgetIdentity;
   static readonly getIdentities: PlatformgetIdentities;
   static readonly getIdentityKeys: PlatformgetIdentityKeys;
+  static readonly getIdentityNonce: PlatformgetIdentityNonce;
+  static readonly getIdentityContractNonce: PlatformgetIdentityContractNonce;
   static readonly getIdentityBalance: PlatformgetIdentityBalance;
   static readonly getIdentityBalanceAndRevision: PlatformgetIdentityBalanceAndRevision;
   static readonly getProofs: PlatformgetProofs;
@@ -256,6 +276,24 @@ export class PlatformClient {
     requestMessage: platform_pb.GetIdentityKeysRequest,
     callback: (error: ServiceError|null, responseMessage: platform_pb.GetIdentityKeysResponse|null) => void
   ): UnaryResponse;
+  getIdentityNonce(
+    requestMessage: platform_pb.GetIdentityNonceRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: platform_pb.GetIdentityNonceResponse|null) => void
+  ): UnaryResponse;
+  getIdentityNonce(
+    requestMessage: platform_pb.GetIdentityNonceRequest,
+    callback: (error: ServiceError|null, responseMessage: platform_pb.GetIdentityNonceResponse|null) => void
+  ): UnaryResponse;
+  getIdentityContractNonce(
+    requestMessage: platform_pb.GetIdentityContractNonceRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: platform_pb.GetIdentityContractNonceResponse|null) => void
+  ): UnaryResponse;
+  getIdentityContractNonce(
+    requestMessage: platform_pb.GetIdentityContractNonceRequest,
+    callback: (error: ServiceError|null, responseMessage: platform_pb.GetIdentityContractNonceResponse|null) => void
+  ): UnaryResponse;
   getIdentityBalance(
     requestMessage: platform_pb.GetIdentityBalanceRequest,
     metadata: grpc.Metadata,

package/clients/platform/v0/web/platform_pb_service.js

@@ -46,6 +46,24 @@ Platform.getIdentityKeys = {
   responseType: platform_pb.GetIdentityKeysResponse
 };
 
+Platform.getIdentityNonce = {
+  methodName: "getIdentityNonce",
+  service: Platform,
+  requestStream: false,
+  responseStream: false,
+  requestType: platform_pb.GetIdentityNonceRequest,
+  responseType: platform_pb.GetIdentityNonceResponse
+};
+
+Platform.getIdentityContractNonce = {
+  methodName: "getIdentityContractNonce",
+  service: Platform,
+  requestStream: false,
+  responseStream: false,
+  requestType: platform_pb.GetIdentityContractNonceRequest,
+  responseType: platform_pb.GetIdentityContractNonceResponse
+};
+
 Platform.getIdentityBalance = {
   methodName: "getIdentityBalance",
   service: Platform,
@@ -303,6 +321,68 @@ PlatformClient.prototype.getIdentityKeys = function getIdentityKeys(requestMessa
   };
 };
 
+PlatformClient.prototype.getIdentityNonce = function getIdentityNonce(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Platform.getIdentityNonce, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+PlatformClient.prototype.getIdentityContractNonce = function getIdentityContractNonce(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Platform.getIdentityContractNonce, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
 PlatformClient.prototype.getIdentityBalance = function getIdentityBalance(requestMessage, metadata, callback) {
   if (arguments.length === 2) {
     callback = arguments[1];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashevo/dapi-grpc",
-  "version": "1.0.0-dev.4",
+  "version": "1.0.0-dev.5",
   "description": "DAPI GRPC definition file and generated clients",
   "browser": "browser.js",
   "main": "node.js",
@@ -45,7 +45,7 @@
   },
   "homepage": "https://github.com/dashevo/dapi-grpc#readme",
   "dependencies": {
-    "@dashevo/grpc-common": "1.0.0-dev.4",
+    "@dashevo/grpc-common": "1.0.0-dev.5",
     "@dashevo/protobufjs": "6.10.5",
     "@grpc/grpc-js": "1.4.4",
     "@improbable-eng/grpc-web": "^0.15.0",

package/protos/platform/v0/platform.proto

@@ -12,6 +12,8 @@ service Platform {
   rpc getIdentity(GetIdentityRequest) returns (GetIdentityResponse);
   rpc getIdentities(GetIdentitiesRequest) returns (GetIdentitiesResponse);
   rpc getIdentityKeys(GetIdentityKeysRequest) returns (GetIdentityKeysResponse);
+  rpc getIdentityNonce(GetIdentityNonceRequest) returns (GetIdentityNonceResponse);
+  rpc getIdentityContractNonce(GetIdentityContractNonceRequest) returns (GetIdentityContractNonceResponse);
   rpc getIdentityBalance(GetIdentityBalanceRequest)
       returns (GetIdentityBalanceResponse);
   rpc getIdentityBalanceAndRevision(GetIdentityBalanceAndRevisionRequest)
@@ -74,6 +76,28 @@ message GetIdentityRequest {
   oneof version { GetIdentityRequestV0 v0 = 1; }
 }
 
+message GetIdentityNonceRequest {
+
+  message GetIdentityNonceRequestV0 {
+    bytes identity_id = 1;
+    bool prove = 2;
+  }
+
+  oneof version { GetIdentityNonceRequestV0 v0 = 1; }
+}
+
+
+message GetIdentityContractNonceRequest {
+
+  message GetIdentityContractNonceRequestV0 {
+    bytes identity_id = 1;
+    bytes contract_id = 2;
+    bool prove = 3;
+  }
+
+  oneof version { GetIdentityContractNonceRequestV0 v0 = 1; }
+}
+
 message GetIdentityBalanceRequest {
 
   message GetIdentityBalanceRequestV0 {
@@ -139,6 +163,32 @@ message GetIdentitiesResponse {
   oneof version { GetIdentitiesResponseV0 v0 = 1; }
 }
 
+message GetIdentityNonceResponse {
+
+  message GetIdentityNonceResponseV0 {
+    oneof result {
+      uint64 identity_nonce = 1;
+      Proof proof = 2;
+    }
+    ResponseMetadata metadata = 3;
+  }
+
+  oneof version { GetIdentityNonceResponseV0 v0 = 1; }
+}
+
+message GetIdentityContractNonceResponse {
+
+  message GetIdentityContractNonceResponseV0 {
+    oneof result {
+      uint64 identity_contract_nonce = 1;
+      Proof proof = 2;
+    }
+    ResponseMetadata metadata = 3;
+  }
+
+  oneof version { GetIdentityContractNonceResponseV0 v0 = 1; }
+}
+
 message GetIdentityBalanceResponse {
 
   message GetIdentityBalanceResponseV0 {
@@ -234,6 +284,7 @@ message GetProofsRequest {
         FULL_IDENTITY = 0;
         BALANCE = 1;
         KEYS = 2;
+        REVISION = 3;
       }
       bytes identity_id = 1;
       Type request_type = 2;

package/src/core/proto/org.dash.platform.dapi.v0.rs

@@ -1,6 +1,10 @@
+#[derive(::serde::Serialize, ::serde::Deserialize)]
+#[derive(::dapi_grpc_macros::Mockable)]
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GetStatusRequest {}
+#[derive(::serde::Serialize, ::serde::Deserialize)]
+#[derive(::dapi_grpc_macros::Mockable)]
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GetStatusResponse {
@@ -21,6 +25,8 @@ pub struct GetStatusResponse {
 }
 /// Nested message and enum types in `GetStatusResponse`.
 pub mod get_status_response {
+    #[derive(::serde::Serialize, ::serde::Deserialize)]
+    #[derive(::dapi_grpc_macros::Mockable)]
     #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Message)]
     pub struct Version {
@@ -31,6 +37,8 @@ pub mod get_status_response {
         #[prost(string, tag = "3")]
         pub agent: ::prost::alloc::string::String,
     }
+    #[derive(::serde::Serialize, ::serde::Deserialize)]
+    #[derive(::dapi_grpc_macros::Mockable)]
     #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Message)]
     pub struct Time {
@@ -41,6 +49,8 @@ pub mod get_status_response {
         #[prost(uint32, tag = "3")]
         pub median: u32,
     }
+    #[derive(::serde::Serialize, ::serde::Deserialize)]
+    #[derive(::dapi_grpc_macros::Mockable)]
     #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Message)]
     pub struct Chain {
@@ -61,6 +71,8 @@ pub mod get_status_response {
         #[prost(double, tag = "8")]
         pub sync_progress: f64,
     }
+    #[derive(::serde::Serialize, ::serde::Deserialize)]
+    #[derive(::dapi_grpc_macros::Mockable)]
     #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Message)]
     pub struct Masternode {
@@ -77,6 +89,7 @@ pub mod get_status_response {
     }
     /// Nested message and enum types in `Masternode`.
     pub mod masternode {
+        #[derive(::serde::Serialize, ::serde::Deserialize)]
         #[derive(
             Clone,
             Copy,
@@ -132,6 +145,8 @@ pub mod get_status_response {
             }
         }
     }
+    #[derive(::serde::Serialize, ::serde::Deserialize)]
+    #[derive(::dapi_grpc_macros::Mockable)]
     #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Message)]
     pub struct NetworkFee {
@@ -140,6 +155,8 @@ pub mod get_status_response {
         #[prost(double, tag = "2")]
         pub incremental: f64,
     }
+    #[derive(::serde::Serialize, ::serde::Deserialize)]
+    #[derive(::dapi_grpc_macros::Mockable)]
     #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Message)]
     pub struct Network {
@@ -148,6 +165,7 @@ pub mod get_status_response {
         #[prost(message, optional, tag = "2")]
         pub fee: ::core::option::Option<NetworkFee>,
     }
+    #[derive(::serde::Serialize, ::serde::Deserialize)]
     #[derive(
         Clone,
         Copy,
@@ -191,6 +209,8 @@ pub mod get_status_response {
         }
     }
 }
+#[derive(::serde::Serialize, ::serde::Deserialize)]
+#[derive(::dapi_grpc_macros::Mockable)]
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GetBlockRequest {
@@ -199,6 +219,7 @@ pub struct GetBlockRequest {
 }
 /// Nested message and enum types in `GetBlockRequest`.
 pub mod get_block_request {
+    #[derive(::serde::Serialize, ::serde::Deserialize)]
     #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Oneof)]
     pub enum Block {
@@ -208,12 +229,16 @@ pub mod get_block_request {
         Hash(::prost::alloc::string::String),
     }
 }
+#[derive(::serde::Serialize, ::serde::Deserialize)]
+#[derive(::dapi_grpc_macros::Mockable)]
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GetBlockResponse {
     #[prost(bytes = "vec", tag = "1")]
     pub block: ::prost::alloc::vec::Vec<u8>,
 }
+#[derive(::serde::Serialize, ::serde::Deserialize)]
+#[derive(::dapi_grpc_macros::Mockable)]
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct BroadcastTransactionRequest {
@@ -224,18 +249,24 @@ pub struct BroadcastTransactionRequest {
     #[prost(bool, tag = "3")]
     pub bypass_limits: bool,
 }
+#[derive(::serde::Serialize, ::serde::Deserialize)]
+#[derive(::dapi_grpc_macros::Mockable)]
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct BroadcastTransactionResponse {
     #[prost(string, tag = "1")]
     pub transaction_id: ::prost::alloc::string::String,
 }
+#[derive(::serde::Serialize, ::serde::Deserialize)]
+#[derive(::dapi_grpc_macros::Mockable)]
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GetTransactionRequest {
     #[prost(string, tag = "1")]
     pub id: ::prost::alloc::string::String,
 }
+#[derive(::serde::Serialize, ::serde::Deserialize)]
+#[derive(::dapi_grpc_macros::Mockable)]
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GetTransactionResponse {
@@ -252,6 +283,8 @@ pub struct GetTransactionResponse {
     #[prost(bool, tag = "6")]
     pub is_chain_locked: bool,
 }
+#[derive(::serde::Serialize, ::serde::Deserialize)]
+#[derive(::dapi_grpc_macros::Mockable)]
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct BlockHeadersWithChainLocksRequest {
@@ -264,6 +297,7 @@ pub struct BlockHeadersWithChainLocksRequest {
 }
 /// Nested message and enum types in `BlockHeadersWithChainLocksRequest`.
 pub mod block_headers_with_chain_locks_request {
+    #[derive(::serde::Serialize, ::serde::Deserialize)]
     #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Oneof)]
     pub enum FromBlock {
@@ -273,6 +307,8 @@ pub mod block_headers_with_chain_locks_request {
         FromBlockHeight(u32),
     }
 }
+#[derive(::serde::Serialize, ::serde::Deserialize)]
+#[derive(::dapi_grpc_macros::Mockable)]
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct BlockHeadersWithChainLocksResponse {
@@ -283,6 +319,7 @@ pub struct BlockHeadersWithChainLocksResponse {
 }
 /// Nested message and enum types in `BlockHeadersWithChainLocksResponse`.
 pub mod block_headers_with_chain_locks_response {
+    #[derive(::serde::Serialize, ::serde::Deserialize)]
     #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Oneof)]
     pub enum Responses {
@@ -292,24 +329,32 @@ pub mod block_headers_with_chain_locks_response {
         ChainLock(::prost::alloc::vec::Vec<u8>),
     }
 }
+#[derive(::serde::Serialize, ::serde::Deserialize)]
+#[derive(::dapi_grpc_macros::Mockable)]
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct BlockHeaders {
     #[prost(bytes = "vec", repeated, tag = "1")]
     pub headers: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
 }
+#[derive(::serde::Serialize, ::serde::Deserialize)]
+#[derive(::dapi_grpc_macros::Mockable)]
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GetEstimatedTransactionFeeRequest {
     #[prost(uint32, tag = "1")]
     pub blocks: u32,
 }
+#[derive(::serde::Serialize, ::serde::Deserialize)]
+#[derive(::dapi_grpc_macros::Mockable)]
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GetEstimatedTransactionFeeResponse {
     #[prost(double, tag = "1")]
     pub fee: f64,
 }
+#[derive(::serde::Serialize, ::serde::Deserialize)]
+#[derive(::dapi_grpc_macros::Mockable)]
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct TransactionsWithProofsRequest {
@@ -324,6 +369,7 @@ pub struct TransactionsWithProofsRequest {
 }
 /// Nested message and enum types in `TransactionsWithProofsRequest`.
 pub mod transactions_with_proofs_request {
+    #[derive(::serde::Serialize, ::serde::Deserialize)]
     #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Oneof)]
     pub enum FromBlock {
@@ -333,6 +379,8 @@ pub mod transactions_with_proofs_request {
         FromBlockHeight(u32),
     }
 }
+#[derive(::serde::Serialize, ::serde::Deserialize)]
+#[derive(::dapi_grpc_macros::Mockable)]
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct BloomFilter {
@@ -345,6 +393,8 @@ pub struct BloomFilter {
     #[prost(uint32, tag = "4")]
     pub n_flags: u32,
 }
+#[derive(::serde::Serialize, ::serde::Deserialize)]
+#[derive(::dapi_grpc_macros::Mockable)]
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct TransactionsWithProofsResponse {
@@ -353,6 +403,7 @@ pub struct TransactionsWithProofsResponse {
 }
 /// Nested message and enum types in `TransactionsWithProofsResponse`.
 pub mod transactions_with_proofs_response {
+    #[derive(::serde::Serialize, ::serde::Deserialize)]
     #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Oneof)]
     pub enum Responses {
@@ -364,12 +415,16 @@ pub mod transactions_with_proofs_response {
         RawMerkleBlock(::prost::alloc::vec::Vec<u8>),
     }
 }
+#[derive(::serde::Serialize, ::serde::Deserialize)]
+#[derive(::dapi_grpc_macros::Mockable)]
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct RawTransactions {
     #[prost(bytes = "vec", repeated, tag = "1")]
     pub transactions: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
 }
+#[derive(::serde::Serialize, ::serde::Deserialize)]
+#[derive(::dapi_grpc_macros::Mockable)]
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct InstantSendLockMessages {

package/src/lib.rs

@@ -22,3 +22,9 @@ pub mod platform {
 #[cfg(feature = "serde")]
 // Serde deserialization logic
 pub mod deserialization;
+
+// We need mock module even if the feature is disabled
+pub mod mock;
+
+// Re-export tonic to ensure everyone uses the same version
+pub use tonic;

package/src/mock.rs

@@ -0,0 +1,68 @@
+//! Mocking support for messages.
+//!
+//! Contains [Mockable] trait that should be implemented by any object that can be used in the DAPI.
+//!
+//! Note that this trait is defined even if mocks are not supported, but it should always return `None` on serialization.
+use tonic::Streaming;
+
+/// Mocking support for messages.
+///
+/// This trait should be implemented by any object that can be used in the DAPI.
+///
+/// We use serde_json to serialize/deserialize messages.
+//  TODO: Move to a different crate where it can be easily shared by dapi-grpc, dash-platform-sdk, and rs-dapi-client.
+pub trait Mockable
+where
+    Self: std::marker::Sized,
+{
+    /// Serialize the message to bytes for mocking purposes.
+    ///
+    /// Returns None if the message is not serializable or mocking is disabled.
+    ///
+    /// # Panics
+    ///
+    /// Panics on any error.
+    fn mock_serialize(&self) -> Option<Vec<u8>> {
+        None
+    }
+    /// Deserialize the message serialized with [mock_serialize()].
+    ///
+    /// Returns None if the message is not serializable or mocking is disabled.
+    ///
+    /// # Panics
+    ///
+    /// Panics on any error.
+    fn mock_deserialize(_data: &[u8]) -> Option<Self> {
+        None
+    }
+}
+
+impl<T: Mockable> Mockable for Option<T> {
+    #[cfg(feature = "mocks")]
+    fn mock_serialize(&self) -> Option<Vec<u8>> {
+        self.as_ref().and_then(|value| value.mock_serialize())
+    }
+
+    #[cfg(feature = "mocks")]
+    fn mock_deserialize(data: &[u8]) -> Option<Self> {
+        T::mock_deserialize(data).map(Some)
+    }
+}
+
+impl Mockable for Vec<u8> {
+    #[cfg(feature = "mocks")]
+    fn mock_serialize(&self) -> Option<Vec<u8>> {
+        serde_json::to_vec(self).ok()
+    }
+
+    #[cfg(feature = "mocks")]
+    fn mock_deserialize(data: &[u8]) -> Option<Self> {
+        serde_json::from_slice(data).ok()
+    }
+}
+
+/// Mocking of gRPC streaming responses is not supported.
+///
+/// This will return `None` on serialization,
+/// effectively disabling mocking of streaming responses.
+impl<T: Mockable> Mockable for Streaming<T> {}