File 1 of 1: MEXPToken.sol
pragma solidity 0.5.16;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
contract owned {
address payable public owner;
address payable private newOwner;
address public signer;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
signer = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlySigner {
require(msg.sender == signer);
_;
}
function changeSigner(address _signer) public onlyOwner {
signer = _signer;
}
function transferOwnership(address payable _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
interface niftyMoji
{
function ownerOf(uint256 tokenId) external view returns (address);
function powerNLucks(uint256 tokenID) external view returns(uint256, uint256);
function totalSupply() external view returns(uint256);
}
contract MEXPToken is owned {
using SafeMath for uint256;
uint256 public withdrawnByAdmin;
string public constant name = "MOJI Experience Points";
string public constant symbol = "MEXP";
uint256 public constant decimals = 18;
uint256 public totalSupply;
uint256 public burnTracker;
uint256 public mintingMultiplier=10000;
address public niftyMojiContractAddress = 0xde544E54a330Abd1eA8a0E6693D46BFe95D9A684;
uint256 public battleFees=1;
uint256 public mintTokenFee = 0.001 ether;
uint256 public battleWinReward= 10**18;
uint256 public battleLooseReward = 10**17;
uint256 public maxBattlePerDay=10;
bool public globalHalt;
uint256 public lastFinishedIndex;
mapping (address => uint256) public balanceOf;
mapping(uint256 => uint256) public totalMintedForTokenId;
mapping(uint256 => uint256) public totalMintedByOwnerForTokenID;
mapping(uint256 => uint256) public totalMintedByUserForTokenID;
mapping(uint256 => uint256) public totalMintedByBattleForTokenID;
mapping(uint256 => uint256) public dayTracker;
mapping (address => mapping (address => uint256)) public allowance;
mapping(address => uint256) public BattleCountEndTime;
mapping (address => uint256) public userBattleCount;
mapping(address => bool) public blackListedUser;
mapping(uint256 => bool) public blackListedToken;
struct battleInfo
{
uint256 tokenID;
uint256 userSeed;
uint256 rewardAmount;
uint256 blockNo;
uint256 opponentTokenID;
}
battleInfo[] public battleInfos;
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed indexed from, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value );
function _transfer(address _from, address _to, uint _value) internal {
require(!globalHalt, "paused by admin");
require (_to != address(0x0));
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
emit Transfer(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool success) {
require(!blackListedUser[msg.sender], "you are not allowed");
_transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(!blackListedUser[msg.sender], "you are not allowed");
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
require(!blackListedUser[msg.sender], "you are not allowed");
require(!globalHalt, "paused by admin");
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
constructor() public
{
battleInfo memory temp;
battleInfos.push(temp);
}
function () payable external {}
function burn(uint256 _value) public returns (bool success) {
require(!globalHalt, "paused by admin");
require(!blackListedUser[msg.sender], "you are not allowed");
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
burnTracker = burnTracker.add(_value);
emit Transfer(msg.sender, address(0), _value);
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(!globalHalt, "paused by admin");
require(!blackListedUser[msg.sender], "you are not allowed");
balanceOf[_from] = balanceOf[_from].sub(_value);
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
burnTracker = burnTracker.add(_value);
emit Transfer(_from, address(0), _value);
emit Burn(_from, _value);
return true;
}
function mintTokenOwnerOnly(address user, uint256 _tokenID, uint256 tokenAmount) public onlyOwner returns(bool)
{
require(user != address(this) && user != address(0), "invalid address" );
require(tokenAmount > 0 , "Invalid token to mint");
require(!blackListedToken[_tokenID], "this token is blacklisted");
if(_tokenID != 0)
{
require(niftyMoji(niftyMojiContractAddress).ownerOf(_tokenID) == user,"user is not the owner of this tokenID");
totalMintedForTokenId[_tokenID] = totalMintedForTokenId[_tokenID].add(tokenAmount);
totalMintedByOwnerForTokenID[_tokenID] = totalMintedByOwnerForTokenID[_tokenID].add(tokenAmount);
}
totalSupply = totalSupply.add(tokenAmount);
balanceOf[user] = balanceOf[user].add(tokenAmount);
emit Transfer(address(0),user,tokenAmount);
return true;
}
function blackListUser(address user) public onlyOwner returns(bool)
{
blackListedUser[user] = true;
return true;
}
function removeUserFromBlackList(address user) public onlyOwner returns(bool)
{
blackListedUser[user] = false;
return true;
}
function blackListToken(uint256 _tokenID) public onlyOwner returns(bool)
{
blackListedToken[_tokenID] = true;
return true;
}
function removeTokenFromBlackList(uint256 _tokenID) public onlyOwner returns(bool)
{
blackListedToken[_tokenID] = false;
return true;
}
function mintToken(uint256 _tokenID) public payable returns(bool) {
require(!globalHalt, "paused by admin");
address caller = niftyMoji(niftyMojiContractAddress).ownerOf(_tokenID);
require(!blackListedUser[caller], "you are not allowed");
require(!blackListedToken[_tokenID], "this token is blacklisted");
require(caller == msg.sender,"caller is not the owner of this tokenID");
require(msg.value >= mintTokenFee, 'Not enough token minting fee');
uint256 dt = dayTracker[_tokenID];
if (dt != 0)
{
uint256 secPassed = now - dt ;
require(secPassed > 0 , "already minted for the day");
(,uint256 luckPercent ) = niftyMoji(niftyMojiContractAddress).powerNLucks(_tokenID);
uint256 mintAmount = (( (mintingMultiplier * (10 ** 18) * ((luckPercent + 9 ) / 10 ) ) / 100000 ) / 86400 ) * secPassed ;
dayTracker[_tokenID] = now ;
totalMintedByUserForTokenID[_tokenID] = totalMintedByUserForTokenID[_tokenID].add(mintAmount);
totalMintedForTokenId[_tokenID] = totalMintedForTokenId[_tokenID].add(mintAmount);
totalSupply = totalSupply.add(mintAmount);
balanceOf[caller] = balanceOf[caller].add(mintAmount);
emit Transfer(address(0),caller,mintAmount);
}
else
{
dayTracker[_tokenID] = now;
}
owner.transfer(msg.value);
return true;
}
function viewAmountIfIMintNow(uint256 _tokenID) public view returns(uint256 amount)
{
uint256 dt = dayTracker[_tokenID];
if (dt != 0)
{
uint256 secPassed = now - dt ;
(,uint256 luckPercent ) = niftyMoji(niftyMojiContractAddress).powerNLucks(_tokenID);
amount = (( (mintingMultiplier * (10 ** 18) * ((luckPercent + 9 ) / 10 ) ) / 100000 ) / 86400 ) * secPassed ;
return amount;
}
else
{
return (0);
}
}
function setMaxBattlePerDay(uint _maxBattlePerDay) public onlyOwner returns (bool)
{
maxBattlePerDay = _maxBattlePerDay;
return true;
}
event initiateBattleEv(address caller,uint256 _tokenID,uint256 _userSeed,uint256 battleInfoIndex, uint256 blockNo);
function initiateBattle(uint256 _tokenID, uint256 _userSeed) public payable returns (uint256 battleID)
{
require(!globalHalt, "paused by admin");
require(msg.value == battleFees, "Invalid fees amount");
address caller = niftyMoji(niftyMojiContractAddress).ownerOf(_tokenID);
require(!blackListedUser[caller], "you are not allowed");
require(!blackListedToken[_tokenID], "this token is blacklisted");
require(caller == msg.sender,"caller is not the owner of this tokenID");
require( userBattleCount[caller] <= maxBattlePerDay, "enough for the day");
if(BattleCountEndTime[caller] >= now )
{
userBattleCount[caller] += 1;
}
else
{
BattleCountEndTime[caller] = now + 86400;
userBattleCount[caller] = 1;
}
battleInfo memory temp;
temp.tokenID = _tokenID;
temp.userSeed = _userSeed;
temp.blockNo = block.number;
battleInfos.push(temp);
battleID = battleInfos.length - 1;
address(owner).transfer(msg.value);
emit initiateBattleEv(caller, _tokenID, _userSeed, battleID,block.number );
return battleID;
}
event finishBattleEv(address user, uint256 battleInfoIndex, uint256 _tokenID, uint256 randomToken, uint256 mintAmount);
function finishBattle(uint256 _battleInfoIndex,bytes32 blockHashValue) public onlySigner returns (bool)
{
require(_battleInfoIndex < battleInfos.length, "Invalid Battle Index");
require(battleInfos[_battleInfoIndex].rewardAmount == 0, "Already finished");
uint256 _tokenID = battleInfos[_battleInfoIndex].tokenID;
uint256 _userSeed = battleInfos[_battleInfoIndex].userSeed;
address caller = niftyMoji(niftyMojiContractAddress).ownerOf(_tokenID);
bool success;
uint256 randomToken;
address randomTokenUser;
for(uint256 i=0;i<50;i++)
{
randomToken = uint256(keccak256(abi.encodePacked(blockHashValue, _userSeed))) % niftyMoji(niftyMojiContractAddress).totalSupply() + 1;
randomTokenUser = niftyMoji(niftyMojiContractAddress).ownerOf(_tokenID);
if(blackListedToken[randomToken] || blackListedUser[randomTokenUser])
{
_userSeed += block.number%8;
}
else
{
success = true;
break;
}
}
require(success, "try again");
(uint256 powerPercent,uint256 luckPercent ) = niftyMoji(niftyMojiContractAddress).powerNLucks(_tokenID);
(uint256 powerPercent2,uint256 luckPercent2 ) = niftyMoji(niftyMojiContractAddress).powerNLucks(randomToken);
uint256 mintAmount;
if( powerPercent + luckPercent > powerPercent2 + luckPercent2)
{
mintAmount = battleWinReward ;
}
else
{
mintAmount = battleLooseReward;
}
battleInfos[_battleInfoIndex].rewardAmount = mintAmount;
battleInfos[_battleInfoIndex].opponentTokenID = randomToken;
emit finishBattleEv(caller,_battleInfoIndex, _tokenID, randomToken, mintAmount);
balanceOf[caller] = balanceOf[caller].add(mintAmount);
totalSupply = totalSupply.add(mintAmount);
totalMintedForTokenId[_tokenID] = totalMintedForTokenId[_tokenID].add(mintAmount);
totalMintedByBattleForTokenID[_tokenID] = totalMintedByBattleForTokenID[_tokenID].add(mintAmount);
dayTracker[_tokenID] = now;
lastFinishedIndex = _battleInfoIndex;
emit Transfer(address(0),caller,mintAmount);
return true;
}
function multipleFinishBattle (bytes32[] memory _blockHashValue) public onlySigner returns(bool)
{
uint i;
for(i=0;i<_blockHashValue.length;i++)
{
require(finishBattle(lastFinishedIndex + i + 1,_blockHashValue[i]),"could not fihish battle");
}
return true;
}
function lastUnFinishedIndexNBlock() public view returns (uint256 lastUnFinishedIndex, uint256 blockNo)
{
uint len = battleInfos.length-1;
if(len > lastFinishedIndex)
{
return (lastFinishedIndex +1, battleInfos[lastFinishedIndex +1].blockNo);
}
else
{
return (0,0);
}
}
function setNiftyMojiContractAddress(address _niftyMojiContractAddress) public onlyOwner returns(bool)
{
niftyMojiContractAddress = _niftyMojiContractAddress;
return true;
}
function setMintingMultiplier(uint256 _mintingMultiplier) public onlyOwner returns (bool)
{
mintingMultiplier = _mintingMultiplier;
return true;
}
function setbattleFees(uint256 _battleFees) public onlyOwner returns(bool)
{
battleFees = _battleFees;
return true;
}
function setMintTokenFee(uint256 _mintTokenFee) public onlyOwner returns(bool)
{
mintTokenFee = _mintTokenFee;
return true;
}
function setBattleReward(uint256 winReward, uint256 looseReward) public onlyOwner returns(bool)
{
battleWinReward = winReward;
battleLooseReward = looseReward;
return true;
}
function changeGlobalHalt() onlyOwner public returns(bool) {
if (globalHalt == false){
globalHalt = true;
}
else{
globalHalt = false;
}
return true;
}
function totalEtherbalanceContract() public view returns(uint256){
return address(this).balance;
}
function manualWithdrawEtherAdmin(uint64 Amount) public onlyOwner returns (bool){
require (address(this).balance >= Amount);
address(owner).transfer(Amount);
withdrawnByAdmin = withdrawnByAdmin.add(Amount);
return true;
}
}
