Fists security record

The function `_isAddLiquidity()` serve to determine whether the current transfer operation is part of an add liquidity process. This determination is made by comparing the balance of other token(i.e `usdt`) with the reserve value in the pair: - `_isAddLiquidity()`: It is assumed to be an addition of liquidity if balanceOther >= rOther + amountOther. However, it's important to note that this assumption holds true only when other token is transferred to the pair before `Fists` during the process of adding liquidity. This assumption becomes incorrect if `Fists` is transferred to the pair before other token: ```solidity router.addLiquidity( address(Fists), address(USDT), 10 ether, 1 ether, 1, 1, address(this), block.timestamp + 60 seconds ); ``` https://github.com/Uniswap/v2-periphery/blob/0335e8f7e1bd1e8d8329fd300aea2ef2f36dd19f/contracts/UniswapV2Router01.sol#L70 ```solidity TransferHelper.safeTransferFrom(tokenA, msg.sender, pair, amountA); TransferHelper.safeTransferFrom(tokenB, msg.sender, pair, amountB); ```

All of the `Fists` tokens are sent to the contract deployer or one or several externally-owned account (EOA) addresses. This is a centralization risk because the deployer or the owner(s) of the EOAs 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.

Based on the function `_isAddLiquidity()`, if the `USDT` balance of `_usdtPair` has already increased during the transfer process of `Fists` token, the transaction is interpreted as adding liquidity. Consequently, the sender can get dividend tracker shares. ```solidity=1017 if (addLPLiquidity > 0) { isAddLP = true; if (to == _usdtPair) { _userInfo[from].lpAmount += addLPLiquidity; try lpTracker.setAccount(payable(from), _userInfo[from].lpAmount){} catch {} } } ``` However, malicious actors can transfer `USDT` to `_usdtPair` before swapping `FIST` to `USDT`. Through these steps, they can become dividend tracker shareholders without actually contributing liquidity or bypassing the transaction fee in this way. The same problem also occurs when a judge is involved in adding or removing liquidity for other trading pairs. For example, a liquidity provider can transfer other tokens into the pair before removing liquidity, thereby making the value of the removed liquidity zero, so that the value of the `lpAmount` does not change after the liquidity is removed. Additionally, fee whitelisted users who transfer `Fists` directly to pairs will be recognized by the contract as adding liquidity, which will update the `startAddLPBlock` if `startAddLPBlock` is 0. To sum up, the behavior of adding/removing liquidity can be spoofed, and there are significant flaws in the liquidity-related logic within the contract.

The `Fists` contract has created two trading pairs, [WBNB-Fists](https://bscscan.com/address/0x2239C128c01eC7be5755bb8b8b5bD40fb0d61b26) and [USDT-Fists](https://bscscan.com/address/0x22A165467aA18a9F73e8687120f800cb3C33958e). The two pair contracts calculate `feeToLiquidity` as follows: ```solidity if (feeOn) { if (_kLast != 0) { uint rootK = Math.sqrt(uint(_reserve0).mul(_reserve1)); uint rootKLast = Math.sqrt(_kLast); if (rootK > rootKLast) { uint numerator = totalSupply.mul(rootK.sub(rootKLast)).mul(8); uint denominator = rootK.mul(17).add(rootKLast.mul(8)); uint liquidity = numerator / denominator; if (liquidity > 0) _mint(feeTo, liquidity); } } } ``` The formula for calculating `feeToLiquidity` in the contract is inconsistent with that of the trading pair contracts: ```solidity if (feeOn) { if (_kLast != 0) { uint256 rootK = Math.sqrt(r0 * r1); uint256 rootKLast = Math.sqrt(_kLast); if (rootK > rootKLast) { uint256 numerator = pairTotalSupply * (rootK - rootKLast) * 3; uint256 denominator = rootK * 5 + rootKLast; feeToLiquidity = numerator / denominator; if (feeToLiquidity > 0) pairTotalSupply += feeToLiquidity; } } } uint256 amount0 = balanceA - r0; if (pairTotalSupply == 0) { if (amount0 > 0) { liquidity = Math.sqrt(amount0 * amount) - 1000; } } else { liquidity = Math.min( (amount0 * pairTotalSupply) / r0, (amount * pairTotalSupply) / r1 ); } ``` This will cause the estimated `LP` amount to exceed the actual `LP` amount received by the user, and the calculated `LP` amount will be recorded as the user's `LP` holdings. However, the `DividendTracker` contract only distributes dividends to users whose recorded `LP` holdings are less than their actual holdings, so in reality, users are unable to receive dividends. Similarly, since the calculation result is greater than the actual `LP` amount obtained by the user, the user's `_userInfo.lpAmount` data in the contract cannot be cleared when the user removes liquidity.

According to the design of the `Fists` contract, when `from` is `swapRouter`, the contract assumes the transaction is an operation to remove liquidity from the **WBNB-Fists** pair. The contract will calculate the number of `LP` tokens to be removed based on the transfer amount through the `_isRemoveLiquidityETH()` function. ```solidity if (_pairs[from] && to != address(_swapRouter)) { removeLPLiquidity = _isRemoveLiquidity(from, amount); } else if (from == address(_swapRouter)) { removeLPLiquidity = _isRemoveLiquidityETH(from, amount); lpAmountW = removeLPLiquidity; } function _isRemoveLiquidityETH(address pair, uint256 amount) internal view returns (uint256 liquidity){ (uint256 rOther,, uint256 balanceOther) = _getReserves(pair); //isRemoveLP if (balanceOther <= rOther) { liquidity = amount * ISwapPair(pair).totalSupply() / balanceOf(pair); } } ``` However, the actual address passed in the `_isRemoveLiquidityETH()` function is the router's address, not the **WBNB-Fists** pair address. Since the router contract does not contain a `getReserves()` function, the call will fail.

The reward amount is calculated by $\frac{\_rewardTokenAmount \times \_balances[account]}{totalSupply}$. It is worth noting that the reward amount to be distributed is determined based on the `DividendTracker` shares of a wallet. Hackers can exploit issue `FIS-07` to create multiple accounts for arbitrage. ```solidity=928 uint256 reward = accountHoldBalance * _rewardTokenAmount / totalSupply; ``` Hackers can calculate the number of shareholders at each dividend distribution, as well as the array cursor `lastProcessedIndex` after the last dividend. With this information, they can transfer the `LP` tokens they hold to a malicious account they control before the dividends are distributed. By executing a transfer, they trigger the dividend mechanism, and after the account receives the dividend, they continue to transfer the `LP` tokens to the next account eligible for dividends, thus continuously receiving dividends.

The `setPairs()` function allows the owner of the `Fists` contract to add supported pairs. However, there's a compatibility risk if the pairs were not established via the hardcoded `_swapRouter` at `0x10ED43C718714eb63d5aA57B78B54704E256024E`. ```solidity=946 function setPairs(address pair, bool enable) external onlyOwner { _pairs[pair] = enable; } ```

The "_isRemoveLiquidity()", "_isRemoveLiquidityETH()" 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.

```solidity=1309 if (amountToBurn > 0) { _balances[_wbnbPair] = balanceOf(_wbnbPair) - amountToBurn; _takeTransfer(_wbnbPair, deadWallet, amountToBurn); ISwapPair(_wbnbPair).sync(); } ``` The function `Fists.autoBurnLiquidityPairTokens` updates the balances by an amount that is derived from the balance of `_wbnbPair`. This would result in the price of `FIST` increasing every hour.

The `setTrackerAddress()` function allows the contract owner to establish a new dividend tracker. This new tracker will not distribute dividends to dead or zero addresses, and it will be included in the `_feeWhiteList` as well as receive authorization from the `Fists` contract. ```solidity=969 function setTrackerAddress(address _lpTracker) public onlyOwner { lpTracker = DividendTracker(_lpTracker); lpTracker.excludeFromDividends(0x000000000000000000000000000000000000dEaD, true); lpTracker.excludeFromDividends(0x0000000000000000000000000000000000000000, true); _feeWhiteList[_lpTracker] = true; IERC20(usdt).approve(_lpTracker, 1e60); } ``` Nonetheless, the configurations associated with the old dividend tracker have not been removed.