qvtx-developer-kit 1.0.0 → 1.2.0

package/smart-contracts/QVTXVesting.sol

@@ -0,0 +1,411 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+/**
+ * @title QVTX Vesting
+ * @dev Token vesting contract for team, advisors, and investors
+ * @author QuantVestrix Tech Team (07-Tech)
+ */
+
+interface IQVTXToken {
+    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 QVTXVesting {
+    IQVTXToken public qvtxToken;
+    address public owner;
+
+    struct VestingSchedule {
+        uint256 id;
+        address beneficiary;
+        uint256 totalAmount;
+        uint256 releasedAmount;
+        uint256 startTime;
+        uint256 cliffDuration;
+        uint256 vestingDuration;
+        uint256 slicePeriod;
+        bool revocable;
+        bool revoked;
+        VestingType vestingType;
+    }
+
+    enum VestingType {
+        Team,
+        Advisor,
+        Investor,
+        Partnership,
+        Community,
+        Custom
+    }
+
+    // Storage
+    uint256 public scheduleCount;
+    mapping(uint256 => VestingSchedule) public vestingSchedules;
+    mapping(address => uint256[]) public beneficiarySchedules;
+
+    uint256 public totalVested;
+    uint256 public totalReleased;
+
+    // Preset vesting configurations
+    mapping(VestingType => VestingConfig) public presetConfigs;
+
+    struct VestingConfig {
+        uint256 cliffDuration;
+        uint256 vestingDuration;
+        uint256 slicePeriod;
+        bool revocable;
+    }
+
+    // Events
+    event VestingScheduleCreated(
+        uint256 indexed scheduleId,
+        address indexed beneficiary,
+        uint256 amount,
+        VestingType vestingType
+    );
+    event TokensReleased(uint256 indexed scheduleId, address indexed beneficiary, uint256 amount);
+    event VestingRevoked(uint256 indexed scheduleId, uint256 refundAmount);
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+    modifier onlyOwner() {
+        require(msg.sender == owner, "Vesting: not owner");
+        _;
+    }
+
+    modifier scheduleExists(uint256 scheduleId) {
+        require(scheduleId > 0 && scheduleId <= scheduleCount, "Vesting: invalid schedule");
+        _;
+    }
+
+    constructor(address _qvtxToken) {
+        qvtxToken = IQVTXToken(_qvtxToken);
+        owner = msg.sender;
+
+        // Initialize preset vesting configurations
+        // Team: 1 year cliff, 4 year vesting, monthly releases
+        presetConfigs[VestingType.Team] = VestingConfig({
+            cliffDuration: 365 days,
+            vestingDuration: 4 * 365 days,
+            slicePeriod: 30 days,
+            revocable: true
+        });
+
+        // Advisors: 6 month cliff, 2 year vesting, monthly releases
+        presetConfigs[VestingType.Advisor] = VestingConfig({
+            cliffDuration: 180 days,
+            vestingDuration: 2 * 365 days,
+            slicePeriod: 30 days,
+            revocable: true
+        });
+
+        // Investors: 3 month cliff, 18 month vesting, monthly releases
+        presetConfigs[VestingType.Investor] = VestingConfig({
+            cliffDuration: 90 days,
+            vestingDuration: 18 * 30 days,
+            slicePeriod: 30 days,
+            revocable: false
+        });
+
+        // Partnership: No cliff, 1 year vesting, quarterly releases
+        presetConfigs[VestingType.Partnership] = VestingConfig({
+            cliffDuration: 0,
+            vestingDuration: 365 days,
+            slicePeriod: 90 days,
+            revocable: false
+        });
+
+        // Community: No cliff, 6 month vesting, weekly releases
+        presetConfigs[VestingType.Community] = VestingConfig({
+            cliffDuration: 0,
+            vestingDuration: 180 days,
+            slicePeriod: 7 days,
+            revocable: false
+        });
+    }
+
+    // Create vesting schedule with preset config
+    function createVestingSchedule(
+        address beneficiary,
+        uint256 amount,
+        VestingType vestingType
+    ) external onlyOwner returns (uint256) {
+        require(beneficiary != address(0), "Vesting: zero address");
+        require(amount > 0, "Vesting: zero amount");
+
+        VestingConfig memory config = presetConfigs[vestingType];
+
+        return _createSchedule(
+            beneficiary,
+            amount,
+            block.timestamp,
+            config.cliffDuration,
+            config.vestingDuration,
+            config.slicePeriod,
+            config.revocable,
+            vestingType
+        );
+    }
+
+    // Create custom vesting schedule
+    function createCustomVestingSchedule(
+        address beneficiary,
+        uint256 amount,
+        uint256 startTime,
+        uint256 cliffDuration,
+        uint256 vestingDuration,
+        uint256 slicePeriod,
+        bool revocable
+    ) external onlyOwner returns (uint256) {
+        require(beneficiary != address(0), "Vesting: zero address");
+        require(amount > 0, "Vesting: zero amount");
+        require(vestingDuration > 0, "Vesting: zero duration");
+        require(slicePeriod > 0, "Vesting: zero slice period");
+        require(vestingDuration >= cliffDuration, "Vesting: cliff > duration");
+
+        return _createSchedule(
+            beneficiary,
+            amount,
+            startTime > 0 ? startTime : block.timestamp,
+            cliffDuration,
+            vestingDuration,
+            slicePeriod,
+            revocable,
+            VestingType.Custom
+        );
+    }
+
+    function _createSchedule(
+        address beneficiary,
+        uint256 amount,
+        uint256 startTime,
+        uint256 cliffDuration,
+        uint256 vestingDuration,
+        uint256 slicePeriod,
+        bool revocable,
+        VestingType vestingType
+    ) internal returns (uint256) {
+        // Transfer tokens to this contract
+        require(
+            qvtxToken.transferFrom(msg.sender, address(this), amount),
+            "Vesting: transfer failed"
+        );
+
+        scheduleCount++;
+        uint256 scheduleId = scheduleCount;
+
+        vestingSchedules[scheduleId] = VestingSchedule({
+            id: scheduleId,
+            beneficiary: beneficiary,
+            totalAmount: amount,
+            releasedAmount: 0,
+            startTime: startTime,
+            cliffDuration: cliffDuration,
+            vestingDuration: vestingDuration,
+            slicePeriod: slicePeriod,
+            revocable: revocable,
+            revoked: false,
+            vestingType: vestingType
+        });
+
+        beneficiarySchedules[beneficiary].push(scheduleId);
+        totalVested += amount;
+
+        emit VestingScheduleCreated(scheduleId, beneficiary, amount, vestingType);
+
+        return scheduleId;
+    }
+
+    // Batch create vesting schedules
+    function batchCreateVestingSchedules(
+        address[] calldata beneficiaries,
+        uint256[] calldata amounts,
+        VestingType vestingType
+    ) external onlyOwner returns (uint256[] memory) {
+        require(beneficiaries.length == amounts.length, "Vesting: length mismatch");
+        require(beneficiaries.length > 0, "Vesting: empty arrays");
+
+        uint256[] memory scheduleIds = new uint256[](beneficiaries.length);
+
+        for (uint256 i = 0; i < beneficiaries.length; i++) {
+            VestingConfig memory config = presetConfigs[vestingType];
+            scheduleIds[i] = _createSchedule(
+                beneficiaries[i],
+                amounts[i],
+                block.timestamp,
+                config.cliffDuration,
+                config.vestingDuration,
+                config.slicePeriod,
+                config.revocable,
+                vestingType
+            );
+        }
+
+        return scheduleIds;
+    }
+
+    // Release vested tokens
+    function release(uint256 scheduleId) external scheduleExists(scheduleId) {
+        VestingSchedule storage schedule = vestingSchedules[scheduleId];
+        require(!schedule.revoked, "Vesting: schedule revoked");
+        require(msg.sender == schedule.beneficiary, "Vesting: not beneficiary");
+
+        uint256 releasable = _computeReleasableAmount(schedule);
+        require(releasable > 0, "Vesting: nothing to release");
+
+        schedule.releasedAmount += releasable;
+        totalReleased += releasable;
+
+        require(
+            qvtxToken.transfer(schedule.beneficiary, releasable),
+            "Vesting: transfer failed"
+        );
+
+        emit TokensReleased(scheduleId, schedule.beneficiary, releasable);
+    }
+
+    // Release all vested tokens for beneficiary
+    function releaseAll() external {
+        uint256[] memory scheduleIds = beneficiarySchedules[msg.sender];
+        require(scheduleIds.length > 0, "Vesting: no schedules");
+
+        uint256 totalReleasable = 0;
+
+        for (uint256 i = 0; i < scheduleIds.length; i++) {
+            VestingSchedule storage schedule = vestingSchedules[scheduleIds[i]];
+            if (!schedule.revoked) {
+                uint256 releasable = _computeReleasableAmount(schedule);
+                if (releasable > 0) {
+                    schedule.releasedAmount += releasable;
+                    totalReleasable += releasable;
+                    emit TokensReleased(scheduleIds[i], msg.sender, releasable);
+                }
+            }
+        }
+
+        require(totalReleasable > 0, "Vesting: nothing to release");
+        totalReleased += totalReleasable;
+
+        require(
+            qvtxToken.transfer(msg.sender, totalReleasable),
+            "Vesting: transfer failed"
+        );
+    }
+
+    // Revoke vesting schedule
+    function revoke(uint256 scheduleId) external onlyOwner scheduleExists(scheduleId) {
+        VestingSchedule storage schedule = vestingSchedules[scheduleId];
+        require(schedule.revocable, "Vesting: not revocable");
+        require(!schedule.revoked, "Vesting: already revoked");
+
+        // Release any vested tokens first
+        uint256 releasable = _computeReleasableAmount(schedule);
+        if (releasable > 0) {
+            schedule.releasedAmount += releasable;
+            totalReleased += releasable;
+            qvtxToken.transfer(schedule.beneficiary, releasable);
+            emit TokensReleased(scheduleId, schedule.beneficiary, releasable);
+        }
+
+        // Calculate refund
+        uint256 refundAmount = schedule.totalAmount - schedule.releasedAmount;
+        schedule.revoked = true;
+
+        if (refundAmount > 0) {
+            totalVested -= refundAmount;
+            qvtxToken.transfer(owner, refundAmount);
+        }
+
+        emit VestingRevoked(scheduleId, refundAmount);
+    }
+
+    // Compute releasable amount
+    function _computeReleasableAmount(VestingSchedule storage schedule) internal view returns (uint256) {
+        uint256 vestedAmount = _computeVestedAmount(schedule);
+        return vestedAmount - schedule.releasedAmount;
+    }
+
+    // Compute vested amount
+    function _computeVestedAmount(VestingSchedule storage schedule) internal view returns (uint256) {
+        if (block.timestamp < schedule.startTime + schedule.cliffDuration) {
+            return 0;
+        }
+
+        uint256 timeFromStart = block.timestamp - schedule.startTime;
+
+        if (timeFromStart >= schedule.vestingDuration) {
+            return schedule.totalAmount;
+        }
+
+        // Calculate vested amount based on slice periods
+        uint256 vestedSlices = timeFromStart / schedule.slicePeriod;
+        uint256 totalSlices = schedule.vestingDuration / schedule.slicePeriod;
+
+        return (schedule.totalAmount * vestedSlices) / totalSlices;
+    }
+
+    // View functions
+    function getVestingSchedule(uint256 scheduleId) external view returns (VestingSchedule memory) {
+        return vestingSchedules[scheduleId];
+    }
+
+    function getBeneficiarySchedules(address beneficiary) external view returns (uint256[] memory) {
+        return beneficiarySchedules[beneficiary];
+    }
+
+    function getReleasableAmount(uint256 scheduleId) external view scheduleExists(scheduleId) returns (uint256) {
+        VestingSchedule storage schedule = vestingSchedules[scheduleId];
+        if (schedule.revoked) return 0;
+        return _computeReleasableAmount(schedule);
+    }
+
+    function getVestedAmount(uint256 scheduleId) external view scheduleExists(scheduleId) returns (uint256) {
+        return _computeVestedAmount(vestingSchedules[scheduleId]);
+    }
+
+    function getTotalReleasable(address beneficiary) external view returns (uint256) {
+        uint256[] memory scheduleIds = beneficiarySchedules[beneficiary];
+        uint256 total = 0;
+
+        for (uint256 i = 0; i < scheduleIds.length; i++) {
+            VestingSchedule storage schedule = vestingSchedules[scheduleIds[i]];
+            if (!schedule.revoked) {
+                total += _computeReleasableAmount(schedule);
+            }
+        }
+
+        return total;
+    }
+
+    // Admin functions
+    function updatePresetConfig(
+        VestingType vestingType,
+        uint256 cliffDuration,
+        uint256 vestingDuration,
+        uint256 slicePeriod,
+        bool revocable
+    ) external onlyOwner {
+        presetConfigs[vestingType] = VestingConfig({
+            cliffDuration: cliffDuration,
+            vestingDuration: vestingDuration,
+            slicePeriod: slicePeriod,
+            revocable: revocable
+        });
+    }
+
+    function transferOwnership(address newOwner) external onlyOwner {
+        require(newOwner != address(0), "Vesting: zero address");
+        emit OwnershipTransferred(owner, newOwner);
+        owner = newOwner;
+    }
+
+    // Emergency withdraw (only unvested tokens)
+    function emergencyWithdraw() external onlyOwner {
+        uint256 balance = qvtxToken.balanceOf(address(this));
+        uint256 unvested = balance - (totalVested - totalReleased);
+        if (unvested > 0) {
+            qvtxToken.transfer(owner, unvested);
+        }
+    }
+}

package/smart-contracts/interfaces/IERC20.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+interface IERC20 {
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+
+    function totalSupply() external view returns (uint256);
+    function balanceOf(address account) external view returns (uint256);
+    function transfer(address to, uint256 amount) external returns (bool);
+    function allowance(address owner, address spender) external view returns (uint256);
+    function approve(address spender, uint256 amount) external returns (bool);
+    function transferFrom(address from, address to, uint256 amount) external returns (bool);
+}

package/smart-contracts/interfaces/IERC20Metadata.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+interface IERC20Metadata {
+    function name() external view returns (string memory);
+    function symbol() external view returns (string memory);
+    function decimals() external view returns (uint8);
+}

package/smart-contracts/interfaces/IERC721.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+interface IERC721 {
+    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
+    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
+    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
+
+    function balanceOf(address owner) external view returns (uint256);
+    function ownerOf(uint256 tokenId) external view returns (address);
+    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
+    function safeTransferFrom(address from, address to, uint256 tokenId) external;
+    function transferFrom(address from, address to, uint256 tokenId) external;
+    function approve(address to, uint256 tokenId) external;
+    function setApprovalForAll(address operator, bool approved) external;
+    function getApproved(uint256 tokenId) external view returns (address);
+    function isApprovedForAll(address owner, address operator) external view returns (bool);
+}

package/smart-contracts/interfaces/IERC721Metadata.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+interface IERC721Metadata {
+    function name() external view returns (string memory);
+    function symbol() external view returns (string memory);
+    function tokenURI(uint256 tokenId) external view returns (string memory);
+}

package/smart-contracts/interfaces/IERC721Receiver.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+interface IERC721Receiver {
+    function onERC721Received(
+        address operator,
+        address from,
+        uint256 tokenId,
+        bytes calldata data
+    ) external returns (bytes4);
+}

package/storage/index.js

@@ -0,0 +1,112 @@
+'use strict';
+
+/**
+ * QVTX Neural Storage Module
+ * Decentralized storage utilities with IPFS and Arweave support
+ */
+
+const crypto = require('crypto');
+
+class QVTXStorage {
+    constructor(config = {}) {
+        this.provider = config.provider || 'ipfs';
+        this.gateway = config.gateway || 'https://ipfs.io/ipfs/';
+        this.apiKey = config.apiKey || null;
+    }
+
+    // Generate content hash
+    hash(content) {
+        return crypto.createHash('sha256').update(content).digest('hex');
+    }
+
+    // Upload to IPFS via Pinata or Infura
+    async uploadToIPFS(content, options = {}) {
+        if (!this.apiKey) {
+            throw new Error('IPFS API key required. Set apiKey in config.');
+        }
+
+        const axios = require('axios');
+        const FormData = require('form-data');
+
+        const form = new FormData();
+
+        if (typeof content === 'string') {
+            form.append('file', Buffer.from(content), {
+                filename: options.filename || 'data.json'
+            });
+        } else {
+            form.append('file', content);
+        }
+
+        const response = await axios.post('https://api.pinata.cloud/pinning/pinFileToIPFS', form, {
+            headers: {
+                ...form.getHeaders(),
+                'Authorization': `Bearer ${this.apiKey}`
+            }
+        });
+
+        return {
+            hash: response.data.IpfsHash,
+            url: this.gateway + response.data.IpfsHash,
+            size: response.data.PinSize
+        };
+    }
+
+    // Fetch from IPFS
+    async fetchFromIPFS(hash) {
+        const axios = require('axios');
+        const url = this.gateway + hash;
+        const response = await axios.get(url);
+        return response.data;
+    }
+
+    // Create metadata for NFT
+    createNFTMetadata(name, description, image, attributes = []) {
+        return {
+            name,
+            description,
+            image,
+            attributes: attributes.map(attr => ({
+                trait_type: attr.trait,
+                value: attr.value
+            }))
+        };
+    }
+
+    // Store encrypted data
+    async storeEncrypted(data, password) {
+        const algorithm = 'aes-256-gcm';
+        const key = crypto.scryptSync(password, 'qvtx-salt', 32);
+        const iv = crypto.randomBytes(16);
+
+        const cipher = crypto.createCipheriv(algorithm, key, iv);
+        let encrypted = cipher.update(JSON.stringify(data), 'utf8', 'hex');
+        encrypted += cipher.final('hex');
+
+        const authTag = cipher.getAuthTag();
+
+        return {
+            encrypted,
+            iv: iv.toString('hex'),
+            authTag: authTag.toString('hex')
+        };
+    }
+
+    // Retrieve encrypted data
+    async retrieveEncrypted(encryptedData, password) {
+        const algorithm = 'aes-256-gcm';
+        const key = crypto.scryptSync(password, 'qvtx-salt', 32);
+        const iv = Buffer.from(encryptedData.iv, 'hex');
+        const authTag = Buffer.from(encryptedData.authTag, 'hex');
+
+        const decipher = crypto.createDecipheriv(algorithm, key, iv);
+        decipher.setAuthTag(authTag);
+
+        let decrypted = decipher.update(encryptedData.encrypted, 'hex', 'utf8');
+        decrypted += decipher.final('utf8');
+
+        return JSON.parse(decrypted);
+    }
+}
+
+module.exports = QVTXStorage;