Struct scrypto_test::prelude::v1::substates::multi_resource_pool::Substate

pub struct Substate {
    pub vaults: IndexMap<ResourceAddress, Vault>,
    pub pool_unit_resource_manager: ResourceManager,
}

Fields

vaults: IndexMap<ResourceAddress, Vault>

The vaults being stored as a IndexMap and not as a KeyValueStore is intentional here!

All of the operations on the many pool blueprint require loading all of the vaults and doing some arithmetic, reading their state (with exception to protected deposit and withdraw). Storing this as a KeyValueStore only to later read the entire KVStore is pointless.

Also, while protected deposits and withdraws technically do not need to read the entire map of vaults they realistically do since the caller needs to know the balances to do the arithmetic they need prior to doing a deposit or withdraw. Thus, these two methods are in a realistic setting need to read that state.

Additionally, size should not be a serious concern for any realistic application. The vaults map in a pool of 10 resources is just 605 bytes with 20 resources its 1205 bytes which is still reasonable. Note that most applications that would use a pool of this kind might be balancer-esc applications where the maximum number of tokens a pool can hold is 8; thus there is no concern that this map would become too big.

Finally, when using this resource pool as part of a dApp all that the dApp would store is a reference to the pool. In other words, if the dApp has a method that does not interact with the pool, it is not in any way affected by how the pool stores the vaults; cost units and fees do not come into the picture there.

pool_unit_resource_manager: ResourceManager

The resource manager of the pool unit resource that the pool works with.

Trait Implementations

impl Categorize<ScryptoCustomValueKind> for Substate

fn value_kind() -> ValueKind<ScryptoCustomValueKind>

impl Debug for Substate

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

Formats the value using the given formatter.

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

where D: Decoder<ScryptoCustomValueKind>,

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

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

impl Describe<ScryptoCustomTypeKind> for Substate

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<ScryptoCustomValueKind, E> for Substate

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 FieldContentSource<MultiResourcePoolStateFieldPayload> for Substate

fn into_content(self) -> VersionedMultiResourcePoolState

fn into_payload(self) -> Payload

fn into_locked_substate(self) -> FieldSubstate<Payload>

fn into_unlocked_substate(self) -> FieldSubstate<Payload>

impl From<Substate> for VersionedMultiResourcePoolState

fn from(value: Substate) -> VersionedMultiResourcePoolState

Converts to this type from the input type.

impl PartialEq for Substate

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl SborTuple<ScryptoCustomValueKind> for Substate

fn get_length(&self) -> usize

impl VersionedMultiResourcePoolStateVersion for Substate

type Versioned = VersionedMultiResourcePoolState

fn into_versioned( self ) -> <Substate as VersionedMultiResourcePoolStateVersion>::Versioned

impl Eq for Substate

impl StructuralPartialEq for Substate