0x88da9901b3a02fe24e498e1ed683d2310383e295
As of 21 Nov 2026, Trustblock’s record holds 0x88da9901b3a02fe24e498e1ed683d2310383e295 on BNB Chain as a contract of Grok Cat. 2 audit reports on Trustblock list this address, from CertiK and Cyberscope; the newest is CertiK, 24 Nov 2023. 16 findings in them 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 |
|---|---|---|---|---|
| BabyGrok - Audit | CertiK | Not recorded (see the report) | On Trustblock | |
| Baby Grok | Cyberscope | Not recorded (see the report) | Open |
1 High, 15 Low. In the firm’s own words; statuses are the firm’s, from each report.
All of the `BabyGrok` tokens are sent to the contract deployer or one or several externally-owned account (EOA) addresses. This is a centralization risk because the deployer or the owner(s) of the EOAs 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 TrustblockThere are some hardcode addresses in this codebase. If not configured properly, this can cause side effects on the contract.
The audit on TrustblockThe official website states that a percentage of every transaction is burned, reducing the total supply and increasing the scarcity of Baby Grok over time. However, the fee of a normal transfer is zero, which does not align with the description on the website.
The audit on TrustblockThe `transferFrom()` reduce the allowance directly without checking the allowance.
The audit on TrustblockThe current contract is vulnerable to [a known ERC20 race condition issue](https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729), which could lead to token theft. When a user calls `approve()` for a second time on a spender that has already been allowed, the spender could call `transferFrom()` to transfer the previous value and still receive the authorization to transfer the new value. Exploit scenario: 1. Alice calls `approve(Bob, 100)` to allow Bob to spend 100 tokens. 2. Alice changes her mind and calls `approve(Bob, 50)`. 3. Bob observes the second `approve(Bob, 50)` function call and calls `transferFrom(Alice, Bob, 100)` before the second `approve(Bob, 50)` call. 4. The above scenario can be achieved by front-running. In this case, Bob can transfer another 50 tokens from Alice and in total, he transferred 150 tokens from Alice.
The audit on TrustblockA sandwich attack may 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 (executing before the target) a transaction to purchase one of the assets and make profits by backrunning (executing after the target) 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: - `swapRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(...)`
The audit on TrustblockState variables that never change should be declared as `constant` to save gas. ```solidity=180 uint256 private buyAllocation = 40; ``` - `buyAllocation` should be declared `constant`. --- ```solidity=181 uint256 private sellAllocation = 40; ``` - `sellAllocation` should be declared `constant`. --- ```solidity=182 uint256 private liquidityAllocation = 20; ``` - `liquidityAllocation` should be declared `constant`.
The audit on TrustblockThe 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=387 try swapRouter.addLiquidityETH{value: newBalance}( address(this), secondMath, 0, 0, DEAD, block.timestamp ){} catch {return;} ```
The audit on TrustblockThe 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 TrustblockThe Grok Cat security record · Every Grok Cat address · This address on the explorer