WrappersConfig.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 "WICCloneEvers.hpp"
 
namespace tvm {
 
struct WrappersConfigSalt {
  address super_root; 
  cell    wic_code;   
};
 
struct WrappersConfigDetails {
  uint32              token_version;     
  dict_array<address> wrapper_deployers; 
  address_opt         first_wic;         
  address_opt         last_wic;          
  uint32              wic_count;         
  uint256             salted_wic_hash;   
};
 
struct WrapperDeployer {
  address deployer;          
  uint256 wrapper_code_hash; 
  uint256 wallet_code_hash;  
};
 
__interface IWrappersConfig {
 
  [[deploy, internal]]
  void onDeploy(
    uint128             keep_evers,        
    opt<WICCloneEvers>  evers,             
    opt<uint32>         old_token_version, 
    dict_array<address> wrapper_deployers, 
    address_opt         first_wic,         
    address_opt         last_wic,          
    uint32              wic_count          
  );
 
  [[internal]]
  void onWICsCloned(
    address_opt first_wic, 
    address_opt last_wic,  
    uint32      wic_count  
  );
 
  [[internal]]
  void addWrapperType(
    uint128 keep_evers,      
    uint8   type,            
    address wrapper_deployer 
  );
 
  [[internal]]
  void addWrapper(
    uint128       keep_evers, 
    WICCloneEvers evers,      
    string        symbol,     
    uint8         type,       
    cell          init_args   
  );
 
  [[internal]]
  void unlistWrapper(
    address wic 
  );
 
  [[internal, answer_id]]
  address cloneUpgrade(
    address_opt         answer_addr,        
    uint128             keep_evers,         
    uint128             clone_deploy_evers, 
    WICCloneEvers       evers,              
    uint32              new_token_version,  
    dict_array<address> wrapper_deployers   
  );
 
  [[getter]]
  WrappersConfigDetails getDetails();
 
  [[getter]]
  WrappersConfigSalt getConfig();
};
using IWrappersConfigPtr = handle<IWrappersConfig>;
 
struct DWrappersConfig {
  uint32              token_version_;     
  // ^^^ Fields defined at deploy (used for address calculation) ^^^
  bool_t              deployed_;          
  uint128             keep_evers_;        
  int8                workchain_id_;      
  dict_array<address> wrapper_deployers_; 
  address_opt         first_wic_;         
  address_opt         last_wic_;          
  uint32              wic_count_;         
};
 
__interface EWrappersConfig {
};
 
template<>
struct preparer<IWrappersConfig, DWrappersConfig> {
  __always_inline
  static std::pair<StateInit, uint256> execute(DWrappersConfig data, cell code) {
    cell data_cl = prepare_persistent_data<IWrappersConfig, void>({}, data);
    StateInit init { {}, {}, code, data_cl, {} };
    cell init_cl = build(init).make_cell();
    return { init, uint256(tvm_hash(init_cl)) };
  }
};
 
template<>
struct expecter<IWrappersConfig, DWrappersConfig> {
  __always_inline
  static uint256 execute(DWrappersConfig data, uint256 code_hash, uint16 code_depth) {
    cell data_cl = prepare_persistent_data<IWrappersConfig, void>({}, data);
    return tvm_state_init_hash(code_hash, uint256(tvm_hash(data_cl)), code_depth, uint16(data_cl.cdepth()));
  }
};
 
} // namespace tvm