A sequential number that prevents replay attacks and ensures transaction order from a single account. It increments by one with each transaction sent from that address.

• Function: If nonce N is pending, transaction N+1 cannot be processed.
• Network State: The current nonce for an address is stored in the network's state trie.
• Example: Your first transaction has nonce 0, the next is 1. This ordering is critical for state consistency.

The value field specifies the amount of native currency (e.g., ETH, MATIC) to transfer, denominated in wei. The data field (often input on Ethereum) is optional and carries encoded information.

• Data Payloads: Used for smart contract function calls (ABI-encoded) or adding memos.
• Contract Interaction: A to address plus data triggers a contract function.
• Simple Transfer: data field is empty (0x).

The cryptographic proof that the owner of the from address authorized the transaction. Generated using the Elliptic Curve Digital Signature Algorithm (ECDSA) with the sender's private key.

• Components: The signature is split into three values: v (recovery id), r, and s.
• Verification: Nodes recover the public key from the signature and hash to derive the sender's address.
• Security: Any alteration to the transaction data invalidates the signature.

A user initiates a transaction using a wallet, specifying the recipient, amount, and gas parameters. The wallet cryptographically signs the transaction with the user's private key, creating a unique digital signature. This proves ownership and authorizes the transfer without revealing the private key.

• Key Inputs: Nonce, gas limit, max fee per gas (EIP-1559), recipient address, value.
• Example: Sending 1 ETH from a MetaMask wallet to a new address.

The signed transaction is broadcast to the network's peer-to-peer nodes. It enters a waiting area called the mempool (memory pool). Nodes validate the transaction's basic structure and signature. Transactions compete for inclusion based on gas fees.

• Mempool State: A dynamic, unconfirmed transaction pool.
• Front-running Risk: High-fee transactions can be prioritized, a concern for DeFi users.

A validator or miner selects transactions from the mempool and assembles them into a candidate block. The block includes a cryptographic hash of the previous block, linking the chain. Network nodes then perform state validation, checking every transaction against the current blockchain state (e.g., sufficient balance, correct nonce).

The network reaches agreement on the valid block. Mechanisms differ:

• Proof of Work (Bitcoin, Ethereum pre-Merge): Miners solve a cryptographic puzzle.
• Proof of Stake (Ethereum, Solana): Validators stake ETH to propose and attest to blocks.

Finality is the point where a transaction is irreversible. Probabilistic finality (Bitcoin) requires multiple confirmations. Ethereum PoS offers single-slot finality after checkpoints.

Once finalized, the block's transactions execute, updating the global state trie. Balances change, smart contract code runs, and events are emitted. A transaction receipt is generated, containing critical data:

• Status: Success (1) or failure (0).
• Gas Used: Actual computational units consumed.
• Logs: Events emitted by smart contracts.
• Block Hash & Number: Proof of inclusion.

Gas is the unit that measures the computational work required to execute a transaction or smart contract on a blockchain. Every operation (adding numbers, storing data) has a predefined gas cost. The total fee is calculated as:

Gas Fee = Gas Units Used * Gas Price

• Gas Units (Limit): The maximum amount of work you allow. A failed transaction still consumes gas up to this limit.
• Gas Price: The amount of native token (e.g., ETH, MATIC) you pay per unit of gas, often denoted in Gwei (1 Gwei = 0.000000001 ETH).

Blockchains like Ethereum use a fee market where users bid for block space. Miners or validators prioritize transactions with higher gas prices.

• Base Fee: A network-calculated minimum price per gas that is burned (EIP-1559).
• Priority Fee (Tip): An extra incentive paid to the block producer for faster inclusion.

Your total fee is: (Base Fee + Priority Fee) * Gas Units. During network congestion, the base fee rises, increasing costs for all users.

Not all chains use Ethereum's model. Fees vary significantly by architecture.

• Solana: Uses a prioritization fee in lamports, with fees typically under $0.01.
• Avalanche C-Chain: Uses a gas price similar to Ethereum but is often cheaper.
• Polygon PoS: Uses MATIC for gas, with fees often a fraction of a cent.
• Layer 2s (Optimism, Arbitrum): Post transactions in batches to Ethereum, splitting the cost. Users pay a small L2 execution fee plus a share of the L1 data posting fee.

You can estimate and reduce gas costs before submitting a transaction.

• Use Gas Estimation Tools: Wallets (MetaMask) and block explorers (Etherscan) provide real-time estimates.
• Check Gas Tracker: Sites like GasNow or Blocknative show current network fees.
• Optimize Smart Contracts: Use efficient code patterns to reduce gas units. For example, storing data in packed uint variables or using events instead of storage for logs.
• Time Your Transactions: Submit during off-peak hours (e.g., weekends, UTC night) when base fees are lower.

Failed transactions often result from gas misconfiguration.

• Out of Gas: Transaction ran out of gas units before completion. Increase your gas limit.
• Gas Price Too Low: Transaction is stuck in the mempool. You can replace it with a higher gas price.
• Revert: The transaction logic failed (e.g., insufficient funds), but you still pay for gas used up to the point of failure.
• Insufficient Funds for Gas: Your wallet balance must cover gas limit * gas price, even if the transaction fails.

New standards aim to simplify the user experience with gas fees.

• ERC-4337 (Account Abstraction): Allows sponsored transactions where a dapp or payer covers the gas fee.
• Gasless Transactions: Protocols like Gelato enable meta-transactions, where a relayer pays the fee.
• Fixed Fee Models: Some chains (e.g., Algorand) use a fixed, minimal fee (0.001 ALGO) per transaction, independent of complexity.
• EIP-4844 (Proto-Danksharding): Aims to drastically reduce L2 data posting costs to Ethereum by introducing blobs.