binary_sv2/
lib.rs

1//! Export custom implementations of the `binary_sv2` protocol,
2//! enabling encoding and decoding through custom traits.
3//!
4//! # Overview
5//!
6//! This crate will re-export implementations of the`Deserialize` and `Serialize` traits
7//! from a custom implementation provided by `binary_codec_sv2` and `derive_codec_sv2`.
8//! This allows for flexible integration of SV2  protocol types and binary serialization.
9//!
10//! ## Features
11//! - **prop_test**: Adds support for property testing for protocol types.
12//! - **with_buffer_pool**: Enables support for buffer pooling to optimize memory usage during
13//!   serialization and deserialization.
14#![no_std]
15
16#[macro_use]
17extern crate alloc;
18
19use core::convert::TryInto;
20
21pub use binary_codec_sv2::{self, Decodable as Deserialize, Encodable as Serialize, *};
22pub use derive_codec_sv2::{Decodable as Deserialize, Encodable as Serialize};
23
24/// Does nothing and will be removed during refactor
25pub fn clone_message<T: Serialize>(_: T) -> T {
26    todo!()
27}
28
29/// Converts a value implementing the `Into<u64>` trait into a custom `U256` type.
30pub fn u256_from_int<V: Into<u64>>(value: V) -> U256<'static> {
31    // initialize u256 as a bytes vec of len 24
32    let mut u256 = vec![0_u8; 24];
33    let val: u64 = value.into();
34    for v in &(val.to_le_bytes()) {
35        // add 8 bytes to u256
36        u256.push(*v)
37    }
38    // Always safe cause u256 is 24 + 8 (32) bytes
39    let u256: U256 = u256.try_into().unwrap();
40    u256
41}
42
43#[cfg(test)]
44mod test {
45    use super::*;
46    use alloc::vec::Vec;
47
48    mod test_struct {
49        use super::*;
50        use core::convert::TryInto;
51
52        #[derive(Clone, Deserialize, Serialize, PartialEq, Debug)]
53        struct Test {
54            a: u32,
55            b: u8,
56            c: U24,
57        }
58
59        #[test]
60        fn test_struct() {
61            let expected = Test {
62                a: 456,
63                b: 9,
64                c: 67_u32.try_into().unwrap(),
65            };
66
67            let mut bytes = to_bytes(expected.clone()).unwrap();
68
69            let deserialized: Test = from_bytes(&mut bytes[..]).unwrap();
70
71            assert_eq!(deserialized, expected);
72        }
73    }
74
75    mod test_f32 {
76        use super::*;
77        use core::convert::TryInto;
78
79        #[derive(Clone, Deserialize, Serialize, PartialEq, Debug)]
80        struct Test {
81            a: u8,
82            b: U24,
83            c: f32,
84        }
85
86        #[test]
87        fn test_struct() {
88            let expected = Test {
89                c: 0.345,
90                a: 9,
91                b: 67_u32.try_into().unwrap(),
92            };
93
94            let mut bytes = to_bytes(expected.clone()).unwrap();
95
96            let deserialized: Test = from_bytes(&mut bytes[..]).unwrap();
97
98            assert_eq!(deserialized, expected);
99        }
100    }
101
102    mod test_b0255 {
103        use super::*;
104        use core::convert::TryInto;
105
106        #[derive(Clone, Deserialize, Serialize, PartialEq, Debug)]
107        struct Test<'decoder> {
108            a: B0255<'decoder>,
109        }
110
111        #[test]
112        fn test_b0255() {
113            let mut b0255 = [6; 3];
114            let b0255: B0255 = (&mut b0255[..]).try_into().unwrap();
115
116            let expected = Test { a: b0255 };
117
118            let mut bytes = to_bytes(expected.clone()).unwrap();
119
120            let deserialized: Test = from_bytes(&mut bytes[..]).unwrap();
121
122            assert_eq!(deserialized, expected);
123        }
124
125        #[test]
126        fn test_b0255_max() {
127            let mut b0255 = [6; 255];
128            let b0255: B0255 = (&mut b0255[..]).try_into().unwrap();
129
130            let expected = Test { a: b0255 };
131
132            let mut bytes = to_bytes(expected.clone()).unwrap();
133
134            let deserialized: Test = from_bytes(&mut bytes[..]).unwrap();
135
136            assert_eq!(deserialized, expected);
137        }
138    }
139
140    mod test_u256 {
141        use super::*;
142        use core::convert::TryInto;
143
144        #[derive(Clone, Deserialize, Serialize, PartialEq, Debug)]
145        struct Test<'decoder> {
146            a: U256<'decoder>,
147        }
148
149        #[test]
150        fn test_u256() {
151            let mut u256 = [6_u8; 32];
152            let u256: U256 = (&mut u256[..]).try_into().unwrap();
153
154            let expected = Test { a: u256 };
155
156            let mut bytes = to_bytes(expected.clone()).unwrap();
157
158            let deserialized: Test = from_bytes(&mut bytes[..]).unwrap();
159
160            assert_eq!(deserialized, expected);
161        }
162    }
163
164    mod test_signature {
165        use super::*;
166        use core::convert::TryInto;
167
168        #[derive(Deserialize, Serialize, PartialEq, Debug, Clone)]
169        struct Test<'decoder> {
170            a: Signature<'decoder>,
171        }
172
173        #[test]
174        fn test_signature() {
175            let mut s = [6; 64];
176            let s: Signature = (&mut s[..]).try_into().unwrap();
177
178            let expected = Test { a: s };
179
180            let mut bytes = to_bytes(expected.clone()).unwrap();
181
182            let deserialized: Test = from_bytes(&mut bytes[..]).unwrap();
183
184            assert_eq!(deserialized, expected);
185        }
186    }
187
188    mod test_b016m {
189        use super::*;
190        use core::convert::TryInto;
191
192        #[derive(Deserialize, Serialize, PartialEq, Debug, Clone)]
193        struct Test<'decoder> {
194            b: bool,
195            a: B016M<'decoder>,
196        }
197
198        #[test]
199        fn test_b016m() {
200            let mut b = [0_u8; 70000];
201            let b: B016M = (&mut b[..]).try_into().unwrap();
202            //println!("{:?}", to_bytes(&b).unwrap().len());
203
204            let expected = Test { a: b, b: true };
205
206            let mut bytes = to_bytes(expected.clone()).unwrap();
207
208            let deserialized: Test = from_bytes(&mut bytes[..]).unwrap();
209
210            assert_eq!(deserialized, expected);
211        }
212
213        #[test]
214        fn test_b016m_max() {
215            let mut b = vec![0_u8; 16777215];
216            let b: B016M = (&mut b[..]).try_into().unwrap();
217            //println!("{:?}", to_bytes(&b).unwrap().len());
218
219            let expected = Test { a: b, b: true };
220
221            let mut bytes = to_bytes(expected.clone()).unwrap();
222
223            let deserialized: Test = from_bytes(&mut bytes[..]).unwrap();
224
225            assert_eq!(deserialized, expected);
226        }
227    }
228
229    mod test_b064k {
230        use super::*;
231        use core::convert::TryInto;
232
233        #[derive(Deserialize, Serialize, PartialEq, Debug, Clone)]
234        struct Test<'decoder> {
235            b: bool,
236            a: B064K<'decoder>,
237        }
238
239        #[test]
240        fn test_b064k() {
241            let mut b = [1, 2, 9];
242            let b: B064K = (&mut b[..])
243                .try_into()
244                .expect("vector smaller than 64K should not fail");
245
246            let expected = Test { a: b, b: true };
247
248            let mut bytes = to_bytes(expected.clone()).unwrap();
249
250            let deserialized: Test = from_bytes(&mut bytes[..]).unwrap();
251
252            assert_eq!(deserialized, expected);
253        }
254    }
255
256    mod test_seq0255_u256 {
257        use super::*;
258        use core::convert::TryInto;
259
260        #[derive(Deserialize, Serialize, PartialEq, Debug, Clone)]
261        struct Test<'decoder> {
262            a: Seq0255<'decoder, U256<'decoder>>,
263        }
264
265        #[test]
266        fn test_seq0255_u256() {
267            let mut u256_1 = [6; 32];
268            let mut u256_2 = [5; 32];
269            let mut u256_3 = [0; 32];
270            let u256_1: U256 = (&mut u256_1[..]).try_into().unwrap();
271            let u256_2: U256 = (&mut u256_2[..]).try_into().unwrap();
272            let u256_3: U256 = (&mut u256_3[..]).try_into().unwrap();
273
274            let val = vec![u256_1, u256_2, u256_3];
275            let s = Seq0255::new(val).unwrap();
276
277            let test = Test { a: s };
278
279            let mut bytes = to_bytes(test.clone()).unwrap();
280
281            let deserialized: Test = from_bytes(&mut bytes[..]).unwrap();
282
283            let bytes_2 = to_bytes(deserialized.clone()).unwrap();
284
285            assert_eq!(bytes, bytes_2);
286        }
287    }
288
289    mod test_0255_bool {
290        use super::*;
291
292        #[derive(Deserialize, Serialize, PartialEq, Debug, Clone)]
293        struct Test<'decoder> {
294            a: Seq0255<'decoder, bool>,
295        }
296
297        #[test]
298        fn test_seq0255_bool() {
299            let s: Seq0255<bool> = Seq0255::new(vec![true, false, true]).unwrap();
300
301            let expected = Test { a: s };
302
303            let mut bytes = to_bytes(expected.clone()).unwrap();
304
305            let deserialized: Test = from_bytes(&mut bytes[..]).unwrap();
306
307            assert_eq!(deserialized, expected);
308        }
309    }
310
311    mod test_seq0255_u16 {
312        use super::*;
313
314        #[derive(Deserialize, Serialize, PartialEq, Debug, Clone)]
315        struct Test<'decoder> {
316            a: Seq0255<'decoder, u16>,
317        }
318
319        #[test]
320        fn test_seq0255_u16() {
321            let s: Seq0255<u16> = Seq0255::new(vec![10, 43, 89]).unwrap();
322
323            let expected = Test { a: s };
324
325            let mut bytes = to_bytes(expected.clone()).unwrap();
326
327            let deserialized: Test = from_bytes(&mut bytes[..]).unwrap();
328
329            assert_eq!(deserialized, expected);
330        }
331    }
332
333    mod test_seq_0255_u24 {
334        use super::*;
335        use core::convert::TryInto;
336
337        #[derive(Deserialize, Serialize, PartialEq, Debug, Clone)]
338        struct Test<'decoder> {
339            a: Seq0255<'decoder, U24>,
340        }
341
342        #[test]
343        fn test_seq0255_u24() {
344            let u24_1: U24 = 56_u32.try_into().unwrap();
345            let u24_2: U24 = 59_u32.try_into().unwrap();
346            let u24_3: U24 = 70999_u32.try_into().unwrap();
347
348            let val = vec![u24_1, u24_2, u24_3];
349            let s: Seq0255<U24> = Seq0255::new(val).unwrap();
350
351            let expected = Test { a: s };
352
353            let mut bytes = to_bytes(expected.clone()).unwrap();
354
355            let deserialized: Test = from_bytes(&mut bytes[..]).unwrap();
356
357            assert_eq!(deserialized, expected);
358        }
359    }
360
361    mod test_seqo255_u32 {
362        use super::*;
363
364        #[derive(Deserialize, Serialize, PartialEq, Debug, Clone)]
365        struct Test<'decoder> {
366            a: Seq0255<'decoder, u32>,
367        }
368
369        #[test]
370        fn test_seq0255_u32() {
371            let s: Seq0255<u32> = Seq0255::new(vec![546, 99999, 87, 32]).unwrap();
372
373            let expected = Test { a: s };
374
375            let mut bytes = to_bytes(expected.clone()).unwrap();
376
377            let deserialized: Test = from_bytes(&mut bytes[..]).unwrap();
378
379            assert_eq!(deserialized, expected);
380        }
381    }
382
383    mod test_seq0255_signature {
384        use super::*;
385        use core::convert::TryInto;
386
387        #[derive(Deserialize, Serialize, PartialEq, Debug, Clone)]
388        struct Test<'decoder> {
389            a: Seq0255<'decoder, Signature<'decoder>>,
390        }
391
392        #[test]
393        fn test_seq0255_signature() {
394            let mut siganture_1 = [88_u8; 64];
395            let mut siganture_2 = [99_u8; 64];
396            let mut siganture_3 = [220_u8; 64];
397            let siganture_1: Signature = (&mut siganture_1[..]).try_into().unwrap();
398            let siganture_2: Signature = (&mut siganture_2[..]).try_into().unwrap();
399            let siganture_3: Signature = (&mut siganture_3[..]).try_into().unwrap();
400
401            let val = vec![siganture_1, siganture_2, siganture_3];
402            let s: Seq0255<Signature> = Seq0255::new(val).unwrap();
403
404            let expected = Test { a: s };
405
406            let mut bytes = to_bytes(expected.clone()).unwrap();
407
408            let deserialized: Test = from_bytes(&mut bytes[..]).unwrap();
409
410            assert_eq!(deserialized, expected);
411        }
412    }
413
414    mod test_seq_064_u256 {
415        use super::*;
416        use core::convert::TryInto;
417
418        #[derive(Deserialize, Serialize, PartialEq, Debug, Clone)]
419        struct Test<'decoder> {
420            a: Seq064K<'decoder, U256<'decoder>>,
421        }
422
423        #[test]
424        fn test_seq064k_u256() {
425            let mut u256_1 = [6; 32];
426            let mut u256_2 = [5; 32];
427            let mut u256_3 = [0; 32];
428            let u256_1: U256 = (&mut u256_1[..]).try_into().unwrap();
429            let u256_2: U256 = (&mut u256_2[..]).try_into().unwrap();
430            let u256_3: U256 = (&mut u256_3[..]).try_into().unwrap();
431
432            let val = vec![u256_1, u256_2, u256_3];
433            let s = Seq064K::new(val).unwrap();
434
435            let test = Test { a: s };
436
437            let mut bytes = to_bytes(test.clone()).unwrap();
438
439            let deserialized: Test = from_bytes(&mut bytes[..]).unwrap();
440
441            let bytes_2 = to_bytes(deserialized.clone()).unwrap();
442
443            assert_eq!(bytes, bytes_2);
444        }
445    }
446
447    mod test_064_bool {
448        use super::*;
449
450        #[derive(Deserialize, Serialize, PartialEq, Debug, Clone)]
451        struct Test<'decoder> {
452            a: Seq064K<'decoder, bool>,
453        }
454
455        #[test]
456        fn test_seq064k_bool() {
457            let s: Seq064K<bool> = Seq064K::new(vec![true, false, true]).unwrap();
458            let s2: Seq064K<bool> = Seq064K::new(vec![true; 64000]).unwrap();
459
460            let expected = Test { a: s };
461            let expected2 = Test { a: s2 };
462
463            let mut bytes = to_bytes(expected.clone()).unwrap();
464            let mut bytes2 = to_bytes(expected2.clone()).unwrap();
465
466            let deserialized: Test = from_bytes(&mut bytes[..]).unwrap();
467            let deserialized2: Test = from_bytes(&mut bytes2[..]).unwrap();
468
469            assert_eq!(deserialized, expected);
470            assert_eq!(deserialized2, expected2);
471        }
472    }
473
474    mod test_se1o64k_u16 {
475        use super::*;
476
477        #[derive(Deserialize, Serialize, PartialEq, Debug, Clone)]
478        struct Test<'decoder> {
479            a: Seq064K<'decoder, u16>,
480        }
481
482        #[test]
483        fn test_seq064k_u16() {
484            let s: Seq064K<u16> = Seq064K::new(vec![10, 43, 89]).unwrap();
485
486            let expected = Test { a: s };
487
488            let mut bytes = to_bytes(expected.clone()).unwrap();
489
490            let deserialized: Test = from_bytes(&mut bytes[..]).unwrap();
491
492            assert_eq!(deserialized, expected);
493        }
494    }
495
496    mod test_seq064k_u24 {
497        use super::*;
498        use core::convert::TryInto;
499
500        #[derive(Deserialize, Serialize, PartialEq, Debug, Clone)]
501        struct Test<'decoder> {
502            a: Seq064K<'decoder, U24>,
503        }
504
505        #[test]
506        fn test_seq064k_u24() {
507            let u24_1: U24 = 56_u32.try_into().unwrap();
508            let u24_2: U24 = 59_u32.try_into().unwrap();
509            let u24_3: U24 = 70999_u32.try_into().unwrap();
510
511            let val = vec![u24_1, u24_2, u24_3];
512            let s: Seq064K<U24> = Seq064K::new(val).unwrap();
513
514            let expected = Test { a: s };
515
516            let mut bytes = to_bytes(expected.clone()).unwrap();
517
518            let deserialized: Test = from_bytes(&mut bytes[..]).unwrap();
519
520            assert_eq!(deserialized, expected);
521        }
522    }
523
524    mod test_seq064k_u32 {
525        use super::*;
526
527        #[derive(Deserialize, Serialize, PartialEq, Debug, Clone)]
528        struct Test<'decoder> {
529            a: Seq064K<'decoder, u32>,
530        }
531
532        #[test]
533        fn test_seq064k_u32() {
534            let s: Seq064K<u32> = Seq064K::new(vec![546, 99999, 87, 32]).unwrap();
535
536            let expected = Test { a: s };
537
538            let mut bytes = to_bytes(expected.clone()).unwrap();
539
540            let deserialized: Test = from_bytes(&mut bytes[..]).unwrap();
541
542            assert_eq!(deserialized, expected);
543        }
544    }
545    mod test_seq064k_signature {
546        use super::*;
547        use core::convert::TryInto;
548
549        #[derive(Deserialize, Serialize, PartialEq, Debug, Clone)]
550        struct Test<'decoder> {
551            a: Seq064K<'decoder, Signature<'decoder>>,
552        }
553
554        #[test]
555        fn test_seq064k_signature() {
556            let mut siganture_1 = [88_u8; 64];
557            let mut siganture_2 = [99_u8; 64];
558            let mut siganture_3 = [220_u8; 64];
559            let siganture_1: Signature = (&mut siganture_1[..]).try_into().unwrap();
560            let siganture_2: Signature = (&mut siganture_2[..]).try_into().unwrap();
561            let siganture_3: Signature = (&mut siganture_3[..]).try_into().unwrap();
562
563            let val = vec![siganture_1, siganture_2, siganture_3];
564            let s: Seq064K<Signature> = Seq064K::new(val).unwrap();
565
566            let expected = Test { a: s };
567
568            let mut bytes = to_bytes(expected.clone()).unwrap();
569
570            let deserialized: Test = from_bytes(&mut bytes[..]).unwrap();
571
572            assert_eq!(deserialized, expected);
573        }
574    }
575    mod test_seq064k_b016m {
576        use super::*;
577        use core::convert::TryInto;
578
579        #[derive(Deserialize, Serialize, PartialEq, Debug, Clone)]
580        struct Test<'decoder> {
581            a: Seq064K<'decoder, B016M<'decoder>>,
582        }
583
584        #[test]
585        fn test_seq064k_b016m() {
586            let mut bytes_1 = [88_u8; 64];
587            let mut bytes_2 = [99_u8; 64];
588            let mut bytes_3 = [220_u8; 64];
589            let bytes_1: B016M = (&mut bytes_1[..]).try_into().unwrap();
590            let bytes_2: B016M = (&mut bytes_2[..]).try_into().unwrap();
591            let bytes_3: B016M = (&mut bytes_3[..]).try_into().unwrap();
592
593            let val = vec![bytes_1, bytes_2, bytes_3];
594            let s: Seq064K<B016M> = Seq064K::new(val).unwrap();
595
596            let expected = Test { a: s };
597
598            let mut bytes = to_bytes(expected.clone()).unwrap();
599
600            let deserialized: Test = from_bytes(&mut bytes[..]).unwrap();
601
602            assert_eq!(deserialized, expected);
603        }
604    }
605    mod test_seq_0255_in_struct {
606        use super::*;
607
608        #[derive(Deserialize, Serialize, PartialEq, Debug, Clone)]
609        struct Test<'decoder> {
610            a: u8,
611            b: Seq0255<'decoder, u8>,
612            c: u32,
613        }
614
615        #[test]
616        fn test_seq_0255_in_struct() {
617            let expected = Test {
618                a: 89,
619                b: Seq0255::new(vec![]).unwrap(),
620                c: 32,
621            };
622            let len = expected.get_size();
623            let mut buffer = Vec::new();
624            buffer.resize(len, 0);
625            to_writer(expected.clone(), &mut buffer).unwrap();
626            let deserialized: Test = from_bytes(&mut buffer[..]).unwrap();
627            assert_eq!(deserialized, expected);
628        }
629    }
630    mod test_sv2_option_u256 {
631        use super::*;
632        use core::convert::TryInto;
633
634        #[derive(Deserialize, Serialize, PartialEq, Debug, Clone)]
635        struct Test<'decoder> {
636            a: Sv2Option<'decoder, U256<'decoder>>,
637        }
638
639        #[test]
640        fn test_sv2_option_u256() {
641            let mut u256_1 = [6; 32];
642            let u256_1: U256 = (&mut u256_1[..]).try_into().unwrap();
643
644            let val = Some(u256_1);
645            let s = Sv2Option::new(val);
646
647            let test = Test { a: s };
648
649            let mut bytes = to_bytes(test.clone()).unwrap();
650
651            let deserialized: Test = from_bytes(&mut bytes[..]).unwrap();
652
653            let bytes_2 = to_bytes(deserialized.clone()).unwrap();
654
655            assert_eq!(bytes, bytes_2);
656        }
657    }
658    mod test_sv2_option_none {
659        use super::*;
660
661        #[derive(Deserialize, Serialize, PartialEq, Debug, Clone)]
662        struct Test<'decoder> {
663            a: Sv2Option<'decoder, U256<'decoder>>,
664        }
665
666        #[test]
667        fn test_sv2_option_none() {
668            let val = None;
669            let s = Sv2Option::new(val);
670
671            let test = Test { a: s };
672
673            let mut bytes = to_bytes(test.clone()).unwrap();
674
675            let deserialized: Test = from_bytes(&mut bytes[..]).unwrap();
676
677            let bytes_2 = to_bytes(deserialized.clone()).unwrap();
678
679            assert_eq!(bytes, bytes_2);
680        }
681    }
682}
binary_sv2/lib.rs

binary_sv2/
lib.rs
