Blockchain, Honestly · Chapter 5 of 6
The stack you would actually use
The products a real project reaches for, what each one is for, and which of them are avoidable.
If you were staffed on this tomorrow, here is the shape of what you would meet. Nothing here is an endorsement — it is a map, so the names stop being noise.
| Layer | What it is for | What you would meet |
|---|---|---|
| Chain | Where your code runs and state lives | Ethereum — most tooling, most liquidity, slowest and dearest. Solana — far faster, Rust, one integrated chain rather than layers. Base / Arbitrum — layer 2s: cheap, Ethereum-compatible, borrow its security. |
| Language | Writing the contract | Solidity on Ethereum and every compatible chain — the default by a wide margin. Rust on Solana. Move on Aptos and Sui, where the type system itself refuses to let an asset be copied or silently dropped. |
| Toolkit | Compile, test, deploy | Foundry — Rust-based, tests written in Solidity, built-in fuzzing; where new security-sensitive work starts. Hardhat — older, JavaScript, larger plugin ecosystem, engine rewritten in Rust in v3 (late 2025). |
| Libraries | Not writing the dangerous parts yourself | OpenZeppelin Contracts — audited implementations of the token standards, access control, proxies and pausing. Using these instead of hand-rolling is the single highest-value habit in the field. |
| Node access | Talking to the chain without running one | Alchemy, Infura, QuickNode. Same reasoning as a managed database — and the same concentration risk. |
| Oracles | Getting outside facts in | Chainlink is the incumbent; Pyth is the main challenger, publisher-sourced and low latency. Chapter 4 explains why this choice carries more risk than it looks like it should. |
| Front end | The application people click | viem and wagmi (TypeScript, current default) or the older ethers.js; web3.js was retired in March 2025. WalletConnect links a phone wallet to a desktop app. |
| Indexing | Reading history at speed | The Graph, Dune. A chain is a bad database to query — it has no indexes and no aggregates — so essentially every real product mirrors chain data into ordinary infrastructure and queries that instead. |
| Permissioned | Enterprise consortiums | Hyperledger Fabric and R3 Corda. No mining, no currency, known participants. Chapter 6 is largely about what happens to these in practice. Note: Hyperledger Fabric has nothing to do with Microsoft Fabric, an unrelated data and analytics platform — a collision that catches people in exactly the enterprise conversations where both come up. |
The indexing row deserves a second look, because it is the tell
Almost every serious application ends up with a chain for settlement and a normal database for everything else — search, history, dashboards, reporting.
If most of your system is going to be conventional infrastructure anyway, the honest question is what specifically the chain part is buying you. Chapter 6 gives you a way to answer that in one minute.
Reading the chain from ordinary code
Most engineering work here is not contract authoring at all — it is a normal backend talking to a chain. That looks like this, and it is deliberately unremarkable:
import { createPublicClient, http, formatEther } from 'viem'
import { mainnet } from 'viem/chains'
const client = createPublicClient({
chain: mainnet,
transport: http(process.env.RPC_URL), // your node provider endpoint
})
// read a balance -- free, no transaction, no key needed
const wei = await client.getBalance({ address: '0xd8dA...6045' })
console.log(formatEther(wei), 'ETH')
// read a contract -- also free; "view" functions cost nothing (chapter 3)
const symbol = await client.readContract({
address: TOKEN_ADDRESS,
abi: ERC20_ABI,
functionName: 'symbol',
})An ABI (Application Binary Interface) is the JSON description of a contract's functions that your client needs in order to encode a call — the equivalent of an OpenAPI specification, the machine-readable description of a web API specification. Reads are free and instant; only writes cost gas and wait for a block. Most integration work is reads.
The token standards, in one line each
- ERC-20 — fungible tokens. One unit equals any other, like currency.
- ERC-721 — non-fungible tokens (NFTs). Each one is individually identified. Worth knowing what it actually stores: almost always a URL, not the image. If that server goes away, the token points at nothing.
- ERC-1155 — both at once in a single contract; came from gaming.
- ERC-4337 — 'account abstraction': lets an account be a contract with its own rules, so someone else can pay your fees, or a lost key can be recovered socially. This is a direct attempt to fix the unrecoverable-key problem from chapter 4.
A stablecoin is a token intended to hold a fixed value, usually one US dollar. The credible ones — USDC, USDT — achieve that by a company holding actual reserves and honouring redemptions. Which is a trusted issuer, again, and it is why the largest genuinely working use of public chains is also the one that quietly depends on a regulated intermediary.
Check yourself