A smart contract is code that moves money when conditions are met. No bank, no human, no possibility of calling someone on a Sunday. That last part is sold as a feature. Future-you, locked out of $400 at 3am because line 47 reverted, may have a different view. The panda watches the marketing. The panda also reads the code.
What is a smart contract, exactly?
A smart contract is a small program stored on a blockchain. When you send it a transaction, it runs its code and updates the blockchain state. If you send 1 ETH to a swap contract, it might send you USDC back. If you deposit into a lending contract, it logs a balance and starts paying interest. The contract holds the funds. The contract decides. The contract does not ask permission.
According to Ethereum.org's developer documentation, a smart contract is "a program that runs at a specific address on the Ethereum blockchain." That is the technical version. The plain-English version: it is a vending machine with a bank account, written in code, that any wallet on Earth can interact with at any time of day.
Two things follow from that definition, and they explain almost every smart-contract story ever told. First, the rules are public: anyone can read the code. Second, the rules are rigid: nobody can override them at runtime. Both are usually pitched as strengths. Both are also, on a bad day, exactly the reasons people lose money.
How does a smart contract actually work?
Under the hood, a smart contract lives at a blockchain address, just like a wallet. The difference is that a wallet is controlled by a private key, and a contract is controlled by its bytecode. When you sign a transaction targeting that address, the network runs the bytecode inside an isolated environment called the Ethereum Virtual Machine, or EVM. The Ethereum.org EVM reference has the formal spec for anyone who wants the deep version.
Three things happen in order:
- The transaction is signed and broadcast. Your wallet builds a payload (which function to call, what arguments to pass, how much ETH or BNB to attach). You sign it. The network receives it.
- A validator includes it in a block. The contract's bytecode then executes step by step inside the EVM. Every step costs gas. If you run out of gas mid-execution, the entire transaction reverts and your state changes never happen.
- The state updates. Balances change, events are emitted, your wallet sees the result. Or, if the contract reverted, nothing happens except the gas you already paid.
The "and that is final" part is the bit that breaks new users. On a traditional database, a wrong transaction can be undone by an admin. On a smart contract, the admin role is itself a line of code. If the developer wrote no admin function, there is no admin. None. Spoiler: most exploits stem from a developer writing one anyway, and then losing the key.
Smart contracts vs traditional contracts: the honest comparison
A "smart" contract is not actually that smart. The name is a marketing carryover from a 1994 essay by Nick Szabo, long before any blockchain existed. What it really means is "automated", and even that comes with limits. Here is the comparison nobody puts in the pitch deck.
| Property | Smart contract | Traditional contract |
|---|---|---|
| Execution | Automatic, on-chain | Manual, court-enforced |
| Cost to enforce | Gas fee (cents to dollars) | Lawyers (thousands of dollars) |
| Speed | Seconds | Months to years |
| Reversibility | None unless coded in | Available via courts |
| Ambiguity tolerance | Zero (code or no code) | High (judges interpret intent) |
| Audit cost | One-time, upfront | Recurring during disputes |
| Failure mode | Funds frozen or stolen | Slow litigation |
The honest read: smart contracts beat traditional contracts on speed and cost, and lose on flexibility and recourse. For predictable, repeatable operations (a token swap, a yield-farm deposit, a payroll stream), they are excellent. For anything that needs human judgment ("did the supplier deliver in good faith?"), they are useless. Every project pretending otherwise is selling you a future lawsuit dressed up as a vision deck.
Where smart contracts actually run today
Smart contracts launched on Ethereum in 2015 and most of the dollar value still lives there. According to DefiLlama's Ethereum chain page, Ethereum smart contracts currently hold $43.09 billion in total value locked (TVL) across DeFi protocols on 2026-05-24. Across all chains, DefiLlama's aggregate dashboard puts global DeFi TVL at $82.31 billion. Ethereum, on its own, therefore still hosts more than half of the entire smart-contract economy by value.
Other chains run their own variants. BNB Chain holds $5.60 billion in TVL on the same day, with a +1.01% move over the past seven days. BNB Chain uses the same EVM tooling, which means a Solidity contract written for Ethereum runs on BNB Chain with minor tweaks. Solana uses a different runtime ("programs", not "contracts") and a different language (Rust mostly). Avalanche, Polygon, Arbitrum, Base, Optimism: all EVM-compatible, all running the same kind of bytecode underneath.
Why does this matter for a beginner? Because picking a chain is picking a smart-contract environment. Ethereum has the deepest tooling and the highest gas fees. BNB Chain has cheap transactions and a memecoin-heavy ecosystem. Solana has speed and a different mental model. The contract logic translates between EVM chains; the user experience does not.
For wider context, ETH's market cap sits at $255.59 billion on 2026-05-24. A non-trivial slice of that valuation is the implicit assumption that Ethereum will keep being the default smart-contract platform. That assumption is a thesis, not a fact. The numbers move. Boring is the feature, until it isn't.
What can go wrong with smart contracts (and usually does)
Smart contracts fail in three flavors, and every story in ten years of DeFi exploits maps to one of them.
1. Code bugs. A logic error in the contract lets attackers withdraw more than they deposited, or call a function in an unintended sequence. Reentrancy, integer overflows, missing access controls. The Ethereum.org security docs catalog the classics. An audit reduces the risk but does not erase it. Reading audit reports before you deposit is a habit, not a luxury, which is why we wrote a guide to reading smart contract audit reports.
2. Economic design flaws. The code does exactly what it was written to do, and the result is still a loss. Liquidity pool depositors get squeezed by impermanent loss when prices diverge. Lending markets get drained by flash-loan price manipulation. Stablecoin pegs break under correlated redemption pressure. The code is "correct"; the design is not. The numbers say yes. The panda raises an eyebrow.
3. Centralization back doors. The developer kept an admin key. The admin key got phished, leaked, or rug-pulled by the developer themselves. "Decentralized" turns out to mean "one externally owned address holds the upgrade key". Always check who can change the contract. Always check whether the upgrade path is timelocked. Always assume the worst until proven otherwise.
What to watch next: AI agents now interact with smart contracts autonomously, signing transactions on behalf of users, which adds a fourth failure mode (the agent itself misjudges the call). That is the topic we track in the AI agents and on-chain automation cluster. For projects on BNB Chain, including Dadacoin, the BSC ecosystem is where most of the day-to-day smart-contract activity sits. Different chain, same fundamental mechanics. Same advice: read the code, or trust someone who has.
