Quantum Audit Logo
Ethereum · Smart Contract Security · Updated Jul 24, 2026

Is Cronos Safe? CRO

On-chain security analysis — is it a scam or legit?

Contract 0xa0b7…450b DexScreener ↗
Critical Risk How is this score calculated? →
Volume 24h
$16.3K
Liquidity
$422.4K
Price
$0.0583
Token Age
1y
Top 10 Holders
96.4%

Security Checklist

Contract VerifiedPass
Ownership RenouncedFail
No Mint FunctionFail
Liquidity LockedFail
Not a ProxyPass

Audit History

Jul 2380

Every audit run adds a dated snapshot — history is append-only and cannot be edited.

Audit Summary

This audit covers a standard ERC-20 token implementation with minting capabilities, based on OpenZeppelin contracts from Solidity version 0.4.13. The contract utilizes `SafeMath` for arithmetic operations and an `Ownable` pattern for administrative control. Key findings include significant economic risks due to centralized and uncapped minting, and technical risks associated with an outdated Solidity compiler version and the known ERC-20 `approve` race condition. Operational risks related to owner renouncement and lack of emergency pausability are also noted.

Final Recommendation: It is strongly recommended to migrate to a modern Solidity compiler version (e.g., 0.8.x) to leverage improved security features, gas efficiency, and best practices. Implement a clear, immutable total supply cap for the token to mitigate economic risks associated with centralized minting. Consider implementing a timelock for critical administrative actions and an emergency pause mechanism to provide a safety net against unforeseen vulnerabilities or market events.

Category Ratings

TechnicalMedium
6/10

The contract's architecture (7.1) is based on well-established OpenZeppelin patterns for ERC-20 and Ownable, which provides a solid foundation. `SafeMath` is correctly used throughout for arithmetic safety (7.2 Code Security). However, the use of Solidity `^0.4.13` introduces technical debt and

GovernanceHigh
1/10

The economic model (7.4) presents a high risk due to the centralized minting mechanism, which allows the contract owner to mint an unlimited supply of tokens until `finishMinting` is called. There is no explicit maximum total supply defined, leading to potential arbitrary inflation. Access control (

UpgradesMedium
4/10

The contract is not designed with an upgrade mechanism (7.7 Architecture), meaning its logic cannot be modified after deployment. This eliminates upgrade-related risks but also prevents future bug fixes or feature enhancements without a new deployment and migration.

LP Distribution

Top-1 Unlocked Holder64.5%
Top-3 Unlocked85.9%

What Raised This Score

Each factor is an on-chain fact recorded at the time of this analysis. The score is computed from them by a deterministic function, so the same contract returns the same score for anyone who runs the audit. How scores are computed

Security Findings

2 High 2 Medium 1 Low
H-01HighUnresolved

Centralized and Uncapped Minting Authority

The `MintableToken` contract grants the `owner` the ability to mint an arbitrary amount of new tokens at any time until the `finishMinting()` function is called. There is no predefined maximum total supply for the token. This centralized control over supply, without a hard cap, poses a significant economic risk as the owner could inflate the token supply, devaluing existing tokens for holders.

Recommendation: Implement a hard cap on the total supply of tokens that can ever be minted. Consider decentralizing the minting process or introducing a multi-signature wallet for minting operations. Ensure the `finishMinting()` function is called promptly once the desired supply is reached, or integrate a time-locked mechanism for this action.
H-02HighUnresolved

Outdated Solidity Compiler Version

The contract is compiled with Solidity `^0.4.13`. This version is significantly outdated and lacks numerous security enhancements, bug fixes, and gas optimizations introduced in later compiler versions (e.g., 0.6.x, 0.8.x). Notably, `assert()` statements, as used in `SafeMath`, consume all remaining gas on failure in 0.4.x, which is less efficient than `require()`/`revert()` introduced in 0.4.22 and later.

Recommendation: Upgrade the contract to a recent and stable Solidity compiler version (e.g., 0.8.x). This would allow for the use of modern language features, improved security checks, and more gas-efficient error handling. Thoroughly test the contract after upgrading to ensure compatibility and correctness.
M-01MediumUnresolved

ERC-20 `approve` Race Condition Vulnerability

The `approve` function in `StandardToken` is susceptible to a known ERC-20 race condition. If a user changes an allowance from a non-zero value to another non-zero value, a malicious spender could potentially spend both the old and new allowance amounts by front-running the transaction. While `increaseApproval` and `decreaseApproval` functions are provided to mitigate this, the base `approve` function remains vulnerable if used directly.

Recommendation: Educate users to exclusively use `increaseApproval` and `decreaseApproval` for modifying allowances. For the `approve` function itself, consider implementing the 'set to zero then set to new value' pattern, or clearly document the risk and the recommended alternative functions.
M-02MediumUnresolved

Owner Renouncement Operational Risk

The `renounceOwnership` function allows the current owner to set the `owner` address to `address(0)`. If this function is called without a subsequent `transferOwnership` to a new, valid owner, the contract will become permanently unowned. This would render all functions protected by the `onlyOwner` modifier, such as `mint` and `finishMinting`, inaccessible, leading to a loss of critical administrative control.

Recommendation: Implement a multi-step process for `renounceOwnership` or `transferOwnership` to prevent accidental loss of control. For example, require the new owner to accept ownership before the transfer is finalized. If renouncement is intended, ensure all necessary administrative actions are completed beforehand.
L-01LowUnresolved

Lack of Emergency Pausability

The contract lacks a mechanism to pause critical operations, such as token transfers or minting, in the event of an emergency. In scenarios like a discovered vulnerability, a major exploit, or extreme market volatility, the absence of an emergency stop can prevent a rapid response to mitigate potential damage.

Recommendation: Consider implementing a pausability mechanism (e.g., using OpenZeppelin's `Pausable` contract pattern) that allows the owner or a designated role to temporarily halt sensitive operations. This should be used as a last resort and ideally be time-limited or subject to governance control.

Would You Like a More Detailed Audit of Cronos?

Our AI-powered scanner gives you a deeper, real-time smart contract analysis — free, no signup required.

Get Detailed Audit
Run Free Audit →