Sign Up for a Code Audit Today and Get 3 Months of Skynet for Free

`public` functions that are never called by the contract could be declared as `external`. `external` functions are more efficient than `public` functions.

Improper Usage of `public` and `external` Type

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

In the contract `HUHGovernance/HUHGovernance_V2`, the role `proxy` has authority over the following functions:

- `upgradeTo()/upgradeToAndCall()`: change the implementation of the contract

Any compromise to the `proxy` account may allow a hacker to take advantage of this authority.

Centralization Related Risks

According to the following codes, the function `caculateYearsDeltatime()` is used to calculate the seconds of the given years.

```solidity=12
    function caculateYearsDeltatime(uint _years) public pure returns (uint256){
        uint oneDay = 1 days;
        return ((_years * 3652425 + 5000)/ 10000) * oneDay;
    }
```

In solidity, the division truncation problem exists for division operations. The calculation `(_years * 3652425 + 5000)/ 10000` uses division truncation to calculate the number of days for the given years.

However, the result of 1st,2nd,4th year is 365 days, the result of 3rd year is 366 days, and so on. This does not correspond to the common calculation of the number of days for the given years.

Logical issue of the function `caculateYearsDeltatime()`

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

Missing Emit Events

Huh-governance

HUHGovernance_V2.sol

HUHGovernance.sol

Import.sol

Timestamp.sol

TokenTimeLock.sol

Visibility Specifiers Missing

Address Type Could Be Indexed In Events

Set `constant` to Variables

Third Party Dependencies

Initial Token Distribution

Division Before Multiplication

Return Value Not Handled

Potential Sandwich Attacks

Function Visibility Optimization

Centralization Risk

Comparison to A Boolean Constant

Discussion For The Function `updatePancakeSwapRouter`

Discussion For The `swapEnabled`

Privilege Revoke

Potential Risk of Economic Module

Hardcode Address

Lack of Error Message

Lack of Zero Address Validation

Unchecked The Existed `rewardRecipient`

Logic Issue Of The Function `_giftReward`

No Check  For `rewardRecipient`

HuhToken

RewardDistributor.sol

helpers

IterableMapping.sol

DividendPayingTokenOptionalInterface.sol

SafeMathUint.sol

SafeMathInt.sol

IDividendDistributor.sol

HuhTokenFlatten.sol

HuhToken.sol

DividendPayingToken.sol

DividendDistributor.sol

interfaces

IUniswap.sol

DividendPayingTokenInterface.sol

IBEP20.sol

HUH.sol

dividends

HUH Token 

HUH Token

Highlights & Alerts

This is just a placeholder

highlight placeholder lorem Ipsum...

highlight lorem

This is a alert demo

Alert demo

Code Audit History

6

0

1

0

5