Struct pool_xyk::PairSwapAction

pub struct PairSwapAction<AssetId, AccountId, TechAccountId> {
    pub client_account: Option<AccountId>,
    pub receiver_account: Option<AccountId>,
    pub pool_account: TechAccountId,
    pub source: Resource<AssetId, Balance>,
    pub destination: Resource<AssetId, Balance>,
    pub fee: Option<Balance>,
    pub fee_account: Option<TechAccountId>,
    pub get_fee_from_destination: Option<bool>,
}

Fields

client_account: Option<AccountId>

receiver_account: Option<AccountId>

pool_account: TechAccountId

source: Resource<AssetId, Balance>

destination: Resource<AssetId, Balance>

fee: Option<Balance>

fee_account: Option<TechAccountId>

get_fee_from_destination: Option<bool>

Trait Implementations

impl<AssetId: Clone, AccountId: Clone, TechAccountId: Clone> Clone for PairSwapAction<AssetId, AccountId, TechAccountId>

fn clone(&self) -> PairSwapAction<AssetId, AccountId, TechAccountId>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<AssetId, AccountId, TechAccountId> Debug for PairSwapAction<AssetId, AccountId, TechAccountId>where AssetId: Debug, AccountId: Debug, TechAccountId: Debug,

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

Formats the value using the given formatter.

impl<AssetId, AccountId, TechAccountId> Decode for PairSwapAction<AssetId, AccountId, TechAccountId>where Option<AccountId>: Decode, TechAccountId: Decode, Resource<AssetId, Balance>: Decode, Option<TechAccountId>: Decode,

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

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self> ) -> Result<DecodeFinished, Error>where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

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<AssetId, AccountId, TechAccountId> Encode for PairSwapAction<AssetId, AccountId, TechAccountId>where Option<AccountId>: Encode, TechAccountId: Encode, Resource<AssetId, Balance>: Encode, Option<TechAccountId>: Encode,

fn size_hint(&self) -> usize

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

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

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

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<AssetId: PartialEq, AccountId: PartialEq, TechAccountId: PartialEq> PartialEq<PairSwapAction<AssetId, AccountId, TechAccountId>> for PairSwapAction<AssetId, AccountId, TechAccountId>

fn eq(&self, other: &PairSwapAction<AssetId, AccountId, TechAccountId>) -> 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<T: Config> SwapAction<<T as Config>::AccountId, <T as Config>::TechAccountId, <T as Config>::AssetId, T> for PairSwapAction<<T as Config>::AssetId, <T as Config>::AccountId, <T as Config>::TechAccountId>

fn reserve( &self, source: &<T as Config>::AccountId, base_asset_id: &<T as Config>::AssetId ) -> DispatchResult

This function is called after validation, and every Option is Some, and it is safe to do unwrap. Bounds is also safe to unwrap.

fn claim(&self, _source: &<T as Config>::AccountId) -> bool

Claim the reserved resources, with source. Returns whether the claim succeeds.

fn weight(&self) -> Weight

Weight for executing the operation.

fn cancel(&self, _source: &<T as Config>::AccountId)

Cancel the resources reserved in source.

impl<T: Config> SwapRulesValidation<<T as Config>::AccountId, <T as Config>::TechAccountId, <T as Config>::AssetId, T> for PairSwapAction<<T as Config>::AssetId, <T as Config>::AccountId, <T as Config>::TechAccountId>

fn is_abstract_checking(&self) -> bool

If action is only for abstract checking, shoud not apply by reserve function.

fn prepare_and_validate( &mut self, source_opt: Option<&<T as Config>::AccountId>, base_asset_id: &<T as Config>::AssetId ) -> DispatchResult

Validate action if next steps must be applied by reserve function or if source account is None, than just ability to do operation is checked.

fn instant_auto_claim_used(&self) -> bool

Instant auto claim is performed just after reserve. If triggered is not used, than it is one time auto claim, it will be canceled if it fails.

fn triggered_auto_claim_used(&self) -> bool

Triggered auto claim can be used for example for crowd like schemes. for example: when crowd aggregation if succesefull event is fired by consensus, and it is trigger.

fn is_able_to_claim(&self) -> bool

Predicate for posibility to claim, timeout for example, or one time for crowd schemes/

impl<AssetId, AccountId, TechAccountId> TypeInfo for PairSwapAction<AssetId, AccountId, TechAccountId>where Option<AccountId>: TypeInfo + 'static, TechAccountId: TypeInfo + 'static, Resource<AssetId, Balance>: TypeInfo + 'static, Option<TechAccountId>: TypeInfo + 'static, AssetId: TypeInfo + 'static, AccountId: TypeInfo + 'static,

type Identity = PairSwapAction<AssetId, AccountId, TechAccountId>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<AssetId, AccountId, TechAccountId> EncodeLike<PairSwapAction<AssetId, AccountId, TechAccountId>> for PairSwapAction<AssetId, AccountId, TechAccountId>where Option<AccountId>: Encode, TechAccountId: Encode, Resource<AssetId, Balance>: Encode, Option<TechAccountId>: Encode,

impl<AssetId: Eq, AccountId: Eq, TechAccountId: Eq> Eq for PairSwapAction<AssetId, AccountId, TechAccountId>

impl<AssetId, AccountId, TechAccountId> StructuralEq for PairSwapAction<AssetId, AccountId, TechAccountId>

impl<AssetId, AccountId, TechAccountId> StructuralPartialEq for PairSwapAction<AssetId, AccountId, TechAccountId>