dash_sdk/mock/
requests.rs

1use super::MockDashPlatformSdk;
2use dpp::balances::total_single_token_balance::TotalSingleTokenBalance;
3use dpp::bincode::config::standard;
4use dpp::address_funds::PlatformAddress;
5use dpp::data_contract::associated_token::token_perpetual_distribution::reward_distribution_moment::RewardDistributionMoment;
6use dpp::data_contract::group::Group;
7use dpp::group::group_action::GroupAction;
8use dpp::tokens::contract_info::TokenContractInfo;
9use dpp::tokens::info::IdentityTokenInfo;
10use dpp::tokens::status::TokenStatus;
11use dpp::tokens::token_pricing_schedule::TokenPricingSchedule;
12use dpp::{
13    bincode,
14    block::{extended_epoch_info::ExtendedEpochInfo, finalized_epoch_info::FinalizedEpochInfo},
15    dashcore::{hashes::Hash as CoreHash, ProTxHash},
16    document::{serialization_traits::DocumentCborMethodsV0, Document},
17    identifier::Identifier,
18    identity::{identities_contract_keys::IdentitiesContractKeys, IdentityPublicKey},
19    platform_serialization::{platform_encode_to_vec, platform_versioned_decode_from_slice},
20    prelude::{DataContract, Identity},
21    serialization::{
22        PlatformDeserializableWithPotentialValidationFromVersionedStructure,
23        PlatformSerializableWithPlatformVersion,
24    },
25    voting::votes::{resource_vote::ResourceVote, Vote},
26};
27use drive::grovedb::Element;
28use drive_proof_verifier::types::evonode_status::EvoNodeStatus;
29use drive_proof_verifier::types::groups::GroupActions;
30use drive_proof_verifier::types::identity_token_balance::{
31    IdentitiesTokenBalances, IdentityTokenBalances,
32};
33use drive_proof_verifier::types::token_info::{IdentitiesTokenInfos, IdentityTokenInfos};
34use drive_proof_verifier::types::token_status::TokenStatuses;
35use drive::grovedb::GroveTrunkQueryResult;
36use drive_proof_verifier::types::{
37    AddressInfo, Contenders, ContestedResources, CurrentQuorumsInfo, ElementFetchRequestItem,
38    IdentityBalanceAndRevision, IndexMap, MasternodeProtocolVote, NullifiersTrunkState,
39    PlatformAddressTrunkState, PrefundedSpecializedBalance, ProposerBlockCounts,
40    RecentAddressBalanceChanges, RecentCompactedAddressBalanceChanges,
41    MostRecentShieldedAnchor, RecentCompactedNullifierChanges, RecentNullifierChanges,
42    RetrievedValues, ShieldedAnchors, TokenPreProgrammedDistributions,
43    ShieldedEncryptedNote, ShieldedEncryptedNotes, ShieldedNullifierStatus,
44    ShieldedNullifierStatuses, ShieldedPoolState, TotalCreditsInPlatform,
45    VotePollsGroupedByTimestamp, Voters,
46};
47use std::{collections::BTreeMap, hash::Hash};
48
49static BINCODE_CONFIG: bincode::config::Configuration = bincode::config::standard();
50
51/// Trait implemented by objects that can be used in mock expectation responses.
52///
53/// ## Panics
54///
55/// Can panic on errors.
56pub trait MockResponse {
57    /// Serialize the object to save into expectations
58    ///
59    /// ## Panics
60    ///
61    /// Can panic on errors.
62    fn mock_serialize(&self, mock_sdk: &MockDashPlatformSdk) -> Vec<u8>;
63
64    /// Deserialize the object from expectations
65    ///
66    /// ## Panics
67    ///
68    /// Can panic on errors.
69    fn mock_deserialize(mock_sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
70    where
71        Self: Sized;
72}
73
74impl<T: MockResponse> MockResponse for Option<T> {
75    fn mock_deserialize(mock_sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
76    where
77        Self: Sized,
78    {
79        if buf.is_empty() {
80            return None;
81        }
82
83        Some(T::mock_deserialize(mock_sdk, buf))
84    }
85    fn mock_serialize(&self, mock_sdk: &MockDashPlatformSdk) -> Vec<u8> {
86        match self {
87            Some(item) => item.mock_serialize(mock_sdk),
88            None => vec![],
89        }
90    }
91}
92
93impl<T: MockResponse> MockResponse for Vec<T> {
94    fn mock_deserialize(mock_sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
95    where
96        Self: Sized,
97    {
98        let items: Vec<Vec<u8>> = bincode::decode_from_slice(buf, BINCODE_CONFIG)
99            .expect("decode vec of data")
100            .0;
101        items
102            .into_iter()
103            .map(|item| T::mock_deserialize(mock_sdk, &item))
104            .collect()
105    }
106
107    fn mock_serialize(&self, mock_sdk: &MockDashPlatformSdk) -> Vec<u8> {
108        let data: Vec<Vec<u8>> = self
109            .iter()
110            .map(|item| item.mock_serialize(mock_sdk))
111            .collect();
112
113        bincode::encode_to_vec(data, BINCODE_CONFIG).expect("encode vec of data")
114    }
115}
116
117impl<K: Ord + MockResponse, V: MockResponse> MockResponse for BTreeMap<K, V> {
118    fn mock_deserialize(sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
119    where
120        Self: Sized,
121    {
122        let (data, _): (BTreeMap<Vec<u8>, Vec<u8>>, _) =
123            bincode::decode_from_slice(buf, BINCODE_CONFIG).expect("decode BTreeMap");
124
125        data.into_iter()
126            .map(|(k, v)| (K::mock_deserialize(sdk, &k), V::mock_deserialize(sdk, &v)))
127            .collect()
128    }
129
130    fn mock_serialize(&self, sdk: &MockDashPlatformSdk) -> Vec<u8> {
131        let data: BTreeMap<Vec<u8>, Vec<u8>> = self
132            .iter()
133            .map(|(k, v)| (k.mock_serialize(sdk), v.mock_serialize(sdk)))
134            .collect();
135
136        bincode::encode_to_vec(data, BINCODE_CONFIG).expect("encode BTreeMap")
137    }
138}
139
140impl<K: Hash + Eq + MockResponse, V: MockResponse> MockResponse for IndexMap<K, V> {
141    fn mock_deserialize(sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
142    where
143        Self: Sized,
144    {
145        let (data, _): (IndexMap<Vec<u8>, Vec<u8>>, _) =
146            bincode::serde::decode_from_slice(buf, BINCODE_CONFIG).expect("decode IndexMap");
147
148        data.into_iter()
149            .map(|(k, v)| (K::mock_deserialize(sdk, &k), V::mock_deserialize(sdk, &v)))
150            .collect()
151    }
152
153    fn mock_serialize(&self, sdk: &MockDashPlatformSdk) -> Vec<u8> {
154        let data: IndexMap<Vec<u8>, Vec<u8>> = self
155            .iter()
156            .map(|(k, v)| (k.mock_serialize(sdk), v.mock_serialize(sdk)))
157            .collect();
158
159        bincode::serde::encode_to_vec(data, BINCODE_CONFIG).expect("encode IndexMap")
160    }
161}
162
163/// Serialize and deserialize the object for mocking using bincode.
164///
165/// Use this macro when the object implements platform serialization.
166macro_rules! impl_mock_response {
167    ($name:ident) => {
168        impl MockResponse for $name {
169            fn mock_serialize(&self, sdk: &MockDashPlatformSdk) -> Vec<u8> {
170                platform_encode_to_vec(self, BINCODE_CONFIG, sdk.version())
171                    .expect(concat!("encode ", stringify!($name)))
172            }
173            fn mock_deserialize(sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
174            where
175                Self: Sized,
176            {
177                platform_versioned_decode_from_slice(buf, BINCODE_CONFIG, sdk.version())
178                    .expect(concat!("decode ", stringify!($name)))
179            }
180        }
181    };
182}
183
184// FIXME: Seems that DataContract doesn't implement PlatformVersionedDecode + PlatformVersionEncode,
185// so we just use some methods implemented directly on these objects.
186impl MockResponse for DataContract {
187    fn mock_serialize(&self, sdk: &MockDashPlatformSdk) -> Vec<u8> {
188        self.serialize_to_bytes_with_platform_version(sdk.version())
189            .expect("encode data")
190    }
191
192    fn mock_deserialize(sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
193    where
194        Self: Sized,
195    {
196        DataContract::versioned_deserialize(buf, true, sdk.version()).expect("decode data")
197    }
198}
199
200// FIXME: Seems that DataContract doesn't implement PlatformVersionedDecode + PlatformVersionEncode,
201// so we just use some methods implemented directly on these objects.
202impl MockResponse for (DataContract, Vec<u8>) {
203    fn mock_serialize(&self, _sdk: &MockDashPlatformSdk) -> Vec<u8> {
204        self.1.clone()
205    }
206
207    fn mock_deserialize(sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
208    where
209        Self: Sized,
210    {
211        (
212            DataContract::versioned_deserialize(buf, true, sdk.version()).expect("decode data"),
213            buf.to_vec(),
214        )
215    }
216}
217
218// FIXME: Seems that Document doesn't implement PlatformVersionedDecode + PlatformVersionEncode,
219// so we use cbor.
220impl MockResponse for Document {
221    fn mock_serialize(&self, _sdk: &MockDashPlatformSdk) -> Vec<u8> {
222        self.to_cbor().expect("encode data")
223    }
224
225    fn mock_deserialize(sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
226    where
227        Self: Sized,
228    {
229        Self::from_cbor(buf, None, None, sdk.version()).expect("decode data")
230    }
231}
232
233impl MockResponse for Element {
234    fn mock_serialize(&self, _sdk: &MockDashPlatformSdk) -> Vec<u8> {
235        // Create a bincode configuration
236        let config = standard();
237
238        // Serialize using the specified configuration
239        bincode::encode_to_vec(self, config).expect("Failed to serialize Element")
240    }
241
242    fn mock_deserialize(_sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
243    where
244        Self: Sized,
245    {
246        // Create a bincode configuration
247        let config = standard();
248
249        // Deserialize using the specified configuration
250        bincode::decode_from_slice(buf, config)
251            .expect("Failed to deserialize Element")
252            .0
253    }
254}
255
256impl MockResponse for drive_proof_verifier::types::IdentityNonceFetcher {
257    fn mock_serialize(&self, _sdk: &MockDashPlatformSdk) -> Vec<u8> {
258        self.0.to_be_bytes().to_vec()
259    }
260
261    fn mock_deserialize(_sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
262    where
263        Self: Sized,
264    {
265        drive_proof_verifier::types::IdentityNonceFetcher(u64::from_be_bytes(
266            buf.try_into()
267                .expect("identity contract nonce should be should be 8 bytes"),
268        ))
269    }
270}
271
272impl MockResponse for drive_proof_verifier::types::IdentityContractNonceFetcher {
273    fn mock_serialize(&self, _sdk: &MockDashPlatformSdk) -> Vec<u8> {
274        self.0.to_be_bytes().to_vec()
275    }
276
277    fn mock_deserialize(_sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
278    where
279        Self: Sized,
280    {
281        drive_proof_verifier::types::IdentityContractNonceFetcher(u64::from_be_bytes(
282            buf.try_into()
283                .expect("identity contract nonce should be should be 8 bytes"),
284        ))
285    }
286}
287impl MockResponse for ProTxHash {
288    fn mock_serialize(&self, sdk: &MockDashPlatformSdk) -> Vec<u8> {
289        let data = self.as_raw_hash().as_byte_array();
290        platform_encode_to_vec(data, BINCODE_CONFIG, sdk.version()).expect("encode ProTxHash")
291    }
292    fn mock_deserialize(sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
293    where
294        Self: Sized,
295    {
296        let data = platform_versioned_decode_from_slice(buf, BINCODE_CONFIG, sdk.version())
297            .expect("decode ProTxHash");
298        ProTxHash::from_raw_hash(CoreHash::from_byte_array(data))
299    }
300}
301
302impl MockResponse for ProposerBlockCounts {
303    fn mock_serialize(&self, sdk: &MockDashPlatformSdk) -> Vec<u8> {
304        self.0.mock_serialize(sdk)
305    }
306
307    fn mock_deserialize(sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
308    where
309        Self: Sized,
310    {
311        let data = RetrievedValues::<Identifier, u64>::mock_deserialize(sdk, buf);
312        ProposerBlockCounts(data)
313    }
314}
315
316impl MockResponse for IdentityTokenBalances {
317    fn mock_serialize(&self, sdk: &MockDashPlatformSdk) -> Vec<u8> {
318        self.0.mock_serialize(sdk)
319    }
320
321    fn mock_deserialize(sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
322    where
323        Self: Sized,
324    {
325        let map = RetrievedValues::mock_deserialize(sdk, buf);
326        Self(map)
327    }
328}
329
330impl MockResponse for IdentitiesTokenBalances {
331    fn mock_serialize(&self, sdk: &MockDashPlatformSdk) -> Vec<u8> {
332        self.0.mock_serialize(sdk)
333    }
334
335    fn mock_deserialize(sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
336    where
337        Self: Sized,
338    {
339        let map = RetrievedValues::mock_deserialize(sdk, buf);
340        Self(map)
341    }
342}
343
344impl MockResponse for IdentityTokenInfos {
345    fn mock_serialize(&self, sdk: &MockDashPlatformSdk) -> Vec<u8> {
346        // Clone and collect into vector
347        let vec: Vec<(Identifier, Option<IdentityTokenInfo>)> =
348            self.0.iter().map(|(k, v)| (*k, v.clone())).collect();
349
350        // Serialize vector
351        platform_encode_to_vec(vec, BINCODE_CONFIG, sdk.version())
352            .expect(concat!("encode ", stringify!($name)))
353    }
354
355    fn mock_deserialize(sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
356    where
357        Self: Sized,
358    {
359        // deserialize vector
360        let vec: Vec<(Identifier, Option<IdentityTokenInfo>)> =
361            platform_versioned_decode_from_slice(buf, BINCODE_CONFIG, sdk.version())
362                .expect(concat!("decode ", stringify!($name)));
363
364        Self(RetrievedValues::from_iter(vec))
365    }
366}
367
368impl MockResponse for IdentitiesTokenInfos {
369    fn mock_serialize(&self, sdk: &MockDashPlatformSdk) -> Vec<u8> {
370        // Clone and collect into vector
371        let vec: Vec<(Identifier, Option<IdentityTokenInfo>)> =
372            self.0.iter().map(|(k, v)| (*k, v.clone())).collect();
373
374        // Serialize vector
375        platform_encode_to_vec(vec, BINCODE_CONFIG, sdk.version())
376            .expect(concat!("encode ", stringify!($name)))
377    }
378
379    fn mock_deserialize(sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
380    where
381        Self: Sized,
382    {
383        // deserialize vector
384        let vec: Vec<(Identifier, Option<IdentityTokenInfo>)> =
385            platform_versioned_decode_from_slice(buf, BINCODE_CONFIG, sdk.version())
386                .expect(concat!("decode ", stringify!($name)));
387
388        Self(RetrievedValues::from_iter(vec))
389    }
390}
391
392impl MockResponse for TokenStatuses {
393    fn mock_serialize(&self, sdk: &MockDashPlatformSdk) -> Vec<u8> {
394        // Clone and collect into vector
395        let vec: Vec<(Identifier, Option<TokenStatus>)> =
396            self.iter().map(|(k, v)| (*k, v.clone())).collect();
397
398        // Serialize vector
399        platform_encode_to_vec(vec, BINCODE_CONFIG, sdk.version())
400            .expect(concat!("encode ", stringify!($name)))
401    }
402
403    fn mock_deserialize(sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
404    where
405        Self: Sized,
406    {
407        // deserialize vector
408        let vec: Vec<(Identifier, Option<TokenStatus>)> =
409            platform_versioned_decode_from_slice(buf, BINCODE_CONFIG, sdk.version())
410                .expect(concat!("decode ", stringify!($name)));
411
412        RetrievedValues::from_iter(vec)
413    }
414}
415
416impl MockResponse for TokenContractInfo {
417    fn mock_serialize(&self, sdk: &MockDashPlatformSdk) -> Vec<u8> {
418        platform_encode_to_vec(self, BINCODE_CONFIG, sdk.version())
419            .expect("encode TokenContractInfo")
420    }
421
422    fn mock_deserialize(sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
423    where
424        Self: Sized,
425    {
426        platform_versioned_decode_from_slice(buf, BINCODE_CONFIG, sdk.version())
427            .expect("decode TokenContractInfo")
428    }
429}
430
431impl MockResponse for TotalSingleTokenBalance {
432    fn mock_serialize(&self, _sdk: &MockDashPlatformSdk) -> Vec<u8> {
433        bincode::encode_to_vec(self, BINCODE_CONFIG).expect("encode vec of data")
434    }
435
436    fn mock_deserialize(_sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
437    where
438        Self: Sized,
439    {
440        bincode::decode_from_slice(buf, BINCODE_CONFIG)
441            .expect("decode vec of data")
442            .0
443    }
444}
445
446impl MockResponse for GroupActions {
447    fn mock_serialize(&self, sdk: &MockDashPlatformSdk) -> Vec<u8> {
448        // Clone and collect into vector
449        let vec: Vec<(Identifier, Option<GroupAction>)> =
450            self.iter().map(|(k, v)| (*k, v.clone())).collect();
451
452        // Serialize vector
453        platform_encode_to_vec(vec, BINCODE_CONFIG, sdk.version())
454            .expect(concat!("encode ", stringify!($name)))
455    }
456
457    fn mock_deserialize(sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
458    where
459        Self: Sized,
460    {
461        // deserialize vector
462        let vec: Vec<(Identifier, Option<GroupAction>)> =
463            platform_versioned_decode_from_slice(buf, BINCODE_CONFIG, sdk.version())
464                .expect(concat!("decode ", stringify!($name)));
465
466        RetrievedValues::from_iter(vec)
467    }
468}
469
470impl MockResponse for IdentitiesContractKeys {
471    fn mock_serialize(&self, _sdk: &MockDashPlatformSdk) -> Vec<u8> {
472        bincode::encode_to_vec(self, BINCODE_CONFIG).expect("encode IdentitiesContractKeys")
473    }
474
475    fn mock_deserialize(_sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
476    where
477        Self: Sized,
478    {
479        bincode::decode_from_slice(buf, BINCODE_CONFIG)
480            .expect("decode IdentitiesContractKeys")
481            .0
482    }
483}
484
485impl_mock_response!(Identity);
486impl_mock_response!(IdentityPublicKey);
487impl_mock_response!(Identifier);
488impl_mock_response!(MasternodeProtocolVote);
489impl_mock_response!(ResourceVote);
490impl_mock_response!(u8);
491impl_mock_response!(u16);
492impl_mock_response!(u32);
493impl_mock_response!(u64);
494impl_mock_response!(Vote);
495impl_mock_response!(ExtendedEpochInfo);
496impl_mock_response!(FinalizedEpochInfo);
497impl_mock_response!(ContestedResources);
498impl_mock_response!(IdentityBalanceAndRevision);
499impl_mock_response!(Contenders);
500impl_mock_response!(Voters);
501impl_mock_response!(VotePollsGroupedByTimestamp);
502impl_mock_response!(PrefundedSpecializedBalance);
503impl_mock_response!(TotalCreditsInPlatform);
504impl_mock_response!(ElementFetchRequestItem);
505impl_mock_response!(EvoNodeStatus);
506impl_mock_response!(CurrentQuorumsInfo);
507impl_mock_response!(Group);
508impl_mock_response!(TokenPricingSchedule);
509impl_mock_response!(RewardDistributionMoment);
510impl_mock_response!(TokenPreProgrammedDistributions);
511impl_mock_response!(PlatformAddress);
512impl_mock_response!(AddressInfo);
513impl_mock_response!(RecentAddressBalanceChanges);
514impl_mock_response!(RecentCompactedAddressBalanceChanges);
515impl_mock_response!(ShieldedPoolState);
516impl_mock_response!(ShieldedAnchors);
517impl_mock_response!(MostRecentShieldedAnchor);
518impl_mock_response!(ShieldedEncryptedNotes);
519impl_mock_response!(ShieldedEncryptedNote);
520impl_mock_response!(ShieldedNullifierStatuses);
521impl_mock_response!(ShieldedNullifierStatus);
522impl_mock_response!(RecentNullifierChanges);
523impl_mock_response!(RecentCompactedNullifierChanges);
524
525/// MockResponse for GroveTrunkQueryResult - panics when called because the Tree type
526/// doesn't support serialization. Address sync operations should not be mocked.
527impl MockResponse for GroveTrunkQueryResult {
528    fn mock_serialize(&self, _sdk: &MockDashPlatformSdk) -> Vec<u8> {
529        unimplemented!("GroveTrunkQueryResult does not support mock serialization - the Tree type is not serializable")
530    }
531
532    fn mock_deserialize(_sdk: &MockDashPlatformSdk, _buf: &[u8]) -> Self
533    where
534        Self: Sized,
535    {
536        unimplemented!("GroveTrunkQueryResult does not support mock deserialization - the Tree type is not serializable")
537    }
538}
539
540/// MockResponse for PlatformAddressTrunkState - panics when called because the underlying
541/// Tree type doesn't support serialization. Address sync operations should not be mocked.
542impl MockResponse for PlatformAddressTrunkState {
543    fn mock_serialize(&self, _sdk: &MockDashPlatformSdk) -> Vec<u8> {
544        unimplemented!("PlatformAddressTrunkState does not support mock serialization - the Tree type is not serializable")
545    }
546
547    fn mock_deserialize(_sdk: &MockDashPlatformSdk, _buf: &[u8]) -> Self
548    where
549        Self: Sized,
550    {
551        unimplemented!("PlatformAddressTrunkState does not support mock deserialization - the Tree type is not serializable")
552    }
553}
554
555/// MockResponse for NullifiersTrunkState - panics when called because the underlying
556/// Tree type doesn't support serialization. Nullifier sync operations should not be mocked.
557impl MockResponse for NullifiersTrunkState {
558    fn mock_serialize(&self, _sdk: &MockDashPlatformSdk) -> Vec<u8> {
559        unimplemented!("NullifiersTrunkState does not support mock serialization - the Tree type is not serializable")
560    }
561
562    fn mock_deserialize(_sdk: &MockDashPlatformSdk, _buf: &[u8]) -> Self
563    where
564        Self: Sized,
565    {
566        unimplemented!("NullifiersTrunkState does not support mock deserialization - the Tree type is not serializable")
567    }
568}
dash_sdk/mock/requests.rs

dash_sdk/mock/
requests.rs
