Manual Review

      function recoverToken(uint256 amount) external onlyOwner {
          uint256 maxRecoverable = balanceOf(address(this)) - getAllPending();
          if (amount > maxRecoverable) revert InvalidAmountToRecover(amount, maxRecoverable);

          _update(address(this), msg.sender, amount);
      }

      function recoverForeignERC20(address tokenAddress, uint256 amount) external onlyOwner {
          if (tokenAddress == address(this)) revert InvalidToken(tokenAddress);

          IERC20(tokenAddress).safeTransfer(msg.sender, amount);
      }
          

          function updateSwapThreshold(uint16 _swapThresholdRatio) public onlyOwner {
              if (_swapThresholdRatio == 0 || _swapThresholdRatio > 500) revert InvalidSwapThresholdRatio(_swapThresholdRatio);

              swapThresholdRatio = _swapThresholdRatio;
              
              emit SwapThresholdUpdated(_swapThresholdRatio);
          }
          

          function marketingyasociacionesAddressSetup(address _newAddress) public onlyOwner {
          if (_newAddress == address(0)) revert InvalidTaxRecipientAddress(address(0));

          marketingyasociacionesAddress = _newAddress;
          excludeFromFees(_newAddress, true);
          _excludeFromLimits(_newAddress, true);

          emit WalletTaxAddressUpdated(1, _newAddress);
         }
          

        function excludeFromFees(address account, bool isExcluded) public onlyOwner {
            isExcludedFromFees[account] = isExcluded;
            
            emit ExcludeFromFees(account, isExcluded);
        }
          

        function updateMaxWalletAmount(uint256 _maxWalletAmount) public onlyOwner {
            if (_maxWalletAmount < _maxWalletSafeLimit()) revert MaxWalletAmountTooLow(_maxWalletAmount, _maxWalletSafeLimit());

            maxWalletAmount = _maxWalletAmount;
            
            emit MaxWalletAmountUpdated(_maxWalletAmount);
        }

        function _maxWalletSafeLimit() private view returns (uint256) {
            return totalSupply() / 1000;
        }
          

    function _maxTxSafeLimit() private view returns (uint256) {
        return totalSupply() * 5 / 10000;
    }

    function updateMaxBuyAmount(uint256 _maxBuyAmount) public onlyOwner {
        if (_maxBuyAmount < _maxTxSafeLimit()) revert MaxTransactionAmountTooLow(_maxBuyAmount, _maxTxSafeLimit());

        maxBuyAmount = _maxBuyAmount;
        
        emit MaxBuyAmountUpdated(_maxBuyAmount);
    }

    function updateMaxSellAmount(uint256 _maxSellAmount) public onlyOwner {
        if (_maxSellAmount < _maxTxSafeLimit()) revert MaxTransactionAmountTooLow(_maxSellAmount, _maxTxSafeLimit());

        maxSellAmount = _maxSellAmount;
        
        emit MaxSellAmountUpdated(_maxSellAmount);
    }

    function updateMaxTransferAmount(uint256 _maxTransferAmount) public onlyOwner {
        if (_maxTransferAmount < _maxTxSafeLimit()) revert MaxTransactionAmountTooLow(_maxTransferAmount, _maxTxSafeLimit());

        maxTransferAmount = _maxTransferAmount;
        
        emit MaxTransferAmountUpdated(_maxTransferAmount);
    }
          

Disclaimer: This smart contract audit report, conducted by SecureWise, is intended for informational purposes only. It does not constitute an endorsement, investment advice, or a guarantee of any kind. The audit involved code analysis, manual review, testing, and risk classification.