miden-objects 0.17.0-rc.5

Canonical Protobuf representations for Miden protocol objects
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

use alloc::string::ToString;
use alloc::vec;

use miden_protocol::Word;

use crate::{DecodeMessage, Verify, proto};

#[test]
fn storage_slot_id_verifies() {
    let decoded = proto::account::StorageSlotId {
        suffix: Some(miden_protocol::Felt::ONE.into()),
        prefix: Some(miden_protocol::Felt::ZERO.into()),
    }
    .decode_fields()
    .unwrap();
    assert_eq!(decoded.verify().unwrap().suffix(), miden_protocol::Felt::ONE);
}

#[test]
fn storage_map_entry_verifies() {
    let decoded = proto::account::StorageMapEntry {
        key: Some(Word::empty().into()),
        value: Some(Word::empty().into()),
    }
    .decode_fields()
    .unwrap();
    assert_eq!(decoded.verify().unwrap().1, Word::empty());
}

#[test]
fn storage_slot_defers_name_validation() {
    let wire = proto::account::account_storage_header::StorageSlot {
        slot_name: "".into(),
        content: Some(proto::account::account_storage_header::storage_slot::Content::MapRoot(
            Word::empty().into(),
        )),
    };
    let decoded = wire.decode_fields().unwrap();
    assert!(matches!(
        decoded.verify(),
        Err(miden_protocol::errors::StorageSlotNameError::TooShort)
    ));
}

#[test]
fn storage_header_defers_duplicate_validation() {
    let slot = proto::account::account_storage_header::StorageSlot {
        slot_name: miden_protocol::account::StorageSlotName::mock(1).as_str().into(),
        content: Some(proto::account::account_storage_header::storage_slot::Content::Value(
            Word::empty().into(),
        )),
    };
    let decoded = proto::account::AccountStorageHeader { slots: vec![slot.clone(), slot] }
        .decode_fields()
        .unwrap();
    assert!(decoded.verify().is_err());
}

#[test]
fn storage_header_verification_reports_the_invalid_slot_index() {
    let slot = proto::account::account_storage_header::StorageSlot {
        slot_name: miden_protocol::account::StorageSlotName::mock(1).as_str().into(),
        content: Some(proto::account::account_storage_header::storage_slot::Content::Value(
            Word::empty().into(),
        )),
    };
    let invalid = proto::account::account_storage_header::StorageSlot {
        slot_name: "".into(),
        ..slot.clone()
    };
    let error = proto::account::AccountStorageHeader { slots: vec![slot, invalid] }
        .decode_fields()
        .unwrap()
        .verify()
        .unwrap_err();

    assert!(error.to_string().starts_with("slots[1]:"), "{error}");
    assert!(matches!(
        crate::test_utils::error_source::<miden_protocol::errors::StorageSlotNameError>(&error),
        Some(miden_protocol::errors::StorageSlotNameError::TooShort)
    ));
}