Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Module 0x7::market_types 

use 0x1::event;
use 0x1::option;
use 0x1::signer;
use 0x1::string;
use 0x1::table;
use 0x5::order_book_types;
use 0x5::single_order_types;
use 0x7::dead_mans_switch_tracker;
use 0x7::market_clearinghouse_order_info;
use 0x7::order_book;
use 0x7::pre_cancellation_tracker;

Enum OrderCancellationReason

Reasons why an order was cancelled

enum OrderCancellationReason has copy, drop, store
Variants
PostOnlyViolation
Fields
IOCViolation
Fields
PositionUpdateViolation
Fields
ReduceOnlyViolation
Fields
ClearinghouseSettleViolation
Fields
MaxFillLimitViolation
Fields
DuplicateClientOrderIdViolation
Fields
OrderPreCancelled
Fields
PlaceMakerOrderViolation
Fields
DeadMansSwitchExpired
Fields
DisallowedSelfTrading
Fields
OrderCancelledByUser
Fields
OrderCancelledBySystem
Fields
OrderCancelledBySystemDueToError
Fields
ClearinghouseStoppedMatching
Fields

Enum OrderStatus 

enum OrderStatus has copy, drop, store
Variants
OPEN
Fields
FILLED
Fields
CANCELLED
Fields
REJECTED
Fields
SIZE_REDUCED
Fields
ACKNOWLEDGED
Fields

Enum CallbackResult 

enum CallbackResult<R: copy, drop, store> has copy, drop
Variants
NOT_AVAILABLE
Fields
CONTINUE_MATCHING
Fields
result: R
STOP_MATCHING
Fields
result: R

Enum SettleTradeResult 

enum SettleTradeResult<R: copy, drop, store> has drop
Variants
V1
Fields
settled_size: u64
maker_cancellation_reason: option::Option<string::String>
taker_cancellation_reason: option::Option<string::String>
callback_result: market_types::CallbackResult<R>

Enum ValidationResult 

enum ValidationResult has copy, drop
Variants
V1
Fields
failure_reason: option::Option<string::String>

Enum PlaceMakerOrderResult 

enum PlaceMakerOrderResult<R: copy, drop, store> has copy, drop
Variants
V1
Fields
cancellation_reason: option::Option<string::String>
action: option::Option<R>

Enum MarketClearinghouseCallbacks 

enum MarketClearinghouseCallbacks<M: copy, drop, store, R: copy, drop, store> has drop
Variants
V1
Fields
settle_trade_f: |&mut market_types::Market<M>, market_clearinghouse_order_info::MarketClearinghouseOrderInfo<M>, market_clearinghouse_order_info::MarketClearinghouseOrderInfo<M>, u128, u64, u64|market_types::SettleTradeResult<R> has copy + drop
settle_trade_f arguments: market, taker, maker, fill_id, settled_price, settled_size,
validate_order_placement_f: |market_clearinghouse_order_info::MarketClearinghouseOrderInfo<M>, u64|market_types::ValidationResult has copy + drop
validate_settlement_update_f arguments: order_info, size
validate_bulk_order_placement_f: |address, &vector<u64>, &vector<u64>, &vector<u64>, &vector<u64>, &M|market_types::ValidationResult has copy + drop
Validate the bulk order placement arguments: account, bids_prices, bids_sizes, asks_prices, asks_sizes
place_maker_order_f: |market_clearinghouse_order_info::MarketClearinghouseOrderInfo<M>, u64|market_types::PlaceMakerOrderResult<R> has copy + drop
place_maker_order_f arguments: order_info, size
cleanup_order_f: |market_clearinghouse_order_info::MarketClearinghouseOrderInfo<M>, u64, bool| has copy + drop
cleanup_order_f arguments: order_info, cleanup_size, is_taker
cleanup_bulk_order_at_price_f: |address, order_book_types::OrderId, bool, u64, u64| has copy + drop
cleanup_bulk_orders_f arguments: account, is_bid, remaining_sizes
place_bulk_order_f: |address, order_book_types::OrderId, &vector<u64>, &vector<u64>, &vector<u64>, &vector<u64>, &vector<u64>, &vector<u64>, &vector<u64>, &vector<u64>, &M| has copy + drop
place_bulk_order_f arguments: account, order_id, bid_prices, bid_sizes, ask_prices, ask_sizes, cancelled_bid_prices, cancelled_bid_sizes, cancelled_ask_prices, cancelled_ask_sizes, metadata
decrease_order_size_f: |market_clearinghouse_order_info::MarketClearinghouseOrderInfo<M>, u64| has copy + drop
decrease_order_size_f arguments: order_info, size
get_order_metadata_bytes: |&M|vector<u8> has copy + drop
get a string representation of order metadata to be used in events

Enum Market 

enum Market<M: copy, drop, store> has store
Variants
V1
Fields
parent: address
Address of the parent object that created this market Purely for grouping events based on the source DEX, not used otherwise
market: address
Address of the market object of this market.
config: market_types::MarketConfig
order_book: order_book::OrderBook<M>
pre_cancellation_tracker: table::Table<u8, pre_cancellation_tracker::PreCancellationTracker>
Pre cancellation tracker for the market, it is wrapped inside a table as otherwise any insertion/deletion from the tracker would cause conflict with the order book.
dead_mans_switch_tracker: table::Table<u8, dead_mans_switch_tracker::DeadMansSwitchTracker>

Enum MarketConfig 

enum MarketConfig has drop, store
Variants
V1
Fields
allow_self_trade: bool
Weather to allow self matching orders
allow_events_emission: bool
Whether to allow sending all events for the markett
pre_cancellation_window_secs: u64
Pre cancellation window in seconds
enable_dead_mans_switch: bool
Enable dead man's switch functionality
min_keep_alive_time_secs: u64

Enum OrderEvent 

#[event]
enum OrderEvent has copy, drop, store
Variants
V1
Fields
parent: address
market: address
order_id: u128
client_order_id: option::Option<string::String>
user: address
orig_size: u64
Original size of the order
remaining_size: u64
Remaining size of the order in the order book
size_delta: u64
OPEN - size_delta will be amount of size added CANCELLED - size_delta will be amount of size removed FILLED - size_delta will be amount of size filled REJECTED - size_delta will always be 0
price: u64
is_bid: bool
is_taker: bool
Whether the order crosses the orderbook.
status: market_types::OrderStatus
details: string::String
metadata_bytes: vector<u8>
time_in_force: order_book_types::TimeInForce
trigger_condition: option::Option<order_book_types::TriggerCondition>
cancellation_reason: option::Option<market_types::OrderCancellationReason>

Enum BulkOrderPlacedEvent 

#[event]
enum BulkOrderPlacedEvent has copy, drop, store
Variants
V1
Fields
parent: address
market: address
order_id: u128
sequence_number: u64
user: address
bid_prices: vector<u64>
bid_sizes: vector<u64>
ask_prices: vector<u64>
ask_sizes: vector<u64>
cancelled_bid_prices: vector<u64>
cancelled_bid_sizes: vector<u64>
cancelled_ask_prices: vector<u64>
cancelled_ask_sizes: vector<u64>
previous_seq_num: u64

Enum BulkOrderModifiedEvent 

#[event]
enum BulkOrderModifiedEvent has copy, drop, store
Variants
V1
Fields
parent: address
market: address
order_id: u128
sequence_number: u64
user: address
bid_prices: vector<u64>
bid_sizes: vector<u64>
ask_prices: vector<u64>
ask_sizes: vector<u64>
cancelled_bid_prices: vector<u64>
cancelled_bid_sizes: vector<u64>
cancelled_ask_prices: vector<u64>
cancelled_ask_sizes: vector<u64>
previous_seq_num: u64
cancellation_reason: option::Option<market_types::OrderCancellationReason>

Enum BulkOrderFilledEvent 

#[event]
enum BulkOrderFilledEvent has copy, drop, store
Variants
V1
Fields
parent: address
market: address
order_id: u128
sequence_number: u64
user: address
filled_size: u64
price: u64
orig_price: u64
is_bid: bool
fill_id: u128

Enum BulkOrderRejectionEvent 

#[event]
enum BulkOrderRejectionEvent has copy, drop, store
Variants
V1
Fields
parent: address
market: address
user: address
sequence_number: u64
existing_sequence_number: u64

Constants 

const EINVALID_TIME_IN_FORCE: u64 = 3;


const DEAD_MANS_SWITCH_TRACKER_KEY: u8 = 1;


const EINVALID_ADDRESS: u64 = 1;


const EINVALID_SETTLE_RESULT: u64 = 2;


const EORDER_DOES_NOT_EXIST: u64 = 6;


const PRE_CANCELLATION_TRACKER_KEY: u8 = 0;

Function order_cancellation_reason_post_only_violation 

public fun order_cancellation_reason_post_only_violation(): market_types::OrderCancellationReason
Implementation 
public fun order_cancellation_reason_post_only_violation(): OrderCancellationReason {
    OrderCancellationReason::PostOnlyViolation
}

Function order_cancellation_reason_ioc_violation 

public fun order_cancellation_reason_ioc_violation(): market_types::OrderCancellationReason
Implementation 
public fun order_cancellation_reason_ioc_violation(): OrderCancellationReason {
    OrderCancellationReason::IOCViolation
}

Function order_cancellation_reason_position_update_violation 

public fun order_cancellation_reason_position_update_violation(): market_types::OrderCancellationReason
Implementation 
public fun order_cancellation_reason_position_update_violation()
    : OrderCancellationReason {
    OrderCancellationReason::PositionUpdateViolation
}

Function order_cancellation_reason_clearinghouse_settle_violation 

public fun order_cancellation_reason_clearinghouse_settle_violation(): market_types::OrderCancellationReason
Implementation 
public fun order_cancellation_reason_clearinghouse_settle_violation()
    : OrderCancellationReason {
    OrderCancellationReason::ClearinghouseSettleViolation
}

Function order_cancellation_reason_max_fill_limit_violation 

public fun order_cancellation_reason_max_fill_limit_violation(): market_types::OrderCancellationReason
Implementation 
public fun order_cancellation_reason_max_fill_limit_violation()
    : OrderCancellationReason {
    OrderCancellationReason::MaxFillLimitViolation
}

Function order_cancellation_reason_duplicate_client_order_id 

public fun order_cancellation_reason_duplicate_client_order_id(): market_types::OrderCancellationReason
Implementation 
public fun order_cancellation_reason_duplicate_client_order_id()
    : OrderCancellationReason {
    OrderCancellationReason::DuplicateClientOrderIdViolation
}

Function order_cancellation_reason_order_pre_cancelled 

public fun order_cancellation_reason_order_pre_cancelled(): market_types::OrderCancellationReason
Implementation 
public fun order_cancellation_reason_order_pre_cancelled(): OrderCancellationReason {
    OrderCancellationReason::OrderPreCancelled
}

Function order_cancellation_reason_place_maker_order_violation 

public fun order_cancellation_reason_place_maker_order_violation(): market_types::OrderCancellationReason
Implementation 
public fun order_cancellation_reason_place_maker_order_violation()
    : OrderCancellationReason {
    OrderCancellationReason::PlaceMakerOrderViolation
}

Function order_cancellation_reason_dead_mans_switch_expired 

public fun order_cancellation_reason_dead_mans_switch_expired(): market_types::OrderCancellationReason
Implementation 
public fun order_cancellation_reason_dead_mans_switch_expired()
    : OrderCancellationReason {
    OrderCancellationReason::DeadMansSwitchExpired
}

Function order_cancellation_reason_disallowed_self_trading 

public fun order_cancellation_reason_disallowed_self_trading(): market_types::OrderCancellationReason
Implementation 
public fun order_cancellation_reason_disallowed_self_trading(): OrderCancellationReason {
    OrderCancellationReason::DisallowedSelfTrading
}

Function order_cancellation_reason_cancelled_by_user 

public fun order_cancellation_reason_cancelled_by_user(): market_types::OrderCancellationReason
Implementation 
public fun order_cancellation_reason_cancelled_by_user(): OrderCancellationReason {
    OrderCancellationReason::OrderCancelledByUser
}

Function order_cancellation_reason_cancelled_by_system 

public fun order_cancellation_reason_cancelled_by_system(): market_types::OrderCancellationReason
Implementation 
public fun order_cancellation_reason_cancelled_by_system(): OrderCancellationReason {
    OrderCancellationReason::OrderCancelledBySystem
}

Function order_cancellation_reason_cancelled_by_system_due_to_error 

public fun order_cancellation_reason_cancelled_by_system_due_to_error(): market_types::OrderCancellationReason
Implementation 
public fun order_cancellation_reason_cancelled_by_system_due_to_error()
    : OrderCancellationReason {
    OrderCancellationReason::OrderCancelledBySystemDueToError
}

Function order_cancellation_reason_clearinghouse_stopped_matching 

public fun order_cancellation_reason_clearinghouse_stopped_matching(): market_types::OrderCancellationReason
Implementation 
public fun order_cancellation_reason_clearinghouse_stopped_matching()
    : OrderCancellationReason {
    OrderCancellationReason::ClearinghouseStoppedMatching
}

Function order_status_open 

public fun order_status_open(): market_types::OrderStatus
Implementation 
public fun order_status_open(): OrderStatus {
    OrderStatus::OPEN
}

Function order_status_filled 

public fun order_status_filled(): market_types::OrderStatus
Implementation 
public fun order_status_filled(): OrderStatus {
    OrderStatus::FILLED
}

Function order_status_cancelled 

public fun order_status_cancelled(): market_types::OrderStatus
Implementation 
public fun order_status_cancelled(): OrderStatus {
    OrderStatus::CANCELLED
}

Function order_status_rejected 

public fun order_status_rejected(): market_types::OrderStatus
Implementation 
public fun order_status_rejected(): OrderStatus {
    OrderStatus::REJECTED
}

Function order_status_size_reduced 

public fun order_status_size_reduced(): market_types::OrderStatus
Implementation 
public fun order_status_size_reduced(): OrderStatus {
    OrderStatus::SIZE_REDUCED
}

Function order_status_acknowledged 

public fun order_status_acknowledged(): market_types::OrderStatus
Implementation 
public fun order_status_acknowledged(): OrderStatus {
    OrderStatus::ACKNOWLEDGED
}

Function new_settle_trade_result 

public fun new_settle_trade_result<R: copy, drop, store>(settled_size: u64, maker_cancellation_reason: option::Option<string::String>, taker_cancellation_reason: option::Option<string::String>, callback_result: market_types::CallbackResult<R>): market_types::SettleTradeResult<R>
Implementation 
public fun new_settle_trade_result<R: store + copy + drop>(
    settled_size: u64,
    maker_cancellation_reason: Option<String>,
    taker_cancellation_reason: Option<String>,
    callback_result: CallbackResult<R>
): SettleTradeResult<R> {
    SettleTradeResult::V1 {
        settled_size,
        maker_cancellation_reason,
        taker_cancellation_reason,
        callback_result
    }
}

Function new_validation_result 

public fun new_validation_result(cancellation_reason: option::Option<string::String>): market_types::ValidationResult
Implementation 
public fun new_validation_result(
    cancellation_reason: Option<String>
): ValidationResult {
    ValidationResult::V1 { failure_reason: cancellation_reason }
}

Function new_place_maker_order_result 

public fun new_place_maker_order_result<R: copy, drop, store>(cancellation_reason: option::Option<string::String>, actions: option::Option<R>): market_types::PlaceMakerOrderResult<R>
Implementation 
public fun new_place_maker_order_result<R: store + copy + drop>(
    cancellation_reason: Option<String>, actions: Option<R>
): PlaceMakerOrderResult<R> {
    PlaceMakerOrderResult::V1 { cancellation_reason, action: actions }
}

Function new_market_clearinghouse_callbacks 

public fun new_market_clearinghouse_callbacks<M: copy, drop, store, R: copy, drop, store>(settle_trade_f: |&mut market_types::Market<M>, market_clearinghouse_order_info::MarketClearinghouseOrderInfo<M>, market_clearinghouse_order_info::MarketClearinghouseOrderInfo<M>, u128, u64, u64|market_types::SettleTradeResult<R> has copy + drop, validate_order_placement_f: |market_clearinghouse_order_info::MarketClearinghouseOrderInfo<M>, u64|market_types::ValidationResult has copy + drop, validate_bulk_order_placement_f: |address, &vector<u64>, &vector<u64>, &vector<u64>, &vector<u64>, &M|market_types::ValidationResult has copy + drop, place_maker_order_f: |market_clearinghouse_order_info::MarketClearinghouseOrderInfo<M>, u64|market_types::PlaceMakerOrderResult<R> has copy + drop, cleanup_order_f: |market_clearinghouse_order_info::MarketClearinghouseOrderInfo<M>, u64, bool| has copy + drop, cleanup_bulk_order_at_price_f: |address, order_book_types::OrderId, bool, u64, u64| has copy + drop, place_bulk_order_f: |address, order_book_types::OrderId, &vector<u64>, &vector<u64>, &vector<u64>, &vector<u64>, &vector<u64>, &vector<u64>, &vector<u64>, &vector<u64>, &M| has copy + drop, decrease_order_size_f: |market_clearinghouse_order_info::MarketClearinghouseOrderInfo<M>, u64| has copy + drop, get_order_metadata_bytes: |&M|vector<u8> has copy + drop): market_types::MarketClearinghouseCallbacks<M, R>
Implementation 
public fun new_market_clearinghouse_callbacks<M: store + copy + drop, R: store + copy + drop>(
    settle_trade_f: |
        &mut Market<M>,
        MarketClearinghouseOrderInfo<M>,
        MarketClearinghouseOrderInfo<M>,
        u128,
        u64,
        u64
    | SettleTradeResult<R> has drop + copy,
    validate_order_placement_f: |
        MarketClearinghouseOrderInfo<M>,
        u64
    | ValidationResult has drop + copy,
    validate_bulk_order_placement_f: |
        address,
        &vector<u64>,
        &vector<u64>,
        &vector<u64>,
        &vector<u64>,
        &M
    | ValidationResult has drop + copy,
    place_maker_order_f: |MarketClearinghouseOrderInfo<M>, u64| PlaceMakerOrderResult<R> has drop
    + copy,
    cleanup_order_f: |
        MarketClearinghouseOrderInfo<M>,
        u64,
        bool
    | has drop + copy,
    cleanup_bulk_order_at_price_f: |
        address,
        OrderId,
        bool,
        u64,
        u64
    | has drop + copy,
    place_bulk_order_f: |
        address,
        OrderId,
        &vector<u64>,
        &vector<u64>,
        &vector<u64>,
        &vector<u64>,
        &vector<u64>,
        &vector<u64>,
        &vector<u64>,
        &vector<u64>,
        &M
    | has drop + copy,
    decrease_order_size_f: |
        MarketClearinghouseOrderInfo<M>,
        u64
    | has drop + copy,
    get_order_metadata_bytes: |&M| vector<u8> has drop + copy
): MarketClearinghouseCallbacks<M, R> {
    MarketClearinghouseCallbacks::V1 {
        settle_trade_f,
        validate_order_placement_f,
        validate_bulk_order_placement_f,
        place_maker_order_f,
        cleanup_order_f,
        cleanup_bulk_order_at_price_f,
        place_bulk_order_f,
        decrease_order_size_f,
        get_order_metadata_bytes
    }
}

Function get_settled_size 

public fun get_settled_size<R: copy, drop, store>(self: &market_types::SettleTradeResult<R>): u64
Implementation 
public fun get_settled_size<R: store + copy + drop>(
    self: &SettleTradeResult<R>
): u64 {
    self.settled_size
}

Function get_maker_cancellation_reason 

public fun get_maker_cancellation_reason<R: copy, drop, store>(self: &market_types::SettleTradeResult<R>): option::Option<string::String>
Implementation 
public fun get_maker_cancellation_reason<R: store + copy + drop>(
    self: &SettleTradeResult<R>
): Option<String> {
    self.maker_cancellation_reason
}

Function get_taker_cancellation_reason 

public fun get_taker_cancellation_reason<R: copy, drop, store>(self: &market_types::SettleTradeResult<R>): option::Option<string::String>
Implementation 
public fun get_taker_cancellation_reason<R: store + copy + drop>(
    self: &SettleTradeResult<R>
): Option<String> {
    self.taker_cancellation_reason
}

Function get_callback_result 

public fun get_callback_result<R: copy, drop, store>(self: &market_types::SettleTradeResult<R>): &market_types::CallbackResult<R>
Implementation 
public fun get_callback_result<R: store + copy + drop>(
    self: &SettleTradeResult<R>
): &CallbackResult<R> {
    &self.callback_result
}

Function is_validation_result_valid 

public fun is_validation_result_valid(self: &market_types::ValidationResult): bool
Implementation 
public fun is_validation_result_valid(self: &ValidationResult): bool {
    self.failure_reason.is_none()
}

Function get_validation_failure_reason 

public fun get_validation_failure_reason(self: &market_types::ValidationResult): option::Option<string::String>
Implementation 
public fun get_validation_failure_reason(self: &ValidationResult): Option<String> {
    self.failure_reason
}

Function get_place_maker_order_actions 

public fun get_place_maker_order_actions<R: copy, drop, store>(self: &market_types::PlaceMakerOrderResult<R>): option::Option<R>
Implementation 
public fun get_place_maker_order_actions<R: store + copy + drop>(
    self: &PlaceMakerOrderResult<R>
): Option<R> {
    self.action
}

Function get_place_maker_order_cancellation_reason 

public fun get_place_maker_order_cancellation_reason<R: copy, drop, store>(self: &market_types::PlaceMakerOrderResult<R>): option::Option<string::String>
Implementation 
public fun get_place_maker_order_cancellation_reason<R: store + copy + drop>(
    self: &PlaceMakerOrderResult<R>
): Option<String> {
    self.cancellation_reason
}

Function extract_results 

public fun extract_results<R: copy, drop, store>(self: market_types::CallbackResult<R>): option::Option<R>
Implementation 
public fun extract_results<R: store + copy + drop>(
    self: CallbackResult<R>
): Option<R> {
    match(self) {
        CallbackResult::NOT_AVAILABLE => option::none(),
        CallbackResult::CONTINUE_MATCHING { result } => option::some(result),
        CallbackResult::STOP_MATCHING { result } => option::some(result)
    }
}

Function should_stop_matching 

public fun should_stop_matching<R: copy, drop, store>(self: &market_types::CallbackResult<R>): bool
Implementation 
public fun should_stop_matching<R: store + copy + drop>(
    self: &CallbackResult<R>
): bool {
    self is CallbackResult::STOP_MATCHING
}

Function new_callback_result_continue_matching 

public fun new_callback_result_continue_matching<R: copy, drop, store>(result: R): market_types::CallbackResult<R>
Implementation 
public fun new_callback_result_continue_matching<R: store + copy + drop>(
    result: R
): CallbackResult<R> {
    CallbackResult::CONTINUE_MATCHING { result }
}

Function new_callback_result_stop_matching 

public fun new_callback_result_stop_matching<R: copy, drop, store>(result: R): market_types::CallbackResult<R>
Implementation 
public fun new_callback_result_stop_matching<R: store + copy + drop>(
    result: R
): CallbackResult<R> {
    CallbackResult::STOP_MATCHING { result }
}

Function new_callback_result_not_available 

public fun new_callback_result_not_available<R: copy, drop, store>(): market_types::CallbackResult<R>
Implementation 
public fun new_callback_result_not_available<R: store + copy + drop>()
    : CallbackResult<R> {
    CallbackResult::NOT_AVAILABLE
}

Function settle_trade 

#[lint::skip(#[needless_mutable_reference])]
public fun settle_trade<M: copy, drop, store, R: copy, drop, store>(self: &market_types::MarketClearinghouseCallbacks<M, R>, market: &mut market_types::Market<M>, taker: market_clearinghouse_order_info::MarketClearinghouseOrderInfo<M>, maker: market_clearinghouse_order_info::MarketClearinghouseOrderInfo<M>, fill_id: u128, settled_price: u64, settled_size: u64): market_types::SettleTradeResult<R>
Implementation 
public fun settle_trade<M: store + copy + drop, R: store + copy + drop>(
    self: &MarketClearinghouseCallbacks<M, R>,
    market: &mut Market<M>,
    taker: MarketClearinghouseOrderInfo<M>,
    maker: MarketClearinghouseOrderInfo<M>,
    fill_id: u128,
    settled_price: u64,
    settled_size: u64
): SettleTradeResult<R> {
    (self.settle_trade_f) (market, taker, maker, fill_id, settled_price, settled_size)
}

Function validate_order_placement 

public fun validate_order_placement<M: copy, drop, store, R: copy, drop, store>(self: &market_types::MarketClearinghouseCallbacks<M, R>, order_info: market_clearinghouse_order_info::MarketClearinghouseOrderInfo<M>, size: u64): market_types::ValidationResult
Implementation 
public fun validate_order_placement<M: store + copy + drop, R: store + copy + drop>(
    self: &MarketClearinghouseCallbacks<M, R>,
    order_info: MarketClearinghouseOrderInfo<M>,
    size: u64
): ValidationResult {
    (self.validate_order_placement_f) (order_info, size)
}

Function validate_bulk_order_placement 

public fun validate_bulk_order_placement<M: copy, drop, store, R: copy, drop, store>(self: &market_types::MarketClearinghouseCallbacks<M, R>, account: address, bids_prices: &vector<u64>, bids_sizes: &vector<u64>, asks_prices: &vector<u64>, asks_sizes: &vector<u64>, order_metadata: &M): market_types::ValidationResult
Implementation 
public fun validate_bulk_order_placement<M: store + copy + drop, R: store + copy + drop>(
    self: &MarketClearinghouseCallbacks<M, R>,
    account: address,
    bids_prices: &vector<u64>,
    bids_sizes: &vector<u64>,
    asks_prices: &vector<u64>,
    asks_sizes: &vector<u64>,
    order_metadata: &M
): ValidationResult {
    (self.validate_bulk_order_placement_f) (
        account, bids_prices, bids_sizes, asks_prices, asks_sizes, order_metadata
    )
}

Function place_maker_order 

public fun place_maker_order<M: copy, drop, store, R: copy, drop, store>(self: &market_types::MarketClearinghouseCallbacks<M, R>, order_info: market_clearinghouse_order_info::MarketClearinghouseOrderInfo<M>, size: u64): market_types::PlaceMakerOrderResult<R>
Implementation 
public fun place_maker_order<M: store + copy + drop, R: store + copy + drop>(
    self: &MarketClearinghouseCallbacks<M, R>,
    order_info: MarketClearinghouseOrderInfo<M>,
    size: u64
): PlaceMakerOrderResult<R> {
    (self.place_maker_order_f) (order_info, size)
}

Function cleanup_order 

public fun cleanup_order<M: copy, drop, store, R: copy, drop, store>(self: &market_types::MarketClearinghouseCallbacks<M, R>, order_info: market_clearinghouse_order_info::MarketClearinghouseOrderInfo<M>, cleanup_size: u64, is_taker: bool)
Implementation 
public fun cleanup_order<M: store + copy + drop, R: store + copy + drop>(
    self: &MarketClearinghouseCallbacks<M, R>,
    order_info: MarketClearinghouseOrderInfo<M>,
    cleanup_size: u64,
    is_taker: bool
) {
    (self.cleanup_order_f) (order_info, cleanup_size, is_taker)
}

Function cleanup_bulk_order_at_price 

public fun cleanup_bulk_order_at_price<M: copy, drop, store, R: copy, drop, store>(self: &market_types::MarketClearinghouseCallbacks<M, R>, account: address, order_id: order_book_types::OrderId, is_bid: bool, price: u64, cleanup_size: u64)
Implementation 
public fun cleanup_bulk_order_at_price<M: store + copy + drop, R: store + copy + drop>(
    self: &MarketClearinghouseCallbacks<M, R>,
    account: address,
    order_id: OrderId,
    is_bid: bool,
    price: u64,
    cleanup_size: u64
) {
    (self.cleanup_bulk_order_at_price_f) (
        account, order_id, is_bid, price, cleanup_size
    )
}

Function place_bulk_order 

public fun place_bulk_order<M: copy, drop, store, R: copy, drop, store>(self: &market_types::MarketClearinghouseCallbacks<M, R>, account: address, order_id: order_book_types::OrderId, bid_prices: &vector<u64>, bid_sizes: &vector<u64>, ask_prices: &vector<u64>, ask_sizes: &vector<u64>, cancelled_bid_prices: &vector<u64>, cancelled_bid_sizes: &vector<u64>, cancelled_ask_prices: &vector<u64>, cancelled_ask_sizes: &vector<u64>, metadata: &M)
Implementation 
public fun place_bulk_order<M: store + copy + drop, R: store + copy + drop>(
    self: &MarketClearinghouseCallbacks<M, R>,
    account: address,
    order_id: OrderId,
    bid_prices: &vector<u64>,
    bid_sizes: &vector<u64>,
    ask_prices: &vector<u64>,
    ask_sizes: &vector<u64>,
    cancelled_bid_prices: &vector<u64>,
    cancelled_bid_sizes: &vector<u64>,
    cancelled_ask_prices: &vector<u64>,
    cancelled_ask_sizes: &vector<u64>,
    metadata: &M
) {
    (self.place_bulk_order_f) (
        account,
        order_id,
        bid_prices,
        bid_sizes,
        ask_prices,
        ask_sizes,
        cancelled_bid_prices,
        cancelled_bid_sizes,
        cancelled_ask_prices,
        cancelled_ask_sizes,
        metadata
    )
}

Function decrease_order_size 

public fun decrease_order_size<M: copy, drop, store, R: copy, drop, store>(self: &market_types::MarketClearinghouseCallbacks<M, R>, order_info: market_clearinghouse_order_info::MarketClearinghouseOrderInfo<M>, new_size: u64)
Implementation 
public fun decrease_order_size<M: store + copy + drop, R: store + copy + drop>(
    self: &MarketClearinghouseCallbacks<M, R>,
    order_info: MarketClearinghouseOrderInfo<M>,
    new_size: u64
) {
    (self.decrease_order_size_f) (order_info, new_size)
}

Function get_order_metadata_bytes 

public fun get_order_metadata_bytes<M: copy, drop, store, R: copy, drop, store>(self: &market_types::MarketClearinghouseCallbacks<M, R>, order_metadata: &M): vector<u8>
Implementation 
public fun get_order_metadata_bytes<M: store + copy + drop, R: store + copy + drop>(
    self: &MarketClearinghouseCallbacks<M, R>,
    order_metadata: &M
): vector<u8> {
    (self.get_order_metadata_bytes) (order_metadata)
}

Function new_market_config 

public fun new_market_config(allow_self_matching: bool, allow_events_emission: bool, pre_cancellation_window_secs: u64, enable_dead_mans_switch: bool, min_keep_alive_time_secs: u64): market_types::MarketConfig
Implementation 
public fun new_market_config(
    allow_self_matching: bool,
    allow_events_emission: bool,
    pre_cancellation_window_secs: u64,
    enable_dead_mans_switch: bool,
    min_keep_alive_time_secs: u64
): MarketConfig {
    MarketConfig::V1 {
        allow_self_trade: allow_self_matching,
        allow_events_emission,
        pre_cancellation_window_secs,
        enable_dead_mans_switch,
        min_keep_alive_time_secs
    }
}

Function new_market 

public fun new_market<M: copy, drop, store>(parent: &signer, market: &signer, config: market_types::MarketConfig): market_types::Market<M>
Implementation 
public fun new_market<M: store + copy + drop>(
    parent: &signer, market: &signer, config: MarketConfig
): Market<M> {
    // requiring signers, and not addresses, purely to guarantee different dexes
    // cannot polute events to each other, accidentally or maliciously.
    let pre_cancellation_window = config.pre_cancellation_window_secs;
    let pre_cancellation_tracker = table::new();
    pre_cancellation_tracker.add(
        PRE_CANCELLATION_TRACKER_KEY,
        new_pre_cancellation_tracker(pre_cancellation_window)
    );
    let dead_mans_switch_tracker = table::new();
    dead_mans_switch_tracker.add(
        DEAD_MANS_SWITCH_TRACKER_KEY,
        new_dead_mans_switch_tracker(config.min_keep_alive_time_secs)
    );
    Market::V1 {
        parent: signer::address_of(parent),
        market: signer::address_of(market),
        config,
        order_book: new_order_book(),
        pre_cancellation_tracker,
        dead_mans_switch_tracker
    }
}

Function set_allow_self_trade 

public fun set_allow_self_trade<M: copy, drop, store>(self: &mut market_types::Market<M>, allow_self_trade: bool)
Implementation 
public fun set_allow_self_trade<M: store + copy + drop>(
    self: &mut Market<M>, allow_self_trade: bool
) {
    self.config.allow_self_trade = allow_self_trade;
}

Function set_allow_events_emission 

public fun set_allow_events_emission<M: copy, drop, store>(self: &mut market_types::Market<M>, allow_events_emission: bool)
Implementation 
public fun set_allow_events_emission<M: store + copy + drop>(
    self: &mut Market<M>, allow_events_emission: bool
) {
    self.config.allow_events_emission = allow_events_emission;
}

Function set_allow_dead_mans_switch 

public fun set_allow_dead_mans_switch<M: copy, drop, store>(self: &mut market_types::Market<M>, enable_dead_mans_switch: bool)
Implementation 
public fun set_allow_dead_mans_switch<M: store + copy + drop>(
    self: &mut Market<M>, enable_dead_mans_switch: bool
) {
    self.config.enable_dead_mans_switch = enable_dead_mans_switch;
}

Function set_dead_mans_switch_min_keep_alive_time_secs 

public fun set_dead_mans_switch_min_keep_alive_time_secs<M: copy, drop, store>(self: &mut market_types::Market<M>, min_keep_alive_time_secs: u64)
Implementation 
public fun set_dead_mans_switch_min_keep_alive_time_secs<M: store + copy + drop>(
    self: &mut Market<M>, min_keep_alive_time_secs: u64
) {
    self.config.min_keep_alive_time_secs = min_keep_alive_time_secs;
    let parent = self.parent;
    let market = self.market;
    dead_mans_switch_tracker::set_min_keep_alive_time_secs(
        self.get_dead_mans_switch_tracker_mut(),
        parent,
        market,
        min_keep_alive_time_secs
    );
}

Function get_order_book 

public fun get_order_book<M: copy, drop, store>(self: &market_types::Market<M>): &order_book::OrderBook<M>
Implementation 
public fun get_order_book<M: store + copy + drop>(self: &Market<M>): &OrderBook<M> {
    &self.order_book
}

Function get_market_address 

public fun get_market_address<M: copy, drop, store>(self: &market_types::Market<M>): address
Implementation 
public fun get_market_address<M: store + copy + drop>(self: &Market<M>): address {
    self.market
}

Function best_bid_price 

public fun best_bid_price<M: copy, drop, store>(self: &market_types::Market<M>): option::Option<u64>
Implementation 
public fun best_bid_price<M: store + copy + drop>(self: &Market<M>): Option<u64> {
    self.order_book.best_bid_price()
}

Function best_ask_price 

public fun best_ask_price<M: copy, drop, store>(self: &market_types::Market<M>): option::Option<u64>
Implementation 
public fun best_ask_price<M: store + copy + drop>(self: &Market<M>): Option<u64> {
    self.order_book.best_ask_price()
}

Function is_taker_order 

public fun is_taker_order<M: copy, drop, store>(self: &market_types::Market<M>, price: u64, is_bid: bool, trigger_condition: option::Option<order_book_types::TriggerCondition>): bool
Implementation 
public fun is_taker_order<M: store + copy + drop>(
    self: &Market<M>,
    price: u64,
    is_bid: bool,
    trigger_condition: Option<TriggerCondition>
): bool {
    self.order_book.is_taker_order(price, is_bid, trigger_condition)
}

Function is_allowed_self_trade 

public fun is_allowed_self_trade<M: copy, drop, store>(self: &market_types::Market<M>): bool
Implementation 
public fun is_allowed_self_trade<M: store + copy + drop>(self: &Market<M>): bool {
    self.config.allow_self_trade
}

Function get_remaining_size

Remaining size of the order in the order book.

public fun get_remaining_size<M: copy, drop, store>(self: &market_types::Market<M>, order_id: order_book_types::OrderId): u64
Implementation 
public fun get_remaining_size<M: store + copy + drop>(
    self: &Market<M>, order_id: OrderId
): u64 {
    self.order_book.get_single_remaining_size(order_id)
}

Function get_bulk_order_remaining_size 

public fun get_bulk_order_remaining_size<M: copy, drop, store>(self: &market_types::Market<M>, user: address, is_bid: bool): u64
Implementation 
public fun get_bulk_order_remaining_size<M: store + copy + drop>(
    self: &Market<M>, user: address, is_bid: bool
): u64 {
    self.order_book.get_bulk_order_remaining_size(user, is_bid)
}

Function get_order_metadata 

public fun get_order_metadata<M: copy, drop, store>(self: &market_types::Market<M>, order_id: order_book_types::OrderId): option::Option<M>
Implementation 
public fun get_order_metadata<M: store + copy + drop>(
    self: &Market<M>, order_id: OrderId
): Option<M> {
    self.order_book.get_single_order_metadata(order_id)
}

Function set_order_metadata

Returns the order metadata for an order by order id. It is up to the caller to perform necessary permissions checks

public fun set_order_metadata<M: copy, drop, store>(self: &mut market_types::Market<M>, order_id: order_book_types::OrderId, metadata: M)
Implementation 
public fun set_order_metadata<M: store + copy + drop>(
    self: &mut Market<M>, order_id: OrderId, metadata: M
) {
    self.order_book.set_single_order_metadata(order_id, metadata);
}

Function get_order_metadata_by_client_id 

public fun get_order_metadata_by_client_id<M: copy, drop, store>(self: &market_types::Market<M>, user: address, client_order_id: string::String): option::Option<M>
Implementation 
public fun get_order_metadata_by_client_id<M: store + copy + drop>(
    self: &Market<M>, user: address, client_order_id: String
): Option<M> {
    let order_id = self.order_book.get_order_id_by_client_id(user, client_order_id);
    if (order_id.is_none()) {
        return option::none();
    };
    return self.get_order_metadata(order_id.destroy_some())
}

Function set_order_metadata_by_client_id

Sets the order metadata for an order by client id. It is up to the caller to perform necessary permissions checks around ownership of the order.

public fun set_order_metadata_by_client_id<M: copy, drop, store>(self: &mut market_types::Market<M>, user: address, client_order_id: string::String, metadata: M)
Implementation 
public fun set_order_metadata_by_client_id<M: store + copy + drop>(
    self: &mut Market<M>,
    user: address,
    client_order_id: String,
    metadata: M
) {
    let order_id = self.order_book.get_order_id_by_client_id(user, client_order_id);
    assert!(order_id.is_some(), EORDER_DOES_NOT_EXIST);
    self.set_order_metadata(order_id.destroy_some(), metadata);
}

Function take_ready_price_based_orders

Returns all the pending order ready to be executed based on the oracle price. The caller is responsible to call the place_order_with_order_id API to place the order with the order id returned from this API.

public fun take_ready_price_based_orders<M: copy, drop, store>(self: &mut market_types::Market<M>, oracle_price: u64, order_limit: u64): vector<single_order_types::SingleOrder<M>>
Implementation 
public fun take_ready_price_based_orders<M: store + copy + drop>(
    self: &mut Market<M>, oracle_price: u64, order_limit: u64
): vector<SingleOrder<M>> {
    self.order_book.take_ready_price_based_orders(oracle_price, order_limit)
}

Function take_ready_time_based_orders

Returns all the pending order that are ready to be executed based on current time stamp. The caller is responsible to call the place_order_with_order_id API to place the order with the order id returned from this API.

public fun take_ready_time_based_orders<M: copy, drop, store>(self: &mut market_types::Market<M>, order_limit: u64): vector<single_order_types::SingleOrder<M>>
Implementation 
public fun take_ready_time_based_orders<M: store + copy + drop>(
    self: &mut Market<M>, order_limit: u64
): vector<SingleOrder<M>> {
    self.order_book.take_ready_time_based_orders(order_limit)
}

Function emit_event_for_order 

public fun emit_event_for_order<M: copy, drop, store, R: copy, drop, store>(self: &market_types::Market<M>, order_id: order_book_types::OrderId, client_order_id: option::Option<string::String>, user: address, orig_size: u64, remaining_size: u64, size_delta: u64, price: u64, is_bid: bool, is_taker: bool, status: market_types::OrderStatus, details: string::String, metadata: M, trigger_condition: option::Option<order_book_types::TriggerCondition>, time_in_force: order_book_types::TimeInForce, cancellation_reason: option::Option<market_types::OrderCancellationReason>, callbacks: &market_types::MarketClearinghouseCallbacks<M, R>)
Implementation 
public fun emit_event_for_order<M: store + copy + drop, R: store + copy + drop>(
    self: &Market<M>,
    order_id: OrderId,
    client_order_id: Option<String>,
    user: address,
    orig_size: u64,
    remaining_size: u64,
    size_delta: u64,
    price: u64,
    is_bid: bool,
    is_taker: bool,
    status: OrderStatus,
    details: String,
    metadata: M,
    trigger_condition: Option<TriggerCondition>,
    time_in_force: TimeInForce,
    cancellation_reason: Option<OrderCancellationReason>,
    callbacks: &MarketClearinghouseCallbacks<M, R>
) {
    // Final check whether event sending is enabled
    if (self.config.allow_events_emission) {
        let metadata_bytes = callbacks.get_order_metadata_bytes(&metadata);
        event::emit(
            OrderEvent::V1 {
                parent: self.parent,
                market: self.market,
                order_id: order_id.get_order_id_value(),
                client_order_id,
                user,
                orig_size,
                remaining_size,
                size_delta,
                price,
                is_bid,
                is_taker,
                status,
                details,
                metadata_bytes,
                time_in_force,
                trigger_condition,
                cancellation_reason
            }
        );
    };
}

Function emit_event_for_bulk_order_placed 

public fun emit_event_for_bulk_order_placed<M: copy, drop, store>(self: &market_types::Market<M>, order_id: order_book_types::OrderId, sequence_number: u64, user: address, bid_prices: vector<u64>, bid_sizes: vector<u64>, ask_prices: vector<u64>, ask_sizes: vector<u64>, cancelled_bid_prices: vector<u64>, cancelled_bid_sizes: vector<u64>, cancelled_ask_prices: vector<u64>, cancelled_ask_sizes: vector<u64>, previous_seq_num: u64)
Implementation 
public fun emit_event_for_bulk_order_placed<M: store + copy + drop>(
    self: &Market<M>,
    order_id: OrderId,
    sequence_number: u64,
    user: address,
    bid_prices: vector<u64>,
    bid_sizes: vector<u64>,
    ask_prices: vector<u64>,
    ask_sizes: vector<u64>,
    cancelled_bid_prices: vector<u64>,
    cancelled_bid_sizes: vector<u64>,
    cancelled_ask_prices: vector<u64>,
    cancelled_ask_sizes: vector<u64>,
    previous_seq_num: u64
) {
    // Final check whether event sending is enabled
    if (self.config.allow_events_emission) {
        event::emit(
            BulkOrderPlacedEvent::V1 {
                parent: self.parent,
                market: self.market,
                order_id: order_id.get_order_id_value(),
                sequence_number,
                user,
                bid_prices,
                bid_sizes,
                ask_prices,
                ask_sizes,
                cancelled_bid_prices,
                cancelled_bid_sizes,
                cancelled_ask_prices,
                cancelled_ask_sizes,
                previous_seq_num
            }
        );
    };
}

Function emit_event_for_bulk_order_cancelled 

public fun emit_event_for_bulk_order_cancelled<M: copy, drop, store>(self: &market_types::Market<M>, order_id: order_book_types::OrderId, sequence_number: u64, user: address, cancelled_bid_prices: vector<u64>, cancelled_bid_sizes: vector<u64>, cancelled_ask_prices: vector<u64>, cancelled_ask_sizes: vector<u64>, cancellation_reason: option::Option<market_types::OrderCancellationReason>)
Implementation 
public fun emit_event_for_bulk_order_cancelled<M: store + copy + drop>(
    self: &Market<M>,
    order_id: OrderId,
    sequence_number: u64,
    user: address,
    cancelled_bid_prices: vector<u64>,
    cancelled_bid_sizes: vector<u64>,
    cancelled_ask_prices: vector<u64>,
    cancelled_ask_sizes: vector<u64>,
    cancellation_reason: Option<OrderCancellationReason>
) {
    // Final check whether event sending is enabled
    if (self.config.allow_events_emission) {
        event::emit(
            BulkOrderModifiedEvent::V1 {
                parent: self.parent,
                market: self.market,
                order_id: order_id.get_order_id_value(),
                sequence_number,
                user,
                bid_prices: vector[],
                bid_sizes: vector[],
                ask_prices: vector[],
                ask_sizes: vector[],
                cancelled_bid_prices,
                cancelled_bid_sizes,
                cancelled_ask_prices,
                cancelled_ask_sizes,
                previous_seq_num: sequence_number,
                cancellation_reason
            }
        )
    };
}

Function emit_event_for_bulk_order_filled 

public fun emit_event_for_bulk_order_filled<M: copy, drop, store>(self: &market_types::Market<M>, order_id: order_book_types::OrderId, sequence_number: u64, user: address, filled_size: u64, price: u64, orig_price: u64, is_bid: bool, fill_id: u128)
Implementation 
public fun emit_event_for_bulk_order_filled<M: store + copy + drop>(
    self: &Market<M>,
    order_id: OrderId,
    sequence_number: u64,
    user: address,
    filled_size: u64,
    price: u64,
    orig_price: u64,
    is_bid: bool,
    fill_id: u128
) {
    // Final check whether event sending is enabled
    if (self.config.allow_events_emission) {
        event::emit(
            BulkOrderFilledEvent::V1 {
                parent: self.parent,
                market: self.market,
                order_id: order_id.get_order_id_value(),
                sequence_number,
                user,
                filled_size,
                price,
                orig_price,
                is_bid,
                fill_id
            }
        );
    };
}

Function emit_event_for_bulk_order_modified 

public fun emit_event_for_bulk_order_modified<M: copy, drop, store>(self: &market_types::Market<M>, order_id: order_book_types::OrderId, sequence_number: u64, user: address, bid_prices: vector<u64>, bid_sizes: vector<u64>, ask_prices: vector<u64>, ask_sizes: vector<u64>, cancelled_bid_prices: vector<u64>, cancelled_bid_sizes: vector<u64>, cancelled_ask_prices: vector<u64>, cancelled_ask_sizes: vector<u64>, cancellation_reason: option::Option<market_types::OrderCancellationReason>)
Implementation 
public fun emit_event_for_bulk_order_modified<M: store + copy + drop>(
    self: &Market<M>,
    order_id: OrderId,
    sequence_number: u64,
    user: address,
    bid_prices: vector<u64>,
    bid_sizes: vector<u64>,
    ask_prices: vector<u64>,
    ask_sizes: vector<u64>,
    cancelled_bid_prices: vector<u64>,
    cancelled_bid_sizes: vector<u64>,
    cancelled_ask_prices: vector<u64>,
    cancelled_ask_sizes: vector<u64>,
    cancellation_reason: Option<OrderCancellationReason>
) {
    // Final check whether event sending is enabled
    if (self.config.allow_events_emission) {
        event::emit(
            BulkOrderModifiedEvent::V1 {
                parent: self.parent,
                market: self.market,
                order_id: order_id.get_order_id_value(),
                sequence_number,
                user,
                bid_prices,
                bid_sizes,
                ask_prices,
                ask_sizes,
                cancelled_bid_prices,
                cancelled_bid_sizes,
                cancelled_ask_prices,
                cancelled_ask_sizes,
                previous_seq_num: sequence_number,
                cancellation_reason
            }
        );
    };
}

Function emit_event_for_bulk_order_rejection 

public fun emit_event_for_bulk_order_rejection<M: copy, drop, store>(self: &market_types::Market<M>, user: address, sequence_number: u64, existing_sequence_number: u64)
Implementation 
public fun emit_event_for_bulk_order_rejection<M: store + copy + drop>(
    self: &Market<M>,
    user: address,
    sequence_number: u64,
    existing_sequence_number: u64
) {
    // Final check whether event sending is enabled
    if (self.config.allow_events_emission) {
        event::emit(
            BulkOrderRejectionEvent::V1 {
                parent: self.parent,
                market: self.market,
                user,
                sequence_number,
                existing_sequence_number
            }
        );
    };
}

Function get_order_book_mut 

public(friend) fun get_order_book_mut<M: copy, drop, store>(self: &mut market_types::Market<M>): &mut order_book::OrderBook<M>
Implementation 
public(friend) fun get_order_book_mut<M: store + copy + drop>(
    self: &mut Market<M>
): &mut OrderBook<M> {
    &mut self.order_book
}

Function get_pre_cancellation_tracker_mut 

public(friend) fun get_pre_cancellation_tracker_mut<M: copy, drop, store>(self: &mut market_types::Market<M>): &mut pre_cancellation_tracker::PreCancellationTracker
Implementation 
public(friend) fun get_pre_cancellation_tracker_mut<M: store + copy + drop>(
    self: &mut Market<M>
): &mut PreCancellationTracker {
    self.pre_cancellation_tracker.borrow_mut(PRE_CANCELLATION_TRACKER_KEY)
}

Function get_dead_mans_switch_tracker 

public(friend) fun get_dead_mans_switch_tracker<M: copy, drop, store>(self: &market_types::Market<M>): &dead_mans_switch_tracker::DeadMansSwitchTracker
Implementation 
public(friend) fun get_dead_mans_switch_tracker<M: store + copy + drop>(
    self: &Market<M>
): &DeadMansSwitchTracker {
    self.dead_mans_switch_tracker.borrow(DEAD_MANS_SWITCH_TRACKER_KEY)
}

Function get_dead_mans_switch_tracker_mut 

public(friend) fun get_dead_mans_switch_tracker_mut<M: copy, drop, store>(self: &mut market_types::Market<M>): &mut dead_mans_switch_tracker::DeadMansSwitchTracker
Implementation 
public(friend) fun get_dead_mans_switch_tracker_mut<M: store + copy + drop>(
    self: &mut Market<M>
): &mut DeadMansSwitchTracker {
    self.dead_mans_switch_tracker.borrow_mut(DEAD_MANS_SWITCH_TRACKER_KEY)
}

Function is_dead_mans_switch_enabled 

public(friend) fun is_dead_mans_switch_enabled<M: copy, drop, store>(self: &market_types::Market<M>): bool
Implementation 
public(friend) fun is_dead_mans_switch_enabled<M: store + copy + drop>(
    self: &Market<M>
): bool {
    self.config.enable_dead_mans_switch
}

Function get_parent 

public(friend) fun get_parent<M: copy, drop, store>(self: &market_types::Market<M>): address
Implementation 
public(friend) fun get_parent<M: store + copy + drop>(self: &Market<M>): address {
    self.parent
}

Function get_market 

public(friend) fun get_market<M: copy, drop, store>(self: &market_types::Market<M>): address
Implementation 
public(friend) fun get_market<M: store + copy + drop>(self: &Market<M>): address {
    self.market
}