qvtx-developer-kit 1.0.0 → 1.2.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 {}
+}