Component

Introduction

A component is a runtime instance of a blueprint, with its own persistent state, its own globally-addressable identity, and its own configured access rules. If a blueprint is the class, a component is the instance. Components own vaults, expose methods callable from manifests or other components, and emit events. Their state lives as engine substates, which is how composability and atomic cross-component calls remain safe.

Owned and global components

Instantiating a blueprint does not by itself produce something the rest of the network can call. In Scrypto, ComponentState::instantiate calls the engine's object_new and returns an Owned<C>: a real object holding the blueprint's state fields, but with no address of its own, reachable only through whatever holds it. That makes owned components an internal building block. A component can keep other components inside its own state the same way it keeps vaults.

Publishing one is a separate, explicit step: prepare_to_globalize(owner_role) returns a builder, and globalize() calls object_globalize, which assigns a global address and returns Global<C>. The two states are legible in the address itself. A globalized generic component is addressed component_rdx1… on mainnet, while an owned one carries the internal_component_rdx1… prefix, so an address tells you whether the thing behind it can be called directly or only through its owner.

A component can also be globalized at an address reserved in advance, by passing a GlobalAddressReservation to with_address. That is how a blueprint can name its own future address while it is still being instantiated, which the access rules of self-referencing designs depend on.

What globalization attaches

Globalization is also where a component acquires the parts that are not its own code. globalize() assembles up to three attached modules before it hands the object to the engine:

• Role assignment, always. It carries the owner role supplied at prepare_to_globalize plus the role assignments for the component's own methods and for the other modules. This is the object the role assignment module describes, and it is what turns a blueprint's declared method accessibility into concrete authorization at instantiation time.
• Metadata, always. If the developer configured none, an empty default is attached rather than none at all, so every global component has a metadata module for names, icons, tags and the verification pointers wallets and explorers read.
• Royalties, only on request. enable_component_royalties records an amount per method, each stored together with whether it is locked against later change, and without that call no royalty module is attached at all.

The consequence is that the interesting properties of a component are fixed at the moment it goes global, not when its blueprint is published: the same blueprint can produce one component whose methods are open and free and another, from the same code, that is owner-gated and charges a royalty on every call.

External Links

• Component model in scrypto
• Radix Docs: Components
• scrypto/src/component/component.rs (instantiation, globalization and the attached modules)
• Radix Docs: Component Ownership
• Radix Docs: Address types and prefixes