axelar-cgp-sui

Module 0x0::order

Order module defines the order struct and its methods. All order matching happens in this module.

use 0x0::balances;
use 0x0::constants;
use 0x0::deep_price;
use 0x0::fill;
use 0x0::math;
use 0x0::utils;
use 0x1::option;
use 0x1::u64;
use 0x2::event;
use 0x2::object;

Struct Order

Order struct represents the order in the order book. It is optimized for space.

struct Order has drop, store
Fields
balance_manager_id: object::ID
order_id: u128
client_order_id: u64
quantity: u64
filled_quantity: u64
fee_is_deep: bool
order_deep_price: deep_price::OrderDeepPrice
epoch: u64
status: u8
expire_timestamp: u64

Struct OrderCanceled

Emitted when a maker order is canceled.

struct OrderCanceled has copy, drop, store
Fields
balance_manager_id: object::ID
pool_id: object::ID
order_id: u128
client_order_id: u64
trader: address
price: u64
is_bid: bool
original_quantity: u64
base_asset_quantity_canceled: u64
timestamp: u64

Struct OrderModified

Emitted when a maker order is modified.

struct OrderModified has copy, drop, store
Fields
balance_manager_id: object::ID
pool_id: object::ID
order_id: u128
client_order_id: u64
trader: address
price: u64
is_bid: bool
new_quantity: u64
timestamp: u64

Constants

const EInvalidNewQuantity: u64 = 0;


const EOrderExpired: u64 = 1;

Function balance_manager_id

public fun balance_manager_id(self: &order::Order): object::ID
Implementation 
public fun balance_manager_id(self: &Order): ID {
    self.balance_manager_id
}

Function order_id

public fun order_id(self: &order::Order): u128
Implementation 
public fun order_id(self: &Order): u128 {
    self.order_id
}

Function client_order_id

public fun client_order_id(self: &order::Order): u64
Implementation 
public fun client_order_id(self: &Order): u64 {
    self.client_order_id
}

Function quantity

public fun quantity(self: &order::Order): u64
Implementation 
public fun quantity(self: &Order): u64 {
    self.quantity
}

Function filled_quantity

public fun filled_quantity(self: &order::Order): u64
Implementation 
public fun filled_quantity(self: &Order): u64 {
    self.filled_quantity
}

Function fee_is_deep

public fun fee_is_deep(self: &order::Order): bool
Implementation 
public fun fee_is_deep(self: &Order): bool {
    self.fee_is_deep
}

Function order_deep_price

public fun order_deep_price(self: &order::Order): &deep_price::OrderDeepPrice
Implementation 
public fun order_deep_price(self: &Order): &OrderDeepPrice {
    &self.order_deep_price
}

Function epoch

public fun epoch(self: &order::Order): u64
Implementation 
public fun epoch(self: &Order): u64 {
    self.epoch
}

Function status

public fun status(self: &order::Order): u8
Implementation 
public fun status(self: &Order): u8 {
    self.status
}

Function expire_timestamp

public fun expire_timestamp(self: &order::Order): u64
Implementation 
public fun expire_timestamp(self: &Order): u64 {
    self.expire_timestamp
}

Function price

public fun price(self: &order::Order): u64
Implementation 
public fun price(self: &Order): u64 {
    let (_, price, _) = utils::decode_order_id(self.order_id);

    price
}

Function new

initialize the order struct.

public(friend) fun new(order_id: u128, balance_manager_id: object::ID, client_order_id: u64, quantity: u64, fee_is_deep: bool, order_deep_price: deep_price::OrderDeepPrice, epoch: u64, status: u8, expire_timestamp: u64): order::Order
Implementation 
public(package) fun new(
    order_id: u128,
    balance_manager_id: ID,
    client_order_id: u64,
    quantity: u64,
    fee_is_deep: bool,
    order_deep_price: OrderDeepPrice,
    epoch: u64,
    status: u8,
    expire_timestamp: u64,
): Order {
    Order {
        order_id,
        balance_manager_id,
        client_order_id,
        quantity,
        filled_quantity: 0,
        fee_is_deep,
        order_deep_price,
        epoch,
        status,
        expire_timestamp,
    }
}

Function generate_fill

Generate a fill for the resting order given the timestamp, quantity and whether the order is a bid.

public(friend) fun generate_fill(self: &mut order::Order, timestamp: u64, quantity: u64, is_bid: bool, expire_maker: bool): fill::Fill
Implementation 
public(package) fun generate_fill(
    self: &mut Order,
    timestamp: u64,
    quantity: u64,
    is_bid: bool,
    expire_maker: bool,
): Fill {
    let remaining_quantity = self.quantity - self.filled_quantity;
    let mut base_quantity = remaining_quantity.min(quantity);
    let mut quote_quantity = math::mul(base_quantity, self.price());

    let order_id = self.order_id;
    let balance_manager_id = self.balance_manager_id;
    let expired = timestamp > self.expire_timestamp || expire_maker;

    if (expired) {
        self.status = constants::expired();
        base_quantity = remaining_quantity;
        quote_quantity = math::mul(base_quantity, self.price());
    } else {
        self.filled_quantity = self.filled_quantity + base_quantity;
        self.status =
            if (self.quantity == self.filled_quantity) constants::filled()
            else constants::partially_filled();
    };

    fill::new(
        order_id,
        self.client_order_id,
        self.price(),
        balance_manager_id,
        expired,
        self.quantity == self.filled_quantity,
        base_quantity,
        quote_quantity,
        is_bid,
        self.epoch,
        self.order_deep_price,
    )
}

Function modify

Modify the order with a new quantity. The new quantity must be greater than the filled quantity and less than the original quantity. The timestamp must be less than the expire timestamp.

public(friend) fun modify(self: &mut order::Order, new_quantity: u64, timestamp: u64)
Implementation 
public(package) fun modify(
    self: &mut Order,
    new_quantity: u64,
    timestamp: u64,
) {
    assert!(
        new_quantity > self.filled_quantity &&
        new_quantity < self.quantity,
        EInvalidNewQuantity,
    );
    assert!(timestamp <= self.expire_timestamp, EOrderExpired);
    self.quantity = new_quantity;
}

Function calculate_cancel_refund

Calculate the refund for a canceled order. The refund is any unfilled quantity and the maker fee. If the cancel quantity is not provided, the remaining quantity is used. Cancel quantity is provided when modifying an order, so that the refund can be calculated based on the quantity that’s reduced.

public(friend) fun calculate_cancel_refund(self: &order::Order, maker_fee: u64, cancel_quantity: option::Option<u64>): balances::Balances
Implementation 
public(package) fun calculate_cancel_refund(
    self: &Order,
    maker_fee: u64,
    cancel_quantity: Option<u64>,
): Balances {
    let cancel_quantity = cancel_quantity.get_with_default(
        self.quantity - self.filled_quantity,
    );
    let deep_out = math::mul(
        maker_fee,
        self
            .order_deep_price()
            .deep_quantity(
                cancel_quantity,
                math::mul(cancel_quantity, self.price()),
            ),
    );

    let mut base_out = 0;
    let mut quote_out = 0;
    if (self.is_bid()) {
        quote_out = math::mul(cancel_quantity, self.price());
    } else {
        base_out = cancel_quantity;
    };

    balances::new(base_out, quote_out, deep_out)
}

Function emit_order_canceled

public(friend) fun emit_order_canceled(self: &order::Order, pool_id: object::ID, trader: address, timestamp: u64)
Implementation 
public(package) fun emit_order_canceled(
    self: &Order,
    pool_id: ID,
    trader: address,
    timestamp: u64,
) {
    let is_bid = self.is_bid();
    let price = self.price();
    let remaining_quantity = self.quantity - self.filled_quantity;
    event::emit(OrderCanceled {
        pool_id,
        order_id: self.order_id,
        balance_manager_id: self.balance_manager_id,
        client_order_id: self.client_order_id,
        is_bid,
        trader,
        original_quantity: self.quantity,
        base_asset_quantity_canceled: remaining_quantity,
        timestamp,
        price,
    });
}

Function emit_order_modified

public(friend) fun emit_order_modified(self: &order::Order, pool_id: object::ID, trader: address, timestamp: u64)
Implementation 
public(package) fun emit_order_modified(
    self: &Order,
    pool_id: ID,
    trader: address,
    timestamp: u64,
) {
    let is_bid = self.is_bid();
    let price = self.price();
    event::emit(OrderModified {
        order_id: self.order_id,
        pool_id,
        client_order_id: self.client_order_id,
        balance_manager_id: self.balance_manager_id,
        trader,
        price,
        is_bid,
        new_quantity: self.quantity,
        timestamp,
    });
}

Function copy_order

Copy the order struct.

public(friend) fun copy_order(order: &order::Order): order::Order
Implementation 
public(package) fun copy_order(order: &Order): Order {
    Order {
        order_id: order.order_id,
        balance_manager_id: order.balance_manager_id,
        client_order_id: order.client_order_id,
        quantity: order.quantity,
        filled_quantity: order.filled_quantity,
        fee_is_deep: order.fee_is_deep,
        order_deep_price: order.order_deep_price,
        epoch: order.epoch,
        status: order.status,
        expire_timestamp: order.expire_timestamp,
    }
}

Function set_canceled

Update the order status to canceled.

public(friend) fun set_canceled(self: &mut order::Order)
Implementation 
public(package) fun set_canceled(self: &mut Order) {
    self.status = constants::canceled();
}

Function is_bid

public(friend) fun is_bid(self: &order::Order): bool
Implementation 
public(package) fun is_bid(self: &Order): bool {
    let (is_bid, _, _) = utils::decode_order_id(self.order_id);

    is_bid
}