Struct AccountComponentMetadata 

pub struct AccountComponentMetadata { /* private fields */ }

Represents the full component metadata configuration.

An account component metadata describes the component alongside its storage layout. The storage layout can declare typed values which must be provided at instantiation time via InitStorageData. These can appear either at the slot level (a singular word slot) or inside composed words as typed fields.

When the std feature is enabled, this struct allows for serialization and deserialization to and from a TOML file.

Guarantees

• The metadata’s storage schema does not contain duplicate slot names.
• The schema cannot contain protocol-reserved slot names.
• Each init-time value name uniquely identifies a single value. The expected init-time metadata can be retrieved with AccountComponentMetadata::schema_requirements(), which returns a map from keys to SchemaRequirement (which indicates the expected value type and optional defaults).

Example

use std::collections::{BTreeMap, BTreeSet};

use miden_protocol::account::StorageSlotName;
use miden_protocol::account::component::{
    AccountComponentMetadata,
    FeltSchema,
    InitStorageData,
    SchemaTypeId,
    StorageSchema,
    StorageSlotSchema,
    StorageValueName,
    ValueSlotSchema,
    WordSchema,
    WordValue,
};
use semver::Version;

let slot_name = StorageSlotName::new("demo::test_value")?;

let word = WordSchema::new_value([
    FeltSchema::new_void(),
    FeltSchema::new_void(),
    FeltSchema::new_void(),
    FeltSchema::new_typed(SchemaTypeId::native_felt(), "foo"),
]);

let storage_schema = StorageSchema::new([(
    slot_name.clone(),
    StorageSlotSchema::Value(ValueSlotSchema::new(Some("demo slot".into()), word)),
)])?;

let metadata = AccountComponentMetadata::new(
    "test name".into(),
    "description of the component".into(),
    Version::parse("0.1.0")?,
    BTreeSet::new(),
    storage_schema,
);

// Init value keys are derived from slot name: `demo::test_value.foo`.
let value_name = StorageValueName::from_slot_name_with_suffix(&slot_name, "foo")?;
let mut init_storage_data = InitStorageData::default();
init_storage_data.set_value(value_name, WordValue::Atomic("300".into()))?;

let storage_slots = metadata.storage_schema().build_storage_slots(&init_storage_data)?;
assert_eq!(storage_slots.len(), 1);

Implementations

impl AccountComponentMetadata

pub fn new( name: String, description: String, version: Version, targets: BTreeSet<AccountType>, storage_schema: StorageSchema, ) -> Self

Create a new AccountComponentMetadata.

pub fn schema_requirements( &self, ) -> BTreeMap<StorageValueName, SchemaRequirement>

Returns the init-time values requirements for this schema.

These values are used for initializing storage slot values or storage map entries. For a full example, refer to the docs for AccountComponentMetadata.

Types for returned init values are inferred based on their location in the storage layout.

pub fn name(&self) -> &str

Returns the name of the account component.

pub fn description(&self) -> &str

Returns the description of the account component.

pub fn version(&self) -> &Version

Returns the semantic version of the account component.

pub fn supported_types(&self) -> &BTreeSet<AccountType>

Returns the account types supported by the component.

pub fn storage_schema(&self) -> &StorageSchema

Returns the storage schema of the component.

impl AccountComponentMetadata

pub fn from_toml( toml_string: &str, ) -> Result<Self, AccountComponentTemplateError>

Deserializes toml_string and validates the resulting AccountComponentMetadata

Errors

• If deserialization fails
• If the schema specifies storage slots with duplicates.
• If the schema contains invalid slot definitions.

pub fn to_toml(&self) -> Result<String, AccountComponentTemplateError>

Serializes the account component metadata into a TOML string.

Trait Implementations

impl Clone for AccountComponentMetadata

fn clone(&self) -> AccountComponentMetadata

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AccountComponentMetadata

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Deserializable for AccountComponentMetadata

fn read_from<R: ByteReader>( source: &mut R, ) -> Result<Self, DeserializationError>

Reads a sequence of bytes from the provided source, attempts to deserialize these bytes into Self, and returns the result.

fn read_from_bytes(bytes: &[u8]) -> Result<Self, DeserializationError>

Attempts to deserialize the provided bytes into Self and returns the result.

impl<'de> Deserialize<'de> for AccountComponentMetadata

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for AccountComponentMetadata

fn eq(&self, other: &AccountComponentMetadata) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serializable for AccountComponentMetadata

fn write_into<W: ByteWriter>(&self, target: &mut W)

Serializes self into bytes and writes these bytes into the target.

fn to_bytes(&self) -> Vec<u8>

Serializes self into a vector of bytes.

fn get_size_hint(&self) -> usize

Returns an estimate of how many bytes are needed to represent self.

impl Serialize for AccountComponentMetadata

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&Package> for AccountComponentMetadata

type Error = AccountError

The type returned in the event of a conversion error.

fn try_from(package: &Package) -> Result<Self, Self::Error>

Performs the conversion.

impl Eq for AccountComponentMetadata

impl StructuralPartialEq for AccountComponentMetadata