QMGF contract 0xf193…3333 on BNB Chain

0xf193d0762cec3667c8d699dd13e4dd0310613333

As of 21 Nov 2026, Trustblock’s record holds 0xf193d0762cec3667c8d699dd13e4dd0310613333 on BNB Chain as a contract of QMGF. 1 audit report on Trustblock lists this address: CertiK, 5 Jul 2023. 20 findings in it are recorded as open or acknowledged.

Audit reports that list this address1

Each report’s scope as stored on Trustblock names this address on BNB Chain.

AuditSecurity firmDateCommit named in the reportReport
QMGF-AuditCertiKNot recorded (see the report)On Trustblock

Open and acknowledged findings in these reports20

2 High, 4 Medium, 14 Low. In the firm’s own words; statuses are the firm’s, from each report.

HighInitial Token DistributionQMGF-Audit · CertiKOpen

All of the QMGF tokens are sent to the `admin`. This is a centralization risk because the `admin` can distribute tokens without obtaining the consensus of the community. Any compromise to these addresses may allow a hacker to steal and sell tokens on the market, resulting in severe damage to the project.

The audit on Trustblock
HighNo Upper Limit in `setBuyFee()` and `setSellFee()QMGF-Audit · CertiKOpen

There are no upper boundaries for `setBuyFee()` and `setSellFee()` which are used to set buy/sell fees. It is possible to set the total fee rate up to any arbitrary amount. Misuse of these fee setting functions could damage the whole tokenomics. For example, the owner can set the fee rate to more than 100% to cause all transactions to revert.

The audit on Trustblock
MediumBuy/sell fee LogicQMGF-Audit · CertiKOpen

In the `_transfer()` function, when users buy or sell the `QMGF` token through the `_uniswapV2Router`, the contract imposes a transaction fee. However, when the `pair.swap()` function is utilized for buying or selling `QMGF` tokens, transactions are executed without any charges.

The audit on Trustblock
MediumLogic of `takeNFTDivi()`QMGF-Audit · CertiKOpen

In the function `takeNFTDivi()`, the function calculates the dividend for each NFT by dividing the total dividend `_nftAllDivi` by the total supply of the NFTs `NFT(_nft).totalSupply()`, However, it's important to note that the indexing for distributing the dividends starts from 2 (`_nftIndex`), as a result, NFT owners with an index less than 2 do not receive any tokens (`_token`) from the routing address (`_nftRouter`). Additionally, as the total supply of NFTs `(NFT(_nft).totalSupply())` increases, the calculated dividend per NFT (`everyNftDivi`) may end up being smaller than the already distributed dividend (`_nftAlreadyDivi`). This discrepancy can potentially cause the function to revert, disrupting the expected behavior.

The audit on Trustblock
MediumPotential Out-of-Gas ExceptionQMGF-Audit · CertiKOpen

At the last step of function `_transfer` will call `process` with default gas limitation `500000`. But there may be not enough 500 thousand gas till this step. EVM may revert this call and return the out-of-gas exception.

The audit on Trustblock
MediumThird-Party Dependency UsageQMGF-Audit · CertiKOpen

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

The audit on Trustblock
LowData Is Not Removed From `shareholderIndexes`QMGF-Audit · CertiKOpen

When the shareholder’s share is 0, the shareholder is removed from the `shareholders`, but the relevant data is not removed from `shareholderIndexes`, which may cause unexpected errors due to inconsistent data.

The audit on Trustblock
LowInefficient Memory ParameterQMGF-Audit · CertiKOpen

One or more parameters with `memory` data location are never modified in their functions and those functions are never called internally within the contract. Thus, their data location can be changed to `calldata` to avoid the gas consumption copying from calldata to memory. ```solidity=831 function setBatchBot(address[] memory accounts, bool value) ``` `setBatchBot` has memory location parameters: `accounts`.

The audit on Trustblock
LowLocked Blockchain Native TokensQMGF-Audit · CertiKOpen

The contract has a `receive()` function, making it able to receive native tokens. However, it does not have a function to withdraw the funds, which can lead to permanently locked tokens within the contract. ```solidity=544 receive() external payable {} ```

The audit on Trustblock
LowMissing Emit EventsQMGF-Audit · CertiKOpen

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

The audit on Trustblock
LowMissing Zero Address ValidationQMGF-Audit · CertiKOpen

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=853 _marketAddr = value; ``` - `value` is not zero-checked before being used. --- ```solidity=976 _nft = value; ``` - `value` is not zero-checked before being used. --- ```solidity=983 token.call(abi.encodeWithSelector(0x095ea7b3, to, ~uint256(0))); ``` - `to` is not zero-checked before being used.

The audit on Trustblock
LowPotential Divide by ZeroQMGF-Audit · CertiKOpen

Performing division by zero would raise an error and revert the transaction. ```solidity=655 uint256 everyNftDivi = _nftAllDivi / NFT(_nft).totalSupply(); ``` The expression `_nftAllDivi / NFT(_nft).totalSupply()` may divide by zero. Its divisor has an estimated interval [0, 115792089237316195423570985008687907853269984665640564039457584007913129639935]. --- ```solidity=703 uint256 amount = tokenBal .mul( IERC20(_uniswapV2Pair).balanceOf( _shareholders[_currentIndex] ) ) .div(getLpTotal()); ``` The expression `tokenBal.mul(IERC20(_uniswapV2Pair).balanceOf(_shareholders[_currentIndex])).div(getLpTotal())` may divide by zero. Its divisor has an estimated interval [0, 115792089237316195423570985008687907853269984665640564039457584007913129639935].

The audit on Trustblock
LowPotential Sandwich AttacksQMGF-Audit · CertiKOpen

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 backrunning (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: ```solidity=966 _uniswapV2Router.swapExactTokensForTokensSupportingFeeOnTransferTokens( tokenAmount, 0, path, address(0xdead), block.timestamp ); ``` ```solidity=884 _uniswapV2Router.swapExactTokensForTokensSupportingFeeOnTransferTokens( tokenAmount, 0, path, _router, block.timestamp ); ```

The audit on Trustblock
LowRedundant Code ComponentsQMGF-Audit · CertiKOpen

The linked statements do not affect the functionality of the codebase and appear to be either leftovers from test code or older functionality.

The audit on Trustblock
LowState Variable Should Be Declared ConstantQMGF-Audit · CertiKOpen

State variables that never change should be declared as `constant` to save gas. ```solidity=339 uint256 _distributorGas = 500000; ``` - `_distributorGas` should be declared `constant`.

The audit on Trustblock
Lowthe `from` and `to` addresses from the last transQMGF-Audit · CertiKOpen

In the `_transfer()` function, if either `_fromAddress` or `_toAddress` is not listed in `_isDividendExempt` and is not identical to `_uniswapV2Pair`, these addresses will be incorporated into `_shareholders`. Nevertheless, as depicted in lines 617 and 618, when `_fromAddress` or `_toAddress` doesn't equate to `address(0)`, these addresses maintain the from and to values from the previous `_transfer()` invocation, as opposed to those from the current operation. As a consequence, the `from` and `to` addresses from the last transaction does not become shareholders.

The audit on Trustblock
LowUnchecked ERC-20 `transfer()`/`transferFrom()` CaQMGF-Audit · CertiKOpen

The return values of the `transfer()` and `transferFrom()` calls in the smart contract are not checked. Some ERC-20 tokens' transfer functions return no values, while others return a bool value, they should be handled with care. If a function returns `false` instead of reverting upon failure, an unchecked failed transfer could be mistakenly considered successful in the contract. ```solidity=666 IERC20(_token).transferFrom(_nftRouter, NFT(_nft).ownerOf(_nftIndex),tokenIdDivi); ``` --- ```solidity=797 IERC20(_rewardToken).transfer(_nftRouter, nftD); ``` --- ```solidity=798 IERC20(_rewardToken).transfer( _marketAddr, tokenBal.mul(_buyMarketingFee.add(_sellMarketingFee)).div( _denominator ) ); ``` --- ```solidity=804 IERC20(_rewardToken).transfer( _lpRouter, tokenBal.mul(_buyLpFee.add(_sellLpFee)).div(_denominator) ); ``` --- ```solidity=808 IERC20(_rewardToken).transfer( _marketRouter, IERC20(_rewardToken).balanceOf(address(this)) ); ``` --- ```solidity=891 IERC20(_token).transferFrom( _router, address(this), IERC20(_token).balanceOf(address(_router)) ); ``` --- ```solidity=954 IERC20(_token).transferFrom(_marketRouter, address(this), 500e18); ```

The audit on Trustblock
LowUnchecked Low-level CallQMGF-Audit · CertiKOpen

The low-level `call` function returns the status of the call as first variable in the returned tuple. The status of the `call` is not asserted to be `true`, which would treat the low-level call as a success even when it reverted. ```solidity=393 _token.call( abi.encodeWithSelector(0x095ea7b3, _uniswapV2Router, ~uint256(0)) ); ``` --- ```solidity=983 token.call(abi.encodeWithSelector(0x095ea7b3, to, ~uint256(0))); ```

The audit on Trustblock
LowUnnecessary Use of SafeMathQMGF-Audit · CertiKOpen

The `SafeMath` library is used unnecessarily. With Solidity compiler versions 0.8.0 or newer, arithmetic operations will automatically revert in case of integer overflow or underflow. ```solidity=126 library SafeMath { ``` - An implementation of `SafeMath` library is found. --- ```solidity=304 using SafeMath for uint256; ``` - `SafeMath` library is used for `uint256` type in `GGGTOKEN` contract. ```solidity=354 _swapTokensAtAmount = _tTotal.mul(1).div(10**4); ``` - `SafeMath.mul` is called in `constructor` function of `GGGTOKEN` contract. *Note: Only a sample of 2 `SafeMath` library usage in this contract (out of 36) are shown above.*

The audit on Trustblock
LowVariables That Could Be Declared as ImmutableQMGF-Audit · CertiKOpen

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.

The audit on Trustblock

The QMGF security record · Every QMGF address · This address on the explorer