Smart Contracts

From Promise to Code: What a Smart Contract Actually Is

The term 'smart contract' was coined by computer scientist Nick Szabo in 1994, long before blockchains existed. His classic analogy is the vending machine: you insert coins, you press a button, and the machine deterministically dispenses a drink. No cashier verifies the deal, and neither party can cheat — the logic is embedded in the machine itself. A smart contract generalises this idea into software: a set of rules where 'if condition X is true, then action Y executes automatically,' enforced by a network rather than a trusted intermediary.

In modern crypto, a smart contract is a program deployed to a blockchain. It has its own address (just like a wallet), it can hold a balance of tokens, and it contains functions that anyone can call by sending a transaction. Once deployed, the code runs exactly as written on every node in the network, and the outcome is recorded immutably on-chain. Bitcoin has a limited scripting language and was never designed for arbitrary programs; Ethereum, launched in July 2015 by Vitalik Buterin and co-founders, was the first blockchain built specifically to run general-purpose smart contracts.

The key property is determinism without trust. Every participant can independently verify what the code will do, and the network guarantees it does exactly that. There is no customer-support line, no 'undo' button, and no judge to appeal to. This is the source of both the power and the danger of the technology: code is law, and the code does precisely what it says — including its bugs.

The Engine Room: EVM, Gas and Deterministic Execution

To run identically on thousands of machines worldwide, smart contracts execute inside a virtual machine — a sandboxed computer simulated by every node. On Ethereum this is the Ethereum Virtual Machine (EVM). Developers typically write contracts in a high-level language called Solidity (or Vyper), which is compiled down to EVM bytecode. The EVM is now an industry standard: chains such as BNB Chain, Polygon, Avalanche C-Chain and Arbitrum are all 'EVM-compatible,' meaning the same contract code can be deployed across them with little or no change.

Because computation on a shared global computer is a scarce resource, every operation costs gas — a unit measuring computational work. Users pay for gas in the chain's native token (ETH on Ethereum, denominated in tiny units called gwei, where 1 gwei = 0.000000001 ETH). Gas serves two purposes: it compensates validators for the resources they spend, and it prevents abuse such as infinite loops, which would otherwise halt the network. If a transaction runs out of the gas the user allotted, it reverts — all state changes are rolled back, but the gas spent is not refunded. This is why a failed swap can still cost you money.

Solana takes a different architecture. Instead of the EVM, it uses programs written in Rust (or C) compiled to a target called SBF, runs them in parallel via its Sealevel runtime, and charges very low fixed-style fees — often a fraction of a cent — enabling high throughput. The trade-off is a different developer toolchain and a different security and decentralisation profile. Knowing which virtual machine a protocol runs on tells you a lot about its fee structure, speed and ecosystem maturity.

How a Smart Contract Executes: Step by Step

Walking through a single interaction makes the abstraction concrete. Suppose you want to swap 1,000 USDC for ETH on Uniswap. You are not transacting with a company — you are calling a function on a publicly deployed contract. Here is the lifecycle of that transaction from click to confirmation.

1. 1You connect a wallet (e.g. MetaMask) and choose the swap. The dApp front-end builds a transaction that calls a specific function on the Uniswap router contract.
2. 2First, you may need a separate 'approve' transaction granting the router permission to spend your USDC. ERC-20 tokens require this allowance step before a contract can move your funds.
3. 3You sign the swap transaction with your private key and broadcast it to the network's mempool, attaching a gas fee.
4. 4A validator picks up the transaction, and every node runs the contract code in the EVM, calculating the ETH output from the pool's reserves.
5. 5If all conditions pass (sufficient balance, allowance, slippage within limits), the state updates: your USDC leaves, ETH arrives, and the result is written into the next block.
6. 6The transaction is confirmed on-chain. Anyone, forever, can audit exactly what happened via a block explorer like Etherscan.

Two details matter for traders. First, the 'approve then swap' pattern means you often grant contracts spending allowances. Many wallets default to an unlimited allowance for convenience — convenient, but a standing risk if that contract is ever compromised. Second, because anyone can read the mempool, sophisticated bots can see your pending swap and front-run it, a category of extraction called MEV (Maximal Extractable Value) we return to below.

Token Standards: The Templates That Make Crypto Composable

Most assets you trade are not separate blockchains — they are smart contracts that follow a shared standard. On Ethereum, the ERC-20 standard defines a common interface (functions like transfer, balanceOf and approve) that every fungible token implements. Because every ERC-20 behaves the same way, any exchange, wallet or lending protocol can support a new token instantly without custom integration. This shared interface is why thousands of tokens 'just work' across the ecosystem.

Stablecoins are the most economically important smart contracts in crypto. USDT (Tether) and USDC (Circle) are ERC-20 contracts on Ethereum (and deployed on many other chains too) that issuers claim are backed by reserves. Combined, they settle trillions of dollars in volume. When you 'hold USDC,' you hold a balance recorded inside a contract — and the issuer typically retains the ability to freeze or blacklist addresses, an important centralisation caveat that pure protocols like ETH itself do not have.

• ERC-20 — fungible tokens: stablecoins (USDT, USDC), governance tokens (UNI, AAVE), wrapped assets (WETH, WBTC).
• ERC-721 — non-fungible tokens (NFTs), each unique: art, collectibles, in-game items.
• ERC-1155 — multi-token standard, mixing fungible and non-fungible in one contract; common in gaming.
• ERC-4626 — tokenised vaults, standardising yield-bearing deposits across DeFi.

What Smart Contracts Unlocked: DeFi, NFTs and Beyond

Smart contracts turned a payment network into an open financial system. Decentralised finance (DeFi) rebuilds banking primitives as composable, permissionless code. Uniswap replaced order books with an automated market maker (AMM) where prices are set by a formula over pooled reserves. Aave and Compound let users lend and borrow against collateral, with interest rates adjusting algorithmically. MakerDAO mints the DAI stablecoin against locked collateral. None of these require an account application, a credit check or office hours — only a wallet and gas.

The defining superpower is composability, often called 'money legos.' Because every contract is public and callable, developers can stack them: deposit ETH into Aave, borrow USDC against it, swap that USDC on Uniswap, and farm yield elsewhere — all atomically within a single transaction if desired. This is impossible in traditional finance, where each institution is a walled garden. Composability accelerates innovation but also chains risk together: a failure in one widely used contract can cascade through everything built on top of it.

Beyond DeFi, smart contracts power NFTs (provable ownership of digital items via ERC-721), DAOs (decentralised autonomous organisations that govern treasuries by token vote), on-chain games, prediction markets, and tokenised real-world assets like treasury bills. The common thread is removing the trusted middleman and replacing them with transparent, auditable code.

The Risks: Code Is Law, Including Its Bugs

Immutability cuts both ways. Once deployed, a flawed contract often cannot be patched, and there is no central authority to reverse a theft. The history of crypto is in large part a history of smart-contract failures, and traders who ignore this lose money. The 2016 DAO hack drained 3.6 million ETH through a reentrancy bug and was so severe it split Ethereum into two chains (ETH and Ethereum Classic). Reentrancy — where a malicious contract calls back into a vulnerable one before its balances update — remains a textbook attack vector studied to this day.

Not all failures are code bugs; many are economic-design failures. In May 2022, the Terra ecosystem collapsed when its algorithmic stablecoin UST lost its dollar peg. UST's smart contracts were designed to maintain $1 by minting and burning the sister token LUNA, but under stress the mechanism entered a death spiral, vaporising roughly $40 billion in days. The contracts executed exactly as written — the design itself was fragile. This is a crucial distinction: a contract can be bug-free and still be a terrible bet.

Other systemic categories include oracle manipulation (feeding a contract a false price to drain it), governance attacks (acquiring enough tokens to pass a malicious proposal), flash-loan exploits (borrowing huge sums within one transaction to manipulate markets), and rug pulls (developers retaining backdoor mint or withdraw functions, then absconding). It is also worth noting that not every collapse is a smart-contract problem at all: the November 2022 failure of the FTX exchange was old-fashioned custodial fraud at a centralised company — a reminder that 'not your keys, not your coins' and 'on-chain is auditable' are precisely the properties smart contracts were meant to provide.

How a Trader Actually Uses This Knowledge

Smart-contract literacy is an edge, not academic trivia. Every on-chain trade is a contract interaction, so the trader who understands the plumbing makes better decisions and avoids avoidable losses. Practically, that means using a block explorer to verify a token's contract is the official one, checking whether liquidity is locked before buying a new token, and reading a protocol's audit reports and total value locked (TVL) before depositing capital.

It also means managing two costs unique to on-chain trading. Gas fees can dwarf profits on small trades — during peak congestion, a single Ethereum swap has cost over $100, which is why traders often route activity through Layer 2 rollups (Arbitrum, Optimism, Base) or alternative L1s like Solana. And slippage plus MEV can quietly erode fills: set a tight slippage tolerance, use limit orders or MEV-protected RPC endpoints where available, and be wary of low-liquidity pools where a single large order moves the price sharply.

1. 1Verify the contract: confirm the address on the official site and check it is 'verified' on Etherscan or Solscan.
2. 2Assess the risk: look for audits, TVL, locked liquidity, the age of the protocol and whether the team holds admin keys.
3. 3Control your exposure: approve only the amount you need, not unlimited; revoke stale allowances with a tool like Revoke.cash.
4. 4Mind the costs: estimate gas, set sensible slippage, and consider an L2 for smaller positions.
5. 5Use a test mindset: for a new protocol, send a small amount first before committing size.

Finally, understand the role of upgradeability. Many modern protocols use 'proxy' patterns so their contracts can be upgraded — which fixes bugs but reintroduces a trust assumption, because whoever controls the upgrade keys can change the rules. The safest projects place upgrade power behind a time-locked multisig or DAO governance, giving users a window to exit before a change takes effect. Checking who holds the keys, and how upgrades are gated, separates careful capital allocation from blind speculation.

The Trade-Offs in One View

Smart contracts replace trusted intermediaries with transparent, automatic code, but that trade has costs as well as benefits. The table below summarises what you gain and what you give up — the mental model worth carrying into every on-chain decision.

There is no free lunch. You gain censorship resistance, transparency, 24/7 availability and the removal of counterparty risk — but you inherit smart-contract risk, irreversibility, and the burden of self-custody and due diligence. The skilled trader does not fear this; they price it in. Knowing exactly which guarantees a contract gives, and which it does not, is what turns the raw power of programmable money into a durable edge.