SuperRoot.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 "FlexVersion.hpp"
#include "EversConfig.hpp"
#include "WICCloneEvers.hpp"
#include "PairCloneEvers.hpp"
#include "Tip3Config.hpp"
#include "bind_info.hpp"
 
namespace tvm {
 
struct SuperRootDetails {
  uint256          pubkey;             
  bool             stop_trade_;        
  bool             abandon_ship_;      
  bool             update_started_;    
  address          owner;              
  address_opt      update_team;        
  cell             global_config_code; 
  uint256          global_config_hash; 
  int8             workchain_id;       
  opt<FlexVersion> version;            
  opt<FlexVersion> beta_version;       
  address_opt      deploying_cfg;      
  address_opt      cur_cfg;            
  address_opt      beta_cfg;           
  address_opt      prev_super_root;    
  address_opt      next_super_root;    
  uint32           revision;           
};
 
__interface ISuperRoot {
 
  [[internal]]
  void onDeploy(
    cell        global_config_code, 
    cell        flex_client_stub,   
    address_opt prev_super_root     
  ) = 10;
 
  [[internal]]
  void update(
    uint128        cfg_deploy_evers, 
    uint128        cfg_keep_evers,   
    FlexVersion    version,          
    address        wrappers_cfg,     
    address        flex,             
    address        user_cfg,         
    string         description       
  ) = 11;
 
  [[internal]]
  void updateConfirmed(
    FlexVersion version 
  ) = 12;
 
  [[internal]]
  void release() = 13;
 
  [[internal]]
  void proxy(
    cell msg,                     
    bool cant_work_during_update, 
    bool starting_update          
  ) = 14;
 
  [[internal, answer_id]]
  address deployWrappersConfig(
    uint128 deploy_evers,            
    uint128 wrappers_cfg_keep_evers, 
    uint32  token_version,           
    cell    wrappers_cfg_code,       
    cell    wic_code                 
  ) = 15;
 
  [[internal, answer_id]]
  address deployFlex(
    uint128        deploy_evers,     
    uint128        keep_evers,       
    PairCloneEvers evers,            
    address_opt    old_flex,         
    uint32         exchange_version, 
    cell           flex_code,        
    cell           xchg_pair_code,   
    cell           xchg_price_code,  
    EversConfig    ev_cfg,           
    uint8          deals_limit       
  ) = 16;
 
  [[internal, answer_id]]
  address deployUserDataConfig(
    uint128     deploy_evers,       
    FlexVersion triplet,            
    bind_info   binding,            
    cell        user_data_cfg_code, 
    cell        flex_client_code,   
    cell        auth_index_code,    
    cell        user_id_index_code  
  ) = 17;
 
  [[internal, answer_id]]
  void cloneWrappersConfig(
    address             wrappers_cfg,           
    uint128             wrapper_cfg_keep_evers, 
    uint128             clone_deploy_evers,     
    WICCloneEvers       wic_evers,              
    uint32              new_token_version,      
    dict_array<address> wrapper_deployers       
  ) = 18;
 
  [[internal]]
  void transfer(
    address to,   
    uint128 evers 
  ) = 19;
 
  [[internal]]
  void transferReserveTokens(
    address wrapper, 
    uint128 tokens,  
    address to       
  ) = 20;
 
  [[internal]]
  void setFlags(
    opt<bool> stop_trade,    
    opt<bool> abandon_ship,  
    opt<bool> update_started 
  ) = 21;
 
  [[internal]]
  void setOwner(
    address owner 
  ) = 22;
 
  [[internal]]
  void setUpdateTeam(
    address_opt team 
  ) = 23;
 
  [[internal]]
  void setNextSuperRoot(
    address next_super_root 
  ) = 24;
 
  [[getter]]
  SuperRootDetails getDetails() = 25;
 
  [[getter]]
  address getGlobalConfig(FlexVersion version) = 26;
 
  [[getter]]
  address getCurrentGlobalConfig() = 27;
};
using ISuperRootPtr = handle<ISuperRoot>;
 
struct DSuperRoot {
  uint256          pubkey_;                
  bool_t           stop_trade_;            
  bool_t           abandon_ship_;          
  bool_t           update_started_;        
  address          owner_;                 
  address_opt      update_team_;           
  optcell          global_config_code_;    
  optcell          flex_client_stub_;      
  int8             workchain_id_;          
  opt<FlexVersion> version_;               
  opt<FlexVersion> beta_version_;          
  address_opt      deploying_cfg_;         
  address_opt      prev_super_root_;       
  address_opt      next_super_root_;       
  uint32           revision_;              
};
 
__interface ESuperRoot {
};
 
template<>
struct preparer<ISuperRoot, DSuperRoot> {
  __always_inline
  static std::pair<StateInit, uint256> execute(DSuperRoot data, cell code) {
    cell data_cl = prepare_persistent_data<ISuperRoot, void>({}, data);
    StateInit init { {}, {}, code, data_cl, {} };
    cell init_cl = build(init).make_cell();
    return { init, uint256(tvm_hash(init_cl)) };
  }
};
 
} // namespace tvm