ERC-20 vs ERC-721 vs ERC-1155: The Token Standard That Decides Your Gas Bill

The batch mint that made me read the contract ABI

Last spring an onchain art drop on Base let me choose a quantity. I picked forty editions, signed once, and paid about four cents. A friend minted forty items from a different drop the same week — forty separate signatures at roughly three cents each, over a dollar, plus forty chances to fat-finger a price or skip a step. Same chain, same gas conditions, wildly different bills. The difference was not timing or luck. His project shipped as ERC-721; mine was ERC-1155, and that design choice was priced into every transaction before either of us clicked mint.

I stopped treating "which standard" as trivia after that. On Base and Arbitrum the per-unit gas is tiny, but the gap between standards multiplies rather than adds: an ERC-1155 batch does in one signature what ERC-721 needs forty of. When you are minting, airdropping, or moving game items, the standard shapes your gas bill far more than the gwei number does. Gwei is the rate per unit of work; the standard decides how much work the operation is. The unit math lives in the gwei guide — what follows is the part the gwei number cannot explain.

What I did not understand back then is that the standard is a promise about a contract's interface, and your wallet, the marketplace, and the explorer all read that promise before the transaction is even built. The same "send" button produces wildly different receipts depending on what sits behind it. Seeing the interface underneath the button is most of the skill; the gas follows from it. My friend's painful week had nothing to do with his timing and everything to do with an ABI neither of us had ever opened.

ERC-20, ERC-721, ERC-1155: three answers to "what is a token"

All three are interfaces a smart contract promises to implement, so wallets and exchanges know how to talk to it. They differ in what they model.

• ERC-20 is a ledger of amounts. One contract, a balanceOf[address] map, and every unit is interchangeable. transfer(to, amount) moves value. USDC, USDT, and WETH are all ERC-20 — the $0.001-0.01 stablecoin sends covered in the USDC transfer cost breakdown.
• ERC-721 is a ledger of owners. Each token has a unique tokenId and a single ownerOf. One contract is one collection; safeTransferFrom(from, to, tokenId) moves one item at a time. This is the classic NFT.
• ERC-1155 is a ledger of balances keyed by id. A single contract holds many ids at once, each with its own supply. It can behave like fungible editions (id 1, supply 10,000) and unique items (id 7, supply 1) in the same deployment, and it exposes batch functions instead of one-at-a-time calls.

The mental shortcut: ERC-20 counts coins, ERC-721 counts unique items, ERC-1155 counts a shelf of different items under one roof.

A contract advertises which interface it supports through a small discovery function, ERC-165, so a wallet can ask "are you a 721 or a 1155?" instead of guessing from the ticker. That is how a marketplace decides whether to show a gallery or a balance, and it is what lets one 1155 contract present as both a collection and a currency at the same time. When an explorer stamps a standard label onto a token, it is echoing this answer — and when a wallet shows only a generic label instead, it simply has not asked the question.

Why one ERC-1155 batch beats forty ERC-721 transactions

Every Ethereum transaction pays a fixed cost before it does anything useful: a 21,000 gas base, the calldata to describe the call, and the validation that comes with it. Forty separate ERC-721 transfers pay those fixed costs forty times. ERC-1155's safeBatchTransferFrom(from, to, ids[], amounts[], data) pays them once and then loops through the ids inside a single call.

For each item inside the loop the contract still touches storage — the expensive part — but the marginal cost is a single balance update per id, roughly 20,000 gas the first time a slot goes from zero to non-zero and about 5,000 when it is overwritten. So batching does not make storage free; it removes the per-transaction scaffolding. Ten 1155 items in one call is far cheaper than ten separate 721 transfers, and the gap widens linearly with quantity. Minting works the same way through _mintBatch, which is why edition drops choose 1155 before they choose anything else. The broader menu of fee-reduction moves is in reducing gas fees on L2.

The saving is in the fixed scaffolding, not the storage. Forty separate 721 transfers also pay forty signature verifications, forty calldata payloads, and forty sets of event logs; a single 1155 batch pays those once and then loops cheaply through the ids. Storage updates still dominate each individual item, so batching is a constant-factor win rather than a magic one — but at forty items that constant is the entire difference between a dollar and four cents. It is also why you cannot batch across collections: forty 721 mints are forty contract interactions because each item lives in its own contract.

The gas units, side by side

These are the orders of magnitude I plan around on Base and Arbitrum. Costs swing with the token, the pool state, and whether the destination slot is fresh, but the ranking barely moves.

The full mint economics, including the storage-refund quirks of batch minting, are in the NFT minting cost guide.

Read that table by column rather than by row. The standard sets the shape of the cost; the chain sets the scale. On Base every row is a rounding error, so the ranking matters far more than the absolute number — a mint that would be a serious decision on mainnet is noise here. The batch row stays roughly flat as N grows while every per-item row multiplies by N, and that is the whole thesis of the standard: the same quantity of items, priced by architecture instead of by luck.

Approvals are three different things wearing one word

"Approve" means something different in each standard, and this is where most signing mistakes happen.

• ERC-20: an allowance. approve(spender, amount) lets one specific contract spend up to amount of that one token from your wallet. It is per-token, per-spender, and revocable by approving zero. The infinite-approval habit is why the approval fee guide exists.
• ERC-721: a choice of two. approve(spender, tokenId) grants one specific token; setApprovalForAll(operator, true) hands over your entire collection in that contract, current and future. The second is the powerful and dangerous one.
• ERC-1155: only the blanket form. Because ids are unbounded, there is no per-id approval — just setApprovalForAll for the whole contract. Signing it for a marketplace you do not trust is signing over every item you will ever hold there.

Blanket operator approvals are the single largest approval surface in NFT wallets, and they are free to clean up. The routine is in revoking token approvals on L2; I run it quarterly.

One more wrinkle worth knowing: ERC-20 permits (EIP-2612) let you approve and act in a single signature with no separate approval transaction, which is why some swaps show one popup and others show two. ERC-721 and ERC-1155 have no equivalent in their base interfaces, so the two-step approve-then-transfer flow is the norm there. Those operator grants never expire on their own, which is exactly why cleaning them up outlasts every other gas tip on this page.

Where each standard actually shows up on Base and Arbitrum

• ERC-20 rules DeFi. USDC, USDT, DAI, WETH, and every governance and LP token. If a protocol moves value, it is almost certainly 20s underneath. Wrapping native ETH into the ERC-20 form is its own topic — see WETH vs ETH on L2.
• ERC-721 is NFTs and, quietly, positions. Art, PFPs, and collectibles, but also Uniswap v3 liquidity positions, which are NFTs you can transfer or sell as a unit.
• ERC-1155 is editions, games, and anything multi-token. Open-edition drops, in-game currencies and items, tickets, and some marketplace listings. Anything a project expects you to hold in quantity inside one contract lands here.

On Base the mix skews consumer and gaming, so you meet 1155 more often than on mainnet. On Arbitrum you meet 20-heavy DeFi first. Knowing which one a dapp expects tells you roughly what a signature will cost before the wallet even quotes it.

The pattern I watch for: a project that calls itself an NFT collection but mints ERC-1155 usually intends for you to hold duplicates — editions, passes, or in-game consumables. That is a feature, not a warning sign. What would be a warning sign is a token imitating a famous ERC-20 while pointing at the wrong contract address, which is why address verification pays for itself regardless of standard or chain.

How to tell what you are signing before you sign

The wallet usually shows a generic "token" or "collectible" label, which is not enough. When I am about to spend real money, I open the token on the explorer and read the contract tab: the interface it implements lists ERC-20, ERC-721, or ERC-1155, and the token page shows whether it is an NFT collection or a fungible balance. That read takes fifteen seconds and has saved me from fake collections more than once. The explorer walkthrough is in the Basescan guide.

Two things to check while you are there: the number of holders and the transfer history. A "collection" with one holder and a single mint transaction is not a collection. A token whose transfers all bounce is a honeypot. Neither of those is a gas question, but both cost more than any gas mistake, and both are visible on the same screen.

The wallet's label is a heuristic; the contract is the fact. When the two disagree, believe the contract every time, because the label is the wallet's own guesswork while the interface list is the contract telling the truth about itself.

The rule I run before every mint and transfer

• Bulk activity (drops, airdrops, game items in quantity) — prefer the ERC-1155 project if both exist; the batched transaction wins by an order of magnitude on total cost.
• Never sign setApprovalForAll to a marketplace or contract I have not verified, and revoke the ones I stop using.
• For one-off ERC-20 spends, approve the exact amount rather than unlimited.
• Before signing, check the standard and the holder count on the explorer, not the wallet's generic label.
• Keep gas in native ETH — an ERC-20 or ERC-1155 balance, however large, will not pay for any of this.

Get the standard right and the gas question mostly answers itself. Get it wrong and no amount of gwei-watching makes up the difference — the forty-transaction tax is baked in the moment the contract was deployed.

None of these rules are about being clever or watching the market. They are about refusing to pay a forty-transaction tax for a design decision someone else made when they deployed the contract — and about keeping the approvals you hand out as narrow as each standard allows.