OpenGPU Network security record

The `_transfer` function within the `OPENGPU` contract designates a notably high percentage (80%) of Ethereum obtained through token swaps for marketing purposes. The objective of this discussion is to confirm the client's strategic intentions behind this allocation and to explore whether a more balanced distribution might better support the project's long-term goals.

The transaction may be charged fees, so the max holding of the receiver should be the sum of the held tokens and the amount received from the transfer. The fees should not be included in the max holding. ```solidity=395 require( balance + amount <=totalSupply() * maxWalletLimitRate / 1000, "MaxWallet: Recipient exceeds the maxWalletAmount" ); ``` - Max holding is checked. ```solidity=385 amount = amount - fees; ``` - Receiving amount is adjusted. ```solidity=178 _balances[recipient] += amount; ``` - Balance is increased by the adjusted amount.

Addresses are not validated before assignment or external calls, potentially allowing the use of zero addresses and leading to unexpected behavior or vulnerabilities. For example, transferring tokens to a zero address can result in a permanent loss of those tokens. ```solidity=282 marketingWallet = _marketingWallet; ``` - `_marketingWallet` is not zero-checked before being used. --- ```solidity=283 stakingWallet = _stakingWallet; ``` - `_stakingWallet` is not zero-checked before being used.

State variables that never change should be declared as `constant` to save gas. ```solidity=257 uint256 public buyFee = 5; ``` - `buyFee` should be declared `constant`. --- ```solidity=258 uint256 public sellFee = 5; ``` - `sellFee` should be declared `constant`. --- ```solidity=268 address private DEAD = 0x000000000000000000000000000000000000dEaD; ``` - `DEAD` should be declared `constant`. --- ```solidity=276 uint256 private maxWalletLimitRate = 20; ``` - `maxWalletLimitRate` should be declared `constant`.

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. ```solidity=260 address private marketingWallet; address private stakingWallet; ``` ```solidity=266 address public uniswapV2Pair; ``` ```solidity=271 uint256 public swapTokensAtAmount; ```