uups-checker 1.0.0

package/audits/DestraNetwork-security-audit-20260324.md

@@ -0,0 +1,705 @@
+# 🔐 Security Audit — Destra Network (DSync) Token
+
+---
+
+## Scope
+
+|                                  |                                                        |
+| -------------------------------- | ------------------------------------------------------ |
+| **Contract Name**                | DestraNetwork                                          |
+| **Token Symbol**                 | DSync                                                  |
+| **Compiler Version**             | Solidity 0.8.17                                        |
+| **Contract Type**                | ERC20 Token with Trading Controls & Fee Mechanism     |
+| **Audit Date**                   | March 24, 2026                                         |
+| **Confidence Threshold (1-100)** | 95                                                     |
+
+---
+
+## Executive Summary
+
+The Destra Network token is a standard ERC20 token with additional features including:
+- Trading controls and launch mechanism
+- Buy/sell transaction limits
+- Wallet size limits
+- Fee-on-transfer mechanism (5% buy, 60% sell)
+- Blacklist functionality
+- Team-controlled functions
+
+**Overall Risk**: 🟠 **MEDIUM-HIGH**
+
+The contract contains several **centralization risks** and **potential rug pull mechanisms** that give excessive power to the owner and team members.
+
+---
+
+## 🚨 CRITICAL & HIGH SEVERITY FINDINGS
+
+### [95] 🔴 **CRITICAL: Extreme Sell Tax (60%) - Potential Rug Pull**
+
+**Location**: `marketingSellFee = 6000` (line ~220)
+
+**Description**:
+The contract has a **60% sell tax** which is extremely high and creates a significant barrier to exit. This is a common rug pull pattern where:
+1. Users can buy with low tax (5%)
+2. Users cannot profitably sell due to 60% tax
+3. Team can change fees or extract value
+
+```solidity
+uint256 marketingBuyFee = 500;      // 5% buy fee
+uint256 marketingSellFee = 6000;    // 60% sell fee ⚠️ EXTREME
+```
+
+**Impact**:
+- Users lose 60% of value when selling
+- Creates one-way liquidity trap
+- Team can accumulate fees and rug pull
+- Similar to honeypot mechanism
+
+**Proof of Concept**:
+```solidity
+// User buys 100 tokens, pays 5% fee = 95 tokens received
+// User tries to sell 95 tokens, pays 60% fee = 38 tokens received
+// Net loss: 62% of original investment
+```
+
+**Recommendation**:
+```diff
+- uint256 marketingSellFee = 6000;  // 60%
++ uint256 marketingSellFee = 500;   // 5% (match buy fee)
++ 
++ // Add maximum fee limit
++ function setFees(...) external onlyOwner {
++     require(totalBuyFee <= 1000, "Buy fee too high");   // Max 10%
++     require(totalSellFee <= 1000, "Sell fee too high"); // Max 10%
++     ...
++ }
+```
+
+---
+
+### [92] 🔴 **CRITICAL: Unlimited Blacklist Power - Funds Can Be Frozen**
+
+**Location**: `blacklistWallets()` function (line ~380)
+
+**Description**:
+Team members can blacklist ANY wallet at ANY time with NO restrictions. Blacklisted wallets cannot transfer tokens, effectively freezing their funds permanently.
+
+```solidity
+function blacklistWallets(address[] calldata _wallets, bool _blacklist) external onlyTeam {
+    for (uint i = 0; i < _wallets.length; i++) {
+        if (_blacklist) {
+            blacklistCount++;
+            emit WalletBlacklisted(tx.origin, _wallets[i], block.number);
+        } else {
+            if (blacklist[_wallets[i]] != 0) blacklistCount--;
+        }
+        blacklist[_wallets[i]] = _blacklist ? block.number : 0;
+    }
+}
+
+// In checkTxLimit:
+require(blacklist[sender] == 0, "Wallet blacklisted!");
+```
+
+**Attack Scenario**:
+1. User buys tokens
+2. Team blacklists user's wallet
+3. User cannot sell or transfer tokens
+4. Funds permanently frozen
+
+**Impact**:
+- Complete loss of funds for blacklisted users
+- No timelock or governance
+- No appeal mechanism
+- Can be used to prevent selling
+
+**Recommendation**:
+```diff
++ // Add timelock for blacklisting
++ mapping(address => uint256) public blacklistProposal;
++ uint256 constant BLACKLIST_DELAY = 24 hours;
++ 
+  function blacklistWallets(address[] calldata _wallets, bool _blacklist) external onlyTeam {
++     require(_wallets.length <= 10, "Too many wallets");
+      for (uint i = 0; i < _wallets.length; i++) {
++         // Require timelock
++         if (_blacklist) {
++             require(block.timestamp >= blacklistProposal[_wallets[i]] + BLACKLIST_DELAY, "Timelock");
++         }
+          ...
+      }
+  }
++ 
++ function proposeBlacklist(address wallet) external onlyTeam {
++     blacklistProposal[wallet] = block.timestamp;
++ }
+```
+
+---
+
+### [90] 🔴 **HIGH: Centralized Fee Control - Can Be Changed to 100%**
+
+**Location**: `setFees()` function (line ~560)
+
+**Description**:
+Owner can change fees to ANY value at ANY time with NO maximum limits (except liquidity fee parity check). This allows setting fees to 100%, effectively preventing all trading.
+
+```solidity
+function setFees(
+    uint256 _liquidityBuyFee,
+    uint256 _liquiditySellFee,
+    uint256 _marketingBuyFee,
+    uint256 _marketingSellFee,
+    uint256 _feeDenominator
+) external onlyOwner {
+    // Only checks liquidity fee is even, NO maximum fee check
+    require(((_liquidityBuyFee + _liquiditySellFee) / 2) * 2 == (_liquidityBuyFee + _liquiditySellFee), 
+            "Liquidity fee must be an even number for rounding compatibility.");
+    
+    liquidityBuyFee = _liquidityBuyFee;
+    liquiditySellFee = _liquiditySellFee;
+    marketingBuyFee = _marketingBuyFee;
+    marketingSellFee = _marketingSellFee;
+    totalBuyFee = _liquidityBuyFee + _marketingBuyFee;
+    totalSellFee = _liquiditySellFee + _marketingSellFee;
+    feeDenominator = _feeDenominator;
+}
+```
+
+**Attack Scenario**:
+```solidity
+// Owner calls:
+setFees(0, 0, 10000, 10000, 10000);
+// Result: 100% buy and sell fees
+// All trades now take 100% fee, tokens become untradeable
+```
+
+**Impact**:
+- Can make token untradeable
+- Can trap users by setting 100% fees
+- No protection for holders
+
+**Recommendation**:
+```diff
+  function setFees(...) external onlyOwner {
++     // Add maximum fee limits
++     require(_liquidityBuyFee + _marketingBuyFee <= 1000, "Buy fee > 10%");
++     require(_liquiditySellFee + _marketingSellFee <= 1000, "Sell fee > 10%");
++     require(_feeDenominator >= 100, "Denominator too small");
+      ...
+  }
+```
+
+---
+
+### [88] 🔴 **HIGH: Team Can Drain Contract ETH**
+
+**Location**: `clearStuckBalance()` function (line ~370)
+
+**Description**:
+Team members can withdraw ANY percentage of contract ETH to ANY address with NO restrictions. This includes ETH from fees that should go to marketing/liquidity.
+
+```solidity
+function clearStuckBalance(uint256 amountPercentage, address adr) external onlyTeam {
+    uint256 amountETH = address(this).balance;
+    if (amountETH > 0) {
+        (bool sent, ) = adr.call{value: (amountETH * amountPercentage) / 100}("");
+        require(sent, "Failed to transfer funds");
+    }
+}
+```
+
+**Attack Scenario**:
+1. Contract accumulates 100 ETH from fees
+2. Team calls `clearStuckBalance(100, attackerAddress)`
+3. All 100 ETH sent to attacker
+4. Legitimate fee distribution bypassed
+
+**Impact**:
+- Complete loss of accumulated fees
+- Marketing/liquidity funds stolen
+- No accountability
+
+**Recommendation**:
+```diff
+  function clearStuckBalance(uint256 amountPercentage, address adr) external onlyTeam {
++     // Only allow withdrawing truly stuck tokens, not fee ETH
++     require(amountPercentage <= 10, "Max 10% at a time");
++     require(adr == marketingFeeReceiver || adr == liquidityFeeReceiver, "Invalid recipient");
+      uint256 amountETH = address(this).balance;
+      if (amountETH > 0) {
+          (bool sent, ) = adr.call{value: (amountETH * amountPercentage) / 100}("");
+          require(sent, "Failed to transfer funds");
+      }
+  }
+```
+
+---
+
+### [85] 🟠 **HIGH: No Maximum Transaction Limit Enforcement**
+
+**Location**: `setTxLimit()` function (line ~540)
+
+**Description**:
+Owner can set transaction limits to 0 or to 100% of supply, effectively disabling limits or making token untradeable.
+
+```solidity
+function setTxLimit(uint256 buyNumerator, uint256 sellNumerator, uint256 divisor) external onlyOwner {
+    require(buyNumerator > 0 && sellNumerator > 0 && divisor > 0 && divisor <= 10000);
+    _maxBuyTxAmount = (_totalSupply * buyNumerator) / divisor;
+    _maxSellTxAmount = (_totalSupply * sellNumerator) / divisor;
+}
+```
+
+**Attack Scenario**:
+```solidity
+// Owner calls:
+setTxLimit(1, 1, 10000);
+// Result: Max buy = 0.01%, max sell = 0.01%
+// Users can only trade 100,000 tokens at a time (0.01% of 1B supply)
+// Effectively makes trading impossible for large holders
+```
+
+**Recommendation**:
+```diff
+  function setTxLimit(uint256 buyNumerator, uint256 sellNumerator, uint256 divisor) external onlyOwner {
+      require(buyNumerator > 0 && sellNumerator > 0 && divisor > 0 && divisor <= 10000);
++     // Ensure minimum 0.1% transaction limit
++     require(buyNumerator * 1000 >= divisor, "Buy limit too low");
++     require(sellNumerator * 1000 >= divisor, "Sell limit too low");
+      _maxBuyTxAmount = (_totalSupply * buyNumerator) / divisor;
+      _maxSellTxAmount = (_totalSupply * sellNumerator) / divisor;
+  }
+```
+
+---
+
+## 🟡 MEDIUM SEVERITY FINDINGS
+
+### [80] 🟡 **MEDIUM: Reentrancy Risk in swapBack()**
+
+**Location**: `swapBack()` function (line ~490)
+
+**Description**:
+The `swapBack()` function makes external calls to Uniswap router and fee receivers without following checks-effects-interactions pattern. While protected by `swapping` modifier, the pattern is still risky.
+
+```solidity
+function swapBack(uint256 amount) internal swapping {
+    // ... calculations ...
+    
+    router.swapExactTokensForETHSupportingFeeOnTransferTokens(...);  // External call
+    
+    uint256 amountETH = address(this).balance - balanceBefore;
+    
+    if (amountETHMarketing > 0) {
+        (bool sentMarketing, ) = marketingFeeReceiver.call{value: amountETHMarketing}("");  // External call
+        if (!sentMarketing) {
+            //Failed to transfer to marketing wallet
+        }
+    }
+    
+    if (amountToLiquify > 0) {
+        router.addLiquidityETH{value: amountETHLiquidity}(...);  // External call
+    }
+    
+    swapBackCounter[block.number] = swapBackCounter[block.number] + 1;  // State change AFTER external calls
+}
+```
+
+**Issue**:
+- State changes happen after external calls
+- If `marketingFeeReceiver` is a malicious contract, it could attempt reentrancy
+- `swapping` modifier provides protection, but pattern is still poor
+
+**Recommendation**:
+```diff
+  function swapBack(uint256 amount) internal swapping {
++     // Update state BEFORE external calls
++     swapBackCounter[block.number] = swapBackCounter[block.number] + 1;
++     
+      // ... calculations ...
+      
+      router.swapExactTokensForETHSupportingFeeOnTransferTokens(...);
+      
+      // ... rest of function ...
+-     
+-     swapBackCounter[block.number] = swapBackCounter[block.number] + 1;
+  }
+```
+
+---
+
+### [78] 🟡 **MEDIUM: Silent Failure in Marketing Fee Transfer**
+
+**Location**: `swapBack()` function (line ~515)
+
+**Description**:
+If the marketing fee transfer fails, the function silently continues without reverting or emitting an event. This means fees could be lost.
+
+```solidity
+if (amountETHMarketing > 0) {
+    (bool sentMarketing, ) = marketingFeeReceiver.call{value: amountETHMarketing}("");
+    if (!sentMarketing) {
+        //Failed to transfer to marketing wallet
+        // ⚠️ No revert, no event, ETH stays in contract
+    }
+}
+```
+
+**Impact**:
+- Marketing fees accumulate in contract
+- Team can later extract via `clearStuckBalance()`
+- Lack of transparency
+
+**Recommendation**:
+```diff
+  if (amountETHMarketing > 0) {
+      (bool sentMarketing, ) = marketingFeeReceiver.call{value: amountETHMarketing}("");
+-     if (!sentMarketing) {
+-         //Failed to transfer to marketing wallet
+-     }
++     require(sentMarketing, "Marketing transfer failed");
+  }
+```
+
+---
+
+### [75] 🟡 **MEDIUM: Airdrop Function Can Be Abused**
+
+**Location**: `airdrop()` function (line ~360)
+
+**Description**:
+The airdrop function has no limits on number of recipients or amounts, and can be called multiple times. This could be used to:
+1. Bypass transaction limits
+2. Distribute tokens to many wallets to avoid detection
+3. Manipulate holder count
+
+```solidity
+function airdrop(address[] calldata addresses, uint256[] calldata amounts) external onlyOwner {
+    require(addresses.length > 0 && amounts.length == addresses.length);
+    address from = msg.sender;
+
+    for (uint i = 0; i < addresses.length; i++) {
+        if (!liquidityPools[addresses[i]] && !isLiquidityCreator[addresses[i]]) {
+            _basicTransfer(from, addresses[i], amounts[i] * (10 ** _decimals));
+        }
+    }
+}
+```
+
+**Issues**:
+- No limit on array length (gas limit only)
+- No limit on total amount
+- Bypasses all transfer restrictions
+- Can be used before trading is enabled
+
+**Recommendation**:
+```diff
+  function airdrop(address[] calldata addresses, uint256[] calldata amounts) external onlyOwner {
+      require(addresses.length > 0 && amounts.length == addresses.length);
++     require(addresses.length <= 200, "Too many recipients");
++     
+      address from = msg.sender;
++     uint256 totalAmount = 0;
+
+      for (uint i = 0; i < addresses.length; i++) {
++         totalAmount += amounts[i] * (10 ** _decimals);
+          if (!liquidityPools[addresses[i]] && !isLiquidityCreator[addresses[i]]) {
+              _basicTransfer(from, addresses[i], amounts[i] * (10 ** _decimals));
+          }
+      }
++     
++     require(totalAmount <= _totalSupply / 10, "Airdrop amount too large");
+  }
+```
+
+---
+
+### [72] 🟡 **MEDIUM: Team Member Management Lacks Safeguards**
+
+**Location**: `setTeamMember()` function (line ~355)
+
+**Description**:
+Owner can add unlimited team members who have powerful privileges (blacklist, drain ETH, open trading). No limit on number of team members and no way to see who they are.
+
+```solidity
+function setTeamMember(address _team, bool _enabled) external onlyOwner {
+    teamMembers[_team] = _enabled;
+}
+
+modifier onlyTeam() {
+    require(teamMembers[_msgSender()] || msg.sender == owner(), "Caller is not a team member");
+    _;
+}
+```
+
+**Issues**:
+- No limit on team members
+- No public list of team members
+- Team members have critical powers
+- No timelock for adding team members
+
+**Recommendation**:
+```diff
++ address[] public teamMemberList;
++ uint256 public constant MAX_TEAM_MEMBERS = 5;
++ 
+  function setTeamMember(address _team, bool _enabled) external onlyOwner {
++     require(_team != address(0), "Invalid address");
++     
++     if (_enabled) {
++         require(teamMemberList.length < MAX_TEAM_MEMBERS, "Too many team members");
++         teamMemberList.push(_team);
++     } else {
++         // Remove from list
++         for (uint i = 0; i < teamMemberList.length; i++) {
++             if (teamMemberList[i] == _team) {
++                 teamMemberList[i] = teamMemberList[teamMemberList.length - 1];
++                 teamMemberList.pop();
++                 break;
++             }
++         }
++     }
++     
+      teamMembers[_team] = _enabled;
+  }
++ 
++ function getTeamMembers() external view returns (address[] memory) {
++     return teamMemberList;
++ }
+```
+
+---
+
+## 🔵 LOW SEVERITY & INFORMATIONAL
+
+### [65] 🔵 **LOW: Missing Events for Critical State Changes**
+
+Several critical functions don't emit events:
+- `setTeamMember()` - No event when team member added/removed
+- `clearStuckBalance()` - No event when ETH withdrawn
+- `openTrading()` - No event when trading enabled
+- `toggleTransferTax()` - No event when transfer tax toggled
+
+**Recommendation**: Add events for all state-changing functions.
+
+---
+
+### [60] 🔵 **LOW: Inconsistent Use of tx.origin**
+
+**Location**: `blacklistWallets()` function
+
+```solidity
+emit WalletBlacklisted(tx.origin, _wallets[i], block.number);
+```
+
+Using `tx.origin` instead of `msg.sender` can be misleading and is generally discouraged.
+
+**Recommendation**:
+```diff
+- emit WalletBlacklisted(tx.origin, _wallets[i], block.number);
++ emit WalletBlacklisted(msg.sender, _wallets[i], block.number);
+```
+
+---
+
+### [55] 🔵 **INFO: Hardcoded Fee Receiver Addresses**
+
+**Location**: Constructor
+
+```solidity
+address payable public liquidityFeeReceiver = payable(0xa75bFFD82FFE8A5064A5b6122448221aCEbCf950);
+address payable public marketingFeeReceiver = payable(0xa75bFFD82FFE8A5064A5b6122448221aCEbCf950);
+```
+
+Both receivers point to the same address. While this can be changed later, it's worth noting for transparency.
+
+---
+
+### [50] 🔵 **INFO: No Pause Mechanism**
+
+The contract has no emergency pause function. If a critical bug is discovered, there's no way to stop trading temporarily.
+
+**Recommendation**: Consider adding OpenZeppelin's Pausable pattern.
+
+---
+
+## 📊 Centralization Risks Summary
+
+| Function | Risk | Impact |
+|----------|------|--------|
+| `setFees()` | 🔴 CRITICAL | Can set 100% fees, make token untradeable |
+| `blacklistWallets()` | 🔴 CRITICAL | Can freeze any wallet permanently |
+| `clearStuckBalance()` | 🔴 HIGH | Can drain all contract ETH |
+| `setTxLimit()` | 🟠 HIGH | Can make trading impossible |
+| `setMaxWallet()` | 🟠 HIGH | Can prevent buying |
+| `setTeamMember()` | 🟡 MEDIUM | Can add unlimited team members |
+| `openTrading()` | 🟡 MEDIUM | Team controls when trading starts |
+| `renounceOwnership()` | ⚠️ WARNING | Owner can renounce, but team still has power |
+
+---
+
+## 🚨 Rug Pull Risk Assessment
+
+**Overall Risk**: 🔴 **HIGH**
+
+### Red Flags:
+
+1. ✅ **60% Sell Tax** - Extreme exit barrier
+2. ✅ **Unlimited Blacklist Power** - Can freeze funds
+3. ✅ **No Fee Limits** - Can set 100% fees
+4. ✅ **ETH Drain Function** - Can steal accumulated fees
+5. ✅ **Team Powers** - Multiple people with critical access
+6. ✅ **No Timelock** - All changes instant
+7. ✅ **No Governance** - Pure centralized control
+
+### Rug Pull Scenarios:
+
+**Scenario 1: Fee Rug Pull**
+```
+1. Users buy tokens (5% fee)
+2. Price increases
+3. Owner sets sell fee to 100%
+4. Users cannot sell
+5. Owner/team sells their tokens
+6. Owner drains accumulated fees via clearStuckBalance()
+```
+
+**Scenario 2: Blacklist Rug Pull**
+```
+1. Users buy tokens
+2. Large holders identified
+3. Team blacklists large holders
+4. Large holders cannot sell
+5. Team dumps their tokens
+6. Price crashes, blacklisted users lose everything
+```
+
+**Scenario 3: Limit Rug Pull**
+```
+1. Users buy tokens
+2. Owner sets transaction limits to 0.01%
+3. Users can only sell tiny amounts
+4. Team sells large amounts (they're exempt)
+5. Price crashes before users can exit
+```
+
+---
+
+## 🎯 Recommendations Summary
+
+### Critical (Must Fix):
+
+1. **Add Maximum Fee Limits**
+   - Buy fee max: 10%
+   - Sell fee max: 10%
+   - Reduce current 60% sell fee to 5%
+
+2. **Add Blacklist Timelock**
+   - 24-hour delay before blacklist takes effect
+   - Limit number of wallets that can be blacklisted
+   - Add appeal mechanism
+
+3. **Restrict ETH Withdrawal**
+   - Only allow withdrawing to fee receivers
+   - Add maximum percentage limit (10%)
+   - Add timelock
+
+4. **Add Transaction Limit Minimums**
+   - Minimum 0.1% of supply per transaction
+   - Prevent setting limits too low
+
+### High Priority:
+
+5. **Add Timelock for Critical Functions**
+   - Fee changes: 24-hour delay
+   - Limit changes: 24-hour delay
+   - Team member additions: 24-hour delay
+
+6. **Improve Transparency**
+   - Add events for all state changes
+   - Make team member list public
+   - Add getter functions for all settings
+
+7. **Add Emergency Pause**
+   - Implement pausable pattern
+   - Require multisig for pause/unpause
+
+### Medium Priority:
+
+8. **Fix Reentrancy Pattern**
+   - Move state changes before external calls
+   - Add ReentrancyGuard from OpenZeppelin
+
+9. **Improve Error Handling**
+   - Revert on failed marketing transfer
+   - Add proper error messages
+
+10. **Limit Airdrop Function**
+    - Max 200 recipients per call
+    - Max 10% of supply per airdrop
+
+---
+
+## 📈 Gas Optimization Opportunities
+
+1. **Pack Storage Variables**: Some bool and uint256 variables could be packed
+2. **Cache Array Length**: In loops, cache `addresses.length`
+3. **Use Unchecked**: For counter increments in loops (Solidity 0.8.17)
+
+---
+
+## ✅ Positive Aspects
+
+1. ✅ Uses Solidity 0.8.17 (built-in overflow protection)
+2. ✅ Standard ERC20 implementation
+3. ✅ Reasonable initial limits (1% max transaction, 1% max wallet)
+4. ✅ SwapBack rate limiting to prevent MEV
+5. ✅ Proper use of modifiers for access control
+6. ✅ Events for important actions
+
+---
+
+## 🎓 Conclusion
+
+The Destra Network token contract is **functional but contains significant centralization risks** that could lead to rug pulls or user fund loss.
+
+### Risk Summary:
+
+| Category | Risk Level | Details |
+|----------|-----------|---------|
+| Rug Pull Risk | 🔴 HIGH | 60% sell tax, unlimited blacklist, no limits on fees |
+| Centralization | 🔴 HIGH | Owner and team have excessive power |
+| Code Quality | 🟢 GOOD | Clean code, standard patterns |
+| Gas Efficiency | 🟡 MEDIUM | Some optimization opportunities |
+| Documentation | 🟡 MEDIUM | Basic comments, could be improved |
+
+### Final Verdict:
+
+**NOT RECOMMENDED FOR INVESTMENT** without significant changes to reduce centralization and add protections for users.
+
+### For Users:
+
+⚠️ **HIGH RISK** - Be aware of:
+- 60% sell tax (you lose 60% when selling)
+- Team can blacklist your wallet anytime
+- Team can change fees to 100% anytime
+- No governance or timelock protections
+
+### For Developers:
+
+Implement the critical recommendations above, especially:
+1. Reduce sell tax to reasonable level (5-10%)
+2. Add maximum fee limits
+3. Add timelock for critical functions
+4. Restrict blacklist power
+5. Add transparency features
+
+---
+
+**Audit Date**: March 24, 2026  
+**Auditor**: Security Research Team  
+**Status**: ⚠️ HIGH RISK - SIGNIFICANT ISSUES FOUND
+
+---
+
+*This audit is for educational and informational purposes. Always conduct your own research and consider multiple audits before investing.*