Grok 1.5 has 1 public audit report from CertiK; dated 6 May 2024; no critical findings reported. It also holds 1 deployed contract on 1 chain.
Last updated . It holds audits and findings, contracts and incidents up to Nov 2026. Trustblock does not review code.
Statuses are the security firms’ own
11 findings are still open or acknowledged in the firms’ reports: 1 high, 10 low (all open).
Initial Token Distribution
Grok 1.5 - Audit · CertiK · 6 May 2024 · Report ↗
Discussion On The Gas Used In `internalSwap`
Grok 1.5 - Audit · CertiK · 6 May 2024 · Report ↗
Hardcode Address
Grok 1.5 - Audit · CertiK · 6 May 2024 · Report ↗
Lack Of Reverse Functions
Grok 1.5 - Audit · CertiK · 6 May 2024 · Report ↗
Lack of validation for `newPair` Address
Grok 1.5 - Audit · CertiK · 6 May 2024 · Report ↗
Not check the allowance
Grok 1.5 - Audit · CertiK · 6 May 2024 · Report ↗
Potential Sandwich Attacks
Grok 1.5 - Audit · CertiK · 6 May 2024 · Report ↗
State Variable Should Be Declared Constant
Grok 1.5 - Audit · CertiK · 6 May 2024 · Report ↗
Unused Interface
Grok 1.5 - Audit · CertiK · 6 May 2024 · Report ↗
Unused Return Value
Grok 1.5 - Audit · CertiK · 6 May 2024 · Report ↗
Newest first
| Report | Security firm | Date | Scope | Critical findings | Findings | Source |
|---|---|---|---|---|---|---|
| Grok 1.5 - Audit | Security firm: CertiK | Date: | Scope: 1 address on BNB Chain | None open | Findings: 2 high · 10 low 1 fixed · 11 open | Original removed |
Statuses are the security firm’s own, from each report.
| Severity | Open | Acknowledged | Fixed |
|---|---|---|---|
| Critical | 0 | 0 | 0 |
| High | 1 | 0 | 1 |
| Medium | 0 | 0 | 0 |
| Low | 10 | 0 | 0 |
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.
Open the reportIn 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.
Open the reportThere are some hardcode addresses in this codebase. If not configured properly, this can cause side effects on the contract.
Open the reportThe `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.
Open the reportThe `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.
Open the reportThe `transferFrom()` reduce the allowance directly without checking the allowance.
Open the reportA 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()`
Open the reportState 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`.
Open the reportThe 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.
Open the reportThe 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;} ```
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.
Open the report| Address | Chain | Source code |
|---|---|---|
| 0xdf67…4ca40xdf67abeae37266dd6369a5c657cea2c197e64ca4 | Chain: BNB Chain | Source code: Verified source |
Trustblock holds 1 public audit report for Grok 1.5, dated 6 May 2024. The latest is by CertiK (“Grok 1.5 - Audit”).
CertiK wrote the report Trustblock holds for Grok 1.5.
11 findings are still open or acknowledged in the firms’ reports: 1 high, 10 low (all open). No critical finding is reported. Statuses are the security firms’ own.
Is this your project? Show this record on your own website. The label states what the record holds, links to this page and updates by itself. It is free and needs no sign-in.
Automatic: the three strongest facts of this project’s own record (its last audit and two more), highlighted. They update with the record. Picking a fact turns Automatic off.
<head><script src="https://widget.trustblock.run/project-widget.min.js" defer></script></head><body><divdata-tb-project-widgetdata-tb-project-slug="grok-15"></div></body>
Paste the code where the label should appear. It uses no API credit and updates by itself.
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