Token Standards Cheat Sheet
Quick reference for the token standards developers meet most often across EVM and Solana. Use this as a reminder for interfaces, events, and common edge cases, not as a full implementation guide.
ERC-20
ERC-20 is the common standard for fungible EVM tokens. Each unit is interchangeable with any other unit of the same token, like USDC, DAI, or UNI.
type Address = `0x${string}`;
function totalSupply(): Promise<bigint>;
function balanceOf(account: Address): Promise<bigint>;
function transfer(to: Address, value: bigint): Promise<boolean>;
function allowance(owner: Address, spender: Address): Promise<bigint>;
function approve(spender: Address, value: bigint): Promise<boolean>;
function transferFrom(
from: Address,
to: Address,
value: bigint,
): Promise<boolean>;
Events:
type Transfer = { from: Address; to: Address; value: bigint };
type Approval = { owner: Address; spender: Address; value: bigint };
Common patterns:
approveplustransferFromlets another account or contract spend tokens.- Infinite approval uses
2n ** 256n - 1nto avoid repeated approvals. - Permit (EIP-2612) lets a user approve by signature instead of a transaction.
Gotchas:
- Some older tokens, especially USDT-style implementations, do not consistently
return
booleven when the ERC-20 interface says they should. - Fee-on-transfer tokens may deliver less than
value, so protocols should compare balances before and after the transfer when exact receipt matters.
ERC-721
ERC-721 is the common EVM NFT standard. Every token ID is unique, and ownership
is tracked per tokenId.
type Address = `0x${string}`;
function balanceOf(owner: Address): Promise<bigint>;
function ownerOf(tokenId: bigint): Promise<Address>;
function safeTransferFrom(
from: Address,
to: Address,
tokenId: bigint,
): Promise<void>;
function transferFrom(
from: Address,
to: Address,
tokenId: bigint,
): Promise<void>;
function approve(to: Address, tokenId: bigint): Promise<void>;
function getApproved(tokenId: bigint): Promise<Address>;
function setApprovalForAll(operator: Address, approved: boolean): Promise<void>;
function isApprovedForAll(owner: Address, operator: Address): Promise<boolean>;
function tokenURI(tokenId: bigint): Promise<string>;
Events:
type Transfer = { from: Address; to: Address; tokenId: bigint };
type Approval = { owner: Address; approved: Address; tokenId: bigint };
type ApprovalForAll = {
owner: Address;
operator: Address;
approved: boolean;
};
Common patterns:
tokenURI(tokenId)points to metadata for images, traits, and descriptions.setApprovalForAllis the marketplace pattern for listing many NFTs.- Enumeration (
totalSupply,tokenByIndex,tokenOfOwnerByIndex) is an optional extension, not part of the core interface.
Gotchas:
- Prefer
safeTransferFromwhen sending to contracts, because receiver contracts must implement the ERC-721 receiver hook. - Do not assume token IDs are sequential or enumerable unless the contract explicitly implements the enumeration extension.
ERC-1155
ERC-1155 is a multi-token EVM standard. One contract can hold many token IDs, and each ID can behave like a fungible token, an NFT, or a semi-fungible asset.
type Address = `0x${string}`;
type Hex = `0x${string}`;
function balanceOf(account: Address, id: bigint): Promise<bigint>;
function balanceOfBatch(accounts: Address[], ids: bigint[]): Promise<bigint[]>;
function setApprovalForAll(operator: Address, approved: boolean): Promise<void>;
function isApprovedForAll(
account: Address,
operator: Address,
): Promise<boolean>;
function safeTransferFrom(
from: Address,
to: Address,
id: bigint,
value: bigint,
data: Hex,
): Promise<void>;
function safeBatchTransferFrom(
from: Address,
to: Address,
ids: bigint[],
values: bigint[],
data: Hex,
): Promise<void>;
function uri(id: bigint): Promise<string>;
Events:
type TransferSingle = {
operator: Address;
from: Address;
to: Address;
id: bigint;
value: bigint;
};
type TransferBatch = {
operator: Address;
from: Address;
to: Address;
ids: bigint[];
values: bigint[];
};
type ApprovalForAll = {
account: Address;
operator: Address;
approved: boolean;
};
type URI = { value: string; id: bigint };
Common patterns:
- Choose ERC-1155 over ERC-721 when one contract needs many asset types.
- Use batch transfers for game items, editions, and multi-asset inventory moves.
- Metadata URIs often use
{id}substitution instead of one URI per token.
Gotchas:
idsandvaluesarrays must align by index in batch calls.- Receiver contracts need ERC-1155 receiver hooks, or safe transfers to them should revert.
SPL Token (Solana)
SPL Token is Solana's standard token program. A mint defines the asset, and token accounts hold balances for owners. Associated token accounts (ATAs) are the usual wallet-owned token account addresses.
use solana_program::{
instruction::Instruction,
program_error::ProgramError,
pubkey::Pubkey,
};
fn initialize_mint(
token_program_id: &Pubkey,
mint: &Pubkey,
mint_authority: &Pubkey,
freeze_authority: Option<&Pubkey>,
decimals: u8,
) -> Result<Instruction, ProgramError>;
fn transfer_checked(
token_program_id: &Pubkey,
source: &Pubkey,
mint: &Pubkey,
destination: &Pubkey,
authority: &Pubkey,
signer_pubkeys: &[&Pubkey],
amount: u64,
decimals: u8,
) -> Result<Instruction, ProgramError>;
fn approve_checked(
token_program_id: &Pubkey,
source: &Pubkey,
mint: &Pubkey,
delegate: &Pubkey,
owner: &Pubkey,
signer_pubkeys: &[&Pubkey],
amount: u64,
decimals: u8,
) -> Result<Instruction, ProgramError>;
fn mint_to_checked(
token_program_id: &Pubkey,
mint: &Pubkey,
account: &Pubkey,
mint_authority: &Pubkey,
signer_pubkeys: &[&Pubkey],
amount: u64,
decimals: u8,
) -> Result<Instruction, ProgramError>;
Common accounts and authorities:
- Mint account: stores decimals, supply, mint authority, and freeze authority.
- Token account: stores owner, mint, amount, delegate, and close authority.
- Associated token account: deterministic token account for
(wallet, mint). - Delegate: approved spender for part of a token account balance.
Common patterns:
- Create or fetch the recipient ATA before transferring SPL tokens.
- Use checked instructions when the client knows the mint decimals.
- Revoke mint authority when a fixed supply should become permanent.
Gotchas:
amountis the raw base-unit integer. UI amounts must be scaled by10 ** decimals.- A wallet does not hold SPL balances directly; balances live in token accounts, commonly ATAs.