Mint a real token in one transaction you can read before you sign it
This is not a simulator and it is not a waitlist. The form below builds an SPL mint transaction in your browser, hands it to your wallet, and broadcasts it. It defaults to devnet, where the SOL is free and a mistake costs nothing — switch the cluster in the wallet menu when you actually mean it. You keep the mint authority, and therefore the ability to inflate the supply at will, unless you tick the box that destroys it in the same transaction.
The instruction encoding is the reason this page belongs on a Dogecoin fork's website. Doge Inu Core parses the same SPL instruction layout inside OP_SPLMINT, so the bytes your wallet signs here are the bytes the asset plane will accept when the native mint path opens. Launching on Solana today is the rehearsal, not a detour.
Launcher
Fill in four fields. The panel on the right regenerates the exact transaction body as you type, so there is no gap between what the page claims it will send and what it sends.
These become an SPL mint on devnet. Change the cluster in the wallet menu.
What wallets show next to the balance.
9 matches SOL. 6 matches most stablecoins.
Minted to your wallet in one instruction. = 1000000000000000000 base units
const mint = Keypair.generate();
const tx = new Transaction().add(
// 1. Allocate the mint account and pay its rent exemption.
SystemProgram.createAccount({
fromPubkey: owner,
newAccountPubkey: mint.publicKey,
space: MINT_SIZE,
lamports: await getMinimumBalanceForRentExemptMint(conn),
programId: TOKEN_PROGRAM_ID,
}),
// 2. Initialise it. You are both mint and freeze authority.
createInitializeMint2Instruction(mint.publicKey, 9, owner, owner),
// 3. Derive and create your associated token account.
createAssociatedTokenAccountInstruction(owner, ata, owner, mint.publicKey),
// 4. Mint the whole supply into it.
createMintToInstruction(mint.publicKey, ata, owner, 1000000000000000000n),
// 5. Hand the mint authority to nobody. Irreversible.
createSetAuthorityInstruction(mint.publicKey, owner, AuthorityType.MintTokens, null),
);
// The mint keypair signs for its own creation. Your wallet signs the rest,
// so there is never a moment where a private key of yours leaves the wallet.
tx.partialSign(mint);
const signed = await wallet.signTransaction(tx);
await conn.sendRawTransaction(signed.serialize());Your wallet will show five instructions. If it shows anything else — a transfer out, an approval, a program you do not recognise — reject it. That advice applies to this page as much as any other.
The five instructions
A token launch is not one operation. It is five, batched into a single transaction so that either all of them land or none of them do. Atomicity matters here more than it looks: a mint that exists but was never initialised is a permanently stuck account, and a mint initialised without a destination account is a supply you cannot hold.
SystemProgram.createAccountInitializeMint2CreateAssociatedTokenAccountMintToSetAuthority(MintTokens, None)| # | instruction | bytes | CU | accounts | writes |
|---|---|---|---|---|---|
| 1 | SystemProgram::CreateAccount | 52 | 3,000 | 2 | new mint account |
| 2 | Token::InitializeMint2 | 67 | 2,847 | 1 | mint header |
| 3 | AssociatedToken::Create | 34 | 20,096 | 6 | token account |
| 4 | Token::MintTo | 41 | 4,492 | 3 | mint supply, balance |
| 5 | Token::SetAuthority | 38 | 2,910 | 2 | mint authority → null |
| — | transaction total | 398 | 33,345 | 11 | 2 signatures |
33,345 CU against a 200,000 CU default budget, so there is no need to request extra compute and no reason for the transaction to be dropped for exceeding it. The 1,232-byte packet limit is the tighter constraint in general, and at 398 bytes this transaction is nowhere near it.
Almost all of the cost is a deposit, not a fee
A launch looks like it costs about half a dollar. Roughly 99.7% of that is rent exemption — a refundable deposit held against two accounts so that the validator set is not storing your data for free forever. The part that is genuinely spent is two signatures at 5,000 lamports each.
Close the token account when it is empty and the 0.00203928 ◎ comes back. The mint account's 0.00144768 ◎ comes back too, but only once supply is zero, which for a token with holders means never. Treat it as the cost of existing.
Priority fees are zero in the table because the launcher does not add a compute-unit price. On a quiet cluster that is correct. During a congestion event a launch can sit for several slots; the honest fix is to retry rather than to overpay, because a mint is not time-sensitive the way a swap is.
Devnet figures are identical — rent is a protocol constant, not a market — but the SOL is free from the faucet. See the Doge Inu fee schedule for what the equivalent operation costs on the fork's own asset plane.
| line item | ◎ SOL | USD | refundable |
|---|---|---|---|
| Mint account rent (82 B) | 0.00144768 | $0.2146 | at zero supply |
| Token account rent (165 B) | 0.00203928 | $0.3022 | yes |
| Base fee · 2 signatures | 0.00001000 | $0.0015 | no |
| Priority fee (0 µ◎/CU) | 0.00000000 | $0.0000 | no |
| Total signed | 0.00349696 | $0.5183 | 99.7% deposit |
| Unrecoverable, worst case | 0.00145768 | $0.2161 | — |
The launcher refuses to build the transaction below 0.01 ◎, which is roughly three times the requirement. A launch that fails at the rent instruction has still burned your signature fee and produced nothing, so the check is worth the friction.
The same launch from a terminal
Nothing on this page is privileged. If you would rather not trust a web form with a transaction builder — a defensible position — dogeinu-cli produces a byte-identical mint against the fork's asset plane, and spl-token does the Solana half. Both are shown so you can diff the result against what the page produced.
# Solana side: the exact transaction this page builds, one instruction per line.
$ solana config set --url devnet
$ spl-token create-token --decimals 9 --enable-metadata
Creating token 7RmQhVnGwcYbT2fXpLkD9sAeZ4uJ1hN6vB3yCqM8dKtW
$ spl-token create-account 7RmQhVnGwcYbT2fXpLkD9sAeZ4uJ1hN6vB3yCqM8dKtW
$ spl-token mint 7RmQhVnGwcYbT2fXpLkD9sAeZ4uJ1hN6vB3yCqM8dKtW 1000000000
# The instruction that actually makes the supply claim credible.
$ spl-token authorize 7RmQhVnGwcYbT2fXpLkD9sAeZ4uJ1hN6vB3yCqM8dKtW mint --disable
Updating 7RmQhVnGwcYbT2fXpLkD9sAeZ4uJ1hN6vB3yCqM8dKtW
Current mint: 4FhTnPqW2xDvLm9cZsJbK6yUe1gR8aVoQ3tNwXr5HdBj
New mint: disabled
# Doge Inu side: one call, because the node batches the five for you.
$ dogeinu-cli createsplmint '{"decimals":9,"supply":1000000000,"name":"Doge Inu","symbol":"DINU","revokemint":true}'
{
"mint": "9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PB5wBQZ",
"txid": "4b1f8ca07d2e5390bb6c1d47ae9f0328c5d71a6be4028f9317cd5ba2e6740f19",
"rent": 1.00000000,
"fee": 0.00730800,
"mintauthority": null
}After either route, verify rather than believe. The two fields that matter are mintAuthority and supply; everything else is decoration. A mint whose authority is null cannot grow, and that is a property of the ledger rather than a promise made on a website.
$ MINT=7RmQhVnGwcYbT2fXpLkD9sAeZ4uJ1hN6vB3yCqM8dKtW
$ spl-token display $MINT
SPL Token Mint
Address: 7RmQhVnGwcYbT2fXpLkD9sAeZ4uJ1hN6vB3yCqM8dKtW
Program: TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA
Decimals: 9
Supply: 1000000000000000000
Mint authority: (not set)
Freeze authority: 4FhTnPqW2xDvLm9cZsJbK6yUe1gR8aVoQ3tNwXr5HdBj
# The raw account, for anyone who does not trust the pretty printer.
$ solana account $MINT --output json | jq -r '.account.data[0]' | base64 -d | xxd -l 82
00000000: 0100 0000 4fh1 ... 0000 0000 0000 0000 ....O...........
$ spl-token supply $MINT
1000000000
# Largest holders. A single account holding 100% is not a bug, but it is a fact.
$ spl-token accounts --owner $MINT 2>/dev/null; spl-token display $MINT --output json \
| jq '{supply, mintAuthority, freezeAuthority}'
{
"supply": "1000000000000000000",
"mintAuthority": null,
"freezeAuthority": "4FhTnPqW2xDvLm9cZsJbK6yUe1gR8aVoQ3tNwXr5HdBj"
}Revoking the mint authority stops inflation. It does not stop you freezing individual token accounts, which prevents a holder from selling. If you intend the token to be genuinely unowned, run spl-token authorize $MINT freeze --disable as a second transaction. The launcher does not do this for you, because a freeze authority is occasionally legitimate and silently destroying it would be a surprise.
A mint is not a market
At the end of the transaction you own a token that exists and has no price, because nothing has ever traded. Everything that makes a token feel real — a chart, a ticker on an aggregator, someone else holding it — happens afterwards and none of it is automatic.
Liquidity
A price comes from a pool. You deposit some of your supply and some SOL into an AMM, and the ratio you choose is the opening price — there is no discovery mechanism, just your arithmetic. Depositing 10% of supply against 5 ◎ sets a fully diluted valuation of 50 ◎ and hands the other 90% of the supply an exit against your own liquidity.
The pool issues you LP tokens representing your share. Holding them means you can withdraw the SOL at any moment, which is the mechanism behind most of the losses people describe as rug pulls. Burning them, or locking them in a time-locked program, is the only way to make the liquidity a commitment rather than an intention.
Metadata
The mint account stores decimals and authorities. It does not store your name, symbol, or image — those live in a separate metadata account keyed to the mint. Until you create one, wallets will display your token as an unlabelled address and every aggregator will ignore it. The launcher writes the name and symbol you typed into the transaction it displays, but the on-chain metadata account is a separate step.
Listings
Aggregators index automatically once a pool crosses their liquidity threshold, which is usually a few hundred dollars of depth and a handful of distinct trades. Nobody needs to be emailed. Anyone who offers to fast-track a listing for a fee is describing a service that does not exist.
| step | cost ◎ | reversible |
|---|---|---|
| Mint created, supply in your wallet | 0.00350 | yes |
| Create the metadata account | 0.01100 | yes |
| Revoke the mint authority | 0.00001 | never |
| Revoke the freeze authority | 0.00001 | never |
| Open an AMM pool | 0.15400 | yes |
| Burn or lock the LP tokens | 0.00001 | never |
| Aggregator picks it up | 0.00000 | — |
Revoke before you open the pool, not after. A buyer who arrives in the first minutes cannot audit a decision you have not made yet, and “we will revoke soon” has no on-chain representation at all.
How this gets used to take money
The launcher is a neutral tool and the failure modes are well documented, so here they are. Every one of them is visible on-chain before it happens, which is the only reason writing them down is useful.
| mechanism | what the attacker keeps | what you can check first | prevented by |
|---|---|---|---|
| Mint dilution | Mint authority | mintAuthority is not null | revoke mint |
| Liquidity withdrawal | LP tokens | LP supply is not burned or locked | burn LP |
| Selective freeze | Freeze authority | freezeAuthority is not null | revoke freeze |
| Concentrated supply dump | 90%+ of supply in one account | top-holder distribution | nothing technical |
| Impersonation of a real token | Buyers who matched on the symbol | mint address, not the ticker | nothing technical |
| Transfer-hook tax | A cut of every trade | token program is the classic one | program ID check |
While you hold the mint authority, every statement about your token's supply is a statement about your intentions. One instruction, 2,910 compute units, costs a fraction of a cent, and a holder can verify it at any time without asking you anything. If you keep it, say so and say why. The failure mode is not people minting more tokens — it is people announcing a fixed supply while holding the key that changes it, and then changing it after the pool has real money in it.
The symmetrical warning, because it would be dishonest to only warn the launcher: a revoked mint authority tells you the supply is fixed and nothing else. It says nothing about who holds that supply, whether the liquidity can be pulled, or whether the token is worth anything. Fixed supply and worthless are entirely compatible.
What this page does not do
OP_SPLMINT path parses today.dogeinud is still an RPC call from a terminal. Mainnet launches on the fork go through the CLI shown above. This is the honest state of it, not a roadmap claim.If you want the consensus-level story of how an asset commitment becomes spendable, the protocol docs cover the widened CTxOut, the opcode semantics, and the validator's voting path. If you want to know what any of it costs on the fork itself, the fee schedule has the per-operation table.