Fix build errors and dependency conflicts in SEQICO smart contract project

README.md

@@ -13,11 +13,18 @@ This project contains:
 
 ### SEQICO Contract
 - Buy SEQ tokens with ETH, USDT, or USDC
-- Configurable pricing for each payment method
+- **$3 minimum price validation** for all payment methods
+- Configurable pricing for each payment method with owner-only access
 - Owner-only functions for token management and fund withdrawal
 - Automatic ETH refunds for overpayments
 - Event logging for all purchases
 
+#### Price Validation
+- **Minimum price constants**: $3 USD equivalent for all currencies
+- **Strict enforcement**: Prevents setting prices below minimum thresholds
+- **Owner-only access**: Only contract owner can modify prices
+- **Comprehensive testing**: Full test suite validates all edge cases
+
 ### SEQToken Contract
 - Standard ERC20 token
 - Initial distribution: 10% to owner, 90% to ICO contract
@@ -44,16 +51,68 @@ npx hardhat run scripts/deploy.js
 npx hardhat run scripts/deploy-DE.js
 ```
 
+4. Run tests:
+```bash
+# Run the comprehensive test suite
+npm test
+
+# Run specific test categories
+npx hardhat test --grep "Price Setting Functions"
+```
+
+5. Verify and debug deployment:
+```bash
+# Verify price validation (set SEQICO_ADDRESS to your deployed contract)
+SEQICO_ADDRESS=0x... npx hardhat run scripts/verify-price-validation.js
+
+# Debug transactions if needed
+SEQICO_ADDRESS=0x... TX_HASH=0x... npx hardhat run scripts/debug-transactions.js
+```
+
 ## Contract Functions
 
 ### SEQICO Contract
 - `buyWithETH(uint256 tokenAmount)`: Purchase tokens with ETH
 - `buyWithUSDT(uint256 tokenAmount)`: Purchase tokens with USDT
 - `buyWithUSDC(uint256 tokenAmount)`: Purchase tokens with USDC
 - `setSEQToken(address _seqToken)`: Update SEQ token address (owner only)
+- `setPricePerTokenETH(uint256 _pricePerTokenETH)`: Set ETH price per token (owner only, ≥$3)
+- `setPricePerTokenUSDT(uint256 _pricePerTokenUSDT)`: Set USDT price per token (owner only, ≥$3)
+- `setPricePerTokenUSDC(uint256 _pricePerTokenUSDC)`: Set USDC price per token (owner only, ≥$3)
 - `withdrawETH(address payable recipient)`: Withdraw collected ETH (owner only)
 - `withdrawERC20(address token, address recipient)`: Withdraw ERC20 tokens (owner only)
 
+### Price Validation Constants
+- `MIN_PRICE_USD`: 3,000,000 (represents $3.00 with 6 decimals)
+- `MIN_PRICE_ETH`: 0.001 ETH (conservative minimum ~$3 when ETH > $3000)
+
+## Testing and Debugging
+
+### Automated Test Suite
+The project includes comprehensive tests covering:
+- ✅ $3 minimum price validation for all currencies
+- ✅ Owner-only access control for price setting functions
+- ✅ Purchase function validation with all payment methods
+- ✅ Edge cases and error conditions
+- ✅ Contract deployment validation
+
+### Debugging Tools
+- **Price Verification Script**: `scripts/verify-price-validation.js`
+- **Transaction Debugger**: `scripts/debug-transactions.js`
+- **Comprehensive Documentation**: `docs/TESTING_AND_DEBUGGING.md`
+
+### Usage Examples
+```bash
+# Run all tests
+npm test
+
+# Verify deployed contract
+SEQICO_ADDRESS=0x123... npx hardhat run scripts/verify-price-validation.js
+
+# Debug a failed transaction
+SEQICO_ADDRESS=0x123... TX_HASH=0xabc... npx hardhat run scripts/debug-transactions.js
+```
+
 ## Configuration
 
 The deployment scripts include configurable parameters:

contracts/MockERC20.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+contract MockERC20 is ERC20 {
+    uint8 private _decimals;
+
+    constructor(
+        string memory name,
+        string memory symbol,
+        uint256 totalSupply
+    ) ERC20(name, symbol) {
+        // Determine decimals based on symbol for consistency with common tokens
+        if (keccak256(bytes(symbol)) == keccak256(bytes("USDT")) || 
+            keccak256(bytes(symbol)) == keccak256(bytes("USDC"))) {
+            _decimals = 6;
+        } else {
+            _decimals = 18;
+        }
+
+        _mint(msg.sender, totalSupply);
+    }
+
+    function decimals() public view virtual override returns (uint8) {
+        return _decimals;
+    }
+}

contracts/SEQICO.sol

@@ -13,6 +13,10 @@ contract SEQICO is Ownable {
     uint256 public pricePerTokenUSDT;
     uint256 public pricePerTokenUSDC;
 
+    // Minimum price constants (equivalent to $3 USD)
+    uint256 public constant MIN_PRICE_USD = 3 * 1e6; // $3 in 6 decimal format (USDT/USDC)
+    uint256 public constant MIN_PRICE_ETH = 0.001 ether; // Conservative minimum (~$3 when ETH > $3000)
+
     event TokensPurchased(address indexed buyer, uint256 amount, string payment);
 
     constructor(
@@ -26,6 +30,12 @@ contract SEQICO is Ownable {
         seqToken = IERC20(_seqToken);
         usdt = IERC20(_usdt);
         usdc = IERC20(_usdc);
+
+        // Validate minimum prices during deployment
+        require(_pricePerTokenETH >= MIN_PRICE_ETH, "Price must be greater than or equal to $3");
+        require(_pricePerTokenUSDT >= MIN_PRICE_USD, "Price must be greater than or equal to $3");
+        require(_pricePerTokenUSDC >= MIN_PRICE_USD, "Price must be greater than or equal to $3");
+
         pricePerTokenETH = _pricePerTokenETH;
         pricePerTokenUSDT = _pricePerTokenUSDT;
         pricePerTokenUSDC = _pricePerTokenUSDC;
@@ -35,9 +45,24 @@ contract SEQICO is Ownable {
         seqToken = IERC20(_seqToken);
     }
 
+    function setPricePerTokenETH(uint256 _pricePerTokenETH) external onlyOwner {
+        require(_pricePerTokenETH >= MIN_PRICE_ETH, "Price must be greater than or equal to $3");
+        pricePerTokenETH = _pricePerTokenETH;
+    }
+
+    function setPricePerTokenUSDT(uint256 _pricePerTokenUSDT) external onlyOwner {
+        require(_pricePerTokenUSDT >= MIN_PRICE_USD, "Price must be greater than or equal to $3");
+        pricePerTokenUSDT = _pricePerTokenUSDT;
+    }
+
+    function setPricePerTokenUSDC(uint256 _pricePerTokenUSDC) external onlyOwner {
+        require(_pricePerTokenUSDC >= MIN_PRICE_USD, "Price must be greater than or equal to $3");
+        pricePerTokenUSDC = _pricePerTokenUSDC;
+    }
+
     function buyWithETH(uint256 tokenAmount) external payable {
         require(tokenAmount > 0, "Amount must be greater than 0");
-        uint256 requiredETH = pricePerTokenETH * tokenAmount;
+        uint256 requiredETH = pricePerTokenETH * tokenAmount / 1e18; // Properly account for token decimals
         require(msg.value >= requiredETH, "Insufficient ETH sent");
         require(seqToken.balanceOf(address(this)) >= tokenAmount, "Not enough SEQ tokens");