BabyGrok - Audit

CertiK1 address on BNB Chain

CertiK reviewed Grok Cat (BabyGrok - Audit) on 24 Nov 2023: 11 findings, 0 critical; 2 marked fixed, 9 open.

No open critical findings
Open Grok Cat’s security record

The original report was removed from its address (seen 15 Oct 2026).

Trustblock does not review code.

Findings11

Statuses are the security firm’s own, from its report.

SeverityOpenAcknowledgedFixed
Critical000
High101
Medium000
Low801
HighInitial Token DistributionOpen

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.

LowHardcode AddressOpen

There are some hardcode addresses in this codebase. If not configured properly, this can cause side effects on the contract.

LowInconsistency with the official websiteOpen

The 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.

LowNot check the allowanceOpen

The `transferFrom()` reduce the allowance directly without checking the allowance.

LowPotential Risk On `approve()`/`transferFrom()` MeOpen

The 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.

LowPotential Sandwich AttacksOpen

A 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(...)`

LowState Variable Should Be Declared ConstantOpen

State 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`.

LowUnused Return ValueOpen

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=387 try swapRouter.addLiquidityETH{value: newBalance}( address(this), secondMath, 0, 0, DEAD, block.timestamp ){} catch {return;} ```

LowVariables That Could Be Declared as ImmutableOpen

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.

Contracts in scope1

AddressChainSource code
0x88da9901b3a02fe24e498e1ed683d2310383e295Chain: BNB ChainSource code: Verified source

Part of Grok Cat’s security record

Grok Cat
Audits4 audits by 2 firmsLast audit Jul 2025, by Cyberscope.
Critical findingsNo open critical findingsAcross 4 reports.
Open Grok Cat’s security record

Security firm

CertiK

1,045 projects reviewed · 1,376 reports · latest May 2025

See CertiK’s audits

Something wrong on this page? A missing report, a wrong date, a finding that was fixed since. Tell us and we check it against its source.

Tell us