qvtx-developer-kit 1.0.0 → 1.2.0

package/smart-contracts/QVTXRewards.sol

@@ -0,0 +1,102 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+/**
+ * @title QVTX Rewards Contract
+ * @dev Cross-chain rewards distribution for QVTX ecosystem
+ */
+interface IERC20 {
+    function transfer(address to, uint256 amount) external returns (bool);
+    function transferFrom(address from, address to, uint256 amount) external returns (bool);
+    function balanceOf(address account) external view returns (uint256);
+}
+
+contract QVTXRewards {
+    address public owner;
+    address public rewardToken;
+
+    uint256 public rewardRate = 100; // Rewards per block
+    uint256 public lastUpdateBlock;
+    uint256 public rewardPerTokenStored;
+
+    mapping(address => uint256) public userRewardPerTokenPaid;
+    mapping(address => uint256) public rewards;
+    mapping(address => uint256) public stakes;
+
+    uint256 public totalStaked;
+
+    event Staked(address indexed user, uint256 amount);
+    event Withdrawn(address indexed user, uint256 amount);
+    event RewardPaid(address indexed user, uint256 reward);
+    event RewardRateUpdated(uint256 newRate);
+
+    modifier onlyOwner() {
+        require(msg.sender == owner, "Not owner");
+        _;
+    }
+
+    modifier updateReward(address account) {
+        rewardPerTokenStored = rewardPerToken();
+        lastUpdateBlock = block.number;
+        if (account != address(0)) {
+            rewards[account] = earned(account);
+            userRewardPerTokenPaid[account] = rewardPerTokenStored;
+        }
+        _;
+    }
+
+    constructor(address _rewardToken) {
+        owner = msg.sender;
+        rewardToken = _rewardToken;
+        lastUpdateBlock = block.number;
+    }
+
+    function rewardPerToken() public view returns (uint256) {
+        if (totalStaked == 0) {
+            return rewardPerTokenStored;
+        }
+        return rewardPerTokenStored +
+            ((block.number - lastUpdateBlock) * rewardRate * 1e18) / totalStaked;
+    }
+
+    function earned(address account) public view returns (uint256) {
+        return (stakes[account] * (rewardPerToken() - userRewardPerTokenPaid[account])) / 1e18
+            + rewards[account];
+    }
+
+    function stake(uint256 amount) external updateReward(msg.sender) {
+        require(amount > 0, "Cannot stake 0");
+        totalStaked += amount;
+        stakes[msg.sender] += amount;
+        IERC20(rewardToken).transferFrom(msg.sender, address(this), amount);
+        emit Staked(msg.sender, amount);
+    }
+
+    function withdraw(uint256 amount) external updateReward(msg.sender) {
+        require(amount > 0, "Cannot withdraw 0");
+        require(stakes[msg.sender] >= amount, "Insufficient stake");
+        totalStaked -= amount;
+        stakes[msg.sender] -= amount;
+        IERC20(rewardToken).transfer(msg.sender, amount);
+        emit Withdrawn(msg.sender, amount);
+    }
+
+    function claimReward() external updateReward(msg.sender) {
+        uint256 reward = rewards[msg.sender];
+        if (reward > 0) {
+            rewards[msg.sender] = 0;
+            IERC20(rewardToken).transfer(msg.sender, reward);
+            emit RewardPaid(msg.sender, reward);
+        }
+    }
+
+    function setRewardRate(uint256 _rate) external onlyOwner updateReward(address(0)) {
+        rewardRate = _rate;
+        emit RewardRateUpdated(_rate);
+    }
+
+    function emergencyWithdraw() external onlyOwner {
+        uint256 balance = IERC20(rewardToken).balanceOf(address(this));
+        IERC20(rewardToken).transfer(owner, balance);
+    }
+}

package/smart-contracts/QVTXToken.sol

@@ -0,0 +1,227 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+/**
+ * @title QVTX Token
+ * @dev QuantVestrix native token with cross-chain capabilities
+ * @author QuantVestrix Tech Team (07-Tech)
+ */
+
+import "./interfaces/IERC20.sol";
+import "./interfaces/IERC20Metadata.sol";
+
+contract QVTXToken is IERC20, IERC20Metadata {
+    string private constant _name = "QuantVestrix";
+    string private constant _symbol = "QVTX";
+    uint8 private constant _decimals = 18;
+
+    uint256 private _totalSupply;
+    address public owner;
+    address public bridgeContract;
+
+    mapping(address => uint256) private _balances;
+    mapping(address => mapping(address => uint256)) private _allowances;
+    mapping(address => bool) public minters;
+    mapping(address => bool) public blacklisted;
+
+    // Cross-chain tracking
+    mapping(uint256 => uint256) public chainSupply; // chainId => supply on that chain
+    uint256 public constant MAX_SUPPLY = 1_000_000_000 * 10**18; // 1 billion tokens
+
+    // Events
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+    event MinterAdded(address indexed minter);
+    event MinterRemoved(address indexed minter);
+    event BridgeContractUpdated(address indexed newBridge);
+    event CrossChainMint(uint256 indexed sourceChain, address indexed to, uint256 amount);
+    event CrossChainBurn(uint256 indexed targetChain, address indexed from, uint256 amount);
+    event Blacklisted(address indexed account, bool status);
+
+    modifier onlyOwner() {
+        require(msg.sender == owner, "QVTX: caller is not owner");
+        _;
+    }
+
+    modifier onlyMinter() {
+        require(minters[msg.sender] || msg.sender == owner, "QVTX: caller is not minter");
+        _;
+    }
+
+    modifier onlyBridge() {
+        require(msg.sender == bridgeContract, "QVTX: caller is not bridge");
+        _;
+    }
+
+    modifier notBlacklisted(address account) {
+        require(!blacklisted[account], "QVTX: account is blacklisted");
+        _;
+    }
+
+    constructor(uint256 initialSupply) {
+        require(initialSupply <= MAX_SUPPLY, "QVTX: exceeds max supply");
+        owner = msg.sender;
+        _mint(msg.sender, initialSupply);
+        emit OwnershipTransferred(address(0), msg.sender);
+    }
+
+    // ERC20 Metadata
+    function name() external pure override returns (string memory) {
+        return _name;
+    }
+
+    function symbol() external pure override returns (string memory) {
+        return _symbol;
+    }
+
+    function decimals() external pure override returns (uint8) {
+        return _decimals;
+    }
+
+    // ERC20 Standard
+    function totalSupply() external view override returns (uint256) {
+        return _totalSupply;
+    }
+
+    function balanceOf(address account) external view override returns (uint256) {
+        return _balances[account];
+    }
+
+    function transfer(address to, uint256 amount) external override notBlacklisted(msg.sender) notBlacklisted(to) returns (bool) {
+        _transfer(msg.sender, to, amount);
+        return true;
+    }
+
+    function allowance(address tokenOwner, address spender) external view override returns (uint256) {
+        return _allowances[tokenOwner][spender];
+    }
+
+    function approve(address spender, uint256 amount) external override notBlacklisted(msg.sender) returns (bool) {
+        _approve(msg.sender, spender, amount);
+        return true;
+    }
+
+    function transferFrom(address from, address to, uint256 amount) external override notBlacklisted(from) notBlacklisted(to) returns (bool) {
+        uint256 currentAllowance = _allowances[from][msg.sender];
+        require(currentAllowance >= amount, "QVTX: insufficient allowance");
+        unchecked {
+            _approve(from, msg.sender, currentAllowance - amount);
+        }
+        _transfer(from, to, amount);
+        return true;
+    }
+
+    // Extended functions
+    function increaseAllowance(address spender, uint256 addedValue) external returns (bool) {
+        _approve(msg.sender, spender, _allowances[msg.sender][spender] + addedValue);
+        return true;
+    }
+
+    function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool) {
+        uint256 currentAllowance = _allowances[msg.sender][spender];
+        require(currentAllowance >= subtractedValue, "QVTX: decreased allowance below zero");
+        unchecked {
+            _approve(msg.sender, spender, currentAllowance - subtractedValue);
+        }
+        return true;
+    }
+
+    // Minting & Burning
+    function mint(address to, uint256 amount) external onlyMinter {
+        require(_totalSupply + amount <= MAX_SUPPLY, "QVTX: exceeds max supply");
+        _mint(to, amount);
+    }
+
+    function burn(uint256 amount) external {
+        _burn(msg.sender, amount);
+    }
+
+    function burnFrom(address account, uint256 amount) external {
+        uint256 currentAllowance = _allowances[account][msg.sender];
+        require(currentAllowance >= amount, "QVTX: burn amount exceeds allowance");
+        unchecked {
+            _approve(account, msg.sender, currentAllowance - amount);
+        }
+        _burn(account, amount);
+    }
+
+    // Cross-chain functions
+    function bridgeMint(address to, uint256 amount, uint256 sourceChain) external onlyBridge {
+        require(_totalSupply + amount <= MAX_SUPPLY, "QVTX: exceeds max supply");
+        _mint(to, amount);
+        emit CrossChainMint(sourceChain, to, amount);
+    }
+
+    function bridgeBurn(address from, uint256 amount, uint256 targetChain) external onlyBridge {
+        _burn(from, amount);
+        emit CrossChainBurn(targetChain, from, amount);
+    }
+
+    // Admin functions
+    function transferOwnership(address newOwner) external onlyOwner {
+        require(newOwner != address(0), "QVTX: new owner is zero address");
+        emit OwnershipTransferred(owner, newOwner);
+        owner = newOwner;
+    }
+
+    function addMinter(address minter) external onlyOwner {
+        minters[minter] = true;
+        emit MinterAdded(minter);
+    }
+
+    function removeMinter(address minter) external onlyOwner {
+        minters[minter] = false;
+        emit MinterRemoved(minter);
+    }
+
+    function setBridgeContract(address _bridge) external onlyOwner {
+        bridgeContract = _bridge;
+        emit BridgeContractUpdated(_bridge);
+    }
+
+    function setBlacklist(address account, bool status) external onlyOwner {
+        blacklisted[account] = status;
+        emit Blacklisted(account, status);
+    }
+
+    // Internal functions
+    function _transfer(address from, address to, uint256 amount) internal {
+        require(from != address(0), "QVTX: transfer from zero address");
+        require(to != address(0), "QVTX: transfer to zero address");
+        require(_balances[from] >= amount, "QVTX: insufficient balance");
+
+        unchecked {
+            _balances[from] -= amount;
+            _balances[to] += amount;
+        }
+
+        emit Transfer(from, to, amount);
+    }
+
+    function _mint(address account, uint256 amount) internal {
+        require(account != address(0), "QVTX: mint to zero address");
+        _totalSupply += amount;
+        unchecked {
+            _balances[account] += amount;
+        }
+        emit Transfer(address(0), account, amount);
+    }
+
+    function _burn(address account, uint256 amount) internal {
+        require(account != address(0), "QVTX: burn from zero address");
+        require(_balances[account] >= amount, "QVTX: burn exceeds balance");
+
+        unchecked {
+            _balances[account] -= amount;
+            _totalSupply -= amount;
+        }
+
+        emit Transfer(account, address(0), amount);
+    }
+
+    function _approve(address tokenOwner, address spender, uint256 amount) internal {
+        require(tokenOwner != address(0), "QVTX: approve from zero address");
+        require(spender != address(0), "QVTX: approve to zero address");
+        _allowances[tokenOwner][spender] = amount;
+        emit Approval(tokenOwner, spender, amount);
+    }
+}