miden-objects 0.17.0-rc.4

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
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

use alloc::vec::Vec;

use miden_protocol::Word;
use miden_protocol::account::{
    AccountStoragePatch,
    StorageMapPatch,
    StorageSlotName,
    StorageSlotPatch,
    StorageValuePatch,
};
use prost::Message;

use crate::decoded::account::test_utils::account_patch;
use crate::{DecodeMessage, Verify, proto};

#[test]
fn storage_map_patch_oneof_roundtrips_all_operations() {
    use miden_protocol::account::{StorageMapKey, StorageMapPatch, StorageMapPatchEntries};
    use prost::Message;

    let entries: StorageMapPatchEntries = [
        (StorageMapKey::from_raw(Word::from([1_u32, 0, 0, 0])), Word::empty()),
        (
            StorageMapKey::from_raw(Word::from([2_u32, 0, 0, 0])),
            Word::from([3_u32, 0, 0, 0]),
        ),
    ]
    .into_iter()
    .collect();
    for patch in [
        StorageMapPatch::Create { entries: StorageMapPatchEntries::new() },
        StorageMapPatch::Create { entries: entries.clone() },
        StorageMapPatch::Update { entries },
        StorageMapPatch::Remove,
    ] {
        let bytes = proto::account::StorageMapPatch::from(&patch).encode_to_vec();
        let wire = proto::account::StorageMapPatch::decode(bytes.as_slice()).unwrap();
        assert_eq!(wire.decode_fields().unwrap().verify().unwrap(), patch);
    }
}

#[test]
fn account_patch_roundtrips_through_explicit_versioned_protobuf_bytes() {
    let patch = account_patch();

    let encoded = proto::account::AccountPatch::from(&patch).encode_to_vec();
    let message = proto::account::AccountPatch::decode(encoded.as_slice()).unwrap();

    assert_eq!(message.version, proto::account::AccountPatchVersion::V1 as i32);
    assert_eq!(message.decode_fields().unwrap().verify().unwrap(), patch);
}

#[test]
fn account_storage_patch_protobuf_slots_follow_canonical_storage_order() {
    let storage_patch = AccountStoragePatch::from_entries([
        (StorageSlotName::mock(3), StorageSlotPatch::Value(StorageValuePatch::Remove)),
        (StorageSlotName::mock(1), StorageSlotPatch::Map(StorageMapPatch::Remove)),
        (StorageSlotName::mock(4), StorageSlotPatch::Value(StorageValuePatch::Remove)),
        (StorageSlotName::mock(2), StorageSlotPatch::Map(StorageMapPatch::Remove)),
    ])
    .unwrap();

    let expected_slots = [
        ("miden::test::slot::3", true),
        ("miden::test::slot::1", false),
        ("miden::test::slot::4", true),
        ("miden::test::slot::2", false),
    ];
    let message = proto::account::AccountStoragePatch::from(&storage_patch);

    assert_eq!(
        message
            .slots
            .iter()
            .map(|slot| {
                (
                    slot.slot_name.as_str(),
                    matches!(
                        slot.patch.as_ref(),
                        Some(proto::account::storage_slot_patch::Patch::Value(_))
                    ),
                )
            })
            .collect::<Vec<_>>(),
        expected_slots
    );
}

#[test]
fn storage_value_patch_oneof_roundtrips_all_operations() {
    use proto::account::storage_value_patch::Operation;

    for value in [Word::empty(), Word::from([1_u32, 2, 3, 4])] {
        for (patch, expected) in [
            (StorageValuePatch::Create { value }, Operation::Create(value.into())),
            (StorageValuePatch::Update { value }, Operation::Update(value.into())),
            (StorageValuePatch::Remove, Operation::Remove(())),
        ] {
            let message = proto::account::StorageValuePatch::from(&patch);
            assert_eq!(message.operation, Some(expected));
            let encoded = message.encode_to_vec();
            let decoded = proto::account::StorageValuePatch::decode(encoded.as_slice()).unwrap();
            assert_eq!(decoded.decode_fields().unwrap().verify().unwrap(), patch);
        }
    }
}

#[test]
fn storage_value_patch_nested_in_account_storage_patch_roundtrips() {
    let patch = AccountStoragePatch::from_entries([
        (
            StorageSlotName::mock(1),
            StorageSlotPatch::Value(StorageValuePatch::Create { value: Word::empty() }),
        ),
        (
            StorageSlotName::mock(2),
            StorageSlotPatch::Value(StorageValuePatch::Update {
                value: Word::from([1_u32, 0, 0, 0]),
            }),
        ),
        (StorageSlotName::mock(3), StorageSlotPatch::Value(StorageValuePatch::Remove)),
    ])
    .unwrap();
    let message = proto::account::AccountStoragePatch::from(&patch);
    let encoded = message.encode_to_vec();
    let decoded = proto::account::AccountStoragePatch::decode(encoded.as_slice()).unwrap();

    assert_eq!(decoded.decode_fields().unwrap().verify().unwrap(), patch);
}