0xe85562c6ff86a8ff0268222aff0205a26d37d68e
As of 21 Nov 2026, Trustblock’s record holds 0xe85562c6ff86a8ff0268222aff0205a26d37d68e on BNB Chain as a contract of TOP PROTOCOL. 1 audit report on Trustblock lists this address: CertiK, 1 Nov 2024. 13 findings in it are recorded as open or acknowledged.
Each report’s scope as stored on Trustblock names this address on BNB Chain.
| Audit | Security firm | Date | Commit named in the report | Report |
|---|---|---|---|---|
| TOP PROTOCOL - Audit | CertiK | Not recorded (see the report) | Open |
2 High, 4 Medium, 7 Low. In the firm’s own words; statuses are the firm’s, from each report.
All of the `TOP` tokens (10000000) are sent to the `ReceiveAddress` account. This is a centralization risk because the owner of the EOA can distribute tokens without obtaining the consensus of the community. Any compromise to these addresses may allow a hacker to steal and sell tokens on the market, resulting in severe damage to the project.
The audit on Trustblock · Open the reportThe `Top` contract relies extensively on the token pair for various liquidity calculations, such as determining whether liquidity is being added or removed, calculating output amounts, distributing rewards, and other business logic. This reliance introduces a vulnerability, as it can be exploited by whale holders or through flash loans. Potential manipulation cases include: 1. Malicious users can manipulate the pool and then call the transfer function with the recipient set to the **token** contract, thereby acquiring more USDT from the token contract. 2. Malicious users can manipulate the pool to increase the burn value when transferring tokens to the **dead** address, allowing them to gain more rewards from `processRewardDD`. 3. In `processReward`, malicious users can manipulate the pool to increase their share of LP tokens, thus enhancing their rewards from the distribution. 4. Before selling tokens, users can manually transfer a small amount of USDT to the pair to create the appearance of adding liquidity, thereby reducing fees. These examples illustrate only some of the potential manipulation scenarios. Such manipulations could result in incorrect and abnormal calculations, leading to asset losses and unintended side effects for the project.
The audit on Trustblock · Open the reportThe `_isRemoveLiquidity()` and `_isAddLiquidity()` functions are incorrect or inaccurate. It is hard to judge if it is adding/removing liquidity in one transaction. 1. The result returned may be different when the token is token0 or token1 in the pair. 2. The result returned may be different when the caller is using router or using pair's swap()/mint()/burn() functions directly. To swap like a flash loan through the linked [code logic](https://github.com/Uniswap/v2-core/blob/1136544ac842ff48ae0b1b939701436598d74075/contracts/UniswapV2Pair.sol#L172) may help the arbitrager to avoid paying the fee or gain other profits.
The audit on Trustblock · Open the reportA sandwich attack can occur when an attacker notices a transaction involving token swaps or liquidity additions that lacks slippage restrictions or minimum output amount settings. The attacker can exploit this by frontrunning the transaction to purchase one of the assets, thereby manipulating the exchange rate, and then backrunning the transaction to sell the asset for a profit. The referenced functions are invoked without setting slippage restrictions or minimum output amounts, making transactions that trigger these functions particularly vulnerable to sandwich attacks, especially when large input amounts are involved.
The audit on Trustblock · Open the reportThe functions, `processReward` and `processRewardDD`, are intended to distribute rewards among `holders` and `deadHolders`, respectively. However, the current implementation of these functions can lead to an inconsistent and potentially unfair distribution of rewards. In the `processReward` function, rewards are distributed based on the shares of LP tokens each `holder` possesses. The function utilizes the remaining gas from the transaction to determine how much reward to distribute and resumes distribution from the last stopped index. Here is a snippet: ```solidity while (gasUsed < gas && iterations < shareholderCount) { if (currentIndex >= shareholderCount) { currentIndex = 0; } shareHolder = holders[currentIndex]; tokenBalance = holdToken.balanceOf(shareHolder); if (tokenBalance > 0 && !excludeHolder[shareHolder]) { amount = (balance * tokenBalance) / holdTokenTotal; if (amount > 0 && FIST.balanceOf(address(this)) > amount) { FIST.transfer(shareHolder, amount); } } gasUsed = gasUsed + (gasLeft - gasleft()); gasLeft = gasleft(); currentIndex++; iterations++; } ``` Consider a scenario with two `holders`: `accountA` and `accountB` both holding 50 LP tokens, with `holdTokenTotal` being 100. If in the first distribution round the reward balance is 10,000 tokens and due to gas constraints only `accountA` receives 5,000 tokens, `accountB` would unfairly receive only 2,500 tokens in the subsequent round, despite having an equal share of LP tokens. Similarly, the `processRewardDD` function distributes rewards using tokens from the `_deadDistributor`. If the distribution spans multiple transactions, the balance of reward tokens, `burnAllAmount` and other variables may change, further leading to disproportionate reward allocations.
The audit on Trustblock · Open the reportThe issue with the `processReward` function in the contract relates to how rewards are calculated and distributed based on the holders' shares of the liquidity pool (LP) at a specific moment. The function uses the `balanceOf` method to determine the instantaneous share of LP tokens that each holder possesses at the time of reward calculation: ```solidity=1081 tokenBalance = holdToken.balanceOf(shareHolder); ``` This approach can lead to potential manipulation of reward distribution by holders. Since the reward distribution is directly proportional to the amounts of LP tokens a holder has at the time of the calculation, a holder can temporarily increase their share of LP tokens to receive a larger portion of the rewards by borrowing LP tokens, adding temporary liquidity, and transferring LP tokens across multiple accounts. This manipulation can lead to unfair distributions, where strategic holders can exploit the timing of their token balances to gain more rewards than their usual share would entitle them to.
The audit on Trustblock · Open the reportIn the `_tokenTransfer` function of the `Top` contract, there is a conditional block that handles the calculation of profits when tokens are sold. Specifically, this block updates the `buyValue` for the `sender` when a sale occurs. This conditional block only executes if `_sell_profit_fee` is greater than zero: ```solidity if (_swapPairList[recipient] && !isAdd && !isRemove && !_feeWhiteList[sender]){ if(_sell_profit_fee>0){ uint256 v = getTokenValue(tAmount); if (v >= _burnInfo[sender].buyValue) { uint256 profitFees; uint256 tokenAmount = getUSDTValue(_burnInfo[sender].buyValue); profitFees += ((tAmount - tokenAmount) * _sell_profit_fee) / 10000; feeAmount += profitFees; _ts.deadAmount += profitFees*5/10; _ts.redeemAmount += profitFees*5/10; v = _burnInfo[sender].buyValue; _takeTransfer(sender,address(this),profitFees); } _burnInfo[sender].buyValue -=v; } } ``` The issue with this implementation is that if `_sell_profit_fee` is set to zero under some conditions, the logic to update the `buyValue` and `buyAmount` for a user (`sender`) upon selling does not execute. This results in a scenario where a user's `buyValue` and `buyAmount` remain unchanged even after they have sold their tokens. This could potentially misrepresent the actual economic activity of the user, as the historical purchase values (`buyValue`) that contribute to profit calculations during sales are not decreased upon the sale of tokens.
The audit on Trustblock · Open the reportIn the `_transfer` function of the `Top` contract, there is a specific condition where `lpAmount` for the sender (`from`) is incremented only if the sender of the transaction is the same as the transaction originator (`tx.origin`). This is particularly checked when tokens are being transferred to the pair (`_mainPair`), which usually signifies a liquidity provision operation. ```solidity=611 if (to == _mainPair && tx.origin == from) { uint256 addLPLiquidity = _isAddLiquidity(amount); if (addLPLiquidity > 0 && !isContract(from)) { isAdd = true; } lpAmountAll += amount; lpAmount[from] += amount; ``` However, this approach does not account for scenarios where `transferFrom` is used to add liquidity. In such cases, `tx.origin` would not match `from` if the liquidity is added through a different address initiates the transfer on behalf of the original holder. Consequently, `lpAmount[from]` would not be updated even though liquidity is being added, leading to potential discrepancies in tracking liquidity provisions. We would like to confirm with the team whether this implementation detail is intentional or if adjustments are required to ensure that `lpAmount` correctly reflects all liquidity additions, regardless of whether they are conducted directly by the token holder or through an intermediary address.
The audit on Trustblock · Open the reportThe implementation of the function `isContract()` check can not cover all scenarios. The check can be bypassed if the call is from the constructor of a smart contract or when the contract is destroyed. Because, in that case, the codesize will also be zero. The "isContract" function in the OpenZeppelin "Address" library uses the same implementation, but comments mention that "it's unsafe to rely on the check and it can be bypassed". Reference: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Address.sol
The audit on Trustblock · Open the reportThere should always be events emitted in the sensitive functions that are controlled by centralization roles.
The audit on Trustblock · Open the reportThe **require** can be used to check for conditions and throw an exception if the condition is not met. It is better to provide a string message containing details about the error that will be passed back to the caller.
The audit on Trustblock · Open the reportIn the `swapTokenForFund` function, the `if (_ts.rewardAmount >= 0) ` condition check is redundant as the `rewardAmount` is uint256 which is always zero or greater than zero. ```solidity=877 @> if (_ts.rewardAmount >= 0) { if(rewardPath.length != 1){ try _swapRouter.swapExactTokensForTokensSupportingFeeOnTransferTokens( _rewardAmount, 0, rewardPath, address(this), block.timestamp ) ```
The audit on Trustblock · Open the reportThe linked variables assigned in the constructor can be declared as `immutable`. Immutable state variables can be assigned during contract creation but will remain constant throughout the lifetime of a deployed contract. A big advantage of immutable variables is that reading them is significantly cheaper than reading from regular state variables since they will not be stored in storage.
The audit on Trustblock · Open the reportThe TOP PROTOCOL security record · Every TOP PROTOCOL address · This address on the explorer