Glossary

Smart contract glossary: every term explained

Plain-English definitions of 46 smart contract, Solidity, EVM, and Monad terms, from ABI and gas to reentrancy and parallel execution. Each term links to a guide and to the Monsmith IDE where you can see it in practice.

Maintained by Adwait Keshari.

A

ABI (Application Binary Interface): The ABI is the JSON description of a contract's functions, inputs, outputs, and events that wallets and applications use to encode calls and decode results.
Access control: Access control is the set of rules deciding which addresses may call which functions, typically enforced with modifiers such as onlyOwner or role-based checks.

B

Block: A block is a batch of ordered transactions added to the chain at once; Monad produces one every 300 milliseconds.
Bytecode: Bytecode is the compiled, machine-level form of a smart contract that the EVM actually executes; Solidity source is compiled into it before deployment.

C

Checks-effects-interactions: Checks-effects-interactions is the Solidity pattern of validating inputs first, updating your own state second, and calling external contracts last, which neutralises reentrancy.
Constructor: A constructor is the function that runs exactly once, during deployment, to set a contract's initial state such as its owner, name, or supply.

D

Dependency graph: A dependency graph is a diagram of which contract functions depend on the same storage, showing which calls must run in sequence and which can run in parallel.
Deployment: Deployment is the transaction that publishes a contract's bytecode to the blockchain, creating a new address where the contract lives from then on.

E

ERC-1155: ERC-1155 is a multi-token standard where one contract manages many token types, fungible and non-fungible, with batch transfers that save gas.
ERC-20: ERC-20 is the standard interface for fungible tokens on EVM chains, defining functions such as transfer, approve, and balanceOf so every wallet and exchange can handle any token the same way.
ERC-721: ERC-721 is the standard for non-fungible tokens (NFTs) on EVM chains, where every token has a unique ID and can carry its own metadata.
Event: An event is a log entry a contract emits during execution; it is cheap to write, cannot be read by contracts, and is how off-chain applications learn what happened.
EVM (Ethereum Virtual Machine): The EVM is the runtime that executes smart contract bytecode on Ethereum and every EVM-compatible chain, defining opcodes, gas costs, and the rules of state changes.

F

Fallback and receive functions: The receive function runs when a contract is sent plain native tokens with no data; the fallback function runs when a call matches no other function.
Faucet: A faucet is a service that gives out free testnet tokens so developers can pay for test transactions; Monad's is at faucet.monad.xyz.
Finality: Finality is the point after which a transaction is guaranteed to stay in the chain and cannot be reorganised away; on Monad it arrives about 600 milliseconds after submission.
Function selector: A function selector is the first four bytes of the keccak-256 hash of a function's signature, used at the start of calldata to tell the contract which function to run.

G

Gas: Gas is the unit that measures computational work on an EVM chain; every opcode costs a set amount of gas, and users pay gas multiplied by the gas price to have a transaction executed.
Gas limit: The gas limit is the maximum amount of gas a transaction is allowed to consume; if execution needs more, the transaction reverts and the gas is still spent.
Gas price: The gas price is the amount of native token a transaction pays per unit of gas, usually quoted in gwei (one billionth of a token).

I

IDE (integrated development environment): An IDE is a single application that combines a code editor, compiler, debugger, and deployment tools; for smart contracts, a browser IDE such as Monsmith or Remix removes local setup entirely.

L

Layer 1: A Layer 1 is a base blockchain that reaches consensus and settles transactions on its own, without relying on another chain; Ethereum and Monad are Layer 1s, while rollups are Layer 2s.

M

Mainnet: Mainnet is the production blockchain where tokens carry real value and deployed contracts serve real users; Monad mainnet is chain ID 143.
Modifier: A modifier is a reusable Solidity construct that wraps a function with pre- or post-conditions, such as checking that the caller is the owner before the body runs.
MON token: MON is the native token of the Monad blockchain, used to pay gas fees and secure the network through staking.
Monad: Monad is a high-performance, EVM-compatible Layer 1 blockchain that uses optimistic parallel execution and the MonadBFT consensus to reach 300 ms blocks, 600 ms finality, and a 10,000 transactions-per-second design target.
Monad testnet: Monad testnet is the public test network for Monad, chain ID 10143, where developers deploy and try contracts with free test MON before going to mainnet.
MonadBFT: MonadBFT is Monad's pipelined Byzantine fault tolerant consensus protocol, responsible for ordering blocks quickly and finalising them within about 600 milliseconds.

N

NFT (non-fungible token): An NFT is a blockchain token with a unique identifier that represents ownership of one specific item, digital or physical, rather than an interchangeable unit of value.

O

Opcode: An opcode is a single low-level instruction the EVM understands, such as ADD, SLOAD (read storage), SSTORE (write storage), or CALL, each with a defined gas cost.
OpenZeppelin Contracts: OpenZeppelin Contracts is the most widely audited open-source library of reusable Solidity components, including ERC-20, ERC-721, Ownable, AccessControl, and ReentrancyGuard.
Optimistic parallel execution: Optimistic parallel execution runs transactions concurrently on the assumption they do not conflict, then detects and re-runs any transaction that read state another transaction in the same block changed.

P

Parallel EVM: A parallel EVM executes many transactions at the same time on multiple CPU cores instead of one after another, while still producing the same final state as sequential execution.
Private key: A private key is the secret number that controls an address; whoever holds it can sign transactions and move its funds, so it must never appear in source code or a browser tab.

R

Reentrancy: Reentrancy is a vulnerability where an external call lets an attacker's contract call back into your function before its state updates finish, often draining funds.
Revert: A revert is when a transaction fails a check and the EVM undoes every state change it made, while still charging for the gas consumed up to that point.
RPC endpoint: An RPC endpoint is the URL a wallet or application uses to talk to a blockchain node, sending JSON-RPC requests such as eth_sendRawTransaction and eth_call.

S

Smart contract: A smart contract is a program stored on a blockchain that runs exactly as written whenever someone sends it a transaction, with no company or server in the middle.
Smart contract audit: A smart contract audit is a systematic review of contract code for security vulnerabilities, logic errors, and gas inefficiencies before the code is deployed and becomes immutable.
Solidity: Solidity is the most widely used programming language for writing smart contracts on Ethereum and other EVM-compatible blockchains, including Monad.
Static analysis: Static analysis inspects source code or bytecode without running it, flagging patterns known to be dangerous such as unchecked external calls, integer issues, or missing access control.
Storage slot: A storage slot is one of the 2^256 32-byte cells that make up a contract's persistent storage; every state variable and mapping entry lives in a specific slot.

T

Testnet: A testnet is a blockchain network that mirrors mainnet behaviour but uses valueless tokens, so developers can deploy and test contracts for free.
TPS (transactions per second): TPS measures how many transactions a blockchain can process per second; Monad is designed for 10,000 TPS, compared with roughly 15 to 30 on Ethereum mainnet.

U

Upgradeable contract (proxy): An upgradeable contract uses a proxy that delegates calls to a separate implementation contract, so the logic can be replaced while the address and storage stay the same.

W

Wallet: A wallet is software that holds private keys and signs transactions on the user's behalf; MetaMask, Rabby, and Phantom all work with Monad.