This token generation event checklist covers the security steps most TGE guides skip: commissioning and publishing your audit early, deciding mint and pause authority, separating deployer, admin, and treasury roles, documenting your multisig, rehearsing deployment on testnet, and running a verified launch day, using Truebit’s $26.44M overflow exploit and the Bybit blind-signing failure as lessons.

This token generation event checklist covers the security steps most TGE guides skip: commissioning and publishing your audit early, deciding mint and pause authority, separating deployer, admin, and treasury roles, documenting your multisig, rehearsing deployment on testnet, and running a verified launch day, using Truebit’s $26.44M overflow exploit and the Bybit blind-signing failure as lessons.
A token generation event checklist is incomplete if it only covers marketing timing, tokenomics design, and legal sign-off. The week before TGE, someone on your team still has to answer a narrower set of questions: who can call mint() right now, does the pause function survive launch day, and is the treasury multisig actually configured the way your documentation claims? This guide covers the operational, function-level security steps founders and developers need to execute before a token generation event, not the marketing or tokenomics prep that most TGE checklists already cover well.
A token generation event concentrates privilege, liquidity, and attention into a single week. Contracts that sat untouched in a testnet repo for months suddenly hold real treasury funds. Deployer wallets that nobody thought to retire still carry owner-level permissions. And the attack surface that mattered least during development, who can still act as admin, matters most the moment a token has a market price.
Truebit Protocol learned this the hard way. On January 8, 2026, an attacker drained roughly $26.44 million, 8,535.36 ETH, from the protocol by exploiting an integer overflow vulnerability in its token-purchase logic, a defect that existed because the price calculation function was compiled with Solidity ^0.6.10, a version that does not include overflow checks, according to KuCoin's incident writeup. The vulnerability was not exotic. It was the kind of defect a standard audit, and newer Solidity versions, are built to catch before a contract ever touches mainnet.
The same concentration of risk shows up on launch pads that skip the operational layer entirely. Solidus Labs examined liquidity pools on Raydium and found that approximately 93%, about 361,000 pools, exhibited soft rug pull characteristics, with a median rug pull value of about $2,832, per Solidus Labs' research. Most of those are small, but the pattern is the point: the gap between "we launched a token" and "we launched a token with no one able to quietly mint more of it or drain the treasury" is exactly the gap this checklist exists to close.
Here is the full pre-TGE technical checklist, ordered from earliest to latest in the launch timeline:
Each of these gets its own section below, with the reasoning and the failure modes that make it non-negotiable.
A token generation event checklist that treats the audit as "get it done at some point" skips the part that actually matters: timing and transparency. The audit needs to finish early enough that findings get fixed and re-verified, and the report needs to be public so holders are not asked to trust a launch on your word alone.
Can a TGE happen without an audit? Technically yes. Should it? Truebit's $26.44 million loss is a direct answer to that question: an integer overflow bug in outdated Solidity code drained the protocol, and in its aftermath, security analysts recommended the team conduct new security audits of its smart contracts, according to KuCoin's reporting on the incident. That recommendation reads differently before a hack than after one.
Commission the audit with enough runway to fix what it finds, not just read the report. A pre-TGE checklist published by EchoTrade states plainly that a reputable audit from a recognized firm must be completed, with critical findings resolved, and the final report made publicly available before TGE, not after launch, per EchoTrade's token launch checklist. In practice, that means starting the engagement four to six weeks out: one to two weeks for the review itself, one to two weeks to remediate findings, and time for the auditor to re-verify fixes before the report goes public. If your team is not sure its codebase is even ready for that engagement, a smart contract audit readiness checklist is worth working through first.
A report that just says "no critical issues found" is not useful to a holder trying to evaluate your launch. The published audit should state:
A Smart Contract Audit from QuillAudits covers exactly this surface, checking whether mint is capped or owner-controlled and who holds pause, blacklist, or freeze privileges on the contract. It is one option among the firms a team can commission for this step, and the choice of which firm matters less than making sure the engagement happens early and the result gets published.
What is mint authority in a token contract, and should it be revoked before TGE? Mint authority is the permission to create new tokens after deployment. Whoever or whatever holds it can expand supply at will, which is why an unrevoked, unchecked mint function is one of the clearest signals a launch is unsafe.
What happens if mint authority isn't revoked before TGE? The contract keeps a live door for someone, a founder, a compromised key, or a malicious insider, to inflate supply after the market has already priced the token. That is the exact rug-pull pattern QuillAudits flags as one of the most common findings in ERC-20 audits: an uncapped mint function controlled by a single privileged account, per QuillAudits' ERC-20 audit guide.
Before TGE, pick one of three end states for mint authority, and have your audit confirm it on-chain, not just in your documentation:
What a TGE checklist should never allow through is the default state most contracts ship with during development: an EOA, externally owned account, with unrestricted mint access and no public statement about what happens to that access after launch.
Should a token keep a pause function after launch? It depends on what the pause function protects. A pause that halts transfers during an active exploit can limit damage while a team responds. The same pause, left under a single key's control, is also a centralization risk that undermines the "decentralized launch" claim many projects make.
The middle ground most mature projects land on: keep the pause function, but gate it behind the same multisig and timelock that governs mint, and publish the exact conditions under which the team would use it (an active exploit, a critical bug, a confirmed oracle failure). A pause function nobody can explain the purpose of is a pause function a holder is right to be suspicious of.
A contract's deployer wallet often keeps lingering admin rights long after deployment is done, simply because nobody revoked them. That is a well-documented failure mode: a deployer key that still holds owner-level privileges is a single point of compromise for the entire protocol, as covered in QuillAudits' analysis of deployer wallet attack vectors.
Before TGE, your team should be able to answer, role by role:
| Role | Who holds it | What it controls | Should it be a multisig? |
|---|---|---|---|
| Deployer | Should be retired post-deploy | Initial contract setup | N/A once retired |
| Admin/Owner | Protocol team | Pause, upgrade, parameter changes | Yes |
| Treasury | Protocol team + advisors | Fund custody, disbursement | Yes |
| Mint authority | Contract logic or multisig | Supply issuance | Yes, if not renounced |
If any of these rows still maps to a single individual's hot wallet, that is a finding, not a formality. An Admin Audit is built specifically to review this layer: a standard smart contract audit covers the on-chain code, but as QuillAudits puts it, "the other 70% is the operational layer that goes completely unexamined unless you specifically commission an admin/opsec audit," including multisig architecture, governance thresholds, timelocks, and role-based access.
Should treasury wallets use a multisig before TGE? Yes, without exception. Pre-TGE treasury governance guidance from Toku recommends multi-signature requirements on every treasury transaction specifically so that no single individual retains unilateral control over funds, according to Toku's pre-TGE readiness resource.
A multisig is only as strong as its configuration and the discipline of its signers. QuillAudits puts the test plainly: "could one compromise reach quorum on its own. If yes, the threshold is decorative," as stated in its guide to multisig security habits that actually matter. A 2-of-3 multisig where two signers share a laptop, or where two keys live in the same cloud backup, is not meaningfully safer than a single key.
Document, before TGE, not after an incident:
QuillAudits' Multisig Inspector tool gives founders a way to check a treasury Safe's configuration against this documentation step directly, though it does not replace writing the policy down and training every signer on it.
The clearest cautionary tale for why signer process matters as much as signer count is the Bybit incident, where attackers manipulated what multisig signers saw on their screens, getting legitimate signers to approve a malicious transaction without realizing what they were authorizing. The QuillAudits writeup on the Bybit hack covers the mechanics in more detail, but the operational takeaway for a pre-TGE team is simple: a signer who approves whatever their signing interface displays, without independently verifying the transaction's actual destination and calldata, is not providing real security no matter how many signatures the multisig requires.
Blind signing is the gap a documented treasury process has to close. If your signers cannot describe, in their own words, what a pending transaction does before they sign it, your multisig threshold is theater.
The single most valuable hour a founding team can spend before TGE is a full dry run of the exact deployment sequence planned for mainnet, run on a testnet or a mainnet fork, with every privileged action exercised in order.
A testnet rehearsal is not a generic "does the contract compile" check. It is a scripted walkthrough of the specific actions your team expects to take during and immediately after TGE:
Static analysis and fuzzing tools are useful here precisely because they catch the edge cases a manual rehearsal will not. Tools like Slither for static analysis, Echidna for property-based fuzzing, and the Foundry testing framework are commonly used for this kind of pre-launch verification, and QuillAudits' guide to smart contract security tools walks through how each fits into a pre-deployment workflow. Run them against the exact bytecode you intend to deploy, not an earlier draft.
A rollback plan is the document nobody wants to write because it assumes something will go wrong. Write it anyway. At minimum, it should answer:
If your tokenomics include vesting schedules or lockups as part of the TGE, those contracts carry their own release-logic risks that sit outside this checklist's scope; QuillAudits' token vesting and lockup contract audit guide covers what a vesting-specific review should check.
On the day itself, every privileged action should have a named owner and a second person confirming it before execution, not after. A practical launch-day sequence looks like this:
A broader pre-launch security review that goes beyond TGE week specifically, covering infrastructure, front-end, and operational security, is covered in QuillAudits' general web3 security checklist, worth working through earlier in the project timeline alongside this one. QuillAudits also maintains a research hub tracking audit findings and security patterns across live protocols, useful background reading while building out your own launch-day runbook.
Most token generation event checklists stop at tokenomics design and legal review, and leave the function-level questions, who can mint, who can pause, who holds the treasury keys, undocumented until something goes wrong. The teams that get through TGE week cleanly are the ones who treat mint authority, role separation, and multisig configuration as launch-blocking items, not afterthoughts, and who rehearse the deploy sequence on testnet before touching mainnet. A combination of a Smart Contract Audit and an Admin Audit covers both layers, the code and the operational permissions around it, for a team working through this list before launch.
Contents

From day-zero risk mapping to exchange-ready audits, QuillAudits helps projects grow with confidence. Smart contracts, dApps, infrastructure, compliance: secured end to end.