0xc3137c696796d69f783cd0be4ab4bb96814234aa
As of 21 Nov 2026, Trustblock’s record holds 0xc3137c696796d69f783cd0be4ab4bb96814234aa on BNB Chain as a contract of Pepa Inu. 1 audit report on Trustblock lists this address: CertiK, 23 May 2023. 14 findings in it are recorded as open or acknowledged.
Each report’s scope as stored on Trustblock names this address on BNB Chain.
1 High, 1 Medium, 12 Low. In the firm’s own words; statuses are the firm’s, from each report.
All initial `PEPA` tokens are sent to the address `_owner` by the following statement when deploying the contract. This is a potential centralization risk as the deployer can distribute `Golteum` tokens without the consensus of the community. ```solidity=1042 _rOwned[owner()] = _rTotal; ```
The audit on Trustblock · Open the reportThe `swapAndLiquify()` function converts half of the `Pepa` tokens to BNB. The other half of `Pepa` tokens and part of the converted BNB are deposited into the pool on Pancakeswap as liquidity. For every `swapAndLiquify()` function call, a small amount of BNB is left over in the contract. This is because the price of `Pepa` drops after swapping the first half into BNB, and the other half of `Pepa` require less than the converted BNB to be paired with it when adding liquidity. The contract does not appear to provide a way to withdraw those `Pepa`, and they will be locked in the contract forever.
The audit on Trustblock · Open the reportThe error message in the function `includeInReward()` does not describe the error correctly. ```solidity=1225 require(_isExcluded[account], "Account is already excluded") ```
The audit on Trustblock · Open the reportFunctions that update state variables should emit relevant events as notifications. For example: setEnableAntiBot(), deliver(), excludeFromReward(), includeInReward(), excludeFromFee(), setTaxFeePercent(), setLiquidityFeePercent(), setCharityFeePercent(), etc.
The audit on Trustblock · Open the reportAddresses 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=1065 payable(serviceFeeReceiver_).transfer(serviceFee_); ``` - `serviceFeeReceiver_` is not zero-checked before being used.
The audit on Trustblock · Open the reportGenerally, deflationary tokens are incompatible with DEX and special rules need to be coded for DEX addresses eg. excluding them from reward.
The audit on Trustblock · Open the reportWhen the contract is deployed the following addresses are exempted from fees: - the address `_owner` If ownership is transferred or renounced with `transferOwnership()` or `renounceOwnership()`, the exemptions are not granted to the new owner nor are they revoked from the previous owner.
The audit on Trustblock · Open the reportThe condition `!_isExcluded[sender] && !_isExcluded[recipient]` can be included in `else` .
The audit on Trustblock · Open the reportThe function `constructor()` is payable and sends an arbitrary amount of Ether to an arbitrary address(`serviceFeeReceiver_`). The destination `serviceFeeReceiver_` and Ether amount `serviceFee_` are both passed in as inputs. We want to confirm with the client the purpose of this implementation. ```solidity=1065 payable(serviceFeeReceiver_).transfer(serviceFee_); ```
The audit on Trustblock · Open the reportThe function `deliver()` can be called by anyone. It accepts an uint256 number parameter `tAmount`. The function reduces the METT token balance of the caller by `rAmount`, which is `tAmount` reduces the transaction fee. Then, the function adds `tAmount` to variable `_tFeeTotal`, which represents the contract's total transaction fee. We wish the team could explain more on the purpose of having such functionality.
The audit on Trustblock · Open the reportThe `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=201 library SafeMath { ``` - An implementation of `SafeMath` library is found. --- ```solidity=934 using SafeMath for uint256; ``` - `SafeMath` library is used for `uint256` type in `AntiBotLiquidityGeneratorToken` contract. ```solidity=1038 numTokensSellToAddToLiquidity = totalSupply_.div(10**3); // 0.1% ``` - `SafeMath.div` is called in `constructor` function of `AntiBotLiquidityGeneratorToken` contract. *Note: Only a sample of 2 `SafeMath` library usage in this contract (out of 54) are shown above.*
The audit on Trustblock · Open the reportSome events are never emitted, which can lead to confusion and code maintainability issues. ```solidity=979 event MinTokensBeforeSwapUpdated(uint256 minTokensBeforeSwap); ``` - `MinTokensBeforeSwapUpdated` is declared in `AntiBotLiquidityGeneratorToken` but never emitted.
The audit on Trustblock · Open the reportIt is not recommended to use Solidity's `transfer()` and `send()` functions for transferring Ether, since some contracts may not be able to receive the funds. Those functions forward only a fixed amount of gas (2300 specifically) and the receiving contracts may run out of gas before finishing the transfer. Also, EVM instructions' gas costs may increase in the future. Thus, some contracts that can receive now may stop working in the future due to the gas limitation. ```solidity=1065 payable(serviceFeeReceiver_).transfer(serviceFee_); ``` - `AntiBotLiquidityGeneratorToken.constructor` uses `transfer()`.
The audit on Trustblock · Open the reportThe 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 · Open the reportThe Pepa Inu security record · Every Pepa Inu address · This address on the explorer