Grok 1.5 contract 0xdf67…4ca4 on BNB Chain

0xdf67abeae37266dd6369a5c657cea2c197e64ca4

As of 21 Nov 2026, Trustblock’s record holds 0xdf67abeae37266dd6369a5c657cea2c197e64ca4 on BNB Chain as a contract of Grok 1.5. 1 audit report on Trustblock lists this address: CertiK, 6 May 2024. 11 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
Grok 1.5 - AuditCertiKNot recorded (see the report)On Trustblock

Open and acknowledged findings in these reports11

1 High, 10 Low. In the firm’s own words; statuses are the firm’s, from each report.

HighInitial Token DistributionGrok 1.5 - Audit · CertiKOpen

All of the `Grok1.5` tokens are sent to the contract deployer. This is a centralization risk because the deployer 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
LowDiscussion On The Gas Used In `internalSwap`Grok 1.5 - Audit · CertiKOpen

In the `Grok` contract, once the balance exceeds a certain threshold, some tokens are converted into native tokens and sent to `marketingAddress` and `devWallet`. The call to transfer these native tokens attaches 35,000 gas. ```solidity=432 if(mktAmount > 0) (success,) = marketingAddress.call{value: mktAmount, gas: 35000}(""); if(devAmount > 0) (success,) = devWallet.call{value: devAmount, gas: 35000}(""); ``` Typically, a straightforward native token transfer doesn't require such a large amount of gas. However, if `marketingAddress` and `devWallet` are contracts, the additional gas attached possibly enables them to execute operations within their `receive` function to make a recursive call back to the original function. We hope the team will share their thoughts on the design philosophy behind this part.

The audit on Trustblock
LowHardcode AddressGrok 1.5 - Audit · CertiKOpen

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

The audit on Trustblock
LowLack Of Reverse FunctionsGrok 1.5 - Audit · CertiKOpen

The `enableTrading` function allows the admin to enable the trading by setting `isTradingEnabled` to true. ```solidity=444 function enableTrading() external onlyOwner { require(!isTradingEnabled, "Trading already enabled"); isTradingEnabled = true; emit _enableTrading(); } ``` However, there is no reverse function to disable the trading by setting `isTradingEnabled` to false. The `changeLpPair` function also has a similar problem. It allows `isLpPair[newPair]` to be set to true, but lacks a corresponding function to revert `isLpPair` to false once a pair has been marked as true. ```solidity=310 function changeLpPair(address newPair) external onlyOwner { isLpPair[newPair] = true; emit _changePair(newPair); } ``` This can lead to issues if the owner accidentally changes the value, potentially impacting the contract's operations.

The audit on Trustblock
LowLack of validation for `newPair` AddressGrok 1.5 - Audit · CertiKOpen

The `changeLpPair` is designed to allow the owner to update the `isLpPair` mapping, making the new LP pair address as true. ```solidity=310 function changeLpPair(address newPair) external onlyOwner { isLpPair[newPair] = true; emit _changePair(newPair); } ``` However, it's worth noting that the function lacks a verification mechanism to confirm the validity of the provided LP pair address as an actual LP pair for the token.

The audit on Trustblock
LowNot check the allowanceGrok 1.5 - Audit · CertiKOpen

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

The audit on Trustblock
LowPotential Sandwich AttacksGrok 1.5 - 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: - `swapExactTokensForETHSupportingFeeOnTransferTokens()` - `addLiquidityETH()`

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

State variables that never change should be declared as `constant` to save gas. ```solidity=189 uint256 private buyAllocation = 40; ``` - `buyAllocation` should be declared `constant`. --- ```solidity=190 uint256 private sellAllocation = 40; ``` - `sellAllocation` should be declared `constant`. --- ```solidity=191 uint256 private liquidityAllocation = 20; ``` - `liquidityAllocation` should be declared `constant`.

The audit on Trustblock
LowUnused InterfaceGrok 1.5 - Audit · CertiKOpen

The smart contract contains one or more inteface definitions that are not used, which can lead to unnecessary complexity and reduced maintainability. ```solidity=70 interface IV2Pair { ``` - `IV2Pair` is declared but never used.

The audit on Trustblock
LowUnused Return ValueGrok 1.5 - Audit · CertiKOpen

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

The audit on Trustblock
LowVariables That Could Be Declared as ImmutableGrok 1.5 - 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 Grok 1.5 security record · Every Grok 1.5 address · This address on the explorer