eosio_chain/
structs.rs

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

eosio_chain/
structs.rs
