Struct scrypto::resource::resource_builder::InProgressResourceBuilder

pub struct InProgressResourceBuilder<T: AnyResourceType> {
    owner_role: OwnerRole,
    resource_type: T,
    resource_roles: T::ResourceRoles,
    metadata_config: Option<ModuleConfig<MetadataInit>>,
    address_reservation: Option<GlobalAddressReservation>,
}

Utility for setting up a new resource, which has building in progress.

• You start the building process with one of the methods starting with ResourceBuilder::new_.
• The allowed methods change depending on which methods have already been called. For example, you can either use owner_non_fungible_badge or set access rules individually, but not both.
• You can complete the building process using either create_with_no_initial_supply() or mint_initial_supply(..).

Example

use scrypto::prelude::*;

let bucket = ResourceBuilder::new_fungible(OwnerRole::None)
    .mint_initial_supply(5);

Fields

owner_role: OwnerRole

resource_type: T

resource_roles: T::ResourceRoles

metadata_config: Option<ModuleConfig<MetadataInit>>

address_reservation: Option<GlobalAddressReservation>

Implementations

impl<T: AnyResourceType> InProgressResourceBuilder<T>

pub fn new(owner_role: OwnerRole, resource_type: T) -> Self

impl<T: IsNonFungibleLocalId, D: NonFungibleData, S: ScryptoCategorize + ScryptoEncode + ScryptoDecode> InProgressResourceBuilder<NonFungibleResourceType<T, D, S>>

pub fn non_fungible_data_update_roles( self, non_fungible_data_update_roles: Option<NonFungibleDataUpdateRoles<RoleDefinition>> ) -> Self

Sets how each non-fungible’s mutable data can be updated.

• The first parameter is the access rule which allows updating the mutable data of each non-fungible.
• The second parameter is the mutability / access rule which controls if and how the access rule can be updated.

Examples

use radix_engine_interface::non_fungible_data_update_roles;
use scrypto::prelude::*;


#[derive(ScryptoSbor, NonFungibleData)]
struct NFData {
    pub name: String,
    #[mutable]
    pub flag: bool,
}
// Permits the updating of non-fungible mutable data with a proof of a specific resource, and this is locked forever.
ResourceBuilder::new_ruid_non_fungible::<NFData>(OwnerRole::None)
   .non_fungible_data_update_roles(non_fungible_data_update_roles! {
       non_fungible_data_updater => rule!(require(resource_address));
       non_fungible_data_updater_updater => rule!(deny_all);
   });

// Does not currently permit the updating of non-fungible mutable data, but this is can be changed in future by the second rule.
ResourceBuilder::new_ruid_non_fungible::<NFData>(OwnerRole::None)
   .non_fungible_data_update_roles(non_fungible_data_update_roles! {
       non_fungible_data_updater => rule!(deny_all);
       non_fungible_data_updater_updater => rule!(require(resource_address));
   });

impl InProgressResourceBuilder<FungibleResourceType>

pub fn divisibility(self, divisibility: u8) -> Self

Set the resource’s divisibility: the number of digits of precision after the decimal point in its balances.

• 0 means the resource is not divisible (balances are always whole numbers)
• 18 is the maximum divisibility, and the default.

Examples

use scrypto::prelude::*;

// Only permits whole-number balances.
ResourceBuilder::new_fungible(OwnerRole::None)
   .divisibility(0);

// Only permits balances to 3 decimal places.
ResourceBuilder::new_fungible(OwnerRole::None)
   .divisibility(3);

impl InProgressResourceBuilder<FungibleResourceType>

pub fn mint_initial_supply<T: Into<Decimal>>(self, amount: T) -> FungibleBucket

Creates resource with the given initial supply.

Example

use scrypto::prelude::*;

let bucket: FungibleBucket = ResourceBuilder::new_fungible(OwnerRole::None)
    .mint_initial_supply(5);

impl<D: NonFungibleData, S: ScryptoCategorize + ScryptoEncode + ScryptoDecode> InProgressResourceBuilder<NonFungibleResourceType<StringNonFungibleLocalId, D, S>>

pub fn mint_initial_supply<T>(self, entries: T) -> NonFungibleBucket

where T: IntoIterator<Item = (StringNonFungibleLocalId, D)>,

Creates the non-fungible resource, and mints an individual non-fungible for each key/data pair provided.

Example

use scrypto::prelude::*;

#[derive(ScryptoSbor, NonFungibleData)]
struct NFData {
    pub name: String,
    #[mutable]
    pub flag: bool,
}

let bucket: NonFungibleBucket = ResourceBuilder::new_string_non_fungible::<NFData>(OwnerRole::None)
    .mint_initial_supply([
        ("One".try_into().unwrap(), NFData { name: "NF One".to_owned(), flag: true }),
        ("Two".try_into().unwrap(), NFData { name: "NF Two".to_owned(), flag: true }),
    ]);

impl<D: NonFungibleData, S: ScryptoCategorize + ScryptoEncode + ScryptoDecode> InProgressResourceBuilder<NonFungibleResourceType<IntegerNonFungibleLocalId, D, S>>

pub fn mint_initial_supply<T>(self, entries: T) -> NonFungibleBucket

where T: IntoIterator<Item = (IntegerNonFungibleLocalId, D)>,

Creates the non-fungible resource, and mints an individual non-fungible for each key/data pair provided.

Example

use scrypto::prelude::*;

#[derive(ScryptoSbor, NonFungibleData)]
struct NFData {
    pub name: String,
    #[mutable]
    pub flag: bool,
}

let bucket: NonFungibleBucket = ResourceBuilder::new_integer_non_fungible(OwnerRole::None)
    .mint_initial_supply([
        (1u64.into(), NFData { name: "NF One".to_owned(), flag: true }),
        (2u64.into(), NFData { name: "NF Two".to_owned(), flag: true }),
    ]);

impl<D: NonFungibleData, S: ScryptoCategorize + ScryptoEncode + ScryptoDecode> InProgressResourceBuilder<NonFungibleResourceType<BytesNonFungibleLocalId, D, S>>

pub fn mint_initial_supply<T>(self, entries: T) -> NonFungibleBucket

where T: IntoIterator<Item = (BytesNonFungibleLocalId, D)>,

Creates the non-fungible resource, and mints an individual non-fungible for each key/data pair provided.

Example

use scrypto::prelude::*;

#[derive(ScryptoSbor, NonFungibleData)]
struct NFData {
    pub name: String,
    #[mutable]
    pub flag: bool,
}

let bucket: NonFungibleBucket = ResourceBuilder::new_bytes_non_fungible::<NFData>(OwnerRole::None)
    .mint_initial_supply([
        (vec![1u8].try_into().unwrap(), NFData { name: "NF One".to_owned(), flag: true }),
        (vec![2u8].try_into().unwrap(), NFData { name: "NF Two".to_owned(), flag: true }),
    ]);

impl<D: NonFungibleData, S: ScryptoCategorize + ScryptoEncode + ScryptoDecode> InProgressResourceBuilder<NonFungibleResourceType<RUIDNonFungibleLocalId, D, S>>

pub fn mint_initial_supply<T>(self, entries: T) -> NonFungibleBucket

where T: IntoIterator<Item = D>, D: ScryptoEncode,

Creates the RUID non-fungible resource, and mints an individual non-fungible for each piece of data provided.

The system automatically generates a new RUID NonFungibleLocalId for each non-fungible, and assigns the given data to each.

Example

use scrypto::prelude::*;

#[derive(ScryptoSbor, NonFungibleData)]
struct NFData {
    pub name: String,
    #[mutable]
    pub flag: bool,
}

let bucket: NonFungibleBucket = ResourceBuilder::new_ruid_non_fungible::<NFData>(OwnerRole::None)
    .mint_initial_supply([
        (NFData { name: "NF One".to_owned(), flag: true }),
        (NFData { name: "NF Two".to_owned(), flag: true }),
    ]);

Trait Implementations

impl CanCreateWithNoSupply for InProgressResourceBuilder<FungibleResourceType>

type NonFungibleDataSchema = ()

fn into_create_with_no_supply_invocation(self) -> CreateWithNoSupply<()>

impl<Y: IsNonFungibleLocalId, D: NonFungibleData, S: ScryptoCategorize + ScryptoEncode + ScryptoDecode> CanCreateWithNoSupply for InProgressResourceBuilder<NonFungibleResourceType<Y, D, S>>

type NonFungibleDataSchema = S

fn into_create_with_no_supply_invocation(self) -> CreateWithNoSupply<S>

impl<T: AnyResourceType> CanSetAddressReservation for InProgressResourceBuilder<T>

type OutputBuilder = InProgressResourceBuilder<T>

fn set_address( self, address_reservation: GlobalAddressReservation ) -> Self::OutputBuilder

impl<T: AnyResourceType> CanSetMetadata for InProgressResourceBuilder<T>

type OutputBuilder = InProgressResourceBuilder<T>

fn set_metadata( self, metadata: ModuleConfig<MetadataInit> ) -> Self::OutputBuilder

impl UpdateAuthBuilder for InProgressResourceBuilder<FungibleResourceType>

fn mint_roles(self, mint_roles: Option<MintRoles<RoleDefinition>>) -> Self

Sets the resource to be mintable

fn burn_roles(self, burn_roles: Option<BurnRoles<RoleDefinition>>) -> Self

Sets the resource to be burnable.

fn recall_roles(self, recall_roles: Option<RecallRoles<RoleDefinition>>) -> Self

Sets the resource to be recallable from vaults.

fn freeze_roles(self, freeze_roles: Option<FreezeRoles<RoleDefinition>>) -> Self

Sets the resource to have vaults be freezable.

fn withdraw_roles( self, withdraw_roles: Option<WithdrawRoles<RoleDefinition>> ) -> Self

Sets the role rules of withdrawing from a vault of this resource.

fn deposit_roles( self, deposit_roles: Option<DepositRoles<RoleDefinition>> ) -> Self

Sets the roles rules of depositing this resource into a vault.

impl<T: IsNonFungibleLocalId, D: NonFungibleData, S: ScryptoCategorize + ScryptoEncode + ScryptoDecode> UpdateAuthBuilder for InProgressResourceBuilder<NonFungibleResourceType<T, D, S>>

fn mint_roles(self, mint_roles: Option<MintRoles<RoleDefinition>>) -> Self

Sets the resource to be mintable

fn burn_roles(self, burn_roles: Option<BurnRoles<RoleDefinition>>) -> Self

Sets the resource to be burnable.

fn recall_roles(self, recall_roles: Option<RecallRoles<RoleDefinition>>) -> Self

Sets the resource to be recallable from vaults.

fn freeze_roles(self, freeze_roles: Option<FreezeRoles<RoleDefinition>>) -> Self

Sets the resource to have vaults be freezable.

fn withdraw_roles( self, withdraw_roles: Option<WithdrawRoles<RoleDefinition>> ) -> Self

Sets the role rules of withdrawing from a vault of this resource.

fn deposit_roles( self, deposit_roles: Option<DepositRoles<RoleDefinition>> ) -> Self

Sets the roles rules of depositing this resource into a vault.