psibase 0.23.0

Library and command-line tool for interacting with psibase networks
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

use crate::serialize_as_str;
use custom_error::custom_error;
use fracpack::{FracInputStream, Pack, ToSchema, Unpack};
use std::fmt;
use std::str::FromStr;

custom_error! { pub MemoError
    MemoTooLarge = "Memo must be 80 bytes or less"
}

#[derive(Debug, Clone, ToSchema, Default, Pack)]
#[fracpack(fracpack_mod = "fracpack")]
pub struct Memo(String);

impl Memo {
    pub fn new(value: String) -> Result<Self, MemoError> {
        if value.len() <= 80 {
            Ok(Self(value))
        } else {
            Err(MemoError::MemoTooLarge)
        }
    }
}

impl fmt::Display for Memo {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.0.fmt(f)
    }
}

impl TryFrom<String> for Memo {
    type Error = MemoError;

    fn try_from(value: String) -> Result<Self, Self::Error> {
        Self::new(value)
    }
}

impl FromStr for Memo {
    type Err = MemoError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Self::new(s.to_string())
    }
}

impl From<&str> for Memo {
    fn from(s: &str) -> Self {
        Memo::from_str(s).unwrap()
    }
}

impl<'a> Unpack<'a> for Memo {
    const FIXED_SIZE: u32 = 4;
    const VARIABLE_SIZE: bool = true;

    fn unpack(src: &mut FracInputStream) -> fracpack::Result<Self> {
        Ok(Self::new(String::unpack(src)?).map_err(|_| fracpack::Error::ExtraData)?)
    }

    fn verify(src: &mut FracInputStream) -> fracpack::Result<()> {
        let len = <&str>::unpack(src)?.len();

        if len <= 80 {
            Ok(())
        } else {
            Err(fracpack::Error::ExtraData)
        }
    }

    fn new_empty_container() -> fracpack::Result<Self> {
        Ok(Default::default())
    }
}

serialize_as_str!(Memo, "memo");