Short, precise definitions for the terms used across this site. Hover any underlined word in the text to see the same entry inline.
A ledger that tracks mutable balances per address. Used by Ethereum, Polkadot, Algorand.
In the account model the global state is a mapping of address → balance. Transactions mutate sender and receiver balances directly. This makes contract programming feel familiar but introduces shared mutable state and contention.
On Ethereum a token transfer subtracts from one account’s balance and adds to another’s, mutating shared state.
The native currency of Cardano, named after Ada Lovelace.
Ada is the unit users see; it is the fee currency, the staking currency, and the default value carried in every UTxO. Behind the scenes the protocol works in lovelace, the smallest indivisible unit (1 ada = 1,000,000 lovelace).
Sending "10 ada" to a friend is actually moving 10,000,000 lovelace on the ledger.
The destination encoded into a UTxO. May be a public-key address or a script address.
Your house number on Cardano. UTxOs are deliveries waiting at the door until you spend them.
A Cardano address combines a payment credential (a BLAKE2b-224 hash of either a public key or a script) with an optional staking credential (also a key hash or script hash). UTxOs sitting at a script address can only be spent if the script (validator) permits.
A typical mainnet address starts with "addr1…" and embeds the hash of your spending key plus the hash of your staking key, never the keys themselves.
An ordered batch of transactions appended to the chain by the slot leader.
A block contains transactions, a header referencing the previous block, and consensus metadata. On Cardano, slots elect a leader who has the right to produce the next block.
Roughly every 20 seconds on average, a stake pool produces a new block of pending transactions.
An append-only sequence of blocks, each linking to the previous one by hash.
A blockchain is a data structure that orders transactions over time: each block contains a header that includes the hash of the previous block, so any tampering would break every following hash. Cardano’s chain is produced by Ouroboros consensus.
When you "wait for a confirmation", you’re waiting for the blockchain to grow a few blocks past the one containing your transaction.
A new UTxO that returns the leftover value to the spender after a transaction.
Change at the till. Hand over a 50 to pay for a 20, get back two new notes (a 20 for the seller, the rest as change) rather than a modified 50.
Because a UTxO is consumed in full, any value beyond the target plus fee is returned to the spender as a new "change" UTxO. The change output is part of transaction construction, not optional.
Paying 3 ada from a 10 ada UTxO yields a 3 ada output to the recipient and a roughly 6.83 ada change output back to you (after fees).
The wallet’s job of picking which UTxOs to spend for a given target amount.
Like making change at the till: hand over one 20 or four 5s for the same 20 purchase. Each choice has knock-on effects on fees, privacy, and wallet hygiene.
Because a UTxO must be spent in full, wallets need an algorithm to pick a set of UTxOs that covers a target amount. Strategies trade off transaction size, fee, change output, dust accumulation, and privacy. CIP-2 documents the strategies used in the Cardano ecosystem.
To send 12 ada, a wallet may pick a 10 ada and a 5 ada UTxO (total 15) rather than one 100 ada UTxO, to keep change small.
A reserved input the network burns if a Plutus script fails on-chain.
A small deposit the network keeps if your script throws an error on-chain. Like a no-show fee that only fires when something actually goes wrong.
Plutus transactions declare a collateral input (a key-locked, pure-ada UTxO worth at least 150% of the fee, the `collateralPercentage` protocol parameter). Phase-1 checks (signatures, fees, balance) happen off-chain; phase-2 runs the scripts. If a script unexpectedly fails in phase-2, the transaction is still added to the chain so the network is paid for the work, and collateral is forfeited. Since Plutus V2 (Babbage), a transaction can also declare a `collateralReturn` output, so only the required amount is burned and the rest comes back, you don't lose the whole input UTxO.
If a swap script fails because the price moved, the user loses just the collateral (a few ada), not the funds they wanted to swap.
Multiple transactions making progress at the same time. On eUTxO, possible whenever the transactions don't touch the same UTxO.
Two separate supermarket checkout lanes serving customers at the same time because they're independent. eUTxO is full of independent lanes; only people fighting over the same box (UTxO) have to queue.
Concurrency on Cardano is granted by the UTxO model itself: two transactions that consume different UTxOs are independent and can be validated and ordered freely within the same block. Concurrency falls apart wherever many users want to read or update the same UTxO at once, that's contention, and it's why DEXes use batchers and oracles use reference inputs.
Ten users each send ada from their own wallets to ten different recipients, all ten transactions are concurrent. Ten users trying to swap against the same DEX pool UTxO are not.
A small group that checks whether each governance action complies with the constitution.
The Constitutional Committee (CC) is a fixed-size group of members elected via governance actions. For most action types, CC approval is required in addition to DRep and (sometimes) SPO approval. The CC may not propose changes; it only blocks ones that violate the constitution.
A treasury withdrawal proposal needs both a DRep majority and a Constitutional Committee approval to take effect.
When multiple parties want to spend the same UTxO, only one can win per pool-state transition. The rest must wait for the new UTxO.
A single popular ATM. Only one person can use it at a time. The fix is either more ATMs (fragmentation) or a queue manager (batchers).
Because a UTxO is consumed in full and only once, any shared-state contract whose state lives in a single UTxO becomes a contention point: every state change produces a brand-new UTxO that the next user has to spend. Solutions: batchers that aggregate user requests off-chain into one tx, pool fragmentation (many small pools), reference inputs for read-only data, or contract designs that avoid global state altogether.
A new AMM pool starts as one UTxO holding all liquidity. Without a batcher, only one swap per block can succeed; the rest fail or wait.
Custom data attached to an eUTxO. Acts as the “state” of a smart contract output.
Memory attached to a box. The box knows what it is for; the validator can read that memory before deciding to unlock.
A Datum is arbitrary data stored alongside a UTxO at a script address. When the UTxO is consumed, the validator sees the Datum and uses it together with the Redeemer and Script Context to decide whether to permit the spend. Think of it as a note pinned to a banknote that says what it is for.
A vesting UTxO’s Datum may be { beneficiary: "addr1...alice", unlockSlot: 90000000 } so the validator can later check whether Alice is claiming it after the unlock time.
Pointing your stake at a specific stake pool so it can produce blocks on your behalf.
Delegating does not move your ada anywhere; it only declares which stake pool may count your balance toward its block production chances. Delegation is registered with a certificate signed by your staking key and stays in effect until you change it.
You publish a delegation certificate naming pool TICKER; two epoch boundaries later your ada starts strengthening that pool's block-production odds, and rewards land roughly four epochs after the certificate.
A spend either succeeds for every observer or fails for every observer, with no global-state surprises.
Like calculating a chess move on paper before playing it. The board does not change while you think; the move plays out exactly as you computed.
Because eUTxO validators see only the transaction at hand, the outcome of submitting a transaction can be computed in advance. With honest pre-validation, transactions never fail on-chain unexpectedly. If a Plutus script does fail in phase-2 validation, only the dedicated collateral input is consumed, not the full transaction value. Compared to account-model chains where contracts can fail mid-execution and burn the full gas budget, this is a clear safety win.
Because the validator only sees the transaction itself, a Cardano dApp can simulate your DEX swap locally and predict whether it will succeed before you submit it.
A Delegated Representative who casts votes on governance actions on behalf of ada holders.
Your voting proxy. They cast votes on protocol changes, weighted by all the ada delegated to them.
Under CIP-1694, ada holders can delegate their voting power to a DRep, register as one themselves, or pick a pre-defined option ("abstain" or "no confidence"). DReps vote on governance actions; their voting power equals the total stake delegated to them.
You delegate your vote to DRep "alice"; whenever a governance action is open, Alice’s recorded vote is weighted by your stake plus all her other delegators.
A UTxO so small it costs more in fees to spend than it is worth.
Pocket lint. Coins so small it would cost more in fees to pick them up than they're worth, so they just sit there.
Dust UTxOs accumulate when coin selection strategies leave behind tiny outputs. They fragment the wallet, hurt privacy, and may be uneconomic to ever spend on their own. On Cardano every UTxO must satisfy the protocol's minUTxO rule (typically around 1 ada for a plain-ada output, more for outputs carrying native assets, the exact amount depends on the serialized size and `coinsPerUtxoByte`), so "dust" here means outputs that sit close to that floor rather than fractions of an ada.
A 1 ada UTxO is effectively dust if it would cost roughly 0.18 ada to include in a transaction and leaves no useful change behind.
A five-day window on Cardano during which staking distribution is fixed.
A five-day pay cycle. Stake snapshots and rewards land on epoch boundaries, never mid-cycle.
Cardano time is grouped into epochs of 432,000 slots (five days). The staking distribution is snapshotted between epochs, rewards earned in one epoch are paid out two epochs later, and many protocol parameters can only change at epoch boundaries.
You delegate in epoch 500; the snapshot is taken at the end of that epoch, your stake counts toward the pool starting in epoch 502, and the first rewards from blocks it produced with your stake are paid out at the start of epoch 504.
Extended UTxO. Cardano’s ledger model: a UTxO can carry datum and be locked by a script, enabling smart contracts on a UTxO chain.
Classic UTxO + a tag and a bouncer. The tag (datum) says what it's for; the bouncer (validator) checks what you present (redeemer) before opening it.
Extended UTxO (eUTxO) is the model formalised by Chakravarty et al. (2020) and adopted by Cardano. It augments classical UTxOs with a Datum (state attached to the output) and a Validator script (a function that decides whether the output may be spent). Smart contracts gain expressivity while keeping the local-reasoning benefits of UTxO.
A vesting contract is just a UTxO at a script address with a datum like { beneficiary: alice, unlocksAt: 1000 }; a transaction can only spend it when the validator agrees.
A pricing regime where users bid for inclusion. Higher fees mean faster confirmation.
An auction for blockspace. Higher tip means faster confirmation. Cardano deliberately avoids this so the same transaction always costs the same.
A fee market emerges when blockspace is scarce and fees are user-chosen. Bitcoin and most UTxO chains operate this way. Wallets estimate the going rate, sophisticated users pay tips, and low-fee transactions can sit in the mempool for hours when the chain is busy. Cardano deliberately avoids a fee market: the minimum fee is computed as a·size + b with protocol-set constants, and Plutus transactions add a fixed cost for their declared execution units, so two identical transactions always cost the same.
During a Bitcoin congestion spike, a 200-byte transfer may pay 50,000 sat to confirm in the next block while another waits a day for 1,000 sat.
A formal on-chain proposal that, if ratified, changes protocol parameters, the constitution, or the treasury.
CIP-1694 defines several types of governance action: motion of no confidence, update to the Constitutional Committee, new constitution, hard-fork initiation, protocol-parameter update, treasury withdrawal, and a generic "info" action. Each requires a deposit, has a voting window, and a specific approval threshold from DReps, SPOs, and the Constitutional Committee.
A treasury withdrawal of 100,000 ada to fund a public good is filed as a governance action, voted on by DReps and the Constitutional Committee (SPOs do not vote on treasury withdrawals), and only paid out once both reach their thresholds.
A short, fixed-size fingerprint of arbitrary data that changes drastically with any input change.
A digital fingerprint. Tiny change to the data, completely different fingerprint. Easy to compute one way, impossible to reverse.
Blockchains use cryptographic hashes (BLAKE2b on Cardano) to identify transactions, blocks, scripts, and datums. A hash is computed deterministically from its input; changing a single byte produces a completely different hash, which is what lets a chain detect tampering.
A transaction’s hash like "a1b2…e3f4" uniquely identifies it on the chain; you can look it up in any explorer.
A hierarchical deterministic wallet that derives many keys from a single seed.
One seed, many addresses. The wallet keeps deriving fresh ones so observers can't trace all your spending back to a single source.
An HD (Hierarchical Deterministic) wallet uses a tree-like derivation path so a single seed phrase produces every key the wallet will ever need. On Cardano the path is m / 1852′ / 1815′ / account′ / role / index, where role 0 is external receive, 1 is internal change, and 2 is the staking key.
Lace can show you "Address 1", "Address 2", "Address 3" … each comes from a different leaf of the same HD tree rooted in your seed phrase.
A datum stored directly inside the UTxO it belongs to, instead of as a hash that the spender has to resolve.
The note pinned to the box is now glued to the lid, not folded in someone's wallet. Anyone who finds the box can read it directly.
Before Plutus V2 (Babbage hard fork, 2022), a UTxO at a script address only stored the hash of its datum, the spender had to provide the actual datum bytes in the witness set, matching the hash. CIP-32 added inline datums: the full datum value can be stored on-chain in the output itself, removing the off-chain round-trip and making concurrent UTxO consumption easier.
A DEX pool stores its current reserves as an inline datum on the pool UTxO. Anyone can read it without having to fetch the matching datum from somewhere else.
The smallest unit of ada. 1 ada = 1,000,000 lovelace.
The ledger stores all amounts in lovelace integers, never in fractional ada. Wallets convert to ada for display; protocol parameters like the minimum-fee constants and the per-byte UTxO cost are expressed in lovelace.
The minUTxO rule is encoded as the protocol parameter coinsPerUtxoByte (currently 4,310 lovelace per byte), so a plain-ada UTxO typically needs around 1,000,000 lovelace (~1 ada) and a UTxO carrying tokens needs proportionally more.
A node-local pool of pending transactions waiting to be included in a block.
The queue at the airport gate. Transactions sit there until the next slot leader (block producer) calls them up.
Submitted transactions sit in the mempool until a block producer picks them up. On fee-market chains (Bitcoin, Litecoin, etc.) higher fees move a transaction up the queue. On Cardano the minimum fee is deterministic (min_fee = a·size + b), with Plutus transactions paying additional execution-unit costs for declared memory and CPU steps; either way there is no bidding and no fee market. On eUTxO chains, transactions only conflict if they spend the same UTxO, so independent transactions can be included in parallel without ordering constraints.
During a busy moment your transaction may sit in the mempool for a few slots before the next elected block producer picks it up.