Read the findings of the 2022 Web3 Security Report

Calling of `takeInvestment()` at exactly `block.timestamp == userPackets[msg.sender][_packetId].finishTime` allows to extract any amount of money by a subsequent call.

The scenario:
1. The attacker invests funds in `_packetId`.
2. The attacker calls `takeInvestment()` with the corresponding `_packetId` exactly at the moment of packet expiration. Since in BSC blocks are produced every 3 seconds, it requires about 3 attempts to get lucky.
3. The transaction is included into block with `block.timestamp == userPackets[msg.sender][_packetId].finishTime`
4. The attacker gets the reward for 15 days. `lastUpdate[msg.sender][_packetId]` is assigned with `finishTime`.
5. The attacker waits for some time and calls `takeInvestment()` again with the same `_packetId`.
6. Since `lastUpdate[msg.sender][_packetId] == userPackets[msg.sender][_packetId].finishTime` the attacker gets the reward for elapsed time.

All Funds Can Be Stolen Via the `takeInvestment()` Function

`investByRef()` can be called with `_referrer = 0` so the next time a call from the same address will be treated as from a new investor and referral rewards will be credited to a null address. `totalInvestors` will also be incremented.

The Referral Reward May Be Written to a Null Address Via The `investByRef()` Function

Incorrect ROI Value

In case `allPackets[i].finishTime` == `block.timestamp` or `_allPackets[i].paid` == `_allPackets[i].invested.mul(224).div(100)` packets are not returned by both `getActivePackets()` and `getCompletedPackets()`.

`getActivePackets()` and `getCompletedPackets()` Functions May Return Incorrect Values

After [EIP-1884](https://eips.ethereum.org/EIPS/eip-1884) was included in the Istanbul hard fork, it is not recommended to use `.transfer()` or `.send()` for transferring native tokens as these functions have a hard-coded value for gas costs making them obsolete as they are forwarding a fixed amount of gas, specifically `2300`. This can cause issues in case the linked statements are meant to be able to transfer funds to other contracts instead of EOAs.

Usage of `transfer()` for Sending BNB

The linked functions are equivalent to the compiler-generated getter functions for the respective variables.

User-Defined Getters

The `fallback()` function in the `RocketScience` contract is unnecessary as it allows nonstandard function selectors and does not contain any actual logic.

Unnecessary Fallback Function

The `takeInvestment()` function uses the magic number `225` as the return on investment after the full investment cycle based on a payout of 15% per day. The value will not be updated if constants are modified.

Usage of Magic Number

Functions `totalClaimable()` and `takeInvestment()` share the same code.

Code Repetition

The `transfer()` function in the `RocketScience` contract is unnecessary and does not contain any actual logic.

Unnecessary `transfer()` Function

[Events](https://docs.soliditylang.org/en/v0.8.13/contracts.html#events) should be used instead of `referralsRewards`.

Events Should Be Used

Solidity version >=0.8.0 includes checked arithmetic operations and underflow/overflow by default, making SafeMath redundant. 

Redundant SafeMath Usage

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 differing compiler version numbers. 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 functions which are never called internally within the contract should have `external` visibility for gas optimization.

Function Should Be Declared External

Literals with many digits are difficult to read and review.

```solidity
        require(
            msg.value >= 10000000000000000 &&
                msg.value <= 1000000000000000000000,
            "Wrong amount"
        );
```


Too Many Digits

Similar names make the code more difficult to review.

`_withdrawal` is too similar to `withdrawals`.

Variable Names Too Similar

Magic numbers 1, 2 are indicating type of withdrawals (earned, referrals).

`uint256 t` Should Be Replaced with Enum Values

`REF` is actually used as a percentage of the investment when calculating referrals rewards, which does not correspond to its name.

Bad Constant Name `REF`

Commented Out Code 

The `invest()` function uses the magic number `10` as the owner reward.

Usage of Magic Number to Declare the Percentage of the Owner's Reward

The linked error message string contains a typo.

Typo in the Error Message

`_isNew` can be replaced by checking `investors[msg.sender].referrer == address(0)` by combining two logical blocks into one. 

Rocket Science

Highlights & Alerts

This is just a placeholder

highlight placeholder lorem Ipsum...

highlight lorem

This is a alert demo

Alert demo

Code Audit History

22

0

5

2

15