process_queue_state.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "../PriceXchg.hpp"
 
#include "error_code.hpp"
#include <tvm/suffixes.hpp>
 
namespace tvm { namespace xchg {
 
class process_queue_state {
public:
  static constexpr unsigned msgs_per_deal = 4;               
  static constexpr unsigned msgs_per_expired = 1;            
  static constexpr unsigned msgs_per_out_of_evers = 2;       
  static constexpr unsigned msgs_per_no_post_order_done = 2; 
 
  process_queue_state(
    price_t        price,          
    address        pair,           
    Tip3Config     major_tip3cfg,  
    Tip3Config     minor_tip3cfg,  
    EversConfig    ev_cfg,         
    uint128        min_amount,     
    unsigned       deals_limit,    
    unsigned       msgs_limit,     
    IFlexNotifyPtr notify_addr,    
    unsigned       sell_idx,       
    unsigned       buy_idx         
  ) : price_(price), pair_(pair), major_tip3cfg_(major_tip3cfg), minor_tip3cfg_(minor_tip3cfg),
      ev_cfg_(ev_cfg), min_amount_(min_amount), deals_limit_(deals_limit), msgs_limit_(msgs_limit),
      tip3root_major_(major_tip3cfg.root_address), tip3root_minor_(minor_tip3cfg.root_address), notify_addr_(notify_addr),
      sell_idx_(sell_idx), buy_idx_(buy_idx) {}
 
  void on_expired(OrderInfoXchgWithIdx ord_idx, bool sell) {
    auto ord = ord_idx.second;
    ++expired_;
    // For the first expired order we also registering one message for amm notification
    if (sell) {
      msgs_outs_ += (sell_cancels_amount_ ? msgs_per_expired : msgs_per_expired + 1);
      sell_cancels_amount_ += ord.amount;
    } else {
      msgs_outs_ += (buy_cancels_amount_ ? msgs_per_expired : msgs_per_expired + 1);
      buy_cancels_amount_ += ord.amount;
    }
    OrderRet ret { uint32(ec::expired), ord.original_amount - ord.amount, 0u128, price_.num, price_.denum,
                   ord.user_id, ord.order_id, pair_, major_tip3cfg_.decimals, minor_tip3cfg_.decimals, sell };
    IPriceCallbackPtr(ord.tip3_wallet_provide)(Evers(ord.account.get())).
      onOrderFinished(ret);
  }
 
  void on_out_of_evers(OrderInfoXchgWithIdx ord_idx, bool sell) {
    auto ord = ord_idx.second;
    ++out_of_evers_;
    // For the first expired order we also registering one message for amm notification
    if (sell) {
      msgs_outs_ += (sell_cancels_amount_ ? msgs_per_out_of_evers : msgs_per_out_of_evers + 1);
      sell_cancels_amount_ += ord.amount;
    } else {
      msgs_outs_ += (buy_cancels_amount_ ? msgs_per_out_of_evers : msgs_per_out_of_evers + 1);
      buy_cancels_amount_ += ord.amount;
    }
 
    OrderRet ret { uint32(ec::out_of_tons), ord.original_amount - ord.amount, 0u128, price_.num, price_.denum,
                   ord.user_id, ord.order_id, pair_, major_tip3cfg_.decimals, minor_tip3cfg_.decimals, sell };
    check_ret(sell, ord_idx.first, ret);
    if (ord.account > ev_cfg_.return_ownership) {
      ord.account -= ev_cfg_.return_ownership;
      ITONTokenWalletPtr(ord.tip3_wallet_provide)(Evers(ev_cfg_.return_ownership.get())).
        returnOwnership(ord.lend_amount);
      IPriceCallbackPtr(ord.tip3_wallet_provide)(Evers(ord.account.get())).
        onOrderFinished(ret);
    }
  }
 
  void on_order_done(OrderInfoXchgWithIdx ord_idx, bool sell) {
    auto ord = ord_idx.second;
    OrderRet ret { uint32(ok), ord.original_amount - ord.amount, 0u128, price_.num, price_.denum,
                   ord.user_id, ord.order_id, pair_, major_tip3cfg_.decimals, minor_tip3cfg_.decimals, sell };
    check_ret(sell, ord_idx.first, ret);
    IPriceCallbackPtr(ord.tip3_wallet_provide)(Evers(ord.account.get())).
      onOrderFinished(ret);
  }
 
  void on_no_post_order_done(OrderInfoXchgWithIdx ord_idx, bool sell) {
    auto ord = ord_idx.second;
    ++no_post_order_dones_;
    // For the first partially done no-post order we also registering one message for amm notification
    if (sell) {
      msgs_outs_ += (sell_cancels_amount_ ? msgs_per_no_post_order_done : msgs_per_no_post_order_done + 1);
      sell_cancels_amount_ += ord.amount;
    } else {
      msgs_outs_ += (buy_cancels_amount_ ? msgs_per_no_post_order_done : msgs_per_no_post_order_done + 1);
      buy_cancels_amount_ += ord.amount;
    }
 
    OrderRet ret { uint32(ec::no_post_order_partially_done), ord.original_amount - ord.amount, 0u128, price_.num, price_.denum,
                   ord.user_id, ord.order_id, pair_, major_tip3cfg_.decimals, minor_tip3cfg_.decimals, sell };
    check_ret(sell, ord_idx.first, ret);
    if (ord.account > ev_cfg_.return_ownership) {
      ord.account -= ev_cfg_.return_ownership;
      ITONTokenWalletPtr(ord.tip3_wallet_provide)(Evers(ev_cfg_.return_ownership.get())).
        returnOwnership(ord.lend_amount);
      IPriceCallbackPtr(ord.tip3_wallet_provide)(Evers(ord.account.get())).
        onOrderFinished(ret);
    }
  }
 
  void check_ret(bool sell, unsigned idx, OrderRet ret) {
    if (sell && sell_idx_ == idx)
      ret_ = ret;
    if (!sell && buy_idx_ == idx)
      ret_ = ret;
  }
 
  void on_deal(bool seller_taker, uint128 deal_amount) {
    ++deals_processed_;
    sum_deals_amount_ += deal_amount;
    if (seller_taker)
      sum_taker_sells_amount_ += deal_amount;
    else
      sum_taker_buys_amount_ += deal_amount;
  }
 
  bool is_order_done(OrderInfoXchg ord) const {
    return (ord.amount == 0) || (ord.amount < min_amount_) || !minor_cost(ord.amount, price_);
  }
 
  bool overlimit() const {
    return deals_processed_ >= deals_limit_ || msgs_outs_ >= msgs_limit_;
  }
 
  void finalize(uint128 rest_sell_amount, uint128 rest_buy_amount) {
    if (sum_deals_amount_) {
      bool seller_taker = sum_taker_sells_amount_ > sum_taker_buys_amount_;
      notify_addr_(Evers(ev_cfg_.send_notify.get())).
        onXchgDealCompleted(seller_taker, pair_,
                            tip3root_major_, tip3root_minor_,
                            major_tip3cfg_, minor_tip3cfg_,
                            price_.numerator(), price_.denominator(), sum_deals_amount_);
    }
    if (sell_cancels_amount_) {
      notify_addr_(Evers(ev_cfg_.send_notify.get())).
        onXchgOrderCanceled(true, tip3root_major_, tip3root_minor_,
                            price_.numerator(), price_.denominator(), sell_cancels_amount_, rest_sell_amount);
    }
    if (buy_cancels_amount_) {
      notify_addr_(Evers(ev_cfg_.send_notify.get())).
        onXchgOrderCanceled(false, tip3root_major_, tip3root_minor_,
                            price_.numerator(), price_.denominator(), buy_cancels_amount_, rest_buy_amount);
    }
  }
 
  price_t     price_;                  
  address     pair_;                   
  Tip3Config  major_tip3cfg_;          
  Tip3Config  minor_tip3cfg_;          
  EversConfig ev_cfg_;                 
  uint128     expired_;                
  uint128     out_of_evers_;           
  uint128     no_post_order_dones_;    
  uint128     deals_processed_;        
  uint128     msgs_outs_;              
  uint128     sum_deals_amount_;       
  uint128     sum_taker_sells_amount_; 
  uint128     sum_taker_buys_amount_;  
  uint128     sell_cancels_amount_;    
  uint128     buy_cancels_amount_;     
  uint128     min_amount_;             
  unsigned    deals_limit_;            
  unsigned    msgs_limit_;             
  address     tip3root_major_;         
  address     tip3root_minor_;         
  IFlexNotifyPtr notify_addr_;         
  unsigned    sell_idx_;               
  unsigned    buy_idx_;                
  opt<OrderRet> ret_;                  
};
 
}} // namespace tvm::xchg