nintypes 0.2.11

Nintondo shared types
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

use crate::common::hash::Hash256;
use crate::common::inscriptions::Genesis;
use crate::common::mime::{Extension, Other};
use crate::common::tokens::InscriptionProtocol;
use crate::external::electrs::{ElectrsDataswampBlock, ElectrsInscription, ProtocolKey};
use crate::utils::sha256::IntoHash256;
use serde::{Deserialize, Serialize};
use sha2::Digest;
use std::fmt::{Display, Formatter};

use super::electrs::BlockInfo;

#[derive(Clone, Serialize, Deserialize, Debug)]
pub struct PreviewerBlockData {
    pub block_info: BlockInfo,
    pub inscriptions: Vec<PreviewerInscriptionData>,
    pub moved_valid_tokens: Vec<Genesis>,
}

#[derive(Deserialize, Serialize, Clone, Debug)]
pub struct PreviewerInscriptionData {
    pub genesis: Genesis,
    pub content: Vec<u8>,
    pub primary_key: PreviewerInscriptionKey,
    pub delegate: Option<Genesis>,
}

#[derive(Deserialize, Serialize, Clone, Eq, PartialEq, Hash, Debug)]
pub struct PreviewerInscriptionKey {
    pub number: u64,
    pub content_hash: Hash256,
    pub extension: Extension,
    pub protocol: Option<InscriptionProtocol>,
}

impl PreviewerInscriptionKey {
    pub fn generate_hash(&self) -> Hash256 {
        let mut buffer = Vec::new();

        buffer.extend(self.content_hash.0);
        buffer.extend(serde_json::to_vec(&self.extension).expect("Must generate vec from extension"));
        buffer.extend(
            self.protocol
                .as_ref()
                .map(|protocol| serde_json::to_vec(protocol).expect("Must generate vec from protocol"))
                .unwrap_or_default(),
        );

        buffer.hash_256()
    }

    pub fn generate_path(&self) -> String {
        let hash = self.generate_hash();
        let file_type = self.extension.file_type();
        format!("{file_type}/{hash}")
    }
}

impl Display for PreviewerInscriptionKey {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        let hash = self.content_hash;
        let protocol = self.protocol.clone().map(|p| format!("{p:?}")).unwrap_or_default();
        let extension = self.extension.to_string();
        write!(f, "{hash}-{protocol}-{extension}")
    }
}

impl From<ElectrsDataswampBlock> for PreviewerBlockData {
    fn from(value: ElectrsDataswampBlock) -> Self {
        let inscriptions = value
            .inscriptions
            .iter()
            .map(|x| PreviewerInscriptionData {
                genesis: x.location.genesis,
                content: x.clone().content.unwrap_or_default(),
                delegate: None,
                primary_key: PreviewerInscriptionKey::from(
                    x.clone(),
                    value
                        .protocol
                        .get(&ProtocolKey {
                            tx_index: x.tx_index,
                            inscription_number: x.number,
                        })
                        .cloned(),
                ),
            })
            .collect();

        Self {
            block_info: value.block_info,
            inscriptions,
            moved_valid_tokens: vec![],
        }
    }
}

impl PreviewerInscriptionKey {
    fn from(value: ElectrsInscription, protocol: Option<InscriptionProtocol>) -> Self {
        let mut hasher = sha2::Sha256::new();
        hasher.update(value.content.as_deref().unwrap_or_default());
        let content_hash = Hash256(hasher.finalize().into());

        let extension = value.content_type.unwrap_or_default().parse().unwrap_or(Extension::Other(Other::Bytes));

        Self {
            content_hash,
            extension,
            protocol,
            number: value.number.0,
        }
    }
}