feat: Introduce `ComponentPackage` and `ComponentTemplate` #1015

igamigo · 2024-12-11T21:47:36Z

Part of #550.
Introduces a first draft of ComponentPackage and ComponentTemplate.

For now it can serialize and deserialize configs such as this one:

name = "Test Component"
description = "This is a test component"
version = "1.0.0"
targets = ["FungibleFaucet"]

[[storage]]
name = "slot0"
description = "First slot"
slot = 0
value = "0x2551340000000000af02000000000000a3db000000000000ffeeff0f00000000"

[[storage]]
name = "multi"
description = "Multi slot entry"
slots = [1, 2, 3]
values = [["3428645", "687", "0xdba3", "0xfffeeff"], "0x2551340000000000af02000000000000a3db000000000000ffeeff0f00000000", "0x2551340000000000af02000000000000a3db000000000000ffeeff0f00000000"]

[[storage]]
name = "map"
slot = [4]
values = [{key="0x1", value="0x2"}]

Most structs down to the element need to have custom (de)serialization due to the different alternatives discussed in #550, but at least now it's easy if we want to add a new away of encoding things such as felts (for instance, if we want to allow for binary representation for elements).

Planned follow-ups:

Finish template matching ({{foo.bar.baz}}) for matching whole words or single elements

bobbinth

Looks good! Thank you! I left just a few comments inline.

bobbinth · 2024-12-13T08:02:11Z

objects/src/accounts/package/storage_entry/mod.rs

+///
+/// Each entry can describe:
+/// - A value slot (single word or multiple words).
+/// - A multi-slot entry (spanning multiple contiguous slots, with multipe values).


Should this point be about storage maps?

Added the storage map entries alongside its functionality

bobbinth · 2024-12-13T08:04:52Z

objects/src/accounts/package/storage_entry/mod.rs

+        /// The initial value for this slot.
+        value: WordRepresentation,


Should this be just Word? I guess the question is whether it makes sense to keep the original representation at this level as well. The alternative would be to convert WordRepresentation to Word when we go from RawStorageEntry to StorageEntry.

I debated this as well. I think the only real upside of keeping the representation is to be able to get the original representation when unpacking or inspecting packages. Whether this is valuable, I'm not sure. I think whether the value is defined as elements or as a binary number, for instance, could sometimes give some more semantic context to the entry itself, but obviously not sure it will be very useful versus just parsing as words and keeping that (probably less error prone as well, though this is easily tested).
I was thinking of adding some methods for more simply retrieving Word from each entry while keeping the original representation, but again maybe this is too much.

objects/src/accounts/package/mod.rs

bobbinth · 2024-12-26T09:28:56Z

objects/src/lib.rs

+    #[macro_export]
+    macro_rules! digest {
+        ($hex:expr) => {{
+            let felts: [$crate::Felt; 4] = match $crate::utils::parse_hex_string_as_word($hex) {


Question: how would this affect the ability to use the digest! macro from other crates?

tomyrd · 2024-12-26T17:28:38Z

objects/src/accounts/package/storage_entry/mod.rs

+        if slots.len() != values.len() {
+            return Err(ComponentMetadataError::InvalidMultiSlotEntry);
+        }
+
+        Ok(StorageEntry::MultiSlot {
+            name: name.into(),
+            description: description.map(Into::<String>::into),
+            slots,
+            values: values.into_iter().map(Into::into).collect(),
+        })


The description above says:

A multi-slot entry (spanning multiple contiguous slots, with multipe values).

Should we check that the slots are contiguous? (I know we also check it at the ComponentPackage level.

tomyrd · 2024-12-26T17:49:16Z

objects/src/accounts/package/storage_entry/mod.rs

+                if !slot_present {
+                    return Err(D::Error::missing_field("slot"));
+                }
+                if raw.value.is_some() {


nit: could we use value_present here?

tomyrd · 2024-12-26T18:00:09Z

objects/src/accounts/package/storage_entry/mod.rs

+                if slot_present {
+                    return Err(D::Error::custom(
+                        "Fields 'slot' and 'slots' are mutually exclusive.",
+                    ));
+                }
+                if value_present {
+                    return Err(D::Error::custom(
+                        "Fields 'value' and 'values' are mutually exclusive.",
+                    ));
+                }


These checks for mutual exclusivity can be done before the match to reduce code repetition

tomyrd · 2024-12-26T18:00:40Z

objects/src/accounts/package/storage_entry/mod.rs

+                    slot: raw.slot.expect("was checked to be present"),
+                    value: raw.value.expect("was checked to be present"),


instead of the if + expect we could do .ok_or(...)? here

tomyrd · 2024-12-26T18:10:42Z

objects/src/accounts/package/storage_entry/mod.rs

+                let slots = raw.slots.ok_or_else(|| D::Error::missing_field("slots"))?;
+                let values = raw.values.ok_or_else(|| D::Error::missing_field("values"))?;


If we change the match to be match (raw.slots, raw.values) we could deconstruct in the case to (Some(slots), Some(values)) and remove these ok_or_else.

tomyrd · 2024-12-26T18:30:56Z

objects/src/accounts/package/storage_entry/word.rs

+impl Default for WordRepresentation {
+    fn default() -> Self {
+        WordRepresentation::SingleHex(Default::default())
+    }
+}


Should this be in the previous section?

tomyrd · 2024-12-26T18:39:09Z

objects/src/lib.rs

+        }
+        // Enforce and skip the '0x' prefix.
+        let hex_bytes = match hex.as_bytes() {
+            [b'0', b'x', rest @ ..] => rest,


Should we allow for "0X" prefix like we do for Felts?

tomyrd · 2024-12-26T18:41:31Z

objects/src/lib.rs

-                // SAFETY: u8 cast to u64 is safe. We cannot use u64::from in const context so we
-                // are forced to cast.


We should add this safety comment back to the match case

igamigo force-pushed the igamigo-acc-pkg branch 2 times, most recently from 0cee24f to 123e92c Compare December 11, 2024 22:10

igamigo changed the title ~~feat: Introduce ComponentPackage~~ feat: Introduce ComponentPackage and ComponentConfig Dec 11, 2024

igamigo force-pushed the igamigo-acc-pkg branch from f12c492 to 1f66753 Compare December 12, 2024 21:39

igamigo changed the title ~~feat: Introduce ComponentPackage and ComponentConfig~~ feat: Introduce ComponentPackage and ComponentTemplate Dec 12, 2024

igamigo marked this pull request as ready for review December 12, 2024 21:55

bobbinth reviewed Dec 13, 2024

View reviewed changes

greenhat mentioned this pull request Dec 17, 2024

Implement the account storage API 0xPolygonMiden/compiler#340

Open

igamigo force-pushed the igamigo-acc-pkg branch 2 times, most recently from 266af8f to 34abed2 Compare December 17, 2024 20:34

feat: Introduce ComponentPackage and ComponentMetadata

9df6689

igamigo force-pushed the igamigo-acc-pkg branch from e5291d0 to 9df6689 Compare December 19, 2024 14:44

igamigo and others added 4 commits December 19, 2024 16:19

chore: Lints

975469f

refactor: New methods

a41bb4b

Merge branch 'next' into igamigo-acc-pkg

f23d572

fix build

cf05071

bobbinth reviewed Dec 26, 2024

View reviewed changes

tomyrd reviewed Dec 26, 2024

View reviewed changes

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

feat: Introduce `ComponentPackage` and `ComponentTemplate` #1015

feat: Introduce `ComponentPackage` and `ComponentTemplate` #1015

igamigo commented Dec 11, 2024 •

edited

Loading

bobbinth left a comment

bobbinth Dec 13, 2024

igamigo Dec 17, 2024

bobbinth Dec 13, 2024

igamigo Dec 13, 2024

bobbinth Dec 26, 2024

tomyrd Dec 26, 2024

tomyrd Dec 26, 2024

tomyrd Dec 26, 2024

tomyrd Dec 26, 2024

tomyrd Dec 26, 2024

tomyrd Dec 26, 2024

tomyrd Dec 26, 2024

tomyrd Dec 26, 2024

		/// The initial value for this slot.
		value: WordRepresentation,

		slot: raw.slot.expect("was checked to be present"),
		value: raw.value.expect("was checked to be present"),

		let slots = raw.slots.ok_or_else(\|\| D::Error::missing_field("slots"))?;
		let values = raw.values.ok_or_else(\|\| D::Error::missing_field("values"))?;

		// SAFETY: u8 cast to u64 is safe. We cannot use u64::from in const context so we
		// are forced to cast.

feat: Introduce ComponentPackage and ComponentTemplate #1015

Are you sure you want to change the base?

feat: Introduce ComponentPackage and ComponentTemplate #1015

Conversation

igamigo commented Dec 11, 2024 • edited Loading

bobbinth left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

feat: Introduce `ComponentPackage` and `ComponentTemplate` #1015

feat: Introduce `ComponentPackage` and `ComponentTemplate` #1015

igamigo commented Dec 11, 2024 •

edited

Loading