What is crypto? Blockchain, tokens and stablecoins from scratch

"Crypto" is not synonymous with Bitcoin. Bitcoin was the first blockchain architecture, but it is far from being the only one, and much more than a payment system can be built on top of each of those architectures. This article —the second in a three-part series— builds upon what we established in Bitcoin from zero and explores what a generic blockchain is, what Ethereum and smart contracts are, the difference between a native currency and a token, what stablecoins and NFTs are, why there are so many blockchains, and how —when possible— assets move between them.

Why isn't Bitcoin the only blockchain?

In the previous article, we reached an important idea: Bitcoin is not an application; it is an architecture. A set of common rules that many participants follow simultaneously to move and record value, without any single operator controlling the system. And within that architecture, anyone can create their own "point system."

Once that design is accepted, the consequence is obvious: if it works, someone else will build a similar architecture with different rules. There doesn't have to be just one blockchain, just as there isn't just one payment system or one social network. Each architecture optimizes for something different —speed, cost, programmability, decentralization, scale— and the trade-offs between these goals are real: what you gain on one side, you lose on the other. Hence, in 2026, there are dozens of relevant blockchains and hundreds of minor ones. Bitcoin remains the largest by capitalization, but it is just one specific architecture within a much broader ecosystem.

There is a distinction that should be clear from the start: when someone says "I invest in crypto," they almost never mean "I invest in Bitcoin." They mean they have exposure to a heterogeneous set of architectures and "points" created on those architectures, each with different risks, properties, and reasons for existing. Talking about "crypto" as a homogeneous block is like talking about "the internet" as if Wikipedia and an online casino were the same thing.

What changes when money can be programmed?

The second blockchain to gain real traction appeared in 2015 and is called Ethereum. It shares the basic design with Bitcoin —ownerless architecture, database replicated across thousands of nodes, operational neutrality— but adds a decisive piece: the application doesn't just move points; it also executes programs.

In Bitcoin, a transaction essentially says: "send 10 of this to this address." In Ethereum, a transaction can also say: "if this other thing happens, then do it automatically." These programs that live within the shared database and execute identically on all nodes are called smart contracts. They are code stored on the blockchain that applies deterministic rules: if you deposit X, you receive Y; if your collateral falls below Z, I liquidate your position; if the match result is A, I pay you B.

The name is somewhat misleading. A smart contract is neither a "contract" in the legal sense nor "intelligent" in the sense of being adaptive: it is a rigid program that does exactly what it says and nothing more. What makes it distinctive is that no one can interrupt, modify, or reverse its execution once deployed, unless the code itself provides for that possibility. If the contract says things should happen, they happen. If the contract has a bug, the bug executes. This rigidity is both the guarantee and the primary risk.

The practical consequence is that much more than a payment system can be built on a programmable architecture like Ethereum. Loans, exchanges, games, prediction markets, shared custody, voting, ownership certificates: anything that can be written as a set of rules can be expressed as a smart contract and deployed for anyone to use. The entire DeFi layer —which is the subject of the third article in this series— lives precisely on this premise.

Ethereum was the first programmable architecture to work at scale. Today it is not the only one: Solana, Avalanche, BNB Chain, Sui, and many more are programmable architectures with different trade-offs. But the principle introduced by Ethereum —blockchain + programmable computing engine— is what most modern blockchains share.

What is the difference between a native currency and a token?

Once a programmable architecture exists, two distinct types of assets appear that should not be confused.

The native currency is the "point" that the architecture itself needs to function. In Bitcoin, it is bitcoin; in Ethereum, it is ether (ETH); in Solana, it is sol (SOL). They fulfill a specific technical function: paying nodes to process each transaction. This fee is commonly called gas, and it is what prevents the network from collapsing under spam and rewards those who maintain the infrastructure. Without a native currency, the architecture does not function.

A token is any other "point" created on top of that architecture. It has no protocol function: it has whatever function its creator wants to give it. It can represent a unit of account (a stablecoin), a voting right in an organization (a governance token), a real-world asset (a token backed by real estate), an event ticket, an art collection, a portion of ownership in a project, or simply a social experiment with no claimed value. All Ethereum tokens move on the same architecture, all pay gas in ETH to operate, but none is Ethereum.

There is a useful analogy: ETH is the electrical power of the grid; tokens are the appliances you plug into that grid. The power is valuable in itself because without it, nothing works; the appliance is valuable for what its creator made it do. And as in any electrical grid, there are thousands of compatible appliances because they follow the same standard.

That standard on Ethereum is called ERC-20 (for fungible tokens, interchangeable 1:1 with each other) and is the reason why your wallet can show you hundreds of different tokens with the same interface: they all respect a few common technical conventions. On Solana, the analogous standard is called SPL; other architectures have equivalents. There are also specific standards for unique assets —NFTs, which we will see shortly— and for specialized cases.

The scale of this token layer, separate from the native currency, is what surprises newcomers. In January 2026, daily active ERC-20 addresses on Ethereum exceeded 800,000 according to Etherscan: each of them was moving tokens —stablecoins, governance, tokenized assets— that are not ETH, even though they paid their gas in ETH. In other words, the bulk of daily activity on Ethereum is not people moving ether, but people moving "appliances" plugged into the network. The native currency is the fuel; tokens are the economy built on top.

Confusing native currency with a token is one of the most frequent mistakes in the early stages. The distinction matters because the two categories have radically different risks, valuations, and reasons for existing: a stablecoin is not a native currency, a governance token is not a stablecoin, and none of the three is the same as ETH or SOL.

What are stablecoins and why are they used so much?

A stablecoin is a token designed to maintain a stable value, usually pegged to the US dollar (1 stablecoin = 1 dollar). It combines the utility of blockchain architecture —operational neutrality, 24/7 settlement, programmability— with the utility of having an asset that does not fluctuate from hour to hour.

There are three basic models for maintaining this stability, with different levels of risk:

• 1:1 backing with dollars in custody. The issuer (Circle for USDC, Tether for USDT, PayPal for PYUSD) holds a real dollar —in bank accounts or short-term US Treasury bills— for every stablecoin issued. This is the dominant model by market share. The fragility: it depends on the issuer being solvent, honest, and not suffering a regulatory freeze.
• Over-collateralization with crypto. The issuer (MakerDAO for DAI, Aave for GHO) accepts deposits of volatile assets —primarily ETH— at a ratio higher than 1:1 (typically 1.5:1 or more) and issues stablecoins against that collateral. If the collateral falls below a threshold, it is automatically liquidated. It is more decentralized but less capital-efficient.
• Delta-neutral or algorithmic models. The issuer (Ethena for USDe) combines long positions in collateral with short positions in derivatives to neutralize volatility. More complex, higher potential yield, larger failure surface.

The total stablecoin market exceeded $321 billion by mid-2026, with USDT at around 58% (~$184 billion) and USDC at around 25% (~$78 billion) as the two dominant benchmarks. The interesting detail is what they are used for. Two-thirds of that capital —approximately $210 billion— lives in emerging markets and functions as a de facto dollarized bank account: savers in Nigeria, Argentina, Turkey, or Vietnam who do not want to hold their wealth in local currency but cannot open a dollar account in a US bank. For this segment, USDT on Tron is the real financial infrastructure, rather than a speculative alternative to the system.

Stablecoins are, today, the token category that moves the most volume on any blockchain. We cover the case with specific data —reserves, regulatory pressure from the GENIUS Act, dependence on Treasury bills— in the article dedicated to the $321 billion market and the migration toward specialized stablechains.

What are NFTs and why were they so misunderstood?

An NFT (non-fungible token) is a unique token, not interchangeable 1:1 with another of the same type. Where a stablecoin is like a one-euro bill —any bill is worth the same as another— an NFT is like a signed painting or a car license plate: distinguishable, with its own identity.

Technically, an NFT is nothing more than a record on the blockchain that says "address X owns item Y." The standard standard on Ethereum is called ERC-721. The record is indisputable; what that record represents is where the confusion begins.

In 2021, public discourse collapsed NFT with "digital art" and "internet collectibles." The bubble was real, prices were irrational, and the subsequent 90%+ drop in many image collections remains as evidence. What was lost in the noise is that the NFT is not the image: it is the ownership record. The JPEG lives on some server; the NFT lives on the blockchain. People bought ownership records for images that were not particularly well-defined, nor immutably linked to the record, nor backed by anything beyond the market consensus of the moment.

Beyond art, NFTs have demonstrated real utility in other fields: decentralized domain names (ENS on Ethereum, where each name is unique), event tickets (impossible to duplicate tickets with programmable resale), academic or professional certificates, fractional ownership rights over real assets, and on-chain identity in general. In these cases, the NFT is not a collectible: it is the verifiable digital representation of a right. The bubble swept the category away in the popular imagination, but the technical piece remains useful for anything requiring "this belongs to this address and no one else."

Why are there so many blockchains and how are they organized?

When a user first lands in crypto, the most common question is: "why are there so many?". The short answer is that each architecture optimizes for something different and the trade-offs between goals are real. The useful answer is to understand the three main categories into which modern blockchains are organized:

L1 (Layer 1). Independent architectures with their own nodes, their own consensus, and their own rules. Bitcoin is an L1. Ethereum is an L1. Solana, Avalanche, BNB Chain, Sui, Aptos, and many others are as well. Each solves the classic blockchain trilemma —decentralization, security, scale: it's hard to have all three at maximum at the same time— in its own way, and the choices reflect that distribution. Solana prioritizes speed and cost, Bitcoin prioritizes security and decentralization. None is objectively "better": it depends on the use case.

L2 (Layer 2). Architectures built on top of an L1, usually Ethereum, that inherit part of its security while radically lowering cost and increasing speed. Arbitrum, Base, Optimism, zkSync, and Scroll are examples. The intuition: instead of every transaction being verified by thousands of nodes directly on Ethereum, L2s process transactions on their own faster and cheaper layer, and periodically "settle" summaries on Ethereum as immutable proof. It is the dominant model for scaling Ethereum without sacrificing its base layer.

App-chains. Blockchains dedicated to a single product or use case. Hyperliquid, for example, is a blockchain built specifically for decentralized perpetuals — and therefore can optimize everything (consensus, execution, order book) for that specific function. The trade-off is clear: it gains a lot of efficiency but loses the versatility of being able to build anything on top.

There are also alternative models to the dominant L1+L2 scheme. Cosmos bets on a galaxy of sovereign blockchains interconnected via a common protocol (IBC). Polkadot brings together parachains that share a central security layer. These designs capture a smaller slice of the market but propose different answers to the same problem: how to scale and how to connect heterogeneous architectures.

Within most of these architectures, there is another layer of complexity: EVM compatibility. The "Ethereum Virtual Machine" (EVM) is the environment where Ethereum smart contracts execute. Many L1s and L2s are "EVM-compatible" — the same Ethereum contracts work there with almost no changes. But "compatible" is not "equivalent": details can break integrations when it is assumed that everything is identical. We cover it in detail here. For a view of the full catalog, see the list of chains we cover.

How do points move between architectures?

At this point, an operational question arises: if I have bitcoins on the Bitcoin blockchain and I want to use them on Ethereum (because a protocol I'm interested in lives there), how do I move them?

The short answer is: they cannot be moved directly. Each blockchain is an independent architecture. Their databases do not talk to each other natively; a bitcoin only exists in the Bitcoin database, and no one on Ethereum knows anything about it. To solve this, intercommunication mechanisms have been invented, but they are all artificial constructions added on top, not native properties of the design.

The most common mechanism is wrappers. The mechanics: you deposit 1 BTC with a custodial entity that physically locks it at a Bitcoin address. That entity issues, on Ethereum, 1 token called WBTC (Wrapped Bitcoin) representing your locked BTC. You now have an operational WBTC on Ethereum: you can lend it, exchange it, or use it in any protocol on the network. If you want to recover your original BTC, you return the WBTC to the custodian, and they release the locked BTC.

It works, but it introduces a new risk. The centralized custodian is a single point of failure: if they go bankrupt, are hacked, are sanctioned, or decide to block your redemption, the WBTC on Ethereum no longer has real backing. Bitcoin's premise of operational neutrality —no one can stop you— is broken when you put a trusted piece in the middle. There are variants that try to minimize this problem (distributed custody, multiple oracles, non-custodial bridge models), but none eliminates it completely.

Cross-chain bridges are the generalized version: contracts on two blockchains that coordinate locking on one and issuance on the other. The list of bridge hacks in recent years is brutal —Ronin, Wormhole, Nomad, Multichain, Kelp DAO— because they concentrate liquidity from many users and expose a massive attack surface. We did a structural analysis of the problem; those wanting a comparison of the three dominant cross-chain messaging protocols can go to LayerZero vs Wormhole vs Axelar.

The operational conclusion: when moving value between architectures, assume the risk is structurally higher than when operating within a single one. This is not an opinion; it is a property of the design.

What does the real token map look like in 2026?

The abstraction "there are blockchains, there are tokens on top" is best understood by looking at the specific distribution. Public data from May 2026 draws a very specific map:

The non-obvious takeaway: most of the "crypto" moving every day in 2026 is not Bitcoin, is not Ethereum, is not any altcoin: it is US dollars represented as tokens on blockchain architectures. The most successful application of the invention has been, paradoxically, moving the world's reserve currency without going through the banking system. Stablecoins already represent three-quarters of total volume and, in the corridors where they dominate (Mexico-US, Philippines-Singapore, Sub-Saharan Africa), they process more monthly operations than some traditional transfer systems.

The second non-obvious fact: fragmentation by chain is massive and specific. Tron concentrates the bulk of USDT circulating in emerging markets because fees there are consistently low and the platform —centralized in practice— prioritizes that use case. Ethereum and its L2s concentrate the bulk of institutional USDC because they offer more mature integrations with regulated custodians. Solana has captured a growing slice of retail payments and next-generation stablecoins. Talking about "stablecoins" as a single category hides three very different markets with different dynamics.

This heterogeneity is the norm, not the exception. When someone says "the crypto ecosystem" in 2026, they are talking about a collection of architectures with drastically different sizes, properties, and user bases. Ignoring the detail is operationally expensive.

Where to go from here?

With the concepts in this article established —blockchain as architecture, smart contracts, native currency vs token, stablecoins, NFTs, L1/L2/app-chains, bridges, and wrappers— the third article in the series closes the circle: how, on these rails, complete financial services (loans, exchanges, savings, derivatives) are built without banks or intermediaries. This is the layer the industry calls DeFi, and it is much better understood with all the above clear.

If you want to dive deeper before continuing the series, complementary readings:

• What is Ethereum? — dedicated explainer on the most relevant programmable architecture.
• Blockchain basics — conceptual reinforcement on how a generic blockchain works.
• Chains we cover — catalog of all L1s and L2s with an operational presence on CleanSky.
• The $321 billion stablecoin market — deep analysis of the real state of the market, reserves, regulatory pressure, and dependencies.
• EVM-compatible vs equivalent — technical guide on why "works on Ethereum" doesn't mean "works the same on any EVM."
• Cross-chain bridge architecture after the hacks — structural analysis of bridge risk.

Sources and external references: Ethereum whitepaper (Vitalik Buterin, 2013) · DefiLlama — Stablecoins · L2BEAT — L2 comparison · Chainalysis — Global Crypto Adoption Index · Etherscan — daily active ERC-20 addresses