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 };
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#[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 pub data: [u8; 16],
40}
41
42impl Float128 {
43 pub fn new(data: [u8;16]) -> Self {
45 Self {
46 data: data
47 }
48 }
49
50 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#[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 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#[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 pub data: [u8; 32],
120}
121
122impl Checksum256 {
123 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#[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 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 #[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#[cfg_attr(feature = "std", derive(eosio_scale_info::TypeInfo))]
201#[derive(Clone, Copy, Eq, PartialEq)]
202pub struct ECCPublicKey {
203 pub data: [u8; 33],
205}
206
207impl ECCPublicKey {
208 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 #[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#[cfg_attr(feature = "std", derive(eosio_scale_info::TypeInfo))]
247#[derive(Clone, Copy, Eq, PartialEq)]
248pub enum UserPresence {
249 None = 0,
251 Present = 1,
253 Verified = 2,
255}
256
257impl Default for UserPresence {
258 fn default() -> Self {
259 UserPresence::None
260 }
261}
262
263impl Packer for UserPresence {
264 fn size(&self) -> usize {
266 return 1;
267 }
268
269 fn pack(&self, enc: &mut Encoder) -> usize {
271 (*self as u8).pack(enc)
272 }
273
274 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#[cfg_attr(feature = "std", derive(eosio_scale_info::TypeInfo))]
297#[derive(Clone, Eq, PartialEq, Default)]
298pub struct WebAuthNPublicKey {
299 pub key: ECCPublicKey,
301 pub user_presence: UserPresence,
303 pub rpid: String,
305}
306
307impl WebAuthNPublicKey {
308 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 fn size(&self) -> usize {
317 self.key.size() + self.user_presence.size() + self.rpid.size()
318 }
319
320 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 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#[cfg_attr(feature = "std", derive(eosio_scale_info::TypeInfo))]
344#[derive(Clone, Eq, PartialEq)]
345pub enum PublicKey {
346 K1(ECCPublicKey),
348 R1(ECCPublicKey),
350 WebAuth(WebAuthNPublicKey),
352}
353
354impl Default for PublicKey {
355 #[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#[cfg_attr(feature = "std", derive(eosio_scale_info::TypeInfo))]
422#[derive(Clone, Eq, PartialEq)]
423pub struct Signature {
424 ty: u8,
426 data: [u8; 65],
428}
429
430impl Signature {
431 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 fn size(&self) -> usize {
451 return 66;
452 }
453
454 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 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#[repr(C, align(8))]
475#[cfg_attr(feature = "std", derive(eosio_scale_info::TypeInfo))]
476#[derive(Copy, Clone, Eq, PartialEq)]
477pub struct Uint128 {
478 pub lo: u64,
480 pub hi: u64,
482}
483
484impl Default for Uint128 {
485 #[inline]
487 fn default() -> Self {
488 Self {
489 lo: 0,
490 hi: 0,
491 }
492 }
493}
494
495#[repr(C, align(8))]
497#[cfg_attr(feature = "std", derive(eosio_scale_info::TypeInfo))]
498#[derive(Copy, Clone, Default)]
499pub struct Int128 {
500 pub lo: u64,
502 pub hi: u64,
504}
505
506#[repr(C, align(8))]
508#[cfg_attr(feature = "std", derive(eosio_scale_info::TypeInfo))]
509#[derive(Copy, Clone, Eq, PartialEq)]
510pub struct Uint256 {
511 pub data: [u128; 2],
513}
514
515impl Uint256 {
516 pub fn new(lo: u128, hi: u128) -> Self {
518 Self { data: [lo, hi] }
519 }
520}
521
522impl Packer for Uint256 {
523 fn size(&self) -> usize {
525 return 32;
526 }
527
528 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 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 #[inline]
557 fn default() -> Self {
558 Self {
559 data: [Default::default(); 2],
560 }
561 }
562}
563
564#[cfg_attr(feature = "std", derive(eosio_scale_info::TypeInfo))]
566#[derive(Copy, Clone, Default, PartialEq)]
567pub struct TimePoint {
568 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#[cfg_attr(feature = "std", derive(eosio_scale_info::TypeInfo))]
589#[derive(Copy, Clone, Eq, PartialEq, Default)]
590pub struct TimePointSec {
591 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#[cfg_attr(feature = "std", derive(eosio_scale_info::TypeInfo))]
622#[derive(Copy, Clone, Default)]
623pub struct BlockTimeStampType {
624 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#[derive(Clone, Eq, PartialEq)]
645pub struct ProducerKey {
646 pub producer_name: Name,
648 pub block_signing_key: PublicKey,
650}
651
652impl ProducerKey {
653 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 #[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 pub threshold: u32,
728
729 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 pub producer_name: Name,
816
817 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}