Truth

TheTruth

Scan On Mobile Wallet To Start ...
257

Users have settled in
预言机源码

TT Oracle Source
opened source on github
// SPDX-License-Identifier: MIT

pragma solidity 0.7.4;
pragma experimental ABIEncoderV2;

import "../permission/ownable.sol";
import "../utils/IERC20.sol";
import "../utils/strings.sol";
import "../utils/safe_math.sol";
import "../utils/bytes32_normalize.sol";
import "../erc721.sol";
import "../ITTOption.sol";
import "../ITruth.sol";
import "../ITruthData.sol";
import "../ITTDataGuessing.sol";

contract tt_game_guessing is
  Ownable
{
  using strings for *;
  using safe_math for uint256;

  uint256 constant  INVALID_OPTION_IDX = 99999999999;    
  uint256 constant  ratio_prediction   = 10000000000;    

  address private the_truth_addr;
  address private the_tt_addr;
  address private tt_data_guessing;
  uint256 private award_ratio;

  // events 
  event on_new_game( uint256 indexed game_guid,     ITTDataGuessing.st_game_round  gameinst ); 
  event on_new_ticket( uint256 indexed ticket_guid, ITTDataGuessing.st_game_ticket ticketinst ); 
  event on_exe_ticket( uint256 indexed ticket_guid, ITTDataGuessing.st_game_ticket ticketinst ); 
  event on_game_owner_withdraw( uint256 indexed game_guid, ITTDataGuessing.st_game_round  gameinst); 


  constructor( 
    address _addr_the_truth,  
    address _tt_addr, 
    address _tt_data_guessing, 
    uint256 _award_ratio
  ) {
    the_truth_addr   = _addr_the_truth;
    the_tt_addr      = _tt_addr; 
    tt_data_guessing = _tt_data_guessing;
    award_ratio      = _award_ratio;
  }

  function create_ticket(
    uint32             bid_idx,
    uint256[] calldata ticketguid_gguid_pwei_gaswei
  )
    external payable
  {
    _create_ticket(
       bid_idx,
       ticketguid_gguid_pwei_gaswei
      );
  }

  function exe_ticket(
    uint256 _tguid
  )
    external 
  {
    _exe_ticket(_tguid);
  }

  function view_game_param()
    external 
    view returns( uint256 ratio_award ) 
  {
    ratio_award = award_ratio;
  }

  function adjust_game_param(
    uint256[] calldata _ratio
  )
    onlyOwner() 
    external 
  {
    award_ratio = _ratio[0];
  }

  function create_game(
    address[] calldata addrcoin_creator,
    uint256[] calldata gguid_expt_begint_minbet_mingas_fund_ratio,
    string[]  calldata tguid_name,
    string[]  calldata bid_options
  )
    external payable
  {
    _create_game(
    addrcoin_creator,
    gguid_expt_begint_minbet_mingas_fund_ratio,
    tguid_name,
    _copy_arra_str(bid_options)
    ); 
  }

  function balances( address coin_address ) public view returns(uint256) {
      if (coin_address == address(0x0)) {
          return (address(this).balance);    
      } else {
          return IERC20(coin_address).balanceOf(address(this));
      }
  }

  function withdraw( address payable recerver, address erc20_addr, uint256 amount ) 
  external 
  onlyOwner() 
  returns(bool res) {
      _transfer_coin (  erc20_addr, amount,  recerver ); 
      res = true;
  }

  function balances_free( address coin_address ) public view returns(uint256) {
      uint256 free_token_cnt = ITTDataGuessing(tt_data_guessing).view_free_amount(coin_address); 
      return free_token_cnt;
  }

  function withdraw_free( address payable recerver, address erc20_addr, uint256 amount ) 
  external 
  onlyOwner() 
  returns(bool res) {
      uint256 free_token_cnt = balances_free(erc20_addr); 
      require( free_token_cnt >= amount ); 
      ITTDataGuessing(tt_data_guessing).modify_free_amount(erc20_addr, free_token_cnt.sub(amount));
      _transfer_coin (  erc20_addr, amount,  recerver ); 
      res = true;
  }

  function game_owner_withdraw(uint256 _game_guid) 
  external
  {
    _game_owner_withdraw(_game_guid); 
  }

  function _create_game(
    address[] calldata addrcoin_creator,
    uint256[] calldata gguid_expt_begint_minbet_mingas_fund_ratio,
    string[]  calldata tguid_name,
    string[]  memory   bid_options 
  )
    internal 
  { 
    require(addrcoin_creator[1] == msg.sender);

    ITTDataGuessing(tt_data_guessing).create_game(addrcoin_creator, gguid_expt_begint_minbet_mingas_fund_ratio, tguid_name, bid_options);

    if (gguid_expt_begint_minbet_mingas_fund_ratio[5] > 0 ) {
      // init funding 
      // transfer 
      _transfer_coin (  addrcoin_creator[0], gguid_expt_begint_minbet_mingas_fund_ratio[5],  address(this)); 

      // modify amount       
      uint256 new_amount = gguid_expt_begint_minbet_mingas_fund_ratio[5].add(ITTDataGuessing(tt_data_guessing).view_global_amount(addrcoin_creator[0]));
      ITTDataGuessing(tt_data_guessing).modify_global_amount(addrcoin_creator[0], new_amount);

      // platform reserved 
      uint256 free_token_cnt = balances_free(addrcoin_creator[0]); 
      uint256 reserved_cnt   = _platform_reserved(gguid_expt_begint_minbet_mingas_fund_ratio[5]);
      ITTDataGuessing(tt_data_guessing).modify_free_amount(addrcoin_creator[0], free_token_cnt.add(reserved_cnt));
    }

    emit on_new_game( 
      gguid_expt_begint_minbet_mingas_fund_ratio[0], 
      ITTDataGuessing(tt_data_guessing).view_game(gguid_expt_begint_minbet_mingas_fund_ratio[0])
      );
  }

  function _get_option_val_in_event(string memory optstr, ITruthData.event_happen memory evt) 
  pure internal 
  returns (string memory retstr)
  {
    retstr = "";
    strings.slice memory s = optstr.toSlice();
    for ( uint256 i = 0 ; i < evt.datakey.length ; i++ ) {
      if (evt.datakey[i].toSlice().equals(s)) {
        retstr = evt.dataval[i];
      }
    }      
  }

  function _get_win_option ( ITTDataGuessing.st_game_round memory game, ITruthData.event_happen memory evt ) 
  internal pure 
  returns (uint256 winopt_idx)
  {
    winopt_idx = INVALID_OPTION_IDX;
    string memory optval;
    for ( uint256 i = 0 ; i < game.bid_options.length ; i++ ) {
      optval = _get_option_val_in_event(game.bid_options[i], evt); 
      if (bytes32_normalize.string_to_uint(optval) == 1) {
        winopt_idx = i; 
      }
    }  
  }

  function _platform_reserved( uint256 amount ) internal view returns ( uint256 ) {
    return amount > 0 ? amount.sub(amount.mul(award_ratio).div(ratio_prediction)) : 0; 
  }

  function _platform_reserved_wei( ITTDataGuessing.st_game_round memory game_inst ) internal view returns(uint256) {
    return _platform_reserved(game_inst.total_amount_pool);
  }

  function _gameowner_reserved_wei( ITTDataGuessing.st_game_round memory game_inst ) internal view returns(uint256) {
    uint256 _platform_reserved_val = _platform_reserved_wei(game_inst);  
    uint256 _avaliable = game_inst.total_amount_pool.sub(_platform_reserved_val);
    return _avaliable.sub(_avaliable.mul(game_inst.award_ratio).div(ratio_prediction));
  }

  function _ticket_win_amount( ITTDataGuessing.st_game_ticket memory ticket, ITruthData.event_happen memory evt ) 
  internal view 
  returns (uint256 win_amount_wei) 
  {
    win_amount_wei = 0;
    ITTDataGuessing.st_game_round memory game_inst = ITTDataGuessing(tt_data_guessing).view_game(ticket.game_guid); 
    uint256 win_option_idx = _get_win_option( game_inst,  evt); 
    if (win_option_idx == ticket.bid_idx) {
      uint256 _platform_reserved_val   = _platform_reserved_wei(game_inst);  
      uint256 _gameowner_resserved = _gameowner_reserved_wei(game_inst);
      uint256 _pool_avaliable      = game_inst.total_amount_pool.sub(_platform_reserved_val).sub(_gameowner_resserved); 
      win_amount_wei = _pool_avaliable.mul(ticket.amount_payed_wei).mul(ratio_prediction).div(game_inst.bid_amount_pool[win_option_idx]).div(ratio_prediction);
    }
  }

  function _game_owner_withdraw(uint256 _game_guid) 
  internal
  {
    require(_game_is_end(_game_guid)); 

    ITTDataGuessing.st_game_round memory game_inst = ITTDataGuessing(tt_data_guessing).view_game(_game_guid); 

    require(game_inst.init_funding > 0 && 
            game_inst.addres_who_create == msg.sender ); 

    uint256 _gameowner_resserved = _gameowner_reserved_wei(game_inst);

    if (_gameowner_resserved > 0) {
      address addr_coin = game_inst.addres_coin_payed;

      // modify amount 
      uint256 new_amount = ITTDataGuessing(tt_data_guessing).view_global_amount(addr_coin).sub(_gameowner_resserved);
      ITTDataGuessing(tt_data_guessing).modify_global_amount(addr_coin, new_amount);

      game_inst.init_funding = 0; 
      ITTDataGuessing(tt_data_guessing).modify_game(game_inst);

      // transfer 
      _transfer_coin (  addr_coin, _gameowner_resserved,  msg.sender);  
    } 

    emit on_game_owner_withdraw( _game_guid, game_inst); 
  }

  function _exe_ticket(
    uint256 _tguid
  )
    internal 
  {
    require(msg.sender == ERC721(tt_data_guessing).ownerOf(_tguid));

    ITTDataGuessing.st_game_ticket memory ticket = ITTDataGuessing(tt_data_guessing).view_nft_ticket(_tguid); 
    uint256 win_amount = 0 ;

    // require game is end 
    require(_game_is_end(ticket.game_guid) && ticket.amount_payed_wei > 0); 
    ITTDataGuessing.st_game_round  memory game_inst = ITTDataGuessing(tt_data_guessing).view_game(ticket.game_guid); 

    // require event is complete 
    {
      ITruthData.event_happen memory evt = ITruth(the_truth_addr).get_event_by_guid(game_inst.truth_guid);
      require( evt.n_progress >= 100 && (evt.n_result_true + evt.n_result_false) > 0 );
      // check event completed 
      require (evt.n_vote_required >= (evt.n_result_true + evt.n_result_false)); 
      require (evt.n_result_true > evt.n_result_false && evt.n_win_required  <= evt.n_result_true); 
      win_amount = _ticket_win_amount(ticket, evt); 
    }

    if (win_amount > 0) { 
      address addr_coin = game_inst.addres_coin_payed;

      // modify amount 
      uint256 new_amount = ITTDataGuessing(tt_data_guessing).view_global_amount(addr_coin).sub(win_amount);
      ITTDataGuessing(tt_data_guessing).modify_global_amount(addr_coin, new_amount);

      // transfer 
      _transfer_coin (  addr_coin, win_amount,  msg.sender);  
    }

    // event 
    emit on_exe_ticket(_tguid, ticket);

    // destroy 
    ITTDataGuessing(tt_data_guessing).destroy_nft_ticket(_tguid);
  }

  function _create_ticket(
    uint32             bid_idx,
    uint256[] calldata ticketguid_gguid_pwei_gaswei
  )
    internal 
  {
    ITTDataGuessing(tt_data_guessing).create_nft_ticket(msg.sender, bid_idx, ticketguid_gguid_pwei_gaswei);

    // require 
    ITTDataGuessing.st_game_round  memory game_inst   = ITTDataGuessing(tt_data_guessing).view_game(ticketguid_gguid_pwei_gaswei[1]); 
    ITTDataGuessing.st_game_ticket memory ticket_inst = ITTDataGuessing(tt_data_guessing).view_nft_ticket(ticketguid_gguid_pwei_gaswei[0]); 

    require (  !_game_is_begin(ticketguid_gguid_pwei_gaswei[1]) && 
              ticketguid_gguid_pwei_gaswei[2] >= game_inst.min_bet_amount && 
              ticketguid_gguid_pwei_gaswei[3] >= game_inst.min_tt_gas ); 

    // transfer 
    _transfer_coin (  game_inst.addres_coin_payed, ticketguid_gguid_pwei_gaswei[2],  address(this) ); 
    _transfer_coin (  the_tt_addr , ticketguid_gguid_pwei_gaswei[3],  address(this) ); 


    // modify amount 
    game_inst.total_amount_pool = game_inst.total_amount_pool.add(ticketguid_gguid_pwei_gaswei[2]);
    game_inst.bid_amount_pool[bid_idx] = game_inst.bid_amount_pool[bid_idx].add(ticketguid_gguid_pwei_gaswei[2]);
    ITTDataGuessing(tt_data_guessing).modify_game(game_inst);

    uint256 new_amount = ticketguid_gguid_pwei_gaswei[2].add(ITTDataGuessing(tt_data_guessing).view_global_amount(game_inst.addres_coin_payed));
    ITTDataGuessing(tt_data_guessing).modify_global_amount(game_inst.addres_coin_payed, new_amount);

    // platform reserved 
    uint256 free_token_cnt = balances_free(game_inst.addres_coin_payed); 
    uint256 reserved_cnt   = _platform_reserved(ticketguid_gguid_pwei_gaswei[2]);
    ITTDataGuessing(tt_data_guessing).modify_free_amount(game_inst.addres_coin_payed, free_token_cnt.add(reserved_cnt)); 

    emit on_new_ticket( ticketguid_gguid_pwei_gaswei[0], ticket_inst ); 
  }

  function _transfer_coin (  address coin_address, uint256 wei_transfer,  address receiver ) 
    internal 
  { 
    require (receiver != address(0x0));

    // transfer 
    if (coin_address == address(0x0)) { 
      if (receiver != address(this)) {
        payable(receiver).transfer(wei_transfer); 
      } else {
        require (msg.value >= wei_transfer);
      }
    } else {
      if (receiver != address(this)) {
        require (IERC20(coin_address).transfer(receiver, wei_transfer));
      } else {
        require (IERC20(coin_address).transferFrom(msg.sender, receiver, wei_transfer)); 
      }
    }  
  }

  function _game_is_begin(uint256 game_guid) internal view returns( bool ) {
      ITTDataGuessing.st_game_round memory game_inst = ITTDataGuessing(tt_data_guessing).view_game(game_guid);
      return (game_inst.begin_time > 0 && game_inst.begin_time < block.timestamp);
  }

  function _game_is_end(uint256 game_guid) internal view returns( bool ) {
      ITTDataGuessing.st_game_round memory game_inst = ITTDataGuessing(tt_data_guessing).view_game(game_guid);
      return (game_inst.exp_time > 0 && game_inst.exp_time < block.timestamp); 
  }

  function _copy_arra_str ( string[] calldata strs ) internal pure returns( string[] memory memstr )  {
      memstr = new string[]( strs.length );
      for ( uint256 i = 0 ; i < strs.length; i++ ) {
          memstr[i] = strs[i];
      }
  }

}
当前进度(Current progress)

社交(Social)
预言机(Oracle)
竞猜游戏(Quiz game)
About

   讨论区(Discussions)
   @TruthToken2021
   [email protected]
   Telegram Channel
   Telegram Chat
TheTruth

257

预言机源码

当前进度(Current progress)

About

合作伙伴(Partner)
