Auditing sounds like a job for senior engineers with years of experience. Some of it is. But most of the damage in small contracts does not come from exotic vulnerabilities. It comes from a short list of patterns that anyone can learn to spot in an afternoon.
I am not a senior auditor. I am a researcher learning audit from zero — Ethernaut, public audit reports, and a lot of contracts read by hand. This is the checklist I actually use when I open a contract I have never seen before. It will not make you an auditor. It will keep you from being exit liquidity.
The Tools (All Free)
You do not need a paid toolkit to do this:
- BscScan or Etherscan. The Contract tab shows the source (if verified) and the Read Contract tab lets you call view functions without writing code.
- A text editor. Open the source in VS Code or even a plain editor. You will be searching, not reading top to bottom.
- Slither. A free static analyzer by Trail of Bits. Run it on a contract and it flags common issues in seconds. It does not replace reading, but it is a good second pair of eyes.
- A testnet mindset. Never test a suspicious contract with real money. If you must interact with it, use a tiny amount you can afford to lose, or better, do not interact at all.
The Checklist
1. Is the source verified?
If the contract is not verified, you cannot read it, and this checklist stops here. Unverified source on a contract that holds your money is not a yellow flag. It is a closed door. Everything below assumes you can read the code.
2. Who is the owner, and what can they do?
Search the source for onlyOwner. Every function with that modifier is something one address can do unilaterally. Make a list of them. The dangerous ones are:
function mint(address to, uint256 amount) external onlyOwner function pause() external onlyOwner function blacklist(address account) external onlyOwner function setFee(uint256 newFee) external onlyOwner Then check owner() itself. Is it a single externally owned account, a multisig, or the zero address (renounced)? A single EOA holding mint, pause, blacklist, and fee powers is the highest-risk setup you will see. It does not prove the project is a scam — but it means one compromised or dishonest key ends the project.
3. Can the supply inflate?
Find the mint function and read it carefully. Is there a cap? Who can call it? Is there a timelock or a multisig in front of it? Unlimited minting by a single owner means your tokens can be diluted to nothing overnight.
Burn functions are usually fine — burning reduces supply. But check whether burning is something the owner can do to your tokens, rather than their own. A burnFrom without proper allowance checks is a way to destroy other people's balances.
4. Can transfers be frozen?
Look for pause() and any transfer restrictions. A pausable token can be frozen by the owner, which means you cannot sell when you need to. Legitimate projects use pausing as an emergency brake, and it is documented when they do. Undocumented pause powers on a meme token are a different story.
Also watch for maxTxAmount or maxWalletAmount limits. These are sometimes anti-whale measures, which is fine, but check whether the owner can change the limits or exempt themselves. A limit that applies to everyone except the owner is not an anti-whale measure.
5. Can the owner block sellers?
This is the honeypot pattern, and it is the one that hurts the most people. The owner blacklists wallets, or the transfer function silently reverts for everyone except approved addresses. You can buy. You can never sell.
Signs to look for: a blacklist mapping checked inside _transfer, an isExcludedFromFees list that doubles as a sell whitelist, or a transfer function that only succeeds when the sender is the owner or a router. If you cannot see a clear path for an ordinary holder to sell, assume there is not one. There are also free honeypot checkers that simulate a sell for you — use one before you buy, not after.
6. Are the fees honest?
Find the fee logic and read the actual numbers. A transfer tax of 5% is normal for some tokens. A tax that the owner can raise to 99% is a trap: the owner waits for the price to rise, raises the tax, and every sell becomes a donation to the contract.
Check three things: the current fee, the maximum fee the owner can set, and whether fees go to a wallet the owner controls. If the fee has no upper bound in the code, the owner can set it to anything.
7. Is it a proxy?
Search for Proxy, upgradeTo, or delegatecall. If the contract is an upgradeable proxy, the logic contract behind it can be swapped. That means the code you just read can be replaced with different code tomorrow, and your checklist becomes worthless.
Proxies are not inherently bad — many serious projects use them. But you need to audit the implementation contract too, and check who controls the upgrades. If a single EOA can upgrade the implementation, the whole contract is effectively that person's code, whatever it says today.
8. Does it call untrusted contracts?
Look for external calls, especially call with arbitrary data, and check whether state is updated before or after the call. The classic reentrancy pattern is a function that sends funds and only updates the balance afterwards:
// Dangerous pattern: external call before state update (bool success, ) = msg.sender.call{value: amount}(""); balances[msg.sender] = 0; The safe order is check, update state, then interact. If you see a contract sending value before updating its own records, that is a real vulnerability, not a style issue. In practice, most small token contracts do not have this problem — but any contract with a withdraw or claim function deserves this check.
9. Are the important actions visible?
Good contracts emit events for minting, ownership changes, fee changes, and pauses. Events are how the outside world — including you, watching on a block explorer — knows what happened. A contract that changes fees, mints tokens, or transfers ownership in silence is hiding its tracks. Silence is not proof of theft, but it is a reason to be suspicious.
10. Does anything look deliberately confusing?
Finally, trust your eyes. Variable names designed to mislead (_taxFee that is actually 90%), functions with innocent names that do something else, huge files where the dangerous function is buried at the bottom, or code copied from a known template with one quiet change. Obfuscation is not a vulnerability by itself, but honest code does not need to hide.
What to Do With What You Find
A single red flag does not always mean "scam." A pausable token from a team with a public multisig and a documented emergency policy is a different thing from a pausable token deployed by an anonymous wallet yesterday. Context matters, and so does stacking: one flag is a question, three flags are a pattern, and five flags are an answer.
When you find something, write it down — even if only for yourself. Note the function name, the line, and what it allows. That habit is the difference between "this feels wrong" and "the owner can mint unlimited tokens and blacklist sellers," and the second version is the one that keeps your money safe.
I am still early in this path. The checklist above is a beginner's tool, and it will miss things a professional audit would catch. But it catches the patterns that actually hurt people in the token and NFT mints I check every week, and that is a good place to start.
by Regi Ramadhani is an on-chain researcher focused on BSC tokens and NFTs. He writes about token verification, smart contract red flags, and the practical side of hunting free mints.
