dpp::data_contract::associated_token::token_configuration::v0

Struct TokenConfigurationV0

pub struct TokenConfigurationV0 {Show 19 fields
    pub conventions: TokenConfigurationConvention,
    pub conventions_change_rules: ChangeControlRules,
    pub base_supply: TokenAmount,
    pub max_supply: Option<TokenAmount>,
    pub keeps_history: TokenKeepsHistoryRules,
    pub start_as_paused: bool,
    pub allow_transfer_to_frozen_balance: bool,
    pub max_supply_change_rules: ChangeControlRules,
    pub distribution_rules: TokenDistributionRules,
    pub marketplace_rules: TokenMarketplaceRules,
    pub manual_minting_rules: ChangeControlRules,
    pub manual_burning_rules: ChangeControlRules,
    pub freeze_rules: ChangeControlRules,
    pub unfreeze_rules: ChangeControlRules,
    pub destroy_frozen_funds_rules: ChangeControlRules,
    pub emergency_action_rules: ChangeControlRules,
    pub main_control_group: Option<GroupContractPosition>,
    pub main_control_group_can_be_modified: AuthorizedActionTakers,
    pub description: Option<String>,
}

Expand description

Defines the complete configuration for a version 0 token contract.

TokenConfigurationV0 encapsulates all metadata, control rules, supply settings, and governance constraints used to initialize and manage a token instance on Platform. This structure serves as the core representation of a token’s logic, permissions, and capabilities.

This configuration is designed to be deterministic and versioned for compatibility across protocol upgrades and validation environments.

Fields§

§conventions: TokenConfigurationConvention

Metadata conventions, including decimals and localizations.

§conventions_change_rules: ChangeControlRules

Change control rules governing who can modify the conventions field.

§base_supply: TokenAmount

The initial token supply minted at creation.

§max_supply: Option<TokenAmount>

The maximum allowable supply of the token.

If None, the supply is unbounded unless otherwise constrained by minting logic.

§keeps_history: TokenKeepsHistoryRules

Configuration governing which historical actions are recorded for this token.

§start_as_paused: bool

Indicates whether the token should start in a paused state.

When true, transfers are disallowed until explicitly unpaused via an emergency action.

§allow_transfer_to_frozen_balance: bool

Allows minting and transferring to frozen token balances if enabled.

§max_supply_change_rules: ChangeControlRules

Change control rules for updating the max_supply.

Note: The max_supply can never be reduced below the base_supply.

§distribution_rules: TokenDistributionRules

Defines the token’s distribution logic, including perpetual and pre-programmed distributions.

§marketplace_rules: TokenMarketplaceRules

Defines the token’s marketplace logic.

§manual_minting_rules: ChangeControlRules

Rules controlling who is authorized to perform manual minting of tokens.

§manual_burning_rules: ChangeControlRules

Rules controlling who is authorized to perform manual burning of tokens.

§freeze_rules: ChangeControlRules

Rules governing who may freeze token balances.

§unfreeze_rules: ChangeControlRules

Rules governing who may unfreeze token balances.

§destroy_frozen_funds_rules: ChangeControlRules

Rules governing who may destroy frozen funds.

§emergency_action_rules: ChangeControlRules

Rules governing who may invoke emergency actions, such as pausing transfers.

§main_control_group: Option<GroupContractPosition>

Optional reference to the group assigned as the token’s main control group.

§main_control_group_can_be_modified: AuthorizedActionTakers

Defines whether and how the main control group assignment may be modified.

§description: Option<String>

Optional textual description of the token’s purpose, behavior, or metadata.

Struct TokenConfigurationV0 Copy item path

Fields§

Implementations§

impl TokenConfigurationV0

pub fn apply_token_configuration_item( &mut self, change_item: TokenConfigurationChangeItem, )

§Parameters

impl TokenConfigurationV0

pub fn authorized_action_takers_for_configuration_item( &self, change_item: &TokenConfigurationChangeItem, ) -> AuthorizedActionTakers

§Parameters

§Returns

impl TokenConfigurationV0

pub fn can_apply_token_configuration_item( &self, change_item: &TokenConfigurationChangeItem, contract_owner_id: &Identifier, main_group: Option<GroupContractPosition>, groups: &BTreeMap<GroupContractPosition, Group>, action_taker: &ActionTaker, goal: ActionGoal, ) -> bool

§Parameters

impl TokenConfigurationV0

pub fn default_most_restrictive() -> Self

pub fn with_base_supply(self, base_supply: TokenAmount) -> Self

Trait Implementations§

impl<'__de, __Context> BorrowDecode<'__de, __Context> for TokenConfigurationV0

fn borrow_decode<__D: BorrowDecoder<'__de, Context = __Context>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

impl Clone for TokenConfigurationV0

fn clone(&self) -> TokenConfigurationV0

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

impl Debug for TokenConfigurationV0

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

impl<__Context> Decode<__Context> for TokenConfigurationV0

fn decode<__D: Decoder<Context = __Context>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

impl<'de> Deserialize<'de> for TokenConfigurationV0

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

impl Display for TokenConfigurationV0

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

impl Encode for TokenConfigurationV0

fn encode<__E: Encoder>(&self, encoder: &mut __E) -> Result<(), EncodeError>

impl From<TokenConfigurationV0> for TokenConfiguration

fn from(value: TokenConfigurationV0) -> Self

impl PartialEq for TokenConfigurationV0

fn eq(&self, other: &TokenConfigurationV0) -> bool

fn ne(&self, other: &Rhs) -> bool

impl Serialize for TokenConfigurationV0

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

impl TokenConfigurationV0Getters for TokenConfigurationV0

fn conventions(&self) -> &TokenConfigurationConvention

fn conventions_mut(&mut self) -> &mut TokenConfigurationConvention

fn conventions_change_rules(&self) -> &ChangeControlRules

fn base_supply(&self) -> TokenAmount

fn keeps_history(&self) -> &TokenKeepsHistoryRules

fn keeps_history_mut(&mut self) -> &mut TokenKeepsHistoryRules

fn start_as_paused(&self) -> bool

fn is_allowed_transfer_to_frozen_balance(&self) -> bool

fn max_supply(&self) -> Option<TokenAmount>

fn max_supply_change_rules(&self) -> &ChangeControlRules

fn manual_minting_rules(&self) -> &ChangeControlRules

fn manual_burning_rules(&self) -> &ChangeControlRules

fn freeze_rules(&self) -> &ChangeControlRules

fn unfreeze_rules(&self) -> &ChangeControlRules

fn destroy_frozen_funds_rules(&self) -> &ChangeControlRules

fn emergency_action_rules(&self) -> &ChangeControlRules

fn main_control_group(&self) -> Option<GroupContractPosition>

fn main_control_group_can_be_modified(&self) -> &AuthorizedActionTakers

fn all_used_group_positions(&self) -> (BTreeSet<GroupContractPosition>, bool)

fn description(&self) -> &Option<String>

fn distribution_rules(&self) -> &TokenDistributionRules

fn distribution_rules_mut(&mut self) -> &mut TokenDistributionRules

fn all_change_control_rules(&self) -> Vec<(&str, &ChangeControlRules)>

impl TokenConfigurationV0Setters for TokenConfigurationV0

fn set_conventions(&mut self, conventions: TokenConfigurationConvention)

fn set_conventions_change_rules(&mut self, rules: ChangeControlRules)

fn allow_transfer_to_frozen_balance(&mut self, allow: bool)

fn set_base_supply(&mut self, base_supply: TokenAmount)

fn set_start_as_paused(&mut self, start_as_paused: bool)

fn set_max_supply(&mut self, max_supply: Option<TokenAmount>)

fn set_max_supply_change_rules(&mut self, rules: ChangeControlRules)

fn set_manual_minting_rules(&mut self, rules: ChangeControlRules)

fn set_manual_burning_rules(&mut self, rules: ChangeControlRules)

fn set_freeze_rules(&mut self, rules: ChangeControlRules)

fn set_unfreeze_rules(&mut self, rules: ChangeControlRules)

fn set_destroy_frozen_funds_rules(&mut self, rules: ChangeControlRules)

fn set_emergency_action_rules(&mut self, rules: ChangeControlRules)

fn set_main_control_group(&mut self, group: Option<GroupContractPosition>)

fn set_main_control_group_can_be_modified( &mut self, action_takers: AuthorizedActionTakers, )

fn set_description(&mut self, description: Option<String>)

Struct TokenConfigurationV0

impl<'de, Context> BorrowDecode<'de, Context> for TokenConfigurationV0

fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>( decoder: &mut D, ) -> Result<Self, DecodeError>

impl<Context> Decode<Context> for TokenConfigurationV0

fn decode<D: Decoder<Context = Context>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where __D: Deserializer<'de>,

fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer,

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<T> CloneToUninit for T
where T: Clone,

fn conv<T>(self) -> T
where Self: Into<T>,

fn wrap_with_cost(self, cost: OperationCost) -> CostContext<Self>
where Self: Sized,

fn wrap_fn_cost( self, f: impl FnOnce(&Self) -> OperationCost, ) -> CostContext<Self>
where Self: Sized,

impl<'de, T> DefaultBorrowDecode<'de> for T
where T: BorrowDecode<'de, ()>,

fn borrow_decode<D>(decoder: &mut D) -> Result<Self, DecodeError>
where D: BorrowDecoder<'de, Context = ()>, Self: Sized,

impl<T> DefaultDecode for T
where T: Decode<()>,

fn decode<D>(decoder: &mut D) -> Result<Self, DecodeError>
where D: Decoder<Context = ()>, Self: Sized,

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

impl<T, U> Into<U> for T
where U: From<T>,

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

impl<T, U> IntoOnNetwork<U> for T
where U: FromOnNetwork<T>,

impl<T, U> IntoPlatformVersioned<U> for T
where U: FromPlatformVersioned<T>,

impl<T> Pipe for T
where T: ?Sized,

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,