Struct scrypto_test::prelude::v1::v1_0::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.

Note that this function checks to ensure that:

Some amount of resources were provided for each of the resources in the pool, otherwise the operation errors out.
No buckets are provided which do not belong to the liquidity pool. If this happens then the contribution logic will fail and abort the transaction.

Note: it is acceptable for two buckets to contain the same resource, as long as the above checks pass then this is acceptable and the pool can account for it accordingly.

In the case where the pool is new and there are currently no pool units all of the resources are accepted and the pool mints as many pool units as the geometric average of the contributed resources.

There are three operation modes that a pool can be in:

Pool units total supply is zero: regardless of whether there are some reserves or not, the pool is considered to be back to its initial state. The first contributor is able to determine the amount that they wish to contribute and they get minted an amount of pool units that is equal to the geometric average of their contribution.
Pool units total supply is not zero, but some reserves are empty: In this case, the pool is said to be in an illegal state. Some people out there are holding pool units that equate to some percentage of zero, which is an illegal state for the pool to be in.
Pool units total supply is not zero, none of the reserves are empty: The pool is operating normally and is governed by the antilogarithm discussed below.

In the case when the pool is operating normally an antilogarithm 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.