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
77
78
79
80
81
82
use crate::Bytes;
use holo_hash::AgentPubKey;
pub use holochain_integrity_types::signature::*;
use holochain_serialized_bytes::prelude::*;
#[derive(Debug, PartialEq, Serialize, Deserialize, SerializedBytes, Clone)]
pub struct Sign {
pub key: holo_hash::AgentPubKey,
pub data: Bytes,
}
impl Sign {
pub fn new<S>(key: holo_hash::AgentPubKey, input: S) -> Result<Self, SerializedBytesError>
where
S: Serialize + std::fmt::Debug,
{
Ok(Self::new_raw(
key,
holochain_serialized_bytes::encode(&input)?,
))
}
pub fn new_raw(key: holo_hash::AgentPubKey, data: Vec<u8>) -> Self {
Self {
key,
data: Bytes::from(data),
}
}
pub fn key(&self) -> &AgentPubKey {
&self.key
}
pub fn data(&self) -> &[u8] {
&self.data
}
}
#[derive(Serialize, Deserialize, Debug, PartialEq)]
#[serde(transparent)]
pub struct SignEphemeral(pub Vec<Bytes>);
impl SignEphemeral {
pub fn new<S>(inputs: Vec<S>) -> Result<Self, SerializedBytesError>
where
S: Serialize + std::fmt::Debug,
{
let datas: Result<Vec<_>, _> = inputs
.into_iter()
.map(|s| holochain_serialized_bytes::encode(&s))
.collect();
Ok(Self::new_raw(datas?))
}
pub fn new_raw(datas: Vec<Vec<u8>>) -> Self {
Self(datas.into_iter().map(Bytes::from).collect())
}
pub fn into_inner(self) -> Vec<Bytes> {
self.0
}
}