Smart Contract Execution

A smart contract is not a background server that runs continuously. Code executes when the protocol processes a transaction or call that invokes it. The virtual machine loads the code, exposes defined blockchain context, executes instructions, charges resource usage, and commits resulting state changes if execution succeeds.

The contract cannot arbitrarily access a user's computer or the public internet. It operates inside the deterministic execution environment provided by the chain.

A user signs a transaction specifying a destination contract, input data, value if any, and fee parameters. Nodes authenticate the sender and execute the contract entry point. The contract can read storage, perform arithmetic, emit logs, transfer assets, and call other contracts. If execution completes successfully, the resulting writes become part of the new blockchain state.

If execution reverts, specified writes are rolled back while protocol fees can still be consumed.

Every node repeats contract execution, so unbounded computation would let one transaction monopolize the network. Ethereum meters operations in gas; Solana assigns compute-unit limits and account-access constraints. The sender supplies or pays for finite execution capacity.

Resource metering converts computation into a scarce protocol resource and protects validators from infinite loops or deliberately expensive programs.

A DeFi swap can call a router, liquidity pool, token contracts, an oracle, and a fee module within one atomic transaction. Each call adds state dependencies and potential failure points. Atomicity means either the required execution path succeeds under the protocol's rules or the transaction's targeted state changes can revert together.

Composability is powerful because protocols become reusable building blocks, but a bug in one dependency can propagate into others.

Reentrancy, incorrect authorization, integer or precision mistakes, oracle manipulation, unsafe upgrade controls, and unexpected token behavior can convert software defects into irreversible asset loss. Audits reduce risk but do not prove absence of bugs.

Security analysis should trace every state write, external call, privilege, and assumption about caller-controlled input.

Smart-contract execution turns a blockchain into a replicated program environment. A transaction invokes code, the virtual machine reads protocol-managed state, performs deterministic operations, may call other contracts, and produces a new state if execution succeeds. Every validating node must be able to reproduce the same outcome from the same starting state and inputs.

Resource metering is essential because arbitrary programs can consume CPU, memory, or storage. Gas, compute units, or related mechanisms place a price and limit on execution so one transaction cannot demand unbounded resources from every validator. The resource model also affects application design: storage writes may cost more than arithmetic, and loops over growing on-chain data can become impractical.

Composability creates both power and risk. One contract can call another, allowing protocols to combine tokens, exchanges, lending systems, or identity components. But the caller then inherits assumptions about the callee. Reentrancy, unexpected external state changes, upgradeable dependencies, and oracle inputs can create failure paths that are not visible when reading one contract in isolation.

Determinism also limits what a contract can directly know. External facts such as market prices or weather generally require an oracle or signed data feed. The chain can deterministically process the supplied data, but it cannot independently guarantee that an off-chain statement was true.

1. Why must smart-contract execution be deterministic?

2. What problem do gas or compute-unit limits solve?

3. Explain how contract-to-contract calls create composability and dependency risk.

4. Why can a smart contract not directly read an arbitrary web page during deterministic consensus execution?

5. Distinguish a program bug from bad oracle data.

6. Correct this statement: “Smart contracts execute only once on the machine that created the block.”