This article is part of a structured DeFi learning series.

In the previous articles, we learned:

• What DeFi is (First One)
• How wallets work
• How blockchain transactions and gas function

Now we answer an essential question:

What exactly are you interacting with when you use DeFi?

Because before you swap, lend, stake, or earn yield: you are interacting with tokens.
And most beginners misunderstand what tokens really are.

Why This Matters

Almost everything in DeFi runs on tokens.

When you:

• Swap (exchange one token for another through a DEX smart contract)
• Provide liquidity (deposit tokens into a liquidity pool smart contract to enable trading and earn fees)
• Lend (supply tokens to a lending protocol smart contract to earn interest)
• Borrow (take tokens from a lending protocol smart contract by locking collateral)
• Stake (lock tokens in a staking smart contract to support a mechanism and potentially earn rewards)

You are not moving “coins in your wallet.”

You are interacting with smart contracts that update state inside token contracts.

If you misunderstand tokens, you misunderstand DeFi.

Coin vs Token: Same Word, Different Mechanism

Before we continue, there is one important clarification:

In everyday language, people often use the word "coin" to describe any cryptocurrency.

But technically, there is a difference between a "coin" in general speech and a "native coin" in a strict architectural sense.

• Coin (casual usage): Any cryptocurrency, including tokens.
• Native coin (technical usage): The built-in currency of a specific blockchain.

In this article, when we say "native coin," we mean the protocol level currency of a blockchain (like Bitcoin on Bitcoin, or ETH on Ethereum).

Let’s clear the confusion first.

People use the word “coin” for everything.
But technically, there is an important difference.

Native Coin

A native coin is the built-in currency of a blockchain.
It exists at the protocol level.
It is used to:

• Pay gas
• Reward validators
• Secure the network

A native transfer is the most basic blockchain action.
It does not require a smart contract.
It is part of the core system rules.

Example

If you send 0.5 ETH from your wallet to a friend’s address:

• The blockchain directly updates the balance of two accounts.
• No separate token contract is involved.
• The protocol itself processes the transfer.

It is similar to handing someone physical cash. The system simply reduces your balance and increases theirs.

Token

A token is not built into the blockchain.
A token is created by a smart contract.

That contract keeps a ledger: a balance table: inside its state.

Think of it like this:

Inside the token contract, there is a table that says:

Address A → 100
Address B → 250
Address C → 0

When you “transfer a token,” what really happens is:

Two numbers inside that table are updated.

That’s it.

The blockchain doesn’t “store coins in your wallet.”
The blockchain stores numbers inside smart contracts.

Your wallet only holds the private key that allows you to modify those numbers.

Example

Imagine there is a USDC token contract.
If you send 100 USDC to another address:

• Your wallet calls the USDC smart contract.
• The contract checks your balance inside its internal ledger.
• It subtracts 100 from your entry.
• It adds 100 to the recipient’s entry.

Unlike native coin transfers, this process runs contract code.

You are not moving a built-in blockchain currency.
You are asking a smart contract to update its internal accounting system.

Real-World Example

Bitcoin is a native coin on the Bitcoin network.

It is built directly into the protocol. When you send Bitcoin, the network itself updates account balances according to its core rules.

There is no separate "Bitcoin contract" managing balances.

By contrast, USDC on Ethereum is not a native coin. It is an ERC-20 token.

USDC exists because a smart contract keeps an internal balance table.

When you send USDC, your wallet calls the USDC smart contract, and that contract updates its ledger.

So:

• Bitcoin is a native coin on its own blockchain.
• USDC is a token implemented through a smart contract on top of another blockchain.

Final Mental Model

Coin: A currency that lives natively inside its own blockchain protocol.

Token: A programmable asset that lives inside a smart contract and exists because that contract keeps an internal balance ledger.

How Token Balances Actually Exist

In the previous article, we discussed state.

Token balances are simply part of a contract’s state.

When you check your balance:
Your wallet asks the contract: “What number is recorded next to my address?”

The contract responds with the stored value.
Nothing is inside your wallet.
Everything is on-chain.

What Is ERC-20?

ERC-20 is a standard for tokens on the Ethereum blockchain.

It defines a common interface so that wallets and applications can interact with tokens consistently.

It ensures that token contracts expose certain basic functions:

• Check balance
• Transfer tokens
• Approve spending
• Check allowance
• Transfer on someone’s behalf

However, not all tokens use ERC-20.
ERC-20 is specific to Ethereum and Ethereum-compatible networks.

On other blockchains, different token standards exist.

Even on Ethereum, there are other standards such as NFT standards (like ERC-721) or multi-token standards (like ERC-1155).

So when we say "token" in this article, we often mean ERC-20 tokens because they are the most common in DeFi.

But technically:

• ERC-20 is one type of token standard.
• It is not used by all tokens on all blockchains.

Important:

ERC-20 does not mean secure.
ERC-20 does not mean audited.
ERC-20 does not mean safe.

It only means the token follows a common structure so applications know how to interact with it.

Why We Focus on ERC-20 and Not Bitcoin Standards

You might wonder: if Bitcoin is a native coin, why don’t we discuss a "Bitcoin token standard"?

The reason is structural.

Bitcoin does not rely on a general-purpose smart contract platform in the same way Ethereum does.

On Ethereum, DeFi applications are built around smart contracts that manage tokens. Because of this, token standards like ERC-20 became essential for interoperability.

Most DeFi protocols were originally built on Ethereum or Ethereum-compatible networks. These ecosystems assume ERC-20 compatibility for things like swapping, lending, liquidity pools, and staking.

Bitcoin, on the other hand, primarily operates with its native coin and a different scripting model. It does not use ERC-20 because ERC-20 is specific to Ethereum’s smart contract environment.

So we focus on ERC-20 here because:

• It is the dominant standard in DeFi environments.
• Most beginner DeFi interactions involve ERC-20 tokens.
• Understanding ERC-20 prepares you for the majority of DeFi use cases.

Later in the series, when discussing cross-chain assets and wrapped tokens, we will revisit how assets like Bitcoin can interact with smart contract ecosystems.

Are There DeFi Protocols on Other Blockchains?

Yes, DeFi is not limited to Ethereum or ERC-20 tokens.

Other blockchains have their own token standards and their own DeFi ecosystems.

For example:

• Some networks use token standards similar in spirit to ERC-20 but with different technical rules.
• Some ecosystems are built around account-based smart contract models.
• Others use different execution environments and programming models.

What matters is not the name of the standard, but the underlying structure:

A DeFi protocol requires:

• Smart contracts (or equivalent programmable logic)
• A token standard that applications can interact with consistently
• A way to verify and execute transactions on-chain

Ethereum popularized ERC-20, which is why it became dominant in early DeFi. But today, multiple blockchains support their own DeFi protocols using their own standards.

In this article, we focus on ERC-20 because:

• It remains the most common environment beginners encounter.
• Many foundational DeFi concepts were first implemented there.
• Understanding ERC-20 helps you understand how token-based DeFi works in general.

Once you understand this structure, adapting to other ecosystems becomes much easier.

Decimals, Symbol and Illusions

When you see:

1.25 TOKEN

Internally, the contract might be storing:

1250000000000000000 units

Decimals are just a display format.
However, decimals can also be used to mislead.

Decimal Scams: When Numbers Look Bigger Than They Are

Some malicious tokens use unusual decimal settings.

For example:

• A token might use 2 decimals instead of 18.
• Your wallet may show 1,000,000 tokens.
• But the actual economic value may be extremely small.

Large numbers in your wallet do not automatically mean real value.

Always verify:

• Token contract address
• Liquidity
• Market value

Also important:

Token name and symbol are not identity.
Two completely different contracts can use the same symbol.
The only real identity is the contract address.

Beginner mistake: Trusting symbol instead of verifying contract address.

Example

Imagine you search for "USDC" on a decentralized exchange.

You might see two tokens with the same symbol: USDC.

• Token A is the official USDC contract.
• Token B is a fake contract created by someone else, using the same name and symbol.

If you select Token B and swap into it:

• The interface may still display "USDC".
• Your wallet will show "USDC".
• But the contract address is different.

Later, you may discover:

• The fake token has no real liquidity.
• You cannot sell it.
• Or it contains malicious logic.

The only reliable identity of a token is its contract address, not its name or symbol.

Transfer vs Approve: The Critical Difference

Transfer

Transfer means:

You send tokens directly from your address to another address, simple.

Why Approve Exists

DeFi protocols need to move tokens on your behalf.

When you interact with a protocol, two different functions may be used:

• transfer: Used when you directly send tokens to another address.
• transferFrom: Used when a smart contract pulls tokens from your address.

Protocols like DEXs and lending platforms use transferFrom.

But transferFrom only works if you first call approve.

Approve is the key that unlocks transferFrom.

Without approval, the protocol cannot move your tokens.

That is why approve exists.

What Approve Actually Does

Approve gives permission.

It says:

“This contract is allowed to withdraw up to X tokens from my balance.”

It does not send tokens immediately.

It creates an allowance.

Allowance contains three pieces of information:

Owner → You
Spender → The contract
Amount → Maximum allowed withdrawal

Infinite Approval

Many interfaces request unlimited approval.
This is done for convenience.

So you don’t need to approve every time.
But unlimited approval means:

If that contract becomes malicious,
it can withdraw your entire balance.

Approval is not harmless.

It is one of the most misunderstood risks in DeFi.

Does Approval Change From App to App?

Yes.

Approval is not global.

It is specific to:

• A specific token
• A specific spender contract
• A specific blockchain network

When you approve a token, you are granting permission to one contract address only.

If you approve USDC for a DEX contract, that approval does not automatically apply to a lending protocol.

Each protocol has its own contract address, and each one requires its own approval.

Approval also persists until you change it.

It does not reset automatically after one use.

If you approve 1,000 tokens, the contract can continue pulling tokens (up to that limit) in future interactions unless you revoke or reduce the allowance.

This is why reviewing and managing allowances is an important long-term security habit.

Mental Model

Approval is not giving away your tokens. It is giving a smart contract permission to pull them under defined conditions.

"Read-Only" vs Real Approval: Can You Accidentally Give Unlimited Access?

Many applications first ask you to "connect your wallet."

Wallet connection is read-only.

It allows the application to:

• See your public address
• Read your balances
• Detect which network you are on

It does NOT give spending permission.

Spending permission only happens when you sign an approval transaction.

However, this is where confusion begins.

Some interfaces display messages like:

"Approve token for use" "Allow this app to access your USDC"

If you sign that transaction, you may be granting an allowance.

And that allowance could be:

• A limited amount (for example, 100 tokens)
• Or unlimited (often displayed as "Unlimited" or a very large number)

Even if the interface appears simple, the actual spend limit is defined inside the transaction you sign.

So yes: you might believe you are giving minimal access, while the transaction actually sets an unlimited allowance.

This is why it is critical to:

• Read the spend limit in your wallet confirmation screen
• Look for the amount being approved
• Avoid unlimited approval unless you fully trust the protocol

Remember:

Connection is read-only. Approval is permission to spend. They are not the same action.

Interface vs Protocol

The website you visit is not the protocol.
The website is just an interface.
The protocol lives on-chain as smart contracts.

A malicious website can:

• Show a familiar UI
• Ask you to sign a transaction
• Interact with a completely different contract

That is why:

You must check the transaction details inside your wallet.

Always verify:

• The contract address
• The action type (transfer, approve, contract call)

A beautiful interface does not mean security.

Wrapped Assets: Why Do They Exist?

Native coins cannot always behave like ERC-20 tokens.
But many DeFi protocols are built around ERC-20 standards.

This creates a translation problem.

Smart contracts expect ERC-20 style interactions. Native coins do not follow the ERC-20 interface.

The Translation Layer: Why We Need Wrapping

Think of wrapping like packaging.

The native coin is like loose cash. ERC-20 tokens are like standardized digital payment cards.

DeFi protocols are built to accept the standardized card format.

So when you "wrap" a native coin:

• You deposit the native coin into a contract.
• The contract locks it.
• It issues you an ERC-20 representation.

That wrapped token can now interact with DeFi contracts seamlessly.

When you unwrap, the process reverses.

Wrapping does not change value. It changes compatibility.

This is why you often see WETH instead of ETH inside liquidity pools.

Wrapping is a compatibility mechanism.

Types of Tokens You Will See in DeFi

Now that you understand what a token is and how it works technically, let’s look at how different tokens function inside DeFi.

You will commonly encounter:

• Stablecoins (tokens designed to track a stable value, usually a fiat currency)
• Liquidity provider tokens (represent your share in a liquidity pool)
• Lending receipt tokens (represent your deposit inside a lending protocol)
• Governance tokens (used to vote on protocol decisions)
• Reward tokens (issued as incentives for participation)

Not all tokens represent simple money.

Some represent positions. Some represent voting power. Some represent claims on protocol activity.

USDT vs USDC: Why They Are Both Tokens

USDT and USDC are both stablecoins.
They are not native coins.
They are ERC-20 tokens (among other network versions) issued by smart contracts.

Both aim to track the value of 1 US dollar.

However, they differ in important ways:

• Issuer: USDT is issued by Tether. USDC is issued by Circle.
• Transparency model: USDC generally emphasizes more frequent attestations and regulatory alignment.
• Contract control: Both rely on centralized issuers that can freeze addresses or manage supply.

Technically speaking:

• Neither USDT nor USDC exists at the blockchain protocol level.
• They exist because smart contracts maintain internal ledgers representing balances.

This makes them tokens, not native coins.

In the next article, we will examine stablecoins in depth, including how they maintain their peg and what risks come with them.

The Rebase Phenomenon: When Your Balance Changes by Itself

Some tokens use a mechanism called rebase.

A rebase token can automatically adjust the number of tokens in your wallet without you sending or receiving a transaction.

Your balance may increase or decrease based on protocol rules.

This does not necessarily mean you were hacked.

It means the token contract recalculated balances according to its internal logic.

Understanding this prevents panic when wallet numbers change unexpectedly.

Understanding what a token represents is more important than its price.

Token Supply: Mint, Burn and Total Supply

Every token contract defines a total supply.

Total supply represents the total number of tokens that exist according to the contract’s internal ledger.

However, supply is not always fixed.

• Minting: The contract can create new tokens and increase total supply.
• Burning: Tokens can be permanently removed from circulation, decreasing supply.

Some tokens have fixed supply rules. Some allow controlled minting. Some allow admin-controlled minting.

Supply mechanics matter because price is influenced by both demand and circulating supply.

A token with unlimited minting ability carries a different economic risk than one with strictly capped issuance.

Understanding supply dynamics prepares you for later discussions about inflation, yield emissions, and token incentives.

Who Controls the Contract?

A token is code.

Code can include permissions.

Important questions to ask:

• Is there an owner address?
• Can the owner mint new tokens?
• Can transfers be paused?
• Can addresses be blacklisted?
• Is the contract upgradeable?

Some projects renounce ownership, meaning no single address retains administrative control.
Others keep administrative permissions for upgrades or emergency controls.

Administrative flexibility is not automatically malicious. But it introduces trust assumptions.

Understanding who controls the contract helps you understand where the real power lies.

Token Risks: Technical vs Economic

Transparency does not equal safety.

Technical Risks

• Admin minting ability: The contract owner can create new tokens at any time, increasing supply and potentially diluting value.
• Pausing transfers: The contract can freeze all token transfers, preventing users from moving or selling their tokens.
• Blacklisting addresses: Specific addresses can be blocked from sending or receiving tokens.
• Upgradeable contracts: The contract logic can be changed after deployment, which may introduce new risks.
• Fee-on-transfer mechanisms: A percentage is deducted automatically on each transfer, which can affect swaps and liquidity positions.

Economic Risks

• Low liquidity: There may not be enough buyers and sellers, making it hard to exit a position without heavy price impact.
• High volatility: Token prices can change rapidly, leading to significant gains or losses in short periods.
• Poor token distribution: If a small group holds most of the supply, they can influence price dramatically.
• Inflation from token emissions: New tokens may be issued continuously, increasing supply and putting downward pressure on price.

Seeing it on an explorer does not mean it is safe.

Open code does not mean low risk.

Beginner Safety Checklist Before Interacting with a Token

Before you approve or interact:

• Confirm correct network: Make sure your wallet is connected to the intended blockchain. Sending or approving on the wrong network can make your assets inaccessible or unusable in that context.
• Verify contract address: Do not rely on token name or symbol. Always confirm the official contract address from a trusted source before interacting.
• Check transaction type: Read the wallet popup carefully. Are you transferring tokens, approving allowance, or calling a contract function?
• Avoid unlimited approval when unnecessary: If possible, approve only the amount you intend to use. This limits potential damage if the contract is compromised.
• Start with a small test amount: When using a new token or protocol, test with a small amount first to verify behavior.
• Revoke old allowances periodically: Review and remove unused approvals to reduce long-term exposure to contract risk.

Common Beginner Mistakes

• Buying a fake token with same symbol: Attackers can create tokens with identical names and symbols to popular assets.
• Approving unlimited allowance to unknown contracts: This can allow malicious contracts to drain your balance later.
• Confusing transfer with approve: Approve does not send tokens immediately, but it grants permission for future withdrawals.
• Ignoring transaction details in wallet popup: Many users click confirm without reading the contract address or function being executed.
• Assuming ERC-20 means secure: A token can follow the ERC-20 standard and still contain risky or malicious logic.

One Minute Summary For who are Lazy

A token is not “coins in your wallet.”
A token is a smart contract that keeps a balance table on-chain.

Your wallet is just a key, approve grants permission.

Allowance creates risk.

Interface is not the protocol, and every DeFi interaction depends on understanding this structure.

Originally published on X · 2026-03-02