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, MostRecentShieldedAnchor,
39    PlatformAddressTrunkState, PrefundedSpecializedBalance, ProposerBlockCounts,
40    RecentAddressBalanceChanges, RecentCompactedAddressBalanceChanges, RetrievedValues,
41    ShieldedAnchors, ShieldedEncryptedNote, ShieldedEncryptedNotes, ShieldedNotesCount,
42    ShieldedNullifierStatus, ShieldedNullifierStatuses, ShieldedPoolState,
43    TokenPreProgrammedDistributions, TotalCreditsInPlatform, VotePollsGroupedByTimestamp, Voters,
44};
45use std::{collections::BTreeMap, hash::Hash};
46
47static BINCODE_CONFIG: bincode::config::Configuration = bincode::config::standard();
48
49/// Trait implemented by objects that can be used in mock expectation responses.
50///
51/// ## Panics
52///
53/// Can panic on errors.
54pub trait MockResponse {
55    /// Serialize the object to save into expectations
56    ///
57    /// ## Panics
58    ///
59    /// Can panic on errors.
60    fn mock_serialize(&self, mock_sdk: &MockDashPlatformSdk) -> Vec<u8>;
61
62    /// Deserialize the object from expectations
63    ///
64    /// ## Panics
65    ///
66    /// Can panic on errors.
67    fn mock_deserialize(mock_sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
68    where
69        Self: Sized;
70}
71
72impl<T: MockResponse> MockResponse for Option<T> {
73    fn mock_deserialize(mock_sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
74    where
75        Self: Sized,
76    {
77        if buf.is_empty() {
78            return None;
79        }
80
81        Some(T::mock_deserialize(mock_sdk, buf))
82    }
83    fn mock_serialize(&self, mock_sdk: &MockDashPlatformSdk) -> Vec<u8> {
84        match self {
85            Some(item) => item.mock_serialize(mock_sdk),
86            None => vec![],
87        }
88    }
89}
90
91impl<T: MockResponse> MockResponse for Vec<T> {
92    fn mock_deserialize(mock_sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
93    where
94        Self: Sized,
95    {
96        let items: Vec<Vec<u8>> = bincode::decode_from_slice(buf, BINCODE_CONFIG)
97            .expect("decode vec of data")
98            .0;
99        items
100            .into_iter()
101            .map(|item| T::mock_deserialize(mock_sdk, &item))
102            .collect()
103    }
104
105    fn mock_serialize(&self, mock_sdk: &MockDashPlatformSdk) -> Vec<u8> {
106        let data: Vec<Vec<u8>> = self
107            .iter()
108            .map(|item| item.mock_serialize(mock_sdk))
109            .collect();
110
111        bincode::encode_to_vec(data, BINCODE_CONFIG).expect("encode vec of data")
112    }
113}
114
115impl<K: Ord + MockResponse, V: MockResponse> MockResponse for BTreeMap<K, V> {
116    fn mock_deserialize(sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
117    where
118        Self: Sized,
119    {
120        let (data, _): (BTreeMap<Vec<u8>, Vec<u8>>, _) =
121            bincode::decode_from_slice(buf, BINCODE_CONFIG).expect("decode BTreeMap");
122
123        data.into_iter()
124            .map(|(k, v)| (K::mock_deserialize(sdk, &k), V::mock_deserialize(sdk, &v)))
125            .collect()
126    }
127
128    fn mock_serialize(&self, sdk: &MockDashPlatformSdk) -> Vec<u8> {
129        let data: BTreeMap<Vec<u8>, Vec<u8>> = self
130            .iter()
131            .map(|(k, v)| (k.mock_serialize(sdk), v.mock_serialize(sdk)))
132            .collect();
133
134        bincode::encode_to_vec(data, BINCODE_CONFIG).expect("encode BTreeMap")
135    }
136}
137
138impl<K: Hash + Eq + MockResponse, V: MockResponse> MockResponse for IndexMap<K, V> {
139    fn mock_deserialize(sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
140    where
141        Self: Sized,
142    {
143        let (data, _): (IndexMap<Vec<u8>, Vec<u8>>, _) =
144            bincode::serde::decode_from_slice(buf, BINCODE_CONFIG).expect("decode IndexMap");
145
146        data.into_iter()
147            .map(|(k, v)| (K::mock_deserialize(sdk, &k), V::mock_deserialize(sdk, &v)))
148            .collect()
149    }
150
151    fn mock_serialize(&self, sdk: &MockDashPlatformSdk) -> Vec<u8> {
152        let data: IndexMap<Vec<u8>, Vec<u8>> = self
153            .iter()
154            .map(|(k, v)| (k.mock_serialize(sdk), v.mock_serialize(sdk)))
155            .collect();
156
157        bincode::serde::encode_to_vec(data, BINCODE_CONFIG).expect("encode IndexMap")
158    }
159}
160
161/// Serialize and deserialize the object for mocking using bincode.
162///
163/// Use this macro when the object implements platform serialization.
164macro_rules! impl_mock_response {
165    ($name:ident) => {
166        impl MockResponse for $name {
167            fn mock_serialize(&self, sdk: &MockDashPlatformSdk) -> Vec<u8> {
168                platform_encode_to_vec(self, BINCODE_CONFIG, sdk.version())
169                    .expect(concat!("encode ", stringify!($name)))
170            }
171            fn mock_deserialize(sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
172            where
173                Self: Sized,
174            {
175                platform_versioned_decode_from_slice(buf, BINCODE_CONFIG, sdk.version())
176                    .expect(concat!("decode ", stringify!($name)))
177            }
178        }
179    };
180}
181
182// FIXME: Seems that DataContract doesn't implement PlatformVersionedDecode + PlatformVersionEncode,
183// so we just use some methods implemented directly on these objects.
184impl MockResponse for DataContract {
185    fn mock_serialize(&self, sdk: &MockDashPlatformSdk) -> Vec<u8> {
186        self.serialize_to_bytes_with_platform_version(sdk.version())
187            .expect("encode data")
188    }
189
190    fn mock_deserialize(sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
191    where
192        Self: Sized,
193    {
194        DataContract::versioned_deserialize(buf, true, sdk.version()).expect("decode data")
195    }
196}
197
198// FIXME: Seems that DataContract doesn't implement PlatformVersionedDecode + PlatformVersionEncode,
199// so we just use some methods implemented directly on these objects.
200impl MockResponse for (DataContract, Vec<u8>) {
201    fn mock_serialize(&self, _sdk: &MockDashPlatformSdk) -> Vec<u8> {
202        self.1.clone()
203    }
204
205    fn mock_deserialize(sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
206    where
207        Self: Sized,
208    {
209        (
210            DataContract::versioned_deserialize(buf, true, sdk.version()).expect("decode data"),
211            buf.to_vec(),
212        )
213    }
214}
215
216// FIXME: Seems that Document doesn't implement PlatformVersionedDecode + PlatformVersionEncode,
217// so we use cbor.
218impl MockResponse for Document {
219    fn mock_serialize(&self, _sdk: &MockDashPlatformSdk) -> Vec<u8> {
220        self.to_cbor().expect("encode data")
221    }
222
223    fn mock_deserialize(sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
224    where
225        Self: Sized,
226    {
227        Self::from_cbor(buf, None, None, sdk.version()).expect("decode data")
228    }
229}
230
231impl MockResponse for Element {
232    fn mock_serialize(&self, _sdk: &MockDashPlatformSdk) -> Vec<u8> {
233        // Create a bincode configuration
234        let config = standard();
235
236        // Serialize using the specified configuration
237        bincode::encode_to_vec(self, config).expect("Failed to serialize Element")
238    }
239
240    fn mock_deserialize(_sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
241    where
242        Self: Sized,
243    {
244        // Create a bincode configuration
245        let config = standard();
246
247        // Deserialize using the specified configuration
248        bincode::decode_from_slice(buf, config)
249            .expect("Failed to deserialize Element")
250            .0
251    }
252}
253
254impl MockResponse for drive_proof_verifier::types::IdentityNonceFetcher {
255    fn mock_serialize(&self, _sdk: &MockDashPlatformSdk) -> Vec<u8> {
256        self.0.to_be_bytes().to_vec()
257    }
258
259    fn mock_deserialize(_sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
260    where
261        Self: Sized,
262    {
263        drive_proof_verifier::types::IdentityNonceFetcher(u64::from_be_bytes(
264            buf.try_into()
265                .expect("identity contract nonce should be should be 8 bytes"),
266        ))
267    }
268}
269
270impl MockResponse for drive_proof_verifier::types::IdentityContractNonceFetcher {
271    fn mock_serialize(&self, _sdk: &MockDashPlatformSdk) -> Vec<u8> {
272        self.0.to_be_bytes().to_vec()
273    }
274
275    fn mock_deserialize(_sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
276    where
277        Self: Sized,
278    {
279        drive_proof_verifier::types::IdentityContractNonceFetcher(u64::from_be_bytes(
280            buf.try_into()
281                .expect("identity contract nonce should be should be 8 bytes"),
282        ))
283    }
284}
285impl MockResponse for ProTxHash {
286    fn mock_serialize(&self, sdk: &MockDashPlatformSdk) -> Vec<u8> {
287        let data = self.as_raw_hash().as_byte_array();
288        platform_encode_to_vec(data, BINCODE_CONFIG, sdk.version()).expect("encode ProTxHash")
289    }
290    fn mock_deserialize(sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
291    where
292        Self: Sized,
293    {
294        let data = platform_versioned_decode_from_slice(buf, BINCODE_CONFIG, sdk.version())
295            .expect("decode ProTxHash");
296        ProTxHash::from_raw_hash(CoreHash::from_byte_array(data))
297    }
298}
299
300impl MockResponse for ProposerBlockCounts {
301    fn mock_serialize(&self, sdk: &MockDashPlatformSdk) -> Vec<u8> {
302        self.0.mock_serialize(sdk)
303    }
304
305    fn mock_deserialize(sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
306    where
307        Self: Sized,
308    {
309        let data = RetrievedValues::<Identifier, u64>::mock_deserialize(sdk, buf);
310        ProposerBlockCounts(data)
311    }
312}
313
314impl MockResponse for IdentityTokenBalances {
315    fn mock_serialize(&self, sdk: &MockDashPlatformSdk) -> Vec<u8> {
316        self.0.mock_serialize(sdk)
317    }
318
319    fn mock_deserialize(sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
320    where
321        Self: Sized,
322    {
323        let map = RetrievedValues::mock_deserialize(sdk, buf);
324        Self(map)
325    }
326}
327
328impl MockResponse for IdentitiesTokenBalances {
329    fn mock_serialize(&self, sdk: &MockDashPlatformSdk) -> Vec<u8> {
330        self.0.mock_serialize(sdk)
331    }
332
333    fn mock_deserialize(sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
334    where
335        Self: Sized,
336    {
337        let map = RetrievedValues::mock_deserialize(sdk, buf);
338        Self(map)
339    }
340}
341
342impl MockResponse for IdentityTokenInfos {
343    fn mock_serialize(&self, sdk: &MockDashPlatformSdk) -> Vec<u8> {
344        // Clone and collect into vector
345        let vec: Vec<(Identifier, Option<IdentityTokenInfo>)> =
346            self.0.iter().map(|(k, v)| (*k, v.clone())).collect();
347
348        // Serialize vector
349        platform_encode_to_vec(vec, BINCODE_CONFIG, sdk.version())
350            .expect(concat!("encode ", stringify!($name)))
351    }
352
353    fn mock_deserialize(sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
354    where
355        Self: Sized,
356    {
357        // deserialize vector
358        let vec: Vec<(Identifier, Option<IdentityTokenInfo>)> =
359            platform_versioned_decode_from_slice(buf, BINCODE_CONFIG, sdk.version())
360                .expect(concat!("decode ", stringify!($name)));
361
362        Self(RetrievedValues::from_iter(vec))
363    }
364}
365
366impl MockResponse for IdentitiesTokenInfos {
367    fn mock_serialize(&self, sdk: &MockDashPlatformSdk) -> Vec<u8> {
368        // Clone and collect into vector
369        let vec: Vec<(Identifier, Option<IdentityTokenInfo>)> =
370            self.0.iter().map(|(k, v)| (*k, v.clone())).collect();
371
372        // Serialize vector
373        platform_encode_to_vec(vec, BINCODE_CONFIG, sdk.version())
374            .expect(concat!("encode ", stringify!($name)))
375    }
376
377    fn mock_deserialize(sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
378    where
379        Self: Sized,
380    {
381        // deserialize vector
382        let vec: Vec<(Identifier, Option<IdentityTokenInfo>)> =
383            platform_versioned_decode_from_slice(buf, BINCODE_CONFIG, sdk.version())
384                .expect(concat!("decode ", stringify!($name)));
385
386        Self(RetrievedValues::from_iter(vec))
387    }
388}
389
390impl MockResponse for TokenStatuses {
391    fn mock_serialize(&self, sdk: &MockDashPlatformSdk) -> Vec<u8> {
392        // Clone and collect into vector
393        let vec: Vec<(Identifier, Option<TokenStatus>)> =
394            self.iter().map(|(k, v)| (*k, v.clone())).collect();
395
396        // Serialize vector
397        platform_encode_to_vec(vec, BINCODE_CONFIG, sdk.version())
398            .expect(concat!("encode ", stringify!($name)))
399    }
400
401    fn mock_deserialize(sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
402    where
403        Self: Sized,
404    {
405        // deserialize vector
406        let vec: Vec<(Identifier, Option<TokenStatus>)> =
407            platform_versioned_decode_from_slice(buf, BINCODE_CONFIG, sdk.version())
408                .expect(concat!("decode ", stringify!($name)));
409
410        RetrievedValues::from_iter(vec)
411    }
412}
413
414impl MockResponse for TokenContractInfo {
415    fn mock_serialize(&self, sdk: &MockDashPlatformSdk) -> Vec<u8> {
416        platform_encode_to_vec(self, BINCODE_CONFIG, sdk.version())
417            .expect("encode TokenContractInfo")
418    }
419
420    fn mock_deserialize(sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
421    where
422        Self: Sized,
423    {
424        platform_versioned_decode_from_slice(buf, BINCODE_CONFIG, sdk.version())
425            .expect("decode TokenContractInfo")
426    }
427}
428
429impl MockResponse for TotalSingleTokenBalance {
430    fn mock_serialize(&self, _sdk: &MockDashPlatformSdk) -> Vec<u8> {
431        bincode::encode_to_vec(self, BINCODE_CONFIG).expect("encode vec of data")
432    }
433
434    fn mock_deserialize(_sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
435    where
436        Self: Sized,
437    {
438        bincode::decode_from_slice(buf, BINCODE_CONFIG)
439            .expect("decode vec of data")
440            .0
441    }
442}
443
444impl MockResponse for GroupActions {
445    fn mock_serialize(&self, sdk: &MockDashPlatformSdk) -> Vec<u8> {
446        // Clone and collect into vector
447        let vec: Vec<(Identifier, Option<GroupAction>)> =
448            self.iter().map(|(k, v)| (*k, v.clone())).collect();
449
450        // Serialize vector
451        platform_encode_to_vec(vec, BINCODE_CONFIG, sdk.version())
452            .expect(concat!("encode ", stringify!($name)))
453    }
454
455    fn mock_deserialize(sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
456    where
457        Self: Sized,
458    {
459        // deserialize vector
460        let vec: Vec<(Identifier, Option<GroupAction>)> =
461            platform_versioned_decode_from_slice(buf, BINCODE_CONFIG, sdk.version())
462                .expect(concat!("decode ", stringify!($name)));
463
464        RetrievedValues::from_iter(vec)
465    }
466}
467
468impl MockResponse for IdentitiesContractKeys {
469    fn mock_serialize(&self, _sdk: &MockDashPlatformSdk) -> Vec<u8> {
470        bincode::encode_to_vec(self, BINCODE_CONFIG).expect("encode IdentitiesContractKeys")
471    }
472
473    fn mock_deserialize(_sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
474    where
475        Self: Sized,
476    {
477        bincode::decode_from_slice(buf, BINCODE_CONFIG)
478            .expect("decode IdentitiesContractKeys")
479            .0
480    }
481}
482
483impl_mock_response!(Identity);
484impl_mock_response!(IdentityPublicKey);
485impl_mock_response!(Identifier);
486impl_mock_response!(MasternodeProtocolVote);
487impl_mock_response!(ResourceVote);
488impl_mock_response!(u8);
489impl_mock_response!(u16);
490impl_mock_response!(u32);
491impl_mock_response!(u64);
492impl_mock_response!(Vote);
493impl_mock_response!(ExtendedEpochInfo);
494impl_mock_response!(FinalizedEpochInfo);
495impl_mock_response!(ContestedResources);
496impl_mock_response!(IdentityBalanceAndRevision);
497impl_mock_response!(Contenders);
498impl_mock_response!(Voters);
499impl_mock_response!(VotePollsGroupedByTimestamp);
500impl_mock_response!(PrefundedSpecializedBalance);
501impl_mock_response!(TotalCreditsInPlatform);
502impl_mock_response!(ElementFetchRequestItem);
503impl_mock_response!(EvoNodeStatus);
504impl_mock_response!(CurrentQuorumsInfo);
505impl_mock_response!(Group);
506impl_mock_response!(TokenPricingSchedule);
507impl_mock_response!(RewardDistributionMoment);
508impl_mock_response!(TokenPreProgrammedDistributions);
509impl_mock_response!(PlatformAddress);
510impl_mock_response!(AddressInfo);
511impl_mock_response!(RecentAddressBalanceChanges);
512impl_mock_response!(RecentCompactedAddressBalanceChanges);
513impl_mock_response!(ShieldedPoolState);
514impl_mock_response!(ShieldedNotesCount);
515impl_mock_response!(ShieldedAnchors);
516impl_mock_response!(MostRecentShieldedAnchor);
517impl_mock_response!(ShieldedEncryptedNotes);
518impl_mock_response!(ShieldedEncryptedNote);
519impl_mock_response!(ShieldedNullifierStatuses);
520impl_mock_response!(ShieldedNullifierStatus);
521
522/// MockResponse for GroveTrunkQueryResult - panics when called because the Tree type
523/// doesn't support serialization. Address sync operations should not be mocked.
524impl MockResponse for GroveTrunkQueryResult {
525    fn mock_serialize(&self, _sdk: &MockDashPlatformSdk) -> Vec<u8> {
526        unimplemented!("GroveTrunkQueryResult does not support mock serialization - the Tree type is not serializable")
527    }
528
529    fn mock_deserialize(_sdk: &MockDashPlatformSdk, _buf: &[u8]) -> Self
530    where
531        Self: Sized,
532    {
533        unimplemented!("GroveTrunkQueryResult does not support mock deserialization - the Tree type is not serializable")
534    }
535}
536
537/// MockResponse for PlatformAddressTrunkState - panics when called because the underlying
538/// Tree type doesn't support serialization. Address sync operations should not be mocked.
539impl MockResponse for PlatformAddressTrunkState {
540    fn mock_serialize(&self, _sdk: &MockDashPlatformSdk) -> Vec<u8> {
541        unimplemented!("PlatformAddressTrunkState does not support mock serialization - the Tree type is not serializable")
542    }
543
544    fn mock_deserialize(_sdk: &MockDashPlatformSdk, _buf: &[u8]) -> Self
545    where
546        Self: Sized,
547    {
548        unimplemented!("PlatformAddressTrunkState does not support mock deserialization - the Tree type is not serializable")
549    }
550}
551
552impl MockResponse for drive_proof_verifier::DocumentCount {
553    fn mock_serialize(&self, _sdk: &MockDashPlatformSdk) -> Vec<u8> {
554        let bincode_config = standard();
555        bincode::encode_to_vec(self.0, bincode_config).expect("encode DocumentCount")
556    }
557
558    fn mock_deserialize(_sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
559    where
560        Self: Sized,
561    {
562        let bincode_config = standard();
563        let (count, _): (u64, _) =
564            bincode::decode_from_slice(buf, bincode_config).expect("decode DocumentCount");
565        drive_proof_verifier::DocumentCount(count)
566    }
567}
568
569/// Wire shape for `DocumentSplitCounts` mock round-trip:
570/// `(in_key, key, count)` triples preserving the In dimension
571/// AND the verified-vs-absent count distinction. Shared by
572/// `mock_serialize`/`mock_deserialize` below — single source of
573/// truth so the encode/decode generics align by construction,
574/// and clippy's `type_complexity` lint (CI runs with
575/// `-D warnings`) doesn't fire on the inline form.
576type DocumentSplitCountTriples = Vec<(Option<Vec<u8>>, Vec<u8>, Option<u64>)>;
577
578impl MockResponse for drive_proof_verifier::DocumentSplitCounts {
579    fn mock_serialize(&self, _sdk: &MockDashPlatformSdk) -> Vec<u8> {
580        let bincode_config = standard();
581        // Serialize as `(in_key, key, count)` triples so the In
582        // dimension AND the verified-vs-absent count distinction
583        // both survive the mock roundtrip. Required for compound
584        // (`In + range + distinct`) test fixtures to keep their
585        // `in_key` values, and for GroupByIn-absent-branch
586        // fixtures to keep their `None` counts.
587        let triples: DocumentSplitCountTriples = self
588            .0
589            .iter()
590            .map(|e| (e.in_key.clone(), e.key.clone(), e.count))
591            .collect();
592        bincode::encode_to_vec(triples, bincode_config).expect("encode DocumentSplitCounts")
593    }
594
595    fn mock_deserialize(_sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
596    where
597        Self: Sized,
598    {
599        let bincode_config = standard();
600        let (triples, _): (DocumentSplitCountTriples, _) =
601            bincode::decode_from_slice(buf, bincode_config).expect("decode DocumentSplitCounts");
602        let entries: Vec<drive_proof_verifier::SplitCountEntry> = triples
603            .into_iter()
604            .map(
605                |(in_key, key, count)| drive_proof_verifier::SplitCountEntry { in_key, key, count },
606            )
607            .collect();
608        drive_proof_verifier::DocumentSplitCounts::from_verified(entries)
609    }
610}
611
612impl MockResponse for drive_proof_verifier::DocumentSum {
613    fn mock_serialize(&self, _sdk: &MockDashPlatformSdk) -> Vec<u8> {
614        let bincode_config = standard();
615        bincode::encode_to_vec(self.0, bincode_config).expect("encode DocumentSum")
616    }
617
618    fn mock_deserialize(_sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
619    where
620        Self: Sized,
621    {
622        let bincode_config = standard();
623        let (sum, _): (i64, _) =
624            bincode::decode_from_slice(buf, bincode_config).expect("decode DocumentSum");
625        drive_proof_verifier::DocumentSum(sum)
626    }
627}
628
629/// Wire shape for `DocumentSplitSums` mock round-trip. Mirrors
630/// [`DocumentSplitCountTriples`] — preserves the `in_key` axis
631/// and the verified-vs-absent sum distinction (`Option<i64>`)
632/// across the roundtrip.
633type DocumentSplitSumTriples = Vec<(Option<Vec<u8>>, Vec<u8>, Option<i64>)>;
634
635impl MockResponse for drive_proof_verifier::DocumentSplitSums {
636    fn mock_serialize(&self, _sdk: &MockDashPlatformSdk) -> Vec<u8> {
637        let bincode_config = standard();
638        let triples: DocumentSplitSumTriples = self
639            .0
640            .iter()
641            .map(|e| (e.in_key.clone(), e.key.clone(), e.sum))
642            .collect();
643        bincode::encode_to_vec(triples, bincode_config).expect("encode DocumentSplitSums")
644    }
645
646    fn mock_deserialize(_sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
647    where
648        Self: Sized,
649    {
650        let bincode_config = standard();
651        let (triples, _): (DocumentSplitSumTriples, _) =
652            bincode::decode_from_slice(buf, bincode_config).expect("decode DocumentSplitSums");
653        let entries: Vec<drive_proof_verifier::SplitSumEntry> = triples
654            .into_iter()
655            .map(|(in_key, key, sum)| drive_proof_verifier::SplitSumEntry { in_key, key, sum })
656            .collect();
657        drive_proof_verifier::DocumentSplitSums(entries)
658    }
659}
660
661impl MockResponse for drive_proof_verifier::DocumentAverage {
662    fn mock_serialize(&self, _sdk: &MockDashPlatformSdk) -> Vec<u8> {
663        let bincode_config = standard();
664        bincode::encode_to_vec((self.count, self.sum), bincode_config)
665            .expect("encode DocumentAverage")
666    }
667
668    fn mock_deserialize(_sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
669    where
670        Self: Sized,
671    {
672        let bincode_config = standard();
673        let ((count, sum), _): ((u64, i64), _) =
674            bincode::decode_from_slice(buf, bincode_config).expect("decode DocumentAverage");
675        drive_proof_verifier::DocumentAverage { count, sum }
676    }
677}
678
679/// Wire shape for `DocumentSplitAverages` mock round-trip. Same
680/// `(in_key, key)` axes as the sum variant, but carries both
681/// `Option<u64>` (count) and `Option<i64>` (sum) so the verified-vs-
682/// absent state of each axis can roundtrip independently.
683type DocumentSplitAverageTuples = Vec<(Option<Vec<u8>>, Vec<u8>, Option<u64>, Option<i64>)>;
684
685impl MockResponse for drive_proof_verifier::DocumentSplitAverages {
686    fn mock_serialize(&self, _sdk: &MockDashPlatformSdk) -> Vec<u8> {
687        let bincode_config = standard();
688        let tuples: DocumentSplitAverageTuples = self
689            .0
690            .iter()
691            .map(|e| (e.in_key.clone(), e.key.clone(), e.count, e.sum))
692            .collect();
693        bincode::encode_to_vec(tuples, bincode_config).expect("encode DocumentSplitAverages")
694    }
695
696    fn mock_deserialize(_sdk: &MockDashPlatformSdk, buf: &[u8]) -> Self
697    where
698        Self: Sized,
699    {
700        let bincode_config = standard();
701        let (tuples, _): (DocumentSplitAverageTuples, _) =
702            bincode::decode_from_slice(buf, bincode_config).expect("decode DocumentSplitAverages");
703        let entries: Vec<drive_proof_verifier::SplitAverageEntry> = tuples
704            .into_iter()
705            .map(
706                |(in_key, key, count, sum)| drive_proof_verifier::SplitAverageEntry {
707                    in_key,
708                    key,
709                    count,
710                    sum,
711                },
712            )
713            .collect();
714        drive_proof_verifier::DocumentSplitAverages(entries)
715    }
716}
dash_sdk/mock/requests.rs

dash_sdk/mock/
requests.rs
