Flex.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <tvm/schema/message.hpp>
#include <tvm/smart_switcher.hpp>
#include <tvm/contract_handle.hpp>
#include <tvm/replay_attack_protection/timestamp.hpp>
#include "PriceCommon.hpp"
#include "FlexWallet.hpp"
#include "EversConfig.hpp"
#include "FlexSalt.hpp"
#include "PairCloneEvers.hpp"
#include "XchgPair.hpp"
#include "immutable_ids.hpp"
 
namespace tvm {
 
__interface IFlexNotify {
  [[internal]]
  void onXchgDealCompleted(
    bool       seller_is_taker, 
    address    pair,            
    address    tip3root_major,  
    address    tip3root_minor,  
    Tip3Config major_tip3cfg,   
    Tip3Config minor_tip3cfg,   
    uint128    price_num,       
    uint128    price_denum,     
    uint128    amount           
  ) = 10;
  [[internal]]
  void onXchgOrderAdded(
    bool    sell,           
    address tip3root_major, 
    address tip3root_minor, 
    uint128 price_num,      
    uint128 price_denum,    
    uint128 amount,         
    uint128 sum_amount      
  ) = 11;
  [[internal]]
  void onXchgOrderCanceled(
    bool    sell,           
    address tip3root_major, 
    address tip3root_minor, 
    uint128 price_num,      
    uint128 price_denum,    
    uint128 amount,         
    uint128 sum_amount      
  ) = 12;
};
using IFlexNotifyPtr = handle<IFlexNotify>;
 
struct FlexOwnershipInfo {
  uint256     deployer_pubkey;       
  string      ownership_description; 
  address_opt owner; 
};
 
struct FlexDetails {
  cell        xchg_pair_code;           
  uint256     unsalted_price_code_hash; 
  address_opt first_pair;               
  address_opt last_pair;                
  uint32      pairs_count;              
};
 
struct PairsRange {
  address_opt first_pair;               
  address_opt last_pair;                
};
 
__interface IFlex {
 
  [[internal, deploy]]
  resumable<void> onDeploy(
    uint128        flex_keep_evers,   
    PairCloneEvers evers,             
    address_opt    old_flex           
  ) = immutable_ids::flex_on_deploy_id;
 
  [[internal, answer_id]]
  address addXchgPair(
    PairCloneEvers evers,       
    Tip3Config major_tip3cfg,   
    Tip3Config minor_tip3cfg,   
    uint128    min_amount,      
    uint128    minmove,         
    uint128    price_denum,     
    address    notify_addr      
    ) = immutable_ids::flex_register_xchg_pair_id;
 
  [[internal]]
  void unlistXchgPair(
    address pair 
  );
 
  [[internal, answer_id]]
  PairsRange requestPairs() = immutable_ids::flex_request_pairs_id;
  // ========== getters ==========
 
  [[getter]]
  FlexSalt getConfig() = 20;
 
  [[getter]]
  FlexDetails getDetails() = 21;
 
  [[getter]]
  address getXchgTradingPair(address tip3_major_root, address tip3_minor_root) = 22;
 
  [[getter]]
  uint128 calcLendTokensForOrder(bool sell, uint128 major_tokens, price_t price) = 23;
};
using IFlexPtr = handle<IFlex>;
 
struct DFlex {
  uint32      exchange_version_; 
  // ^^^ Fields defined at deploy (used for address calculation) ^^^
  int8          workchain_id_;    
  optcell       xchg_pair_code_;  
  address_opt   first_pair_;      
  address_opt   last_pair_;       
  uint32        pairs_count_;     
  uint128       flex_keep_evers_; 
  address_opt   it_;              
  address_opt   prev_clone_;      
  address_opt   next_;            
  address_opt   notify_addr_;     
  uint128       min_amount_;      
  uint128       minmove_;         
  uint128       price_denum_;     
  opt<Tip3Config> major_tip3cfg_; 
  opt<Tip3Config> minor_tip3cfg_; 
};
 
__interface EFlex {
};
 
template<>
struct preparer<IFlex, DFlex> {
  __always_inline
  static std::pair<StateInit, uint256> execute(DFlex data, cell code) {
    cell data_cl = prepare_persistent_data<IFlex, void>({}, data);
    StateInit init { {}, {}, code, data_cl, {} };
    cell init_cl = build(init).make_cell();
    return { init, uint256(tvm_hash(init_cl)) };
  }
};
 
} // namespace tvm