Struct Package 

pub struct Package {
    pub name: PackageId,
    pub version: Version,
    pub description: Option<String>,
    pub kind: TargetType,
    pub mast: Arc<Library>,
    pub manifest: PackageManifest,
    pub sections: Vec<Section>,
}

A package is a assembled artifact containing:

• Basic metadata like name, description, and semantic version
• The type of target the package represents, e.g. a library or executable
• The assembled miden_core::mast::MastForest for that target
• A manifest describing the exported contents of the package, and its runtime dependencies.
• One or more custom sections containing metadata produced by the assembler or other tools which applies to the package, e.g. debug symbols.

Fields

name: PackageId

Name of the package

version: Version

An optional semantic version for the package

description: Option<String>

An optional description of the package

kind: TargetType

The project target type which produced this package

mast: Arc<Library>

The underlying Library of this package

NOTE: This will change to MastForest soon. We are currently using Library because we have not yet fully removed the usage of Library throughout the assembler, so it is more convenient to use. However, this can change at any time, so you should avoid accessing this field directly unless you absolutely need to and can handle potential breakage.

manifest: PackageManifest

The package manifest, containing the set of exported procedures and their signatures, if known.

sections: Vec<Section>

The set of custom sections included with the package, e.g. debug information, account metadata, etc.

Implementations

impl Package

Construction

pub fn from_library( name: PackageId, version: Version, kind: TargetType, library: Arc<Library>, dependencies: impl IntoIterator<Item = Dependency>, ) -> Box<Package>

Construct a Package from a Library by providing the necessary metadata.

impl Package

Accessors

pub const EXTENSION: &'static str = "masp"

The file extension given to serialized packages

pub fn digest(&self) -> Word

Returns the digest of the package’s MAST artifact

pub fn is_program(&self) -> bool

Returns true if this package was produced for an executable target

pub fn is_library(&self) -> bool

Returns true if this package was produced for a library or kernel target

pub fn is_kernel(&self) -> bool

Returns true if this package was produced specifically for a kernel target

pub fn kernel_module_info(&self) -> Result<ModuleInfo, Report>

Get the ModuleInfo corresponding to the kernel module, if this package contains the kernel

pub fn to_kernel(&self) -> Result<Kernel, Report>

Get a Kernel from this package, if this package contains one.

pub fn try_into_kernel_library(&self) -> Result<KernelLibrary, Report>

Converts this package into a KernelLibrary if it is marked as a kernel package.

pub fn to_dependency(&self) -> Dependency

pub fn kernel_runtime_dependency(&self) -> Result<Option<&Dependency>, Report>

If this package depends on a kernel, this method extracts the Dependency corresponding to it.

Returns Err if the dependency metadata for this package contains multiple kernels.

pub fn make_executable( &self, entrypoint: &QualifiedProcedureName, ) -> Result<Package, Report>

Derive a new executable package from this one by specifying the entrypoint to use.

To succeed, the following must be true:

• This package was produced from a library target
• The entrypoint procedure is exported from this package according to the manifest
• The entrypoint procedure can be resolved to a node in the MAST of this package

The resulting package has a target type and manifest reflecting what would have been used if the package was originally assembled as an executable, however the underlying miden_core::mast::MastForest is left untouched, so the resulting package may still contain nodes in the forest which are now unused.

pub fn procedure_name(&self, digest: &Word) -> Option<&str>

Returns the procedure name for the given MAST root digest, if present.

This allows debuggers to resolve human-readable procedure names during execution.

pub fn procedure_names(&self) -> impl Iterator<Item = (Word, &Arc<str>)>

Returns an iterator over all (digest, name) pairs of procedure names.

pub fn write_to_file(&self, path: impl AsRef<Path>) -> Result<(), Error>

Write this package to path

pub fn write_masp_file(&self, dir: impl AsRef<Path>) -> Result<(), Error>

Write this package to a file in dir named $name.masp, where $name is the package name.

Trait Implementations

impl Clone for Package

fn clone(&self) -> Package

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Package

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

Formats the value using the given formatter.

impl Deserializable for Package

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

where R: ByteReader,

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

fn min_serialized_size() -> usize

Returns the minimum serialized size for one instance of this type.

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

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

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

Deserializes Self from bytes with a byte budget limit.

impl<'de> Deserialize<'de> for Package

fn deserialize<__D>( __deserializer: __D, ) -> Result<Package, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Package

fn eq(&self, other: &Package) -> 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 Package

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

where W: ByteWriter,

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 Package

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::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 Package

impl StructuralPartialEq for Package