Read the findings of the 2022 Web3 Security Report

In the contract `CoinToken` the role `_owner` has authority over the functions shown in the diagram below.

Any compromise to the `_owner` account may allow the hacker to take advantage of this authority and fee amounts and addresses receiving fees.

![](https://accelerator-tasks-prod.s3.amazonaws.com/d7560c2af04b4a24986b4e7c8cc6cdee/diagrams/centralization-CoinToken-_owner.svg)

In the contract `Ownable` the role `_owner` has authority over the functions shown in the diagram below.

Any compromise to the `_owner` account may allow the hacker to take advantage of this authority and transfer access to privileged functions.

![](https://accelerator-tasks-prod.s3.amazonaws.com/d7560c2af04b4a24986b4e7c8cc6cdee/diagrams/centralization-Ownable-_owner.svg)

In the contract `Ownable` the role `_previousOwner` has authority over the functions shown in the diagram below.

Any compromise to the `_previousOwner` account may allow the hacker to take advantage of this authority and regain ownership from `owner` address.

![](https://accelerator-tasks-prod.s3.amazonaws.com/d7560c2af04b4a24986b4e7c8cc6cdee/diagrams/centralization-Ownable-_previousOwner.svg)

Centralization Risk in CoinToken.sol

A reentrancy attack can occur when the contract creates a function that makes an external call to another untrusted contract before resolving any effects. If the attacker can control the untrusted contract, they can make a recursive call back to the original function, repeating interactions that would have otherwise not run after the external call resolved the effects.

### External call(s)
File: CoinToken.sol (Line 797, Function `CoinToken._transfer`)
```solidity
            swapAndLiquify(contractTokenBalance);
```
* This function call executes the following external call(s).
* In `CoinToken.addLiquidity`,
    * `uniswapV2Router.addLiquidityETH{value: ethAmount}(address(this),tokenAmount,0,0,owner(),block.timestamp)`
* In `CoinToken.swapTokensForEth`,
    * `uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,0,path,address(this),block.timestamp)`
* This call sends Ether.

### State variables written after the call(s)
File: CoinToken.sol (Line 805, Function `CoinToken._transfer`)
```solidity
        _tokenTransfer(from,to,amount,takeFee);
```
* This function call executes the following assignment(s).
* In `CoinToken._takeLiquidity`,
    * `_rOwned[address(this)] = _rOwned[address(this)].add(rLiquidity)`
* In `CoinToken._takeDev`,
    * `_rOwned[_devWalletAddress] = _rOwned[_devWalletAddress].add(rDev)`
* In `CoinToken._transferStandard`,
    * `_rOwned[sender] = _rOwned[sender].sub(rAmount)`
* In `CoinToken._transferToExcluded`,
    * `_rOwned[sender] = _rOwned[sender].sub(rAmount)`
* In `CoinToken._transferStandard`,
    * `_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount)`
* In `CoinToken._transferFromExcluded`,
    * `_rOwned[sender] = _rOwned[sender].sub(rAmount)`
* In `CoinToken._transferBothExcluded`,
    * `_rOwned[sender] = _rOwned[sender].sub(rAmount)`
* In `CoinToken._transferToExcluded`,
    * `_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount)`
* In `CoinToken._transferFromExcluded`,
    * `_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount)`
* In `CoinToken._transferBothExcluded`,
    * `_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount)`

File: CoinToken.sol (Line 805, Function `CoinToken._transfer`)
```solidity
        _tokenTransfer(from,to,amount,takeFee);
```
* This function call executes the following assignment(s).
* In `CoinToken._reflectFee`,
    * `_rTotal = _rTotal.sub(rFee)`

File: CoinToken.sol (Line 805, Function `CoinToken._transfer`)
```solidity
        _tokenTransfer(from,to,amount,takeFee);
```
* This function call executes the following assignment(s).
* In `CoinToken._takeLiquidity`,
    * `_tOwned[address(this)] = _tOwned[address(this)].add(tLiquidity)`
* In `CoinToken._takeDev`,
    * `_tOwned[_devWalletAddress] = _tOwned[_devWalletAddress].add(tDev)`
* In `CoinToken._transferFromExcluded`,
    * `_tOwned[sender] = _tOwned[sender].sub(tAmount)`
* In `CoinToken._transferBothExcluded`,
    * `_tOwned[sender] = _tOwned[sender].sub(tAmount)`
* In `CoinToken._transferToExcluded`,
    * `_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount)`
* In `CoinToken._transferBothExcluded`,
    * `_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount)`



Potential Reentrancy Attack (Involving Ether)

An owner is possible to gain ownership of the contract even if he calls function `renounceOwnership` to renounce the ownership. This can be achieved by performing the following operations:
1. Call `lock` to lock the contract. The variable `_previousOwner` is set to the current owner.
2. Call `unlock` to unlock the contract.
3. Call `renounceOwnership` to leave the contract without an owner. 
4. Call `unlock` to regain ownership, as `_previousOwner` was not reset.

`_previousOwner` Can Gain Ownership After Renouncing

Variable `_rOwned` is not updated in function `includeInReward()`, which means previously excluded accounts can be included again and continue to receive holder rewards.
Details of this finding can be seen in this article from Pera Finance:

[Link](https://perafinance.medium.com/safemoon-is-it-safe-though-a-detailed-explanation-of-frictionless-yield-bug-338710649846)

Variable `_rOwned` not updated

```solidity=834
uniswapV2Router.addLiquidityETH{value: ethAmount}(
            address(this),
            tokenAmount,
            0, // slippage is unavoidable
            0, // slippage is unavoidable
            owner(),
            block.timestamp
        );
```

The `addLiquidity` function calls the `uniswapV2Router.addLiquidityETH` function with the `to` address specified as `owner()` for acquiring the generated LP tokens from the `OVM-BNB` pool. As a result, over time the `owner()` address will accumulate a significant portion of LP tokens. If the `owner()` is an EOA (Externally Owned Account), mishandling of its private key can have devastating consequences to the project as a whole.

`owner()` Gains `addLiquidity()` LP Tokens

The `swapAndLiquify` function converts half of the `contractTokenBalance` Overmoon tokens to BNB. The other half of Overmoon tokens and part of the converted BNB are deposited into the OVM-BNB pool on pancakeswap as liquidity. For every `swapAndLiquify` function call, a small amount of BNB leftover in the contract. This is because the price of Overmoon drops after swapping the first half of Overmoon tokens into BNBs, and the other half of Overmoon tokens require less than the converted BNB to be paired with it when adding liquidity. The contract doesn't appear to provide a way to withdraw leftover BNB, locking it in the contract forever. 

Contract Gains Non-Withdrawable BNB

Addresses should be checked before assignment or external call to make sure they are not zero addresses.

File: CoinToken.sol (Line 503, Function `CoinToken.constructor`)
```solidity
        _owner = tokenOwner;
```
- `tokenOwner` is not zero-checked before being used.

Missing Zero Address Validation

The contract is serving as the underlying entity to interact with third party Automated Market Maker protocols. The scope of the audit treats 3rd party entities as black boxes and assume their functional correctness. However, in the real world, 3rd parties can be compromised and this may lead to lost or stolen assets. In addition, upgrades of 3rd parties can possibly create severe impacts, such as increasing fees of 3rd parties, migrating to new LP pools, etc.

Third Party Dependencies

There should always be events emitted in the sensitive functions that are controlled by centralization roles.

Missing Emit Events

The contract has unlocked compiler version. An unlocked compiler version in the source code of the contract permits the user to compile it at or above a particular version. This, in turn, leads to differences in the generated bytecode between compilations due to different compiler versions. This can lead to an ambiguity when debugging as compiler specific bugs may occur in the codebase that would be hard to identify over a span of multiple compiler versions rather than a specific one.

Unlocked Compiler Version

The 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.

Variables That Could Be Declared as Immutable

Solidity frequently releases new compiler versions. Using an old version prevents access to new Solidity security features. Also, recent versions may be too early to be trusted.

```x
solc-0.8.13 is not recommended for deployment
```



Solidity Version Not Recommended

The return value of an external call is not stored in a local or state variable.

File: CoinToken.sol (Line 834-841, Function `CoinToken.addLiquidity`)
```solidity
        uniswapV2Router.addLiquidityETH{value: ethAmount}(
            address(this),
            tokenAmount,
            0, // slippage is unavoidable
            0, // slippage is unavoidable
            owner(),
            block.timestamp
        );
```



Unused Return Value

Performing integer division before multiplication truncates the low bits, losing the precision of calculation.

File: CoinToken.sol (Line 485, Function `CoinToken.constructor`)
```solidity
        _maxTxAmount = (_tTotal * 5 / 1000) * 10 ** _decimals;
```


---
File: CoinToken.sol (Line 486, Function `CoinToken.constructor`)
```solidity
        numTokensSellToAddToLiquidity = (_tTotal * 5 / 10000) * 10 ** _decimals;
```



Divide Before Multiply

The function `setMaxTxPercent()` sets the variable `_maxTxAmount` directly rather than using the `maxTxPercent` parameter as a percentage of the total supply.

`setMaxTxPercent()` Sets `_maxTxAmount` Directly

The linked comment spelling `recieve` should be `receive` and `swaping` should be `swapping` in the line of comment `//to recieve ETH from uniswapV2Router when swaping`.

Typos in the contract

The condition `!_isExcluded[sender] && !_isExcluded[recipient]` can be included in `else` .

OverMoon

Highlights & Alerts

This is just a placeholder

highlight placeholder lorem Ipsum...

highlight lorem

This is a alert demo

Alert demo

Code Audit History

17

0

17

0

0