rust_chain/
structs.rs

1use crate::utils::{
2    decode_hex,
3};
4
5use crate::vmapi::eosio::{
6    slice_copy,
7    check,
8};
9
10use crate::name::{ Name };
11
12use crate::print::{ 
13    Printable,
14    printui128,
15    // printhex,
16};
17
18use crate::serializer::{
19    Packer,
20    Encoder,
21    Decoder,
22};
23
24use crate::varint::{
25    VarUint32,
26};
27
28use crate::{
29    vec::Vec,
30    string::String,
31};
32
33///
34#[repr(C, align(8))]
35#[cfg_attr(feature = "std", derive(eosio_scale_info::TypeInfo))]
36#[derive(Clone, Copy, Eq, PartialEq, Default)]
37pub struct Float128 {
38    ///
39    pub data: [u8; 16],
40}
41
42impl Float128 {
43    ///
44    pub fn new(data: [u8;16]) -> Self {
45        Self {
46            data: data
47        }
48    }
49
50    ///
51    pub fn data(&self) -> &[u8; 16] {
52        return &self.data;
53    }
54}
55
56impl Packer for Float128 {
57    fn size(&self) -> usize {
58        return 16;
59    }
60
61    fn pack(&self, enc: &mut Encoder) -> usize {
62        let data = enc.alloc(self.size());
63        slice_copy(data, &self.data);
64        self.size()
65    }
66
67    fn unpack(&mut self, raw: &[u8]) -> usize {
68        let size = self.size();
69        check(raw.len() >= size, "Float128.unpack: buffer overflow!");
70        slice_copy(&mut self.data, &raw[..size]);
71        return self.size();
72    }
73}
74
75///
76#[repr(C, align(8))]
77#[cfg_attr(feature = "std", derive(eosio_scale_info::TypeInfo))]
78#[derive(Clone, Copy, Eq, PartialEq, Default)]
79pub struct Checksum160 {
80    pub data: [u8; 20],
81}
82
83impl Checksum160 {
84    ///
85    pub fn from_hex(s: &str) -> Self {
86        check(s.len() == 40, "Checksum160: bad hex string length");
87        let data = decode_hex(s);
88        let mut ret = Self::default();
89        slice_copy(&mut ret.data, &data);
90        return ret;
91    }
92}
93
94impl Packer for Checksum160 {
95    fn size(&self) -> usize {
96        return 20;
97    }
98
99    fn pack(&self, enc: &mut Encoder) -> usize {
100        let data = enc.alloc(self.size());
101        slice_copy(data, &self.data);
102        self.size()
103    }
104
105    fn unpack(&mut self, raw: &[u8]) -> usize {
106        let size = self.size();
107        check(raw.len() >= size, "Checksum160.unpack: buffer overflow!");
108        slice_copy(&mut self.data, &raw[..size]);
109        return size;
110    }
111}
112
113///
114#[repr(C, align(8))]
115#[cfg_attr(feature = "std", derive(eosio_scale_info::TypeInfo))]
116#[derive(Clone, Copy, Eq, PartialEq, Default)]
117pub struct Checksum256 {
118    ///
119    pub data: [u8; 32],
120}
121
122impl Checksum256 {
123    ///
124    pub fn from_hex(s: &str) -> Self {
125        check(s.len() == 64, "Checksum256: bad hex string length");
126        let data = decode_hex(s);
127        let mut ret = Self::default();
128        slice_copy(&mut ret.data, &data);
129        return ret;
130    }
131}
132
133impl Packer for Checksum256 {
134    fn size(&self) -> usize {
135        return 32;
136    }
137
138    fn pack(&self, enc: &mut Encoder) -> usize {
139        let data = enc.alloc(self.size());
140        slice_copy(data, &self.data);
141        self.size()
142    }
143
144    fn unpack(&mut self, raw: &[u8]) -> usize {
145        let size = self.size();
146        check(raw.len() >= size, "Checksum256.unpack: buffer overflow!");
147        slice_copy(&mut self.data, &raw[..size]);
148        return self.size();
149    }
150}
151
152///
153#[repr(C, align(8))]
154#[cfg_attr(feature = "std", derive(eosio_scale_info::TypeInfo))]
155#[derive(Clone, Copy, Eq, PartialEq)]
156pub struct Checksum512 {
157    pub data: [u8; 64],
158}
159
160impl Checksum512 {
161    ///
162    pub fn from_hex(s: &str) -> Self {
163        check(s.len() == 128, "Checksum512: bad hex string length");
164        let data = decode_hex(s);
165        let mut ret = Self::default();
166        slice_copy(&mut ret.data, &data);
167        return ret;
168    }
169}
170
171impl Default for Checksum512 {
172    ///
173    #[inline]
174    fn default() -> Self {
175        Checksum512{data: [0; 64]}
176    }
177}
178
179impl Packer for Checksum512 {
180    fn size(&self) -> usize {
181        return 64;
182    }
183
184    fn pack(&self, enc: &mut Encoder) -> usize {
185        let data = enc.alloc(self.size());
186        slice_copy(data, &self.data);
187        self.size()
188    }
189
190    fn unpack(&mut self, raw: &[u8]) -> usize {
191        let size = self.size();
192        check(raw.len() >= size, "Checksum512.unpack: buffer overflow!");
193        slice_copy(&mut self.data, &raw[..size]);
194        return size;
195    }
196}
197
198
199///
200#[cfg_attr(feature = "std", derive(eosio_scale_info::TypeInfo))]
201#[derive(Clone, Copy, Eq, PartialEq)]
202pub struct ECCPublicKey {
203    ///
204    pub data: [u8; 33],
205}
206
207impl ECCPublicKey {
208    ///
209    pub fn from_hex(s: &str) -> Self {
210        let mut ret = Self::default();
211        check(s.len() == 33*2, "ECCPublicKey: bad hex string length");
212        let data = decode_hex(s);
213        slice_copy(&mut ret.data, &data);
214        return ret;
215    }
216}
217
218impl Default for ECCPublicKey {
219    ///
220    #[inline]
221    fn default() -> Self {
222        ECCPublicKey{data: [0; 33]}
223    }
224}
225
226impl Packer for ECCPublicKey {
227    fn size(&self) -> usize {
228        return 33;
229    }
230
231    fn pack(&self, enc: &mut Encoder) -> usize {
232        let data = enc.alloc(self.size());
233        slice_copy(data, &self.data);
234        self.size()
235    }
236
237    fn unpack(&mut self, raw: &[u8]) -> usize {
238        let size = self.size();
239        check(raw.len() >= size, "EccPublicKey.unpack: buffer overflow!");
240        slice_copy(&mut self.data, &raw[..size]);
241        return size;
242    }
243}
244
245///
246#[cfg_attr(feature = "std", derive(eosio_scale_info::TypeInfo))]
247#[derive(Clone, Copy, Eq, PartialEq)]
248pub enum UserPresence {
249    ///
250    None = 0,
251    ///
252    Present = 1,
253    ///
254    Verified = 2,
255}
256
257impl Default for UserPresence {
258    fn default() -> Self {
259        UserPresence::None
260    }
261}
262
263impl Packer for UserPresence {
264    ///
265    fn size(&self) -> usize {
266        return 1;
267    }
268
269    ///
270    fn pack(&self, enc: &mut Encoder) -> usize {
271        (*self as u8).pack(enc)
272    }
273
274    ///
275    fn unpack(&mut self, data: &[u8]) -> usize {
276        check(data.len() >= 1, "UserPresence.unpack: buffer overflow");
277        match data[0] {
278            0 => {
279                *self = UserPresence::None;
280            },
281            1 => {
282                *self = UserPresence::Present;
283            },
284            2 => {
285                *self = UserPresence::Verified;
286            }
287            _ => {
288                check(false, "not a UserPresence type");
289            }
290        }
291        return 1;
292    }
293}
294
295///
296#[cfg_attr(feature = "std", derive(eosio_scale_info::TypeInfo))]
297#[derive(Clone, Eq, PartialEq, Default)]
298pub struct WebAuthNPublicKey {
299    ///
300    pub key: ECCPublicKey,
301    ///
302    pub user_presence: UserPresence,
303    ///
304    pub rpid: String,
305}
306
307impl WebAuthNPublicKey {
308    ///
309    pub fn new(key: ECCPublicKey, user_presence: UserPresence, rpid: String) -> Self {
310        Self { key, user_presence, rpid }
311    }
312}
313
314impl Packer for WebAuthNPublicKey {
315    ///
316    fn size(&self) -> usize {
317        self.key.size() + self.user_presence.size() + self.rpid.size()
318    }
319
320    ///
321    fn pack(&self, enc: &mut Encoder) -> usize {
322        let pos = enc.get_size();
323        
324        self.key.pack(enc);
325        self.user_presence.pack(enc);
326        self.rpid.pack(enc);
327        
328        enc.get_size() - pos
329    }
330
331    ///
332    fn unpack(&mut self, data: &[u8]) -> usize {
333        check(data.len() >= 33, "WebAuthNPublicKey.unpack: buffer overflow!");
334        let mut dec = Decoder::new(data);
335        dec.unpack(&mut self.key);
336        dec.unpack(&mut self.user_presence);
337        dec.unpack(&mut self.rpid);
338        return dec.get_pos();
339    }
340}
341
342///
343#[cfg_attr(feature = "std", derive(eosio_scale_info::TypeInfo))]
344#[derive(Clone, Eq, PartialEq)]
345pub enum PublicKey {
346    ///
347    K1(ECCPublicKey),
348    ///
349    R1(ECCPublicKey),
350    ///
351    WebAuth(WebAuthNPublicKey),
352}
353
354impl Default for PublicKey {
355    ///
356    #[inline]
357    fn default() -> Self {
358        PublicKey::K1(ECCPublicKey::default())
359    }
360}
361
362impl Packer for PublicKey {
363    fn size(&self) -> usize {
364        match self {
365            PublicKey::K1(x) => x.size() + 1,
366            PublicKey::R1(x) => x.size() + 1,
367            PublicKey::WebAuth(x) => x.size() + 1,
368        }
369    }
370
371    fn pack(&self, enc: &mut Encoder) -> usize {
372        let pos = enc.get_size();
373        match self {
374            PublicKey::K1(x) => {
375                0u8.pack(enc);
376                x.pack(enc);
377            }
378            PublicKey::R1(x) => {
379                1u8.pack(enc);
380                x.pack(enc);
381            }
382            PublicKey::WebAuth(x) => {
383                2u8.pack(enc);
384                x.pack(enc);
385            }
386        }
387        enc.get_size() - pos
388    }
389
390    fn unpack(&mut self, raw: &[u8]) -> usize {
391        check(raw.len() >= 34, "PublicKey.unpack: buffer overflow!");
392
393        let mut dec = Decoder::new(raw);
394        let mut ty: u8 = 0;
395        dec.unpack(&mut ty);
396        match ty {
397            0 => {
398                let mut pub_key = ECCPublicKey::default();
399                dec.unpack(&mut pub_key);
400                *self = PublicKey::K1(pub_key);
401            },
402            1 => {
403                let mut pub_key = ECCPublicKey::default();
404                dec.unpack(&mut pub_key);
405                *self = PublicKey::R1(pub_key);
406            },
407            2 => {
408                let mut pub_key = WebAuthNPublicKey::default();
409                dec.unpack(&mut pub_key);
410                *self = PublicKey::WebAuth(pub_key);
411            }
412            _ => {
413                check(false, "invalid public key type");
414            }
415        }
416        return dec.get_pos();
417    }
418}
419
420///
421#[cfg_attr(feature = "std", derive(eosio_scale_info::TypeInfo))]
422#[derive(Clone, Eq, PartialEq)]
423pub struct Signature {
424    /// Signature type
425	ty: u8,
426    ///
427	data: [u8; 65],
428}
429
430impl Signature {
431    ///
432    pub fn from_hex(s: &str) -> Self {
433        let mut ret = Self::default();
434        check(s.len() == 65*2, "Signature: bad hex string length");
435        let data = decode_hex(s);
436        ret.ty = 0;
437        slice_copy(&mut ret.data, &data);
438        return ret;
439    }
440}
441
442impl Default for Signature {
443    fn default() -> Self {
444        Self { ty: 0, data: [0; 65] }
445    }
446}
447
448impl Packer for Signature {
449    ///
450    fn size(&self) -> usize {
451        return 66;
452    }
453
454    ///
455    fn pack(&self, enc: &mut Encoder) -> usize {
456        self.ty.pack(enc);
457        let data = enc.alloc(self.data.len());
458        slice_copy(data, &self.data);
459        self.size()
460    }
461
462    ///
463    fn unpack(&mut self, data: &[u8]) -> usize {
464        let size = self.size();
465        check(data.len() >= size, "Signature::unpack: buffer overflow");
466        self.ty = data[0];
467        check(self.ty == 0, "bad signature type");
468        slice_copy(&mut self.data, &data[1..size]);
469        return self.size();
470    }
471}
472
473///
474#[repr(C, align(8))]
475#[cfg_attr(feature = "std", derive(eosio_scale_info::TypeInfo))]
476#[derive(Copy, Clone, Eq, PartialEq)]
477pub struct Uint128 {
478    ///
479    pub lo: u64,
480    ///
481    pub hi: u64,
482}
483
484impl Default for Uint128 {
485    ///
486    #[inline]
487    fn default() -> Self {
488        Self {
489            lo: 0,
490            hi: 0,
491        }
492    }
493}
494
495///
496#[repr(C, align(8))]
497#[cfg_attr(feature = "std", derive(eosio_scale_info::TypeInfo))]
498#[derive(Copy, Clone, Default)]
499pub struct Int128 {
500    ///
501    pub lo: u64,
502    ///
503    pub hi: u64,
504}
505
506///
507#[repr(C, align(8))]
508#[cfg_attr(feature = "std", derive(eosio_scale_info::TypeInfo))]
509#[derive(Copy, Clone, Eq, PartialEq)]
510pub struct Uint256 {
511    ///
512    pub data: [u128; 2],
513}
514
515impl Uint256 {
516    ///
517    pub fn new(lo: u128, hi: u128) -> Self {
518        Self { data: [lo, hi] }
519    }
520}
521
522impl Packer for Uint256 {
523    ///
524    fn size(&self) -> usize {
525        return 32;
526    }
527
528    ///
529    fn pack(&self, enc: &mut Encoder) -> usize {
530        self.data[0].pack(enc);
531        self.data[1].pack(enc);
532        self.size()
533    }
534
535    ///
536    fn unpack(&mut self, data: &[u8]) -> usize {
537        let mut dec = Decoder::new(data);
538        dec.unpack(&mut self.data[0]);
539        dec.unpack(&mut self.data[1]);
540        return dec.get_pos();
541    }
542}
543
544impl Printable for Uint256 {
545    fn print(&self) {
546        if self.data[1] == 0 {
547            printui128(self.data[0]);
548        } else {
549            crate::vmapi::print::printhex(self.data.as_ptr() as *mut u8, 32);
550        }
551    }
552}
553
554impl Default for Uint256 {
555    ///
556    #[inline]
557    fn default() -> Self {
558        Self {
559            data: [Default::default(); 2],
560        }
561    }
562}
563
564///
565#[cfg_attr(feature = "std", derive(eosio_scale_info::TypeInfo))]
566#[derive(Copy, Clone, Default, PartialEq)]
567pub struct TimePoint {
568    /// elapsed in microseconds
569    pub elapsed: u64,
570}
571
572impl Packer for TimePoint {
573    fn size(&self) -> usize {
574        return 8;
575    }
576
577    fn pack(&self, enc: &mut Encoder) -> usize {
578        self.elapsed.pack(enc)
579    }
580
581    fn unpack(&mut self, raw: &[u8]) -> usize {
582        check(raw.len() >= self.size(), "TimePoint.unpack: buffer overflow!");
583        return self.elapsed.unpack(raw);
584    }
585}
586
587///
588#[cfg_attr(feature = "std", derive(eosio_scale_info::TypeInfo))]
589#[derive(Copy, Clone, Eq, PartialEq, Default)]
590pub struct TimePointSec {
591    ///
592    pub seconds: u32,
593}
594
595impl TimePointSec {
596    pub fn new(seconds: u32) -> Self{
597        Self{ seconds }
598    }
599
600    pub fn seconds(&self) -> u32 {
601        return self.seconds;
602    }
603}
604
605impl Packer for TimePointSec {
606    fn size(&self) -> usize {
607        return 4;
608    }
609
610    fn pack(&self, enc: &mut Encoder) -> usize {
611        self.seconds.pack(enc)
612    }
613
614    fn unpack(&mut self, raw: &[u8]) -> usize {
615        check(raw.len() >= self.size(), "TimePointSec.unpack: buffer overflow!");
616        return self.seconds.unpack(raw);
617    }
618}
619
620///
621#[cfg_attr(feature = "std", derive(eosio_scale_info::TypeInfo))]
622#[derive(Copy, Clone, Default)]
623pub struct BlockTimeStampType {
624    ///
625    pub slot: u32,
626}
627
628impl Packer for BlockTimeStampType {
629    fn size(&self) -> usize {
630        return 4;
631    }
632
633    fn pack(&self, enc: &mut Encoder) -> usize {
634        self.slot.pack(enc)
635    }
636
637    fn unpack(&mut self, raw: &[u8]) -> usize {
638        check(raw.len() >= self.size(), "BlockTimeStampType.unpack: buffer overflow!");
639        return self.slot.unpack(raw);
640    }
641}
642
643///
644#[derive(Clone, Eq, PartialEq)]
645pub struct ProducerKey {
646    ///
647    pub producer_name: Name,
648    ///
649    pub block_signing_key: PublicKey,
650}
651
652impl ProducerKey {
653    ///
654    pub fn new(producer_name: Name, block_signing_key: PublicKey) -> Self {
655        ProducerKey {
656            producer_name,
657            block_signing_key,
658        }
659    }
660}
661
662impl Packer for ProducerKey {
663    fn size(&self) -> usize {
664        8 + self.block_signing_key.size()
665    }
666
667    fn pack(&self, enc: &mut Encoder) -> usize {
668        let pos = enc.get_size();
669
670        self.producer_name.pack(enc);
671        self.block_signing_key.pack(enc);
672
673        enc.get_size() - pos
674    }
675
676    fn unpack(&mut self, raw: &[u8]) -> usize {
677        let mut dec = Decoder::new(raw);
678        dec.unpack(&mut self.producer_name);
679        dec.unpack(&mut self.block_signing_key);
680        return dec.get_pos();
681    }
682}
683
684impl Default for ProducerKey {
685    ///
686    #[inline]
687    fn default() -> Self {
688        ProducerKey { producer_name: Default::default(), block_signing_key: Default::default() }
689    }
690}
691
692#[derive(Default)]
693pub struct KeyWeight {
694    pub key: PublicKey,
695    pub weight: u16,
696}
697
698impl Packer for KeyWeight {
699    fn size(&self) -> usize {
700        return 2 + self.key.size();
701    }
702
703    fn pack(&self, enc: &mut Encoder) -> usize {
704        let pos = enc.get_size();
705
706        self.key.pack(enc);
707        self.weight.pack(enc);
708
709        enc.get_size() - pos
710    }
711
712    fn unpack(&mut self, raw: &[u8]) -> usize {
713        let mut dec = Decoder::new(raw);
714        dec.unpack(&mut self.key);
715        dec.unpack(&mut self.weight);
716        return dec.get_pos();
717    }
718}
719
720#[derive(Default)]
721pub struct BlockSigningAuthorityV0 {
722    /**
723     * minimum threshold of accumulated weights from component keys that satisfies this authority
724     *
725     * @brief minimum threshold of accumulated weights from component keys that satisfies this authority
726     */
727    pub threshold: u32,
728
729    /**
730     * component keys and their associated weights
731     *
732     * @brief component keys and their associated weights
733     */
734    pub keys: Vec<KeyWeight>,
735}
736
737impl Packer for BlockSigningAuthorityV0 {
738    fn size(&self) -> usize {
739        let mut size = 2 + VarUint32::new(self.keys.len() as u32).size();
740        for key in &self.keys {
741            size += key.size();
742        }
743        return size;
744    }
745
746    fn pack(&self, enc: &mut Encoder) -> usize {
747        let pos = enc.get_size();
748
749        self.threshold.pack(enc);
750        self.keys.pack(enc);
751
752        enc.get_size() - pos
753    }
754
755    fn unpack(&mut self, raw: &[u8]) -> usize {
756        let mut dec = Decoder::new(raw);
757        dec.unpack(&mut self.threshold);
758        dec.unpack(&mut self.keys);
759        return dec.get_pos();
760    }
761}
762
763pub enum BlockSigningAuthority {
764    V0(BlockSigningAuthorityV0)
765}
766
767impl Default for BlockSigningAuthority {
768    fn default() -> Self {
769        BlockSigningAuthority::V0(Default::default())
770    }
771}
772
773impl Packer for BlockSigningAuthority {
774    fn size(&self) -> usize {
775        return 1 + match self {
776            BlockSigningAuthority::V0(x) => x.size(),
777        };
778    }
779
780    fn pack(&self, enc: &mut Encoder) -> usize {
781        let pos = enc.get_size();
782        0u8.pack(enc);
783        match self {
784            BlockSigningAuthority::V0(x) => {
785                x.pack(enc);
786            }
787        }
788        enc.get_size() - pos
789    }
790
791    fn unpack(&mut self, raw: &[u8]) -> usize {
792        let mut dec = Decoder::new(raw);
793        let mut ty = 0u8;
794        dec.unpack(&mut ty);
795        if ty == 0 {
796            let mut v0 = BlockSigningAuthorityV0::default();
797            dec.unpack(&mut v0);
798            *self = BlockSigningAuthority::V0(v0);
799        } else {
800            check(false, "bad BlockSigningAuthority type");
801        }
802        return dec.get_pos();
803    }
804}
805
806
807#[derive(Default)]
808pub struct ProducerAuthority {
809
810    /**
811     * Name of the producer
812     *
813     * @brief Name of the producer
814     */
815    pub producer_name: Name,
816
817    /**
818     * The block signing authority used by this producer
819     */
820    pub authority: BlockSigningAuthority,
821}
822
823impl Packer for ProducerAuthority {
824    fn size(&self) -> usize {
825        return self.producer_name.size() + self.authority.size();
826    }
827
828    fn pack(&self, enc: &mut Encoder) -> usize {
829        let pos = enc.get_size();
830
831        self.producer_name.pack(enc);
832        self.authority.pack(enc);
833
834        enc.get_size() - pos
835    }
836
837    fn unpack(&mut self, raw: &[u8]) -> usize {
838        let mut dec = Decoder::new(raw);
839        dec.unpack(&mut self.producer_name);
840        dec.unpack(&mut self.authority);
841        return dec.get_pos();
842    }
843}
rust_chain/structs.rs

rust_chain/
structs.rs
