MBD Financials security record

Performing division by zero would raise an error and revert the transaction. ```solidity=1047 return rAmount / currentRate; ``` The expression `rAmount / currentRate` may divide by zero. Its divisor has has estimated interval [0, 115792089237316195423570985008687907853269984665640564039457584007913129639935]. --- ```solidity=1179 return rSupply / tSupply; ``` The expression `rSupply / tSupply` may divide by zero. Its divisor has has estimated interval [ninf, pinf]. --- ```solidity=1193 if (rSupply < _rTotal / _tTotal) return (_rTotal, _tTotal); ``` The expression `_rTotal / _tTotal` may divide by zero. Its divisor has has estimated interval [0, 40000000000000000000000000000].

A sandwich attack might happen when an attacker observes a transaction swapping tokens or adding liquidity without setting restrictions on slippage or minimum output amount. The attacker can manipulate the exchange rate by frontrunning (before the transaction being attacked) a transaction to purchase one of the assets and make profits by back running (after the transaction being attacked) a transaction to sell the asset. The following functions are called without setting restrictions on slippage or minimum output amount, so transactions triggering these functions are vulnerable to sandwich attacks, especially when the input amount is large: - `uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens()` - `uniswapV2Router.addLiquidity()` Moreover,

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

State variables that never change should be declared as `constant` to save gas. ```solidity=779 uint256 public _feeDenominator = 10000; ``` - `_feeDenominator` should be declared `constant`. --- ```solidity=780 uint256 public _MaxtotalFee = 2000; ``` - `_MaxtotalFee` should be declared `constant`. --- ```solidity=803 uint256 private numTokensSellToAddToLiquidity = 500000 * 10 ** 18; ``` - `numTokensSellToAddToLiquidity` should be declared `constant`. --- ```solidity=819 uint256 public _locktime = 60; ``` - `_locktime` should be declared `constant`.

The for loop contains repeated storage read access in the condition check. Given that the ending condition does not change in the for loop, the repeated storage read is unnecessary, and its associated high gas cost can be eliminated. ```solidity=1185 for (uint256 i = 0; i < _excluded.length; i++) { ``` Loop condition `i < _excluded.length` accesses the `length` field of a storage array.

One or more logic contracts do not protect their initializers. An attacker can call the initializer and assume ownership of the logic contract, whereby she can perform privileged operations that trick unsuspecting users into believing that she is the owner of the upgradeable contract. ```solidity=217 contract MBD is Initializable, IERC20Upgradeable, AccessControlUpgradeable { ``` - `MBD` is an upgradeable contract that does not protect its initializer. ```solidity=313 function initialize() public initializer { ``` - `initialize` is an unprotected initializer function.

The smart contract does not check or store the return value of an external call in a local or state variable, which may introduce vulnerabilities due to the unhandled outcome. ```solidity=1361 uniswapV2Router.addLiquidityETH{value: ethAmount}( address(this), tokenAmount, 0, // slippage is unavoidable 0, // slippage is unavoidable owner(), block.timestamp ); ```

The smart contract contains one or more values that are not used, which can lead to unnecessary complexity and reduced maintainability. ```solidity=1523 proposalIDcount = proposalIDcount + 1; ``` - The variable `proposalIDcount` is never used after this assignment.

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=776 uint256 private _tTotal; ``` ```solidity=784 uint256 private _decimals; ```

The report gives no description here.