qvtx-developer-kit 1.0.0 → 1.1.0

package/smart-contracts/QVTXNFT.sol

@@ -0,0 +1,338 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+/**
+ * @title QVTX NFT
+ * @dev ERC721 NFT contract for QuantVestrix ecosystem
+ * @author QuantVestrix Tech Team (07-Tech)
+ */
+
+import "./interfaces/IERC721.sol";
+import "./interfaces/IERC721Metadata.sol";
+import "./interfaces/IERC721Receiver.sol";
+
+contract QVTXNFT is IERC721, IERC721Metadata {
+    string private _name;
+    string private _symbol;
+    string private _baseURI;
+
+    address public owner;
+    uint256 public totalSupply;
+    uint256 public maxSupply;
+    uint256 public mintPrice;
+    bool public mintingEnabled;
+
+    // Token data
+    mapping(uint256 => address) private _owners;
+    mapping(address => uint256) private _balances;
+    mapping(uint256 => address) private _tokenApprovals;
+    mapping(address => mapping(address => bool)) private _operatorApprovals;
+    mapping(uint256 => string) private _tokenURIs;
+
+    // Royalties (EIP-2981)
+    address public royaltyReceiver;
+    uint96 public royaltyBps = 500; // 5%
+
+    // Whitelist
+    mapping(address => bool) public whitelist;
+    mapping(address => uint256) public mintedCount;
+    uint256 public maxPerWallet = 10;
+    bool public whitelistOnly;
+
+    // Events
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+    event BaseURIUpdated(string newBaseURI);
+    event MintingToggled(bool enabled);
+    event WhitelistUpdated(address indexed account, bool status);
+    event RoyaltyUpdated(address receiver, uint96 bps);
+
+    modifier onlyOwner() {
+        require(msg.sender == owner, "NFT: not owner");
+        _;
+    }
+
+    constructor(
+        string memory name_,
+        string memory symbol_,
+        string memory baseURI_,
+        uint256 _maxSupply,
+        uint256 _mintPrice
+    ) {
+        _name = name_;
+        _symbol = symbol_;
+        _baseURI = baseURI_;
+        maxSupply = _maxSupply;
+        mintPrice = _mintPrice;
+        owner = msg.sender;
+        royaltyReceiver = msg.sender;
+    }
+
+    // ERC721 Metadata
+    function name() external view override returns (string memory) {
+        return _name;
+    }
+
+    function symbol() external view override returns (string memory) {
+        return _symbol;
+    }
+
+    function tokenURI(uint256 tokenId) external view override returns (string memory) {
+        require(_exists(tokenId), "NFT: nonexistent token");
+
+        string memory _tokenURI = _tokenURIs[tokenId];
+        if (bytes(_tokenURI).length > 0) {
+            return _tokenURI;
+        }
+
+        return string(abi.encodePacked(_baseURI, _toString(tokenId), ".json"));
+    }
+
+    // ERC721 Standard
+    function balanceOf(address tokenOwner) external view override returns (uint256) {
+        require(tokenOwner != address(0), "NFT: zero address");
+        return _balances[tokenOwner];
+    }
+
+    function ownerOf(uint256 tokenId) public view override returns (address) {
+        address tokenOwner = _owners[tokenId];
+        require(tokenOwner != address(0), "NFT: nonexistent token");
+        return tokenOwner;
+    }
+
+    function approve(address to, uint256 tokenId) external override {
+        address tokenOwner = ownerOf(tokenId);
+        require(to != tokenOwner, "NFT: approval to owner");
+        require(
+            msg.sender == tokenOwner || isApprovedForAll(tokenOwner, msg.sender),
+            "NFT: not authorized"
+        );
+        _tokenApprovals[tokenId] = to;
+        emit Approval(tokenOwner, to, tokenId);
+    }
+
+    function getApproved(uint256 tokenId) public view override returns (address) {
+        require(_exists(tokenId), "NFT: nonexistent token");
+        return _tokenApprovals[tokenId];
+    }
+
+    function setApprovalForAll(address operator, bool approved) external override {
+        require(operator != msg.sender, "NFT: approve to caller");
+        _operatorApprovals[msg.sender][operator] = approved;
+        emit ApprovalForAll(msg.sender, operator, approved);
+    }
+
+    function isApprovedForAll(address tokenOwner, address operator) public view override returns (bool) {
+        return _operatorApprovals[tokenOwner][operator];
+    }
+
+    function transferFrom(address from, address to, uint256 tokenId) public override {
+        require(_isApprovedOrOwner(msg.sender, tokenId), "NFT: not authorized");
+        _transfer(from, to, tokenId);
+    }
+
+    function safeTransferFrom(address from, address to, uint256 tokenId) external override {
+        safeTransferFrom(from, to, tokenId, "");
+    }
+
+    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override {
+        require(_isApprovedOrOwner(msg.sender, tokenId), "NFT: not authorized");
+        _safeTransfer(from, to, tokenId, data);
+    }
+
+    // Minting
+    function mint(uint256 quantity) external payable {
+        require(mintingEnabled, "NFT: minting disabled");
+        require(totalSupply + quantity <= maxSupply, "NFT: exceeds max supply");
+        require(mintedCount[msg.sender] + quantity <= maxPerWallet, "NFT: exceeds max per wallet");
+        require(msg.value >= mintPrice * quantity, "NFT: insufficient payment");
+
+        if (whitelistOnly) {
+            require(whitelist[msg.sender], "NFT: not whitelisted");
+        }
+
+        for (uint256 i = 0; i < quantity; i++) {
+            totalSupply++;
+            _mint(msg.sender, totalSupply);
+        }
+
+        mintedCount[msg.sender] += quantity;
+
+        // Refund excess
+        if (msg.value > mintPrice * quantity) {
+            payable(msg.sender).transfer(msg.value - mintPrice * quantity);
+        }
+    }
+
+    function ownerMint(address to, uint256 quantity) external onlyOwner {
+        require(totalSupply + quantity <= maxSupply, "NFT: exceeds max supply");
+
+        for (uint256 i = 0; i < quantity; i++) {
+            totalSupply++;
+            _mint(to, totalSupply);
+        }
+    }
+
+    function airdrop(address[] calldata recipients) external onlyOwner {
+        require(totalSupply + recipients.length <= maxSupply, "NFT: exceeds max supply");
+
+        for (uint256 i = 0; i < recipients.length; i++) {
+            totalSupply++;
+            _mint(recipients[i], totalSupply);
+        }
+    }
+
+    // Burn
+    function burn(uint256 tokenId) external {
+        require(_isApprovedOrOwner(msg.sender, tokenId), "NFT: not authorized");
+        _burn(tokenId);
+    }
+
+    // EIP-2981 Royalties
+    function royaltyInfo(uint256, uint256 salePrice) external view returns (address, uint256) {
+        uint256 royaltyAmount = (salePrice * royaltyBps) / 10000;
+        return (royaltyReceiver, royaltyAmount);
+    }
+
+    // Admin functions
+    function setBaseURI(string memory baseURI_) external onlyOwner {
+        _baseURI = baseURI_;
+        emit BaseURIUpdated(baseURI_);
+    }
+
+    function setTokenURI(uint256 tokenId, string memory _tokenURI) external onlyOwner {
+        require(_exists(tokenId), "NFT: nonexistent token");
+        _tokenURIs[tokenId] = _tokenURI;
+    }
+
+    function setMintPrice(uint256 _price) external onlyOwner {
+        mintPrice = _price;
+    }
+
+    function setMaxPerWallet(uint256 _max) external onlyOwner {
+        maxPerWallet = _max;
+    }
+
+    function toggleMinting(bool _enabled) external onlyOwner {
+        mintingEnabled = _enabled;
+        emit MintingToggled(_enabled);
+    }
+
+    function setWhitelistOnly(bool _whitelistOnly) external onlyOwner {
+        whitelistOnly = _whitelistOnly;
+    }
+
+    function updateWhitelist(address[] calldata accounts, bool status) external onlyOwner {
+        for (uint256 i = 0; i < accounts.length; i++) {
+            whitelist[accounts[i]] = status;
+            emit WhitelistUpdated(accounts[i], status);
+        }
+    }
+
+    function setRoyalty(address receiver, uint96 bps) external onlyOwner {
+        require(bps <= 1000, "NFT: royalty too high"); // Max 10%
+        royaltyReceiver = receiver;
+        royaltyBps = bps;
+        emit RoyaltyUpdated(receiver, bps);
+    }
+
+    function withdraw() external onlyOwner {
+        uint256 balance = address(this).balance;
+        require(balance > 0, "NFT: no balance");
+        payable(owner).transfer(balance);
+    }
+
+    function transferOwnership(address newOwner) external onlyOwner {
+        require(newOwner != address(0), "NFT: zero address");
+        emit OwnershipTransferred(owner, newOwner);
+        owner = newOwner;
+    }
+
+    // Internal functions
+    function _exists(uint256 tokenId) internal view returns (bool) {
+        return _owners[tokenId] != address(0);
+    }
+
+    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
+        address tokenOwner = ownerOf(tokenId);
+        return (spender == tokenOwner || getApproved(tokenId) == spender || isApprovedForAll(tokenOwner, spender));
+    }
+
+    function _mint(address to, uint256 tokenId) internal {
+        require(to != address(0), "NFT: mint to zero address");
+        require(!_exists(tokenId), "NFT: token exists");
+
+        _balances[to]++;
+        _owners[tokenId] = to;
+
+        emit Transfer(address(0), to, tokenId);
+    }
+
+    function _burn(uint256 tokenId) internal {
+        address tokenOwner = ownerOf(tokenId);
+
+        // Clear approvals
+        delete _tokenApprovals[tokenId];
+
+        _balances[tokenOwner]--;
+        delete _owners[tokenId];
+        delete _tokenURIs[tokenId];
+
+        emit Transfer(tokenOwner, address(0), tokenId);
+    }
+
+    function _transfer(address from, address to, uint256 tokenId) internal {
+        require(ownerOf(tokenId) == from, "NFT: not owner");
+        require(to != address(0), "NFT: transfer to zero address");
+
+        // Clear approvals
+        delete _tokenApprovals[tokenId];
+
+        _balances[from]--;
+        _balances[to]++;
+        _owners[tokenId] = to;
+
+        emit Transfer(from, to, tokenId);
+    }
+
+    function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal {
+        _transfer(from, to, tokenId);
+        require(_checkOnERC721Received(from, to, tokenId, data), "NFT: transfer to non-receiver");
+    }
+
+    function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory data) private returns (bool) {
+        if (to.code.length > 0) {
+            try IERC721Receiver(to).onERC721Received(msg.sender, from, tokenId, data) returns (bytes4 retval) {
+                return retval == IERC721Receiver.onERC721Received.selector;
+            } catch {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    function _toString(uint256 value) internal pure returns (string memory) {
+        if (value == 0) return "0";
+        uint256 temp = value;
+        uint256 digits;
+        while (temp != 0) {
+            digits++;
+            temp /= 10;
+        }
+        bytes memory buffer = new bytes(digits);
+        while (value != 0) {
+            digits--;
+            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
+            value /= 10;
+        }
+        return string(buffer);
+    }
+
+    // ERC165
+    function supportsInterface(bytes4 interfaceId) external pure returns (bool) {
+        return
+            interfaceId == 0x01ffc9a7 || // ERC165
+            interfaceId == 0x80ac58cd || // ERC721
+            interfaceId == 0x5b5e139f || // ERC721Metadata
+            interfaceId == 0x2a55205a;   // ERC2981
+    }
+}

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);
+    }
+}