Struct AccountComponentMetadata 

pub struct AccountComponentMetadata { /* private fields */ }

Represents the full component template configuration.

An account component metadata describes the component alongside its storage layout. On the storage layout, placeholders can be utilized to identify values that should be provided at the moment of instantiation.

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

Guarantees

• The metadata’s storage layout does not contain duplicate slots, and it always starts at slot index 0.
• Storage slots are laid out in a contiguous manner.
• Each placeholder represents a single value. The expected placeholders can be retrieved with AccountComponentMetadata::get_placeholder_requirements(), which returns a map from keys to PlaceholderTypeRequirement (which, in turn, indicates the expected value type for the placeholder).

Example

let first_felt = FeltRepresentation::from(Felt::new(0u64));
let second_felt = FeltRepresentation::from(Felt::new(1u64));
let third_felt = FeltRepresentation::from(Felt::new(2u64));
// Templated element:
let last_element =
    FeltRepresentation::new_template(TemplateType::new("felt")?, StorageValueName::new("foo")?);

let word_representation = WordRepresentation::new_value(
    [first_felt, second_felt, third_felt, last_element],
    Some(StorageValueName::new("test_value")?.into()),
)
.with_description("this is the first entry in the storage layout");
let storage_entry = StorageEntry::new_value(0, word_representation);

let init_storage_data =
    InitStorageData::new([(StorageValueName::new("test_value.foo")?, "300".to_string())]);

let component_template = AccountComponentMetadata::new(
    "test name".into(),
    "description of the component".into(),
    Version::parse("0.1.0")?,
    BTreeSet::new(),
    vec![storage_entry],
)?;

let library = Assembler::default().assemble_library([CODE]).unwrap();
let template = AccountComponentTemplate::new(component_template, library);

let component = AccountComponent::from_template(&template, &init_storage_data)?;

Implementations

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 template specifies storage slots with duplicates.
• If the template includes slot numbers that do not start at zero.
• If storage slots in the template are not contiguous.

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

Serializes the account component template into a TOML string.

impl AccountComponentMetadata

pub fn new( name: String, description: String, version: Version, targets: BTreeSet<AccountType>, storage: Vec<StorageEntry>, ) -> Result<Self, AccountComponentTemplateError>

Create a new AccountComponentMetadata.

Errors

• If the specified storage slots contain duplicates.
• If the slot numbers do not start at zero.
• If the slots are not contiguous.

pub fn get_placeholder_requirements( &self, ) -> BTreeMap<StorageValueName, PlaceholderTypeRequirement>

Retrieves a map of unique storage placeholder names mapped to their expected type that require a value at the moment of component instantiation.

These values will be used for initializing storage slot values, or storage map entries. For a full example on how a placeholder may be utilized, please refer to the docs for AccountComponentMetadata.

Types for the returned storage placeholders are inferred based on their location in the storage layout structure.

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_entries(&self) -> &Vec<StorageEntry>

Returns the list of storage entries of the component.

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 Eq for AccountComponentMetadata

impl StructuralPartialEq for AccountComponentMetadata