TONTokenWallet.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <tvm/schema/message.hpp>
#include <tvm/sequence.hpp>
#include <tvm/small_dict_map.hpp>
 
#include <tvm/replay_attack_protection/timestamp.hpp>
#include <tvm/smart_switcher.hpp>
#include <tvm/contract_handle.hpp>
 
#include "FlexLendPayloadArgs.hpp"
#include "Tip3Config.hpp"
#include "Tip3Creds.hpp"
#include "bind_info.hpp"
#include "immutable_ids.hpp"
 
namespace tvm {
 
// #define TIP3_ENABLE_EXTERNAL
// #define TIP3_ENABLE_LEND_OWNERSHIP
// #define TIP3_ENABLE_BURN
// #define TIP3_ENABLE_DESTROY
// #define TIP3_ONLY_FLEX_EXTERNAL
 
#if defined(TIP3_ENABLE_EXTERNAL) && !defined(TIP3_ONLY_FLEX_EXTERNAL)
#define TIP3_EXTERNAL [[external]]
#else
#define TIP3_EXTERNAL
#endif
 
#if defined(TIP3_ENABLE_EXTERNAL) || defined(TIP3_ONLY_FLEX_EXTERNAL)
#define FLEX_EXTERNAL [[external]]
#else
#define FLEX_EXTERNAL
#endif
 
static constexpr unsigned TOKEN_WALLET_TIMESTAMP_DELAY = 1800;
using wallet_replay_protection_t = replay_attack_protection::timestamp<TOKEN_WALLET_TIMESTAMP_DELAY>;
 
struct lend_owner_key {
  addr_std_fixed dest;    
};
 
struct lend_owner {
  uint128 lend_balance;     
  uint32  lend_finish_time; 
  uint256 user_pubkey;      
};
using lend_owners_map = small_dict_map<lend_owner_key, lend_owner>;
 
struct lend_owner_array_record {
  lend_owner_key lend_key;         
  uint128        lend_balance;     
  uint32         lend_finish_time; 
};
using lend_owners_array = dict_array<lend_owner_array_record>;
 
struct details_info {
  string            name;              
  string            symbol;            
  uint8             decimals;          
  uint128           balance;           
  uint256           root_pubkey;       
  address           root_address;      
  uint256           wallet_pubkey;     
  address_opt       owner_address;     
  opt<uint256>      lend_pubkey;       
  lend_owners_array lend_owners;       
  uint128           lend_balance;      
  opt<bind_info>    binding;           
  uint256           code_hash;         
  uint16            code_depth;        
  int8              workchain_id;      
};
 
__interface ITONTokenWalletNotify {
 
  [[internal, answer_id]]
  bool onTip3LendOwnership(
    uint128     balance,          
    uint32      lend_finish_time, 
    Tip3Creds   creds,            
    cell        payload,          
    address     answer_addr       
  ) = 201;
 
  [[internal, answer_id]]
  bool onTip3Transfer(
    uint128        balance,       
    uint128        new_tokens,    
    uint128        evers_balance, 
    Tip3Config     tip3cfg,       
    opt<Tip3Creds> sender,        
    Tip3Creds      receiver,      
    cell           payload,       
    address        answer_addr    
  ) = 202;
};
using ITONTokenWalletNotifyPtr = handle<ITONTokenWalletNotify>;
 
__interface ITONTokenWallet {
 
  TIP3_EXTERNAL
  [[internal, answer_id]]
  void transfer(
    address_opt answer_addr,      
    address     to,               
    uint128     tokens,           
    uint128     evers,            
    uint128     return_ownership, 
    opt<cell>   notify_payload    
  ) = 10;
 
  TIP3_EXTERNAL
  [[internal, answer_id]]
  void transferToRecipient(
    address_opt answer_addr,      
    Tip3Creds   to,               
    uint128     tokens,           
    uint128     evers,            
    uint128     keep_evers,       
    bool        deploy,           
    uint128     return_ownership, 
    opt<cell>   notify_payload    
  ) = 11;
 
  [[internal, answer_id]]
  uint128 balance() = 12;
 
  [[internal]]
  void acceptMint(
    uint128 _value,          
    address answer_addr,     
    uint128 keep_evers,      
    opt<cell> notify_payload 
  ) = 0x4384F298;
 
  [[internal]]
  void acceptTransfer(
    uint128     _value,        
    address     answer_addr,   
    uint128     keep_evers,    
    uint256     sender_pubkey, 
    address_opt sender_owner,  
    opt<cell>   payload        
  ) = 0x67A0B95F;
 
#ifdef TIP3_ENABLE_DESTROY
  TIP3_EXTERNAL
  [[internal]]
  void destroy(
    address dest 
  ) = 13;
#endif // TIP3_ENABLE_DESTROY
 
#ifdef TIP3_ENABLE_BURN
  [[internal, answer_id]]
  void burn(
    uint256     out_pubkey, 
    address_opt out_owner,  
    opt<cell>   notify      
  ) = 14;
 
  [[internal, answer_id]]
  void unwrap(
    uint256     out_pubkey, 
    address_opt out_owner,  
    uint128     tokens,     
    opt<cell>   notify      
  ) = 15;
#endif // TIP3_ENABLE_BURN
 
#ifdef TIP3_ENABLE_LEND_OWNERSHIP
  FLEX_EXTERNAL
  [[internal, answer_id]]
  void makeOrder(
    address_opt answer_addr,         
    uint128     evers,               
    uint128     lend_balance,        
    uint32      lend_finish_time,    
    uint128     price_num,           
    cell        unsalted_price_code, 
    cell        salt,                
    FlexLendPayloadArgs args         
  ) = 16;
 
  FLEX_EXTERNAL
  [[internal]]
  void cancelOrder(
    uint128      evers,       
    address      price,       
    bool         sell,        
    opt<uint256> order_id     
  ) = 17;
 
  [[internal]]
  void returnOwnership(
    uint128 tokens 
  ) = 18;
 
  [[internal]]
  void bind(
    bool             set_binding, 
    opt<bind_info>   binding,     
    bool             set_trader,  
    opt<uint256>     trader       
  ) = 19;
#endif // TIP3_ENABLE_LEND_OWNERSHIP
 
  [[internal, answer_id]]
  details_info details() = 20;
 
  // =============================== getters =============================== //
  [[getter]]
  details_info getDetails() = immutable_ids::wallet_get_details_id;
 
#ifdef TIP3_ENABLE_EXTERNAL
  [[getter]]
  uint128 getBalance() = 22;
#endif // TIP3_ENABLE_EXTERNAL
};
using ITONTokenWalletPtr = handle<ITONTokenWallet>;
 
struct DTONTokenWallet {
  string           name_;          
  string           symbol_;        
  uint8            decimals_;      
  uint128          balance_;       
  uint256          root_pubkey_;   
  address          root_address_;  
  uint256          wallet_pubkey_; 
  address_opt      owner_address_; 
#ifdef TIP3_ENABLE_LEND_OWNERSHIP
  opt<uint256>     lend_pubkey_;   
  lend_owners_map  lend_owners_;   
  opt<bind_info>   binding_;       
#endif // TIP3_ENABLE_LEND_OWNERSHIP
  uint256 code_hash_;              
  uint16  code_depth_;             
  int8    workchain_id_;           
};
 
struct DTONTokenWalletExternal {
  string      name_;              
  string      symbol_;            
  uint8       decimals_;          
  uint128     balance_;           
  uint256     root_pubkey_;       
  address     root_address_;      
  uint256     wallet_pubkey_;     
  address_opt owner_address_;     
  uint256     code_hash_;         
  uint16      code_depth_;        
  int8        workchain_id_;      
};
 
struct DTONTokenWalletInternal {
  string       name_;            
  string       symbol_;          
  uint8        decimals_;        
  uint128      balance_;         
  uint256      root_pubkey_;     
  address      root_address_;    
  uint256      wallet_pubkey_;   
  address_opt  owner_address_;   
  opt<uint256> lend_pubkey_;     
  lend_owners_map lend_owners_;  
  opt<bind_info>  binding_;      
  uint256         code_hash_;    
  uint16          code_depth_;   
  int8            workchain_id_; 
};
 
struct ETONTokenWallet {
};
 
inline
DTONTokenWallet prepare_wallet_data(
  string name, string symbol, uint8 decimals,
  uint256 root_pubkey, address root_address,
  uint256 wallet_pubkey, address_opt wallet_owner,
  uint256 code_hash, uint16 code_depth, int8 workchain_id
) {
  return {
    name, symbol, decimals,
    uint128(0), root_pubkey, root_address,
    wallet_pubkey, wallet_owner,
#ifdef TIP3_ENABLE_LEND_OWNERSHIP
    {}, {}, {},
#endif
    code_hash, code_depth,
    workchain_id
  };
}
 
__always_inline
uint256 calc_wallet_init_hash(
  string name, string symbol, uint8 decimals,
  uint256 root_pubkey, address root_address, uint256 wallet_pubkey, address_opt wallet_owner,
  uint256 code_hash, uint16 code_depth, int8 workchain_id
) {
  DTONTokenWallet wallet_data =
    prepare_wallet_data(name, symbol, decimals, root_pubkey, root_address, wallet_pubkey, wallet_owner,
                        code_hash, code_depth, workchain_id);
  auto init_hdr = persistent_data_header<ITONTokenWallet, wallet_replay_protection_t>::init();
  cell data_cl = prepare_persistent_data<ITONTokenWallet, wallet_replay_protection_t>(init_hdr, wallet_data);
  return tvm_state_init_hash(code_hash, uint256(tvm_hash(data_cl)), code_depth, uint16(data_cl.cdepth()));
}
 
__always_inline
uint256 calc_ext_wallet_init_hash(
  string name, string symbol, uint8 decimals,
  uint256 root_pubkey, address root_address, uint256 wallet_pubkey, address_opt wallet_owner,
  uint256 code_hash, uint16 code_depth, int8 workchain_id
) {
  DTONTokenWalletExternal wallet_data {
    name, symbol, decimals,
    uint128(0), root_pubkey, root_address, wallet_pubkey, wallet_owner,
    code_hash, code_depth, workchain_id
  };
  auto init_hdr = persistent_data_header<ITONTokenWallet, wallet_replay_protection_t>::init();
  cell data_cl = prepare_persistent_data<ITONTokenWallet, wallet_replay_protection_t>(init_hdr, wallet_data);
  return tvm_state_init_hash(code_hash, uint256(tvm_hash(data_cl)), code_depth, uint16(data_cl.cdepth()));
}
 
__always_inline
uint256 calc_int_wallet_init_hash(
  Tip3Config tip3cfg, uint256 wallet_pubkey, address_opt wallet_owner,
  uint256 code_hash, uint16 code_depth, int8 workchain_id
) {
  DTONTokenWalletInternal wallet_data {
    tip3cfg.name, tip3cfg.symbol, tip3cfg.decimals,
    uint128(0), tip3cfg.root_pubkey, tip3cfg.root_address, wallet_pubkey, wallet_owner,
    {}, {}, {}, code_hash, code_depth, workchain_id
  };
  auto init_hdr = persistent_data_header<ITONTokenWallet, wallet_replay_protection_t>::init();
  cell data_cl = prepare_persistent_data<ITONTokenWallet, wallet_replay_protection_t>(init_hdr, wallet_data);
  return tvm_state_init_hash(code_hash, uint256(tvm_hash(data_cl)), code_depth, uint16(data_cl.cdepth()));
}
 
inline
std::pair<StateInit, uint256> prepare_wallet_state_init_and_addr(DTONTokenWallet wallet_data, cell code) {
  auto init_hdr = persistent_data_header<ITONTokenWallet, wallet_replay_protection_t>::init();
  cell wallet_data_cl =
    prepare_persistent_data<ITONTokenWallet, wallet_replay_protection_t>(init_hdr, wallet_data);
  StateInit wallet_init {
    /*split_depth*/{}, /*special*/{},
    code, wallet_data_cl, /*library*/{}
  };
  cell wallet_init_cl = build(wallet_init).make_cell();
  return { wallet_init, uint256(tvm_hash(wallet_init_cl)) };
}
 
inline
std::pair<StateInit, uint256> prepare_external_wallet_state_init_and_addr(
  string name, string symbol, uint8 decimals,
  uint256 root_pubkey, address root_address,
  uint256 wallet_pubkey, address_opt wallet_owner,
  uint256 code_hash, uint16 code_depth,
  int8 workchain_id, cell code
) {
  DTONTokenWalletExternal wallet_data {
    name, symbol, decimals,
    uint128(0), root_pubkey, root_address, wallet_pubkey, wallet_owner,
    code_hash, code_depth, workchain_id
  };
  cell wallet_data_cl =
    prepare_persistent_data<ITONTokenWallet, wallet_replay_protection_t, DTONTokenWalletExternal>(
      wallet_replay_protection_t::init(), wallet_data);
  StateInit wallet_init {
    /*split_depth*/{}, /*special*/{},
    code, wallet_data_cl, /*library*/{}
  };
  cell wallet_init_cl = build(wallet_init).make_cell();
  return { wallet_init, uint256(tvm_hash(wallet_init_cl)) };
}
 
inline
std::pair<StateInit, uint256> prepare_internal_wallet_state_init_and_addr(
  string name, string symbol, uint8 decimals,
  uint256 root_pubkey, address root_address,
  uint256 wallet_pubkey, address_opt wallet_owner,
  uint256 code_hash, uint16 code_depth,
  int8 workchain_id, cell code
) {
  DTONTokenWalletInternal wallet_data {
    name, symbol, decimals,
    uint128(0), root_pubkey, root_address, wallet_pubkey, wallet_owner,
    {}, {}, {}, code_hash, code_depth, workchain_id
  };
  cell wallet_data_cl =
    prepare_persistent_data<ITONTokenWallet, wallet_replay_protection_t, DTONTokenWalletInternal>(
      wallet_replay_protection_t::init(), wallet_data
      );
  StateInit wallet_init {
    /*split_depth*/{}, /*special*/{},
    code, wallet_data_cl, /*library*/{}
  };
  cell wallet_init_cl = build(wallet_init).make_cell();
  return { wallet_init, uint256(tvm_hash(wallet_init_cl)) };
}
 
} // namespace tvm