Struct pallet_lbp::Pool

pub struct Pool<AccountId, BlockNumber: AtLeast32BitUnsigned + Copy> {
    pub owner: AccountId,
    pub start: Option<BlockNumber>,
    pub end: Option<BlockNumber>,
    pub assets: (AssetId, AssetId),
    pub initial_weight: LBPWeight,
    pub final_weight: LBPWeight,
    pub weight_curve: WeightCurveType,
    pub fee: (u32, u32),
    pub fee_collector: AccountId,
    pub repay_target: Balance,
}

Fields

owner: AccountId

owner of the pool after CreatePoolOrigin creates it

start: Option<BlockNumber>

start block

end: Option<BlockNumber>

end block

assets: (AssetId, AssetId)

Asset ids of the tokens (accumulating asset, sold asset) // TODO maybe name them accordingly in struct instead of tuple

initial_weight: LBPWeight

initial weight of the asset_a where the minimum value is 0 (equivalent to 0% weight), and the maximum value is 100_000_000 (equivalent to 100% weight)

final_weight: LBPWeight

final weights of the asset_a where the minimum value is 0 (equivalent to 0% weight), and the maximum value is 100_000_000 (equivalent to 100% weight)

weight_curve: WeightCurveType

weight curve

fee: (u32, u32)

standard fee amount

fee_collector: AccountId

person that receives the fee

repay_target: Balance

repayment target of the accumulated asset in fee collectors account, when this target is reached fee drops from 20% to fee

Implementations

impl<AccountId, BlockNumber: AtLeast32BitUnsigned + Copy> Pool<AccountId, BlockNumber>

pub(crate) fn new(
    pool_owner: AccountId,
    asset_a: AssetId,
    asset_b: AssetId,
    initial_weight: LBPWeight,
    final_weight: LBPWeight,
    weight_curve: WeightCurveType,
    fee: (u32, u32),
    fee_collector: AccountId,
    repay_target: Balance
) -> Self

Trait Implementations

impl<AccountId: Clone, BlockNumber: Clone + AtLeast32BitUnsigned + Copy> Clone for Pool<AccountId, BlockNumber>

fn clone(&self) -> Pool<AccountId, BlockNumber>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<AccountId, BlockNumber> Debug for Pool<AccountId, BlockNumber>where
    AccountId: Debug,
    BlockNumber: Debug + AtLeast32BitUnsigned + Copy,

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

Formats the value using the given formatter.

impl<AccountId, BlockNumber: AtLeast32BitUnsigned + Copy> Decode for Pool<AccountId, BlockNumber>where
    AccountId: Decode,
    Option<BlockNumber>: Decode,

fn decode<__CodecInputEdqy: Input>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn skip<I>(input: &mut I) -> Result<(), Error>where
    I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<'de, AccountId, BlockNumber> Deserialize<'de> for Pool<AccountId, BlockNumber>where
    AccountId: Deserialize<'de>,
    BlockNumber: Deserialize<'de> + AtLeast32BitUnsigned + Copy,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<AccountId, BlockNumber: AtLeast32BitUnsigned + Copy> Encode for Pool<AccountId, BlockNumber>where
    AccountId: Encode,
    Option<BlockNumber>: Encode,

fn encode_to<__CodecOutputEdqy: Output + ?Sized>(
    &self,
    __codec_dest_edqy: &mut __CodecOutputEdqy
)

Convert self to a slice and append it to the destination.

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode(&self) -> Vec<u8, Global>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> Rwhere
    F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<AccountId: PartialEq, BlockNumber: PartialEq + AtLeast32BitUnsigned + Copy> PartialEq<Pool<AccountId, BlockNumber>> for Pool<AccountId, BlockNumber>

fn eq(&self, other: &Pool<AccountId, BlockNumber>) -> 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<AccountId, BlockNumber> Serialize for Pool<AccountId, BlockNumber>where
    AccountId: Serialize,
    BlockNumber: Serialize + AtLeast32BitUnsigned + Copy,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl<AccountId, BlockNumber> TypeInfo for Pool<AccountId, BlockNumber>where
    AccountId: TypeInfo + 'static,
    Option<BlockNumber>: TypeInfo + 'static,
    BlockNumber: AtLeast32BitUnsigned + Copy + TypeInfo + 'static,

type Identity = Pool<AccountId, BlockNumber>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<AccountId, BlockNumber: AtLeast32BitUnsigned + Copy> EncodeLike<Pool<AccountId, BlockNumber>> for Pool<AccountId, BlockNumber>where
    AccountId: Encode,
    Option<BlockNumber>: Encode,

impl<AccountId: Eq, BlockNumber: Eq + AtLeast32BitUnsigned + Copy> Eq for Pool<AccountId, BlockNumber>

impl<AccountId, BlockNumber: AtLeast32BitUnsigned + Copy> StructuralEq for Pool<AccountId, BlockNumber>

impl<AccountId, BlockNumber: AtLeast32BitUnsigned + Copy> StructuralPartialEq for Pool<AccountId, BlockNumber>