qvtx-developer-kit 1.0.0 → 1.1.0

package/smart-contracts/QVTXBridge.sol

@@ -0,0 +1,305 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+/**
+ * @title QVTX Bridge
+ * @dev Cross-chain bridge for QVTX token transfers
+ * @author QuantVestrix Tech Team (07-Tech)
+ */
+
+interface IQVTXToken {
+    function bridgeMint(address to, uint256 amount, uint256 sourceChain) external;
+    function bridgeBurn(address from, uint256 amount, uint256 targetChain) external;
+    function balanceOf(address account) external view returns (uint256);
+    function transferFrom(address from, address to, uint256 amount) external returns (bool);
+}
+
+contract QVTXBridge {
+    // Bridge configuration
+    IQVTXToken public qvtxToken;
+    address public owner;
+    address public validator;
+
+    uint256 public currentChainId;
+    uint256 public nonce;
+    uint256 public bridgeFee = 0.001 ether; // Fee for bridging
+    uint256 public minBridgeAmount = 100 * 10**18; // Minimum 100 QVTX
+    uint256 public maxBridgeAmount = 10_000_000 * 10**18; // Maximum 10M QVTX
+
+    bool public paused;
+
+    // Supported chains
+    mapping(uint256 => bool) public supportedChains;
+    mapping(uint256 => address) public chainBridges; // chainId => bridge contract on that chain
+
+    // Bridge requests
+    struct BridgeRequest {
+        uint256 id;
+        address sender;
+        address recipient;
+        uint256 amount;
+        uint256 sourceChain;
+        uint256 targetChain;
+        uint256 timestamp;
+        bytes32 txHash;
+        BridgeStatus status;
+    }
+
+    enum BridgeStatus {
+        Pending,
+        Completed,
+        Refunded,
+        Failed
+    }
+
+    mapping(uint256 => BridgeRequest) public bridgeRequests;
+    mapping(bytes32 => bool) public processedHashes;
+    mapping(address => uint256[]) public userBridgeRequests;
+
+    // Daily limits
+    mapping(uint256 => uint256) public dailyVolume; // day => volume
+    uint256 public dailyLimit = 100_000_000 * 10**18; // 100M QVTX daily
+
+    // Events
+    event BridgeInitiated(
+        uint256 indexed requestId,
+        address indexed sender,
+        address indexed recipient,
+        uint256 amount,
+        uint256 sourceChain,
+        uint256 targetChain
+    );
+    event BridgeCompleted(
+        uint256 indexed requestId,
+        address indexed recipient,
+        uint256 amount,
+        uint256 sourceChain,
+        bytes32 sourceTxHash
+    );
+    event BridgeRefunded(uint256 indexed requestId, address indexed sender, uint256 amount);
+    event ChainAdded(uint256 indexed chainId, address bridgeContract);
+    event ChainRemoved(uint256 indexed chainId);
+    event ValidatorUpdated(address indexed newValidator);
+    event FeesWithdrawn(address indexed to, uint256 amount);
+    event Paused(bool status);
+
+    modifier onlyOwner() {
+        require(msg.sender == owner, "Bridge: not owner");
+        _;
+    }
+
+    modifier onlyValidator() {
+        require(msg.sender == validator || msg.sender == owner, "Bridge: not validator");
+        _;
+    }
+
+    modifier whenNotPaused() {
+        require(!paused, "Bridge: paused");
+        _;
+    }
+
+    constructor(address _qvtxToken, uint256 _chainId) {
+        qvtxToken = IQVTXToken(_qvtxToken);
+        currentChainId = _chainId;
+        owner = msg.sender;
+        validator = msg.sender;
+
+        // Add default supported chains
+        _addChain(1, address(0)); // Ethereum
+        _addChain(56, address(0)); // BSC
+        _addChain(137, address(0)); // Polygon
+        _addChain(42161, address(0)); // Arbitrum
+        _addChain(43114, address(0)); // Avalanche
+        _addChain(10, address(0)); // Optimism
+    }
+
+    // Initiate bridge transfer
+    function bridge(
+        address recipient,
+        uint256 amount,
+        uint256 targetChain
+    ) external payable whenNotPaused returns (uint256) {
+        require(supportedChains[targetChain], "Bridge: unsupported chain");
+        require(targetChain != currentChainId, "Bridge: same chain");
+        require(amount >= minBridgeAmount, "Bridge: below minimum");
+        require(amount <= maxBridgeAmount, "Bridge: exceeds maximum");
+        require(msg.value >= bridgeFee, "Bridge: insufficient fee");
+        require(recipient != address(0), "Bridge: zero recipient");
+
+        // Check daily limit
+        uint256 today = block.timestamp / 1 days;
+        require(dailyVolume[today] + amount <= dailyLimit, "Bridge: daily limit exceeded");
+        dailyVolume[today] += amount;
+
+        // Lock/burn tokens
+        qvtxToken.bridgeBurn(msg.sender, amount, targetChain);
+
+        // Create bridge request
+        nonce++;
+        uint256 requestId = nonce;
+
+        bridgeRequests[requestId] = BridgeRequest({
+            id: requestId,
+            sender: msg.sender,
+            recipient: recipient,
+            amount: amount,
+            sourceChain: currentChainId,
+            targetChain: targetChain,
+            timestamp: block.timestamp,
+            txHash: bytes32(0),
+            status: BridgeStatus.Pending
+        });
+
+        userBridgeRequests[msg.sender].push(requestId);
+
+        emit BridgeInitiated(requestId, msg.sender, recipient, amount, currentChainId, targetChain);
+
+        // Refund excess fee
+        if (msg.value > bridgeFee) {
+            payable(msg.sender).transfer(msg.value - bridgeFee);
+        }
+
+        return requestId;
+    }
+
+    // Complete bridge (called by validator on destination chain)
+    function completeBridge(
+        address recipient,
+        uint256 amount,
+        uint256 sourceChain,
+        bytes32 sourceTxHash,
+        bytes calldata signature
+    ) external onlyValidator whenNotPaused {
+        require(!processedHashes[sourceTxHash], "Bridge: already processed");
+        require(supportedChains[sourceChain], "Bridge: unsupported source chain");
+
+        // Verify signature
+        bytes32 messageHash = keccak256(abi.encodePacked(
+            recipient,
+            amount,
+            sourceChain,
+            currentChainId,
+            sourceTxHash
+        ));
+        require(_verifySignature(messageHash, signature), "Bridge: invalid signature");
+
+        processedHashes[sourceTxHash] = true;
+
+        // Mint tokens to recipient
+        qvtxToken.bridgeMint(recipient, amount, sourceChain);
+
+        // Create completion record
+        nonce++;
+        bridgeRequests[nonce] = BridgeRequest({
+            id: nonce,
+            sender: address(0),
+            recipient: recipient,
+            amount: amount,
+            sourceChain: sourceChain,
+            targetChain: currentChainId,
+            timestamp: block.timestamp,
+            txHash: sourceTxHash,
+            status: BridgeStatus.Completed
+        });
+
+        emit BridgeCompleted(nonce, recipient, amount, sourceChain, sourceTxHash);
+    }
+
+    // Refund failed bridge
+    function refund(uint256 requestId) external onlyValidator {
+        BridgeRequest storage request = bridgeRequests[requestId];
+        require(request.status == BridgeStatus.Pending, "Bridge: not pending");
+        require(request.sourceChain == currentChainId, "Bridge: wrong chain");
+
+        request.status = BridgeStatus.Refunded;
+
+        // Mint back to sender
+        qvtxToken.bridgeMint(request.sender, request.amount, currentChainId);
+
+        emit BridgeRefunded(requestId, request.sender, request.amount);
+    }
+
+    // Verify validator signature
+    function _verifySignature(bytes32 messageHash, bytes calldata signature) internal view returns (bool) {
+        bytes32 ethSignedHash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", messageHash));
+        (bytes32 r, bytes32 s, uint8 v) = _splitSignature(signature);
+        address signer = ecrecover(ethSignedHash, v, r, s);
+        return signer == validator;
+    }
+
+    function _splitSignature(bytes calldata sig) internal pure returns (bytes32 r, bytes32 s, uint8 v) {
+        require(sig.length == 65, "Bridge: invalid signature length");
+        assembly {
+            r := calldataload(sig.offset)
+            s := calldataload(add(sig.offset, 32))
+            v := byte(0, calldataload(add(sig.offset, 64)))
+        }
+    }
+
+    // Get user bridge history
+    function getUserBridgeRequests(address user) external view returns (uint256[] memory) {
+        return userBridgeRequests[user];
+    }
+
+    // Get bridge request details
+    function getBridgeRequest(uint256 requestId) external view returns (BridgeRequest memory) {
+        return bridgeRequests[requestId];
+    }
+
+    // Check if chain is supported
+    function isChainSupported(uint256 chainId) external view returns (bool) {
+        return supportedChains[chainId];
+    }
+
+    // Admin functions
+    function addChain(uint256 chainId, address bridgeContract) external onlyOwner {
+        _addChain(chainId, bridgeContract);
+    }
+
+    function _addChain(uint256 chainId, address bridgeContract) internal {
+        supportedChains[chainId] = true;
+        chainBridges[chainId] = bridgeContract;
+        emit ChainAdded(chainId, bridgeContract);
+    }
+
+    function removeChain(uint256 chainId) external onlyOwner {
+        supportedChains[chainId] = false;
+        chainBridges[chainId] = address(0);
+        emit ChainRemoved(chainId);
+    }
+
+    function setValidator(address _validator) external onlyOwner {
+        require(_validator != address(0), "Bridge: zero address");
+        validator = _validator;
+        emit ValidatorUpdated(_validator);
+    }
+
+    function setBridgeFee(uint256 _fee) external onlyOwner {
+        bridgeFee = _fee;
+    }
+
+    function setLimits(uint256 _min, uint256 _max, uint256 _daily) external onlyOwner {
+        minBridgeAmount = _min;
+        maxBridgeAmount = _max;
+        dailyLimit = _daily;
+    }
+
+    function setPaused(bool _paused) external onlyOwner {
+        paused = _paused;
+        emit Paused(_paused);
+    }
+
+    function withdrawFees(address payable to) external onlyOwner {
+        uint256 balance = address(this).balance;
+        require(balance > 0, "Bridge: no fees");
+        to.transfer(balance);
+        emit FeesWithdrawn(to, balance);
+    }
+
+    function transferOwnership(address newOwner) external onlyOwner {
+        require(newOwner != address(0), "Bridge: zero address");
+        owner = newOwner;
+    }
+
+    receive() external payable {}
+}

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