Contracts
Test Token 20 info
Test Token 20 contract
game contract info
Game Token contract
Test Token 20 info
Test Token 20
Contact Address
0xbf52601D3d897927b8c9A909f907D517a0DC0EfA
Test Token 20 contract
// SPDX-License-Identifier: MIT
// Compatible with OpenZeppelin Contracts ^4.4.0
pragma solidity ^0.8.20;
import “@openzeppelin/contracts/token/ERC20/ERC20.sol”;
import “@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol”;
import “@openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol”;
import “@openzeppelin/contracts/access/Ownable.sol”;
import “@openzeppelin/contracts/security/ReentrancyGuard.sol”;
contract Twenty is ERC20, ERC20Burnable, ERC20Permit, Ownable, ReentrancyGuard {
struct TimeLock {
uint256 amount;
uint256 releaseTime;
}
mapping(address => TimeLock[]) private _timeLocks;
mapping(address => bool) private _whitelist;
uint256 public buyTax;
uint256 public sellTax;
address public buyTaxWallet;
address public sellTaxWallet;
address public marketingWallet;
event WhitelistedAddressAdded(address addr);
event WhitelistedAddressRemoved(address addr);
event BuyTaxChanged(uint256 newTax);
event SellTaxChanged(uint256 newTax);
event BuyTaxWalletChanged(address newWallet);
event SellTaxWalletChanged(address newWallet);
event MarketingWalletChanged(address newWallet);
event TokensLocked(address indexed account, uint256 amount, uint256 releaseTime);
event TokensUnlocked(address indexed account, uint256 amount);
constructor(address initialOwner)
ERC20(“Twenty”, “20”)
ERC20Permit(“Fifteen”)
Ownable(initialOwner)
{
_mint(msg.sender, 20000000000000 * 10 ** decimals());
buyTax = 0; // initialize to 0, can be changed later
sellTax = 0; // initialize to 0, can be changed later
buyTaxWallet = msg.sender; // initialize to contract deployer, can be changed later
sellTaxWallet = msg.sender; // initialize to contract deployer, can be changed later
}
function addToWhitelist(address addr) external onlyOwner {
_whitelist[addr] = true;
emit WhitelistedAddressAdded(addr);
}
function removeFromWhitelist(address addr) external onlyOwner {
_whitelist[addr] = false;
emit WhitelistedAddressRemoved(addr);
}
function isWhitelisted(address addr) public view returns (bool) {
return _whitelist[addr];
}
function setBuyTax(uint256 newTax) external onlyOwner {
buyTax = newTax;
emit BuyTaxChanged(newTax);
}
function setSellTax(uint256 newTax) external onlyOwner {
sellTax = newTax;
emit SellTaxChanged(newTax);
}
function setBuyTaxWallet(address newWallet) external onlyOwner {
buyTaxWallet = newWallet;
emit BuyTaxWalletChanged(newWallet);
}
function setSellTaxWallet(address newWallet) external onlyOwner {
sellTaxWallet = newWallet;
emit SellTaxWalletChanged(newWallet);
}
function setMarketingWallet(address newWallet) external onlyOwner {
marketingWallet = newWallet;
emit MarketingWalletChanged(newWallet);
}
function lockTokens(address account, uint256 amount, uint256 releaseTime) external onlyOwner {
require(account != address(0), “Lock for the zero address”);
require(amount > 0, “Lock for zero tokens”);
require(releaseTime > block.timestamp, “Lock in the past”);
_timeLocks[account].push(TimeLock(amount, releaseTime));
_transfer(account, address(this), amount);
emit TokensLocked(account, amount, releaseTime);
}
function unlockTokens() external {
TimeLock[] storage timeLocks = _timeLocks[msg.sender];
uint256 unlockableAmount = 0;
for (uint256 i = 0; i < timeLocks.length; i++) {
if (block.timestamp >= timeLocks[i].releaseTime) {
unlockableAmount += timeLocks[i].amount;
delete timeLocks[i];
}
}
require(unlockableAmount > 0, “No tokens to unlock”);
_transfer(address(this), msg.sender, unlockableAmount);
emit TokensUnlocked(msg.sender, unlockableAmount);
}
function withdrawEther(uint256 amount) external onlyOwner {
payable(owner()).transfer(amount);
}
function withdrawToken(address token, uint256 amount) external onlyOwner {
require(token != address(this), “Cannot withdraw Fifteen token”);
IERC20(token).transfer(owner(), amount);
}
function cleanUp() external onlyOwner {
for (uint256 i = 0; i < _timeLocks[msg.sender].length; i++) {
delete _timeLocks[msg.sender][i];
}
}
function recoverERC20(address token, uint256 amount) external onlyOwner {
require(token != address(this), “Cannot recover Fifteen token”);
IERC20(token).transfer(owner(), amount);
}
}
game contract info
Game Contract
Contact Address
0x70737656B967FC40c7f589ea5FEF6E054bac4DbA
Game Token contract
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import “@openzeppelin/contracts/token/ERC20/IERC20.sol”;
import “@openzeppelin/contracts/access/Ownable.sol”;
import “@openzeppelin/contracts/security/ReentrancyGuard.sol”;
contract GameHub is Ownable, ReentrancyGuard {
IERC20 public gameToken;
address private marketingWallet;
mapping(address => bool) public hasClaimedFaucet;
mapping(address => uint256) public referralRewards;
event TokensClaimed(address indexed user, uint256 amount);
event GameWon(address indexed user, string game, uint256 amount);
event ReferralReward(address indexed referrer, uint256 amount);
constructor(address _marketingWallet, address _gameToken, address initialOwner) Ownable(initialOwner) {
require(_marketingWallet != address(0), “Marketing wallet address cannot be the zero address.”);
require(_gameToken != address(0), “Game token address cannot be the zero address.”);
marketingWallet = _marketingWallet;
gameToken = IERC20(_gameToken);
}
function setMarketingWallet(address _newMarketingWallet) public onlyOwner {
require(_newMarketingWallet != address(0), “Invalid address”);
marketingWallet = _newMarketingWallet;
}
function setGameToken(address _newTokenAddress) public onlyOwner {
require(_newTokenAddress != address(0), “Invalid address”);
gameToken = IERC20(_newTokenAddress);
}
function claimFaucetTokens() external {
require(!hasClaimedFaucet[msg.sender], “Already claimed faucet tokens”);
hasClaimedFaucet[msg.sender] = true;
_distributeTokens(msg.sender, 100 ether);
emit TokensClaimed(msg.sender, 100 ether);
}
function startTreasureHunt() external {
uint256 reward = _calculateRandomReward(5, 100);
_distributeTokens(msg.sender, reward * 1 ether);
emit GameWon(msg.sender, “Treasure Hunt”, reward);
}
function rollDice(uint256 guess) external {
require(guess >= 1 && guess <= 6, “Guess must be between 1 and 6”);
bool won = _rollDiceLogic(guess);
if (won) {
uint256 reward = _calculateRandomReward(5, 100);
_distributeTokens(msg.sender, reward * 1 ether);
emit GameWon(msg.sender, “Dice Game”, reward);
}
}
function enterLottery() external {
uint256 reward = _calculateRandomReward(5, 100);
_distributeTokens(msg.sender, reward * 1 ether);
emit GameWon(msg.sender, “Lottery”, reward);
}
function claimReferralReward(address referee) external {
uint256 reward = 10 ether; // Example fixed reward
referralRewards[referee] += reward;
_distributeTokens(referee, reward);
emit ReferralReward(referee, reward);
}
function _distributeTokens(address to, uint256 amount) internal {
require(gameToken.transferFrom(marketingWallet, to, amount), “Token transfer failed”);
}
function _calculateRandomReward(uint256 min, uint256 max) private view returns (uint256) {
return (uint256(keccak256(abi.encodePacked(block.timestamp, msg.sender))) % (max – min + 1)) + min;
}
function _rollDiceLogic(uint256 guess) private view returns (bool) {
uint256 rollResult = (uint256(keccak256(abi.encodePacked(block.timestamp, msg.sender))) % 6) + 1;
return guess == rollResult;
}
}