rain_metadata/
metaboard.rs

1use alloy::primitives::{Bytes, FixedBytes, hex};
2use alloy::sol_types::SolCall;
3use rain_metadata_bindings::MetaBoard::emitMetaCall;
4use serde::Serialize;
5
6use crate::{Error, RainMetaDocumentV1Item};
7use crate::meta::types::dotrain::source_v1::DotrainSourceV1;
8
9/// Generate calldata for MetaBoard.emitMeta() function using raw bytes
10fn generate_emit_data_calldata(subject: FixedBytes<32>, data: Vec<u8>) -> Vec<u8> {
11    let call = emitMetaCall {
12        subject,
13        meta: Bytes::from(data),
14    };
15    call.abi_encode()
16}
17
18/// Generate calldata for MetaBoard.emitMeta() function from any RainMetaDocumentV1Item
19pub fn generate_emit_meta_calldata(meta: RainMetaDocumentV1Item) -> Result<Vec<u8>, Error> {
20    let meta_bytes = meta.cbor_encode()?;
21    let hash = meta.hash(false)?;
22    Ok(generate_emit_data_calldata(hash.into(), meta_bytes))
23}
24
25/// Deployment data for publishing to MetaBoard
26#[derive(Debug, Clone, Serialize, serde::Deserialize)]
27pub struct DotrainSourceEmitData {
28    /// Keccak256 hash of the content (hex-encoded with 0x prefix)
29    pub subject: String,
30    /// CBOR-encoded metadata bytes (hex-encoded with 0x prefix)
31    pub meta_bytes: String,
32    /// Complete calldata for MetaBoard.emitMeta() (hex-encoded with 0x prefix)
33    pub calldata: String,
34}
35
36/// Validate dotrain content - currently only checks for non-empty content
37fn validate_dotrain_content(content: &str) -> Result<(), Error> {
38    // Reject empty or whitespace-only content
39    if content.trim().is_empty() {
40        return Err(Error::InvalidInput(
41            "Dotrain content cannot be empty".to_string(),
42        ));
43    }
44    Ok(())
45}
46
47/// Generate tx data for DotrainSourceV1 content
48/// Validates content and returns subject hash, meta bytes, and calldata
49pub fn generate_dotrain_source_emit_tx_data(content: &str) -> Result<DotrainSourceEmitData, Error> {
50    // Validate content
51    validate_dotrain_content(content)?;
52
53    // Create DotrainSourceV1
54    let dotrain_source = DotrainSourceV1(content.to_string());
55    // Convert to RainMetaDocumentV1Item
56    let document: RainMetaDocumentV1Item = dotrain_source.into();
57
58    // Hash before moving the document into the sequence to avoid cloning.
59    // Calculate subject hash
60    let subject_hash = document.hash(false)?;
61    let documents = vec![document];
62
63    // Generate CBOR bytes
64    let meta_bytes =
65        RainMetaDocumentV1Item::cbor_encode_seq(&documents, crate::KnownMagic::RainMetaDocumentV1)?;
66
67    // Prepare hex-encoded meta first to avoid cloning later
68    let meta_bytes_hex = hex::encode_prefixed(&meta_bytes);
69    // Generate calldata
70    let calldata = generate_emit_data_calldata(subject_hash.into(), meta_bytes);
71
72    Ok(DotrainSourceEmitData {
73        subject: hex::encode_prefixed(subject_hash),
74        meta_bytes: meta_bytes_hex,
75        calldata: hex::encode_prefixed(calldata),
76    })
77}
78
79#[cfg(test)]
80mod tests {
81    use super::*;
82    use crate::meta::{ContentEncoding, ContentLanguage, ContentType, KnownMagic};
83
84    fn create_test_meta(content: &str) -> RainMetaDocumentV1Item {
85        RainMetaDocumentV1Item {
86            payload: serde_bytes::ByteBuf::from(content),
87            magic: KnownMagic::DotrainSourceV1,
88            content_type: ContentType::OctetStream,
89            content_encoding: ContentEncoding::None,
90            content_language: ContentLanguage::None,
91        }
92    }
93
94    #[test]
95    fn test_generate_emit_meta_calldata_success() {
96        let meta = create_test_meta("test content");
97        let calldata = generate_emit_meta_calldata(meta.clone()).unwrap();
98
99        // Verify calldata is not empty
100        assert!(!calldata.is_empty());
101
102        // Decode and verify structure
103        let decoded = emitMetaCall::abi_decode(&calldata).unwrap();
104        let expected_hash = meta.hash(false).unwrap();
105        let expected_meta_bytes = meta.cbor_encode().unwrap();
106
107        assert_eq!(decoded.subject, FixedBytes::from(expected_hash));
108        assert_eq!(decoded.meta.as_ref(), expected_meta_bytes.as_slice());
109    }
110
111    #[test]
112    fn test_validate_dotrain_content() {
113        // Valid content
114        assert!(validate_dotrain_content("#main _ _: int-add(1 2)").is_ok());
115        assert!(validate_dotrain_content("/* comment */\n#main _ _: 1").is_ok());
116
117        // Invalid content
118        assert!(validate_dotrain_content("").is_err());
119        assert!(validate_dotrain_content("   ").is_err());
120        assert!(validate_dotrain_content("\n\t\r").is_err());
121    }
122
123    #[test]
124    fn test_generate_dotrain_source_emit_tx_data_success() {
125        let content = "#main _ _: int-add(1 2) int-add(2 3)";
126        let deployment = generate_dotrain_source_emit_tx_data(content).unwrap();
127
128        // Check all fields have 0x prefix
129        assert!(deployment.subject.starts_with("0x"));
130        assert!(deployment.meta_bytes.starts_with("0x"));
131        assert!(deployment.calldata.starts_with("0x"));
132
133        // Check lengths are reasonable
134        assert_eq!(deployment.subject.len(), 66); // 0x + 64 hex chars
135        assert!(deployment.meta_bytes.len() > 10); // Should have some content
136        assert!(deployment.calldata.len() > 10); // Should have some content
137
138        // Optional: verify subject in calldata matches the declared subject
139        let calldata_bytes =
140            alloy::hex::decode(deployment.calldata.trim_start_matches("0x")).unwrap();
141        let decoded = emitMetaCall::abi_decode(&calldata_bytes).unwrap();
142        let subject_hex = deployment.subject.to_lowercase();
143        assert_eq!(hex::encode_prefixed(decoded.subject), subject_hex);
144
145        // meta in calldata must equal the meta_bytes field
146        let meta_bytes_from_field =
147            alloy::hex::decode(deployment.meta_bytes.trim_start_matches("0x")).unwrap();
148        assert_eq!(decoded.meta.as_ref(), meta_bytes_from_field.as_slice());
149    }
150
151    #[test]
152    fn test_generate_dotrain_source_emit_tx_data_empty_content() {
153        let result = generate_dotrain_source_emit_tx_data("");
154        assert!(result.is_err());
155
156        let result = generate_dotrain_source_emit_tx_data("   ");
157        assert!(result.is_err());
158    }
159
160    #[test]
161    fn test_cas_property_same_content() {
162        // Content Addressable Storage: same content -> same calldata
163        let meta1 = create_test_meta("identical content");
164        let meta2 = create_test_meta("identical content");
165
166        let calldata1 = generate_emit_meta_calldata(meta1).unwrap();
167        let calldata2 = generate_emit_meta_calldata(meta2).unwrap();
168
169        // Same content should produce identical calldata
170        assert_eq!(calldata1, calldata2);
171    }
172
173    #[test]
174    fn test_cas_property_different_content() {
175        let meta1 = create_test_meta("content A");
176        let meta2 = create_test_meta("content B");
177
178        let calldata1 = generate_emit_meta_calldata(meta1).unwrap();
179        let calldata2 = generate_emit_meta_calldata(meta2).unwrap();
180
181        // Different content should produce different calldata
182        assert_ne!(calldata1, calldata2);
183
184        // Verify different subjects
185        let decoded1 = emitMetaCall::abi_decode(&calldata1).unwrap();
186        let decoded2 = emitMetaCall::abi_decode(&calldata2).unwrap();
187        assert_ne!(decoded1.subject, decoded2.subject);
188    }
189
190    #[test]
191    fn test_different_magic_same_content() {
192        let meta1 = create_test_meta("same content");
193        let mut meta2 = create_test_meta("same content");
194        meta2.magic = KnownMagic::AuthoringMetaV1; // Different magic
195
196        let calldata1 = generate_emit_meta_calldata(meta1).unwrap();
197        let calldata2 = generate_emit_meta_calldata(meta2).unwrap();
198
199        // Different magic should produce different calldata (even with same payload)
200        assert_ne!(calldata1, calldata2);
201    }
202
203    #[test]
204    fn test_hash_deterministic() {
205        let meta = create_test_meta("test for deterministic hash");
206
207        // Generate calldata multiple times
208        let calldata1 = generate_emit_meta_calldata(meta.clone()).unwrap();
209        let calldata2 = generate_emit_meta_calldata(meta.clone()).unwrap();
210        let calldata3 = generate_emit_meta_calldata(meta).unwrap();
211
212        // All should be identical (deterministic hashing)
213        assert_eq!(calldata1, calldata2);
214        assert_eq!(calldata2, calldata3);
215    }
216
217    #[test]
218    fn test_subject_matches_document_hash() {
219        let meta = create_test_meta("content for hash verification");
220        let expected_hash = meta.hash(false).unwrap();
221
222        let calldata = generate_emit_meta_calldata(meta).unwrap();
223        let decoded = emitMetaCall::abi_decode(&calldata).unwrap();
224
225        // Subject in calldata should match document's own hash
226        assert_eq!(decoded.subject, FixedBytes::from(expected_hash));
227    }
228}
rain_metadata/metaboard.rs

rain_metadata/
metaboard.rs
