Struct InProgressResourceBuilder

pub struct InProgressResourceBuilder<T: AnyResourceType> { /* private fields */ }

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);

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 create_with_no_initial_supply(self) -> FungibleResourceManager

Creates the fungible resource with no initial supply.

The fungible resource’s manager is returned. It is easily convertible to generic resource manager. One just can use .into() method.

Example

let resource_manager = ResourceBuilder::new_fungible(OwnerRole::None)
    .mint_roles(mint_roles! {
        minter => rule!(deny_all);
        minter_updater => rule!(deny_all);
    })
    .metadata(metadata! {
        init {
            "name" => "Super Admin Badge", locked;
        }
    })
    .with_address(address_reservation)
    .create_with_no_initial_supply();

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

pub fn create_with_no_initial_supply(self) -> NonFungibleResourceManager

Creates the non-fungible resource with no initial supply.

The non-fungible resource’s manager is returned. It is easily convertible to the generic resource manager. One just can use .into() method.

Example

#[derive(ScryptoSbor, NonFungibleData)]
struct Sandwich {
    name: String,
    with_ham: bool,
}

let resource_manager: ResourceManager =
    ResourceBuilder::new_ruid_non_fungible::<Sandwich>(OwnerRole::None)
        .mint_roles(mint_roles! {
            minter => rule!(allow_all);
            minter_updater => rule!(deny_all);
        })
        .create_with_no_initial_supply()
        .into();

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

// 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 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.