pub struct MultiResourcePoolBlueprint;

Implementations§

source§

impl MultiResourcePoolBlueprint

source

pub fn instantiate<Y>( resource_addresses: IndexSet<ResourceAddress>, owner_role: OwnerRole, pool_manager_rule: AccessRule, address_reservation: Option<GlobalAddressReservation>, api: &mut Y ) -> Result<MultiResourcePoolInstantiateOutput, RuntimeError>

source

pub fn contribute<Y>( buckets: Vec<Bucket>, api: &mut Y ) -> Result<MultiResourcePoolContributeOutput, 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 r1, r2, …, rn be the reserves of the resources in the pool and c1, c2, …, cn the amounts being contributed to each of the resources in the pool.

We calculate the ratios of contribution to reserves which is denoted as kn where kn = cn / rn such that we find k1, k2, …, kn. We then find the minimum value of k denoted as kmin 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 kmin 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 kmin is multiplied by the pool units total supply.

The following is a minimal example

n123Note
r100020003000
c200030004000
k21.51.33
kmin1.33
ca133326664000Amount of contribution to accept
source

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

source

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

source

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

source

pub fn get_redemption_value<Y>( amount_of_pool_units: Decimal, api: &mut Y ) -> Result<MultiResourcePoolGetRedemptionValueOutput, RuntimeError>

source

pub fn get_vault_amounts<Y>( api: &mut Y ) -> Result<TwoResourcePoolGetVaultAmountsOutput, RuntimeError>

source

fn with_state<Y, F, O>(api: &mut Y, callback: F) -> Result<O, RuntimeError>

source

fn calculate_amount_owed( pool_units_to_redeem: Decimal, pool_units_total_supply: Decimal, reserves: IndexMap<ResourceAddress, ReserveResourceInformation> ) -> Result<IndexMap<ResourceAddress, Decimal>, RuntimeError>

Auto Trait Implementations§

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
§

impl<U> As for U

§

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

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

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

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.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

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

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V