rustao 0.2.0

Rust SDK for the AO protocol on Arweave
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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

use crate::error::{Error, Result};
use crate::schema::Tag;
use crate::signer::ARSigner;
use crate::utils::{base64url_encode, read_varint, sha256, write_varint};

#[derive(Debug, Clone)]
pub struct DataItem {
    pub target: String,
    pub data: Vec<u8>,
    pub tags: Vec<Tag>,
    pub anchor: Vec<u8>,
    pub owner: Vec<u8>,
    pub signature: Vec<u8>,
    pub id: String,
}

impl DataItem {
    pub fn new(target: String, data: Vec<u8>, tags: Vec<Tag>, anchor: Vec<u8>) -> Self {
        let anchor = if anchor.len() > 32 { anchor[..32].to_vec() } else { anchor };
        Self {
            target,
            data,
            tags,
            anchor,
            owner: Vec::new(),
            signature: Vec::new(),
            id: String::new(),
        }
    }

    pub fn sign(&mut self, signer: &ARSigner) -> Result<()> {
        let data_to_sign = self.get_signature_data()?;
        self.signature = signer.sign(&data_to_sign)?;
        self.owner = signer.public_key().to_vec();
        self.id = self.compute_id()?;
        Ok(())
    }

    pub fn get_signature_data(&self) -> Result<Vec<u8>> {
        let mut buf = Vec::new();

        // Owner
        write_varint(&mut buf, self.owner.len() as u64);
        buf.extend_from_slice(&self.owner);

        // Target
        let target_bytes = self.target.as_bytes();
        write_varint(&mut buf, target_bytes.len() as u64);
        buf.extend_from_slice(target_bytes);

        // Anchor
        write_varint(&mut buf, self.anchor.len() as u64);
        buf.extend_from_slice(&self.anchor);

        // Tags
        write_varint(&mut buf, self.tags.len() as u64);
        for tag in &self.tags {
            let name_bytes = tag.name.as_bytes();
            write_varint(&mut buf, name_bytes.len() as u64);
            buf.extend_from_slice(name_bytes);

            let value_bytes = tag.value.as_bytes();
            write_varint(&mut buf, value_bytes.len() as u64);
            buf.extend_from_slice(value_bytes);
        }

        // Data
        write_varint(&mut buf, self.data.len() as u64);
        buf.extend_from_slice(&self.data);

        Ok(buf)
    }

    pub fn serialize(&self) -> Result<Vec<u8>> {
        let mut buf = self.get_signature_data()?;
        write_varint(&mut buf, self.signature.len() as u64);
        buf.extend_from_slice(&self.signature);
        Ok(buf)
    }

    pub fn compute_id(&self) -> Result<String> {
        let data_to_sign = self.get_signature_data()?;
        let hash = sha256(&data_to_sign);
        Ok(base64url_encode(&hash))
    }

    pub fn deserialize(data: &[u8]) -> Result<Self> {
        let mut pos = 0;

        // Owner
        let (owner_len, new_pos) = read_varint(data, pos).map_err(|e| Error::DataItem(e))?;
        pos = new_pos;
        if pos + owner_len as usize > data.len() {
            return Err(Error::DataItem("unexpected end of data reading owner".into()));
        }
        let owner = data[pos..pos + owner_len as usize].to_vec();
        pos += owner_len as usize;

        // Target
        let (target_len, new_pos) = read_varint(data, pos).map_err(|e| Error::DataItem(e))?;
        pos = new_pos;
        let target = if target_len > 0 {
            let target_bytes = &data[pos..pos + target_len as usize];
            pos += target_len as usize;
            String::from_utf8(target_bytes.to_vec()).map_err(|_| Error::DataItem("invalid target UTF-8".into()))?
        } else {
            String::new()
        };

        // Anchor
        let (anchor_len, new_pos) = read_varint(data, pos).map_err(|e| Error::DataItem(e))?;
        pos = new_pos;
        let anchor = data[pos..pos + anchor_len as usize].to_vec();
        pos += anchor_len as usize;

        // Tags
        let (tag_count, new_pos) = read_varint(data, pos).map_err(|e| Error::DataItem(e))?;
        pos = new_pos;
        let mut tags = Vec::with_capacity(tag_count as usize);
        for _ in 0..tag_count {
            let (name_len, new_pos) = read_varint(data, pos).map_err(|e| Error::DataItem(e))?;
            pos = new_pos;
            let name_bytes = &data[pos..pos + name_len as usize];
            pos += name_len as usize;
            let name = String::from_utf8(name_bytes.to_vec()).map_err(|_| Error::DataItem("invalid tag name UTF-8".into()))?;

            let (value_len, new_pos) = read_varint(data, pos).map_err(|e| Error::DataItem(e))?;
            pos = new_pos;
            let value_bytes = &data[pos..pos + value_len as usize];
            pos += value_len as usize;
            let value = String::from_utf8(value_bytes.to_vec()).map_err(|_| Error::DataItem("invalid tag value UTF-8".into()))?;

            tags.push(Tag::new(&name, &value));
        }

        // Data
        let (data_len, new_pos) = read_varint(data, pos).map_err(|e| Error::DataItem(e))?;
        pos = new_pos;
        let payload = data[pos..pos + data_len as usize].to_vec();
        pos += data_len as usize;

        // Signature
        let (sig_len, new_pos) = read_varint(data, pos).map_err(|e| Error::DataItem(e))?;
        pos = new_pos;
        let signature = data[pos..pos + sig_len as usize].to_vec();

        let mut di = Self::new(target, payload, tags, anchor);
        di.owner = owner;
        di.signature = signature;
        di.id = di.compute_id()?;
        Ok(di)
    }
}