Struct scrypto_test::prelude::v1::v1_1::MultiResourcePoolBlueprint

impl MultiResourcePoolBlueprint

pub fn instantiate<Y>( resource_addresses: IndexSet<ResourceAddress>, owner_role: OwnerRole, pool_manager_rule: AccessRule, address_reservation: Option<GlobalAddressReservation>, api: &mut Y ) -> Result<Global<MultiResourcePoolObjectTypeInfo>, RuntimeError>
where Y: ClientApi<RuntimeError> + KernelNodeApi,

pub fn contribute<Y>( buckets: Vec<Bucket>, api: &mut Y ) -> Result<(Bucket, Vec<Bucket>), RuntimeError>
where Y: ClientApi<RuntimeError>,

This function calculates the amount of resources that should be contributed to the pool and then contributes them to the pool returning back a pool unit resource in exchange for the contributed resources.

The various states that the pool can be in can be outlined within the context laid out in the docs of the TwoResourcePool::contribute function, but in a more generalized way.

State 1: If no pool units exist in circulation then consider the pool to be new. All of the resources are accepted and an amount of pool units equivalent to the geometric mean of the non zero contributions is minted.
State 2: If pool units exist in circulation but all of the reserves are empty then this pool is in an invalid state, one that requires external intervention from a protected withdraw or deposit to get out of. This has to do with how we represent the fact that the user owns 100% of the pool.
State 3: If pool units exist in circulation and some but not all of the reserves are empty then contributions will be accepted according to the ratio of resources in the pool and the contribution of any of the resources with zero reserves will be returned as change.
State 4: Pool units exist in circulation and none of the vaults are empty, the pool is in normal operation.

In the case when the pool is operating normally an algorithm is needed to determine the following:

Given some resources, how much of these resources can the pool accept.
Given some resources, how much pool units should the pool mint.

Let r₁, r₂, …, r_n be the reserves of the resources in the pool and c₁, c₂, …, c_n the amounts being contributed to each of the resources in the pool.

We calculate the ratios of contribution to reserves which is denoted as k_n where k_n = c_n / r_n such that we find k₁, k₂, …, k_n. We then find the minimum value of k denoted as k_min which gives us the ratio which can be satisfied by all of the resources provided for contribution.

To determine the amount of resources that should be contributed k_min is multiplied by the reserves of each of the resources. This amount is put in the pool’s vaults and whatever amount remains is returned as change.

To determine the amount of pool units to mint k_min is multiplied by the pool units total supply.

The following is a minimal example

n	1	2	3	Note
r	1000	2000	3000
c	2000	3000	4000
k	2	1.5	1.33
k_min			1.33
ca	1333	2666	4000	Amount of contribution to accept

pub fn redeem<Y>( bucket: Bucket, api: &mut Y ) -> Result<Vec<Bucket>, RuntimeError>
where Y: ClientApi<RuntimeError>,

pub fn protected_deposit<Y>( bucket: Bucket, api: &mut Y ) -> Result<(), RuntimeError>
where Y: ClientApi<RuntimeError>,

pub fn protected_withdraw<Y>( resource_address: ResourceAddress, amount: Decimal, withdraw_strategy: WithdrawStrategy, api: &mut Y ) -> Result<Bucket, RuntimeError>
where Y: ClientApi<RuntimeError>,

pub fn get_redemption_value<Y>( amount_of_pool_units: Decimal, api: &mut Y ) -> Result<IndexMap<ResourceAddress, Decimal>, RuntimeError>
where Y: ClientApi<RuntimeError>,

pub fn get_vault_amounts<Y>( api: &mut Y ) -> Result<IndexMap<ResourceAddress, Decimal>, RuntimeError>
where Y: ClientApi<RuntimeError>,

Auto Trait Implementations§

impl UnwindSafe for MultiResourcePoolBlueprint

Blanket Implementations§

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

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl As for U

fn as_<T>(self) -> T
where T: CastFrom,

Casts self to type T. The semantics of numeric casting with the as operator are followed, so <T as As>::as_:: can be used in the same way as T as U for numeric conversions. Read more

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

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

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

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> Downcast for T
where T: Any,

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.

impl<T> DowncastSync for T
where T: Any + Send + Sync,

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait.