made in Remix IDE
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
// PeakeCoin Token with Multiple Minters (Upgradeable)
contract PeakeCoin is Initializable, ERC20Upgradeable, OwnableUpgradeable {
mapping(address => bool) public isMinter;
event MinterAdded(address indexed minter);
event MinterRemoved(address indexed minter);
bool public paused;
uint256 public cooldownBlocks;
mapping(address => uint256) public lastActionBlock;
event Paused();
event Unpaused();
event CooldownBlocksChanged(uint256 newCooldown);
uint256 public mintBurnFee;
address public profitRecipient;
event FeeChanged(uint256 newFee);
event ProfitRecipientChanged(address newRecipient);
uint256 public maxTotalSupply;
mapping(address => bool) public isFeeExempt;
event FeeExemptionSet(address indexed account, bool isExempt);
event Recovered(address token, uint256 amount);
// --- Staking Extensibility ---
bool public stakingEnabled; // Use only this variable for staking enabled/disabled
uint256 public minStakeTime; // Minimum time to stake before rewards
uint256 public unstakeDelay; // Time after unstaking before tokens are liquid
uint256 public stakingRewardRate; // Placeholder for reward rate (per year, per block, etc.)
struct StakeInfo {
uint256 amount;
uint256 stakedAt;
uint256 unstakeRequestedAt;
bool isUnstaking;
}
mapping(address => StakeInfo) public stakes;
event StakingEnabled(bool enabled);
event Staked(address indexed user, uint256 amount);
event UnstakeRequested(address indexed user, uint256 amount);
event Unstaked(address indexed user, uint256 amount);
event RewardsClaimed(address indexed user, uint256 amount);
event StakingParamsSet(uint256 minStakeTime, uint256 unstakeDelay, uint256 rewardRate);
function initialize(address initialOwner) public initializer {
__ERC20_init("PeakeCoin", "PEK");
__Ownable_init(initialOwner);
paused = false;
cooldownBlocks = 10;
mintBurnFee = 0.01 ether;
maxTotalSupply = 1000000000 ether; // Example: 1 billion tokens max
}
// Set fee exemption for an address
function setFeeExemption(address account, bool exempt) external onlyOwner {
isFeeExempt[account] = exempt;
emit FeeExemptionSet(account, exempt);
}
// Rescue function to recover ERC20 tokens or Ether sent to contract
function recoverERC20(address tokenAddress, uint256 amount) external onlyOwner {
require(tokenAddress != address(0), "Invalid token address");
require(amount > 0, "Amount must be greater than zero");
emit Recovered(tokenAddress, amount);
IERC20Upgradeable(tokenAddress).transfer(owner(), amount);
}
function recoverETH(uint256 amount) external onlyOwner {
require(amount > 0, "Amount must be greater than zero");
emit Recovered(address(0), amount);
payable(owner()).transfer(amount);
}
// Only minters can mint/burn
modifier onlyMinter() {
require(isMinter[msg.sender], "Not a minter");
_;
}
modifier notPaused() {
require(!paused, "Contract is paused");
_;
}
modifier cooldownPassed() {
require(block.number > lastActionBlock[msg.sender] + cooldownBlocks, "Cooldown not passed");
_;
lastActionBlock[msg.sender] = block.number;
}
modifier paysFee() {
if (!isFeeExempt[msg.sender]) {
require(msg.value >= mintBurnFee, "Insufficient fee sent");
if (profitRecipient != address(0)) {
payable(profitRecipient).transfer(msg.value);
} else {
payable(owner()).transfer(msg.value);
}
}
_;
}
// Owner can add a bridge/minter
function addMinter(address minter) external onlyOwner {
isMinter[minter] = true;
emit MinterAdded(minter);
}
// Owner can remove a bridge/minter
function removeMinter(address minter) external onlyOwner {
isMinter[minter] = false;
emit MinterRemoved(minter);
}
function pause() external onlyOwner {
paused = true;
emit Paused();
}
function unpause() external onlyOwner {
paused = false;
emit Unpaused();
}
function setCooldownBlocks(uint256 blocks_) external onlyOwner {
cooldownBlocks = blocks_;
emit CooldownBlocksChanged(blocks_);
}
function setMintBurnFee(uint256 fee) external onlyOwner {
mintBurnFee = fee;
emit FeeChanged(fee);
}
function setProfitRecipient(address recipient) external onlyOwner {
profitRecipient = recipient;
emit ProfitRecipientChanged(recipient);
}
event MintWithMemo(address indexed to, uint256 amount, string memo);
event BurnWithMemo(address indexed from, uint256 amount, string memo);
// Mapping for future supported external tokens/contracts
mapping(bytes32 => address) public externalContracts; // e.g., chainId => contract address
event ExternalContractSet(bytes32 indexed chainId, address contractAddress);
// Event for cross-chain transfers
event CrossChainTransfer(address indexed from, address indexed to, uint256 amount, string targetChain, string txReference, string memo);
// Owner can update maxTotalSupply to match Hive or other chains
function setMaxTotalSupply(uint256 newMax) external onlyOwner {
require(newMax >= totalSupply(), "New max less than current supply");
maxTotalSupply = newMax;
}
// Owner can register external contracts for future expansion
function setExternalContract(bytes32 chainId, address contractAddress) external onlyOwner {
require(contractAddress != address(0), "Invalid contract address");
require(chainId != bytes32(0), "Invalid chainId");
// Prevent overwriting unless explicitly allowed (optional: add a mechanism for removal)
require(externalContracts[chainId] == address(0), "Contract already set for this chainId");
externalContracts[chainId] = contractAddress;
emit ExternalContractSet(chainId, contractAddress);
}
// Minter can mint to any address
function mint(address to, uint256 amount, string calldata memo, string calldata targetChain, string calldata txReference) external payable onlyMinter notPaused cooldownPassed paysFee {
require(totalSupply() + amount <= maxTotalSupply, "Mint exceeds cap");
_mint(to, amount);
emit MintWithMemo(to, amount, memo);
emit CrossChainTransfer(address(0), to, amount, targetChain, txReference, memo);
}
// Minter can burn from any address (for bridge redemptions)
function burn(address from, uint256 amount, string calldata memo, string calldata targetChain, string calldata txReference) external payable onlyMinter notPaused cooldownPassed paysFee {
_burn(from, amount);
emit BurnWithMemo(from, amount, memo);
emit CrossChainTransfer(from, address(0), amount, targetChain, txReference, memo);
} // --- Staking Rewards Logic ---
// Placeholder for future reward logic
/*
function _calculateRewards(address user) internal view returns (uint256) {
// Future implementation
return 0;
}
function claimRewards() external {
// Future implementation
revert("Staking rewards not enabled yet");
}
*/
function stake(uint256 amount) external {
require(stakingEnabled, "Staking not enabled");
require(amount > 0, "Cannot stake 0");
StakeInfo storage info = stakes[msg.sender];
_transfer(msg.sender, address(this), amount);
info.amount += amount;
// Note: block.timestamp is used for staking timing. This is acceptable for this use case,
// but not suitable for critical randomness or high-value time-based security.
info.stakedAt = block.timestamp;
info.isUnstaking = false;
emit Staked(msg.sender, amount);
}
function requestUnstake(uint256 amount) external {
require(stakingEnabled, "Staking not enabled");
StakeInfo storage info = stakes[msg.sender];
require(info.amount >= amount && amount > 0, "Insufficient staked");
require(!info.isUnstaking, "Already unstaking");
info.amount -= amount;
// Note: block.timestamp is used for staking timing. This is acceptable for this use case,
// but not suitable for critical randomness or high-value time-based security.
info.unstakeRequestedAt = block.timestamp;
info.isUnstaking = true;
emit UnstakeRequested(msg.sender, amount);
}
// Complete the unstaking process after the delay
function _completeUnstake(address user) internal {
StakeInfo storage info = stakes[user];
require(info.isUnstaking, "Not unstaking");
/*
Note: block.timestamp is used for staking timing. This is acceptable for this use case,
but not suitable for critical randomness or high-value time-based security.
*/
require(block.timestamp >= info.unstakeRequestedAt + unstakeDelay, "Unstake delay not passed");
uint256 amount = info.amount;
info.amount = 0;
info.isUnstaking = false;
_transfer(address(this), user, amount);
emit Unstaked(user, amount);
}
// Owner can enable or disable staking
function setStakingEnabled(bool enabled) external onlyOwner {
stakingEnabled = enabled;
emit StakingEnabled(enabled);
}
// Owner can set staking parameters
function setStakingParams(uint256 minTime, uint256 delay, uint256 rewardRate) external onlyOwner {
minStakeTime = minTime;
unstakeDelay = delay;
stakingRewardRate = rewardRate;
emit StakingParamsSet(minTime, delay, rewardRate);
}
// Override _beforeTokenTransfer to handle automatic unstaking
function _beforeTokenTransfer(address from, address /*to*/, uint256 /*amount*/) internal virtual {
if (from != address(0)) {
StakeInfo storage info = stakes[from];
require(!info.isUnstaking || block.timestamp >= info.unstakeRequestedAt + unstakeDelay, "Cannot transfer while unstaking");
}
}
}
