IRemusDEX Trait Reference

Below is the trait defining RemusDEX’s external functions.

#[starknet::interface]
trait IRemusDEX<TState> {
    fn add_market(ref self: TState, market_config: MarketConfig) -> MarketId;
    fn get_all_market_configs(self: @TState) -> Array<(MarketId, MarketConfig)>;
    fn update_market_config(ref self: TState, market_id: MarketId, market_config: MarketConfig);
    fn get_market_config(self: @TState, market_id: MarketId) -> MarketConfig;
    fn set_trading_status(ref self: TState, market_id: MarketId, trading_enabled: bool);
    fn get_trading_status(self: @TState, market_id: MarketId) -> Option<bool>;
    fn get_price_level(self: @TState, price_level_id: PriceLevelId) -> PriceLevel;
    fn get_price_level_with_size(self: @TState, price_level_id: PriceLevelId) -> PriceLevelWithSize;
    fn get_price_level_with_orders(self: @TState, price_level_id: PriceLevelId) -> PriceLevelWithOrders;
    fn get_maker_order(self: @TState, maker_order_id: MakerOrderId) -> MakerOrder;
    fn submit_maker_order(
        ref self: TState,
        market_id: MarketId,
        target_token_address: TokenAddress,
        order_price: u128,
        order_size: u256,
        order_side: MakerOrderSide,
        order_type: MakerOrderType,
        time_limit: TimeLimit,
    ) -> MakerOrderId;
    fn delete_maker_order(ref self: TState, maker_order_id: MakerOrderId);
    fn get_claimable(self: @TState, token_address: ContractAddress, user_address: ContractAddress) -> u256;
    fn claim(ref self: TState, token_address: ContractAddress, amount: u256);
    fn get_orderbook(self: @TState, market_id: MarketId) -> OrderBook;
    fn get_whole_orderbook_with_levels_and_size(self: @TState, market_id: MarketId) -> OrderBookWithLevels;
    fn get_all_user_orders(self: @TState, user: ContractAddress) -> Array<MakerOrder>;
    fn get_orderbook_side_with_levels_and_size(
        self: @TState, market_id: MarketId, is_bid: bool
    ) -> Array<PriceLevelWithSize>;
    fn get_collected_fees(self: @TState, token_address: TokenAddress) -> u256;
    fn claim_fees(ref self: TState, token_address: TokenAddress, amount: u256);
    fn upgrade(ref self: TState, hash: ClassHash);
}

Associated Types and Structs

type UserAddress = ContractAddress;
type TokenAddress = ContractAddress;
type MarketId = u64;
type MakerOrderId = u256;
type TradeId = u256;
type PriceLevelId = u256;

MarketConfig

struct MarketConfig {
    base_token: TokenAddress,
    quote_token: TokenAddress,
    tick_size: u256,
    lot_size: u256,
    trading_enabled: bool,
    fees: Fees
}

struct Fees {
    taker_fee_bps: u16,
    maker_fee_bps: u16
}

OrderBook and Related Structs

struct OrderBook {
    bids: PriceLevelList,
    asks: PriceLevelList,
    market_id: MarketId
}

struct OrderBookWithLevels {
    bids: Array<PriceLevelWithSize>,
    asks: Array<PriceLevelWithSize>,
    market_id: MarketId
}

struct PriceLevelList {
    first: PriceLevelId,
    last: PriceLevelId,
    market_id: MarketId,
    is_bid: bool
}

struct PriceLevel {
    id: PriceLevelId,
    price: u128,
    previous: PriceLevelId,
    next: PriceLevelId,
    first_order: MakerOrderId,
    last_order: MakerOrderId,
    is_bid: bool
}

struct PriceLevelWithSize {
    level: PriceLevel,
    size: u256
}

struct PriceLevelWithOrders {
    level: PriceLevel,
    orders: Array<MakerOrder>
}

MakerOrder and Enums

struct MakerOrder {
    market_id: MarketId,
    maker_order_id: u256,
    trader: UserAddress,
    order_side: MakerOrderSide,
    order_type: MakerOrderType,
    amount: u256,
    amount_remaining: u256,
    price: u128,
    time_limit: TimeLimit,
    entry_time: u64,
    next: MakerOrderId,
    previous: MakerOrderId
}

enum MakerOrderType {
    Post,
    IOC,
    Basic
}

enum MakerOrderSide {
    Bid,
    Ask
}

enum TimeLimit {
    GTC
}