Quantum Audit Logo

Is Quant Safe?

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

Is this your token? Publish your own audit on this page →

Quant QNT
0x4a22…4675
Ethereum Not verifiedLast checked 3d ago 1 audit on record
DexScreener ↗
How is this score calculated? → High Risk
Executive SummaryAI Copilot

The audit of the StandardToken contract revealed a critical flaw where the `totalSupply()` function does not accurately reflect the actual circulating supply due to the `mint` function failing to update the `totalSupply_` variable. Additionally, the contract uses an outdated Solidity compiler version, which may expose it to known vulnerabilities. Access control for minting is centralized and immutable, and the ERC-20 `approve` function is susceptible to a race condition.

1 Critical1 High2 Medium1 Low
Volume 24h
$103.0K
Liquidity
$459.8K
Price
$65.4300
Token Age
5y
Top 10 Holders
28.8%

Security Findings

1 Crit1 High2 Med1 Low
Critical

Inaccurate `totalSupply` Calculation

C-01The `totalSupply_` variable is initialized to a fixed value (45,467,000 QNT with 18 decimals) and never updated by the `mint` function. This means `totalSupply()` will always return the initial hardcoded value, not the actual sum of all token balances, leading to a critical misrepresentation of the token's circulating supply. This can severely impact market perception, integrations, and overall token economics.
IssueThe `totalSupply_` variable is initialized to a fixed value (45,467,000 QNT with 18 decimals) and never updated by the `mint` function. This means `totalSupply()` will always return the initial hardcoded value, not the actual sum of all token balances, leading to a critical misrepresentation of the token's circulating supply. This can severely impact market perception, integrations, and overall token economics.
FixModify the `mint` function to increment `totalSupply_` by `_value` whenever new tokens are minted. Ensure `totalSupply_` accurately reflects the sum of all token balances. Alternatively, remove `totalSupply_` and calculate `totalSupply()` by summing all balances, though this is less gas efficient.
StatusUnresolved
High

Outdated Solidity Compiler Version

H-01The contract uses `pragma solidity ^0.4.21`. This version range is significantly outdated and may be susceptible to known compiler bugs and security vulnerabilities that have been patched in newer versions (e.g., 0.8.x). Deploying with an old compiler version increases the risk of undiscovered or known exploits.
IssueThe contract uses `pragma solidity ^0.4.21`. This version range is significantly outdated and may be susceptible to known compiler bugs and security vulnerabilities that have been patched in newer versions (e.g., 0.8.x). Deploying with an old compiler version increases the risk of undiscovered or known exploits.
FixUpgrade the Solidity compiler version to a recent, stable release (e.g., `^0.8.0`). Thoroughly test the contract after upgrading, as syntax and behavior may have changed, particularly regarding `assert` vs `require` and default overflow checks.
StatusUnresolved
Medium

ERC-20 `approve` Race Condition

M-01The `approve` function is vulnerable to the known ERC-20 race condition. If a user calls `approve` to change an allowance from `X` to `Y`, and the spender front-runs this transaction by spending `X` tokens, the spender could then spend `Y` tokens, effectively spending `X+Y` tokens. While `increaseApproval` and `decreaseApproval` are provided to mitigate this, the `approve` function itself remains vulnerable.
IssueThe `approve` function is vulnerable to the known ERC-20 race condition. If a user calls `approve` to change an allowance from `X` to `Y`, and the spender front-runs this transaction by spending `X` tokens, the spender could then spend `Y` tokens, effectively spending `X+Y` tokens. While `increaseApproval` and `decreaseApproval` are provided to mitigate this, the `approve` function itself remains vulnerable.
FixWhile `increaseApproval` and `decreaseApproval` are good additions, users should be educated to use these functions instead of `approve` when modifying an existing allowance. For `approve` itself, consider adding a check that `_value` is 0 if `allowed[msg.sender][_spender]` is not 0, forcing a two-step approval process (set to 0, then set to new value).
StatusUnresolved
Medium

Immutable Crowdsale Address and Centralized Minting

M-02The `crowdsale` address, which has exclusive permission to call the `mint` function, is set in the constructor and cannot be changed. This creates a single point of control for token minting without any mechanism for transferability or multi-signature protection. If the `crowdsale` key is compromised or lost, it could lead to unauthorized minting or a permanent inability to mint new tokens.
IssueThe `crowdsale` address, which has exclusive permission to call the `mint` function, is set in the constructor and cannot be changed. This creates a single point of control for token minting without any mechanism for transferability or multi-signature protection. If the `crowdsale` key is compromised or lost, it could lead to unauthorized minting or a permanent inability to mint new tokens.
FixConsider implementing a mechanism to transfer ownership of the `crowdsale` role, possibly through a time-locked or multi-signature process. Ideally, the `crowdsale` address itself should be a multi-signature wallet to reduce the risk of a single point of failure.
StatusUnresolved
Low

Gas Inefficiency with `assert` in SafeMath

L-01The `SafeMath` library uses `assert` for overflow/underflow checks. In Solidity versions prior to 0.8.0, `assert` consumes all remaining gas upon failure, whereas `require` refunds unused gas. While functionally correct for preventing arithmetic errors, this can lead to higher gas costs for failed transactions compared to modern `require`-based checks.
IssueThe `SafeMath` library uses `assert` for overflow/underflow checks. In Solidity versions prior to 0.8.0, `assert` consumes all remaining gas upon failure, whereas `require` refunds unused gas. While functionally correct for preventing arithmetic errors, this can lead to higher gas costs for failed transactions compared to modern `require`-based checks.
FixIf upgrading to Solidity 0.8.0+, `SafeMath` might not be strictly necessary due to built-in overflow checks. If remaining in 0.4.x, consider replacing `assert` with `require` in `SafeMath` functions for better gas efficiency on reverts, though this would require careful re-evaluation of the `SafeMath` library's design.
StatusUnresolved

Category Ratings

TechnicalMedium5/10

The contract implements the ERC-20 standard using the `SafeMath` library to prevent integer overflows/underflows, which is a strength (7.2 Code Security). However, a critical issue exists where the `totalSupply()` function does not correctly track the token supply after minting, leading to a misrepresentation of the token's circulating supply (7.1 Architecture, 7.2 Code Security, 7.4 Economic). The use of an outdated Solidity compiler version (`^0.4.21`) introduces potential exposure to known compiler bugs (7.2 Code Security). Furthermore, the `approve` function is vulnerable to a race condition (7.2 Code Security).

GovernanceHigh1/10

The economic model is severely impacted by the `totalSupply` misrepresentation, which can lead to incorrect market valuations and user confusion (7.4 Economic). Access control for the `mint` function is appropriately restricted to a `crowdsale` address (7.3 Access Control). However, this `crowdsale` address is immutable and represents a single point of control for token issuance, lacking any multi-signature or upgradeability features (7.3 Access Control, 7.5 Governance). There are no explicit governance mechanisms beyond this single-address control.

UpgradesHigh2/10

The contract does not implement any upgradeability patterns, meaning its logic is immutable once deployed (7.7 Upgrades). While this eliminates risks associated with faulty upgrade mechanisms, it also prevents any future bug fixes, feature enhancements, or adjustments to the `crowdsale` address without a complete redeployment and migration. This lack of flexibility is a significant operational constraint (7.8 Operations).

Security Checklist

2/5 checks passed
Contract VerifiedPass
Ownership RenouncedFail
No Mint FunctionFail
Liquidity LockedFail
Not a ProxyPass
HoneypotNoneBuy Tax0.0%Sell Tax0.0%

Holder Composition

28.8% in top 10
7.8% in wallets21.0% in contracts
Effective Concentration16.2%

Share held by contracts — treasury, vesting, bridge or staking — is discounted against share held by wallets when the score is computed: a contract cannot decide to sell the way an anonymous holder can, though it can still be drained or voted to sell. Effective concentration is the figure the risk score is actually calculated from.

Liquidity Depth

$1.06M across 8 pairs
Uniswap v3WETHanalysed$459.8K43.6%Uniswap v4USDC$455.4K43.1%Uniswap v2WETH$62.1K5.9%Balancer v3wstETH$38.4K3.6%Balancer v3WBTC$20.6K2.0%Uniswap v3USDT$14.1K1.3%
Show 2 more pairsShow less
Uniswap v4ETH$4.9K0.5%Uniswap v4ETH$3540.0%

The risk score reads depth across every pair. The volume figure and the volume-to-liquidity ratio elsewhere on this page describe only the pair this audit analysed, so the two are not directly comparable.

LP Distribution

Top-1 Unlocked Holder76.8%
Top-3 Unlocked100.0%

Key Addresses

5 addresses
Deployer
0xf5e3…c4bc
Unlocked LP Held By
0x0271…110d0xc6f7…8bc60xceea…d3d40x8cc5…366e

No privileged address appears among these holders: the unlocked liquidity sits with independent providers, not with the deployer.

What Raised This Score

9 factors
  • Ownership NOT renounced (admin/mint authority retained)
  • Mintable supply — no cap found, dilution unbounded
  • Liquidity not locked, but no owner/deployer address holds LP — market-depth risk, not rug risk
  • LP top1 unlocked holder = 76.8% (independent LP — depth risk, pool = 44% of DEX liquidity)
  • LP top3 unlocked holders = 100.0% (independent LP — depth risk, pool = 44% of DEX liquidity)
  • 1 Critical finding(s) from audit
  • 1 High finding(s) from audit
  • 2 Medium finding(s) from audit
  • 1 Low finding(s) from audit

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

Related Audits

6 more on the record
Helix Token (HLX)High RiskEuler (EUL)High RiskMorphoHigh RiskBeamHigh RiskSuperVerse (SUPER)High Risk00 Token (00)High Risk

Would You Like a More Detailed Audit of Quant?

Our AI-powered scanner gives you a deeper, real-time smart contract analysis — free, with every scoring factor shown.

Get Detailed Audit