qvtx-developer-kit 1.0.0 → 1.2.0

package/smart-contracts/QVTXGovernance.sol

@@ -0,0 +1,325 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+/**
+ * @title QVTX Governance
+ * @dev DAO governance contract for QuantVestrix ecosystem
+ * @author QuantVestrix Tech Team (07-Tech)
+ */
+
+interface IQVTXToken {
+    function balanceOf(address account) external view returns (uint256);
+    function totalSupply() external view returns (uint256);
+}
+
+contract QVTXGovernance {
+    // Governance token
+    IQVTXToken public qvtxToken;
+    address public owner;
+
+    // Proposal structure
+    struct Proposal {
+        uint256 id;
+        address proposer;
+        string title;
+        string description;
+        bytes callData;
+        address target;
+        uint256 value;
+        uint256 forVotes;
+        uint256 againstVotes;
+        uint256 abstainVotes;
+        uint256 startBlock;
+        uint256 endBlock;
+        bool executed;
+        bool canceled;
+        mapping(address => Receipt) receipts;
+    }
+
+    struct Receipt {
+        bool hasVoted;
+        uint8 support; // 0 = against, 1 = for, 2 = abstain
+        uint256 votes;
+    }
+
+    struct ProposalInfo {
+        uint256 id;
+        address proposer;
+        string title;
+        string description;
+        uint256 forVotes;
+        uint256 againstVotes;
+        uint256 abstainVotes;
+        uint256 startBlock;
+        uint256 endBlock;
+        bool executed;
+        bool canceled;
+        ProposalState state;
+    }
+
+    enum ProposalState {
+        Pending,
+        Active,
+        Canceled,
+        Defeated,
+        Succeeded,
+        Queued,
+        Expired,
+        Executed
+    }
+
+    // Configuration
+    uint256 public proposalThreshold = 100_000 * 10**18; // 100k QVTX to propose
+    uint256 public quorumVotes = 4_000_000 * 10**18; // 4M QVTX (0.4% of supply)
+    uint256 public votingDelay = 1; // 1 block
+    uint256 public votingPeriod = 40320; // ~1 week (assuming 15s blocks)
+    uint256 public timelockDelay = 172800; // 2 days in seconds
+
+    // Storage
+    uint256 public proposalCount;
+    mapping(uint256 => Proposal) public proposals;
+    mapping(address => uint256) public latestProposalIds;
+    mapping(uint256 => uint256) public proposalTimelocks; // proposalId => execution timestamp
+
+    // Events
+    event ProposalCreated(
+        uint256 indexed id,
+        address indexed proposer,
+        string title,
+        address target,
+        uint256 startBlock,
+        uint256 endBlock
+    );
+    event VoteCast(
+        address indexed voter,
+        uint256 indexed proposalId,
+        uint8 support,
+        uint256 votes,
+        string reason
+    );
+    event ProposalCanceled(uint256 indexed id);
+    event ProposalQueued(uint256 indexed id, uint256 eta);
+    event ProposalExecuted(uint256 indexed id);
+    event ConfigUpdated(string param, uint256 value);
+
+    modifier onlyOwner() {
+        require(msg.sender == owner, "Governance: not owner");
+        _;
+    }
+
+    constructor(address _qvtxToken) {
+        qvtxToken = IQVTXToken(_qvtxToken);
+        owner = msg.sender;
+    }
+
+    // Create proposal
+    function propose(
+        string memory title,
+        string memory description,
+        address target,
+        uint256 value,
+        bytes memory callData
+    ) external returns (uint256) {
+        require(
+            qvtxToken.balanceOf(msg.sender) >= proposalThreshold,
+            "Governance: below proposal threshold"
+        );
+        require(
+            latestProposalIds[msg.sender] == 0 ||
+            getProposalState(latestProposalIds[msg.sender]) != ProposalState.Active,
+            "Governance: already has active proposal"
+        );
+
+        proposalCount++;
+        uint256 proposalId = proposalCount;
+
+        Proposal storage proposal = proposals[proposalId];
+        proposal.id = proposalId;
+        proposal.proposer = msg.sender;
+        proposal.title = title;
+        proposal.description = description;
+        proposal.target = target;
+        proposal.value = value;
+        proposal.callData = callData;
+        proposal.startBlock = block.number + votingDelay;
+        proposal.endBlock = proposal.startBlock + votingPeriod;
+
+        latestProposalIds[msg.sender] = proposalId;
+
+        emit ProposalCreated(
+            proposalId,
+            msg.sender,
+            title,
+            target,
+            proposal.startBlock,
+            proposal.endBlock
+        );
+
+        return proposalId;
+    }
+
+    // Cast vote
+    function castVote(uint256 proposalId, uint8 support) external {
+        _castVote(msg.sender, proposalId, support, "");
+    }
+
+    function castVoteWithReason(uint256 proposalId, uint8 support, string calldata reason) external {
+        _castVote(msg.sender, proposalId, support, reason);
+    }
+
+    function _castVote(
+        address voter,
+        uint256 proposalId,
+        uint8 support,
+        string memory reason
+    ) internal {
+        require(getProposalState(proposalId) == ProposalState.Active, "Governance: voting closed");
+        require(support <= 2, "Governance: invalid vote type");
+
+        Proposal storage proposal = proposals[proposalId];
+        Receipt storage receipt = proposal.receipts[voter];
+        require(!receipt.hasVoted, "Governance: already voted");
+
+        uint256 votes = qvtxToken.balanceOf(voter);
+        require(votes > 0, "Governance: no voting power");
+
+        if (support == 0) {
+            proposal.againstVotes += votes;
+        } else if (support == 1) {
+            proposal.forVotes += votes;
+        } else {
+            proposal.abstainVotes += votes;
+        }
+
+        receipt.hasVoted = true;
+        receipt.support = support;
+        receipt.votes = votes;
+
+        emit VoteCast(voter, proposalId, support, votes, reason);
+    }
+
+    // Queue successful proposal
+    function queue(uint256 proposalId) external {
+        require(
+            getProposalState(proposalId) == ProposalState.Succeeded,
+            "Governance: proposal not succeeded"
+        );
+
+        proposalTimelocks[proposalId] = block.timestamp + timelockDelay;
+
+        emit ProposalQueued(proposalId, proposalTimelocks[proposalId]);
+    }
+
+    // Execute queued proposal
+    function execute(uint256 proposalId) external payable {
+        require(
+            getProposalState(proposalId) == ProposalState.Queued,
+            "Governance: proposal not queued"
+        );
+        require(
+            block.timestamp >= proposalTimelocks[proposalId],
+            "Governance: timelock not passed"
+        );
+
+        Proposal storage proposal = proposals[proposalId];
+        proposal.executed = true;
+
+        (bool success, ) = proposal.target.call{value: proposal.value}(proposal.callData);
+        require(success, "Governance: execution failed");
+
+        emit ProposalExecuted(proposalId);
+    }
+
+    // Cancel proposal
+    function cancel(uint256 proposalId) external {
+        Proposal storage proposal = proposals[proposalId];
+        require(
+            msg.sender == proposal.proposer || msg.sender == owner,
+            "Governance: not authorized"
+        );
+        require(!proposal.executed, "Governance: already executed");
+
+        proposal.canceled = true;
+
+        emit ProposalCanceled(proposalId);
+    }
+
+    // Get proposal state
+    function getProposalState(uint256 proposalId) public view returns (ProposalState) {
+        require(proposalId > 0 && proposalId <= proposalCount, "Governance: invalid proposal");
+
+        Proposal storage proposal = proposals[proposalId];
+
+        if (proposal.canceled) {
+            return ProposalState.Canceled;
+        } else if (block.number <= proposal.startBlock) {
+            return ProposalState.Pending;
+        } else if (block.number <= proposal.endBlock) {
+            return ProposalState.Active;
+        } else if (proposal.forVotes <= proposal.againstVotes || proposal.forVotes < quorumVotes) {
+            return ProposalState.Defeated;
+        } else if (proposal.executed) {
+            return ProposalState.Executed;
+        } else if (proposalTimelocks[proposalId] == 0) {
+            return ProposalState.Succeeded;
+        } else if (block.timestamp < proposalTimelocks[proposalId]) {
+            return ProposalState.Queued;
+        } else if (block.timestamp >= proposalTimelocks[proposalId] + 14 days) {
+            return ProposalState.Expired;
+        } else {
+            return ProposalState.Queued;
+        }
+    }
+
+    // Get proposal info
+    function getProposal(uint256 proposalId) external view returns (ProposalInfo memory) {
+        Proposal storage proposal = proposals[proposalId];
+        return ProposalInfo({
+            id: proposal.id,
+            proposer: proposal.proposer,
+            title: proposal.title,
+            description: proposal.description,
+            forVotes: proposal.forVotes,
+            againstVotes: proposal.againstVotes,
+            abstainVotes: proposal.abstainVotes,
+            startBlock: proposal.startBlock,
+            endBlock: proposal.endBlock,
+            executed: proposal.executed,
+            canceled: proposal.canceled,
+            state: getProposalState(proposalId)
+        });
+    }
+
+    // Get vote receipt
+    function getReceipt(uint256 proposalId, address voter) external view returns (Receipt memory) {
+        return proposals[proposalId].receipts[voter];
+    }
+
+    // Admin functions
+    function setProposalThreshold(uint256 _threshold) external onlyOwner {
+        proposalThreshold = _threshold;
+        emit ConfigUpdated("proposalThreshold", _threshold);
+    }
+
+    function setQuorumVotes(uint256 _quorum) external onlyOwner {
+        quorumVotes = _quorum;
+        emit ConfigUpdated("quorumVotes", _quorum);
+    }
+
+    function setVotingPeriod(uint256 _period) external onlyOwner {
+        votingPeriod = _period;
+        emit ConfigUpdated("votingPeriod", _period);
+    }
+
+    function setTimelockDelay(uint256 _delay) external onlyOwner {
+        timelockDelay = _delay;
+        emit ConfigUpdated("timelockDelay", _delay);
+    }
+
+    function transferOwnership(address newOwner) external onlyOwner {
+        require(newOwner != address(0), "Governance: zero address");
+        owner = newOwner;
+    }
+
+    receive() external payable {}
+}

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