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

Is B Safe? B

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

Contract 0x6bdc…4444 DexScreener ↗
Volume 24h
$1.18M
Liquidity
$2.37M
Price
$0.1953
Token Age
1y
Top 10 Holders
10.9%

Security Checklist

Contract VerifiedPass
Ownership RenouncedPass
No Mint FunctionPass
Liquidity LockedPass
Not a ProxyPass

Audit History

Jul 230

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

Audit Summary

The FourERC20 contract implements a standard ERC-20 token, largely based on OpenZeppelin Contracts v4.9.4. The provided code snippet is truncated, specifically for the core `_transfer` function, which limits a full security assessment of the token's fundamental transfer logic. The contract is simple, lacking complex economic models, governance, or upgradeability features, which inherently reduces certain risk vectors. Key areas of review included architecture, code security, and access control, with a notable limitation due to incomplete source code.

Final Recommendation: It is strongly recommended to provide the complete source code for all contracts, especially core logic like `_transfer`, to enable a comprehensive security audit. If this token is intended to be part of a larger system or to have additional features (e.g., minting, burning, pausing, access control), those functionalities should be implemented in derived contracts and undergo a separate, thorough security review. Ensure that the `_init` function is correctly called in the constructor of the deployed contract to set the token's name and symbol as intended.

Category Ratings

TechnicalLow
10/10

The contract leverages OpenZeppelin's battle-tested ERC-20 implementation, which provides a strong foundation for code security (7.2 Code Security). Standard functions like `transfer`, `approve`, and `transferFrom` are present, and the `decreaseAllowance` function correctly uses an `unchecked`

GovernanceLow
10/10

The FourERC20 token is a straightforward ERC-20 implementation without any complex economic models, staking mechanisms, or fee structures (7.4 Economic). This simplicity inherently reduces economic attack vectors. There are no explicit governance mechanisms (7.5 Governance) built into this base cont

UpgradesLow
10/10

The FourERC20 contract is not designed with any upgradeability patterns (e.g., UUPS, Transparent, Beacon proxies) (7.7 Upgrades). This means the contract is immutable once deployed, eliminating risks associated with upgrade logic, proxy administration, or storage collisions. Any future changes would

LP Distribution

LP Burned100.0% · ≈ permanent lock
LP Locked100.0% · Null Address

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

1 Low 2 Info
L-01LowUnresolved

Incomplete Source Code for Core Logic

The provided source code for the `FourERC20.sol` contract is truncated, specifically within the `_transfer` internal function. This prevents a full and definitive security assessment of the token's fundamental transfer mechanism, including checks for zero addresses, sufficient balances, and event emissions (7.2 Code Security). While the contract is based on OpenZeppelin, which implies robust implementations, the absence of the complete code means these critical internal operations could not be fully verified.

Recommendation: Provide the complete and untruncated source code for all contracts, especially for core internal functions like `_transfer`, `_mint`, and `_burn`, to allow for a comprehensive security audit and verification of all logic and checks.
I-01InformationalUnresolved

Missing Public Mint/Burn Functionality

The `FourERC20` contract, as a base ERC-20 implementation, does not expose public `_mint` or `_burn` functions. This means that the token's total supply (`_totalSupply`) is fixed at deployment and can only be modified by the internal `_transfer` function, or if a derived contract implements and exposes minting/burning capabilities (7.4 Economic). This is a design choice and not a vulnerability, but it's important for understanding the token's supply dynamics.

Recommendation: If a variable token supply is desired, ensure that any derived contract implementing minting or burning functions includes appropriate access control (e.g., `Ownable`, `AccessControl`) and limits on who can call these functions and under what conditions. Clearly document the token's supply mechanism.
I-02InformationalUnresolved

Internal `_init` Function Requires Constructor Call

The `_init(string memory name_, string memory symbol_)` function, responsible for setting the token's name and symbol, is declared as `internal`. This means it must be explicitly called within the constructor of the `FourERC20` contract itself or a contract that inherits from it (7.1 Architecture). If `FourERC20` is deployed directly without a constructor calling `_init`, the `name()` and `symbol()` functions will return empty strings, potentially leading to issues with token display and integration in wallets or exchanges.

Recommendation: Ensure that the `_init` function is called in the constructor of the contract that is deployed to set the desired token name and symbol. For example: `constructor() { _init("MyToken", "MTK"); }`

Would You Like a More Detailed Audit of B?

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

Get Detailed Audit
Run Free Audit →