Trait hydradx_traits::router::TradeExecution

pub trait TradeExecution<Origin, AccountId, AssetId, Balance> {
    type Error;

    fn calculate_sell(
        pool_type: PoolType<AssetId>,
        asset_in: AssetId,
        asset_out: AssetId,
        amount_in: Balance
    ) -> Result<Balance, ExecutorError<Self::Error>>;
    fn calculate_buy(
        pool_type: PoolType<AssetId>,
        asset_in: AssetId,
        asset_out: AssetId,
        amount_out: Balance
    ) -> Result<Balance, ExecutorError<Self::Error>>;
    fn execute_sell(
        who: Origin,
        pool_type: PoolType<AssetId>,
        asset_in: AssetId,
        asset_out: AssetId,
        amount_in: Balance,
        min_limit: Balance
    ) -> Result<(), ExecutorError<Self::Error>>;
    fn execute_buy(
        who: Origin,
        pool_type: PoolType<AssetId>,
        asset_in: AssetId,
        asset_out: AssetId,
        amount_out: Balance,
        max_limit: Balance
    ) -> Result<(), ExecutorError<Self::Error>>;
}

Required Associated Types

type Error

Required Methods

fn calculate_sell(
    pool_type: PoolType<AssetId>,
    asset_in: AssetId,
    asset_out: AssetId,
    amount_in: Balance
) -> Result<Balance, ExecutorError<Self::Error>>

fn calculate_buy(
    pool_type: PoolType<AssetId>,
    asset_in: AssetId,
    asset_out: AssetId,
    amount_out: Balance
) -> Result<Balance, ExecutorError<Self::Error>>

fn execute_sell(
    who: Origin,
    pool_type: PoolType<AssetId>,
    asset_in: AssetId,
    asset_out: AssetId,
    amount_in: Balance,
    min_limit: Balance
) -> Result<(), ExecutorError<Self::Error>>

fn execute_buy(
    who: Origin,
    pool_type: PoolType<AssetId>,
    asset_in: AssetId,
    asset_out: AssetId,
    amount_out: Balance,
    max_limit: Balance
) -> Result<(), ExecutorError<Self::Error>>

Implementations on Foreign Types

impl<E: PartialEq, Origin: Clone, AccountId, AssetId: Copy, Balance: Copy, TupleElement0> TradeExecution<Origin, AccountId, AssetId, Balance> for (TupleElement0,)where
    TupleElement0: TradeExecution<Origin, AccountId, AssetId, Balance, Error = E> + TradeExecution<Origin, AccountId, AssetId, Balance>,

type Error = E

fn calculate_sell(
    pool_type: PoolType<AssetId>,
    asset_in: AssetId,
    asset_out: AssetId,
    amount_in: Balance
) -> Result<Balance, ExecutorError<Self::Error>>

fn calculate_buy(
    pool_type: PoolType<AssetId>,
    asset_in: AssetId,
    asset_out: AssetId,
    amount_out: Balance
) -> Result<Balance, ExecutorError<Self::Error>>

fn execute_sell(
    who: Origin,
    pool_type: PoolType<AssetId>,
    asset_in: AssetId,
    asset_out: AssetId,
    amount_in: Balance,
    min_limit: Balance
) -> Result<(), ExecutorError<Self::Error>>

fn execute_buy(
    who: Origin,
    pool_type: PoolType<AssetId>,
    asset_in: AssetId,
    asset_out: AssetId,
    amount_out: Balance,
    max_limit: Balance
) -> Result<(), ExecutorError<Self::Error>>

impl<E: PartialEq, Origin: Clone, AccountId, AssetId: Copy, Balance: Copy, TupleElement0, TupleElement1> TradeExecution<Origin, AccountId, AssetId, Balance> for (TupleElement0, TupleElement1)where
    TupleElement0: TradeExecution<Origin, AccountId, AssetId, Balance, Error = E> + TradeExecution<Origin, AccountId, AssetId, Balance>,
    TupleElement1: TradeExecution<Origin, AccountId, AssetId, Balance, Error = E> + TradeExecution<Origin, AccountId, AssetId, Balance>,

type Error = E

fn calculate_sell(
    pool_type: PoolType<AssetId>,
    asset_in: AssetId,
    asset_out: AssetId,
    amount_in: Balance
) -> Result<Balance, ExecutorError<Self::Error>>

fn calculate_buy(
    pool_type: PoolType<AssetId>,
    asset_in: AssetId,
    asset_out: AssetId,
    amount_out: Balance
) -> Result<Balance, ExecutorError<Self::Error>>

fn execute_sell(
    who: Origin,
    pool_type: PoolType<AssetId>,
    asset_in: AssetId,
    asset_out: AssetId,
    amount_in: Balance,
    min_limit: Balance
) -> Result<(), ExecutorError<Self::Error>>

fn execute_buy(
    who: Origin,
    pool_type: PoolType<AssetId>,
    asset_in: AssetId,
    asset_out: AssetId,
    amount_out: Balance,
    max_limit: Balance
) -> Result<(), ExecutorError<Self::Error>>

impl<E: PartialEq, Origin: Clone, AccountId, AssetId: Copy, Balance: Copy, TupleElement0, TupleElement1, TupleElement2> TradeExecution<Origin, AccountId, AssetId, Balance> for (TupleElement0, TupleElement1, TupleElement2)where
    TupleElement0: TradeExecution<Origin, AccountId, AssetId, Balance, Error = E> + TradeExecution<Origin, AccountId, AssetId, Balance>,
    TupleElement1: TradeExecution<Origin, AccountId, AssetId, Balance, Error = E> + TradeExecution<Origin, AccountId, AssetId, Balance>,
    TupleElement2: TradeExecution<Origin, AccountId, AssetId, Balance, Error = E> + TradeExecution<Origin, AccountId, AssetId, Balance>,

type Error = E

fn calculate_sell(
    pool_type: PoolType<AssetId>,
    asset_in: AssetId,
    asset_out: AssetId,
    amount_in: Balance
) -> Result<Balance, ExecutorError<Self::Error>>

fn calculate_buy(
    pool_type: PoolType<AssetId>,
    asset_in: AssetId,
    asset_out: AssetId,
    amount_out: Balance
) -> Result<Balance, ExecutorError<Self::Error>>

fn execute_sell(
    who: Origin,
    pool_type: PoolType<AssetId>,
    asset_in: AssetId,
    asset_out: AssetId,
    amount_in: Balance,
    min_limit: Balance
) -> Result<(), ExecutorError<Self::Error>>

fn execute_buy(
    who: Origin,
    pool_type: PoolType<AssetId>,
    asset_in: AssetId,
    asset_out: AssetId,
    amount_out: Balance,
    max_limit: Balance
) -> Result<(), ExecutorError<Self::Error>>

impl<E: PartialEq, Origin: Clone, AccountId, AssetId: Copy, Balance: Copy, TupleElement0, TupleElement1, TupleElement2, TupleElement3> TradeExecution<Origin, AccountId, AssetId, Balance> for (TupleElement0, TupleElement1, TupleElement2, TupleElement3)where
    TupleElement0: TradeExecution<Origin, AccountId, AssetId, Balance, Error = E> + TradeExecution<Origin, AccountId, AssetId, Balance>,
    TupleElement1: TradeExecution<Origin, AccountId, AssetId, Balance, Error = E> + TradeExecution<Origin, AccountId, AssetId, Balance>,
    TupleElement2: TradeExecution<Origin, AccountId, AssetId, Balance, Error = E> + TradeExecution<Origin, AccountId, AssetId, Balance>,
    TupleElement3: TradeExecution<Origin, AccountId, AssetId, Balance, Error = E> + TradeExecution<Origin, AccountId, AssetId, Balance>,

type Error = E

fn calculate_sell(
    pool_type: PoolType<AssetId>,
    asset_in: AssetId,
    asset_out: AssetId,
    amount_in: Balance
) -> Result<Balance, ExecutorError<Self::Error>>

fn calculate_buy(
    pool_type: PoolType<AssetId>,
    asset_in: AssetId,
    asset_out: AssetId,
    amount_out: Balance
) -> Result<Balance, ExecutorError<Self::Error>>

fn execute_sell(
    who: Origin,
    pool_type: PoolType<AssetId>,
    asset_in: AssetId,
    asset_out: AssetId,
    amount_in: Balance,
    min_limit: Balance
) -> Result<(), ExecutorError<Self::Error>>

fn execute_buy(
    who: Origin,
    pool_type: PoolType<AssetId>,
    asset_in: AssetId,
    asset_out: AssetId,
    amount_out: Balance,
    max_limit: Balance
) -> Result<(), ExecutorError<Self::Error>>

impl<E: PartialEq, Origin: Clone, AccountId, AssetId: Copy, Balance: Copy, TupleElement0, TupleElement1, TupleElement2, TupleElement3, TupleElement4> TradeExecution<Origin, AccountId, AssetId, Balance> for (TupleElement0, TupleElement1, TupleElement2, TupleElement3, TupleElement4)where
    TupleElement0: TradeExecution<Origin, AccountId, AssetId, Balance, Error = E> + TradeExecution<Origin, AccountId, AssetId, Balance>,
    TupleElement1: TradeExecution<Origin, AccountId, AssetId, Balance, Error = E> + TradeExecution<Origin, AccountId, AssetId, Balance>,
    TupleElement2: TradeExecution<Origin, AccountId, AssetId, Balance, Error = E> + TradeExecution<Origin, AccountId, AssetId, Balance>,
    TupleElement3: TradeExecution<Origin, AccountId, AssetId, Balance, Error = E> + TradeExecution<Origin, AccountId, AssetId, Balance>,
    TupleElement4: TradeExecution<Origin, AccountId, AssetId, Balance, Error = E> + TradeExecution<Origin, AccountId, AssetId, Balance>,

type Error = E

fn calculate_sell(
    pool_type: PoolType<AssetId>,
    asset_in: AssetId,
    asset_out: AssetId,
    amount_in: Balance
) -> Result<Balance, ExecutorError<Self::Error>>

fn calculate_buy(
    pool_type: PoolType<AssetId>,
    asset_in: AssetId,
    asset_out: AssetId,
    amount_out: Balance
) -> Result<Balance, ExecutorError<Self::Error>>

fn execute_sell(
    who: Origin,
    pool_type: PoolType<AssetId>,
    asset_in: AssetId,
    asset_out: AssetId,
    amount_in: Balance,
    min_limit: Balance
) -> Result<(), ExecutorError<Self::Error>>

fn execute_buy(
    who: Origin,
    pool_type: PoolType<AssetId>,
    asset_in: AssetId,
    asset_out: AssetId,
    amount_out: Balance,
    max_limit: Balance
) -> Result<(), ExecutorError<Self::Error>>

Implementors