Struct GeneralResourceConstraint

pub struct GeneralResourceConstraint {
    pub required_ids: IndexSet<NonFungibleLocalId>,
    pub lower_bound: LowerBound,
    pub upper_bound: UpperBound,
    pub allowed_ids: AllowedIds,
}

GeneralResourceConstraint captures constraints on the balance of a single fungible or non-fungible resource.

It captures four concepts:

• A set of required_ids which are NonFungibleLocalIds which are required to be in the balance.
• A lower_bound on the decimal balance amount.
• An upper_bound on the decimal balance amount.
• Constraints on the allowed_ids. These are either:
  • AllowedIds::Any
  • AllowedIds::Allowlist(allowlist) of NonFungibleLocalIds. If this case, the ids in the resource balance must be a subset of the allowlist.

Fungible resources are viewed as a specialization of non-fungible resources where we disregard ids and permit non-integer balances. So you must use AllowedIds::Any with fungible resources. An empty allowlist is also permitted if the balance is exactly zero.

Trait implementations

• The PartialEq / Eq implementations both are correctly order-independent on the id sets, from the order-independent implementation of IndexSet.

Validity

To be valid, the following checks must be satisfied:

• The numeric bounds must be satisfiable:

  • lower_bound <= upper_bound`

• The id bounds must be satisfiable:

  • Either allowed_ids is AllowedIds::Any
  • Or allowed_ids is AllowedIds::Allowlist(allowlist) and required_ids is a subset of allowlist.

• The numeric and id bounds must be jointly satisfiable, that is, they must overlap:

  • required_ids.len() <= upper_bound.equivalent_decimal()
  • If there is an allowlist, lower_bound.equivalent_decimal() <= allowlist.len()

Also, depending on the resource type, further checks must be satisfied:

• If the constraints are for a fungible resource, then required_ids must be empty, and allowed_ids must be AllowedIds::Any (or, if the upper bound is zero, AllowedIds::Allowlist with an empty list is also acceptable).

• If the constraints are for a non-fungible resource, then any decimal balances must be integers.

Normalization

Normalization takes a valid GeneralResourceConstraint and internally tightens it into a canonical form. The resultant fields satisfies these tighter conditions:

• Strict ordering of constraints:
  • required_ids.len() <= lower_bound <= upper_bound <= allowlist.len()
• Detection of exact definition:
  • If required_ids.len() == upper_bound, then allowed_ids == AllowedIds::Allowlist(required_ids)
  • If lower_bound == allowlist.len(), then required_ids == allowlist

Fields

required_ids: IndexSet<NonFungibleLocalId>

lower_bound: LowerBound

upper_bound: UpperBound

allowed_ids: AllowedIds

Implementations

impl GeneralResourceConstraint

pub fn fungible( lower_bound: impl Resolve<LowerBound>, upper_bound: impl Resolve<UpperBound>, ) -> GeneralResourceConstraint

pub fn non_fungible_no_allow_list( required_ids: impl IntoIterator<Item = NonFungibleLocalId>, lower_bound: impl Resolve<LowerBound>, upper_bound: impl Resolve<UpperBound>, ) -> GeneralResourceConstraint

pub fn non_fungible_with_allow_list( required_ids: impl IntoIterator<Item = NonFungibleLocalId>, lower_bound: impl Resolve<LowerBound>, upper_bound: impl Resolve<UpperBound>, allowed_ids: impl IntoIterator<Item = NonFungibleLocalId>, ) -> GeneralResourceConstraint

pub fn is_valid_for_fungible_use(&self) -> bool

pub fn is_valid_for_non_fungible_use(&self) -> bool

pub fn validate_fungible( &self, amount: Decimal, ) -> Result<(), ResourceConstraintError>

pub fn validate_non_fungible_ids( &self, ids: &IndexSet<NonFungibleLocalId>, ) -> Result<(), ResourceConstraintError>

pub fn is_valid_independent_of_resource_type(&self) -> bool

pub fn normalize(&mut self)

The process of normalization defined under GeneralResourceConstraint.

This method is assumed to apply to a valid GeneralResourceConstraint - else the result is non-sensical.

Trait Implementations

impl Categorize<ManifestCustomValueKind> for GeneralResourceConstraint

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl Categorize<ScryptoCustomValueKind> for GeneralResourceConstraint

fn value_kind() -> ValueKind<ScryptoCustomValueKind>

impl Clone for GeneralResourceConstraint

fn clone(&self) -> GeneralResourceConstraint

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GeneralResourceConstraint

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

Formats the value using the given formatter.

impl<D> Decode<ManifestCustomValueKind, D> for GeneralResourceConstraint

where D: Decoder<ManifestCustomValueKind>,

fn decode_body_with_value_kind( decoder: &mut D, value_kind: ValueKind<ManifestCustomValueKind>, ) -> Result<GeneralResourceConstraint, DecodeError>

Decodes the type from the decoder, which should match a preloaded value kind.

impl<D> Decode<ScryptoCustomValueKind, D> for GeneralResourceConstraint

where D: Decoder<ScryptoCustomValueKind>,

fn decode_body_with_value_kind( decoder: &mut D, value_kind: ValueKind<ScryptoCustomValueKind>, ) -> Result<GeneralResourceConstraint, DecodeError>

Decodes the type from the decoder, which should match a preloaded value kind.

impl Describe<ScryptoCustomTypeKind> for GeneralResourceConstraint

const TYPE_ID: RustTypeId

The TYPE_ID should give a unique identifier for its SBOR schema type. An SBOR schema type capture details about the SBOR payload, how it should be interpreted, validated and displayed.

fn type_data() -> TypeData<ScryptoCustomTypeKind, RustTypeId>

Returns the local schema for the given type.

fn add_all_dependencies(aggregator: &mut TypeAggregator<ScryptoCustomTypeKind>)

For each type referenced in get_local_type_data, we need to ensure that the type and all of its own references get added to the aggregator.

impl<E> Encode<ManifestCustomValueKind, E> for GeneralResourceConstraint

where E: Encoder<ManifestCustomValueKind>,

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

Encodes the SBOR value’s kind to the encoder

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

Encodes the SBOR body of the type to the encoder.

impl<E> Encode<ScryptoCustomValueKind, E> for GeneralResourceConstraint

where E: Encoder<ScryptoCustomValueKind>,

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

Encodes the SBOR value’s kind to the encoder

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

Encodes the SBOR body of the type to the encoder.

impl PartialEq for GeneralResourceConstraint

fn eq(&self, other: &GeneralResourceConstraint) -> 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 SborTuple<ManifestCustomValueKind> for GeneralResourceConstraint

fn get_length(&self) -> usize

impl SborTuple<ScryptoCustomValueKind> for GeneralResourceConstraint

fn get_length(&self) -> usize

impl Eq for GeneralResourceConstraint

impl StructuralPartialEq for GeneralResourceConstraint