0xf86af2fbcf6a0479b21b1d3a4af3893f63207fe7
As of 21 Nov 2026, Trustblock’s record holds 0xf86af2fbcf6a0479b21b1d3a4af3893f63207fe7 on BNB Chain as a contract of GOUT. 1 audit report on Trustblock lists this address: CertiK, 26 Nov 2024. 16 findings in it are recorded as open or acknowledged.
Each report’s scope as stored on Trustblock names this address on BNB Chain.
| Audit | Security firm | Date | Commit named in the report | Report |
|---|---|---|---|---|
| GOUT - Audit | CertiK | Not recorded (see the report) | Open |
5 High, 2 Medium, 9 Low. In the firm’s own words; statuses are the firm’s, from each report.
The `_transfer()` function includes a burn mechanism using `autoBurnUniswapPair()` designed to reduce the reserve of tokens in the `_autoPair` and potentially increase the token's price. When the transaction is interacting with the `_autoPair`, it may trigger `autoBurnUniswapPair()`. A vulnerability arises when a malicious user takes advantage of the burn mechanism, easpecially in case the accumlated fee in the contract is less than the `minSwapFee`. This mechanism can be exploited by a malicious actor through the following steps: 1. The actor obtains a large number of tokens, possibly using a flash loan for the initial purchase, which provides them with significant capital without upfront investment. 2. After acquiring the tokens, the actor waits for the burn mechanism to be triggered, reducing the overall token supply. 3. Once the burn has taken place, the actor sells the tokens back to the pool, capitalizing on the increased token price due to the reduced supply.
The audit on Trustblock · Open the reportIn the contract `GOUT`, the role `_owner` has authority over the functions shown in the diagram below. Any compromise to the `_owner` account may allow the hacker to take advantage of this authority and: - `receiveToken`, transfer all the ETH and any type of ERC20 tokens to the owner - `setExcludeFee`, set exclude fee for multiple addresses - `addLiquidity`, add liquidity using ETH and tokens - `setAutoLPBurnSettings`, set auto LP burn settings - `setLaunch`, set the launch status  In the contract `Ownable`, the role `_owner` has authority over the functions shown in the diagram below. Any compromise to the `_owner` account may allow the hacker to take advantage of this authority and transfer contract ownership or renounce ownership rights. 
The audit on Trustblock · Open the reportThe `withdrawETH` function is used for users to sell tokens to the contract and receive ETH. However, it would always revert due to a faulty fee calculation. The problematic line: ```solidity uint256 fee = (amount * feeBase) / feeTotal; ``` uses `feeBase` set to 10,000 and `feeTotal` set to 100, resulting in an effective multiplier of 100 for the fee. This causes the calculated fee to be 100 times the amount, leading to an underflow in the `amount -= fee` operation, and consequently causing the function to revert. This issue makes the `withdrawETH` function unusable and creates a critical barrier to withdrawal functionality.
The audit on Trustblock · Open the reportAll GOUT tokens are sent to the contract and the `_owner` address. This is a centralization risk because the `_owner` can distribute tokens without obtaining the consensus of the community. Any compromise to the address may allow a hacker to steal and sell tokens on the market, resulting in severe damage to the project.
The audit on Trustblock · Open the reportThe `receiveToken()` function allows the `_owner` to withdraw both BNB and any ERC20 tokens (e.g., GOUT tokens) from the contract without restrictions. This can pose significant risks, as it grants the `_owner` full control over the contract's assets without any limitations or conditions. ```solidity=1389 function receiveToken(address _addr) public onlyOwner { if (_addr == address(0)) { payable(_msgSender()).transfer(address(this).balance); } else { IERC20 token = IERC20(_addr); token.transfer(_msgSender(), token.balanceOf(address(this))); } } ```
The audit on Trustblock · Open the reportThe `getWithdrawOut()` function is designed to calculate the amount of BNB a user would receive by selling GOUT tokens. The auditor has identified potential concerns regarding the calculation logic and potential manipulation risks associated with this function. Below are the two main questions raised, along with a discussion on their implications. ### Questions for Clarification: 1. **Calculation Logic Using `total + amountIn`:** The function divides `amountIn * address(this).balance` by `total + amountIn` instead of just `total`. This implies that when a user sells all circulating GOUT tokens, they will only receive half of the contract's BNB balance, rather than the full balance. 2. **Manipulation of `total` by the Seller:** the `total` value in the calculation is derived from the `totalSupply()` minus the balances of the `0xdead` address and liquidity pools (`pairETH` and `pairUSDT`). A seller could potentially manipulate `total` by swapping BNB for GOUT to increase the token balance in the `pairETH` address. This would decrease `total`, resulting in a higher amount of BNB received when selling GOUT. ```solidity=1346 function getWithdrawOut(uint256 amountIn) public view returns (uint256) { uint256 total = totalSupply() - balanceOf(address(0xdead)) - balanceOf(pairETH) - balanceOf(pairUSDT); return (amountIn * address(this).balance) / (total + amountIn); } ```
The audit on Trustblock · Open the reportThe `addLiquidity` function, designed to add initial liquidity, can currently be called multiple times without restriction. The project allows users to sell tokens to the contract, which could lead to the contract accumulating a substantial amountInToken. The contract owner could repeatedly call the addLiquidity function, using these accumulated tokens to gain LP tokens.
The audit on Trustblock · Open the reportThe `setAutoLPBurnSettings()` function is intended to configure the parameters for the automatic LP token burn process. According to the error message, the intended design is to ensure that the burn percentage does not exceed 5%. However, due to the way the percentage is calculated (`percentForLPBurn / percentDiv`), the current implementation allows the burn percentage to exceed 5% because `percentDiv` can be set arbitrarily high or low. ```soldiity=1375 function setAutoLPBurnSettings( uint256 _frequencyInSeconds, uint256 _percent, uint256 _div, bool _Enabled ) external onlyOwner { require(_percent <= 500, "percent too high"); require(_frequencyInSeconds >= 100, "frequency too shrot"); lpBurnFrequency = _frequencyInSeconds; percentForLPBurn = _percent; percentDiv = _div; lpBurnEnabled = _Enabled; } ```
The audit on Trustblock · Open the reportThe `_transfer` function enforces a restriction where users must retain a minimum balance of `_minWallet` (set to 8 * 10^18, equivalent to 8 tokens) in their accounts. The relevant logic: ```solidity function _transfer( address from, address to, uint256 amount ) internal virtual override { if(from != address(this) && balanceOf(from).sub(amount) < _minWallet) { amount = balanceOf(from).sub(_minWallet); } ``` effectively limits the transfer amount if the transaction would cause the sender's balance to fall below `_minWallet`. As a result, users are unable to fully utilize their token balance, leaving 8 tokens "locked" in every account. This design can cause confusion and frustration among users, as they might expect to withdraw or transfer their entire balance but are prevented from doing so without a clear explanation or documentation of this restriction.
The audit on Trustblock · Open the reportAn SPDX (Software Package Data Exchange) license identifier is a standardized short-form identifier for software licenses. These identifiers are used to communicate the licensing components of software packages in a concise, consistent, and machine-readable manner. Placing the SPDX license identifier on the first line of a file is a best practice because it enhances visibility, ensures consistency, supports tool compatibility, and aids in standardizing license documentation across codebases. However, in the file, the SPDX license identifier is misplaced, thus the best practice is not followed. For more references: 1. [SPDX Official Website](https://spdx.org) 2. [GitHub Licensing a Repository Help Page**](https://docs.github.com/en/github/creating-cloning-and-archiving-repositories/licensing-a-repository) 3. [Open Source Initiative (OSI)](https://opensource.org/licenses/MIT) 4. [SPDX License List](https://spdx.org/licenses/)
The audit on Trustblock · Open the reportThere should always be events emitted in the sensitive functions that are controlled by centralization roles.
The audit on Trustblock · Open the reportThe `multiTransfer()` function uses `addrs` and `amounts` arrays in a single `transfer()` function call. Therefore, the elements of arrays must correspond one-to-one, and their lengths must match. However, the function does not perform this check.
The audit on Trustblock · Open the reportA sandwich attack can occur when an attacker notices a transaction involving token swaps or liquidity additions that lacks slippage restrictions or minimum output amount settings. The attacker can exploit this by frontrunning the transaction to purchase one of the assets, thereby manipulating the exchange rate, and then backrunning the transaction to sell the asset for a profit. The referenced functions are invoked without setting slippage restrictions or minimum output amounts, making transactions that trigger these functions particularly vulnerable to sandwich attacks, especially when large input amounts are involved.
The audit on Trustblock · Open the reportThe change of `_owner` by function `transferOwnership()` overrides the previously set `_owner` with the new one without guaranteeing the new `_owner` is able to actuate transactions on-chain.
The audit on Trustblock · Open the reportThe 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 · Open the reportSolidity version >=0.8.0 includes checked arithmetic operations and underflow/overflow by default, making SafeMath redundant.
The audit on Trustblock · Open the reportThe GOUT security record · Every GOUT address · This address on the explorer